iter.hpp

Go to the documentation of this file.

/**
 * @file addons/cpp/impl/iter.hpp
 * @brief Iterator implementation.
 */
 
#pragma once
 
namespace flecs
{
 
/** Get the entity associated with the system currently being run. */
inline flecs::entity iter::system() const {
    return flecs::entity(iter_->stage, iter_->system);
}
 
/** Get the entity associated with the event that triggered the observer. */
inline flecs::entity iter::event() const {
    return flecs::entity(iter_->stage, iter_->event);
}
 
/** Get the event ID (component or pair). */
inline flecs::id iter::event_id() const {
    return flecs::id(iter_->stage, iter_->event_id);
}
 
/** Get the iterator world. */
inline flecs::world iter::world() const {
    return flecs::world(iter_->world);
}
 
inline flecs::world iter::stage() const {
    return flecs::world(iter_->stage);
}
 
/** Get the entity for a given row. */
inline flecs::entity iter::entity(size_t row) const {
    ecs_assert(row < static_cast<size_t>(iter_->count),
        ECS_COLUMN_INDEX_OUT_OF_RANGE, nullptr);
    return flecs::entity(iter_->stage, iter_->entities[row]);
}
 
/** Get the source entity for a field. */
inline flecs::entity iter::src(int8_t index) const {
    return flecs::entity(iter_->stage, ecs_field_src(iter_, index));
}
 
/** Get the ID for a field. */
inline flecs::id iter::id(int8_t index) const {
    return flecs::id(iter_->stage, ecs_field_id(iter_, index));
}
 
/** Get the pair ID for a field. */
inline flecs::id iter::pair(int8_t index) const {
    flecs::id_t id = ecs_field_id(iter_, index);
    ecs_check(ECS_HAS_ID_FLAG(id, PAIR), ECS_INVALID_PARAMETER, nullptr);
    return flecs::id(iter_->stage, id);
error:
    return flecs::id();
}
 
/** Get the type of the current table. */
inline flecs::type iter::type() const {
    return flecs::type(iter_->stage, ecs_table_get_type(iter_->table));
}
 
/** Get the current table. */
inline flecs::table iter::table() const {
    return flecs::table(iter_->world, iter_->table);
}
 
/** Get the other table (used for on_add/on_remove observers). */
inline flecs::table iter::other_table() const {
    return flecs::table(iter_->world, iter_->other_table);
}
 
/** Get the table range for the current result. */
inline flecs::table_range iter::range() const {
    return flecs::table_range(iter_->world, iter_->table,
        iter_->offset, iter_->count);
}
 
/** Get field data for a const component type. */
template <typename T, typename A, if_t< is_const_v<T> >>
inline flecs::field<A> iter::field(int8_t index) const {
    ecs_assert(!(iter_->flags & EcsIterCppEach) ||
               ecs_field_src(iter_, index) != 0, ECS_INVALID_OPERATION,
        "cannot .field from .each, use .field_at<%s>(%d, row) instead",
            _::type_name<T>(), index);
    return get_field<A>(index);
}
 
/** Get field data for a mutable component type. */
template <typename T, typename A, if_not_t< is_const_v<T> >>
inline flecs::field<A> iter::field(int8_t index) const {
    ecs_assert(!(iter_->flags & EcsIterCppEach) ||
               ecs_field_src(iter_, index) != 0, ECS_INVALID_OPERATION,
        "cannot .field from .each, use .field_at<%s>(%d, row) instead",
            _::type_name<T>(), index);
    ecs_assert(!ecs_field_is_readonly(iter_, index),
        ECS_ACCESS_VIOLATION, nullptr);
    return get_field<A>(index);
}
 
/** Get base field data for a const component type. */
template <typename T, typename A, if_t< is_const_v<T> >>
inline flecs::base_field<A> iter::base_field(int8_t index) const {
    ecs_assert(!(iter_->flags & EcsIterCppEach) ||
               ecs_field_src(iter_, index) != 0, ECS_INVALID_OPERATION,
        "cannot .base_field from .each, use .field_at<%s>(%d, row) instead",
            _::type_name<T>(), index);
    return get_base_field<A>(index);
}
 
/** Get base field data for a mutable component type. */
template <typename T, typename A, if_not_t< is_const_v<T> >>
inline flecs::base_field<A> iter::base_field(int8_t index) const {
    ecs_assert(!(iter_->flags & EcsIterCppEach) ||
               ecs_field_src(iter_, index) != 0, ECS_INVALID_OPERATION,
        "cannot .base_field from .each, use .field_at<%s>(%d, row) instead",
            _::type_name<T>(), index);
    ecs_assert(!ecs_field_is_readonly(iter_, index),
        ECS_ACCESS_VIOLATION, nullptr);
    return get_base_field<A>(index);
}
 
#ifdef FLECS_QUERY_PLANS
/** Get the value of a variable by ID. */
inline flecs::entity iter::get_var(int var_id) const {
    ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, nullptr);
    return flecs::entity(iter_->stage, ecs_iter_get_var(iter_, var_id));
}
 
/** Get the value of a variable by name.
 * Get the value of a query variable for the current result.
 */
inline flecs::entity iter::get_var(const char *name) const {
    const flecs::query_t *q = iter_->query;
 
    int var_id = ecs_query_find_var(q, name);
    ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, "%s", name);
    return flecs::entity(iter_->stage, ecs_iter_get_var(iter_, var_id));
}
#endif
 
/** Iterate over targets for a field. */
template <typename Func>
void iter::targets(int8_t index, const Func& func) {
    ecs_assert(iter_->table != nullptr, ECS_INVALID_OPERATION, nullptr);
    ecs_assert(index < iter_->field_count, ECS_INVALID_PARAMETER, nullptr);
    ecs_assert(ecs_field_is_set(iter_, index), ECS_INVALID_PARAMETER, nullptr);
    const ecs_type_t *table_type = ecs_table_get_type(iter_->table);
    const ecs_table_record_t *tr = iter_->trs[index];
    int32_t i = tr->index, end = i + tr->count;
    for (; i < end; i ++) {
        ecs_id_t id = table_type->array[i];
        ecs_assert(ECS_IS_PAIR(id), ECS_INVALID_PARAMETER,
            "field does not match a pair");
        flecs::entity tgt(iter_->stage,
            ecs_pair_second(iter_->world, id));
        func(tgt);
    }
}
 
} // namespace flecs