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()
    {
        world_ = world;
        if (!ecs_get_scope(world_) && !ecs_get_with(world_)) {
            id_ = ecs_new(world);
        } else {
            ecs_entity_desc_t desc = {};
            id_ = ecs_entity_init(world_, &desc);
        }
    }
 
    explicit entity(const flecs::world_t *world, flecs::entity_t id) {
        world_ = const_cast<flecs::world_t*>(world);
        id_ = id;
    }
 
    explicit entity(world_t *world, const char *name)
        : entity_builder()
    {
        world_ = world;
 
        ecs_entity_desc_t desc = {};
        desc.name = name;
        desc.sep = "::";
        desc.root_sep = "::";
        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 = _::type<T>::id(world_);
        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        return *static_cast<T*>(ecs_ensure_id(world_, id_, comp_id));
    }
 
    void* ensure(entity_t comp) const {
        return ecs_ensure_id(world_, 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(world_, id_, ecs_pair(
            _::type<First>::id(world_),
            _::type<Second>::id(world_))));
    }
 
    template <typename First>
    First& ensure(entity_t second) const {
        auto comp_id = _::type<First>::id(world_);
        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        return *static_cast<First*>(
            ecs_ensure_id(world_, id_, ecs_pair(comp_id, second)));
    }
 
    void* ensure(entity_t first, entity_t second) const {
        return ecs_ensure_id(world_, id_, ecs_pair(first, second));
    }
 
    template <typename Second>
    Second& ensure_second(entity_t first) const {
        auto second = _::type<Second>::id(world_);
        ecs_assert(_::type<Second>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        return *static_cast<Second*>(
            ecs_ensure_id(world_, id_, ecs_pair(first, second)));
    }
 
    #endif
 
    template <typename T>
    void modified() const {
        auto comp_id = _::type<T>::id(world_);
        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        this->modified(comp_id);
    }
 
    template <typename First, typename Second>
    void modified() const {
        this->modified<First>(_::type<Second>::id(world_));
    }
 
    template <typename First>
    void modified(entity_t second) const {
        auto first = _::type<First>::id(world_);
        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        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(world_, id_, comp);
    }
 
    template <typename T, if_t< is_actual<T>::value > = 0>
    ref<T> get_ref() const {
        return ref<T>(world_, id_, _::type<T>::id(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>(world_, id_,
                      ecs_pair(_::type<typename T::first>::id(world_),
                               _::type<typename T::second>::id(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>(world_, id_,
            ecs_pair(_::type<First>::id(world_),
                _::type<Second>::id(world_)));
    }
 
    template <typename First>
    ref<First> get_ref(flecs::entity_t second) const {
        return ref<First>(world_, id_,
            ecs_pair(_::type<First>::id(world_), second));
    }
 
    template <typename Second>
    ref<Second> get_ref_second(flecs::entity_t first) const {
        return ref<Second>(world_, id_,
            ecs_pair(first, _::type<Second>::id(world_)));
    }
 
    void clear() const {
        ecs_clear(world_, id_);
    }
 
    void destruct() const {
        ecs_delete(world_, id_);
    }
 
    flecs::entity_view view() const {
        return flecs::entity_view(
            const_cast<flecs::world_t*>(ecs_get_world(world_)), id_);
    }
 
    static
    flecs::entity null(const flecs::world_t *world) {
        flecs::entity result;
        result.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