Ticket #4046: EntityMapForComponents.2.patch

source/simulation2/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);
         }

source/simulation2/system/ComponentManager.h

@@ -26 +26 @@
 
 #include <boost/random/linear_congruential.hpp>
 #include <boost/unordered_map.hpp>
-
 #include <map>
 
 class IComponent;
@@ -35 +34 @@
 class CSimContext;
 class CDynamicSubscription;
 
+template <class U>
+class GlobalEntityMap;
+
 class CComponentManager
 {
     NONCOPYABLE(CComponentManager);
@@ -355 +357 @@
     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;

source/simulation2/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;
@@ -109 +110 @@
     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 +119 @@
 
         // 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 +134 @@
 
         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 +189 @@
     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 +200 @@
     {
         // 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 +239 @@
 
         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 +266 @@
 
         // 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 +279 @@
         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)

source/simulation2/system/EntityMap.h

@@ -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>.
@@ -43 +45 @@
     };
     typedef key_val<entity_id_t, T> value_type;
 
-private:
+protected:
     size_t m_BufferSize;        // number of elements in the buffer
     size_t m_BufferCapacity;    // capacity of the buffer
     value_type* m_Buffer;       // vector with all the mapped key-value pairs
@@ -210 +212 @@
     }
 
     // Operations
+    inline iterator operator[](const entity_id_t key)
+    {
+        return m_Buffer + key;
+    };
+    inline const_iterator operator[](const entity_id_t key) const
+    {
+        return m_Buffer + key;
+    };
     inline iterator find(const entity_id_t key)
     {
         if (key < m_BufferSize) // is this key in the range of existing entitites?
         {
             value_type* ptr = m_Buffer + key;
-            if (ptr->first != INVALID_ENTITY)
-                return ptr;
+        if (ptr->first != INVALID_ENTITY)
+            return ptr;
         }
         return m_Buffer + m_BufferSize; // return iterator end()
     }
@@ -225 +235 @@
         if (key < m_BufferSize) // is this key in the range of existing entitites?
         {
             const value_type* ptr = m_Buffer + key;
-            if (ptr->first != INVALID_ENTITY)
-                return ptr;
+        if (ptr->first != INVALID_ENTITY)
+            return ptr;
         }
         return m_Buffer + m_BufferSize; // return iterator end()
     }
@@ -278 +288 @@
     }
 };
 
+template<class T>
+class GlobalEntityMap : public EntityMap<T>
+{
+protected:
+    // Variants for local entities
+    size_t m_LocalBufferSize;       // number of elements in the buffer
+    size_t m_LocalBufferCapacity;   // capacity of the buffer
+    value_type* m_LocalBuffer;      // vector with all the mapped key-value pairs
+    size_t m_LocalCount;                // number of 'valid' entity id's
 
+public:
+
+    inline GlobalEntityMap() : m_LocalBufferSize(1), m_LocalBufferCapacity(4096), m_LocalCount(0)
+    {
+        m_LocalBuffer = (value_type*)malloc(sizeof(value_type) * (m_LocalBufferCapacity + 1));
+
+        // create the first element:
+        m_LocalBuffer[0].first = INVALID_ENTITY;
+        m_LocalBuffer[1].first = 0xFFFFFFFF; // ensure end() always has 0xFFFFFFFF
+    }
+    inline ~GlobalEntityMap()
+    {
+        free(m_LocalBuffer);
+    }
+
+    // Iterators
+    template<class U, class V> struct _iter : public std::iterator<std::forward_iterator_tag, U>
+    {
+    private:
+        inline _iter(U* init) : val(init) {}
+    public:
+        V* const map;
+        U* val;
+        inline U& operator*() { return *val; }
+        inline U* operator->() { return val; }
+        inline _iter(V* const init, U* ival) : map(init), val(ival) {}
+
+        inline _iter& operator++()// ++it
+        {
+            ++val;
+            // skip any invalid entities, jump to local
+            while (val->first == INVALID_ENTITY) ++val;
+            if (val->first == 0xFFFFFFFF && val == &*map->normalEnd())
+                val = &*(map->localBegin());
+            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->first == 0xFFFFFFFF && val == &*map->normalEnd())
+                val = &*map->localBegin();
+            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>() const { return _iter<U const, V const>(map, val); }
+    };
+
+    typedef _iter<value_type, GlobalEntityMap> iterator;
+    typedef _iter<value_type const, GlobalEntityMap const> const_iterator;
+
+    inline iterator begin()
+    {
+        auto iter = EntityMap::begin();
+        if (iter->first == 0xFFFFFFFF)
+            return localBegin();
+        return iterator(this, &*iter);
+    }
+    inline iterator localBegin()
+    {
+        value_type* ptr = m_LocalBuffer + 1; // skip the first INVALID_ENTITY
+        while (ptr->first == INVALID_ENTITY) ++ptr; // skip any other invalid entities
+        return iterator(this, ptr);
+    }
+    inline iterator end()
+    {
+        return iterator(this, m_LocalBuffer + m_LocalBufferSize);
+    }
+    inline iterator normalEnd()
+    {
+        return iterator(this, &*EntityMap::end());
+    }
+    inline const_iterator begin() const
+    {
+        auto iter = EntityMap::begin();
+        if (iter->first == 0xFFFFFFFF)
+            return localBegin();
+        return const_iterator(this, &*iter);
+    }
+    inline const_iterator localBegin() const
+    {
+        value_type* ptr = m_LocalBuffer + 1; // skip the first INVALID_ENTITY
+        while (ptr->first == INVALID_ENTITY) ++ptr; // skip any other invalid entities
+        return const_iterator(this, ptr);
+    }
+    inline const_iterator end() const
+    {
+        return const_iterator(this, m_LocalBuffer + m_LocalBufferSize);
+    }
+    inline const_iterator normalEnd() const
+    {
+        return const_iterator(this, &*EntityMap::end());
+    }
+
+    // Size
+    inline bool localEmpty() const { return m_LocalCount == 0; }
+    inline size_t localSize() const { return m_LocalCount; }
+
+    // Modification
+    void insert(const key_type actual_key, const mapped_type& value)
+    {
+        if (actual_key < ENTITY_TAGMASK)
+        {
+            EntityMap::insert(actual_key, value);
+            return;
+        }
+        key_type key = actual_key & ~ENTITY_TAGMASK;
+        if (key>= m_LocalBufferCapacity)
+        {
+            size_t newCapacity = m_LocalBufferCapacity + 4096;
+            while (key >= newCapacity) newCapacity += 4096;
+            // always allocate +1 behind the scenes, because end() must have a 0xFFFFFFFF key
+            value_type* mem = (value_type*)realloc(m_LocalBuffer, sizeof(value_type) * (newCapacity + 1));
+            if (!mem)
+            {
+                debug_warn("GlobalEntityMap::insert() realloc failed! Out of memory.");
+                throw std::bad_alloc(); // fail to expand and insert
+            }
+            m_LocalBufferCapacity = newCapacity;
+            m_LocalBuffer = mem;
+            goto fill_gaps;
+        }
+        else if (key > m_LocalBufferSize) // weird insert far beyond the end
+        {
+fill_gaps:
+            // set all entity id's to INVALID_ENTITY inside the new range
+            for (size_t i = m_LocalBufferSize; i <= key; ++i)
+                m_LocalBuffer[i].first = INVALID_ENTITY;
+            m_LocalBufferSize = key; // extend the new size
+        }
+
+        value_type& item = m_LocalBuffer[key];
+        key_type oldKey = item.first;
+        item.first = key;
+        if (key == m_LocalBufferSize) // push_back
+        {
+            ++m_LocalBufferSize; // expand
+            ++m_Count;
+            ++m_LocalCount;
+            new (&item.second) mapped_type(value); // copy ctor to init
+            m_LocalBuffer[m_LocalBufferSize].first = 0xFFFFFFFF; // ensure end() always has 0xFFFFFFFF
+        }
+        else if (!item.first) // insert new to middle
+        {
+            ++m_Count;
+            ++m_LocalCount;
+            new (&item.second) mapped_type(value); // copy ctor to init
+        }
+        else // set existing value
+        {
+            if (oldKey == INVALID_ENTITY)
+            {
+                ++m_Count;
+                ++m_LocalCount;
+            }
+            item.second = value; // overwrite existing
+        }
+    }
+
+    void erase(iterator it)
+    {
+        if (ptr->first != INVALID_ENTITY && ptr >= m_LocalBuffer && ptr < m_LocalBuffer + m_LocalBufferSize)
+            --m_LocalCount;
+        EntityMap::erase(it);
+    }
+    void erase(const entity_id_t actual_key)
+    {
+        if (actual_key < ENTITY_TAGMASK)
+        {
+            EntityMap::erase(actual_key);
+            return;
+        }
+        key_type key = actual_key & ~ENTITY_TAGMASK;
+        if (key < m_LocalBufferSize)
+        {
+            value_type* ptr = m_LocalBuffer + key;
+            if (ptr->first != INVALID_ENTITY)
+            {
+                ptr->first = INVALID_ENTITY;
+                ptr->second.~T(); // call dtor
+                --m_Count;
+                --m_LocalCount;
+            }
+        }
+    }
+    inline void clear()
+    {
+        EntityMap::clear();
+        // orphan whole range
+        value_type* ptr = m_LocalBuffer;
+        value_type* end = m_LocalBuffer + m_LocalBufferSize;
+        for (; ptr != end; ++ptr)
+        {
+            if (ptr->first != INVALID_ENTITY)
+            {
+                ptr->first = INVALID_ENTITY;
+                ptr->second.~T(); // call dtor
+            }
+        }
+        m_Count = 0;
+        m_LocalCount = 0;
+    }
+
+    // Operations
+    inline iterator operator[](const entity_id_t actual_key)
+    {
+        if (actual_key < ENTITY_TAGMASK)
+            return iterator(this,&*(EntityMap::operator[](actual_key)));
+        key_type key = actual_key & ~ENTITY_TAGMASK;
+        return iterator(this, m_LocalBuffer + key);
+    };
+    inline const_iterator operator[](const entity_id_t actual_key) const
+    {
+        if (actual_key < ENTITY_TAGMASK)
+            return const_iterator(this, &*(EntityMap::operator[](actual_key)));
+        key_type key = actual_key & ~ENTITY_TAGMASK;
+        return const_iterator(this, m_LocalBuffer + key);
+    };
+    inline iterator find(const entity_id_t actual_key)
+    {
+        if (actual_key < ENTITY_TAGMASK)
+            return iterator(this, &*EntityMap::find(actual_key)) == normalEnd() ? end() : iterator(this, &*EntityMap::find(actual_key));
+        key_type key = actual_key & ~ENTITY_TAGMASK;
+
+        value_type* ptr = key < m_LocalBufferSize ? m_LocalBuffer + key : m_LocalBuffer + m_LocalBufferSize;
+        if (ptr->first != INVALID_ENTITY)
+            return iterator(this, ptr);
+        return iterator(this, m_LocalBuffer + m_LocalBufferSize);
+    }
+    inline const_iterator find(const entity_id_t actual_key) const
+    {
+        if (actual_key < ENTITY_TAGMASK)
+            return const_iterator(this, &*EntityMap::find(actual_key)) == normalEnd() ? end() : const_iterator(this, &*EntityMap::find(actual_key));
+        key_type key = actual_key & ~ENTITY_TAGMASK;
+        const value_type* ptr = key < m_LocalBufferSize ? m_LocalBuffer + key : m_LocalBuffer + m_LocalBufferSize;
+        if (ptr->first != INVALID_ENTITY)
+            return const_iterator(this, ptr);
+        return const_iterator(this, m_LocalBuffer + m_LocalBufferSize);
+    }
+    inline size_t count(const entity_id_t actual_key) const
+    {
+        if (actual_key < ENTITY_TAGMASK)
+            return EntityMap::count(actual_key)
+        key_type key = actual_key & ~ENTITY_TAGMASK;
+        if (key < m_LocalBufferSize)
+        {
+            if (m_LocalBuffer[key].first != INVALID_ENTITY)
+                return 1;
+        }
+        return 0;
+    }
+};
+
+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

source/simulation2/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"
+
+class TestGlobalEntityMap : public CxxTest::TestSuite
+{
+    GlobalEntityMap<int* > map;
+    EntityMap<int* > testMap;
+    std::array<int, 6> verif;
+    void setUp()
+    {
+        verif.fill(0);
+        testMap.insert(5, verif.data());
+        testMap.insert(6, verif.data()+1);
+        map.insert(5, verif.data());
+        map.insert(6, verif.data()+1);
+        map.insert(ENTITY_TAGMASK + 5, verif.data() + 2);
+        map.insert(ENTITY_TAGMASK + 6, verif.data() + 3);
+    }
+public:
+    void test_TestEntity()
+    {
+        setUp();
+        TS_ASSERT_EQUALS((int)testMap.size(), 2);
+        TS_ASSERT_EQUALS(map.size(), 4);
+        TS_ASSERT_EQUALS(map.localSize(), 2);
+        
+        TS_ASSERT_EQUALS(map.begin()->second, verif.data());
+        TS_ASSERT_EQUALS(map.normalEnd()->first, 0xFFFFFFFF);
+        TS_ASSERT_EQUALS(testMap.begin()->second, verif.data());
+        TS_ASSERT_EQUALS(testMap.end()->first, 0xFFFFFFFF);
+
+        TS_ASSERT_EQUALS(map.localBegin()->second, verif.data() + 2);
+        TS_ASSERT_EQUALS(map.end()->first, 0xFFFFFFFF);
+
+        int i = 0;
+        auto it = map.begin();
+        for (; it != map.end(); ++it)
+        {
+            TS_ASSERT_EQUALS(&verif[i], it->second);
+            i++;
+        }
+
+        map.erase(5);
+        TS_ASSERT_EQUALS(map.begin()->second, verif.data() + 1);
+
+        map.erase(ENTITY_TAGMASK + 5);
+        TS_ASSERT_EQUALS(map.localBegin()->second, verif.data() + 3);
+
+        map.clear();
+        testMap.clear();
+
+        TS_ASSERT_EQUALS((int)testMap.size(), 0);
+        TS_ASSERT_EQUALS(map.size(), 0);
+        TS_ASSERT_EQUALS(map.localSize(), 0);
+
+        map.insert(ENTITY_TAGMASK + 5, verif.data() + 2);
+        map.insert(ENTITY_TAGMASK + 6, verif.data() + 3);
+
+        TS_ASSERT_EQUALS(map.begin()->second, verif.data() + 2);
+        TS_ASSERT_EQUALS(map.normalEnd()->first, 0xFFFFFFFF);
+
+        TS_ASSERT_EQUALS(map.localBegin()->second, verif.data() + 2);
+        TS_ASSERT_EQUALS(map.end()->first, 0xFFFFFFFF);
+
+        map.insert(1500, verif.data());
+        TS_ASSERT_EQUALS(map.find(1500)->second, verif.data());
+        TS_ASSERT_EQUALS(map[1500]->second, verif.data());
+
+    }
+};