JonnyReeves.co.uk

/**
 * 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"
        }
}