table.hpp

Go to the documentation of this file.

 
#pragma once
 
namespace flecs {
 
struct table {
    table() : m_world(nullptr), m_table(nullptr) { }
 
    table(world_t *world, table_t *t)
        : m_world(world)
        , m_table(t) { }
 
    virtual ~table() { }
 
    flecs::string str() const {
        return flecs::string(ecs_table_str(m_world, m_table));
    }
 
    flecs::type type() const {
        return flecs::type(m_world, ecs_table_get_type(m_table));
    }
 
    int32_t count() const {
        return ecs_table_count(m_table);
    }
 
    int32_t type_index(flecs::id_t id) const {
        return ecs_table_get_type_index(m_world, m_table, id);
    }
 
    template <typename T>
    int32_t type_index() const {
        return type_index(_::cpp_type<T>::id(m_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(_::cpp_type<First>::id(m_world), second);
    }
 
    template <typename First, typename Second>
    int32_t type_index() const {
        return type_index<First>(_::cpp_type<Second>::id(m_world));
    }
 
    int32_t column_index(flecs::id_t id) const {
        return ecs_table_get_column_index(m_world, m_table, id);
    }
 
    template <typename T>
    int32_t column_index() const {
        return column_index(_::cpp_type<T>::id(m_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(_::cpp_type<First>::id(m_world), second);
    }
 
    template <typename First, typename Second>
    int32_t column_index() const {
        return column_index<First>(_::cpp_type<Second>::id(m_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(m_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(_::cpp_type<T>::id(m_world)));
    }
 
    template <typename T, if_t< is_enum<T>::value > = 0>
    T* get() const {
        return static_cast<T*>(get(_::cpp_type<T>::id(m_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(_::cpp_type<T>::id(m_world)));
    }
 
    template <typename First>
    First* get(flecs::entity_t second) const {
        return static_cast<First*>(get(_::cpp_type<First>::id(m_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>(_::cpp_type<Second>::id(m_world)));
    }
 
    size_t column_size(int32_t index) {
        return ecs_table_get_column_size(m_table, index);
    }
 
    int32_t depth(flecs::entity_t rel) {
        return ecs_table_get_depth(m_world, m_table, rel);
    }
 
    template <typename Rel>
    int32_t depth() {
        return depth(_::cpp_type<Rel>::id(m_world));
    }
 
    /* Implicit conversion to table_t */
    operator table_t*() const {
        return m_table;
    }
 
protected:
    world_t *m_world;
    table_t *m_table;
};
 
struct table_range : table {
    table_range()
        : table()
        , m_offset(0)
        , m_count(0) { }
 
    table_range(world_t *world, table_t *t, int32_t offset, int32_t count)
        : table(world, t)
        , m_offset(offset)
        , m_count(count) { }
 
    int32_t offset() const {
        return m_offset;
    }
 
    int32_t count() const {
        return m_count;
    }
 
    void* get_column(int32_t index) const override {
        return ecs_table_get_column(m_table, index, m_offset);
    }
 
private:
    int32_t m_offset = 0;
    int32_t m_count = 0;
};
 
}