Merge branch 'bgarde-register_alias'

src/com/pblabs/engine/core/NameManager.as

@@ -74,6 +74,77 @@ package com.pblabs.engine.core
                 _objects[object.name] = null;
                 delete _objects[object.name];
             }
+
+            unregisterAliases(object);
+        }
+
+
+        /**
+         * Register an alias for an IPBObject 
+         * @param object The object to register the alias for
+         * @param alias The alias to register
+         **/
+        public function registerAlias(object:IPBObject, alias:String):void
+        {
+            if(alias == null || alias == "") 
+            {
+                Logger.warn(this, "registerAlias", "Attempt made to register invalid alias '"+alias+"'");
+                return;
+            }
+
+            if(_objects[alias])
+            {
+                Logger.warn(this, "registerAlias","A PBObject with the name '" + alias + "' already exists ");
+                return;
+            }
+
+            _objects[alias] = object;
+
+            //Store the alias in the registeredAliases map
+            if(!_registeredAliases[object])
+                _registeredAliases[object] = [];
+            _registeredAliases[object].push(alias);
+        }
+
+        /**
+         * Unregister an alias for an IPBObject 
+         * @param object The object to register the alias for.
+         * @param alias The alias to unregister.
+         **/		
+        public function unregisterAlias(object:IPBObject, alias:String):void
+        {
+            // Check if the alias exists, points to the IPBObject and is an alias.
+            if(_objects[alias] && _objects[alias] == object
+                && _registeredAliases[object] && _registeredAliases[object].indexOf(alias) > -1)
+            {
+                _objects[alias] = null;
+                delete _objects[alias];
+
+                _registeredAliases[object].splice(_registeredAliases[object].indexOf(alias), 1);
+                if(_registeredAliases[object].length < 1)
+                    delete _registeredAliases[object];
+            } 
+            else 
+            {
+                Logger.warn(this, "unregisterAlias", "Attempt made to unregister alias '"+alias+"' but the object registered is not the same or the alias is not a registered alias.");
+                return;
+            }
+        }
+        /**
+         * Unregister all aliases for an IPBObject 
+         * @param object The IPBObject to unregister.
+         **/
+        public function unregisterAliases(object:IPBObject):void{
+            if(!_registeredAliases[object])
+                return;
+
+            for each(var alias:String in  _registeredAliases[object])
+            {
+                _objects[alias] = null;
+                delete _objects[alias];
+            }
+
+            delete _registeredAliases[object];
         }
 
         /**
@@ -165,5 +236,9 @@ package com.pblabs.engine.core
         }
 
         private var _objects:Dictionary = new Dictionary();
+
+        //Map from PBObject -> String[] that contains all registered aliases
+        private var _registeredAliases:Dictionary = new Dictionary();
+
     }
 }

test/src/com/pblabs/PBEngineTestSuite.as

@@ -17,6 +17,7 @@ package com.pblabs
 	import com.pblabs.engine.tests.ResourceTests;
 	import com.pblabs.engine.tests.SanityTests;
 	import com.pblabs.engine.tests.UtilTests;
+    import com.pblabs.engine.tests.RegisterAliasTests;
 	import com.pblabs.rendering2D.tests.Rendering2DTests;
 
 	/**
@@ -39,5 +40,6 @@ package com.pblabs
 		public var inputTests:InputTests;
         public var entityRegistrationTests:EntityRegistrationTests;
         public var groupAndSetTests:GroupAndSetTests;
+        public var registerAliasTests:RegisterAliasTests;
 	}
 }

test/src/com/pblabs/engine/tests/RegisterAliasTests.as

@@ -0,0 +1,54 @@
+package com.pblabs.engine.tests
+{
+    import com.pblabs.engine.PBE;
+    import com.pblabs.engine.entity.IEntity;
+    import com.pblabs.engine.entity.allocateEntity;
+
+    import flexunit.framework.Assert;
+
+    import mx.core.UIComponent;
+
+    import org.fluint.uiImpersonation.UIImpersonator;
+
+    /**
+     * Unit test for registerAlias and unregisterAlias functionality on NameManager 
+     **/
+    public class RegisterAliasTests
+    {		
+
+
+        [Test]
+        public function testRegisterAlias():void{
+            var entity:IEntity = allocateEntity();
+            entity.initialize("testEntity");
+
+            Assert.assertNull(PBE.nameManager.lookup("testAlias"));
+
+            //Register the alias and check if lookups work ok
+            PBE.nameManager.registerAlias(entity, "testAlias");
+            PBE.nameManager.registerAlias(entity, "testAlias2");
+            Assert.assertEquals(entity, PBE.nameManager.lookup("testAlias"));
+            Assert.assertEquals(entity, PBE.nameManager.lookup("testAlias2"));
+
+            //Unregister the alias
+            PBE.nameManager.unregisterAlias(entity, "testAlias");
+            Assert.assertNull(PBE.nameManager.lookup("testAlias"));
+            Assert.assertEquals(entity, PBE.nameManager.lookup("testAlias2"));
+            PBE.nameManager.unregisterAlias(entity, "testAlias2");
+            Assert.assertNull(PBE.nameManager.lookup("testAlias2"));
+
+            //Try to unregister the entityname, this should not remove the entity registration
+            PBE.nameManager.unregisterAlias(entity, "testEntity");
+            Assert.assertEquals(entity, PBE.nameManager.lookup("testEntity"));
+
+            //Re-register the alias and destroy the entity
+            PBE.nameManager.registerAlias(entity, "testAlias");
+            PBE.nameManager.registerAlias(entity, "testAlias2");
+            Assert.assertEquals(entity, PBE.nameManager.lookup("testAlias"));   
+            Assert.assertEquals(entity, PBE.nameManager.lookup("testAlias2"));            
+            entity.destroy();
+            Assert.assertNull(PBE.nameManager.lookup("testAlias"));
+            Assert.assertNull(PBE.nameManager.lookup("testAlias2"));    
+        }    
+    }
+}