package uk.co.jonnyreeves
{
        public class MyClass
        {
                // Request an ILogger instance for this Class.
                public static const LOGGER : ILogger = LogFactory.getClassLogger(MyClass);

                public function MyClass()
                {
                        // Write a log message using the Logger instance.
                        LOGGER.info("Created instance of MyClass");
                }
        }
}
 

Sun Feb 21 10:33:29 GMT+0000 2010 [INFO]  uk.co.jonnyreeves.MyClass - Created instance of MyClass

package uk.co.jonnyreeves.logging.util.monsterdebugger
{
        import nl.demonsters.debugger.MonsterDebugger;

        import org.as3commons.logging.ILogger;
        import org.as3commons.logging.ILoggerFactory;

        /**
         * Provides a bridge between the AS3Commons Logging Framework and MonsterDebugger.
         *
         * @author John Reeves
         */
        public class MonsterDebuggerLoggerFactory implements ILoggerFactory
        {
               
                /**
                 * Initialises MonsterDebugger
                 *
                 * @param target                The Base Object you wisht to start graphing from (usually you will supply the
                 *                                              Display Root DisplayObject).
                 *                                     
                 * @param clearConsole  Clears MonsterDebugger’s Trace Console when the initial connection is made.
                 */
                public function MonsterDebuggerLoggerFactory(target : Object, clearConsole : Boolean = true)
                {
                        new MonsterDebugger(target);
                        if (clearConsole)
                        {
                                MonsterDebugger.clearTraces();
                        }
                }

                /**
                 * Factory Method, used to return an instance of ILogger to the AS3Commons Logging Framework.
                 */
                public function getLogger(name : String) : ILogger
                {
                        return new MonsterDebuggerLogger(name);
                }
        }
}
 

package uk.co.jonnyreeves.logging.util.monsterdebugger
{
        import org.as3commons.logging.util.MessageUtil;
        import nl.demonsters.debugger.MonsterDebugger;

        import org.as3commons.logging.LogLevel;
        import org.as3commons.logging.impl.AbstractLogger;

        /**
         * Provides a bridge between the AS3 Commons Logging implementation and Monster Debugger; it’s not perfect but it
         * works for the most part.
         *
         * The Target of the log message will always be the name of the logger.
         *
         * The Object of the log message will vary depending on the parameters passed.  If the message string is empty
         * then the params Array will be logged.  If the message string is not empty, the params Array will be used to
         * tokenise the message string.
         *
         * Usage:
         *              LOGGER.debug("Hello World");            // Outputs message: "(String) Hello World"
         *              LOGGER.debug("Hello {0} {1}, "Jonny", "Reeves");        // Outputs message: "(String) Hello Jonny Reeves"
         *              LOGGER.debug("", [ 1, 2, 3 ]);          // Outputs message: "(Array)…" (which can then be inspected)
         *             
         * Incorrect usage:
         *              LOGGER.debug("Some Array", [1, 2, 3]);  // Outputs message: "(String) Some Array" (which can’t be inspected)
         *
         * @author John Reeves
         */
        public class MonsterDebuggerLogger extends AbstractLogger
        {
                public var level : int = LogLevel.DEBUG;

                public function MonsterDebuggerLogger(name : String)
                {
                        super(name);
                }

                override protected function log(level : uint, message : String, params : Array) : void
                {
                        if (level >= this.level)
                        {
                                var target : Object = name;
                                var object : Object = getLogObject(message, params);
                                var colour : uint = getLogMessageColour(level);
                                MonsterDebugger.trace(target, object, colour);
                        }
                }

                private function getLogObject(message : String, params : Array) : Object
                {
                        if (message == "")
                        {
                                // If the user only supplied a single param to log, we remove the params array which is enclosing it.
                                return (params.length == 1) ? params.pop() : params;
                        }
                        else
                        {
                                return MessageUtil.toString(message, params);
                        }
                }

                private function getLogMessageColour(level : int) : uint
                {
                        var colour : int;
                        switch (level)
                        {
                                case LogLevel.FATAL:
                                case LogLevel.ERROR:
                                        colour = MonsterDebugger.COLOR_ERROR;
                                        break;
                                       
                                case LogLevel.WARN:
                                        colour = MonsterDebugger.COLOR_WARNING;
                                        break;
                               
                                default:
                                        colour = MonsterDebugger.COLOR_NORMAL;
                                        break;
                        }
                        return colour;
                }

                override public function get debugEnabled() : Boolean
                {
                        return LogLevel.DEBUG >= level;
                }

                override public function get errorEnabled() : Boolean
                {
                        return LogLevel.ERROR >= level;
                }

                override public function get infoEnabled() : Boolean
                {
                        return LogLevel.INFO >= level;
                }

                override public function get warnEnabled() : Boolean
                {
                        return LogLevel.WARN >= level;
                }

                override public function get fatalEnabled() : Boolean
                {
                        return LogLevel.FATAL >= level;
                }
        }
}
 

package  
{
        import uk.co.jonnyreeves.logging.util.MonsterDebuggerLoggerFactory
        import flash.display.Sprite;

        /**
         * Application Entry Point.
         * @author John Reeves
         */
        public class MyApp extends Sprite
        {
                public function MyApp()
                {
                        LoggerFactory.loggerFactory = new MonsterDebuggerLoggerFactory(this);
                }
        }
}
 

<artifact:pom id="maven.project" groupId="com.example" version="${build.version}" artifactId="${project.name}" packaging="zip">
        <remoteRepository id="releases" url="http://maven:8081/nexus/content/repositories/releases" />
</artifact:pom>
<artifact:install-provider artifactId="wagon-http-lightweight" version="1.0-beta-2" />
<artifact:deploy file="deploy/${project.name}.zip">
    <pom refid="maven.project" />
</artifact:deploy>
 

<!–  Generate a Dynamic POM file –>
<artifact:pom id="pom.tmp.ref" groupId="com.example" version="${build.version}" artifactId="${project.name}" packaging="zip" />

<!–  Write the generated POM file out to a temporary file on disc –>
<tempfile property="pom.tmp.file" />
<artifact:writepom pomRefId="pom.tmp.ref" file="${pom.tmp.file}" />

<!–  Read the temporary file back in as the POM reference –>
<artifact:pom id="maven.project" file="${pom.tmp.file}" />

<!– We can now deploy, but we have to include a reference to the repository –>
<artifact:install-provider artifactId="wagon-http-lightweight" version="1.0-beta-2" />
<artifact:deploy file="deploy/${project.name}.zip">
    <pom refid="maven.project" />
    <remoteRepository id="releases" url="http://maven:8081/nexus/content/repositories/releases" />
</artifact:deploy>
 

/**
 * This example method will send an event back to a Registered Listener, in this
 * case we’re going to inform the listener that we have loaded our data and
 * are ready for use.
 *
 *      @param Void
 *      @return Void
*/
private function __onLoadComplete():Void
{
        // This forms the basis of the event we are going to send.
        var eventObject:Object = new Object();
       
        // Populate our eventObject with its type & the event message to send
        eventObject.type = ‘ModelEvent’;
        eventObject.event = ‘data_loaded’
       
        // And send the object via mx.events.EventDispatcher
        this.dispatchEvent(eventObject);
}
 

/**
 * Example function, showing us registering the event listener to the Model with
 * a delegated callback to the __onModelEvent() function.
 *
 *      @param Void
 *      @return Void
*/
private function registerModel()
{
        model.addEventListener("modelEvent", Delegate.create(this, __onModelEvent));
}

/**
 * Callback method which was registered at the same time as adding the eventListener
 * this method handles incoming events from registered models
 *
 *      @param Object event object dispatched from registered model.
 *      @return Void
*/
private function __onModelEvent(event:Object):Void
{
        switch (event.event)
        {
                case ‘data_loaded’:
                        trace (‘Controller::__onModelEvent — Data Loaded!’);
                        break;

                default:
                        trace (‘Controller::__onModelEvent — Unkown Model State recieved: ‘ + event.event);
                        break;
        }
}
 

/**
 * ModelEvent.as
 * John Reeves, http://www.jonnyreeves.co.uk/
 * May 2008
 *
 * Typesafe Event dispatched from Models.
*/
class ModelEvent
{
        private var _name:String;
        private var _level:Number;
       
        /**
         * Private Constructor for creating ModelEvent instances.  This stops developers
         * creating their own ModelEvent’s in the code, instead we encourage people
         * to create Static Model Events below:
        */
        private function ModelEvent(name:String, level:Number)
        {
                this._name = name;
                this._level = level;
        }
       
        // Static Events Models can Send.
        static public var DATA_LOADED:ModelEvent = new ModelEvent(‘DATA_LOADED’, 1);   
        static public var DATA_ERROR:ModelEvent = new ModelEvent(‘DATA_ERROR’, 2);
       

        /**
         * Returns the ModelEvent object for the given ModelEvent String
         *
         *      @param mediaType the MediaType’s name
         *      @return the MediaType object
        */     
        public static function forName(ModelEvent:String):ModelEvent
        {
                if ((ModelEvent[ModelEvent.toUpperCase()] instanceof ModelEvent)) {
                        return ModelEvent[ModelEvent.toUpperCase()];
                }
        }
       

        /**
         * Returns the current ModelEvent’s name as a String
        */
        public function getName():String
        {
                return this._name;
        }
       

        /**
         * Returns the current ModelEvent’s Level as a Number
        */
        public function getLevel():Number
        {
                return this._level;
        }
       
       
        /**
         * Compares an incoming ModelEvent (x) to the current Object.
         *
         *      @param ModelEvent x Incoming ModelEvent Object to perform comparison on.
         *      @return Boolean true if it matches
        */
        public function equals(x:ModelEvent):Boolean
        {
                if (x.getName() == this.getName() && x.getLevel() == this.getLevel()) {
                        return true;
                }
                return false;
        }       
}
 

/**
 * Now we will update this method to use the ModelEvent Enum class.
 *
 *      @param Void
 *      @return Void
*/
private function __onLoadComplete():Void
{
        // This forms the basis of the event we are going to send.
        var eventObject:Object = new Object();
       
        // Populate our eventObject with its type & the state message to send,
        // this time instead of setting state as a String, we set it to be on the
        // ModelEvent’s static properties.
        eventObject.type = ‘ModelEvent’;
        eventObject.event = ModelEvent.DATA_LOADED;
       
        // And send the object via mx.events.EventDispatcher
        this.dispatchEvent(eventObject);
}
 

/**
 * Callback method, this time update to handle the incoming ModelEvent
 *
 *      @param Object event object dispatched from registered model.
 *      @return Void
*/
private function __onModelEvent(event:Object):Void
{
        // extract the ModelEvent Enum from the event Object
        var event:ModelEvent = event.event;
       
        // Use the ModelEvent::equals method to perform comparison
        if (event.equals(ModelEvent.DATA_LOADED)) {
                trace (‘Controller::__onModelEvent — Data Loaded!’);
        }
}
 

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
 <textValue>armén</textValue>
 </configuration>
 

import mx.events.EventDispatcher;
import mx.utils.Delegate;

/**
 * ActionScript 2.0 Configuration Class
 * John Reves, http://www.jonnyreeves.co.uk/
 * June 2008
 *
 * Singleton configuration class with class notation value access and XML
 * import.
*/
class co.uk.jonnyreeves.Configure
{
        // Event Listener
        private var dispatchEvent:Function;
        public var addEventListener:Function;
        public var removeEventListener:Function;

        /**
         * Singleton Instance of this Object.
        */
        private static var _INSTANCE:Configure;

        /**
         * Dynamic Object containing all configuration values
         *      @see Configure::read()
        */
        private var _values:Object;

        /**
         * Interval used to handle Timeouts when retrieving XML Documents.
        */
        private var _xmlTimeoutInterval:Number

        /**
         * Indicates if the XML document timed out whilst loading.
        */
        private var _hasTimedOut:Boolean

        /**
         * Constructor
         * Private, Access via getInstance() only.
        */
        private function Configure(Void)
        {
                this._values = new Object();
                EventDispatcher.initialize(this);
        }

        /**
         * Return a singleton instance of Configure.
         *
         *      @return Configure instance
        */
        static public function getInstance(Void):Configure
        {
                if (_INSTANCE == undefined) {
                        _INSTANCE = new Configure();
                }
                return _INSTANCE;
        }

        /**
         * Attempts to load in Configuration from an XML File, will dispatch
         * an Event depending on the result of this method.
         *
         *      @param xmlFile Location of XML File containing Configuration Values
         *      @return Void
        */
        static public function loadXML(xmlFile:String):Void
        {
                var _this:Configure = getInstance();
                var parser:XML = new XML();
                parser.ignoreWhite = true;

                // Handles XML Document Retreval.
                parser.onLoad = function(success:Boolean):Void
                {
                        if (success &amp;&amp; _this.__validates(this)) {
                                _this.__clearXMLTimeout();
                                _this.__parseXML(this.childNodes[0], _this._values);
                                _this.__onXMLLoadSuccess();
                        }
                        else {
                                _this.__onXMLLoadError();
                        }
                }

                // Create an Interval to handle timeouts.
                _this.__createXMLTimeout();
                parser.load(xmlFile);
        }

        /**
         * Attemps to load all flashVars from _root which exist in the ‘config’
         * namespace.  flashVars should be written using dot notation, but with
         * underscores replacing the dots.
         *
         * For example:
         *      _root.config_testMessage = ‘hello world!’
         *      _root.config_shapes_rectangle_width’ = ‘250′
         *
         * Or using SWFObject notation in the HTML
         *      fo.AddVariable(’config_testMessage’, ‘hello world!’);
         *      fo.AddVariable(’config_shapes_rectangle_width’, ‘250′);
        */
        static public function loadFlashVars():Void
        {
                for (var flashVar:String in _root) {
                        if (flashVar.substr(0, 7) == ‘config_’) {
                                Configure.write(flashVar.substr(7).split(‘_’).join(‘.’), unescape(_root[flashVar]));
                        }
                }
        }

        /**
         * Read a Variable from the Loaded Configuration.  Access to Conifg Groups
         * is handled in {dot} notation.  So to access _config[Omniture][tracking][dc]
         * you would pass in the String ‘omniture.tracking.dc’
         *
         *      @param key Variable to obtain in . notation
         *      @return String value of Configure::_values[key]
        */
        static public function read(key:String):String
        {
                // Turn the . syntax notation into AS2.0 Array access notation.
                var keys:Array = key.split(‘.’);
                var thisGroup:Object = getInstance()._values
                while (keys.length) {
                        thisGroup = thisGroup[keys.shift()];
                }

                // Debugging.
                if (thisGroup.toString() == undefined) {
                        trace(‘Configure::read – Returning Undefined Value for: ‘ + arguments[0]);
                }

                return thisGroup.toString();
        }

        /**
         * Write a Key, Value pair to the Config Object at Run Time.  The key
         * should be supplied in {dot} notation.  The return value could slow
         * down performance on writes.
         *
         *      @param key Varible to write in . notation
         *      @param value Value to write to @param key as a String
         *      @return indicates write was succesfull.
        */
        static public function write(key:String, value:String):Boolean
        {
                // Helper method used for recursion
                getInstance().__recurseWrite(key.split(‘.’), value, getInstance()._values);
                return (read(key) == value);
        }

        /**
         * Helper method used by Configure::write() when dealing with "deep"
         * values inside the _values object.  Method will recurse through the
         * input String (x), and write value to the current configObj node.
         *
         *      @param keys Array contianing the "path" of _values object to write to
         *      @param value String value to write to ConfigObject.
         *      @param configObj Current Node of the Configuration Values _values object
         *      @return Void
        */
        private function __recurseWrite(keys:Array, value:String, configObj:Object):Void
        {
                // Write if that was the last key index.
                if (keys.length == 1) {
                        configObj[keys.shift()] = value;
                }
                // Otherwise Recurse again, create new object if needed.
                else {
                        var thisKey = keys.shift();
                        if (configObj[thisKey] == undefined) {
                                configObj[thisKey] = new Object();
                        }
                        this.__recurseWrite(keys, value, configObj[thisKey]);
                }
        }

        /**
         * Callback to handle failed attempts to Load the configuration XML.
         *
         *      @param Void
         *      @return Void
        */
        private function __onXMLLoadError(Void):Void
        {
                this.__clearXMLTimeout();
                var eventObject:Object = new Object();
                eventObject.target = this;
                eventObject.type = ‘configureEvent’;
                eventObject.name = ‘Configure.onXMLLoadError’
                this.dispatchEvent(eventObject);
        }

        /**
         * XML has been successfully loaded and is ready to be interacted with.
         *
         *      @param Void
         *      @return Void
        */
        private function __onXMLLoadSuccess(Void):Void
        {
                var eventObject:Object = new Object();
                eventObject.target = this;
                eventObject.type = ‘configureEvent’;
                eventObject.name = ‘Configure.onXMLLoaded’
                this.dispatchEvent(eventObject);
        }

        /**
         * Validates the loaded XML Document
         *
         *      @param xml XMLObject loaded by Configure::loadXML()
         *      @return Boolean false on validation errors
        */
        private function __validates(xml:XML):Boolean
        {
                // Abort if we have already timed out.
                if (this._hasTimedOut) {
                        trace (‘Configure::__validateXML – Refusing to Parse XML, timed out’);
                        return false;
                }

                // Check the first node is
                if (String(xml.childNodes[0].nodeName) !== "configuration") {
                        this.__onInvalidXML();
                        return false;
                }

                return true;
        }

        /**
         * Parses the Loaded XML Documents, populating this object’s _values prop.
         *
         *      @param xml XMLObject loaded by Configure::loadXML()
         *      @param config Internal Configuration Object to write values to
         *      @return Void
        */
        private function __parseXML(xml:XMLNode, config:Object):Void
        {
                // loop through all Children of this Node.
                var nodeCount:Number = xml.childNodes.length;
                for (var i:Number = 0; i < nodeCount; i++)
                {
                        var thisNode:XMLNode = xml.childNodes[i];

                        // Recurse into Config Groups (tricky because values are considered to have Length.
                        if (thisNode.childNodes.length > 0 &amp;&amp; thisNode.childNodes[0].nodeValue == null)
                        {
                                // Create new Object off of this._values
                                config[thisNode.nodeName] = new Object();
                                this.__parseXML(thisNode, config[thisNode.nodeName]);
                        }

                        // Write Value
                        else {
                                config[thisNode.nodeName] = thisNode.childNodes[0].nodeValue.toString();
                        }
                }
        }

        /**
         * Creates an Interval used by Configure::loadXML to handle XML documents
         * which timeout.
         *
         *      @param Void
         *      @return Void
        */
        private function __createXMLTimeout(Void):Void
        {
                this._xmlTimeoutInterval = _global.setTimeout(this, ‘__onXMLTimeout’, 1000);
                this._hasTimedOut = false;
        }

        /**
         * Triggered when the timeout in createXMLTimeout() has expired, indicates
         * that the XML document failed to load.
         *
         *      @param Void
         *      @return Void
        */
        private function __onXMLTimeout(Void):Void
        {
                trace (‘Configure::__onXMLTimeout’);
                this._hasTimedOut = true;
                this.__clearXMLTimeout();
                this.__onXMLLoadError();
        }

        /**
         * Gets called when the Parser fails to parse the incoming configuration
         * XML.
         *      @param Void
         *      @return Void
        */
        private function __onInvalidXML(Void):Void
        {
                trace(‘Configure::__onInvalidXML’);
        }

        /**
         * Clears the Interval, tidies up.
        */
        private function __clearXMLTimeout()
        {
                clearInterval(this._xmlTimeoutInterval);
        }
}

/**
 * Config.as
 * John Reeves (www.jonnyreeves.co.uk)
 *
 * Actionscript 2.0 Singleton Configuration Class.  This class will load
 * specified config and then allow you to read/write from it at run-time.
*/
import BaseConfig;
class Config
{
        /**
         * @var _instance
         * Instance of config, created only by load() method.
        */
        private var _instance:Config;

        /**
         * Private constructor, as this class is a Singleton we don’t
         * want instances to be be created outside of the Factory
         * method (load()).
        */
        private function Config()
        {
        }

        /**
         * Factory method for loading the desired configuration instance.
         * Extend this method out if you intend to have multiple
         * Configurations accessible at compile time.
         *
         *      @param config   Configuration you wish to load.
        */
        static public function load(config:String):Void
        {
                // Check if configuration has already loaded.
                if (_configuration !== undefined)
                {
                        throw new Error(‘Config::load() -> Configuration’
                                +‘ has already been loaded.’);
                }

                switch (config.toString())
                {
                        case ‘base’:
                                _configuration = new BaseConfig();
                                break;

                        default:
                                throw new Error(‘Config::load() -> Invalid’
                                        + ‘ configuration requested’);
                }
        }

        /**
         * Read a configuration value from the loaded instance.
         *
         *      @param key      Property you wish to read from loaded instance.
        */
        static public function read(key:String)
        {
                // Check user has loaded a config.
                if (_configuration == undefined) {
                        throw new Error(‘Config::read() -> No configuration’
                                +‘ loaded, please Config.load() one first.’);
                }

                // Using the Array access method.
                return _configuration[key];
        }

        /**
         * Write to the currently loaded configuration instance.
         *
         *      @param key      Property you wish to write
         *      @param value    New value for above Property
        */
        static public function write(key:String, value:Object)
        {

                if (_configuration == undefined) {
                        throw new Error(‘Config::read() -> No configuration’
                                +‘ loaded, please use Config.load() first.’);
                }

                // Only write values if the property exists in the Config’s
                // Constructor, this is a nasty ActionScript 2.0 hack.
                if (_configuration.hasOwnProperty("_" + key))
                {
                        // Using array access method, will call custom setter.
                        _configuration[key] = value;
                }

                // Refusing to write key, add any error handling here.
                else
                {
                        trace (‘Config.write() -> Invalid Property: ‘
                                +key.toString());
                }
        }
}

/**
 * BaseConfiguration.as
 * John Reeves (www.jonnyreeves.co.uk)
 *
 * Base configuration class, should you need even more flexibility
 * at run-time you can extend this and add to the Factory Method in
 * the Config class.
 *
 * This file contains the actual configuration values for your application
 * complete with Strict Type Checking at both Compile and Run time.
*/
class BaseConfiguration
{
        /**
         * @var _exampleProtectedString
         * This is an example string which has a default value but can’t be
         * over-ridden at run time with a flashVar. (see Constructor)
        */
        protected var _exampleProtectedString:String = ‘default value’;

        /**
         * @var _exampleString
         * This is an example string, it doesn’t have a default value but
         * can be over-ridden at run time with a flashVar.  (see Constructor)
        */
        private var _exampleString:String;

        /**
         * @var _exampleNumber
         * private var _examplePrivateNumber
         * This is an example number, it has a default value and can be
         * over-ridden by a flashVar at runtime.
        */
        private var _exampleNumber:Number = 1234;

        /**
         * Constructor
         * Any properties defined here can be over-ridden at run-time by flashVars
         * embedded in the HTML.  Any properties not defined will be "protected"
        */
        public function BaseConfiguration()
        {
                // These props are modifiy-able at runtime with flashVars.
                exampleString = this._exampleString;
                exampleNumber = this._exampleNumber;

                // If the next line were un-commented, we would be able to
                // modify exampleProtectedString at runtime with a flashVar
                // exampleProtectedString = this._exampleProtectedString;
        }

        /**
         * Getter and Setter for exampleString
        */
        public function get exampleString():String
        {
                return this._exampleString;
        }
        public function set exampleString(value:String):Void
        {
                // Run time type checking.
                if (value !== undefined || value !== null)
                {
                        this._exampleString = value.toString();
                }
        }

        /**
         * Getter and Setter for exampleProtectedString
        */
        public function get exampleProtectedString():String
        {
                return this._exampleProtectedString;
        }
        public function set exampleProtectedString(value:String):Void
        {
                // Run time type checking.
                if (value !== undefined || value !== null)
                {
                        this._exampleString = value.toString();
                }
        }

        /**
         * Getter and Setter for exampleNumber
        */
        public function get exampleNumber():Number
        {
                return this._exampleNumber;
        }
        public function set exampleNumber(value:Number):Void
        {
                // Run time type checking.
                if (!isNaN(value))
                {
                        this._exampleNumber = Number(value);
                }
        }
}

/**
 * Main.as
 * John Reeves (www.jonnyreeves.co.uk)
 *
 * Example application which will use our Config class to read a value
 * and write any flashVars which were passed in at run time.
 *
 * Please note that this is psudo code and probably wont’ compile.
*/
import Config;
class Main
{
        /**
         * Constructor, just an example of using the config class.
        */
        public function Main()
        {
                // Load ‘base’ config
                Config.load(‘base’);

                // Trace out exampleString
                trace(Config.read(‘exampleNumber’);     // outputs "1234"

                // Set an example flashVar (_root), this can also be done
                // in the HTML using the flashVar param, or
                // using the URI param: move="main.swf?exampleNumber=4321"
                _root.exampleNumber = 4321             

                // Load in all flashVars from the _root and set them
                for (var flashVar in _root)
                {
                        // Loop each _root var and set it in our config
                        Config.write(flashVar, unescape(_root[flashVar]));

                }

                trace (Config.read(‘exampleNumber’));   // outputs "4321"

                // And with a string (outputs "default Value")
                trace (Config.read(‘exampleProtectedString’))

                // try to over-write a "protected" value (one not set in the
                // BaseConfiguration constructor.
                _root.exampleProtectedString = "a new value";

                // Load in all flashVars from _root again…
                for (var flashVar in _root)
                {
                        // Loop each _root var and set it in our config
                        Config.write(flashVar, unescape(_root[flashVar]));
                }

                // as it’s protected, it won’t have written it
                trace (Config.read(‘exampleProtectedString’) // still outputs
                                                        // "default value"
        }
}

<?xml version="1.0" encoding="UTF-8"?>
<playlist version="1" xmlns="http://xspf.org/ns/0/">
 <title></title>
 <creator></creator>
 <date></date>
 <extension application="http://www.cnetnetworks.co.uk/xspf/reccomendations/1/0/">
  <cnet:reccomendation>
   <cnet:title></cnet:title>
   <cnet:image></cnet:image>
   <cnet:info></cnet:info>
   <cnet:annotation></cnet:annotation>
  </cnet:reccomendation>
 </extension>
 <trackList>
  <track>
   <location></location>  
   <title></title>
   <creator></creator>
   <annotation></annotation>
   <info></info>
   <image></image>
   <duration>1</duration>
   <meta rel="http://www.cnetnetworks.co.uk/xspf/product_id/1/0/"></meta>
   <meta rel="http://www.cnetnetworks.co.uk/xspf/is_ad/1/0/"></meta>
   <meta rel="http://www.cnetnetworks.co.uk/xspf/alternative_audio/1/0/"></meta>
   <meta rel="http://www.cnetnetworks.co.uk/xspf/captions_file/1/0/"></meta>
   <extension application="http://www.cnetnetworks.co.uk/xspf/chapters/1/0/">
    <cnet:chapter>
     <cnet:title></cnet:title>
     <cnet:image></cnet:image>
     <cnet:annotation></cnet:annotation>
     <cnet:position></cnet:position>
    </cnet:chapter>
   </extension>
  </track>
 </trackList>
</playlist>