component.h

#ifndef OE_SCENE_COMPONENT_H
#define OE_SCENE_COMPONENT_H
 
#include <memory>
#include <string>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <chrono>
 
namespace oe::component
{
    class Component
    {
        public:
            virtual void onUpdate(const std::chrono::nanoseconds, const int8_t = 0)
            {}
 
            bool is_active = true;
 
            virtual ~Component()
            {}
    };
 
    template <typename Entity, typename ComponentType>
    class ComponentList;
 
    template <typename Entity>
    class EntityComponent : public Component
    {
        public:
            const std::string& getName() const
            {
                return _name;
            }
 
        protected:
            EntityComponent(Entity& entity):
                _entity(entity)
            {}
 
            Entity& _entity;
 
        private:
            std::string _name = {};
 
            template <typename E, typename C>
            friend class ComponentList;
    };
 
    template <typename Entity, typename ComponentType = EntityComponent<Entity>>
    class ComponentList
    {
        using ComponentContainer = std::vector<std::shared_ptr<ComponentType>>;
 
        public:
            ComponentList(Entity& entity):
                _entity(entity)
            {}
 
            template <typename T = ComponentType, typename ...Args>
            std::shared_ptr<T> addNamed(const std::string& name, Args&& ...args)
            {
                if (name.length() == 0)
                {
                    throw std::invalid_argument("Component name is missing!");
                }
 
                if (_component_by_keys.count(name) != 0)
                {
                    throw std::invalid_argument("Component " + name + "already exists!");
                }
 
                std::shared_ptr<T> result = std::make_shared<T>(_entity, std::forward<Args>(args)...);
 
                _components.push_back(result);
 
                result->_name = name;
                _component_by_keys[name] = result;
 
                return result;
            }
 
            template <typename T = ComponentType, typename ...Args>
            std::shared_ptr<T> add(Args&& ...args)
            {
                std::shared_ptr<T> result = std::make_shared<T>(_entity, std::forward<Args>(args)...);
 
                _components.push_back(result);
 
                return result;
            }
 
            template <typename T = ComponentType>
            const T* getComponentByName(const std::string& name) const noexcept
            {
                if (_component_by_keys.count(name))
                {
                    return dynamic_cast<T*>(_component_by_keys.at(name).get());
                }
 
                return nullptr;
            }
 
            template <typename T = ComponentType>
            T* getComponentByName(const std::string& name) noexcept
            {
                if (_component_by_keys.count(name))
                {
                    return dynamic_cast<T*>(_component_by_keys.at(name).get());
                }
 
                return nullptr;
            }
 
            template <typename T>
            const T* getComponentByType() const noexcept
            {
                for (auto it = _components.begin(); it != _components.end(); it++)
                {
                    if (auto result = dynamic_cast<const T*>(it->get()))
                        return result;
                }
 
                return nullptr;
            }
 
            template <typename T>
            T* getComponentByType() noexcept
            {
                for (auto it = _components.begin(); it != _components.end(); it++)
                {
                    if (auto result = dynamic_cast<T*>(it->get()))
                        return result;
                }
 
                return {};
            }
 
            void remove(const std::string& name)
            {
                // Find if the component exists
                if (!_component_by_keys.count(name))
                    return;
 
                std::shared_ptr<Component> component = _component_by_keys[name];
 
                // Remove the from the key list
                _component_by_keys.erase(name);
 
                // Remove the from the list
                _components.erase(std::remove_if(
                    _components.begin(),
                    _components.end(),
                    [component](const auto& c) {return c == component;}
                ), _components.end());
            }
 
            void update(const std::chrono::nanoseconds delta, const int8_t flags = 0) const
            {
                for (auto it = _components.begin(); it != _components.end(); it++)
                {
                    (*it)->onUpdate(delta, flags);
                }
            }
 
            typename ComponentContainer::iterator begin() noexcept
            {
                return _components.begin();
            }
 
            typename ComponentContainer::iterator end() noexcept
            {
                return _components.end();
            }
 
            const typename ComponentContainer::const_iterator begin() const noexcept
            {
                return _components.begin();
            }
 
            const typename ComponentContainer::const_iterator end() const noexcept
            {
                return _components.end();
            }
 
            const typename ComponentContainer::const_iterator cbegin() const noexcept
            {
                return _components.begin();
            }
 
            const typename ComponentContainer::const_iterator cend() const noexcept
            {
                return _components.end();
            }
 
        private:
            Entity& _entity;
 
            ComponentContainer _components;
            std::unordered_map<std::string, std::shared_ptr<ComponentType>> _component_by_keys;
    };
 
    template <typename Entity, typename ComponentType>
    class HasComponents
    {
        public:
            HasComponents(Entity& entity):
                _components(entity)
            {
            }
 
            ComponentList<Entity, ComponentType>& getComponents() noexcept
            {
                return _components;
            }
 
            const ComponentList<Entity, ComponentType>& getComponents() const noexcept
            {
                return _components;
            }
 
            template <typename T = ComponentType, typename ...Args>
            std::shared_ptr<T> addComponent(Args&&... args)
            {
                return _components. template add<T, Args...>(std::forward<Args>(args)...);
            }
 
            template <typename T = ComponentType, typename ...Args>
            std::shared_ptr<T> addNamedComponent(const std::string& name, Args&&... args)
            {
                return _components. template addNamed<T, Args...>(name, std::forward<Args>(args)...);
            }
 
            void removeComponent(const std::string& name)
            {
                _components.remove(name);
            }
 
            template <typename T>
            const T* getComponentByType() const noexcept
            {
                return _components. template getComponentByType<T>();
            }
 
            template <typename T>
            T* getComponentByType() noexcept
            {
                return _components. template getComponentByType<T>();
            }
 
            template <typename T = ComponentType>
            T* getComponentByName(const std::string& name) noexcept
            {
                return _components. template getComponentByName<T>(name);
            }
 
            template <typename T = ComponentType>
            const T* getComponentByName(const std::string& name) const noexcept
            {
                return _components. template getComponentByName<T>(name);
            }
 
        protected:
            ComponentList<Entity, ComponentType> _components;
 
    };
}
#endif