[java] /foo/diablo-flash/workspace/adoption_ingame/src/com/mindcandy/diablo/adoption_ingame/controller/DropDownConfigManager.as(17): col: 4: Error: unable to resolve ‘dropDownConfig.xml’ for transcoding
[java]
[java]          [Embed(source="dropDownConfig.xml", mimeType="application/octet-stream")]
 

host:/foo/diablo-flash/workspace/adoption_ingame/src# ls -l
total 100
drwxr-xr-x 4 tomcat6 tomcat6  4096 2010-07-19 15:47 com
-rw-r–r– 1 tomcat6 tomcat6 12205 2010-07-19 15:47 dropdownConfig.xml
 

package  
{
        import org.flexunit.asserts.assertTrue;

        /**
         * An example Test Case to get FlexUnit 4.1 Beta up and running.
         * @author Jonny Reeves
         */
        public class TestExample
        {
                [Test]
                public function exampleTest() : void
                {
                        // Not much of a test! :)
                        assertTrue("FlexUnit 4.1 Beta is running under FDT", true);
                }
        }
}
 

<project name="FlexUnit4.1-Example">
</project>
 

<project name="FlexUnit4.1-Example">
        <!– Update this property to point to your FLEX SDK; note there is
                        a bug in FlexUnit 4.1 Beta 1 where the FLEX SDK path must
                        NOT include any spaces, otherwise you will get an error during
                        the MXMLC compilation stage; this has already been fixed in the
                        latest Builds of FlexUnit 4.1, see: http://bit.ly/dpHcHT –>
        <property name="FLEX_HOME" location="${eclipse.fdt.flexsdk}" />

        <property name="bin.dir" value="${basedir}/bin" />
        <property name="report.dir" value="${basedir}/reports" />
        <property name="lib.dir" value="${basedir}/libs" />
        <property name="test-src.dir" value="${basedir}/test-src" />

        <taskdef resource="flexTasks.tasks" classpath="${FLEX_HOME}/ant/lib/flexTasks.jar" />
        <taskdef resource="flexUnitTasks.tasks" classpath="${lib.dir}/flexUnitTasks-4.1.0-beta1.14.jar" />

        <!– Run FlexUnit 4.1 and generate JUnit Output –>
        <target name="test" depends="init" description="Run Unit Tests">
                <flexunit
                        workingDir="${bin.dir}"
                        toDir="${report.dir}"
                        verbose="true"
                        haltonfailure="true">
                        <testSource dir="${test-src.dir}">
                                <include name="**/*Test*.as" />
                        </testSource>
                        <library dir="${lib.dir}" />
                </flexunit>

                <junitreport todir="${report.dir}">
                        <fileset dir="${report.dir}">
                                <include name="TEST-*.xml" />
                        </fileset>
                        <report format="frames" todir="${report.dir}/html" />
                </junitreport>

        </target>

        <!– Create the required directories and clean out the reports folder –>
        <target name="init">
                <delete dir="${report.dir}" />
                <mkdir dir="${bin.dir}" />
                <mkdir dir="${report.dir}" />
        </target>
</project>
 

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);
                }
        }
}
 

package {
        import flash.display.Sprite;
        import flash.utils.Dictionary;

        /**
         * @author Jonny Reeves
         */
        public class DictionarySort extends Sprite
        {
                function DictionarySort() : void
                {
                        var myDictionary : Dictionary = new Dictionary();
                       
                        // Provide some values to sort.
                        myDictionary[500] = "Five Hundred";
                        myDictionary[55] = "Fifty Five";
                        myDictionary[1] = "One";
                        myDictionary[231] = "Two Hundred and Thirty One";
                       
                        var myKeys : Array = this.extractKeysFrom(myDictionary);
                        trace("myKeys Array before sort: " + myKeys);
                       
                        // Apply a Numeric sort to the Array.
                        myKeys.sort(Array.NUMERIC);
                        trace("myKeys Array after sort: " + myKeys);
                       
                        // You can now use the extracted Keys to read from the Dictionary in
                        // the required order.
                        for each (var thisKey : * in myKeys)
                        {
                                // Will trace out the number followed by the english words.
                                trace(thisKey + " = " + myDictionary[thisKey]);
                        }
                }
               
                /**
                 * Helper method to extract the Keys from a Dictionary Object and return
                 * them in an Array.
                 */
                private function extractKeysFrom(source : Dictionary) : Array
                {
                        var output : Array = [];
                       
                        // Note that Dictionary’s Keys are untyped as they can contain
                        // any value.
                        for (var prop : * in source)
                        {
                                output.push(prop);
                        }
                        return output;
                }
        }
}
 

package
{
        import flash.display.Sprite;
        import flash.utils.Dictionary;
        import flash.utils.getTimer;

        /**
         * @author Jonny
         */
        public class Sorting extends Sprite
        {
                public function Sorting()
                {
                        var source1 : Array = this.generateViaIndexOf(10000);
                        var source2 : Array = this.generateViaDictionary(10000, false);
                        var source3 : Array = this.generateViaDictionary(10000, true);
                       
                        this.sort(source1, Array.NUMERIC);
                        this.sort(source2, Array.NUMERIC);
                        this.sort(source3, Array.NUMERIC);
                       
                        debugOutput("indexOf", source1);
                        debugOutput("nonCast", source2);
                        debugOutput("cast", source3);
                }
               
                private function debugOutput(name : String, values : Array) : void
                {
                        trace(name + "[0] = " + values[0] + ", " + name + "[1] = " + values[1]);
                }

                private function sort(source : Array, sortMethod : uint) : void
                {
                        var startTime : uint = getTimer();
                        source.sort(sortMethod);       
                        trace("Array sorted in " + (getTimer() – startTime) + "ms.");
                }

                private function generateViaDictionary(length : int, castOutput : Boolean) : Array
                {
                        var startTime : int = getTimer();
                       
                        var pushed : Boolean;
                        var dictionary : Dictionary = new Dictionary();
                        while (length–)
                        {
                                pushed = false;
                                while (!pushed)
                                {
                                        var thisRand : uint = Math.ceil(Math.random() * 100000000);
                                        if (dictionary[thisRand] == undefined)
                                        {
                                                dictionary[thisRand] = true;
                                                pushed = true;
                                        }
                                }
                        }
                       
                        var output : Array = [];
                        for (var prop : String in dictionary)
                        {
                                if (castOutput)
                                {
                                        output.push(parseInt(prop));                                   
                                }
                                else
                                {
                                        output.push(prop);
                                }
                        }
                       
                        trace("Source Array containing " + output.length + " items created in " + (getTimer() – startTime) + "ms.");
                        return output;
                }
               
                private function generateViaIndexOf(length : int) : Array
                {
                        var startTime : uint = getTimer();
                       
                        var pushed : Boolean;
                        var output : Array = [];
                        while (length–)
                        {
                                pushed = false;
                                while (!pushed)
                                {
                                        var thisRand : uint = Math.ceil(Math.random() * 100000000);
                                        if (output.indexOf(thisRand) == -1)
                                        {
                                                output.push(thisRand);
                                                pushed = true;
                                        }
                                }
                        }
                       
                        trace("Source Array containing " + output.length + " items created in " + (getTimer() – startTime) + "ms.");
                        return output;
                }
        }
}
 

Source Array containing 10000 items created in 3082ms.
Source Array containing 10000 items created in 71ms.
Source Array containing 10000 items created in 102ms.
Array sorted in 19ms.
Array sorted in 312ms.
Array sorted in 17ms.
indexOf[0] = 4532, indexOf[1] = 14806
nonCast[0] = 3553, nonCast[1] = 6646
cast[0] = 10432, cast[1] = 22513

package uk.co.jonnyreeves.classmapping {

        /**
         * Example Model Class for a Car
         */
        public class Car implements IContainsAssetPath
        {
                /**
                 * The name of this Car.
                 */
                private var name : String;
               
               
                /**
                 * Constructor.
                 * @param name          The name of this car.
                 */
                public function Car(name : String)
                {
                        this.name = name;
                }
               
                /**
                 * Returns the name of this car.
                 */
                public function getName() : String
                {
                        return this.name;
                }
               
                /**
                 * Return the filename for this Car’s Asset SWF.
                 */
                public function getAssetPath() : String
                {
                        return this.name + ".swf";
                }
        }
}
 

package uk.co.jonnyreeves.classmapping {

        /**
         * Common Interface for all Models with Assets
         */
        public interface IContainsAssetPath
        {
                /**
                 * Returns the final stub path to this asset.
                 */
                function getAssetPath() : String;
        }
}
 

package uk.co.jonnyreeves.classmapping
{
        import flash.utils.Dictionary; 

        /**
         * Helper for building URLs from Car Objects.
         */
        public class URLManager {
                /**
                 * Dictionary which will contain mappings between Class Definitions
                 * and URL Stubs used to build asset paths.
                 */
                private static var objectMappings : Dictionary = new Dictionary();

                /**
                 * Singleton Instance.
                 */
                private static var instance : URLManager;

                /**
                 * Singleton Accessor Method.
                 */
                public static function getInstance() : URLManager
                {
                        if (instance == null)
                        {
                                instance = new URLManager();
                        }
                        return instance;
                }

                /**
                 * Private Constructor for Singleton Pattern.
                 */
                public function URLManager()
                {
                        createObjectMappings();
                }

                /**
                 * Populate the ObjectMappings Dictionary.
                 */            
                private function createObjectMappings() : void
                {
                        // Here we create relationships between the Class definitions and their
                        // URL Stubs.  We use the constructor object to create a common relation
                        // between ClassDefinitions and instances of those Class Definitions.
                        objectMappings[Car.prototype.constructor] = "/flash/assets/cars/";
                }
               
                /**
                 * Retrieve the AssetURL for the supplied instance of the IContainsAssetPath interface
                 */
                public function getAssetURL(source : IContainsAssetPath) : String
                {
                        // Here we can extract the constructor object from the incoming IContainsAssetPath
                        // implementation.  This will be the same object as the one we stored in
                        // this.createObjectMappings();
                        var sourceConstructor : Object = (source as Object).constructor;
                       
                        // Check to see if a mapping exists for this Class Definition.
                        if (objectMappings[sourceConstructor] == undefined)
                        {
                                throw new Error("Asset Mapping does not exist for object: " + source);
                        }
                       
                        // We can now build the complete URL.
                        return objectMappings[sourceConstructor] + source.getAssetPath();
                }
        }
}