Registry.hpp

Go to the documentation of this file.

 
#ifndef REGISTRY_HPP
#define REGISTRY_HPP
 
//local
#include "SparseArray.hpp"
 
//global
#include <any>
#include <functional>
#include <typeindex>
#include <unordered_map>
#include <vector>
#include <iostream>
#include <vector>
#include <unordered_map>
#include <typeindex>
#include <type_traits>
#include <memory>
#include "System.hpp"
#include "Concepts.hpp"
 
namespace ecs {
 
    class Entity;
    class System;
 
    class Registry {
 
        public:
 
 
            Entity createEntity();
 
            Entity entityFromIndex(std::size_t idx);
 
            void killEntity(Entity const &e);
 
 
            template <typename Component>
            SparseArray<Component> &registerComponent();
 
            template <class ... Components>
            void registerComponents();
 
            template <IsTuple Tuple>
            void registerComponentsByExtraction();
 
            template <class Component>
            SparseArray<Component> &getComponents();
 
            template <class Component>
            const SparseArray<Component> &getComponents() const;
 
            template <typename... Component, typename = std::enable_if_t<(sizeof...(Component) != 0)>>
            void addComponent(Entity const &to, Component &&...c);
 
            template <typename Component, typename ... Params>
            void emplaceComponent(Entity const &to, Params &&... p);
 
            template <typename... Component, typename = std::enable_if<(sizeof...(Component) != 0)>>
            void removeComponent(Entity const &from);
 
 
            template<SystemImplementation System>
            void addSystem(System& s);
 
            template<SystemImplementation System>
            void addSystem(System&& s);
 
            template <SystemImplementation... System, typename = std::enable_if<(sizeof...(System) != 0)>>
            void addSystem(System&& ... s);
 
            template <SystemImplementation System, typename ... Params>
            void emplaceSystem(Params &&... params);
 
            template <SystemImplementation ... System, typename = std::enable_if<(sizeof...(System) != 0)>>
            void removeSystem();
 
            template <SystemImplementation ... System, typename = std::enable_if<(sizeof...(System) != 0)>>
            void callSystem();
 
        private:
 
            size_t _entitiesCount = 0;
            std::vector<Entity> killedEntities;
 
            std::unordered_map<std::type_index, std::any> componentsArrays;
            std::unordered_map<std::type_index, std::any> systemsArrays;
 
            std::vector<std::function<void(Registry &, Entity const &)>> componentsRemoves;
 
            std::unordered_map<std::type_index, std::shared_ptr<ISystem>> systems;
    };
 
}
 
#endif // REGISTRY_HPP