handle.hpp

#ifndef ENTT_ENTITY_HANDLE_HPP
#define ENTT_ENTITY_HANDLE_HPP
 
 
#include "registry.hpp"
 
 
namespace entt {
 
 
template<typename Entity>
struct basic_handle {
    using entity_type = std::remove_const_t<Entity>;
 
    using registry_type = std::conditional_t<
        std::is_const_v<Entity>,
        const basic_registry<entity_type>,
        basic_registry<entity_type>
    >;
 
    basic_handle(registry_type &ref, entity_type value = null) ENTT_NOEXCEPT
        : reg{&ref}, entt{value}
    {}
 
    basic_handle & operator=(const entity_type value) ENTT_NOEXCEPT {
        entt = value;
        return *this;
    }
 
    basic_handle & operator=(null_t) ENTT_NOEXCEPT {
        return (*this = static_cast<entity_type>(null));
    }
 
    [[nodiscard]] operator basic_handle<const entity_type>() const ENTT_NOEXCEPT {
        return {*reg, entt};
    }
 
    [[nodiscard]] operator entity_type() const ENTT_NOEXCEPT {
        return entity();
    }
 
    [[nodiscard]] explicit operator bool() const {
        return reg->valid(entt);
    }
 
    [[nodiscard]] registry_type & registry() const ENTT_NOEXCEPT {
        return *reg;
    }
 
    [[nodiscard]] entity_type entity() const ENTT_NOEXCEPT {
        return entt;
    }
 
    template<typename Component, typename... Args>
    decltype(auto) emplace(Args &&... args) const {
        return reg->template emplace<Component>(entt, std::forward<Args>(args)...);
    }
 
    template<typename Component, typename... Args>
    decltype(auto) emplace_or_replace(Args &&... args) const {
        return reg->template emplace_or_replace<Component>(entt, std::forward<Args>(args)...);
    }
 
    template<typename Component, typename... Func>
    decltype(auto) patch(Func &&... func) const {
        return reg->template patch<Component>(entt, std::forward<Func>(func)...);
    }
 
    template<typename Component, typename... Args>
    decltype(auto) replace(Args &&... args) const {
        return reg->template replace<Component>(entt, std::forward<Args>(args)...);
    }
 
    template<typename... Components>
    void remove() const {
        reg->template remove<Components...>(entt);
    }
 
    template<typename... Components>
    decltype(auto) remove_if_exists() const {
        return reg->template remove_if_exists<Components...>(entt);
    }
 
    void remove_all() const {
        reg->remove_all(entt);
    }
 
    template<typename... Components>
    [[nodiscard]] decltype(auto) has() const {
        return reg->template has<Components...>(entt);
    }
 
    template<typename... Components>
    [[nodiscard]] decltype(auto) any() const {
        return reg->template any<Components...>(entt);
    }
 
    template<typename... Components>
    [[nodiscard]] decltype(auto) get() const {
        return reg->template get<Components...>(entt);
    }
 
    template<typename Component, typename... Args>
    [[nodiscard]] decltype(auto) get_or_emplace(Args &&... args) const {
        return reg->template get_or_emplace<Component>(entt, std::forward<Args>(args)...);
    }
 
    template<typename... Components>
    [[nodiscard]] decltype(auto) try_get() const {
        return reg->template try_get<Components...>(entt);
    }
 
    [[nodiscard]] bool orphan() const {
        return reg->orphan(entt);
    }
 
    template<typename Func>
    void visit(Func &&func) const {
        reg->visit(entt, std::forward<Func>(func));
    }
 
private:
    registry_type *reg;
    entity_type entt;
};
 
 
template<typename Entity>
basic_handle(basic_registry<Entity> &, Entity) -> basic_handle<Entity>;
 
 
template<typename Entity>
basic_handle(const basic_registry<Entity> &, Entity) -> basic_handle<const Entity>;
 
 
}
 
 
#endif