AccessPolicy.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/ecs/ComponentRegistry.h"
#include "ncengine/ecs/EcsFilter.h"
#include "ncengine/ecs/Hierarchy.h"
#include "ncengine/ecs/Tag.h"
#include "ncengine/ecs/Transform.h"
 
#include <concepts>
#include <type_traits>
 
namespace nc::ecs
{
template<class T>
concept RegistryType = Component<T> || std::same_as<Entity, T>;
 
template<class F, class T>
concept PoolInvocable = std::invocable<F, decltype(std::declval<ComponentRegistry*>()->GetPool<T>())>;
 
template<FilterBase Base, class... Includes>
class AccessPolicy
{
    public:
        static constexpr auto base = Base;
 
        using FilterType = std::conditional_t<Base == FilterBase::All,
            detail::AllFilter,
            std::conditional_t<Base == FilterBase::Basic,
                detail::MatchFilter<Entity, Hierarchy, Tag, Transform, Includes...>,
                detail::MatchFilter<Includes...>>>;
 
        template<class... TargetIncludes>
        static constexpr bool HasAccess = (FilterType::template included<TargetIncludes> && ...);
 
        template<FilterBase TargetBase>
        static constexpr bool BaseContains = Base >= TargetBase;
 
        template<FilterBase TargetBase, class... TargetIncludes>
        static constexpr bool ConvertibleTo = BaseContains<TargetBase> && HasAccess<TargetIncludes...>;
 
        AccessPolicy(ComponentRegistry& registry) noexcept
            : m_registry{&registry} {}
 
        template<FilterBase TargetBase, class... TargetIncludes>
            requires ConvertibleTo<TargetBase, TargetIncludes...>
        operator AccessPolicy<TargetBase, TargetIncludes...>() const noexcept
        {
            return AccessPolicy<TargetBase, TargetIncludes...>{*m_registry};
        }
 
        template<RegistryType T>
            requires HasAccess<T>
        auto GetPool() const -> decltype(auto)
        {
            return m_registry->GetPool<T>();
        }
 
        template<RegistryType T>
            requires HasAccess<T>
        auto GetPool() -> decltype(auto)
        {
            return m_registry->GetPool<T>();
        }
 
        auto GetFreeComponentPool() -> decltype(auto)
        {
            return m_registry->GetFreeComponentPool();
        }
 
        auto GetFreeComponentPool() const -> decltype(auto)
        {
            return m_registry->GetFreeComponentPool();
        }
 
        auto GetComponentPools()
            requires BaseContains<FilterBase::All>
        {
            return m_registry->GetComponentPools();
        }
 
    private:
        mutable ComponentRegistry* m_registry;
};
} // namespace nc::ecs