royale-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From alinak...@apache.org
Subject [royale-asjs] branch feature/MXRoyale updated: Log.as Added
Date Fri, 27 Apr 2018 06:22:33 GMT
This is an automated email from the ASF dual-hosted git repository.

alinakazi pushed a commit to branch feature/MXRoyale
in repository https://gitbox.apache.org/repos/asf/royale-asjs.git


The following commit(s) were added to refs/heads/feature/MXRoyale by this push:
     new 0d7394b  Log.as Added
0d7394b is described below

commit 0d7394b153f11b50b73b9c955a60e0c6117d2f0c
Author: alinakazi <ALINAKAZI1990@GMAIL.COM>
AuthorDate: Fri Apr 27 11:22:31 2018 +0500

    Log.as Added
---
 .../MXRoyale/src/main/royale/mx/logging/Log.as     | 493 +++++++++++++++++++++
 1 file changed, 493 insertions(+)

diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/logging/Log.as b/frameworks/projects/MXRoyale/src/main/royale/mx/logging/Log.as
new file mode 100644
index 0000000..c3fcd34
--- /dev/null
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/logging/Log.as
@@ -0,0 +1,493 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Licensed to the Apache Software Foundation (ASF) under one or more
+//  contributor license agreements.  See the NOTICE file distributed with
+//  this work for additional information regarding copyright ownership.
+//  The ASF licenses this file to You under the Apache License, Version 2.0
+//  (the "License"); you may not use this file except in compliance with
+//  the License.  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package mx.logging
+{
+/* 
+import mx.logging.errors.InvalidCategoryError;
+import mx.managers.ISystemManager;
+import mx.managers.SystemManager;
+import mx.resources.IResourceManager;
+import mx.resources.ResourceManager; */
+//[ResourceBundle("logging")]
+
+/**
+ *  Provides pseudo-hierarchical logging capabilities with multiple format and
+ *  output options.
+ *  The log system consists of two major components, the logger and a target.
+ *  You can use the logger to send information to a target.
+ *  The target is responsible for formatting and general output of the log data.
+ *  <p>
+ *  Loggers are singleton instances created for a particular category of
+ *  information.
+ *  Typically, the category is the package name of the component
+ *  that desires to log information.
+ *  The category provides users the ability to specify what log information they
+ *  are interested in.
+ *  Multiple categories can be selected and combined with regular expressions.
+ *  This allows for both broad and narrow logging information to be acquired.
+ *  For example, you might be interested in all logging information under
+ *  the "mx.messaging" and "mx.rpc" packages and want the output from these
+ *  packages to be formatted as XML.
+ *  To get the all of the logging information under the "mx.messaging" category
+ *  including sub-packages and components a wildcard expression is required, such as
+ *  "mx.messaging.~~".
+ *  See the code example below for more details.
+ *  </p>
+ *  <p>Targets provide the output mechanism of the data being logged.
+ *  This mechanism typically includes formatting, transmission, or storage, but
+ *  can be anything possible under the VM.
+ *  There are two targets provided: <code>MiniDebugTarget</code> and 
+ *  <code>TraceTarget</code>.
+ *  Each of these writers take the current log information and "sends" it
+ *  somewhere for display and/or storage.
+ *  Targets also provide the specification of what log data to output.
+ *  </p>
+ *
+ *  @example
+ *  <pre>
+ *  ... 
+ *  import mx.logging.targets.*;
+ *  import mx.logging.*;
+ *
+ *  private function initLogging():void {
+ *      // Create a target.
+ *      var logTarget:TraceTarget = new TraceTarget();
+ *
+ *      // Log only messages for the classes in the mx.rpc.* and 
+ *      // mx.messaging packages.
+ *      logTarget.filters=["mx.rpc.*","mx.messaging.*"];
+ *
+ *      // Log all log levels.
+ *      logTarget.level = LogEventLevel.ALL;
+ *
+ *      // Add date, time, category, and log level to the output.
+ *      logTarget.includeDate = true;
+ *      logTarget.includeTime = true;
+ *      logTarget.includeCategory = true;
+ *      logTarget.includeLevel = true;
+ *
+ *      // Begin logging.
+ *      Log.addTarget(logTarget);
+ *  } 
+ *  ...
+ *  </pre>
+ *  
+ *  @langversion 3.0
+ *  @playerversion Flash 9
+ *  @playerversion AIR 1.1
+ *  @productversion Royale 0.9.3
+ */
+public class Log
+{
+   // include "../core/Version.as";
+
+    //--------------------------------------------------------------------------
+    //
+    //  Class variables
+    //
+    //--------------------------------------------------------------------------
+
+    /**
+     *  @private
+     *  Sentinal value for the target log level to indicate no logging.
+     */
+   // private static var NONE:int = int.MAX_VALUE;
+
+    /**
+     *  @private
+     *  The most verbose supported log level among registered targets.
+     */
+  //  private static var _targetLevel:int = NONE;
+        // Initialize target level to a value out of range.
+
+    /**
+     *  @private
+     *  An associative Array of existing loggers keyed by category
+     */
+    private static var _loggers:Array;
+
+    /**
+     *  @private
+     *  Array of targets that should be searched any time
+     *  a new logger is created.
+     */
+   // private static var _targets:Array = [];
+
+	/**
+	 *  @private
+	 *  Storage for the resourceManager getter.
+	 *  This gets initialized on first access,
+	 *  not at static initialization time, in order to ensure
+	 *  that the Singleton registry has already been initialized.
+	 */
+	//private static var _resourceManager:IResourceManager;
+	
+	/**
+	 *  @private
+     *  A reference to the object which manages
+     *  all of the application's localized resources.
+     *  This is a singleton instance which implements
+     *  the IResourceManager interface.
+	 */
+	/* private static function get resourceManager():IResourceManager
+	{
+		if (!_resourceManager)
+			_resourceManager = ResourceManager.getInstance();
+
+		return _resourceManager;
+	} */
+
+    //--------------------------------------------------------------------------
+    //
+    //  Class methods
+    //
+    //--------------------------------------------------------------------------
+
+    /**
+     *  Indicates whether a fatal level log event will be processed by a
+     *  log target.
+     *
+     *  @return true if a fatal level log event will be logged; otherwise false.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Royale 0.9.3
+     */
+   /*  public static function isFatal():Boolean
+    {
+        return (_targetLevel <= LogEventLevel.FATAL) ? true : false;
+    } */
+    
+    /**
+     *  Indicates whether an error level log event will be processed by a
+     *  log target.
+     *
+     *  @return true if an error level log event will be logged; otherwise false.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Royale 0.9.3
+     */
+   /*  public static function isError():Boolean
+    {
+        return (_targetLevel <= LogEventLevel.ERROR) ? true : false;
+    } */
+    
+    /**
+     *  Indicates whether a warn level log event will be processed by a
+     *  log target.
+     *
+     *  @return true if a warn level log event will be logged; otherwise false.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Royale 0.9.3
+     */
+    /* public static function isWarn():Boolean
+    {
+        return (_targetLevel <= LogEventLevel.WARN) ? true : false;
+    } */
+
+    /**
+     *  Indicates whether an info level log event will be processed by a
+     *  log target.
+     *
+     *  @return true if an info level log event will be logged; otherwise false.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Royale 0.9.3
+     */ 
+   /*  public static function isInfo():Boolean
+    {
+        return (_targetLevel <= LogEventLevel.INFO) ? true : false;
+    } */
+    
+    /**
+     *  Indicates whether a debug level log event will be processed by a
+     *  log target.
+     *
+     *  @return true if a debug level log event will be logged; otherwise false.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Royale 0.9.3
+     */
+    /* public static function isDebug():Boolean
+    {
+        return (_targetLevel <= LogEventLevel.DEBUG) ? true : false;
+    } */
+
+    /**
+     *  Allows the specified target to begin receiving notification of log
+     *  events.
+     *
+     *  @param The specific target that should capture log events.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Royale 0.9.3
+     */
+    /* public static function addTarget(target:ILoggingTarget):void
+    {
+        if (target)
+        {
+            var filters:Array = target.filters;
+            var logger:ILogger;
+            // need to find what filters this target matches and set the specified
+            // target as a listener for that logger.
+            for (var i:String in _loggers)
+            {
+                if (categoryMatchInFilterList(i, filters))
+                    target.addLogger(ILogger(_loggers[i]));
+            }
+            // if we found a match all is good, otherwise we need to
+            // put the target in a waiting queue in the event that a logger
+            // is created that this target cares about.
+            _targets.push(target);
+            
+            if (_targetLevel == NONE)
+                _targetLevel = target.level
+            else if (target.level < _targetLevel)
+                _targetLevel = target.level;
+        }
+        else
+        {
+            var message:String = resourceManager.getString(
+                "logging", "invalidTarget");
+            throw new ArgumentError(message);
+        }
+    } */
+
+    /**
+     *  Stops the specified target from receiving notification of log
+     *  events.
+     *
+     *  @param The specific target that should capture log events.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Royale 0.9.3
+     */
+    /* public static function removeTarget(target:ILoggingTarget):void
+    {
+        if (target)
+        {
+            var filters:Array = target.filters;
+            var logger:ILogger;
+            // Disconnect this target from any matching loggers.
+            for (var i:String in _loggers)
+            {
+                if (categoryMatchInFilterList(i, filters))
+                {
+                    target.removeLogger(ILogger(_loggers[i]));
+                }                
+            }
+            // Remove the target.
+            for (var j:int = 0; j<_targets.length; j++)
+            {
+                if (target == _targets[j])
+                {
+                    _targets.splice(j, 1);
+                    j--;
+                }
+            }
+            resetTargetLevel();
+        }
+        else
+        {
+            var message:String = resourceManager.getString(
+                "logging", "invalidTarget");
+            throw new ArgumentError(message);
+        }
+    } */
+
+    /**
+     *  Returns the logger associated with the specified category.
+     *  If the category given doesn't exist a new instance of a logger will be
+     *  returned and associated with that category.
+     *  Categories must be at least one character in length and may not contain
+     *  any blanks or any of the following characters:
+     *  []~$^&amp;\/(){}&lt;&gt;+=`!#%?,:;'"&#64;
+     *  This method will throw an <code>InvalidCategoryError</code> if the
+     *  category specified is malformed.
+     *
+     *  @param category The category of the logger that should be returned.
+     *
+     *  @return An instance of a logger object for the specified name.
+     *  If the name doesn't exist, a new instance with the specified
+     *  name is returned.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Royale 0.9.3
+     */
+    public static function getLogger(category:String):ILogger
+    {
+       // checkCategory(category);
+        if (!_loggers)
+            _loggers = [];
+
+        // get the logger for the specified category or create one if it
+        // doesn't exist
+        var result:ILogger = _loggers[category];
+       /*  if (result == null)
+        {
+            result = new LogLogger(category);
+            _loggers[category] = result;
+        }
+
+        // check to see if there are any targets waiting for this logger.
+        var target:ILoggingTarget;
+        for (var i:int = 0; i < _targets.length; i++)
+        {
+            target = ILoggingTarget(_targets[i]);
+            if (categoryMatchInFilterList(category, target.filters))
+                target.addLogger(result);
+        } */
+
+        return result;
+    }
+
+    /**
+     *  This method removes all of the current loggers from the cache.
+     *  Subsquent calls to the <code>getLogger()</code> method return new instances
+     *  of loggers rather than any previous instances with the same category.
+     *  This method is intended for use in debugging only.
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Royale 0.9.3
+     */
+    /* public static function flush():void
+    {
+        _loggers = [];
+        _targets = [];
+        _targetLevel = NONE;
+    } */
+
+    /**
+     *  This method checks the specified string value for illegal characters.
+     *
+     *  @param value The String to check for illegal characters.
+     *            The following characters are not valid:
+     *                []~$^&amp;\/(){}&lt;&gt;+=`!#%?,:;'"&#64;
+     *  @return   <code>true</code> if there are any illegal characters found,
+     *            <code>false</code> otherwise
+     *  
+     *  @langversion 3.0
+     *  @playerversion Flash 9
+     *  @playerversion AIR 1.1
+     *  @productversion Royale 0.9.3
+     */
+    /* public static function hasIllegalCharacters(value:String):Boolean
+    {
+        return value.search(/[\[\]\~\$\^\&\\(\)\{\}\+\?\/=`!@#%,:;'"<>\s]/) !=
-1;
+    }
+ */
+    // private members
+    /**
+     *  This method checks that the specified category matches any of the filter
+     *  expressions provided in the <code>filters</code> Array.
+     *
+     *  @param category The category to match against
+     *  @param filters A list of Strings to check category against.
+     *  @return <code>true</code> if the specified category matches any of the
+     *            filter expressions found in the filters list, <code>false</code>
+     *            otherwise.
+     *  @private
+     */
+   /*  private static function categoryMatchInFilterList(category:String, filters:Array):Boolean
+    {
+        var result:Boolean = false;
+        var filter:String;
+        var index:int = -1;
+        for (var i:uint = 0; i < filters.length; i++)
+        {
+            filter = filters[i];
+            // first check to see if we need to do a partial match
+            // do we have an asterisk?
+            index = filter.indexOf("*");
+
+            if (index == 0)
+                return true;
+
+            index = index < 0 ? index = category.length : index -1;
+
+            if (category.substring(0, index) == filter.substring(0, index))
+                return true;
+        }
+        return false;
+    } */
+
+    /**
+     *  This method will ensure that a valid category string has been specified.
+     *  If the category is not valid an <code>InvalidCategoryError</code> will
+     *  be thrown.
+     *  Categories can not contain any blanks or any of the following characters:
+     *    []`*~,!#$%^&amp;()]{}+=\|'";?&gt;&lt;./&#64; or be less than 1
character in length.
+     *  @private
+     */
+   /*  private static function checkCategory(category:String):void
+    {
+        var message:String;
+        
+        if (category == null || category.length == 0)
+        {
+            message = resourceManager.getString(
+                "logging", "invalidLen");
+            throw new InvalidCategoryError(message);
+        }
+
+        if (hasIllegalCharacters(category) || (category.indexOf("*") != -1))
+        {
+            message = resourceManager.getString(
+                "logging", "invalidChars");
+            throw new InvalidCategoryError(message);
+        }
+    } */
+    
+    /**
+     *  @private
+     *  This method resets the Log's target level to the most verbose log level
+     *  for the currently registered targets.
+     */
+    /* private static function resetTargetLevel():void
+    {
+        var minLevel:int = NONE;
+        for (var i:int = 0; i < _targets.length; i++)
+        {
+            if (minLevel == NONE || _targets[i].level < minLevel)
+                minLevel = _targets[i].level;
+        }
+        _targetLevel = minLevel;
+    } */
+}
+
+}

-- 
To stop receiving notification emails like this one, please contact
alinakazi@apache.org.

Mime
View raw message