refactor(Core/AI): factory functions cleanup (#11779)

src/common/Dynamic/FactoryHolder.h

@@ -19,33 +19,29 @@
 #define ACORE_FACTORY_HOLDER
 
 #include "Define.h"
-#include "Dynamic/TypeList.h"
 #include "ObjectRegistry.h"
+#include "TypeList.h"
 
-/*
- * FactoryHolder holds a factory object of a specific type
+/** 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 = nullptr) 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
+/** Permissible is a classic way of letting the object decide
  * whether how good they handle things.  This is not retricted
  * to factory selectors.
  */
@@ -54,7 +50,6 @@ class Permissible
 {
 public:
     virtual ~Permissible() { }
-    virtual int Permit(const T*) const = 0;
+    virtual int32 Permit(T const*) const = 0;
 };
-
 #endif

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