Core/AI: Factory functions cleanup

- Get rid of fugly void pointers
- Streamlined AI selection code, using Permissible as it should've been instead of harcoded checks on the selector code
- Moved IdleMovementGenerator singleton to factory code

(cherry picked from commit ce3787f190d28c1e981598eef2cd24c622a2cbae)

1 files changed, 21 insertions, 50 deletions

diff --git a/src/server/shared/Dynamic/ObjectRegistry.h b/src/server/shared/Dynamic/ObjectRegistry.h
index 45380d699d3..89ca33f15fa 100644
--- a/src/server/shared/Dynamic/ObjectRegistry.h
+++ b/src/server/shared/Dynamic/ObjectRegistry.h
@@ -23,14 +23,15 @@
 #include <string>
 #include <map>
 #include <vector>
+#include <memory>
 
 /** ObjectRegistry holds all registry item of the same type
  */
 template<class T, class Key = std::string>
-class ObjectRegistry
+class ObjectRegistry final
 {
     public:
-        typedef std::map<Key, T*> RegistryMapType;
+        typedef std::map<Key, std::unique_ptr<T>> RegistryMapType;
 
         static ObjectRegistry<T, Key>* instance()
         {
@@ -39,71 +40,41 @@ class ObjectRegistry
         }
 
         /// Returns a registry item
-        const T* GetRegistryItem(Key key) const
+        T const* GetRegistryItem(Key const& key) const
         {
-            typename RegistryMapType::const_iterator iter = i_registeredObjects.find(key);
-            return( iter == i_registeredObjects.end() ? NULL : iter->second );
+            auto itr = _registeredObjects.find(key);
+            if (itr == _registeredObjects.end())
+                return nullptr;
+            return itr->second.get();
         }
 
         /// Inserts a registry item
-        bool InsertItem(T *obj, Key key, bool _override = false)
+        bool InsertItem(T* obj, Key const& key, bool force = false)
         {
-            typename RegistryMapType::iterator iter = i_registeredObjects.find(key);
-            if ( iter != i_registeredObjects.end() )
+            auto itr = _registeredObjects.find(key);
+            if (itr != _registeredObjects.end())
             {
-                if ( !_override )
+                if (!force)
                     return false;
-                delete iter->second;
-                i_registeredObjects.erase(iter);
+                _registeredObjects.erase(itr);
             }
 
-            i_registeredObjects[key] = obj;
+            _registeredObjects.emplace(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(obj));
             return true;
         }
 
-        /// Removes a registry item
-        void RemoveItem(Key key, bool delete_object = true)
-        {
-            typename RegistryMapType::iterator iter = i_registeredObjects.find(key);
-            if ( iter != i_registeredObjects.end() )
-            {
-                if ( delete_object )
-                    delete iter->second;
-                i_registeredObjects.erase(iter);
-            }
-        }
-
-        /// Returns true if registry contains an item
-        bool HasItem(Key key) const
-        {
-            return (i_registeredObjects.find(key) != i_registeredObjects.end());
-        }
-
-        /// Inefficiently return a vector of registered items
-        unsigned int GetRegisteredItems(std::vector<Key> &l) const
-        {
-            unsigned int sz = l.size();
-            l.resize(sz + i_registeredObjects.size());
-            for (typename RegistryMapType::const_iterator iter = i_registeredObjects.begin(); iter != i_registeredObjects.end(); ++iter)
-                l[sz++] = iter->first;
-            return i_registeredObjects.size();
-        }
-
         /// Return the map of registered items
-        RegistryMapType const &GetRegisteredItems() const
+        RegistryMapType const& GetRegisteredItems() const
         {
-            return i_registeredObjects;
+            return _registeredObjects;
         }
 
-        ObjectRegistry() { }
-        ~ObjectRegistry()
-        {
-            for (typename RegistryMapType::iterator iter=i_registeredObjects.begin(); iter != i_registeredObjects.end(); ++iter)
-                delete iter->second;
-            i_registeredObjects.clear();
-        }
     private:
-        RegistryMapType i_registeredObjects;
+        RegistryMapType _registeredObjects;
+
+        // non instanceable, only static
+        ObjectRegistry() { }
+        ~ObjectRegistry() { }
 };
 
 #endif