Struct Query 

pub struct Query<'a, Q: Query> { /* private fields */ }

Borrow of an ECS query result.

Obtained as a system parameter; derefs to hecs::QueryBorrow.

Iterating

Query implements IntoIterator for &mut Query, so you can iterate it directly without going through Deref:

fn move_system(mut q: Query<(&mut Position, &Velocity)>) {
    for (entity, (pos, vel)) in &mut q {
        pos.x += vel.x;
        pos.y += vel.y;
    }
}

Single-entity lookups

Use Query::get to fetch components for one known Entity without scanning the whole result set, and Query::single / Query::get_single when you expect exactly one match (e.g. “the player”, “the active camera”).

Implementations

impl<'a, Q: Query> Query<'a, Q>

pub fn get(&self, entity: Entity) -> QueryOne<'_, Q>

Look up a single entity’s components for this query. Returns None if the entity doesn’t exist or doesn’t match Q.

pub fn with<R: Query>(self) -> QueryBorrow<'a, With<Q, R>>

Filter this query to only entities that ALSO have component R, without R itself being part of the yielded items. Consumes self — matches hecs’s own QueryBorrow::with signature.

pub fn without<R: Query>(self) -> QueryBorrow<'a, Without<Q, R>>

Filter this query to only entities that do NOT have component R. Consumes self, same reasoning as with.

pub fn single(&mut self) -> Q::Item<'_>

Return the single entity’s components for this query.

Panics if there isn’t exactly one match. Intended for singleton-style queries (the player, the active camera, …) where zero or multiple matches indicate a bug. See Query::get_single for a non-panicking version. Include hecs::Entity in Q if you need the id alongside the components.

pub fn get_single(&mut self) -> Option<Q::Item<'_>>

Like Query::single, but returns None instead of panicking when there isn’t exactly one match.

Methods from Deref<Target = QueryBorrow<'a, Q>>

pub fn iter(&mut self) -> QueryIter<'_, Q>

Execute the query

pub fn view(&mut self) -> View<'_, Q>

Provide random access to the query results

pub fn iter_batched(&mut self, batch_size: u32) -> BatchedIter<'_, Q>

Like iter, but returns child iterators of at most batch_size elements

Useful for distributing work over a threadpool.

Trait Implementations

impl<'a, Q: Query> Deref for Query<'a, Q>

type Target = QueryBorrow<'a, Q>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, Q: Query> DerefMut for Query<'a, Q>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'q, Q: Query> IntoIterator for &'q mut Query<'_, Q>

type Item = <Q as Query>::Item<'q>

The type of the elements being iterated over.

type IntoIter = QueryIter<'q, Q>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Q> SystemParam for Query<'static, Q>

where Q: Query + 'static,

type Item<'a> = Query<'a, Q>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, _resources: &'a Resources, ) -> Self::Item<'a>