Core/Grids: Modernize TypeContainer with variadic template

(cherry picked from commit 401502ea3c5ceca0c6253910035b2949e13746cc)

8 files changed, 119 insertions, 418 deletions

diff --git a/src/server/game/Grids/Dynamic/TypeContainer.h b/src/server/game/Grids/Dynamic/TypeContainer.h
index f1d57735cef..38198bce3a5 100644
--- a/src/server/game/Grids/Dynamic/TypeContainer.h
+++ b/src/server/game/Grids/Dynamic/TypeContainer.h
@@ -23,203 +23,71 @@
  * types of object at the same time.
  */
 
-#include <unordered_map>
 #include "Define.h"
-#include "Dynamic/TypeList.h"
-#include "GridRefManager.h"
+#include <type_traits>
 
-/*
- * @class ContainerMapList is a mulit-type container for map elements
- * By itself its meaningless but collaborate along with TypeContainers,
- * it become the most powerfully container in the whole system.
- */
-template<class OBJECT>
-struct ContainerMapList
-{
-    GridRefManager<OBJECT> _element;
-};
-
-template<>
-struct ContainerMapList<TypeNull>                /* nothing is in type null */
-{
-};
-
-template<class H, class T>
-struct ContainerMapList<TypeList<H, T> >
+template <template <typename> typename UnderlyingContainer, typename... Types>
+struct TypeListContainerStorage
 {
-    ContainerMapList<H> _elements;
-    ContainerMapList<T> _TailElements;
+    // empty case
 };
 
-template<class OBJECT, class KEY_TYPE>
-struct ContainerUnorderedMap
-{
-    std::unordered_map<KEY_TYPE, OBJECT*> _element;
-};
-
-template<class KEY_TYPE>
-struct ContainerUnorderedMap<TypeNull, KEY_TYPE>
-{
-};
-
-template<class H, class T, class KEY_TYPE>
-struct ContainerUnorderedMap<TypeList<H, T>, KEY_TYPE>
-{
-    ContainerUnorderedMap<H, KEY_TYPE> _elements;
-    ContainerUnorderedMap<T, KEY_TYPE> _TailElements;
+template <template <typename> typename UnderlyingContainer, typename First, typename... Rest>
+struct TypeListContainerStorage<UnderlyingContainer, First, Rest...>
+{
+    typename UnderlyingContainer<First>::Container Head;
+    TypeListContainerStorage<UnderlyingContainer, Rest...> Tail;
+
+    template <typename ObjectType>
+    typename UnderlyingContainer<ObjectType>::Container& FindContainer()
+    {
+        if constexpr (std::is_same_v<First, ObjectType>)
+            return Head;
+        else
+            return Tail.template FindContainer<ObjectType>();
+    }
+
+    template <typename ObjectType>
+    typename UnderlyingContainer<ObjectType>::Container const& FindContainer() const
+    {
+        if constexpr (std::is_same_v<First, ObjectType>)
+            return Head;
+        else
+            return Tail.template FindContainer<ObjectType>();
+    }
 };
 
-#include "TypeContainerFunctions.h"
-
-/*
- * @class TypeMapContainer contains a fixed number of types and is
- * determined at compile time.  This is probably the most complicated
- * class and do its simplest thing, that is, holds objects
- * of different types.
- */
-
-template<class OBJECT_TYPES>
-class TypeMapContainer
-{
-public:
-    TypeMapContainer();
-    TypeMapContainer(TypeMapContainer const&) = default;
-    TypeMapContainer(TypeMapContainer&&) noexcept = default;
-    TypeMapContainer& operator=(TypeMapContainer const&) = default;
-    TypeMapContainer& operator=(TypeMapContainer&&) noexcept = default;
-    ~TypeMapContainer();
-
-    template<class SPECIFIC_TYPE>
-    size_t Count() const;
-
-    /// inserts a specific object into the container
-    template<class SPECIFIC_TYPE>
-    bool insert(SPECIFIC_TYPE *obj);
-
-    ///  Removes the object from the container, and returns the removed object
-    //template<class SPECIFIC_TYPE>
-    //bool remove(SPECIFIC_TYPE* obj)
-    //{
-    //    SPECIFIC_TYPE* t = Trinity::Remove(i_elements, obj);
-    //    return (t != nullptr);
-    //}
-
-    ContainerMapList<OBJECT_TYPES>& GetElements(void);
-    const ContainerMapList<OBJECT_TYPES>& GetElements(void) const;
-
-private:
-    ContainerMapList<OBJECT_TYPES> i_elements;
-};
-
-template <class OBJECT_TYPES>
-TypeMapContainer<OBJECT_TYPES>::TypeMapContainer() = default;
-
-template <class OBJECT_TYPES>
-TypeMapContainer<OBJECT_TYPES>::~TypeMapContainer() = default;
-
-template <class OBJECT_TYPES>
-template <class SPECIFIC_TYPE>
-size_t TypeMapContainer<OBJECT_TYPES>::Count() const
-{
-    return Trinity::Count(i_elements, (SPECIFIC_TYPE*)nullptr);
-}
-
-template <class OBJECT_TYPES>
-template <class SPECIFIC_TYPE>
-bool TypeMapContainer<OBJECT_TYPES>::insert(SPECIFIC_TYPE* obj)
-{
-    SPECIFIC_TYPE* t = Trinity::Insert(i_elements, obj);
-    return (t != nullptr);
-}
-
-template <class OBJECT_TYPES>
-ContainerMapList<OBJECT_TYPES>& TypeMapContainer<OBJECT_TYPES>::GetElements()
-{
-    return i_elements;
-}
-
-template <class OBJECT_TYPES>
-const ContainerMapList<OBJECT_TYPES>& TypeMapContainer<OBJECT_TYPES>::GetElements() const
-{
-    return i_elements;
-}
-
-template<class OBJECT_TYPES, class KEY_TYPE>
-class TypeUnorderedMapContainer
-{
-public:
-    TypeUnorderedMapContainer();
-    TypeUnorderedMapContainer(TypeUnorderedMapContainer const&) = default;
-    TypeUnorderedMapContainer(TypeUnorderedMapContainer&&) noexcept = default;
-    TypeUnorderedMapContainer& operator=(TypeUnorderedMapContainer const&) = default;
-    TypeUnorderedMapContainer& operator=(TypeUnorderedMapContainer&&) noexcept = default;
-    ~TypeUnorderedMapContainer();
-
-    template<class SPECIFIC_TYPE>
-    bool Insert(KEY_TYPE const& handle, SPECIFIC_TYPE* obj);
-
-    template<class SPECIFIC_TYPE>
-    bool Remove(KEY_TYPE const& handle);
-
-    template<class SPECIFIC_TYPE>
-    SPECIFIC_TYPE* Find(KEY_TYPE const& handle);
-
-    template<class SPECIFIC_TYPE>
-    std::size_t Size() const;
-
-    ContainerUnorderedMap<OBJECT_TYPES, KEY_TYPE>& GetElements();
-    ContainerUnorderedMap<OBJECT_TYPES, KEY_TYPE> const& GetElements() const;
-
-private:
-    ContainerUnorderedMap<OBJECT_TYPES, KEY_TYPE> _elements;
+template <template <typename> typename UnderlyingContainer, typename... Types>
+struct TypeListContainer
+{
+    TypeListContainerStorage<UnderlyingContainer, Types...> Data;
+
+    template <typename ObjectType>
+    static constexpr bool TypeExists = std::disjunction_v<std::is_same<ObjectType, Types>...>;
+
+    template <typename ObjectType> requires TypeExists<ObjectType>
+    bool Insert(ObjectType* object)
+    {
+        return UnderlyingContainer<ObjectType>::Insert(Data.template FindContainer<ObjectType>(), object);
+    }
+
+    template <typename ObjectType> requires TypeExists<ObjectType>
+    bool Remove(ObjectType* object)
+    {
+        return UnderlyingContainer<ObjectType>::Remove(Data.template FindContainer<ObjectType>(), object);
+    }
+
+    template <typename ObjectType> requires TypeExists<ObjectType>
+    bool Size() const
+    {
+        return UnderlyingContainer<ObjectType>::Size(Data.template FindContainer<ObjectType>());
+    }
+
+    template <typename ObjectType> requires TypeExists<ObjectType> && requires { typename UnderlyingContainer<ObjectType>::KeyType; }
+    ObjectType* Find(typename UnderlyingContainer<ObjectType>::KeyType const& key) const
+    {
+        return UnderlyingContainer<ObjectType>::Find(Data.template FindContainer<ObjectType>(), key);
+    }
 };
 
-template <class OBJECT_TYPES, class KEY_TYPE>
-TypeUnorderedMapContainer<OBJECT_TYPES, KEY_TYPE>::TypeUnorderedMapContainer() = default;
-
-template <class OBJECT_TYPES, class KEY_TYPE>
-TypeUnorderedMapContainer<OBJECT_TYPES, KEY_TYPE>::~TypeUnorderedMapContainer() = default;
-
-template <class OBJECT_TYPES, class KEY_TYPE>
-template <class SPECIFIC_TYPE>
-bool TypeUnorderedMapContainer<OBJECT_TYPES, KEY_TYPE>::Insert(KEY_TYPE const& handle, SPECIFIC_TYPE* obj)
-{
-    return Trinity::Insert(_elements, handle, obj);
-}
-
-template <class OBJECT_TYPES, class KEY_TYPE>
-template <class SPECIFIC_TYPE>
-bool TypeUnorderedMapContainer<OBJECT_TYPES, KEY_TYPE>::Remove(KEY_TYPE const& handle)
-{
-    return Trinity::Remove(_elements, handle, (SPECIFIC_TYPE*)nullptr);
-}
-
-template <class OBJECT_TYPES, class KEY_TYPE>
-template <class SPECIFIC_TYPE>
-SPECIFIC_TYPE* TypeUnorderedMapContainer<OBJECT_TYPES, KEY_TYPE>::Find(KEY_TYPE const& handle)
-{
-    return Trinity::Find(_elements, handle, (SPECIFIC_TYPE*)nullptr);
-}
-
-template <class OBJECT_TYPES, class KEY_TYPE>
-template <class SPECIFIC_TYPE>
-std::size_t TypeUnorderedMapContainer<OBJECT_TYPES, KEY_TYPE>::Size() const
-{
-    std::size_t size = 0;
-    Trinity::Size(_elements, &size, (SPECIFIC_TYPE*)nullptr);
-    return size;
-}
-
-template <class OBJECT_TYPES, class KEY_TYPE>
-ContainerUnorderedMap<OBJECT_TYPES, KEY_TYPE>& TypeUnorderedMapContainer<OBJECT_TYPES, KEY_TYPE>::GetElements()
-{
-    return _elements;
-}
-
-template <class OBJECT_TYPES, class KEY_TYPE>
-ContainerUnorderedMap<OBJECT_TYPES, KEY_TYPE> const& TypeUnorderedMapContainer<OBJECT_TYPES, KEY_TYPE>::GetElements() const
-{
-    return _elements;
-}
-
 #endif
diff --git a/src/server/game/Grids/Dynamic/TypeContainerFunctions.h b/src/server/game/Grids/Dynamic/TypeContainerFunctions.h
deleted file mode 100644
index d138ccff2d7..00000000000
--- a/src/server/game/Grids/Dynamic/TypeContainerFunctions.h
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
- * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
- *
- * This program 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.
- *
- * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TYPECONTAINER_FUNCTIONS_H
-#define TYPECONTAINER_FUNCTIONS_H
-
-/*
- * Here you'll find a list of helper functions to make
- * the TypeContainer usefull.  Without it, its hard
- * to access or mutate the container.
- */
-
-#include "Define.h"
-#include "Dynamic/TypeList.h"
-
-namespace Trinity
-{
-    // Helpers
-    // Insert helpers
-    template<class SPECIFIC_TYPE, class KEY_TYPE, class H, class T>
-    inline bool Insert(ContainerUnorderedMap<TypeList<H, T>, KEY_TYPE>& elements, KEY_TYPE const& handle, SPECIFIC_TYPE* obj)
-    {
-        if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
-        {
-            auto i = elements._elements._element.find(handle);
-            if (i == elements._elements._element.end())
-            {
-                elements._elements._element[handle] = obj;
-                return true;
-            }
-            else
-            {
-                ASSERT(i->second == obj, "Object with certain key already in but objects are different!");
-                return false;
-            }
-        }
-
-        if constexpr (std::is_same_v<T, TypeNull>)
-            return false;
-        else
-            return Insert(elements._TailElements, handle, obj);
-    }
-
-    // Find helpers
-    template<class SPECIFIC_TYPE, class KEY_TYPE, class H, class T>
-    inline SPECIFIC_TYPE* Find(ContainerUnorderedMap<TypeList<H, T>, KEY_TYPE> const& elements, KEY_TYPE const& handle, SPECIFIC_TYPE* obj)
-    {
-        if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
-        {
-            auto i = elements._elements._element.find(handle);
-            if (i == elements._elements._element.end())
-                return nullptr;
-            else
-                return i->second;
-        }
-
-        if constexpr (std::is_same_v<T, TypeNull>)
-            return nullptr;
-        else
-            return Find(elements._TailElements, handle, obj);
-    }
-
-    // Erase helpers
-    template<class SPECIFIC_TYPE, class KEY_TYPE, class H, class T>
-    inline bool Remove(ContainerUnorderedMap<TypeList<H, T>, KEY_TYPE>& elements, KEY_TYPE const& handle, SPECIFIC_TYPE* obj)
-    {
-        if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
-        {
-            elements._elements._element.erase(handle);
-            return true;
-        }
-
-        if constexpr (std::is_same_v<T, TypeNull>)
-            return false;
-        else
-            return Remove(elements._TailElements, handle, obj);
-    }
-
-    // Count helpers
-    template<class SPECIFIC_TYPE, class KEY_TYPE, class H, class T>
-    inline bool Size(ContainerUnorderedMap<TypeList<H, T>, KEY_TYPE> const& elements, std::size_t* size, SPECIFIC_TYPE* obj)
-    {
-        if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
-        {
-            *size = elements._elements._element.size();
-            return true;
-        }
-
-        if constexpr (std::is_same_v<T, TypeNull>)
-            return false;
-        else
-            return Size(elements._TailElements, size, obj);
-    }
-
-    /* ContainerMapList Helpers */
-    // count functions
-    template<class SPECIFIC_TYPE, class H, class T>
-    inline size_t Count(ContainerMapList<TypeList<H, T>> const& elements, SPECIFIC_TYPE* fake)
-    {
-        if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
-        {
-            return elements._elements._element.getSize();
-        }
-
-        if constexpr (std::is_same_v<T, TypeNull>)
-            return 0;
-        else
-            return Count(elements._TailElements, fake);
-    }
-
-    // non-const insert functions
-    template<class SPECIFIC_TYPE, class H, class T>
-    inline SPECIFIC_TYPE* Insert(ContainerMapList<TypeList<H, T>>& elements, SPECIFIC_TYPE* obj)
-    {
-        if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
-        {
-            obj->AddToGrid(elements._elements._element);
-            return obj;
-        }
-
-        if constexpr (std::is_same_v<T, TypeNull>)
-            return nullptr;
-        else
-            return Insert(elements._TailElements, obj);
-    }
-
-    //// non-const remove method
-    //template<class SPECIFIC_TYPE, class H, class T>
-    //SPECIFIC_TYPE* Remove(ContainerMapList<TypeList<H, T>>& elements, SPECIFIC_TYPE* obj)
-    //{
-    //    if constexpr (std::is_same_v<H, SPECIFIC_TYPE>)
-    //    {
-    //        obj->GetGridRef().unlink();
-    //        return obj;
-    //    }
-
-    //    if constexpr (std::is_same_v<T, TypeNull>)
-    //        return nullptr;
-    //    else
-    //        return Remove(elements._TailElements, obj);
-    //}
-}
-#endif
diff --git a/src/server/game/Grids/Dynamic/TypeContainerVisitor.h b/src/server/game/Grids/Dynamic/TypeContainerVisitor.h
index d22f159af28..35864b18a41 100644
--- a/src/server/game/Grids/Dynamic/TypeContainerVisitor.h
+++ b/src/server/game/Grids/Dynamic/TypeContainerVisitor.h
@@ -26,76 +26,42 @@
 
 #include "Dynamic/TypeContainer.h"
 
-// forward declaration
-template<class T, class Y> class TypeContainerVisitor;
-
 // visitor helper
-template<class VISITOR, class TYPE_CONTAINER> void VisitorHelper(VISITOR &v, TYPE_CONTAINER &c)
-{
-    v.Visit(c);
-}
-
-// terminate condition container map list
-template<class VISITOR> void VisitorHelper(VISITOR &/*v*/, ContainerMapList<TypeNull> &/*c*/) { }
-
-template<class VISITOR, class T> void VisitorHelper(VISITOR &v, ContainerMapList<T> &c)
-{
-    v.Visit(c._element);
-}
-
-// recursion container map list
-template<class VISITOR, class H, class T> void VisitorHelper(VISITOR &v, ContainerMapList<TypeList<H, T> > &c)
-{
-    VisitorHelper(v, c._elements);
-    VisitorHelper(v, c._TailElements);
-}
-
-// for TypeMapContainer
-template<class VISITOR, class OBJECT_TYPES> void VisitorHelper(VISITOR &v, TypeMapContainer<OBJECT_TYPES> &c)
-{
-    VisitorHelper(v, c.GetElements());
-}
-
-// TypeUnorderedMapContainer
-template<class VISITOR, class KEY_TYPE>
-void VisitorHelper(VISITOR& /*v*/, ContainerUnorderedMap<TypeNull, KEY_TYPE>& /*c*/) { }
-
-template<class VISITOR, class KEY_TYPE, class T>
-void VisitorHelper(VISITOR& v, ContainerUnorderedMap<T, KEY_TYPE>& c)
+template <class Visitor, template <typename> typename UnderlyingContainer, typename... Types>
+inline void VisitorHelper(Visitor& /*v*/, [[maybe_unused]] TypeListContainerStorage<UnderlyingContainer, Types...>& /*c*/)
 {
-    v.Visit(c._element);
 }
 
-template<class VISITOR, class KEY_TYPE, class H, class T>
-void VisitorHelper(VISITOR& v, ContainerUnorderedMap<TypeList<H, T>, KEY_TYPE>& c)
+template <class Visitor, template <typename> typename UnderlyingContainer, typename First, typename... Types>
+inline void VisitorHelper(Visitor& v, TypeListContainerStorage<UnderlyingContainer, First, Types...>& c)
 {
-    VisitorHelper(v, c._elements);
-    VisitorHelper(v, c._TailElements);
+    v.Visit(c.Head);
+    VisitorHelper(v, c.Tail);
 }
 
-template<class VISITOR, class OBJECT_TYPES, class KEY_TYPE>
-void VisitorHelper(VISITOR& v, TypeUnorderedMapContainer<OBJECT_TYPES, KEY_TYPE>& c)
+template <class Visitor, template <typename> typename UnderlyingContainer, typename... Types>
+inline void VisitorHelper(Visitor& v, TypeListContainer<UnderlyingContainer, Types...>& c)
 {
-    VisitorHelper(v, c.GetElements());
+    VisitorHelper(v, c.Data);
 }
 
-template<class VISITOR, class TYPE_CONTAINER>
+template<class Visitor, class TypeContainer>
 class TypeContainerVisitor
 {
-    public:
-        TypeContainerVisitor(VISITOR &v) : i_visitor(v) { }
+public:
+    TypeContainerVisitor(Visitor& v) : i_visitor(v) { }
 
-        void Visit(TYPE_CONTAINER& c)
-        {
-            VisitorHelper(i_visitor, c);
-        }
+    void Visit(TypeContainer& c)
+    {
+        VisitorHelper(i_visitor, c);
+    }
 
-        void Visit(TYPE_CONTAINER const& c) const
-        {
-            VisitorHelper(i_visitor, c);
-        }
+    void Visit(TypeContainer const& c) const
+    {
+        VisitorHelper(i_visitor, c);
+    }
 
-    private:
-        VISITOR &i_visitor;
+private:
+    Visitor& i_visitor;
 };
 #endif
diff --git a/src/server/game/Grids/Grid.h b/src/server/game/Grids/Grid.h
index 4cecd2942d7..6b13b07949b 100644
--- a/src/server/game/Grids/Grid.h
+++ b/src/server/game/Grids/Grid.h
@@ -30,7 +30,7 @@
 */
 
 #include "Define.h"
-#include "TypeContainer.h"
+#include "Errors.h"
 #include "TypeContainerVisitor.h"
 
 // forward declaration
@@ -57,7 +57,7 @@ class Grid
          */
         template<class SPECIFIC_OBJECT> void AddWorldObject(SPECIFIC_OBJECT *obj)
         {
-            i_objects.template insert<SPECIFIC_OBJECT>(obj);
+            i_objects.template Insert<SPECIFIC_OBJECT>(obj);
             ASSERT(obj->IsInGrid());
         }
 
@@ -103,14 +103,14 @@ class Grid
         template<class T>
         uint32 GetWorldObjectCountInGrid() const
         {
-            return uint32(i_objects.template Count<T>());
+            return uint32(i_objects.template Size<T>());
         }
 
         /** Inserts a container type object into the grid.
          */
         template<class SPECIFIC_OBJECT> void AddGridObject(SPECIFIC_OBJECT *obj)
         {
-            i_container.template insert<SPECIFIC_OBJECT>(obj);
+            i_container.template Insert<SPECIFIC_OBJECT>(obj);
             ASSERT(obj->IsInGrid());
         }
 
@@ -139,4 +139,5 @@ class Grid
         //typedef std::set<void*> ActiveGridObjects;
         //ActiveGridObjects m_activeGridObjects;
 };
+
 #endif
diff --git a/src/server/game/Grids/GridDefines.h b/src/server/game/Grids/GridDefines.h
index a40de811a29..821597bf57c 100644
--- a/src/server/game/Grids/GridDefines.h
+++ b/src/server/game/Grids/GridDefines.h
@@ -62,11 +62,6 @@ class Conversation;
 #define MAX_FALL_DISTANCE     250000.0f                     // "unlimited fall" to find VMap ground if it is available, just larger than MAX_HEIGHT - INVALID_HEIGHT
 #define DEFAULT_HEIGHT_SEARCH     50.0f                     // default search distance to find height at nearby locations
 
-// Creature used instead pet to simplify *::Visit templates (not required duplicate code for Creature->Pet case)
-typedef TYPELIST_4(Player, Creature/*pets*/, Corpse/*resurrectable*/, DynamicObject/*farsight target*/) AllWorldObjectTypes;
-typedef TYPELIST_7(GameObject, Creature/*except pets*/, DynamicObject, Corpse/*Bones*/, AreaTrigger, SceneObject, Conversation) AllGridObjectTypes;
-typedef TYPELIST_8(Creature, GameObject, DynamicObject, Pet, Corpse, AreaTrigger, SceneObject, Conversation) AllMapStoredObjectTypes;
-
 typedef GridRefManager<Corpse>          CorpseMapType;
 typedef GridRefManager<Creature>        CreatureMapType;
 typedef GridRefManager<DynamicObject>   DynamicObjectMapType;
@@ -89,11 +84,12 @@ enum GridMapTypeMask
     GRID_MAP_TYPE_MASK_ALL              = 0xFF
 };
 
-extern template class TypeMapContainer<AllGridObjectTypes>;
-extern template class TypeMapContainer<AllWorldObjectTypes>;
+// Creature used instead pet to simplify *::Visit templates (not required duplicate code for Creature->Pet case)
+extern template struct TypeListContainer<GridRefManagerContainer, GameObject, Creature/*except pets*/, DynamicObject, Corpse/*Bones*/, AreaTrigger, SceneObject, Conversation>;
+extern template struct TypeListContainer<GridRefManagerContainer, Player, Creature/*pets*/, Corpse/*resurrectable*/, DynamicObject/*farsight target*/>;
 
-typedef TypeMapContainer<AllGridObjectTypes> GridTypeMapContainer;
-typedef TypeMapContainer<AllWorldObjectTypes> WorldTypeMapContainer;
+typedef TypeListContainer<GridRefManagerContainer, GameObject, Creature/*except pets*/, DynamicObject, Corpse/*Bones*/, AreaTrigger, SceneObject, Conversation> GridTypeMapContainer;
+typedef TypeListContainer<GridRefManagerContainer, Player, Creature/*pets*/, Corpse/*resurrectable*/, DynamicObject/*farsight target*/> WorldTypeMapContainer;
 
 extern template class Grid<Player, WorldTypeMapContainer, GridTypeMapContainer>;
 extern template class NGrid<MAX_NUMBER_OF_CELLS, Player, WorldTypeMapContainer, GridTypeMapContainer>;
diff --git a/src/server/game/Grids/GridRefManager.h b/src/server/game/Grids/GridRefManager.h
index 44945e6c335..54f1e7c6b35 100644
--- a/src/server/game/Grids/GridRefManager.h
+++ b/src/server/game/Grids/GridRefManager.h
@@ -27,4 +27,30 @@ template<class OBJECT>
 class GridRefManager : public RefManager<GridReference<OBJECT>>
 {
 };
+
+template <typename ObjectType>
+struct GridRefManagerContainer
+{
+    using Container = GridRefManager<ObjectType>;
+    using ValueType = ObjectType*;
+
+    static bool Insert(Container& container, ValueType object)
+    {
+        object->AddToGrid(container);
+        return true;
+    }
+
+    static bool Remove(Container& /*container*/, ValueType object)
+    {
+        object->RemoveFromGrid();
+        return true;
+    }
+
+    static std::size_t Size(Container const& container)
+    {
+        return container.getSize();
+    }
+};
+
+
 #endif
diff --git a/src/server/game/Grids/NGrid.cpp b/src/server/game/Grids/NGrid.cpp
index b71f9fb994e..ff6cfc34c60 100644
--- a/src/server/game/Grids/NGrid.cpp
+++ b/src/server/game/Grids/NGrid.cpp
@@ -32,5 +32,5 @@ GridInfo::GridInfo(time_t expiry, bool unload /*= true */) : i_timer(expiry), vi
 template class Grid<Player, WorldTypeMapContainer, GridTypeMapContainer>;
 template class NGrid<MAX_NUMBER_OF_CELLS, Player, WorldTypeMapContainer, GridTypeMapContainer>;
 
-template class TC_GAME_API TypeMapContainer<AllGridObjectTypes>;
-template class TC_GAME_API TypeMapContainer<AllWorldObjectTypes>;
+template struct TC_GAME_API TypeListContainer<GridRefManagerContainer, GameObject, Creature/*except pets*/, DynamicObject, Corpse/*Bones*/, AreaTrigger, SceneObject, Conversation>;
+template struct TC_GAME_API TypeListContainer<GridRefManagerContainer, Player, Creature/*pets*/, Corpse/*resurrectable*/, DynamicObject/*farsight target*/>;
diff --git a/src/server/game/Grids/NGrid.h b/src/server/game/Grids/NGrid.h
index 68e9abc8831..2babe75cc88 100644
--- a/src/server/game/Grids/NGrid.h
+++ b/src/server/game/Grids/NGrid.h
@@ -22,6 +22,7 @@
  */
 
 #include "Grid.h"
+#include "GridRefManager.h"
 #include "GridReference.h"
 #include "Timer.h"