entity_ref.hpp

Go to the documentation of this file.

#pragma once
 
#include <co_ecs/base_registry.hpp>
 
namespace co_ecs {
 
class entity_ref {
public:
    constexpr entity_ref(base_registry& registry, entity entity) noexcept : _entity(entity), _registry(registry) {
    }
 
    [[nodiscard]] constexpr auto archetype() const noexcept -> const archetype& {
        return *_registry.get().get_location(_entity).archetype;
    }
 
    [[nodiscard]] constexpr auto alive() const noexcept -> bool {
        return _registry.get().alive(_entity);
    }
 
    template<component... C>
    [[nodiscard]] constexpr auto has() const noexcept -> bool {
        return _registry.get().template has<C...>(_entity);
    }
 
    template<component C>
    [[nodiscard]] constexpr auto get() -> C& {
        return std::get<0>(base_registry::template get_impl<C>(_registry.get(), _entity));
    }
 
    template<component C>
    [[nodiscard]] constexpr auto get() const -> const C& {
        return std::get<0>(base_registry::template get_impl<C>(_registry.get(), _entity));
    }
 
    template<component C, component O, component... Args>
    [[nodiscard]] constexpr auto get() -> decltype(auto) {
        return base_registry::template get_impl<C, O, Args...>(_registry.get(), _entity);
    }
 
    template<component C, component O, component... Args>
    [[nodiscard]] constexpr auto get() const -> decltype(auto) {
        return base_registry::template get_impl<C, O, Args...>(_registry.get(), _entity);
    }
 
    template<component C>
    [[nodiscard]] constexpr auto get_or_insert(auto&&... args) -> C& {
        auto [inserted, ptr] = _registry.get().set_impl<C>(_entity);
        if (inserted) {
            std::construct_at(ptr, std::forward<decltype(args)>(args)...);
        }
        return *ptr;
    }
 
    template<component C, typename... Args>
    constexpr auto set(Args&&... args) -> entity_ref {
        auto [inserted, ptr] = _registry.get().set_impl<C>(_entity);
        if (inserted) {
            std::construct_at(ptr, std::forward<Args>(args)...);
        } else {
            *ptr = C{ std::forward<Args>(args)... };
        }
        return *this;
    }
 
    template<component C>
    constexpr auto remove() -> entity_ref {
        _registry.get().remove<C>(_entity);
        return *this;
    }
 
    void destroy() {
        _registry.get().destroy(_entity);
    }
 
    constexpr auto visit(auto&& func) {
        _registry.get().visit(_entity, std::forward<decltype(func)>(func));
    }
 
    constexpr auto visit(auto&& func) const {
        static_cast<const base_registry&>(_registry.get()).visit(_entity, std::forward<decltype(func)>(func));
    }
 
    auto clone() const -> entity_ref {
        return entity_ref{ _registry, _registry.get().clone(_entity) };
    }
 
    auto clone(placeholder_entity placeholder) {
        return entity_ref{ _registry, _registry.get().clone(_entity, placeholder) };
    }
 
    auto copy(base_registry& destination) const -> entity_ref {
        return entity_ref{ destination, _registry.get().copy(_entity, destination) };
    }
 
    auto copy(base_registry& destination, placeholder_entity placeholder) const {
        return entity_ref{ destination, _registry.get().copy(_entity, destination, placeholder) };
    }
 
    auto move(base_registry& destination) -> entity_ref {
        return entity_ref{ destination, _registry.get().move(_entity, destination) };
    }
 
    auto move(base_registry& destination, placeholder_entity placeholder) {
        return entity_ref{ destination, _registry.get().move(_entity, destination, placeholder) };
    }
 
    [[nodiscard]] constexpr operator entity() const noexcept {
        return _entity;
    }
 
    [[nodiscard]] constexpr operator bool() const noexcept {
        return _entity.valid();
    }
 
private:
    std::reference_wrapper<base_registry> _registry;
    entity _entity;
};
 
 
class const_entity_ref {
public:
    constexpr const_entity_ref(const base_registry& registry, entity entity) : _entity(entity), _registry(registry) {
    }
 
    [[nodiscard]] constexpr auto archetype() const noexcept -> const archetype& {
        return *_registry.get().get_location(_entity).archetype;
    }
 
    [[nodiscard]] constexpr auto alive() const noexcept -> bool {
        return _registry.get().alive(_entity);
    }
 
    template<component... C>
    [[nodiscard]] constexpr auto has() const noexcept -> bool {
        return _registry.get().template has<C...>(_entity);
    }
 
    template<component C>
    [[nodiscard]] constexpr auto get() const -> const C& {
        return std::get<0>(base_registry::template get_impl<C>(_registry.get(), _entity));
    }
 
    template<component C, component O, component... Args>
    [[nodiscard]] constexpr auto get() const -> decltype(auto) {
        return base_registry::template get_impl<C, O, Args...>(_registry.get(), _entity);
    }
 
    constexpr auto visit(auto&& func) const {
        static_cast<const base_registry&>(_registry.get()).visit(_entity, std::forward<decltype(func)>(func));
    }
 
    auto copy(base_registry& destination) const -> entity_ref {
        return entity_ref{ destination, _registry.get().copy(_entity, destination) };
    }
 
    auto copy(base_registry& destination, placeholder_entity placeholder) const {
        return entity_ref{ destination, _registry.get().copy(_entity, destination, placeholder) };
    }
 
    [[nodiscard]] constexpr operator entity() const noexcept {
        return _entity;
    }
 
    [[nodiscard]] constexpr operator bool() const noexcept {
        return _entity.valid();
    }
 
private:
    std::reference_wrapper<const base_registry> _registry;
    entity _entity;
};
 
} // namespace co_ecs