factory.h

#ifndef OE_UTIL_FACTORY_H
#define OE_UTIL_FACTORY_H
 
#include <map>
#include <string>
 
namespace oe
{
    namespace util
    {
        template <typename Base, typename Key>
        class Factory
        {
            public:
                Base* createEntity(const Key& key)
                {
                    return _map.count(key) == 1 ? _map[key].first->create() : nullptr;
                }
 
                void remove(Base* entity)
                {
                    delete entity;
                }
 
                template <typename ElementClass>
                void linkEntityToClass(const std::string& name, const int& priority = 0)
                {
                   _map.insert(std::pair<std::string, std::pair<Base_deliverer*, int>>(name, {new Entity_deliverer<ElementClass>, priority}));
                }
 
                std::map<int, Key> getEntitiesNames()
                {
                    std::map<int, Key> result;
 
                    for (auto& it : _map)
                    {
                        result[it.second.second] = it.first;
                    }
 
                    return result;
                }
 
                ~Factory()
                {
                    for (auto it = _map.cbegin(); it != _map.cend();)
                    {
                        delete it->second.first;
                        _map.erase(it++);
                    }
                }
            private:
                struct Base_deliverer
                {
                   virtual Base* create() const = 0;
                   virtual ~Base_deliverer() {}
                };
 
                template <typename T>
                struct Entity_deliverer : public Base_deliverer
                {
                   virtual Base* create() const { return new T; };
                };
 
                std::map<Key, std::pair<Base_deliverer*, int>> _map;
        };
    }
}
#endif