ComponentFactory.hpp

#pragma once
#ifndef __H__OCULAR_CORE_SCENE_COMPONENT_FACTORY__H__
#define __H__OCULAR_CORE_SCENE_COMPONENT_FACTORY__H__

#include <unordered_map>
#include <string>
#include <functional>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Core
    {
        template<class T>
        class ComponentFactory
        {
        public:

            ComponentFactory() { }
            ~ComponentFactory() { }

            T* createComponent(std::string const& name)
            {
                T* result = nullptr;
                const auto find = m_ComponentMap.find(name);

                if(find != m_ComponentMap.end())
                {
                    result = find->second();
                }

                return result;
            }

            template<typename S>
            bool registerComponent(std::string name)
            {
                bool result = false;
                const auto find = m_ComponentMap.find(name);

                if(find == m_ComponentMap.end())
                {
                    m_ComponentMap.insert(std::make_pair(name, [](){ return new S; }));
                    result = true;
                }

                return result;
            }

            std::vector<std::string> getRegisteredKeys() const
            {
                std::vector<std::string> result;
                result.reserve(m_ComponentMap.size());

                for(auto keyvalue : m_ComponentMap)
                {
                    result.emplace_back(keyvalue.first);
                }

                return result;
            }

        protected:

        private:

            std::unordered_map<std::string, std::function<T*()>> m_ComponentMap;
        };
    }
}
//------------------------------------------------------------------------------------------

#endif