Context.h

#pragma once
#include "Core/Engine/ECS/Common.h"
#include <concepts>
 
namespace Nui::ECS
{
    template <typename T>
    concept IsSystem = std::is_base_of<SystemBase, T>::value;
 
    class Context
    {
    public:
        using SubscriberMap = std::unordered_map<TypeIndex, std::vector<Internal::EventSubscriberBase*>, std::hash<TypeIndex>, std::equal_to<TypeIndex>>;
 
 
    public:
        Context();
 
        virtual ~Context();
 
        inline U64 GetEntityCount() const noexcept { return m_entities.size(); }
 
        Entity* GetEntityById(U64 id);
 
        Entity* GetEntityByIndex(U64 index);
 
        Entity* CreateEntity();
 
        void DestroyEntity(Entity* e, bool immediate = false);
 
        bool ClearPending();
 
        void Reset();
 
        template <typename T, typename... Args>
        T* RegisterSystem(Args&&... args) requires IsSystem<T>;
 
        template <typename T>
        void UnregisterSystem() requires IsSystem<T>;
 
        void UnregisterAllSystems();
 
        template <typename T>
        T* GetSystem() requires IsSystem<T>;
 
        template <typename T>
        void EnableSystem() requires IsSystem<T>;
 
        template <typename T>
        void DisableSystem() requires IsSystem<T>;
 
        template <typename T>
        bool IsSystmEnabled() requires IsSystem<T>;
 
        template <typename T>
        void SubscribeEvent(EventSubscriber<T>* subscriber);
 
        template<typename T>
        void UnsubscribeEvent(EventSubscriber<T>* subscriber);
 
        void UnsubscribeAll(void* subscriber);
 
        template<typename T>
        void EmitEvent(const T& event);
 
        template<typename... Types>
        Internal::EntityComponentView<Types...> Each(bool includePendingDestroy = false);
 
        template<typename... Types>
        void Each(typename std::common_type<std::function<void(Entity*, ComponentHandle<Types>...)>>::type viewFunc, bool includePendingDestroy = false);
 
        Internal::EntityView All(bool includePendingDestroy = false);
 
        void All(std::function<void(Entity*)> viewFunc, bool includePendingDestroy = false);
 
        void Tick(const F64 dt);
 
    private:
        std::vector<std::unique_ptr<Entity>> m_entities;
 
        std::vector<std::unique_ptr<SystemBase>> m_systems;
 
        SubscriberMap m_subscribers;
 
        U64 m_lastEntityId{ 0 };
    };
}