registry.hpp

Go to the documentation of this file.

#pragma once
 
#include <co_ecs/base_registry.hpp>
#include <co_ecs/entity_ref.hpp>
#include <co_ecs/view_arguments.hpp>
 
 
namespace co_ecs {
 
class registry : public base_registry {
public:
    template<component... Components>
    constexpr auto create(Components&&... args) -> entity_ref {
        return get_entity(create_impl(std::forward<Components>(args)...));
    }
 
    [[nodiscard]]
    constexpr auto get_entity(entity ent) noexcept -> entity_ref {
        return entity_ref{ *this, ent };
    }
 
    [[nodiscard]]
    constexpr auto get_entity(entity ent) const noexcept -> const_entity_ref {
        return const_entity_ref{ *this, ent };
    }
 
    [[nodiscard]]
    constexpr auto get_entity_const(entity ent) const noexcept -> const_entity_ref {
        return get_entity(ent);
    }
 
    template<component_reference... Args>
    constexpr auto view() -> co_ecs::view<Args...>
        requires(!const_component_references_v<Args...>)
    {
 
        return co_ecs::view<Args...>{ *this };
    }
 
    template<component_reference... Args>
    constexpr auto view() const -> co_ecs::view<Args...>
        requires const_component_references_v<Args...>
    {
        return co_ecs::view<Args...>{ *this };
    }
 
    template<component_reference... Args>
    constexpr auto single() -> std::optional<std::tuple<Args...>>
        requires(!const_component_references_v<Args...>)
    {
        return view<Args...>().single();
    }
 
    template<component_reference... Args>
    constexpr auto single() const -> std::optional<std::tuple<Args...>>
        requires const_component_references_v<Args...>
    {
        return view<Args...>().single();
    }
 
    template<typename F>
    constexpr void each(F&& func)
        requires(!detail::func_decomposer<F>::is_const)
    {
        using view_t = typename detail::func_decomposer<F>::view_t;
        view_t{ *this }.each(std::forward<F>(func));
    }
 
    template<typename F>
    constexpr void each(F&& func) const
        requires(detail::func_decomposer<F>::is_const)
    {
        using view_t = typename detail::func_decomposer<F>::view_t;
        view_t{ *this }.each(std::forward<F>(func));
    }
 
    [[nodiscard]] constexpr std::size_t size() const noexcept {
        return _entity_archetype_map.size();
    }
 
    [[nodiscard]] constexpr bool empty() const noexcept {
        return _entity_archetype_map.empty();
    }
};
 
} // namespace co_ecs