Struct QueryBuilder

pub struct QueryBuilder<'a, T>
where
    T: QueryTuple,
{ /* private fields */ }

Fast to iterate, but slower to create than Filter

Implementations

impl<'a, T> QueryBuilder<'a, T>

where T: QueryTuple,

pub fn new(world: &'a World) -> Self

Create a new query builder

Arguments

• world - The world to create the observer in

See also

• C++ API: builder::builder

pub fn new_named(world: &'a World, name: &str) -> Self

Create a new query builder with a name

Arguments

• world - The world to create the observer in
• name - The name of the observer

See also

• C++ API: query_builder::query_builder

Trait Implementations

impl<'a, T: QueryTuple> QueryBuilderImpl<'a> for QueryBuilder<'a, T>

fn named(&mut self, name: &str) -> &mut Self

set the name of the query-like object

fn instanced(&mut self) -> &mut Self

set itself to be instanced

fn query_flags(&mut self, flags: QueryFlags) -> &mut Self

set querylags

fn set_cache_kind(&mut self, kind: QueryCacheKind) -> &mut Self

Set what cache method to use for the query

fn set_cached(&mut self) -> &mut Self

Set the cache method to cached

fn expr(&mut self, expr: &'a str) -> &mut Self

set expression

fn with_id(&mut self, id: impl IntoId) -> &mut Self

set term with Id

fn with<T: ComponentOrPairId>(&mut self) -> &mut Self

set term with type

fn with_enum<T: ComponentId + ComponentType<Enum> + EnumComponentInfo>( &mut self, value: T, ) -> &mut Self

set term with enum

fn with_enum_wildcard<T: ComponentType<Enum> + ComponentId>( &mut self, ) -> &mut Self

set term with enum wildcard

fn with_first<First: ComponentId>( &mut self, second: impl Into<Entity> + Copy, ) -> &mut Self

set term with pairs

fn with_first_name<First: ComponentId>(&mut self, second: &'a str) -> &mut Self

set term with pairs

fn with_second<Second: ComponentId>( &mut self, first: impl Into<Entity> + Copy, ) -> &mut Self

set term with pairs

fn with_second_name<Second: ComponentId>(&mut self, first: &'a str) -> &mut Self

set term with pairs

fn with_name(&mut self, name: &'a str) -> &mut Self

set term with Name

fn with_names(&mut self, first: &'a str, second: &'a str) -> &mut Self

set term with pair names

fn with_first_id( &mut self, first: impl Into<Entity>, second: &'a str, ) -> &mut Self

set term with first id and second name

fn with_second_id( &mut self, first: &'a str, second: impl Into<Entity>, ) -> &mut Self

set term with second id and first name

fn without_id(&mut self, id: impl IntoId) -> &mut Self

set term without Id

fn without<T: ComponentOrPairId>(&mut self) -> &mut Self

set term without type

fn without_enum<T: ComponentId + ComponentType<Enum> + EnumComponentInfo>( &mut self, value: T, ) -> &mut Self

set term without enum

fn without_enum_wildcard<T: ComponentId + ComponentType<Enum> + EnumComponentInfo>( &mut self, ) -> &mut Self

set term without enum wildcard

fn without_first<First: ComponentId>( &mut self, second: impl Into<Entity> + Copy, ) -> &mut Self

set term without pairs

fn without_first_name<First: ComponentId>( &mut self, second: &'a str, ) -> &mut Self

set term without pairs

fn without_second<Second: ComponentId>( &mut self, first: impl Into<Entity> + Copy, ) -> &mut Self

set term without pairs

fn without_second_name<Second: ComponentId>( &mut self, first: &'a str, ) -> &mut Self

set term without pairs

fn without_name(&mut self, name: &'a str) -> &mut Self

set term without Name

fn without_names(&mut self, first: &'a str, second: &'a str) -> &mut Self

set term without pair names

fn without_first_id( &mut self, first: impl Into<Entity>, second: &'a str, ) -> &mut Self

set term without first id and second name

fn without_second_id( &mut self, first: &'a str, second: impl Into<Entity>, ) -> &mut Self

set term without second id and first name

fn term(&mut self) -> &mut Self

Term notation for more complex query features

fn term_at(&mut self, index: u32) -> &mut Self

Term notation for more complex query features

fn write<T: ComponentOrPairId>(&mut self) -> &mut Self

Set the type as current term and in mode out

fn write_id(&mut self, id: impl IntoId) -> &mut Self

Set the id as current term and in mode out

fn write_name(&mut self, name: &'a str) -> &mut Self

Set the name as current term and in mode out

fn write_names(&mut self, first: &'a str, second: &'a str) -> &mut Self

Set the names as current term and in mode out

fn write_enum<T: ComponentId + ComponentType<Enum> + EnumComponentInfo>( &mut self, value: T, ) -> &mut Self

Set the type as current term and in mode out

fn write_first<T: ComponentId>( &mut self, second: impl Into<Entity> + Copy, ) -> &mut Self

Set the relationship as current term and in mode out

fn write_first_name<T: ComponentId>(&mut self, second: &'a str) -> &mut Self

Set the relationship as current term and in mode out

fn write_second<T: ComponentId>( &mut self, first: impl Into<Entity> + Copy, ) -> &mut Self

Set the relationship as current term and in mode out

fn write_second_name<T: ComponentId>(&mut self, first: &'a str) -> &mut Self

Set the relationship as current term and in mode out

fn read<T: ComponentOrPairId>(&mut self) -> &mut Self

Set the type as current term and in mode in

fn read_id(&mut self, id: impl IntoId) -> &mut Self

Set the id as current term and in mode in

fn read_name(&mut self, name: &'a str) -> &mut Self

Set the name as current term and in mode in

fn read_names(&mut self, first: &'a str, second: &'a str) -> &mut Self

Set the names as current term and in mode in

fn read_enum<T: ComponentId + ComponentType<Enum> + EnumComponentInfo>( &mut self, value: T, ) -> &mut Self

Set the type as current term and in mode in

fn read_first<T: ComponentId>( &mut self, second: impl Into<Entity> + Copy, ) -> &mut Self

Set the relationship as current term and in mode in

fn read_first_name<T: ComponentId>(&mut self, second: &'a str) -> &mut Self

Set the relationship as current term and in mode in

fn read_second<T: ComponentId>( &mut self, first: impl Into<Entity> + Copy, ) -> &mut Self

Set the relationship as current term and in mode in

fn read_second_name<T: ComponentId>(&mut self, first: &'a str) -> &mut Self

Set the relationship as current term and in mode in

fn scope_open(&mut self) -> &mut Self

Open a scope for the query

fn scope_close(&mut self) -> &mut Self

Close a scope for the query

fn order_by<T>(&mut self, compare: impl OrderByFn<T>) -> &mut Self

where T: ComponentId, Self: QueryBuilderImpl<'a>,

Sorts the output of a query.

fn order_by_id( &mut self, component: impl Into<Entity>, compare: impl OrderByFnVoid, ) -> &mut Self

Sorts the output of a query.

fn group_by<T>(&mut self) -> &mut Self

where T: ComponentId,

Group and sort matched tables.

fn group_by_fn<T>( &mut self, group_by_action: ecs_group_by_action_t, ) -> &mut Self

where T: ComponentId,

Group and sort matched tables.

fn group_by_id_fn( &mut self, component: impl Into<Entity>, group_by_action: ecs_group_by_action_t, ) -> &mut Self

Group and sort matched tables.

fn group_by_id(&mut self, component: impl Into<Entity>) -> &mut Self

Group and sort matched tables.

fn group_by_ctx( &mut self, ctx: *mut c_void, ctx_free: ecs_ctx_free_t, ) -> &mut Self

Specify context to be passed to the group_by function.

fn on_group_create(&mut self, action: ecs_group_create_action_t) -> &mut Self

Specify the on_group_create action.

fn on_group_delete(&mut self, action: ecs_group_delete_action_t) -> &mut Self

Specify the on_group_delete action.

impl<'a, T: QueryTuple> TermBuilderImpl<'a> for QueryBuilder<'a, T>

fn init_current_term<T>(&mut self, id: T)

where T: IntoId,

initializes a new term from a id of a component or pair

fn init_term_from<T: ComponentOrPairId>(&mut self)

initialize a new term from a component or pair

fn reset(&mut self)

Reset the term

fn is_set(&mut self) -> bool

Check if term is initialized

fn id(&self) -> Id

Get the term id of the current term set

fn inout(&self) -> InOutKind

Get the inout type of term of the current term set

fn oper(&self) -> OperKind

Get the operator of term of the current term set

fn src_id(&self) -> Entity

Get the src id of term of the current term set

fn first_id(&self) -> Entity

Get the first of term of the current term set

fn second_id(&self) -> Entity

Get the second of term of the current term set

fn self_(&mut self) -> &mut Self

The self flag indicates the term identifier itself is used

fn set_id(&mut self, id: impl Into<Entity>) -> &mut Self

Specify value of identifier by id, same as id() of the current term set

fn entity(&mut self, entity: impl Into<Entity>) -> &mut Self

Specify value of identifier by id. Almost the same as id(entity), but this operation explicitly sets the flecs::IsEntity flag. This forces the id to be interpreted as entity, whereas not setting the flag would implicitly convert ids for builtin variables such as flecs::This to a variable.

fn name(&mut self, name: &'a str) -> &mut Self

Specify value of identifier by name

fn set_var(&mut self, var_name: &'a str) -> &mut Self

Specify identifier is a variable (resolved at query evaluation time)

fn flags(&mut self, flags: u64) -> &mut Self

Override term id flags

fn src(&mut self) -> &mut Self

Call prior to setting values for src identifier

fn first(&mut self) -> &mut Self

Call prior to setting values for first identifier. This is either the component identifier, or first element of a pair (in case second is populated as well).

fn second(&mut self) -> &mut Self

Call prior to setting values for second identifier. This is the second element of a pair. Requires that first() is populated as well.

fn set_src_id(&mut self, id: impl Into<Entity>) -> &mut Self

Select src identifier, initialize it with entity id

fn set_src<T: ComponentId>(&mut self) -> &mut Self

Select src identifier, initialize it with id associated with type

fn set_src_name(&mut self, name: &'a str) -> &mut Self

Select src identifier, initialize it with name. If name starts with a $ the name is interpreted as a variable.

fn set_first_id(&mut self, id: impl Into<Entity>) -> &mut Self

Select first identifier, initialize it with entity id

fn set_first<T: ComponentId>(&mut self) -> &mut Self

Select first identifier, initialize it with id associated with type

fn set_first_name(&mut self, name: &'a str) -> &mut Self

Select first identifier, initialize it with name. If name starts with a $ the name is interpreted as a variable.

fn set_second_id(&mut self, id: impl Into<Entity>) -> &mut Self

Select second identifier, initialize it with entity id

fn set_second<T: ComponentId>(&mut self) -> &mut Self

Select second identifier, initialize it with id associated with type

fn set_second_name(&mut self, name: &'a str) -> &mut Self

Select second identifier, initialize it with name. If name starts with a $ the name is interpreted as a variable.

fn up(&mut self) -> &mut Self

default up where trav is set to 0. The up flag indicates that the term identifier may be substituted by traversing a relationship upwards. For example: substitute the identifier with its parent by traversing the ChildOf relationship.

fn parent(&mut self) -> &mut Self

same as up

fn up_id(&mut self, traverse_relationship: impl Into<Entity>) -> &mut Self

The up flag indicates that the term identifier may be substituted by traversing a relationship upwards. For example: substitute the identifier with its parent by traversing the ChildOf relationship.

fn up_type<TravRel: ComponentId>(&mut self) -> &mut Self

The up flag indicates that the term identifier may be substituted by traversing a relationship upwards. For example: substitute the identifier with its parent by traversing the ChildOf relationship.

fn cascade(&mut self) -> &mut Self

Cascade iterates a hierarchy in top to bottom order (breadth first search) The cascade flag is like up, but returns results in breadth-first order. Only supported for flecs::query.

fn cascade_id(&mut self, traverse_relationship: impl Into<Entity>) -> &mut Self

Cascade iterates a hierarchy in top to bottom order (breadth first search) The cascade flag is like up, but returns results in breadth-first order. Only supported for flecs::query

fn cascade_type<TravRel: ComponentId>(&mut self) -> &mut Self

Cascade iterates a hierarchy in top to bottom order (breadth first search) The cascade flag is like up, but returns results in breadth-first order. Only supported for flecs::query

fn desc(&mut self) -> &mut Self

Use with cascade to iterate results in descending (bottom + top) order.

fn trav( &mut self, traverse_relationship: impl Into<Entity>, flags: u64, ) -> &mut Self

Specify relationship to traverse, and flags to indicate direction

fn id_flags(&mut self, flags: impl IntoId) -> &mut Self

Set id flags for term.

fn set_inout_kind(&mut self, inout: InOutKind) -> &mut Self

Set read/write access of term

fn inout_stage(&mut self, inout: InOutKind) -> &mut Self

Set read/write access for stage. Use this when a system reads or writes components other than the ones provided by the query. This information can be used by schedulers to insert sync/merge points between systems where deferred operations are flushed.

fn write_curr(&mut self) -> &mut Self

Set write mode on current term. Short for inout_stage(InOutKind::Out). Use when system uses add, remove or set.

fn read_curr(&mut self) -> &mut Self

Set read mode on current term. Short for inout_stage(InOutKind::In). Use when system uses get

fn read_write(&mut self) -> &mut Self

Short for inout_stage(InOutKind::InOut). Use when system uses ensure

fn set_in(&mut self) -> &mut Self

short for set_inout(InOutKind::In)

fn set_out(&mut self) -> &mut Self

short for set_inout(InOutKind::Out)

fn set_inout(&mut self) -> &mut Self

short for set_inout(InOutKind::InOut)

fn set_inout_none(&mut self) -> &mut Self

short for set_inout(InOutKind::None)

fn set_oper(&mut self, oper: OperKind) -> &mut Self

set operator of term

fn and(&mut self) -> &mut Self

short for set_oper(OperKind::And)

fn or(&mut self) -> &mut Self

short for set_oper(OperKind::Or)

fn not(&mut self) -> &mut Self

short for set_oper(OperKind::Not)

fn optional(&mut self) -> &mut Self

short for set_oper(OperKind::Optional)

fn and_from(&mut self) -> &mut Self

short for set_oper(OperKind::AndFrom)

fn or_from(&mut self) -> &mut Self

short for set_oper(OperKind::OrFrom)

fn not_from(&mut self) -> &mut Self

short for set_oper(OperKind::NotFrom)

fn singleton(&mut self) -> &mut Self

Match singleton

fn filter(&mut self) -> &mut Self

Query terms are not triggered on by observers

impl<'a, T: QueryTuple> WorldProvider<'a> for QueryBuilder<'a, T>

fn world(&self) -> WorldRef<'a>