table.hpp

Go to the documentation of this file.

 
#pragma once
 
namespace flecs {
 
struct table {
    table() : world_(nullptr), table_(nullptr) { }
 
    table(world_t *world, table_t *t)
        : world_(world)
        , table_(t) { }
 
    virtual ~table() { }
 
    flecs::string str() const {
        return flecs::string(ecs_table_str(world_, table_));
    }
 
    flecs::type type() const {
        return flecs::type(world_, ecs_table_get_type(table_));
    }
 
    int32_t count() const {
        return ecs_table_count(table_);
    }
 
    int32_t size() const {
        return ecs_table_size(table_);
    }
 
    const flecs::entity_t* entities() const {
        return ecs_table_entities(table_);
    }
 
    void clear_entities() const {
        ecs_table_clear_entities(world_, table_);
    }
 
    int32_t type_index(flecs::id_t id) const {
        return ecs_table_get_type_index(world_, table_, id);
    }
 
    template <typename T>
    int32_t type_index() const {
        return type_index(_::type<T>::id(world_));
    }
 
    int32_t type_index(flecs::entity_t first, flecs::entity_t second) const {
        return type_index(ecs_pair(first, second));
    }
 
    template <typename First>
    int32_t type_index(flecs::entity_t second) const {
        return type_index(_::type<First>::id(world_), second);
    }
 
    template <typename First, typename Second>
    int32_t type_index() const {
        return type_index<First>(_::type<Second>::id(world_));
    }
 
    int32_t column_index(flecs::id_t id) const {
        return ecs_table_get_column_index(world_, table_, id);
    }
 
    template <typename T>
    int32_t column_index() const {
        return column_index(_::type<T>::id(world_));
    }
 
    int32_t column_index(flecs::entity_t first, flecs::entity_t second) const {
        return column_index(ecs_pair(first, second));
    }
 
    template <typename First>
    int32_t column_index(flecs::entity_t second) const {
        return column_index(_::type<First>::id(world_), second);
    }
 
    template <typename First, typename Second>
    int32_t column_index() const {
        return column_index<First>(_::type<Second>::id(world_));
    }
 
    bool has(flecs::id_t id) const {
        return type_index(id) != -1;
    }
 
    template <typename T>
    bool has() const {
        return type_index<T>() != -1;
    }
 
    bool has(flecs::entity_t first, flecs::entity_t second) const {
        return type_index(first, second) != -1;
    }
 
    template <typename First>
    bool has(flecs::entity_t second) const {
        return type_index<First>(second) != -1;
    }
 
    template <typename First, typename Second>
    bool has() const {
        return type_index<First, Second>() != -1;
    }
 
    virtual void* get_column(int32_t index) const {
        return ecs_table_get_column(table_, index, 0);
    }
 
    void* get(flecs::id_t id) const {
        int32_t index = column_index(id);
        if (index == -1) {
            return NULL;
        }
        return get_column(index);
    }
 
    void* get(flecs::entity_t first, flecs::entity_t second) const {
        return get(ecs_pair(first, second));
    }
 
    template <typename T, if_t< is_actual<T>::value > = 0>
    T* get() const {
        return static_cast<T*>(get(_::type<T>::id(world_)));
    }
 
    template <typename T, if_t< is_enum<T>::value > = 0>
    T* get() const {
        return static_cast<T*>(get(_::type<T>::id(world_)));
    }
 
    template <typename T, typename A = actual_type_t<T>,
        if_t< flecs::is_pair<T>::value > = 0>
    A* get() const {
        return static_cast<A*>(get(_::type<T>::id(world_)));
    }
 
    template <typename First>
    First* get(flecs::entity_t second) const {
        return static_cast<First*>(get(_::type<First>::id(world_), second));
    }
 
    template <typename First, typename Second, typename P = flecs::pair<First, Second>,
        typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
    A* get() const {
        return static_cast<A*>(get<First>(_::type<Second>::id(world_)));
    }
 
    size_t column_size(int32_t index) const {
        return ecs_table_get_column_size(table_, index);
    }
 
    int32_t depth(flecs::entity_t rel) const  {
        return ecs_table_get_depth(world_, table_, rel);
    }
 
    template <typename Rel>
    int32_t depth() const {
        return depth(_::type<Rel>::id(world_));
    }
 
    ecs_table_records_t records() const {
        return flecs_table_records(table_);
    }
 
    uint64_t id() const {
        return flecs_table_id(table_);
    }
 
    void lock() const {
        ecs_table_lock(world_, table_);
    }
 
    void unlock() const {
        ecs_table_unlock(world_, table_);
    }
 
    bool has_flags(ecs_flags32_t flags) const {
        return ecs_table_has_flags(table_, flags);
    }
 
    table_t* get_table() const {
        return table_;
    }
 
    /* Implicit conversion to table_t */
    operator table_t*() const {
        return table_;
    }
 
protected:
    world_t *world_;
    table_t *table_;
};
 
struct table_range : table {
    table_range()
        : table()
        , offset_(0)
        , count_(0) { }
 
    table_range(world_t *world, table_t *t, int32_t offset, int32_t count)
        : table(world, t)
        , offset_(offset)
        , count_(count) { }
 
    int32_t offset() const {
        return offset_;
    }
 
    int32_t count() const {
        return count_;
    }
 
    void* get_column(int32_t index) const override {
        return ecs_table_get_column(table_, index, offset_);
    }
 
private:
    int32_t offset_ = 0;
    int32_t count_ = 0;
};
 
}