entity.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "entity_view.hpp"
#include "mixins/entity/builder.hpp"
 
namespace flecs
{
 
struct entity : entity_builder<entity>
{
    entity() : entity_builder<entity>() { }
 
    explicit entity(world_t *world)
        : entity_builder()
    {
        m_world = world;
        m_id = ecs_new(world, 0);
    }
 
    explicit entity(const flecs::world_t *world, flecs::entity_t id) {
        m_world = const_cast<flecs::world_t*>(world);
        m_id = id;
    }
 
    explicit entity(world_t *world, const char *name)
        : entity_builder()
    {
        m_world = world;
 
        ecs_entity_desc_t desc = {};
        desc.name = name;
        desc.sep = "::";
        desc.root_sep = "::";
        m_id = ecs_entity_init(world, &desc);
    }
 
    explicit entity(entity_t id)
        : entity_builder( nullptr, id ) { }
 
    #ifndef ensure
 
    template <typename T>
    T& ensure() const {
        auto comp_id = _::cpp_type<T>::id(m_world);
        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
        return *static_cast<T*>(ecs_ensure_id(m_world, m_id, comp_id));
    }
 
    void* ensure(entity_t comp) const {
        return ecs_ensure_id(m_world, m_id, comp);
    }
 
    template <typename First, typename Second, typename P = pair<First, Second>,
        typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
    A& ensure() const {
        return *static_cast<A*>(ecs_ensure_id(m_world, m_id, ecs_pair(
            _::cpp_type<First>::id(m_world),
            _::cpp_type<Second>::id(m_world))));
    }
 
    template <typename First>
    First& ensure(entity_t second) const {
        auto comp_id = _::cpp_type<First>::id(m_world);
        ecs_assert(_::cpp_type<First>::size() != 0, ECS_INVALID_PARAMETER, NULL);
        return *static_cast<First*>(
            ecs_ensure_id(m_world, m_id, ecs_pair(comp_id, second)));
    }
 
    void* ensure(entity_t first, entity_t second) const {
        return ecs_ensure_id(m_world, m_id, ecs_pair(first, second));
    }
 
    #endif
 
    template <typename Second>
    Second& ensure_second(entity_t first) const {
        auto second = _::cpp_type<Second>::id(m_world);
        ecs_assert(_::cpp_type<Second>::size() != 0, ECS_INVALID_PARAMETER, NULL);
        return *static_cast<Second*>(
            ecs_ensure_id(m_world, m_id, ecs_pair(first, second)));
    }
 
    template <typename T>
    void modified() const {
        auto comp_id = _::cpp_type<T>::id(m_world);
        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
        this->modified(comp_id);
    }
 
    template <typename First, typename Second>
    void modified() const {
        this->modified<First>(_::cpp_type<Second>::id(m_world));
    }
 
    template <typename First>
    void modified(entity_t second) const {
        auto first = _::cpp_type<First>::id(m_world);
        ecs_assert(_::cpp_type<First>::size() != 0, ECS_INVALID_PARAMETER, NULL);
        this->modified(first, second);
    }
 
    void modified(entity_t first, entity_t second) const {
        this->modified(ecs_pair(first, second));
    }
 
    void modified(entity_t comp) const {
        ecs_modified_id(m_world, m_id, comp);
    }
 
    template <typename T, if_t< is_actual<T>::value > = 0>
    ref<T> get_ref() const {
        return ref<T>(m_world, m_id, _::cpp_type<T>::id(m_world));
    }
 
    template <typename T, typename A = actual_type_t<T>, if_t< flecs::is_pair<T>::value > = 0>
    ref<A> get_ref() const {
        return ref<A>(m_world, m_id,
                      ecs_pair(_::cpp_type<typename T::first>::id(m_world),
                               _::cpp_type<typename T::second>::id(m_world)));
    }
 
 
    template <typename First, typename Second, typename P = flecs::pair<First, Second>,
        typename A = actual_type_t<P>>
    ref<A> get_ref() const {
        return ref<A>(m_world, m_id,
            ecs_pair(_::cpp_type<First>::id(m_world),
                _::cpp_type<Second>::id(m_world)));
    }
 
    template <typename First>
    ref<First> get_ref(flecs::entity_t second) const {
        return ref<First>(m_world, m_id,
            ecs_pair(_::cpp_type<First>::id(m_world), second));
    }
 
    template <typename Second>
    ref<Second> get_ref_second(flecs::entity_t first) const {
        return ref<Second>(m_world, m_id,
            ecs_pair(first, _::cpp_type<Second>::id(m_world)));
    }
 
    void flatten(flecs::entity_t r, const ecs_flatten_desc_t *desc = nullptr) {
        ecs_flatten(m_world, ecs_pair(r, m_id), desc);
    }
 
    void clear() const {
        ecs_clear(m_world, m_id);
    }
 
    void destruct() const {
        ecs_delete(m_world, m_id);
    }
 
    flecs::entity_view view() const {
        return flecs::entity_view(
            const_cast<flecs::world_t*>(ecs_get_world(m_world)), m_id);
    }
 
    static
    flecs::entity null(const flecs::world_t *world) {
        flecs::entity result;
        result.m_world = const_cast<flecs::world_t*>(world);
        return result;
    }
 
    static
    flecs::entity null() {
        return flecs::entity();
    }
 
#   ifdef FLECS_JSON
#   include "mixins/json/entity.inl"
#   endif
};
 
} // namespace flecs