Struct Query 

pub struct Query { /* private fields */ }

Query iterates over entities matching QueryFilter

Examples

use xuko_ecs::prelude::*;

let mut world = World::new();

let filter = QueryFilter::new()
    .with_requires(&[component_id!(i32)]);

let queried = Query::query_world(&world, filter);
// do stuff with the queried entities

Implementations

impl Query

pub fn query_world(world: &World, filter: QueryFilter) -> Self

Queries entities that match filter on world

Examples found in repository

examples/schedule.rs (lines 43-49)

fn move_entities(world: &mut World) {
    let entities = Query::query_world(
        world,
        QueryFilter {
            requires: vec![component_id!(Position), component_id!(Velocity)],
            ..Default::default()
        },
    );

    for e in &entities {
        let entity = world.get_entity_mut(e).unwrap();

        let velocity = entity.get::<Velocity>().cloned().unwrap();
        let position = entity.get_mut::<Position>().unwrap();

        position.0 += velocity.0;
        position.1 += velocity.1;

        println!("Something that has a position: {position:?}");
    }
}

examples/stress.rs (lines 20-27)

fn main() {
    const ENTIIES: u64 = 1_000_000;
    let time = SystemTime::now();

    let mut world = World::new();

    #[allow(dead_code)]
    struct Number(u64);

    for n in 0..=ENTIIES {
        let id = world.spawn();
        world.get_entity_mut(id).unwrap().add(Number(n));
    }

    for e in &Query::query_world(
        &world,
        QueryFilter::new()
            .with_requires(&[component_id!(Number)])
            .with_func(Some(|id, world| {
                world.get_entity(id).unwrap().get::<Number>().unwrap().0 % 147 == 0
            })),
    ) {
        world.despawn(e);
    }

    println!(
        "spawning and filtering {ENTIIES} entities took {}ms",
        time.elapsed().unwrap().as_millis()
    );
}

examples/basic.rs (lines 34-44)

fn main() {
    let mut world = World::new();

    struct Name(String);
    struct Age(u8);
    struct Human;

    let people = [
        (Name("Alice".to_owned()), Age(20)),
        (Name("Bob".to_owned()), Age(26)),
        (Name("Cathrine".to_owned()), Age(33)),
        (Name("Dennis".to_owned()), Age(10)),
    ];

    for (name, age) in people {
        let entity = world.spawn();
        let entity = world.get_entity_mut(entity).unwrap();

        entity.add(name);
        entity.add(age);
        entity.add(Human);
    }

    {
        let entity = world.spawn();
        let entity = world.get_entity_mut(entity).unwrap();

        entity.add(Name("Jupiter".to_owned()));
    }

    for e in &Query::query_world(
        &world,
        QueryFilter {
            requires: vec![
                component_id!(Name),
                component_id!(Age),
                component_id!(Human),
            ],
            ..Default::default()
        },
    ) {
        let e = world.get_entity_mut(e).unwrap();
        let age = e.get::<Age>().map(|x| Age(x.0)).unwrap();
        let name = e.get_mut::<Name>().unwrap();

        name.0 = name.0.to_uppercase();
        println!("Found human named {}, who is {} years old", name.0, age.0);
    }

    for e in &Query::query_world(
        &world,
        QueryFilter {
            requires: vec![component_id!(Name)],
            ..Default::default()
        },
    ) {
        let entity = world.get_entity(e).unwrap();
        let name = entity.get::<Name>().unwrap();

        println!("This entity (#{e}) has a name: {}", name.0);
    }
}

pub fn filter_used(&self) -> Option<&QueryFilter>

Returns the QueryFilter used to create this Query

pub fn iter(&self) -> Iter<'_>

Return an iterator over the query

Trait Implementations

impl Clone for Query

fn clone(&self) -> Query

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Query

fn default() -> Query

Returns the “default value” for a type.

impl<'a> IntoIterator for &'a Query

type Item = usize

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Query

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Query