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 id_;
    }
 
    bool is_valid() const {
        return world_ && ecs_is_valid(world_, id_);
    }
  
    explicit operator bool() const {
        return is_valid();
    }
 
    bool is_alive() const {
        return world_ && ecs_is_alive(world_, id_);
    }
 
    flecs::string_view name() const {
        return flecs::string_view(ecs_get_name(world_, id_));
    }
 
    flecs::string_view symbol() const {
        return flecs::string_view(ecs_get_symbol(world_, id_));
    }
 
    flecs::string path(const char *sep = "::", const char *init_sep = "::") const {
        return path_from(0, sep, init_sep);
    }   
 
    flecs::string path_from(flecs::entity_t parent, const char *sep = "::", const char *init_sep = "::") const {
        char *path = ecs_get_path_w_sep(world_, parent, id_, sep, init_sep);
        return flecs::string(path);
    }
 
    template <typename Parent>
    flecs::string path_from(const char *sep = "::", const char *init_sep = "::") const {
        return path_from(_::type<Parent>::id(world_), sep, init_sep);
    }
 
    bool enabled() const {
        return !ecs_has_id(world_, 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(_::type<First>::id(world_), func);
    }
 
    template <typename Func>
    void children(flecs::entity_t rel, Func&& func) const {
        /* When the entity is a wildcard, this would attempt to query for all
         * entities with (ChildOf, *) or (ChildOf, _) instead of querying for
         * the children of the wildcard entity. */
        if (id_ == flecs::Wildcard || id_ == flecs::Any) {
            /* This is correct, wildcard entities don't have children */
            return;
        }
 
        flecs::world world(world_);
 
        if (rel == flecs::ChildOf) {
            ecs_iter_t it = ecs_children(world_, id_);
            while (ecs_children_next(&it)) {
                _::each_delegate<Func>(FLECS_MOV(func)).invoke(&it);
            }
        } else {
            ecs_iter_t it = ecs_each_id(world_, ecs_pair(rel, id_));
            while (ecs_each_next(&it)) {
                _::each_delegate<Func>(FLECS_MOV(func)).invoke(&it);
            }
        }
    }
 
    template <typename Rel, typename Func>
    void children(Func&& func) const {
        children(_::type<Rel>::id(world_), FLECS_MOV(func));
    }
 
    template <typename Func>
    void children(Func&& func) const {
        children(flecs::ChildOf, FLECS_MOV(func));
    }
 
 
    /* try_get */
 
    template <typename T, if_t< is_actual<T>::value > = 0>
    const T* try_get() 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<const T*>(ecs_get_id(world_, id_, comp_id));
    }
 
    template <typename T, typename A = actual_type_t<T>, 
        if_t< flecs::is_pair<T>::value > = 0>
    const A* try_get() const {
        auto comp_id = _::type<T>::id(world_);
        ecs_assert(_::type<A>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        return static_cast<const A*>(ecs_get_id(world_, 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* try_get() const {
        return this->try_get<P>();
    }
 
    template<typename First, typename Second, if_not_t< is_enum<Second>::value> = 0>
    const First* try_get(Second second) const {
        auto first = _::type<First>::id(world_);
        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        return static_cast<const First*>(
            ecs_get_id(world_, id_, ecs_pair(first, second)));
    }
 
    template<typename First, typename Second, if_t< is_enum<Second>::value && !std::is_same<First, Second>::value > = 0>
    const First* try_get(Second constant) const {
        const auto& et = enum_type<Second>(this->world_);
        flecs::entity_t target = et.entity(constant);
        return try_get<First>(target);
    }
 
    const void* try_get(flecs::id_t comp) const {
        return ecs_get_id(world_, id_, comp);
    }
 
    const void* try_get(flecs::entity_t first, flecs::entity_t second) const {
        return ecs_get_id(world_, id_, ecs_pair(first, second));
    }
 
    template<typename Second>
    const Second* try_get_second(flecs::entity_t first) const {
        auto second = _::type<Second>::id(world_);
        ecs_assert( ecs_get_type_info(world_, ecs_pair(first, second)) != NULL,
            ECS_INVALID_PARAMETER, "pair is not a component");
        ecs_assert( ecs_get_type_info(world_, ecs_pair(first, second))->component == second,
            ECS_INVALID_PARAMETER, "type of pair is not Second");
        ecs_assert(_::type<Second>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        return static_cast<const Second*>(
            ecs_get_id(world_, id_, ecs_pair(first, second)));
    }
 
    template<typename First, typename Second>
    const Second* try_get_second() const {
        return try_get<pair_object<First, Second>>();
    }
 
 
    /* get */
 
    template <typename T, if_t< is_actual<T>::value > = 0>
    const T& get() const {
        const T *r = try_get<T>();
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get: entity does not have component (use try_get)");
        return *r;
    }
 
    template <typename T, typename A = actual_type_t<T>, 
        if_t< flecs::is_pair<T>::value > = 0>
    const A& get() const {
        const A *r = try_get<T>();
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get: entity does not have component (use try_get)");
        return *r;
    }
    
    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 {
        const First *r = try_get<First>(second);
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get: entity does not have component (use try_get)");
        return *r;
    }
 
    template<typename First, typename Second, if_t< is_enum<Second>::value && !std::is_same<First, Second>::value > = 0>
    const First& get(Second constant) const {
        const auto& et = enum_type<Second>(this->world_);
        flecs::entity_t target = et.entity(constant);
        return get<First>(target);
    }
 
    const void* get(flecs::id_t comp) const {
        const void *r = ecs_get_id(world_, id_, comp);
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get: entity does not have component (use try_get)");
        return r;
    }
 
    const void* get(flecs::entity_t first, flecs::entity_t second) const {
        const void *r = ecs_get_id(world_, id_, ecs_pair(first, second));
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get: entity does not have component (use try_get)");
        return r;
    }
 
    template <typename Func, if_t< is_callable<Func>::value > = 0>
    bool get(const Func& func) const;
 
    template<typename Second>
    const Second& get_second(flecs::entity_t first) const {
        const Second *r = try_get_second<Second>(first);
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get: entity does not have component (use try_get)");
        return *r;
    }
 
    template<typename First, typename Second>
    const Second& get_second() const {
        const Second *r = try_get<First, Second>();
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get: entity does not have component (use try_get)");
        return *r;
    }
 
 
    /* try_get_mut */
 
    template <typename T, if_t< is_actual<T>::value > = 0>
    T* try_get_mut() 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_get_mut_id(world_, id_, comp_id));
    }
 
    template <typename T, typename A = actual_type_t<T>, 
        if_t< flecs::is_pair<T>::value > = 0>
    A* try_get_mut() const {
        auto comp_id = _::type<T>::id(world_);
        ecs_assert(_::type<A>::size() != 0, ECS_INVALID_PARAMETER,
            "operation invalid for empty type");
        return static_cast<A*>(ecs_get_mut_id(world_, 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>
    A* try_get_mut() const {
        return this->try_get_mut<P>();
    }
 
    template<typename First, typename Second, if_not_t< is_enum<Second>::value> = 0>
    First* try_get_mut(Second second) const {
        auto first = _::type<First>::id(world_);
        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER, 
            "operation invalid for empty type");
        return static_cast<First*>(
            ecs_get_mut_id(world_, id_, ecs_pair(first, second)));
    }
 
    template<typename First, typename Second, if_t< is_enum<Second>::value && !std::is_same<First, Second>::value > = 0>
    First* try_get_mut(Second constant) const {
        const auto& et = enum_type<Second>(this->world_);
        flecs::entity_t target = et.entity(constant);
        return get_mut<First>(target);
    }
 
    void* try_get_mut(flecs::id_t comp) const {
        return ecs_get_mut_id(world_, id_, comp);
    }
 
    void* try_get_mut(flecs::entity_t first, flecs::entity_t second) const {
        return ecs_get_mut_id(world_, id_, ecs_pair(first, second));
    }
 
    template<typename Second>
    Second* try_get_mut_second(flecs::entity_t first) const {
        auto second = _::type<Second>::id(world_);
        ecs_assert( ecs_get_type_info(world_, ecs_pair(first, second)) != NULL,
            ECS_INVALID_PARAMETER, "pair is not a component");
        ecs_assert( ecs_get_type_info(world_, ecs_pair(first, second))->component == second,
            ECS_INVALID_PARAMETER, "type of pair is not Second");
        ecs_assert(_::type<Second>::size() != 0, ECS_INVALID_PARAMETER, 
            "operation invalid for empty type");
        return static_cast<Second*>(
            ecs_get_mut_id(world_, id_, ecs_pair(first, second)));
    }
 
    template<typename First, typename Second>
    Second* try_get_mut_second() const {
        return get_mut<pair_object<First, Second>>();
    }
 
 
    /* get_mut */
 
    template <typename T, if_t< is_actual<T>::value > = 0>
    T& get_mut() const {
        T* r = try_get_mut<T>();
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get_mut: entity does not have component (use try_get_mut)");
        return *r;
    }
 
    template <typename T, typename A = actual_type_t<T>, 
        if_t< flecs::is_pair<T>::value > = 0>
    A& get_mut() const {
        A* r = try_get_mut<T>();
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get_mut: entity does not have component (use try_get_mut)");
        return *r;
    }
 
    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& get_mut() const {
        A* r = try_get_mut<First, Second>();
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get_mut: entity does not have component (use try_get_mut)");
        return *r;
    }
 
    template<typename First, typename Second, if_not_t< is_enum<Second>::value> = 0>
    First& get_mut(Second second) const {
        First* r = try_get_mut<First>(second);
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get_mut: entity does not have component (use try_get_mut)");
        return *r;
    }
 
    template<typename First, typename Second, if_t< is_enum<Second>::value && !std::is_same<First, Second>::value > = 0>
    First& get_mut(Second constant) const {
        const auto& et = enum_type<Second>(this->world_);
        flecs::entity_t target = et.entity(constant);
        return get_mut<First>(target);
    }
 
    void* get_mut(flecs::id_t comp) const {
        void *r = ecs_get_mut_id(world_, id_, comp);
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get_mut: entity does not have component (use try_get_mut)");
        return r;
    }
 
    void* get_mut(flecs::entity_t first, flecs::entity_t second) const {
        void *r = ecs_get_mut_id(world_, id_, ecs_pair(first, second));
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get_mut: entity does not have component (use try_get_mut)");
        return r;
    }
 
    template<typename Second>
    Second& get_mut_second(flecs::entity_t first) const {
        Second *r = try_get_mut_second<Second>(first);
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get_mut: entity does not have component (use try_get_mut)");
        return *r;
    }
 
    template<typename First, typename Second>
    Second* get_mut_second() const {
        Second *r = try_get_mut_second<First, Second>();
        ecs_assert(r != nullptr, ECS_INVALID_OPERATION, 
            "invalid get_mut: entity does not have component (use try_get_mut)");
        return *r;
    }
 
    template<typename Enum>
    Enum get_constant() const;
    
    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(world_, id_, rel);
    }
 
    template<typename Rel>
    int32_t depth() const {
        return this->depth(_::type<Rel>::id(world_));
    }
 
    flecs::entity parent() const;
    
    flecs::entity lookup(const char *path, bool search_path = false) const;
 
    bool has(flecs::id_t e) const {
        return ecs_has_id(world_, id_, e);
    }     
 
    template <typename T>
    bool has() const {
        flecs::id_t cid = _::type<T>::id(world_);
        bool result = ecs_has_id(world_, id_, cid);
        if (result) {
            return result;
        }
 
        if (is_enum<T>::value) {
            return ecs_has_pair(world_, id_, cid, flecs::Wildcard);
        }
 
        return false;
    }
 
    template <typename E, if_t< is_enum<E>::value > = 0>
    bool has(E value) const {
        auto r = _::type<E>::id(world_);
        auto o = enum_type<E>(world_).entity(value);
        ecs_assert(o, ECS_INVALID_PARAMETER,
            "Constant was not found in Enum reflection data."
            " Did you mean to use has<E>() instead of has(E)?");
        return ecs_has_pair(world_, id_, r, o);
    }
 
    template <typename First, typename Second>
    bool has() const {
        return this->has<First>(_::type<Second>::id(world_));
    }
 
    template<typename First, typename Second, if_not_t< is_enum<Second>::value > = 0>
    bool has(Second second) const {
        auto comp_id = _::type<First>::id(world_);
        return ecs_has_id(world_, id_, ecs_pair(comp_id, second));
    }
 
    template <typename Second>
    bool has_second(flecs::entity_t first) const {
        return this->has(first, _::type<Second>::id(world_));
    }
 
    template<typename First, typename E, if_t< is_enum<E>::value && !std::is_same<First, E>::value > = 0>
    bool has(E value) const {
        const auto& et = enum_type<E>(this->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(world_, id_, ecs_pair(first, second));
    }
 
    bool owns(flecs::id_t e) const {
        return ecs_owns_id(world_, id_, e);
    }
 
    template <typename First>
    bool owns(flecs::id_t second) const {
        auto comp_id = _::type<First>::id(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(_::type<T>::id(world_));
    }
 
    template <typename First, typename Second>
    bool owns() const {
        return owns(
            _::type<First>::id(world_),
            _::type<Second>::id(world_));
    }
 
    bool enabled(flecs::id_t id) const {
        return ecs_is_enabled_id(world_, id_, id);
    }
 
    template<typename T>
    bool enabled() const {
        return this->enabled(_::type<T>::id(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(_::type<First>::id(world_), second);
    }
 
    template <typename First, typename Second>
    bool enabled() const {
        return this->enabled<First>(_::type<Second>::id(world_));
    }
 
    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
#   ifdef FLECS_ALERTS
#   include "mixins/alerts/entity_view.inl"
#   endif
 
#   include "mixins/enum/entity_view.inl"
#   include "mixins/event/entity_view.inl"
 
private:
    flecs::entity set_stage(world_t *stage);
};
 
}