Registry.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_REGISTRY_REGISTRY_HPP_
#define ECSTASY_REGISTRY_REGISTRY_HPP_
 
#include <optional>
#include <span>
 
#include "concepts/RegistryModifier.hpp"
#include "ecstasy/query/Query.hpp"
#include "ecstasy/query/Select.hpp"
#include "ecstasy/query/conditions/Condition.hpp"
#include "ecstasy/query/modifiers/Modifier.hpp"
#include "ecstasy/resources/entity/Entities.hpp"
#include "ecstasy/storages/IStorage.hpp"
#include "ecstasy/storages/Instances.hpp"
#include "ecstasy/storages/StorageConcepts.hpp"
#include "ecstasy/storages/SystemInstances.hpp"
#include "ecstasy/system/ISystem.hpp"
#include "ecstasy/system/Pipeline.hpp"
#include "ecstasy/thread/LockableView.hpp"
#include "util/Allocator.hpp"
#include "util/StackAllocator.hpp"
#include "util/meta/apply.hpp"
#include "util/meta/filter.hpp"
#include "concepts/component_type.hpp"
#include "concepts/queryable_type.hpp"
#include "ecstasy/registry/concepts/modifier_allocator_size.hpp"
#include "util/meta/is_size_t_convertible.hpp"
#include "util/meta/outer_join.hpp"
 
#ifdef _MSC_VER
    #define NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
#else
    #define NO_UNIQUE_ADDRESS [[no_unique_address]]
#endif
 
namespace ecstasy
{
 
    template <typename R, bool AutoLock = thread::AUTO_LOCK_RESOURCES_DEFAULT>
    using ResourceReference = query::thread_safe_reference_t<R, AutoLock>;
    template <typename R, bool AutoLock = thread::AUTO_LOCK_RESOURCES_DEFAULT>
    using RR = ResourceReference<R, AutoLock>;
 
    struct EmptyType {};
 
    class Registry {
      public:
        template <typename C>
        [[nodiscard]] constexpr getStorageType<C> &getQueryable()
        {
            return getStorageSafe<C>();
        }
 
        template <std::derived_from<IResource> R>
            requires query::Queryable<R>
        [[nodiscard]] constexpr R &getQueryable()
        {
            return getResource<R, false>();
        }
 
        template <IsStorage S>
            requires query::Queryable<S>
        [[nodiscard]] S &getQueryable()
        {
            if (!_storages.contains<std::remove_const_t<S>>()) [[unlikely]]
                return _storages.emplace<std::remove_const_t<S>>();
            return _storages.get<std::remove_const_t<S>>();
        }
 
        template <typename C>
        [[nodiscard]] constexpr getStorageType<C> &getFromType()
        {
            return getStorageSafe<C>();
        }
 
        template <IsStorage S>
        [[nodiscard]] S &getFromType()
        {
            return _storages.get<std::remove_const_t<S>>();
        }
 
        template <std::derived_from<IResource> R>
        [[nodiscard]] constexpr R &getFromType()
        {
            return getResource<R, false>();
        }
 
        template <std::derived_from<ISystem> S>
        [[nodiscard]] constexpr S &getFromType()
        {
            return getSystem<S>();
        }
 
        template <std::derived_from<Registry> R>
        [[nodiscard]] constexpr R &getFromType() noexcept
        {
            return *this;
        }
 
        template <typename Operands>
        struct GetModifierProxy {};
 
        template <query::Queryable... Qs>
        struct GetModifierProxy<util::meta::Traits<Qs...>> {
            template <query::Modifier M, typename ModifierAllocator>
            [[nodiscard]] static constexpr M &get(Registry &registry, ModifierAllocator &allocator)
            {
                return allocator.template instanciate<M>(
                    getRegistryQueryable<Qs, ModifierAllocator>(registry, allocator)...);
            }
 
          private:
            template <typename Q, typename ModifierAllocator>
            [[nodiscard]] static constexpr Q &getRegistryQueryable(Registry &registry, ModifierAllocator &allocator)
            {
                if constexpr (RegistryModifier<Q> || query::Modifier<Q>)
                    return registry.getQueryable<Q, ModifierAllocator>(allocator);
                else
                    return registry.getQueryable<Q>();
            }
        };
 
        template <query::Modifier M, typename ModifierAllocator>
        [[nodiscard]] constexpr M &getQueryable(ModifierAllocator &allocator)
        {
            return GetModifierProxy<typename M::Operands>::template get<M, ModifierAllocator>(*this, allocator);
        }
 
        template <RegistryModifier M, typename ModifierAllocator>
        [[nodiscard]] constexpr typename M::Modifier &getQueryable(ModifierAllocator &allocator)
        {
            return getQueryable<typename M::Modifier, ModifierAllocator>(allocator);
        }
 
        template <typename Selects, typename Missings, typename Conditions, bool AutoLock, typename... Cs>
        class RegistryStackQueryMemory {};
 
        template <typename... Selects, typename... Missings, typename... Conditions, bool AutoLock, typename... Cs>
        class RegistryStackQueryMemory<util::meta::Traits<Selects...>, util::meta::Traits<Missings...>,
            util::meta::Traits<Conditions...>, AutoLock, Cs...> {
          public:
            // clang-format off
                using ModifiersAllocatorSize =  modifiers_allocator_size<Missings..., Cs...>;
                using HasModifiersAllocator = std::bool_constant<ModifiersAllocatorSize::value != 0>;
                using ModifiersAllocator = std::conditional_t<
                    HasModifiersAllocator::value,
                    util::StackAllocator<ModifiersAllocatorSize::value, query::modifier::ModifierBase>,
                    EmptyType
                >;
                
                using ViewsAllocatorSize = ecstasy::query::views_allocator_size<AutoLock, queryable_type_t<Missings>..., queryable_type_t<Cs>...>;
                using HasViewsAllocator = std::bool_constant<ViewsAllocatorSize::value != 0>;
                using ViewsAllocator = std::conditional_t<
                    AutoLock && HasViewsAllocator::value,
                    util::StackAllocator<ViewsAllocatorSize::value, thread::LockableViewBase>,
                    EmptyType
                >;
 
                template <typename Q>
                using QueryableType = ecstasy::query::thread_safe_queryable_t<queryable_type_t<Q>, AutoLock>;
 
            // clang-format on
 
            RegistryStackQueryMemory(){};
 
            template <typename Q>
            [[nodiscard]] constexpr QueryableType<Q> &getQueryable(Registry &registry)
            {
                if constexpr (AutoLock && HasViewsAllocator::value && thread::Lockable<queryable_type_t<Q>>)
                    return _viewsAllocator.template instanciate<thread::LockableView<queryable_type_t<Q>>>(
                        getRegistryQueryable<Q>(registry));
                else
                    return getRegistryQueryable<Q>(registry);
            }
 
          protected:
            NO_UNIQUE_ADDRESS ModifiersAllocator _modifiersAllocator;
            NO_UNIQUE_ADDRESS ViewsAllocator _viewsAllocator;
 
          private:
            template <typename Q>
            [[nodiscard]] constexpr auto &getRegistryQueryable(Registry &registry)
            {
                if constexpr (HasModifiersAllocator::value && (RegistryModifier<Q> || query::Modifier<Q>))
                    return registry.getQueryable<Q, ModifiersAllocator>(_modifiersAllocator);
                else
                    return registry.getQueryable<Q>();
            }
        };
 
        template <typename Selects, typename Missings, typename Condition, typename Cs,
            bool AutoLock = thread::AUTO_LOCK_DEFAULT>
        class RegistryStackQuery {};
 
        // clang-format on
 
        template <bool AutoLock, typename... Selects>
        // clang-format off
        using RegistrySelectStackQueryMemory = RegistryStackQueryMemory<
            util::meta::Traits<Selects...>,
            util::meta::Traits<>,
            util::meta::Traits<>,
            AutoLock,
            Selects...
        >;
 
        template <bool AutoLock, typename... Selects>
        // clang-format off
        using RegistrySelectStackQuery = RegistryStackQuery<
            util::meta::Traits<Selects...>,
            util::meta::Traits<>,
            util::meta::Traits<>,
            util::meta::Traits<Selects...>,
            AutoLock
        >;
        // clang-format on
 
        template <typename... Selects, typename... Missings, typename Conditions, typename... Cs, bool AutoLock>
        class RegistryStackQuery<util::meta::Traits<Selects...>, util::meta::Traits<Missings...>, Conditions,
            util::meta::Traits<Cs...>, AutoLock>
            // clang-format off
            : public RegistryStackQueryMemory<
                        util::meta::Traits<Selects...>, 
                        util::meta::Traits<Missings...>,
                        Conditions, 
                        AutoLock, 
                        Cs...>,
              public query::QueryImplementation<util::meta::Traits<
                    typename RegistryStackQueryMemory<
                        util::meta::Traits<Selects...>, 
                        util::meta::Traits<Missings...>,
                        Conditions, 
                        AutoLock, 
                        Cs...>::template QueryableType<Selects>...>,
                    Conditions> 
            {
              public:
                using Memory = RegistryStackQueryMemory<
                    util::meta::Traits<Selects...>, 
                    util::meta::Traits<Missings...>,
                    Conditions, 
                    AutoLock, 
                    Cs...>;
                using Base = ecstasy::query::QueryImplementation<
                    util::meta::Traits<typename Memory::template QueryableType<Selects>...>, 
                    Conditions>;
                
 
                RegistryStackQuery(Registry & registry)
                    : Memory(),
                      Base(std::move(
                        ecstasy::query::Select<
                            typename Memory::template QueryableType<Selects>...>::template 
                        where<Conditions,
                             typename Memory::template QueryableType<Missings>...,
                             typename Memory::template QueryableType<Cs>...
                        >(
                            Memory::template getQueryable<Missings>(registry)...,
                            Memory::template getQueryable<Cs>(registry)...
                        )))
                {
                }
 
            // clang-format on
        };
 
        template <typename... Selects, bool AutoLock>
        class RegistryStackQuery<util::meta::Traits<Selects...>, util::meta::Traits<>, util::meta::Traits<>,
            util::meta::Traits<Selects...>, AutoLock>
            // clang-format off
            : public RegistrySelectStackQueryMemory<AutoLock, Selects...>,
              public query::Query<
                typename RegistrySelectStackQueryMemory<AutoLock, Selects...>::template QueryableType<Selects>...
                >
            {
          public:
            using Memory = RegistrySelectStackQueryMemory<AutoLock, Selects...>;
            using Base = query::Query<
                typename Memory::template QueryableType<Selects>...
            >;
 
            RegistryStackQuery(Registry &registry)
                : Memory(),
                    Base(Memory::template getQueryable<Selects>(registry)...)
            {
            }
        };
        
 
      public:
        class EntityBuilder {
          public:
            EntityBuilder(const EntityBuilder &other) = delete;
 
            template <typename C, typename... Qs, typename... Args>
            EntityBuilder &with(Args &&...args)
            {
                _builder.with(_registry.getStorageSafe<C>(), _registry.getFromType<Qs>()..., std::forward<Args>(args)...);
                return *this;
            }
 
            template <typename C>
                requires requires() { typename C::value_type; }
            EntityBuilder &with(std::initializer_list<typename C::value_type> list)
            {
                _builder.with(_registry.getStorageSafe<C>(), list);
                return *this;
            }
 
            Entity build();
 
            [[nodiscard]] const Entity &getEntity() const noexcept
            {
                return _builder.getEntity();
            }
 
            [[nodiscard]] constexpr const Registry &getRegistry() const noexcept
            {
                return _registry;
            }
 
            [[nodiscard]] constexpr Registry &getRegistry() noexcept
            {
                return _registry;
            }
 
          private:
            Registry &_registry;
            Entities::Builder _builder;
 
            EntityBuilder(Registry &registry) noexcept;
 
            friend Registry;
        };
 
        template <query::Queryable... Selects>
        class Select {
          private:
            template <typename T>
            struct IsCondition : public std::is_base_of<ecstasy::query::ConditionBase, T> {};
 
            template <typename T>
            struct IsNotCondition : std::integral_constant<bool, !IsCondition<T>::value> {};
 
            // clang-format off
            using SelectsTraits = util::meta::Traits<Selects...>;
            template <typename... Cs>
            using MissingsTraits = util::meta::right_outer_join_t<
                util::meta::apply_t<queryable_type_t, 
                    util::meta::filter_t<IsNotCondition, Cs...>>,
                    util::meta::Traits<Selects...>
                >;
            template <typename... Cs>
            using ComponentsTraits = util::meta::filter_t<IsNotCondition, Cs...>;
            template <typename... Cs>
            using ConditionsTraits = util::meta::filter_t<IsCondition, Cs...>;
            template <typename... Cs>
            using QueryType = query::QueryImplementation<SelectsTraits, ConditionsTraits<Cs...>>;
            // clang-format on
 
          public:
            Select(Registry &registry) noexcept : _registry(registry)
            {
            }
 
            // clang-format off
            template <typename C, typename... Cs>
            [[nodiscard]] RegistryStackQuery<
                        SelectsTraits,
                        MissingsTraits<C, Cs...>,
                        ConditionsTraits<C, Cs...>,
                        ComponentsTraits<C, Cs...>
                    >
            where()
            {
                    return RegistryStackQuery<
                        SelectsTraits,
                        MissingsTraits<C, Cs...>,
                        ConditionsTraits<C, Cs...>,
                        ComponentsTraits<C, Cs...>
                    >(_registry);
            }
 
            template <bool AutoLock, typename C, typename... Cs>
            [[nodiscard]] RegistryStackQuery<
                        SelectsTraits,
                        MissingsTraits<C, Cs...>,
                        ConditionsTraits<C, Cs...>,
                        ComponentsTraits<C, Cs...>,
                        AutoLock
                    >
            whereEx()
            {
                    return RegistryStackQuery<
                        SelectsTraits,
                        MissingsTraits<C, Cs...>,
                        ConditionsTraits<C, Cs...>,
                        ComponentsTraits<C, Cs...>,
                        AutoLock
                    >(_registry);
            }
            // clang-format on
 
          private:
            Registry &_registry;
        };
 
        Registry(bool addEntities = true);
 
        ~Registry() = default;
 
        [[nodiscard]] EntityBuilder entityBuilder() noexcept;
 
        template <std::derived_from<ISystem> S,
            Pipeline::PhaseId Phase = static_cast<Pipeline::PhaseId>(Pipeline::PredefinedPhases::OnUpdate),
            typename... Args>
        S &addSystem(Args &&...args)
        {
            return addSystemInPhase<S>(Phase, std::forward<Args>(args)...);
        }
 
        template <std::derived_from<ISystem> S, util::meta::is_size_t_convertible T, typename... Args>
        S &addSystemInPhase(T phaseId, Args &&...args)
        {
            S &system = _systems.emplace<S>(std::forward<Args>(args)...);
 
            _pipeline.addSystem(typeid(S), static_cast<size_t>(phaseId));
            return system;
        }
 
        template <std::derived_from<IResource> R, typename... Args>
        R &addResource(Args &&...args)
        {
            return _resources.emplace<R>(std::forward<Args>(args)...);
        }
 
        template <typename C>
        getStorageType<C> &addStorage()
        {
            return _storages.emplace<getStorageType<C>>();
        }
 
        template <std::derived_from<IResource> R>
        [[nodiscard]] bool hasResource() const
        {
            return _resources.contains<R>();
        }
 
        template <std::derived_from<IResource> R, bool Locked = thread::AUTO_LOCK_RESOURCES_DEFAULT>
        [[nodiscard]] ResourceReference<const R, Locked> getResource() const
        {
            return _resources.get<R>();
        }
 
        template <std::derived_from<IResource> R, bool Locked = thread::AUTO_LOCK_RESOURCES_DEFAULT>
        [[nodiscard]] ResourceReference<R, Locked> getResource()
        {
            return _resources.get<R>();
        }
 
        template <typename C>
        [[nodiscard]] const getStorageType<C> &getStorage() const
        {
            return _storages.get<getStorageType<C>>();
        }
 
        template <typename C>
        [[nodiscard]] getStorageType<C> &getStorage()
        {
            return _storages.get<std::remove_const_t<getStorageType<C>>>();
        }
 
        template <typename C>
        [[nodiscard]] getStorageType<C> &getStorageSafe() noexcept
        {
            if (!_storages.contains<std::remove_const_t<getStorageType<C>>>()) [[unlikely]]
                addStorage<std::remove_const_t<C>>();
            return _storages.get<getStorageType<std::remove_const_t<C>>>();
        }
 
        template <bool Locked = thread::AUTO_LOCK_RESOURCES_DEFAULT>
        [[nodiscard]] ResourceReference<const Entities, Locked> getEntities() const
        {
            return _resources.get<Entities>();
        }
 
        template <bool Locked = thread::AUTO_LOCK_RESOURCES_DEFAULT>
        [[nodiscard]] ResourceReference<Entities, Locked> getEntities()
        {
            return _resources.get<Entities>();
        }
 
        [[nodiscard]] Entity getEntity(Entity::Index index);
 
        [[nodiscard]] std::vector<std::reference_wrapper<IStorage>> getEntityStorages(Entity entity);
 
        template <std::derived_from<ISystem> S>
        [[nodiscard]] S &getSystem()
        {
            return _systems.get<S>();
        }
 
        // clang-format off
        template <typename C, typename... Cs>
        [[nodiscard]] RegistrySelectStackQuery<thread::AUTO_LOCK_DEFAULT, queryable_type_t<C>, queryable_type_t<Cs>...>
        query()
        {
            return RegistrySelectStackQuery<thread::AUTO_LOCK_DEFAULT, queryable_type_t<C>, queryable_type_t<Cs>...>(*this);
        }
 
 
        template <bool AutoLock, typename C, typename... Cs>
        [[nodiscard]] RegistrySelectStackQuery<AutoLock, queryable_type_t<C>, queryable_type_t<Cs>...>
        queryEx()
        {
            return RegistrySelectStackQuery<AutoLock, queryable_type_t<C>, queryable_type_t<Cs>...>(*this);
        }
        // clang-format on
 
        template <typename C, typename... Cs>
        [[nodiscard]] Select<queryable_type_t<C>, queryable_type_t<Cs>...> select()
        {
            return Select<queryable_type_t<C>, queryable_type_t<Cs>...>(*this);
        }
 
        bool eraseEntity(Entity entity);
 
        size_t eraseEntities(std::span<Entity> entities);
 
        void clear();
 
        template <std::derived_from<ISystem> S>
        void runSystem()
        {
            _systems.get<S>().run(*this);
        }
 
        void runSystem(const std::type_index &systemId);
 
        void runSystems();
 
        void runSystemsPhase(Pipeline::PhaseId phase);
 
        [[nodiscard]] constexpr const Instances<IStorage> &getStorages() const noexcept
        {
            return _storages;
        }
 
        [[nodiscard]] constexpr Instances<IStorage> &getStorages() noexcept
        {
            return _storages;
        }
 
        [[nodiscard]] constexpr Pipeline &getPipeline() noexcept
        {
            return _pipeline;
        }
 
        [[nodiscard]] constexpr const Pipeline &getPipeline() const noexcept
        {
            return _pipeline;
        }
 
      private:
        Instances<IResource> _resources;
        Instances<IStorage> _storages;
        Instances<ISystem> _systems;
        Pipeline _pipeline;
 
        void eraseEntityComponents(Entity entity);
 
        void eraseEntitiesComponents(std::span<Entity> entities);
    };
} // namespace ecstasy
 
#endif /* !ECSTASY_REGISTRY_REGISTRY_HPP_ */