builder_i.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../term/builder_i.hpp"
 
namespace flecs 
{
 
template<typename Base, typename ... Components>
struct query_builder_i : term_builder_i<Base> {
    query_builder_i(ecs_query_desc_t *desc, int32_t term_index = 0) 
        : term_index_(term_index)
        , expr_count_(0)
        , desc_(desc) { }
 
    Base& query_flags(ecs_flags32_t flags) {
        desc_->flags |= flags;
        return *this;
    }
 
    Base& cache_kind(query_cache_kind_t kind) {
        desc_->cache_kind = static_cast<ecs_query_cache_kind_t>(kind);
        return *this;
    }
 
    Base& cached() {
        return cache_kind(flecs::QueryCacheAuto);
    }
 
    Base& detect_changes() {
        desc_->flags |= EcsQueryDetectChanges;
        return *this;
    }
 
    Base& expr(const char *expr) {
        ecs_check(expr_count_ == 0, ECS_INVALID_OPERATION,
            "query_builder::expr() called more than once");
        desc_->expr = expr;
        expr_count_ ++;
 
    error:
        return *this;
    }
 
    /* With methods */
 
    template<typename T>
    Base& with() {
        this->term();
        *this->term_ = flecs::term(_::type<T>::id(this->world_v()));
        this->term_->inout = static_cast<ecs_inout_kind_t>(
            _::type_to_inout<T>());
        return *this;
    }
 
    Base& with(id_t component_id) {
        this->term();
        *this->term_ = flecs::term(component_id);
        return *this;
    }
 
    Base& with(const char *component_name) {
        this->term();
        *this->term_ = flecs::term().first(component_name);
        return *this;
    }
 
    Base& with(const char *first, const char *second) {
        this->term();
        *this->term_ = flecs::term().first(first).second(second);
        return *this;
    }
 
    Base& with(entity_t first, entity_t second) {
        this->term();
        *this->term_ = flecs::term(first, second);
        return *this;
    }
 
    Base& with(entity_t first, const char *second) {
        this->term();
        *this->term_ = flecs::term(first).second(second);
        return *this;
    }
 
    Base& with(const char *first, entity_t second) {
        this->term();
        *this->term_ = flecs::term().first(first).second(second);
        return *this;
    }
 
    template<typename First>
    Base& with(entity_t second) {
        return this->with(_::type<First>::id(this->world_v()), second);
    }
 
    template<typename First>
    Base& with(const char *second) {
        return this->with(_::type<First>::id(this->world_v())).second(second);
    }
 
    template<typename First, typename Second>
    Base& with() {
        return this->with<First>(_::type<Second>::id(this->world_v()));
    }
 
    template <typename E, if_t< is_enum<E>::value > = 0>
    Base& with(E value) {
        flecs::entity_t r = _::type<E>::id(this->world_v());
        auto o = enum_type<E>(this->world_v()).entity(value);
        return this->with(r, o);
    }
 
    Base& with(flecs::term& term) {
        this->term();
        *this->term_ = term;
        return *this;
    }
 
    Base& with(flecs::term&& term) {
        this->term();
        *this->term_ = term;
        return *this;
    }
 
    /* Without methods, shorthand for .with(...).not_(). */
 
    template <typename ... Args>
    Base& without(Args&&... args) {
        return this->with(FLECS_FWD(args)...).not_();
    }
 
    template <typename T, typename ... Args>
    Base& without(Args&&... args) {
        return this->with<T>(FLECS_FWD(args)...).not_();
    }
 
    template <typename First, typename Second>
    Base& without() {
        return this->with<First, Second>().not_();
    }
 
    /* Write/read methods */
 
    Base& write() {
        term_builder_i<Base>::write();
        return *this;
    }
 
    template <typename ... Args>
    Base& write(Args&&... args) {
        return this->with(FLECS_FWD(args)...).write();
    }
 
    template <typename T, typename ... Args>
    Base& write(Args&&... args) {
        return this->with<T>(FLECS_FWD(args)...).write();
    }
 
    template <typename First, typename Second>
    Base& write() {
        return this->with<First, Second>().write();
    }
 
    Base& read() {
        term_builder_i<Base>::read();
        return *this;
    }
 
    template <typename ... Args>
    Base& read(Args&&... args) {
        return this->with(FLECS_FWD(args)...).read();
    }
 
    template <typename T, typename ... Args>
    Base& read(Args&&... args) {
        return this->with<T>(FLECS_FWD(args)...).read();
    }
 
    template <typename First, typename Second>
    Base& read() {
        return this->with<First, Second>().read();
    }
 
    /* Scope_open/scope_close shorthand notation. */
    Base& scope_open() {
        return this->with(flecs::ScopeOpen).entity(0);
    }
 
    Base& scope_close() {
        return this->with(flecs::ScopeClose).entity(0);
    }
 
    /* Term notation for more complex query features */
 
    Base& term() {
        if (this->term_) {
            ecs_check(ecs_term_is_initialized(this->term_), 
                ECS_INVALID_OPERATION, 
                    "query_builder::term() called without initializing term");
        }
 
        ecs_check(term_index_ < FLECS_TERM_COUNT_MAX, 
            ECS_INVALID_PARAMETER, "maximum number of terms exceeded");
 
        this->set_term(&desc_->terms[term_index_]);
 
        term_index_ ++;
    
    error:
        return *this;
    }
 
    template <typename T>
    Base& term_at() {
        flecs::id_t term_id = _::type<T>::id(this->world_v());
        for (int i = 0; i < term_index_; i ++) {
            ecs_term_t cur_term = desc_->terms[i];
            ecs_id_t cur_term_id = cur_term.id;
            ecs_id_t cur_term_pair = ecs_pair(cur_term.first.id, cur_term.second.id);
 
            if ((term_id == cur_term_id || (cur_term_id != 0 && term_id == ecs_get_typeid(this->world_v(), cur_term_id))) ||
                (term_id == cur_term_pair || (cur_term_pair != 0 && term_id == ecs_get_typeid(this->world_v(), cur_term_pair)))) {
                return term_at(i);
            }
        }
 
        ecs_err("term not found");
        return *this;
    }
 
    Base& term_at(int32_t term_index) {
        ecs_assert(term_index >= 0, ECS_INVALID_PARAMETER, NULL);
        int32_t prev_index = term_index_;
        term_index_ = term_index;
        this->term();
        term_index_ = prev_index;
        ecs_assert(ecs_term_is_initialized(this->term_), 
            ECS_INVALID_PARAMETER, NULL);
        return *this;
    }
 
    template <typename T>
    Base& term_at(int32_t term_index) {
        this->term_at(term_index);
#if !defined(FLECS_NDEBUG) || defined(FLECS_KEEP_ASSERT)
        flecs::id_t term_id = _::type<T>::id(this->world_v());
        ecs_term_t cur_term = *this->term_;
        ecs_id_t cur_term_id = cur_term.id;
        ecs_id_t cur_term_pair = ecs_pair(cur_term.first.id, cur_term.second.id);
 
        ecs_assert((term_id == cur_term_id || (cur_term_id != 0 && term_id == ecs_get_typeid(this->world_v(), cur_term_id))) ||
            (term_id == cur_term_pair || (cur_term_pair != 0 && term_id == ecs_get_typeid(this->world_v(), cur_term_pair))),
            ECS_INVALID_PARAMETER, "term type mismatch");
#endif
        return *this;
    }
 
    template <typename T>
    Base& order_by(int(*compare)(flecs::entity_t, const T*, flecs::entity_t, const T*)) {
        ecs_order_by_action_t cmp = reinterpret_cast<ecs_order_by_action_t>(compare);
        return this->order_by(_::type<T>::id(this->world_v()), cmp);
    }
 
    Base& order_by(flecs::entity_t component, int(*compare)(flecs::entity_t, const void*, flecs::entity_t, const void*)) {
        desc_->order_by_callback = reinterpret_cast<ecs_order_by_action_t>(compare);
        desc_->order_by = component;
        return *this;
    }
 
    template <typename T>
    Base& group_by(uint64_t(*group_by_action)(flecs::world_t*, flecs::table_t *table, flecs::id_t id, void* ctx)) {
        ecs_group_by_action_t action = reinterpret_cast<ecs_group_by_action_t>(group_by_action);
        return this->group_by(_::type<T>::id(this->world_v()), action);
    }
 
    Base& group_by(flecs::entity_t component, uint64_t(*group_by_action)(flecs::world_t*, flecs::table_t *table, flecs::id_t id, void* ctx)) {
        desc_->group_by_callback = reinterpret_cast<ecs_group_by_action_t>(group_by_action);
        desc_->group_by = component;
        return *this;
    }
 
    template <typename T>
    Base& group_by() {
        return this->group_by(_::type<T>::id(this->world_v()), nullptr);
    }
 
    Base& group_by(flecs::entity_t component) {
        return this->group_by(component, nullptr);
    }
 
    Base& group_by_ctx(void *ctx, ecs_ctx_free_t ctx_free = nullptr) {
        desc_->group_by_ctx = ctx;
        desc_->group_by_ctx_free = ctx_free;
        return *this;
    }
 
    Base& on_group_create(ecs_group_create_action_t action) {
        desc_->on_group_create = action;
        return *this;
    }
 
    Base& on_group_delete(ecs_group_delete_action_t action) {
        desc_->on_group_delete = action;
        return *this;
    }
 
protected:
    virtual flecs::world_t* world_v() override = 0;
    int32_t term_index_;
    int32_t expr_count_;
 
private:
    operator Base&() {
        return *static_cast<Base*>(this);
    }
 
    ecs_query_desc_t *desc_;
};
 
}