Struct Query 

pub struct Query<I, C> { /* private fields */ }

An iterator to find entities that share components.

It creates an intersection of ComponentVecs and yields the entities as well as their components.

The struct is created by calling the into_query method on tuples of ComponentVecs.

Examples

use checs::{ComponentVec, IntoQuery, LendingIterator};
use checs::entity::Allocator;

let mut entities = Allocator::new();
let e0 = entities.alloc();
let e1 = entities.alloc();
let e2 = entities.alloc();
let e3 = entities.alloc();
let e4 = entities.alloc();

let mut strs = ComponentVec::new();
strs.insert(e0, "ninety-nine");
strs.insert(e1, "zero");
strs.insert(e2, "forty-two");
strs.insert(e4, "seventeen");

let mut ints = ComponentVec::new();
ints.insert(e0, 99);
ints.insert(e2, 42);
ints.insert(e3, 1);
ints.insert(e4, 17);

let mut query = (&strs, &mut ints).into_query();

assert_eq!(query.next(), Some((e0, (&"ninety-nine", &mut 99))));
assert_eq!(query.next(), Some((e2, (&"forty-two", &mut 42))));
assert_eq!(query.next(), Some((e4, (&"seventeen", &mut 17))));
assert_eq!(query.next(), None);

Note: In the above example entities e1 and e3 each only have one of the components not both, so they are not included in the query.

Trait Implementations

impl<Iter, C> LendingIterator for Query<Iter, C>

where Iter: Iterator<Item = Entity>, C: GetRefOrMut,

fn next(&mut self) -> Option<<Self as Lifetime<'_>>::Item>

Advances the iterator and returns the next value.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(<Self as Lifetime<'_>>::Item),

Calls a closure on each element of the iterator.

impl<'l, Iter, C> Lifetime<'l> for Query<Iter, C>

where Iter: Iterator<Item = Entity>, C: Lifetime<'l>,

type Item = (Entity, <C as Lifetime<'l>>::Item)

The type of the elements being iterated over.