Ticket #4046: EntityMapForComponents.3.patch

system/ComponentManager.cpp

@@ -20 +20 @@
 #include "ComponentManager.h"
 
 #include "DynamicSubscription.h"
+#include "EntityMap.h"
 #include "IComponent.h"
 #include "ParamNode.h"
 #include "SimContext.h"
@@ -305 +306 @@
     {
         // For every script component with this cid, we need to switch its
         // prototype from the old constructor's prototype property to the new one's
-        const std::map<entity_id_t, IComponent*>& comps = componentManager->m_ComponentsByTypeId[cid];
-        std::map<entity_id_t, IComponent*>::const_iterator eit = comps.begin();
+        const GlobalEntityMap<IComponent*>& comps = componentManager->m_ComponentsByTypeId[cid];
+        GlobalEntityMap<IComponent*>::const_iterator eit = comps.begin();
         for (; eit != comps.end(); ++eit)
         {
             JS::RootedValue instance(cx, eit->second->GetJSInstance());
@@ -509 +510 @@
     m_DynamicMessageSubscriptionsNonsyncByComponent.clear();
 
     // Delete all IComponents
-    std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::iterator iit = m_ComponentsByTypeId.begin();
+    std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::iterator iit = m_ComponentsByTypeId.begin();
     for (; iit != m_ComponentsByTypeId.end(); ++iit)
     {
-        std::map<entity_id_t, IComponent*>::iterator eit = iit->second.begin();
+        GlobalEntityMap<IComponent*>::iterator eit = iit->second.begin();
         for (; eit != iit->second.end(); ++eit)
         {
             eit->second->Deinit();
@@ -757 +758 @@
         return NULL;
     }
 
-    std::map<entity_id_t, IComponent*>& emap2 = m_ComponentsByTypeId[cid];
+    GlobalEntityMap<IComponent*>& emap2 = m_ComponentsByTypeId[cid];
 
     // If this is a scripted component, construct the appropriate JS object first
     JS::RootedValue obj(cx);
@@ -780 +781 @@
 
     // Store a reference to the new component
     emap1.insert(std::make_pair(ent.GetId(), component));
-    emap2.insert(std::make_pair(ent.GetId(), component));
+    emap2.insert(ent.GetId(), component);
     // TODO: We need to more careful about this - if an entity is constructed by a component
     // while we're iterating over all components, this will invalidate the iterators and everything
     // will break.
@@ -918 +919 @@
             PostMessage(ent, msg);
 
             // Destroy the components, and remove from m_ComponentsByTypeId:
-            std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::iterator iit = m_ComponentsByTypeId.begin();
+            std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::iterator iit = m_ComponentsByTypeId.begin();
             for (; iit != m_ComponentsByTypeId.end(); ++iit)
             {
-                std::map<entity_id_t, IComponent*>::iterator eit = iit->second.find(ent);
+                GlobalEntityMap<IComponent*>::iterator eit = iit->second.find(ent);
                 if (eit != iit->second.end())
                 {
                     eit->second->Deinit();
@@ -1007 +1008 @@
         for (; ctit != it->second.end(); ++ctit)
         {
             // Find the component instances of this type (if any)
-            std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
+            std::map<ComponentTypeId, GlobalEntityMap< IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
             if (emap == m_ComponentsByTypeId.end())
                 continue;
 
             // Send the message to all of them
-            std::map<entity_id_t, IComponent*>::const_iterator eit = emap->second.find(ent);
+            GlobalEntityMap<IComponent*>::const_iterator eit = emap->second.find(ent);
             if (eit != emap->second.end())
                 eit->second->HandleMessage(msg, false);
         }
@@ -1032 +1033 @@
         for (; ctit != it->second.end(); ++ctit)
         {
             // Find the component instances of this type (if any)
-            std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
+            std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
             if (emap == m_ComponentsByTypeId.end())
                 continue;
 
             // Send the message to all of them
-            std::map<entity_id_t, IComponent*>::const_iterator eit = emap->second.begin();
+            GlobalEntityMap<IComponent*>::const_iterator eit = emap->second.begin();
             for (; eit != emap->second.end(); ++eit)
                 eit->second->HandleMessage(msg, false);
         }
@@ -1069 +1070 @@
             }
 
             // Find the component instances of this type (if any)
-            std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
+            std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::const_iterator emap = m_ComponentsByTypeId.find(*ctit);
             if (emap == m_ComponentsByTypeId.end())
                 continue;
 
             // Send the message to all of them
-            std::map<entity_id_t, IComponent*>::const_iterator eit = emap->second.begin();
+            GlobalEntityMap<IComponent*>::const_iterator eit = emap->second.begin();
             for (; eit != emap->second.end(); ++eit)
                 eit->second->HandleMessage(msg, true);
         }

system/ComponentManager.h

@@ -35 +35 @@
 class CSimContext;
 class CDynamicSubscription;
 
+template <class U>
+class GlobalEntityMap;
+
 class CComponentManager
 {
     NONCOPYABLE(CComponentManager);
@@ -355 +358 @@
     std::map<ComponentTypeId, ComponentType> m_ComponentTypesById;
     std::vector<CComponentManager::ComponentTypeId> m_ScriptedSystemComponents;
     std::vector<boost::unordered_map<entity_id_t, IComponent*> > m_ComponentsByInterface; // indexed by InterfaceId
-    std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> > m_ComponentsByTypeId;
+    std::map<ComponentTypeId, GlobalEntityMap<IComponent*> > m_ComponentsByTypeId;
     std::map<MessageTypeId, std::vector<ComponentTypeId> > m_LocalMessageSubscriptions;
     std::map<MessageTypeId, std::vector<ComponentTypeId> > m_GlobalMessageSubscriptions;
     std::map<std::string, ComponentTypeId> m_ComponentTypeIdsByName;

system/ComponentManagerSerialization.cpp

@@ -18 +18 @@
 #include "precompiled.h"
 
 #include "ComponentManager.h"
+#include "EntityMap.h"
 #include "IComponent.h"
 #include "ParamNode.h"
 
@@ -58 +59 @@
     std::map<entity_id_t, std::map<ComponentTypeId, IComponent*> > components;
     //std::map<ComponentTypeId, std::string> names;
 
-    std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator ctit = m_ComponentsByTypeId.begin();
+    std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::const_iterator ctit = m_ComponentsByTypeId.begin();
     for (; ctit != m_ComponentsByTypeId.end(); ++ctit)
     {
-        std::map<entity_id_t, IComponent*>::const_iterator eit = ctit->second.begin();
+        GlobalEntityMap<IComponent*>::const_iterator eit = ctit->second.begin();
         for (; eit != ctit->second.end(); ++eit)
         {
-            components[eit->first][ctit->first] = eit->second;
+            if (ENTITY_IS_NORMAL(eit->first))
+                components[eit->first][ctit->first] = eit->second;
+            else
+                components[eit->first][ctit->first] = eit->second;
         }
     }
 
@@ -109 +113 @@
     serializer.StringASCII("rng", SerializeRNG(m_RNG), 0, 32);
     serializer.NumberU32_Unbounded("next entity id", m_NextEntityId);
 
-    std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator cit = m_ComponentsByTypeId.begin();
+    std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::const_iterator cit = m_ComponentsByTypeId.begin();
     for (; cit != m_ComponentsByTypeId.end(); ++cit)
     {
         // In quick mode, only check unit positions
@@ -118 +122 @@
 
         // Only emit component types if they have a component that will be serialized
         bool needsSerialization = false;
-        for (std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
+        for (GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
         {
             // Don't serialize local entities
             if (ENTITY_IS_LOCAL(eit->first))
@@ -133 +137 @@
 
         serializer.NumberI32_Unbounded("component type id", cit->first);
 
-        for (std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
+        for (GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
         {
             // Don't serialize local entities
             if (ENTITY_IS_LOCAL(eit->first))
@@ -188 +192 @@
     serializer.StringASCII("rng", SerializeRNG(m_RNG), 0, 32);
     serializer.NumberU32_Unbounded("next entity id", m_NextEntityId);
 
-    std::map<ComponentTypeId, std::map<entity_id_t, IComponent*> >::const_iterator cit;
+    std::map<ComponentTypeId, GlobalEntityMap<IComponent*> >::const_iterator cit;
     
     uint32_t numSystemComponentTypes = 0;
     uint32_t numComponentTypes = 0;
@@ -199 +203 @@
     {
         // Only emit component types if they have a component that will be serialized
         bool needsSerialization = false;
-        for (std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
+        for (GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
         {
             // Don't serialize local entities, and handle SYSTEM_ENTITY separately
             if (ENTITY_IS_LOCAL(eit->first) || eit->first == SYSTEM_ENTITY)
@@ -238 +242 @@
 
         serializer.StringASCII("name", ctit->second.name, 0, 255);
 
-        std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.find(SYSTEM_ENTITY);
+        GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.find(SYSTEM_ENTITY);
         if (eit == cit->second.end())
         {
             debug_warn(L"Invalid eit"); // this should never happen
@@ -265 +269 @@
 
         // Count the components before serializing any of them
         uint32_t numComponents = 0;
-        for (std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
+        for (GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
         {
             // Don't serialize local entities or SYSTEM_ENTITY
             if (ENTITY_IS_LOCAL(eit->first) || eit->first == SYSTEM_ENTITY)
@@ -278 +282 @@
         serializer.NumberU32_Unbounded("num components", numComponents);
 
         // Serialize the components now
-        for (std::map<entity_id_t, IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
+        for (GlobalEntityMap<IComponent*>::const_iterator eit = cit->second.begin(); eit != cit->second.end(); ++eit)
         {
             // Don't serialize local entities or SYSTEM_ENTITY
             if (ENTITY_IS_LOCAL(eit->first) || eit->first == SYSTEM_ENTITY)

system/EntityMap.h

@@ -1 @@
-/* Copyright (C) 2013 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -18 +18 @@
 #define INCLUDED_ENTITYMAP
 
 #include "Entity.h"
+#include "simulation2/serialization/ISerializer.h"
+#include "simulation2/serialization/IDeserializer.h"
 
 /**
  * A fast replacement for map<entity_id_t, T>.
@@ -48 +50 @@
     size_t m_BufferCapacity;    // capacity of the buffer
     value_type* m_Buffer;       // vector with all the mapped key-value pairs
 
+    size_t m_FirstEntityID;     // real ID of the [0] in the buffer, so we can offset.
     size_t m_Count;             // number of 'valid' entity id's
 
 public:
 
-    inline EntityMap() : m_BufferSize(1), m_BufferCapacity(4096), m_Count(0)
+    inline EntityMap() : m_BufferSize(0), m_BufferCapacity(4096), m_Count(0), m_FirstEntityID(1)
     {
         // for entitymap we allocate the buffer right away
         // with first element in buffer being the Invalid Entity
         m_Buffer = (value_type*)malloc(sizeof(value_type) * (m_BufferCapacity + 1));
 
-        // create the first element:
-        m_Buffer[0].first = INVALID_ENTITY;
-        m_Buffer[1].first = 0xFFFFFFFF; // ensure end() always has 0xFFFFFFFF
+        m_Buffer[0].first = 0xFFFFFFFF; // ensure end() always has 0xFFFFFFFF
     }
+    inline EntityMap(size_t ID) : EntityMap()
+    {
+        m_FirstEntityID = ID;
+    }
+
     inline ~EntityMap()
     {
         free(m_Buffer);
@@ -97 +103 @@
 
     inline iterator begin()
     {
-        value_type* ptr = m_Buffer + 1; // skip the first INVALID_ENTITY
+        value_type* ptr = m_Buffer;
         while (ptr->first == INVALID_ENTITY) ++ptr; // skip any other invalid entities
         return ptr;
     }
@@ -107 +113 @@
     }
     inline const_iterator begin() const
     {
-        value_type* ptr = m_Buffer + 1; // skip the first INVALID_ENTITY
+        value_type* ptr = m_Buffer;
         while (ptr->first == INVALID_ENTITY) ++ptr; // skip any other invalid entities
         return ptr;
     }
@@ -121 +127 @@
     inline size_t size() const { return m_Count; }
 
     // Modification
-    void insert(const key_type key, const mapped_type& value)
+    void insert(const key_type actual_key, const mapped_type& value)
     {
+        key_type key = actual_key - m_FirstEntityID;
         if (key >= m_BufferCapacity) // do we need to resize buffer?
         {
             size_t newCapacity = m_BufferCapacity + 4096;
@@ -143 +150 @@
 fill_gaps:
             // set all entity id's to INVALID_ENTITY inside the new range
             for (size_t i = m_BufferSize; i <= key; ++i)
+            {
                 m_Buffer[i].first = INVALID_ENTITY;
+                new (&m_Buffer[i].second) mapped_type();
+            }
             m_BufferSize = key; // extend the new size
         }
 
         value_type& item = m_Buffer[key];
         key_type oldKey = item.first;
-        item.first = key;
+        item.first = actual_key;
         if (key == m_BufferSize) // push_back
         {
             ++m_BufferSize; // expand
@@ -157 +167 @@
             new (&item.second) mapped_type(value); // copy ctor to init
             m_Buffer[m_BufferSize].first = 0xFFFFFFFF; // ensure end() always has 0xFFFFFFFF
         }
-        else if(!item.first) // insert new to middle
-        {
-            ++m_Count;
-            new (&item.second) mapped_type(value); // copy ctor to init
-        }
         else // set existing value
         {
             if (oldKey == INVALID_ENTITY)
                 m_Count++;
-            item.second = value; // overwrite existing
+            item.second = value;
         }
     }
     
@@ -182 +187 @@
     }
     void erase(const entity_id_t key)
     {
-        if (key < m_BufferSize)
+        if (key - m_FirstEntityID < m_BufferSize)
         {
-            value_type* ptr = m_Buffer + key;
+            value_type* ptr = m_Buffer + key - m_FirstEntityID;
             if (ptr->first != INVALID_ENTITY)
             {
                 ptr->first = INVALID_ENTITY;
@@ -210 +215 @@
     }
 
     // Operations
+    inline iterator operator[](const entity_id_t key)
+    {
+        return m_Buffer + key - m_FirstEntityID;
+    };
+    inline const_iterator operator[](const entity_id_t key) const
+    {
+        return m_Buffer + key - m_FirstEntityID;
+    };
     inline iterator find(const entity_id_t key)
     {
-        if (key < m_BufferSize) // is this key in the range of existing entitites?
+        if (key - m_FirstEntityID >= 0 && key - m_FirstEntityID < m_BufferSize) // is this key in the range of existing entitites?
         {
-            value_type* ptr = m_Buffer + key;
+            value_type* ptr = m_Buffer + key - m_FirstEntityID;
             if (ptr->first != INVALID_ENTITY)
                 return ptr;
         }
@@ -222 +235 @@
     }
     inline const_iterator find(const entity_id_t key) const
     {
-        if (key < m_BufferSize) // is this key in the range of existing entitites?
+        if (key - m_FirstEntityID >= 0 && key - m_FirstEntityID < m_BufferSize) // is this key in the range of existing entitites?
         {
-            const value_type* ptr = m_Buffer + key;
+            const value_type* ptr = m_Buffer + key - m_FirstEntityID;
             if (ptr->first != INVALID_ENTITY)
                 return ptr;
         }
@@ -232 +245 @@
     }
     inline size_t count(const entity_id_t key) const
     {
-        if (key < m_BufferSize)
+        if (key - m_FirstEntityID >= 0 && key - m_FirstEntityID < m_BufferSize)
         {
-            if (m_Buffer[key].first != INVALID_ENTITY)
+            if (m_Buffer[key - m_FirstEntityID].first != INVALID_ENTITY)
                 return 1;
         }
         return 0;
@@ -278 +291 @@
     }
 };
 
+//Implements the same interface as EntityMap but uses two internally to separate local entities
+template<class T>
+class GlobalEntityMap
+{
+protected:
 
+public:
+    EntityMap<T> m_Entities;
+    EntityMap<T> m_LocalEntities;
+
+    inline GlobalEntityMap() : m_LocalEntities(ENTITY_TAGMASK) {}
+    
+    typedef typename EntityMap<T>::mapped_type mapped_type;
+    typedef typename EntityMap<T>::key_type key_type;
+    typedef typename EntityMap<T>::value_type value_type;
+
+    // iterator aware of GlobalEntityMap to jump between the two vectors
+    template<class U, class V, class W> struct _iter : public std::iterator<std::forward_iterator_tag, U>
+    {
+        U* val;
+        V* orig;
+        inline _iter(V* mapInit) : orig(mapInit), val(orig.begin()) {}
+        inline _iter(V* mapInit, U* init) : orig(mapInit), val(init) {}
+        inline _iter(V* mapInit, W& init) : orig(mapInit), val(&*init) {}
+        inline U& operator*() { return *val; }
+        inline U* operator->() { return val; }
+        inline _iter& operator++() // ++it
+        {
+            ++val;
+            while (val->first == INVALID_ENTITY) ++val;
+            auto end = &*orig->m_Entities.end();
+            auto toto = &*orig->m_LocalEntities.begin();
+            auto realtoto = &*orig->m_LocalEntities.end();
+            if (val == &*orig->m_Entities.end())
+                val = &*orig->m_LocalEntities.begin();
+            while (val->first == INVALID_ENTITY) ++val;
+            return *this;
+        }
+        inline _iter& operator++(int) // it++
+        {
+            U* ptr = val;
+            ++val;
+            while (val->first == INVALID_ENTITY) ++val; // skip any invalid entities
+            if (val == &*orig->m_Entities.end())
+                val = &*orig->m_LocalEntities.begin();
+            while (val->first == INVALID_ENTITY) ++val;
+            return ptr;
+        }
+        inline bool operator==(_iter other) { return val == other.val; }
+        inline bool operator!=(_iter other) { return val != other.val; }
+        inline operator _iter<U const, V const, W const>() const { return _iter<U const, V const, W const>(orig, val); }
+    };
+
+    typedef _iter<value_type, GlobalEntityMap, typename EntityMap<T>::iterator> iterator;
+    typedef _iter<value_type const, GlobalEntityMap const, typename EntityMap<T>::const_iterator> const_iterator;
+
+    inline iterator begin()
+    {
+        if (m_Entities.empty())
+            return iterator(this, m_LocalEntities.begin());
+        return iterator(this, m_Entities.begin());
+    }
+    inline iterator end()
+    {
+        return iterator(this, m_LocalEntities.end());
+    }
+    inline const_iterator begin() const
+    {
+        if (m_Entities.empty())
+            return const_iterator(this, m_LocalEntities.begin());
+        return const_iterator(this, m_Entities.begin());
+    }
+    inline const_iterator end() const
+    {
+        return const_iterator(this, m_LocalEntities.end());
+    }
+
+    // Size
+    inline bool empty() const { return m_Entities.empty() && m_LocalEntities.empty(); }
+    inline size_t size() const { return m_Entities.size() + m_LocalEntities.size(); }
+
+    // Modification
+    void insert(const key_type key, const mapped_type& value)
+    {
+        if (key < ENTITY_TAGMASK)
+            m_Entities.insert(key, value);
+        else
+            m_LocalEntities.insert(key, value);
+    }
+
+    void erase(iterator it)
+    {
+        if ((*it)->first < ENTITY_TAGMASK)
+            m_Entities.erase(it);
+        else
+            m_LocalEntities.erase(it);
+    }
+    void erase(const entity_id_t key)
+    {
+        if (key < ENTITY_TAGMASK)
+            m_Entities.erase(key);
+        else
+            m_LocalEntities.erase(key);
+    }
+    inline void clear()
+    {
+        m_Entities.clear();
+        m_LocalEntities.clear();
+    }
+
+    // Operations
+    inline iterator operator[](const entity_id_t key)
+    {
+        if (key < ENTITY_TAGMASK)
+            return iterator(this, m_Entities[key]);
+        else
+            return iterator(this, m_LocalEntities[key]);
+    };
+    inline const_iterator operator[](const entity_id_t key) const
+    {
+        if (key < ENTITY_TAGMASK)
+            return const_iterator(this, m_Entities[key]);
+        else
+            return const_iterator(this, m_LocalEntities[key]);
+    };
+    inline iterator find(const entity_id_t key)
+    {
+        if (key < ENTITY_TAGMASK)
+        {
+            iterator ret(this, m_Entities.find(key));
+            if (&*ret == &*m_Entities.end())
+                return end();
+            return ret;
+        }
+        else
+            return iterator(this, m_LocalEntities.find(key));
+    }
+    inline const_iterator find(const entity_id_t key) const
+    {
+        if (key < ENTITY_TAGMASK)
+        {
+            const_iterator ret(this, m_Entities.find(key));
+            if (&*ret == &*m_Entities.end())
+                return end();
+            return ret;
+        }
+        else
+            return const_iterator(this, m_LocalEntities.find(key));
+    }
+    inline size_t count(const entity_id_t key) const
+    {
+        if (key < ENTITY_TAGMASK)
+            return m_Entities.count(key);
+        else
+            return m_LocalEntities.count(key);
+    }
+};
+
+template<class VSerializer>
+struct SerializeGlobalEntityMap
+{
+    template<class V>
+    void operator()(ISerializer& serialize, const char* UNUSED(name), GlobalEntityMap<V>& value)
+    {
+        size_t len = value.size();
+        serialize.NumberU32_Unbounded("length", (u32)len);
+        size_t locallen = value.localSize();
+        serialize.NumberU32_Unbounded("localLength", (u32)locallen);
+        size_t count = 0;
+        for (typename EntityMap<V>::iterator it = value.begin(); it != value.end(); ++it)
+        {
+            serialize.NumberU32_Unbounded("key", it->first);
+            VSerializer()(serialize, "value", it->second);
+            count++;
+        }
+        // test to see if the entityMap count wasn't wrong 
+        // (which causes a crashing deserialisation)
+        ENSURE(count == len);
+    }
+
+    template<class V>
+    void operator()(IDeserializer& deserialize, const char* UNUSED(name), GlobalEntityMap<V>& value)
+    {
+        value.clear();
+        uint32_t len, locallen;
+        deserialize.NumberU32_Unbounded("length", len);
+        deserialize.NumberU32_Unbounded("localLength", locallen);
+        for (size_t i = 0; i < len; ++i)
+        {
+            entity_id_t k;
+            V v;
+            deserialize.NumberU32_Unbounded("key", k);
+            VSerializer()(deserialize, "value", v);
+            if (i >= len - locallen)
+                k = k | ENTITY_TAGMASK;
+            value.insert(k, v);
+        }
+    }
+};
+
 #endif

tests/test_EntityMap.h

@@ +1 @@
+/* Copyright (C) 2016 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "lib/self_test.h"
+
+#include <array>
+#include "simulation2/system/EntityMap.h"
+
+#include <iostream>
+
+// Test the EntityMap container using the GlobalEntityMap, which uses EntityMap internally.
+class TestEntityMap : public CxxTest::TestSuite
+{
+    GlobalEntityMap<int* > map;
+    std::vector<int> verif;
+
+    void clear()
+    {
+        map.clear();
+        verif.clear();
+    }
+public:
+    void test_TestClear()
+    {
+        for (size_t i = 1; i <= 20; ++i)
+            map.insert(i, verif.data());
+        map.clear();
+        TS_ASSERT_EQUALS(map.size(), 0);
+        TS_ASSERT_EQUALS(map.begin(), map.end())
+    }
+        
+    void test_TestInsert()
+    {
+        clear();
+        // insert items in key positions and verify they are retrieved correctly
+        // I don't actually care about the values, so store pointers in the EntityMap
+        verif = std::vector<int>(20);
+        
+        for (size_t i = 1; i <= 20; ++i)
+            map.insert(i, verif.data() + i);
+
+        TS_ASSERT_EQUALS(map.size(), 20);
+
+        for (size_t i = 1; i <= 20; ++i)
+            TS_ASSERT_EQUALS(map[i]->second, verif.data() + i);
+
+        map.insert(1, verif.data());
+        map.insert(5, verif.data() + 1);
+        map.insert(1500, verif.data() + 2);
+
+        TS_ASSERT_EQUALS(map[1]->second, verif.data());
+        TS_ASSERT_EQUALS(map[5]->second, verif.data()+1);
+        TS_ASSERT_EQUALS(map[1500]->second, verif.data()+2);
+
+        // check that we properly pad
+        TS_ASSERT_EQUALS(map[1300]->first, INVALID_ENTITY);
+    }
+    void test_TestLargeInsert()
+    {
+        clear();
+        verif = std::vector<int>(21);
+
+        for (size_t i = 1; i <= 10; ++i)
+            map.insert(i, verif.data() + i);
+
+        for (size_t i = 11; i <= 20; ++i)
+            map.insert(i + ENTITY_TAGMASK, verif.data() + i);
+
+        TS_ASSERT_EQUALS(map.size(), 20);
+
+        for (size_t i = 1; i <= 10; ++i)
+            TS_ASSERT_EQUALS(map[i]->second, verif.data() + i);
+        for (size_t i = 11; i <= 20; ++i)
+            TS_ASSERT_EQUALS(map[i+ENTITY_TAGMASK]->second, verif.data() + i);
+    }
+    void test_TestIter()
+    {
+        clear();
+        
+        // verify the returned iterators
+        verif = std::vector<int>(20);
+
+        for (size_t i = 1; i < 10; i++)
+            map.insert(i, verif.data() + i-1);
+        for (size_t i = 10; i < 20; i++)
+            map.insert(i + ENTITY_TAGMASK, verif.data() + i - 1);
+
+        TS_ASSERT_EQUALS(map.begin()->second, verif.data());
+        TS_ASSERT_EQUALS(map.end()->first, 0xFFFFFFFF);
+
+        size_t i = 0;
+        auto it = map.begin();
+        for (; it != map.end(); ++it)
+        {
+            TS_ASSERT_EQUALS(it->second, verif.data() + i);
+            i++;
+        }
+        TS_ASSERT_EQUALS(i, map.size())
+    }
+    void test_TestID()
+    {
+        clear();
+        verif = std::vector<int>(20);
+
+        for (size_t i = 1; i <= 10; ++i)
+            map.insert(i, verif.data());
+
+        for (size_t i = 11; i <= 20; ++i)
+            map.insert(i + ENTITY_TAGMASK, verif.data());
+
+        TS_ASSERT_EQUALS(map.begin()->second, verif.data());
+        TS_ASSERT_EQUALS(map.end()->first, 0xFFFFFFFF);
+
+        size_t i = 1;
+        auto it = map.begin();
+        for (; it != map.end(); ++it)
+        {
+            TS_ASSERT_EQUALS(it->first, i);
+            i++;
+            if (i == 11)
+                i += ENTITY_TAGMASK;
+        }
+    }
+    void test_TestFind()
+    {
+        clear();
+        verif = std::vector<int>(20);
+
+        map.insert(5, verif.data());
+        map.insert(10, verif.data()+5);
+        map.insert(50, verif.data() + 1);
+        map.insert(ENTITY_TAGMASK + 5, verif.data()+2);
+        map.insert(ENTITY_TAGMASK + 50, verif.data()+3);
+
+        TS_ASSERT_EQUALS(map.find(5)->second, verif.data());
+        TS_ASSERT_EQUALS(map[5]->second, verif.data());
+        TS_ASSERT_EQUALS(map.find(50)->second, verif.data()+1);
+        TS_ASSERT_EQUALS(map[50]->second, verif.data()+1);
+        TS_ASSERT_EQUALS(map.find(40), map.end());
+        TS_ASSERT_EQUALS(map[40]->first, INVALID_ENTITY);
+
+        TS_ASSERT_EQUALS(map.find(5 + ENTITY_TAGMASK)->second, verif.data()+2);
+        TS_ASSERT_EQUALS(map[5 + ENTITY_TAGMASK]->second, verif.data()+2);
+        TS_ASSERT_EQUALS(map.find(50 + ENTITY_TAGMASK)->second, verif.data()+3);
+        TS_ASSERT_EQUALS(map[50 + ENTITY_TAGMASK]->second, verif.data()+3);
+        TS_ASSERT_EQUALS(map.find(40 + ENTITY_TAGMASK), map.end());
+        TS_ASSERT_EQUALS(map[40 + ENTITY_TAGMASK]->first, INVALID_ENTITY);
+
+
+        TS_ASSERT_EQUALS(map.find(-5), map.end());
+    }
+
+    void test_TestErase()
+    {
+        clear();
+        verif = std::vector<int>(21);
+
+        for (size_t i = 1; i <= 10; ++i)
+            map.insert(i, verif.data() + i);
+
+        for (size_t i = 11; i <= 20; ++i)
+            map.insert(i + ENTITY_TAGMASK, verif.data() + i);
+
+        map.erase(5);
+        map.erase(6);
+        map.erase(5);
+        map.erase(5 + ENTITY_TAGMASK);
+
+        TS_ASSERT_EQUALS(map[5]->first, INVALID_ENTITY);
+        TS_ASSERT_EQUALS(map[6]->first, INVALID_ENTITY);
+        TS_ASSERT_EQUALS(map[5 + ENTITY_TAGMASK]->first, INVALID_ENTITY);
+        TS_ASSERT_EQUALS(map.find(5), map.end());
+    }
+};