builder_i.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../../utils/signature.hpp"
#include <stdio.h>
 
namespace flecs 
{
 
template<typename Base>
struct term_ref_builder_i {
    term_ref_builder_i() : term_ref_(nullptr) { }
 
    virtual ~term_ref_builder_i() { }
 
    Base& self() {
        this->assert_term_ref();
        term_ref_->id |= flecs::Self;
        return *this;
    }
 
    Base& id(flecs::entity_t id) {
        this->assert_term_ref();
        term_ref_->id = id;
        return *this;
    }
 
    Base& entity(flecs::entity_t entity) {
        this->assert_term_ref();
        term_ref_->id = entity | flecs::IsEntity;
        return *this;
    }
 
    Base& name(const char *name) {
        this->assert_term_ref();
        term_ref_->id |= flecs::IsEntity;
        term_ref_->name = const_cast<char*>(name);
        return *this;
    }
 
    Base& var(const char *var_name) {
        this->assert_term_ref();
        term_ref_->id |= flecs::IsVariable;
        term_ref_->name = const_cast<char*>(var_name);
        return *this;
    }
 
    Base& flags(flecs::flags64_t flags) {
        this->assert_term_ref();
        term_ref_->id = flags;
        return *this;
    }
 
    ecs_term_ref_t *term_ref_;
 
protected:
    virtual flecs::world_t* world_v() = 0;
 
    void assert_term_ref() {
        ecs_assert(term_ref_ != NULL, ECS_INVALID_PARAMETER, 
            "no active term (call .with() first)");
    }
 
private:
    operator Base&() {
        return *static_cast<Base*>(this);
    }
};
 
template<typename Base>
struct term_builder_i : term_ref_builder_i<Base> {
    term_builder_i() : term_(nullptr) { }
 
    term_builder_i(ecs_term_t *term_ptr) {
        set_term(term_ptr);
    }
 
    Base& term(id_t id) {
        return this->id(id);
    }
 
    Base& src() {
        this->assert_term();
        this->term_ref_ = &term_->src;
        return *this;
    }
 
    Base& first() {
        this->assert_term();
        this->term_ref_ = &term_->first;
        return *this;
    }
 
    Base& second() {
        this->assert_term();
        this->term_ref_ = &term_->second;
        return *this;
    }
 
    Base& src(flecs::entity_t id) {
        this->src();
        this->id(id);
        return *this;
    }
 
    template<typename T>
    Base& src() {
        this->src(_::type<T>::id(this->world_v()));
        return *this;
    }
 
    Base& src(const char *name) {
        ecs_assert(name != NULL, ECS_INVALID_PARAMETER, NULL);
        this->src();
        if (name[0] == '$') {
            this->var(&name[1]);
        } else {
            this->name(name);
        }
        return *this;
    }
 
    Base& first(flecs::entity_t id) {
        this->first();
        this->id(id);
        return *this;
    }
 
    template<typename T>
    Base& first() {
        this->first(_::type<T>::id(this->world_v()));
        return *this;
    }
 
    Base& first(const char *name) {
        ecs_assert(name != NULL, ECS_INVALID_PARAMETER, NULL);
        this->first();
        if (name[0] == '$') {
            this->var(&name[1]);
        } else {
            this->name(name);
        }
        return *this;
    }
 
    Base& second(flecs::entity_t id) {
        this->second();
        this->id(id);
        return *this;
    }
 
    template<typename T>
    Base& second() {
        this->second(_::type<T>::id(this->world_v()));
        return *this;
    }
 
    Base& second(const char *name) {
        ecs_assert(name != NULL, ECS_INVALID_PARAMETER, NULL);
        this->second();
        if (name[0] == '$') {
            this->var(&name[1]);
        } else {
            this->name(name);
        }
        return *this;
    }
 
    Base& up(flecs::entity_t trav = 0) {
        this->assert_term_ref();
        ecs_check(this->term_ref_ != &term_->first, ECS_INVALID_PARAMETER,
            "up traversal can only be applied to term source");
        ecs_check(this->term_ref_ != &term_->second, ECS_INVALID_PARAMETER,
            "up traversal can only be applied to term source");
        this->term_ref_->id |= flecs::Up;
        if (trav) {
            term_->trav = trav;
        }
    error:
        return *this;
    }
 
    template <typename Trav>
    Base& up() {
        return this->up(_::type<Trav>::id(this->world_v()));
    }
 
    Base& cascade(flecs::entity_t trav = 0) {
        this->assert_term_ref();
        this->up();
        this->term_ref_->id |= flecs::Cascade;
        if (trav) {
            term_->trav = trav;
        }
        return *this;
    }
 
    template <typename Trav>
    Base& cascade() {
        return this->cascade(_::type<Trav>::id(this->world_v()));
    }
 
    Base& desc() {
        this->assert_term_ref();
        this->term_ref_->id |= flecs::Desc;
        return *this;
    }
 
    Base& parent() {
        return this->up();
    }
 
    Base& trav(flecs::entity_t trav, flecs::flags32_t flags = 0) {
        this->assert_term_ref();
        term_->trav = trav;
        this->term_ref_->id |= flags;
        return *this;
    }
 
    Base& id_flags(id_t flags) {
        this->assert_term();
        term_->id |= flags;
        return *this;
    }
 
    Base& inout(flecs::inout_kind_t inout) {
        this->assert_term();
        term_->inout = static_cast<int16_t>(inout);
        return *this;
    }
 
    Base& inout_stage(flecs::inout_kind_t inout) {
        this->assert_term();
        term_->inout = static_cast<int16_t>(inout);
        if (term_->oper != EcsNot) {
            this->src().entity(0);
        }
        return *this;
    }
 
    Base& write() {
        return this->inout_stage(flecs::Out);
    }
 
    Base& read() {
        return this->inout_stage(flecs::In);
    }
 
    Base& read_write() {
        return this->inout_stage(flecs::InOut);
    }
 
    Base& in() {
        return this->inout(flecs::In);
    }
 
    Base& out() {
        return this->inout(flecs::Out);
    }
 
    Base& inout() {
        return this->inout(flecs::InOut);
    }
 
    Base& inout_none() {
        return this->inout(flecs::InOutNone);
    }
 
    Base& oper(flecs::oper_kind_t oper) {
        this->assert_term();
        term_->oper = static_cast<int16_t>(oper);
        return *this;
    }
 
    Base& and_() {
        return this->oper(flecs::And);
    }
 
    Base& or_() {
        return this->oper(flecs::Or);
    }
 
    Base& not_() {
        return this->oper(flecs::Not);
    }
 
    Base& optional() {
        return this->oper(flecs::Optional);
    }
 
    Base& and_from() {
        return this->oper(flecs::AndFrom);
    }
 
    Base& or_from() {
        return this->oper(flecs::OrFrom);
    }
 
    Base& not_from() {
        return this->oper(flecs::NotFrom);
    }
 
    Base& filter() {
        term_->inout = EcsInOutFilter;
        return *this;
    }
 
    ecs_term_t *term_;
 
protected:
    virtual flecs::world_t* world_v() override = 0;
 
    void set_term(ecs_term_t *term) {
        term_ = term;
        if (term) {
            this->term_ref_ = &term_->src; // default to source
        } else {
            this->term_ref_ = nullptr;
        }
    }
 
private:
    void assert_term() {
        ecs_assert(term_ != NULL, ECS_INVALID_PARAMETER, 
            "no active term (call .with() first)");
    }
 
    operator Base&() {
        return *static_cast<Base*>(this);
    }   
};
 
}