iter.hpp

Go to the documentation of this file.

 
#pragma once
 
namespace flecs
{
 
 
namespace _ {
 
 
template <typename T>
struct range_iterator
{
    explicit range_iterator(T value)
        : m_value(value){}
 
    bool operator!=(range_iterator const& other) const
    {
        return m_value != other.m_value;
    }
 
    T const& operator*() const
    {
        return m_value;
    }
 
    range_iterator& operator++()
    {
        ++m_value;
        return *this;
    }
 
private:
    T m_value;
};
 
} // namespace _
 
} // namespace flecs
 
namespace flecs
{
 
 
struct iter {
private:
    using row_iterator = _::range_iterator<size_t>;
 
public:
    iter(ecs_iter_t *it) : m_iter(it) {
        m_begin = 0;
        m_end = static_cast<std::size_t>(it->count);
    }
 
    row_iterator begin() const {
        return row_iterator(m_begin);
    }
 
    row_iterator end() const {
        return row_iterator(m_end);
    }
 
    flecs::entity system() const;
 
    flecs::entity event() const;
 
    flecs::id event_id() const;
 
    flecs::world world() const;
 
    const flecs::iter_t* c_ptr() const {
        return m_iter;
    }
 
    size_t count() const {
        return static_cast<size_t>(m_iter->count);
    }
 
    ecs_ftime_t delta_time() const {
        return m_iter->delta_time;
    }
 
    ecs_ftime_t delta_system_time() const {
        return m_iter->delta_system_time;
    }
 
    flecs::type type() const;
 
    flecs::table table() const;
 
    flecs::table_range range() const;
 
    void* ctx() {
        return m_iter->ctx;
    }
 
    template <typename T>
    T* ctx() {
        return static_cast<T*>(m_iter->ctx);
    }
 
    void* param() {
        return m_iter->param;
    }
 
    template <typename T>
    T* param() {
        /* TODO: type check */
        return static_cast<T*>(m_iter->param);
    }
 
    flecs::entity entity(size_t row) const;
 
    bool is_self(int32_t index) const {
        return ecs_field_is_self(m_iter, index);
    }
 
    bool is_set(int32_t index) const {
        return ecs_field_is_set(m_iter, index);
    }
 
    bool is_readonly(int32_t index) const {
        return ecs_field_is_readonly(m_iter, index);
    }
 
    int32_t field_count() const {
        return m_iter->field_count;
    }
 
    size_t size(int32_t index) const {
        return ecs_field_size(m_iter, index);
    }
 
    flecs::entity src(int32_t index) const;
 
    flecs::id id(int32_t index) const;
 
    flecs::id pair(int32_t index) const;
 
    int32_t column_index(int32_t index) const {
        return ecs_field_column_index(m_iter, index);
    }
 
    flecs::string str() const {
        char *s = ecs_iter_str(m_iter);
        return flecs::string(s);
    }
 
    template <typename T, typename A = actual_type_t<T>,
        typename std::enable_if<std::is_const<T>::value, void>::type* = nullptr>
    flecs::field<A> field(int32_t index) const;
 
    template <typename T, typename A = actual_type_t<T>,
        typename std::enable_if<
            std::is_const<T>::value == false, void>::type* = nullptr>
    flecs::field<A> field(int32_t index) const;
 
    flecs::untyped_field field(int32_t index) const {
        ecs_assert(!(m_iter->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
            "cannot .field from .each, use .field_at(%d, row) instead", index);
        return get_unchecked_field(index);
    }
 
    void* field_at(int32_t index, size_t row) const {
        return get_unchecked_field(index)[row];
    }
 
    template <typename T, typename A = actual_type_t<T>,
        typename std::enable_if<std::is_const<T>::value, void>::type* = nullptr>
    const A& field_at(int32_t index, size_t row) const {
        return get_field<A>(index)[row];
    }
 
    template <typename T, typename A = actual_type_t<T>,
        typename std::enable_if<
            std::is_const<T>::value == false, void>::type* = nullptr>
    A& field_at(int32_t index, size_t row) const {
        ecs_assert(!ecs_field_is_readonly(m_iter, index),
            ECS_ACCESS_VIOLATION, NULL);
        return get_field<A>(index)[row];
    }
 
    flecs::field<const flecs::entity_t> entities() const {
        return flecs::field<const flecs::entity_t>(m_iter->entities, static_cast<size_t>(m_iter->count), false);
    }
 
    int32_t table_count() const {
        return m_iter->table_count;
    }
 
    bool changed() {
        return ecs_query_changed(nullptr, m_iter);
    }
 
    void skip() {
        ecs_query_skip(m_iter);
    }
 
    /* Return group id for current table (grouped queries only) */
    uint64_t group_id() const {
        return m_iter->group_id;
    }
 
#ifdef FLECS_RULES
    flecs::entity get_var(int var_id) const;
 
    flecs::entity get_var(const char *name) const;
#endif
 
private:
    /* Get field, check if correct type is used */
    template <typename T, typename A = actual_type_t<T>>
    flecs::field<T> get_field(int32_t index) const {
 
#ifndef FLECS_NDEBUG
        ecs_entity_t term_id = ecs_field_id(m_iter, index);
        ecs_assert(ECS_HAS_ID_FLAG(term_id, PAIR) ||
            term_id == _::cpp_type<T>::id(m_iter->world),
            ECS_COLUMN_TYPE_MISMATCH, NULL);
#endif
 
        size_t count;
        bool is_shared = !ecs_field_is_self(m_iter, index);
 
        /* If a shared column is retrieved with 'column', there will only be a
         * single value. Ensure that the application does not accidentally read
         * out of bounds. */
        if (is_shared) {
            count = 1;
        } else {
            /* If column is owned, there will be as many values as there are
             * entities. */
            count = static_cast<size_t>(m_iter->count);
        }
 
        return flecs::field<A>(
            static_cast<T*>(ecs_field_w_size(m_iter, sizeof(A), index)),
            count, is_shared);
    }
 
    flecs::untyped_field get_unchecked_field(int32_t index) const {
        size_t count;
        size_t size = ecs_field_size(m_iter, index);
        bool is_shared = !ecs_field_is_self(m_iter, index);
 
        /* If a shared column is retrieved with 'column', there will only be a
         * single value. Ensure that the application does not accidentally read
         * out of bounds. */
        if (is_shared) {
            count = 1;
        } else {
            /* If column is owned, there will be as many values as there are
             * entities. */
            count = static_cast<size_t>(m_iter->count);
        }
 
        return flecs::untyped_field(
            ecs_field_w_size(m_iter, 0, index), size, count, is_shared);
    }
 
    flecs::iter_t *m_iter;
    std::size_t m_begin;
    std::size_t m_end;
};
 
} // namespace flecs