2 files changed, 30 insertions, 55 deletions

diff --git a/src/server/shared/Dynamic/FactoryHolder.h b/src/server/shared/Dynamic/FactoryHolder.h
index ce6622daea4..317d50ea9fc 100644
--- a/src/server/shared/Dynamic/FactoryHolder.h
+++ b/src/server/shared/Dynamic/FactoryHolder.h
@@ -24,23 +24,21 @@
 
 /** FactoryHolder holds a factory object of a specific type
  */
-template<class T, class Key = std::string>
+template<class T, class O, class Key = std::string>
 class FactoryHolder
 {
     public:
-        typedef ObjectRegistry<FactoryHolder<T, Key >, Key > FactoryHolderRegistry;
+        typedef ObjectRegistry<FactoryHolder<T, O, Key>, Key> FactoryHolderRegistry;
 
-        FactoryHolder(Key k) : i_key(k) { }
+        explicit FactoryHolder(Key const& k) : _key(k) { }
         virtual ~FactoryHolder() { }
-        inline Key key() const { return i_key; }
 
-        void RegisterSelf(void) { FactoryHolderRegistry::instance()->InsertItem(this, i_key); }
-        void DeregisterSelf(void) { FactoryHolderRegistry::instance()->RemoveItem(this, false); }
+        void RegisterSelf() { FactoryHolderRegistry::instance()->InsertItem(this, _key); }
 
         /// Abstract Factory create method
-        virtual T* Create(void *data = NULL) const = 0;
+        virtual T* Create(O* object = nullptr) const = 0;
     private:
-        Key i_key;
+        Key const _key;
 };
 
 /** Permissible is a classic way of letting the object decide
@@ -52,6 +50,6 @@ class Permissible
 {
     public:
         virtual ~Permissible() { }
-        virtual int Permit(const T *) const = 0;
+        virtual int32 Permit(T const*) const = 0;
 };
 #endif
diff --git a/src/server/shared/Dynamic/ObjectRegistry.h b/src/server/shared/Dynamic/ObjectRegistry.h
index 45380d699d3..973c34fda24 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,47 @@ 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
+        bool HasItem(Key const& 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 (_registeredObjects.count(key) > 0);
         }
 
         /// 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