actor.hpp

#ifndef ENTT_ENTITY_ACTOR_HPP
#define ENTT_ENTITY_ACTOR_HPP
 
 
#include <utility>
#include <type_traits>
#include "../config/config.h"
#include "registry.hpp"
#include "entity.hpp"
#include "fwd.hpp"
 
 
namespace entt {
 
 
template<typename Entity>
struct basic_actor {
    using registry_type = basic_registry<Entity>;
    using entity_type = Entity;
 
    basic_actor() ENTT_NOEXCEPT
        : entt{entt::null}, reg{nullptr}
    {}
 
    basic_actor(basic_actor &&other) ENTT_NOEXCEPT
        : entt{other.entt}, reg{other.reg}
    {
        other.entt = null;
    }
 
    explicit basic_actor(registry_type &ref)
        : entt{ref.create()}, reg{&ref}
    {}
 
    explicit basic_actor(entity_type entity, registry_type &ref) ENTT_NOEXCEPT
        : entt{entity}, reg{&ref}
    {
        ENTT_ASSERT(ref.valid(entity));
    }
 
    virtual ~basic_actor() {
        if(*this) {
            reg->destroy(entt);
        }
    }
 
    basic_actor & operator=(basic_actor &&other) ENTT_NOEXCEPT {
        if(this != &other) {
            auto tmp{std::move(other)};
            std::swap(reg, tmp.reg);
            std::swap(entt, tmp.entt);
        }
 
        return *this;
    }
 
    template<typename Component, typename... Args>
    decltype(auto) assign(Args &&... args) {
        return reg->template assign_or_replace<Component>(entt, std::forward<Args>(args)...);
    }
 
    template<typename Component>
    void remove() {
        reg->template remove<Component>(entt);
    }
 
    template<typename... Component>
    bool has() const {
        return reg->template has<Component...>(entt);
    }
 
    template<typename... Component>
    decltype(auto) get() const {
        return std::as_const(*reg).template get<Component...>(entt);
    }
 
    template<typename... Component>
    decltype(auto) get() {
        return reg->template get<Component...>(entt);
    }
 
    template<typename... Component>
    auto try_get() const {
        return std::as_const(*reg).template try_get<Component...>(entt);
    }
 
    template<typename... Component>
    auto try_get() {
        return reg->template try_get<Component...>(entt);
    }
 
    const registry_type & backend() const ENTT_NOEXCEPT {
        return *reg;
    }
 
    registry_type & backend() ENTT_NOEXCEPT {
        return const_cast<registry_type &>(std::as_const(*this).backend());
    }
 
    entity_type entity() const ENTT_NOEXCEPT {
        return entt;
    }
 
    explicit operator bool() const {
        return reg && reg->valid(entt);
    }
 
private:
    entity_type entt;
    registry_type *reg;
};
 
 
}
 
 
#endif