Struct flax::query::Query

pub struct Query<Q, F = All, S = Planar> { /* private fields */ }

Represents a query and state for a given world. The archetypes to visit is cached in the query which means it is more performant to reuse the query than creating a new one.

The archetype borrowing assures aliasing. Two of the same queries can be run at the same time as long as they don’t borrow an archetype’s component mutably at the same time.

Implementations

impl<Q> Query<Q, All, Planar>

pub fn new(fetch: Q) -> Self

where Q: for<'x> Fetch<'x>,

Construct a new query which will fetch all items in the given query. The query can be either a singular component, a tuple of components, or any other type which implements crate::Fetch.

Note: The query will not yield components, as it may not be intended behaviour since the most common intent is the entities. See Query::with_components

A fetch may also contain filters Construct a new query which will fetch all items in the given query. The query can be either a singular component, a tuple of components, or any other type which implements crate::Fetch.

Note: The query will not yield components, as it may not be intended behaviour since the most common intent is the entities. See Query::with_components

A fetch may also contain filters Construct a new query which will fetch all items in the given query. The query can be either a singular component, a tuple of components, or any other type which implements crate::Fetch.

Note: The query will not yield components, as it may not be intended behaviour since the most common intent is the entities. See Query::with_components

A fetch may also contain filters

pub fn with_components(self) -> Self

Include components in a planar query.

Note: only relevant for the planar strategy

impl<Q, F> Query<Q, F, Planar>

where Q: for<'x> Fetch<'x>, F: for<'x> Fetch<'x>,

pub fn with_strategy<S>(self, strategy: S) -> Query<Q, F, S>

where S: for<'w> QueryStrategy<'w, Q, F>,

Use the given [QueryStrategy].

This replaces the previous strategy

pub fn entity(self, id: Entity) -> EntityQuery<Q, F>

where Entity: for<'w> QueryStrategy<'w, Q, F>,

Transform the query into a query for a single entity

pub fn topo<T: ComponentValue>( self, relation: impl RelationExt<T> ) -> Query<Q, F, Topo>

where Topo: for<'w> QueryStrategy<'w, Q, F>,

Transform the query into a topologically ordered query

pub fn collect_vec<'w, T>(&'w mut self, world: &'w World) -> Vec<T>

where T: 'static, Q: for<'q> FetchItem<'q, Item = T>,

Collect all elements in the query into a vector

pub fn collect_sorted_vec<'w, T>(&'w mut self, world: &'w World) -> Vec<T>

where T: 'static + Ord, Q: for<'q> FetchItem<'q, Item = T>,

Collect all elements in the query into a sorted vector

impl<Q, F, S> Query<Q, F, S>

where Q: for<'x> Fetch<'x>, F: for<'x> Fetch<'x>,

pub fn filter<G>(self, filter: G) -> Query<Q, F::PushRight, S>

where F: TuplePush<G>,

Adds a new filter to the query. This filter is and:ed with the existing filters.

pub fn batch_size(self, size: Slot) -> Query<Q, F::PushRight, S>

where F: TuplePush<BatchSize>,

Limits the size of each batch using QueryBorrow::iter_batched

pub fn with_relation<T: ComponentValue>( self, rel: impl RelationExt<T> ) -> Query<Q, F::PushRight, S>

where F: TuplePush<WithRelation>,

Shortcut for filter(with_relation)

pub fn without_relation<T: ComponentValue>( self, rel: impl RelationExt<T> ) -> Query<Q, F::PushRight, S>

where F: TuplePush<WithoutRelation>,

Shortcut for filter(without_relation)

pub fn without<T: ComponentValue>( self, component: Component<T> ) -> Query<Q, F::PushRight, S>

where F: TuplePush<Without>,

Shortcut for filter(without)

pub fn with<T: ComponentValue>( self, component: Component<T> ) -> Query<Q, F::PushRight, S>

where F: TuplePush<With>,

Shortcut for filter(with)

pub fn borrow<'w>(&'w mut self, world: &'w World) -> S::Borrow

where S: QueryStrategy<'w, Q, F>,

Borrow data in the world for the query.

The returned value holds the borrows of the query fetch. As such, all references from iteration or using [QueryBorrow::get] will have a lifetime of the [QueryBorrow`].

This is because iterators can not yield references to internal state as all items returned by the iterator need to coexist.

It is safe to use the same prepared query for both iteration and random access, Rust’s borrow rules will ensure aliasing rules.

Trait Implementations

impl<Q: Clone, F: Clone, S: Clone> Clone for Query<Q, F, S>

fn clone(&self) -> Query<Q, F, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Q, F, S: Debug> Debug for Query<Q, F, S>

where Q: for<'x> Fetch<'x> + Debug, F: for<'x> Fetch<'x> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Q, F, S> SystemAccess for Query<Q, F, S>

where Q: 'static + for<'x> Fetch<'x>, F: 'static + for<'x> Fetch<'x>, S: for<'x> QueryStrategy<'x, Q, F>,

fn access(&self, world: &World, dst: &mut Vec<Access>)

Returns all the accesses for a system

impl<'a, Q, F, S> SystemData<'a> for Query<Q, F, S>

where Q: 'static + for<'x> Fetch<'x>, F: 'static + for<'x> Fetch<'x>, S: 'static + for<'x> QueryStrategy<'x, Q, F>,

type Value = QueryData<'a, Q, F, S>

The borrow from the system context

fn acquire(&'a mut self, ctx: &'a SystemContext<'_, '_, '_>) -> Self::Value

Get the data from the system context

fn describe(&self, f: &mut Formatter<'_>) -> Result

Human friendly debug description