entity_view.hpp

Go to the documentation of this file.

 
#pragma once
 
namespace flecs
{
 
struct entity_view : public id {
 
    entity_view() : flecs::id() { }
 
    explicit entity_view(flecs::world_t *world, flecs::id_t id)
        : flecs::id(world 
            ? const_cast<flecs::world_t*>(ecs_get_world(world))
            : nullptr
        , id ) { }
 
    entity_view(entity_t id) 
        : flecs::id( nullptr, id ) { }
 
    entity_t id() const {
        return m_id;
    }
 
    bool is_valid() const {
        return m_world && ecs_is_valid(m_world, m_id);
    }
  
    explicit operator bool() const {
        return is_valid();
    }
 
    bool is_alive() const {
        return m_world && ecs_is_alive(m_world, m_id);
    }
 
    flecs::string_view name() const {
        return flecs::string_view(ecs_get_name(m_world, m_id));
    }
 
    flecs::string_view symbol() const {
        return flecs::string_view(ecs_get_symbol(m_world, m_id));
    }
 
    flecs::string path(const char *sep = "::", const char *init_sep = "::") const {
        char *path = ecs_get_path_w_sep(m_world, 0, m_id, sep, init_sep);
        return flecs::string(path);
    }   
 
    bool enabled() const {
        return !ecs_has_id(m_world, m_id, flecs::Disabled);
    }
 
    flecs::type type() const;
 
    flecs::table table() const;
 
    flecs::table_range range() const;
 
    template <typename Func>
    void each(const Func& func) const;
 
    template <typename Func>
    void each(flecs::id_t first, flecs::id_t second, const Func& func) const;
 
    template <typename Func>
    void each(const flecs::entity_view& rel, const Func& func) const;
 
    template <typename First, typename Func>
    void each(const Func& func) const { 
        return each(_::cpp_type<First>::id(m_world), func);
    }
 
    template <typename Func>
    void children(flecs::entity_t rel, Func&& func) const {
        flecs::world world(m_world);
 
        ecs_term_t terms[2];
        ecs_filter_t f = ECS_FILTER_INIT;
        f.terms = terms;
        f.term_count = 2;
 
        ecs_filter_desc_t desc = {};
        desc.terms[0].id = ecs_pair(rel, m_id);
        desc.terms[1].id = flecs::Prefab;
        desc.terms[1].oper = EcsOptional;
        desc.storage = &f;
        ecs_filter_init(m_world, &desc);
 
        ecs_iter_t it = ecs_filter_iter(m_world, &f);
        while (ecs_filter_next(&it)) {
            _::each_invoker<Func>(FLECS_MOV(func)).invoke(&it);
        }
 
        ecs_filter_fini(&f);
    }
 
    template <typename Rel, typename Func>
    void children(Func&& func) const {
        children(_::cpp_type<Rel>::id(m_world), FLECS_MOV(func));
    }
 
    template <typename Func>
    void children(Func&& func) const {
        children(flecs::ChildOf, FLECS_MOV(func));
    }
 
    template <typename T, if_t< is_actual<T>::value > = 0>
    const T* get() const {
        auto comp_id = _::cpp_type<T>::id(m_world);
        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
        return static_cast<const T*>(ecs_get_id(m_world, m_id, comp_id));
    }
 
    template <typename T, typename A = actual_type_t<T>, 
        if_t< flecs::is_pair<T>::value > = 0>
    const A* get() const {
        auto comp_id = _::cpp_type<T>::id(m_world);
        ecs_assert(_::cpp_type<A>::size() != 0, ECS_INVALID_PARAMETER, NULL);
        return static_cast<const A*>(ecs_get_id(m_world, m_id, comp_id));
    }
 
    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>
    const A* get() const {
        return this->get<P>();
    }
 
    template<typename First, typename Second, if_not_t< is_enum<Second>::value> = 0>
    const First* get(Second 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<const First*>(
            ecs_get_id(m_world, m_id, ecs_pair(comp_id, second)));
    }
 
    template<typename First, typename Second, if_t<is_enum<Second>::value> = 0>
    const First* get(Second constant) const {
        const auto& et = enum_type<Second>(this->m_world);
        flecs::entity_t target = et.entity(constant);
        return get<First>(target);
    }
 
    const void* get(flecs::id_t comp) const {
        return ecs_get_id(m_world, m_id, comp);
    }
 
    const void* get(flecs::entity_t first, flecs::entity_t second) const {
        return ecs_get_id(m_world, m_id, ecs_pair(first, second));
    }
 
    template <typename Func, if_t< is_callable<Func>::value > = 0>
    bool get(const Func& func) const;
 
    template <typename T, if_t< is_enum<T>::value > = 0>
    const T* get() const;
 
    template<typename Second>
    const Second* get_second(flecs::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<const Second*>(
            ecs_get_id(m_world, m_id, ecs_pair(first, second)));
    }
 
    template<typename First, typename Second>
    const Second* get_second() const {
        return get<pair_object<First, Second>>();
    }
 
    template<typename First>
    flecs::entity target(int32_t index = 0) const;
 
    flecs::entity target(flecs::entity_t first, int32_t index = 0) const;
 
    flecs::entity target_for(flecs::entity_t relationship, flecs::id_t id) const;
 
    template <typename T>
    flecs::entity target_for(flecs::entity_t relationship) const;
 
    template <typename First, typename Second>
    flecs::entity target_for(flecs::entity_t relationship) const;
 
    int32_t depth(flecs::entity_t rel) const {
        return ecs_get_depth(m_world, m_id, rel);
    }
 
    template<typename Rel>
    int32_t depth() const {
        return this->depth(_::cpp_type<Rel>::id(m_world));
    }
 
    flecs::entity parent() const;
    
    flecs::entity lookup(const char *path) const;
 
    bool has(flecs::id_t e) const {
        return ecs_has_id(m_world, m_id, e);
    }     
 
    template <typename T>
    bool has() const {
        flecs::id_t cid = _::cpp_type<T>::id(m_world);
        bool result = ecs_has_id(m_world, m_id, cid);
        if (result) {
            return result;
        }
 
        if (is_enum<T>::value) {
            return ecs_has_pair(m_world, m_id, cid, flecs::Wildcard);
        }
 
        return false;
    }
 
    template <typename E, if_t< is_enum<E>::value > = 0>
    bool has(E value) const {
        auto r = _::cpp_type<E>::id(m_world);
        auto o = enum_type<E>(m_world).entity(value);
        return ecs_has_pair(m_world, m_id, r, o);
    }
 
    template <typename First, typename Second>
    bool has() const {
        return this->has<First>(_::cpp_type<Second>::id(m_world));
    }
 
    template<typename First, typename Second, if_not_t< is_enum<Second>::value > = 0>
    bool has(Second second) const {
        auto comp_id = _::cpp_type<First>::id(m_world);
        return ecs_has_id(m_world, m_id, ecs_pair(comp_id, second));
    }
 
    template <typename Second>
    bool has_second(flecs::entity_t first) const {
        return this->has(first, _::cpp_type<Second>::id(m_world));
    }
 
    template<typename First, typename E, if_t< is_enum<E>::value > = 0>
    bool has(E value) const {
        const auto& et = enum_type<E>(this->m_world);
        flecs::entity_t second = et.entity(value);
        return has<First>(second);
    }
 
    bool has(flecs::id_t first, flecs::id_t second) const {
        return ecs_has_id(m_world, m_id, ecs_pair(first, second));
    }
 
    bool owns(flecs::id_t e) const {
        return ecs_owns_id(m_world, m_id, e);
    }
 
    template <typename First>
    bool owns(flecs::id_t second) const {
        auto comp_id = _::cpp_type<First>::id(m_world);
        return owns(ecs_pair(comp_id, second));
    }
 
    bool owns(flecs::id_t first, flecs::id_t second) const {
        return owns(ecs_pair(first, second));
    }
 
    template <typename T>
    bool owns() const {
        return owns(_::cpp_type<T>::id(m_world));
    }
 
    template <typename First, typename Second>
    bool owns() const {
        return owns(
            _::cpp_type<First>::id(m_world),
            _::cpp_type<Second>::id(m_world));
    }
 
    bool enabled(flecs::id_t id) const {
        return ecs_is_enabled_id(m_world, m_id, id);
    }
 
    template<typename T>
    bool enabled() const {
        return this->enabled(_::cpp_type<T>::id(m_world));
    }
 
    bool enabled(flecs::id_t first, flecs::id_t second) const {
        return this->enabled(ecs_pair(first, second));
    }
 
    template <typename First>
    bool enabled(flecs::id_t second) const {
        return this->enabled(_::cpp_type<First>::id(m_world), second);
    }
 
    template <typename First, typename Second>
    bool enabled() const {
        return this->enabled<First>(_::cpp_type<Second>::id(m_world));
    }
 
    ecs_ftime_t delta_time() const {
        const ecs_world_info_t *stats = ecs_get_world_info(m_world);
        return stats->delta_time;
    }
 
    flecs::entity clone(bool clone_value = true, flecs::entity_t dst_id = 0) const;
 
    flecs::entity mut(const flecs::world& stage) const;
 
    flecs::entity mut(const flecs::iter& it) const;
 
    flecs::entity mut(const flecs::entity_view& e) const;
 
#   ifdef FLECS_JSON
#   include "mixins/json/entity_view.inl"
#   endif
#   ifdef FLECS_DOC
#   include "mixins/doc/entity_view.inl"
#   endif
 
#   include "mixins/enum/entity_view.inl"
 
private:
    flecs::entity set_stage(world_t *stage);
};
 
}