Struct QueryFilter 

pub struct QueryFilter {
    pub requires: Vec<ComponentId>,
    pub excludes: Vec<ComponentId>,
    pub single: bool,
    pub func: Option<QueryFunction>,
}

The QueryFilter describes the options for a crate::World query.

Fields

requires: Vec<ComponentId>

Component types to include in the query

excludes: Vec<ComponentId>

Component types to exclude from the query

single: bool

Whether to match only 1 entity

func: Option<QueryFunction>

Function to do additional checks on the entity

Implementations

impl QueryFilter

pub const fn new() -> Self

Create a new empty QueryFilter.

Examples found in repository

examples/stress.rs (line 22)

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()
    );
}

pub fn with_requires(self, requires: &[ComponentId]) -> Self

Sets QueryFilter::requires field and returns the QueryFilter.

Examples found in repository

examples/stress.rs (line 23)

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()
    );
}

pub fn with_excludes(self, excludes: &[ComponentId]) -> Self

Sets QueryFilter::excludes field and returns the QueryFilter.

pub fn with_single(self, single: bool) -> Self

Sets QueryFilter::single field and returns the QueryFilter.

pub fn with_func(self, func: Option<QueryFunction>) -> Self

Sets QueryFilter::func field and returns the QueryFilter.

Examples found in repository

examples/stress.rs (lines 24-26)

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()
    );
}

Trait Implementations

impl Clone for QueryFilter

fn clone(&self) -> QueryFilter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for QueryFilter

fn default() -> Self

Returns the “default value” for a type.

impl Hash for QueryFilter

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.