1 files changed, 20 insertions, 55 deletions

diff --git a/src/common/Dynamic/ObjectRegistry.h b/src/common/Dynamic/ObjectRegistry.h
index 7cc2c9abca..d72fd7b3a7 100644
--- a/src/common/Dynamic/ObjectRegistry.h
+++ b/src/common/Dynamic/ObjectRegistry.h
@@ -23,20 +23,23 @@
 #include <string>
 #include <unordered_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;
 
     /// 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() ? nullptr : iter->second );
+        auto itr = _registeredObjects.find(key);
+        if (itr == _registeredObjects.end())
+            return nullptr;
+        return itr->second.get();
     }
 
     static ObjectRegistry<T, Key>* instance()
@@ -46,72 +49,34 @@ public:
     }
 
     /// 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
     {
-        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