Skip to main content

Queryable

nya_ecs::query

Trait Queryable 

Source 
pub trait Queryable: Sealed {
    // Required methods
    fn query_filter(&self, filters: impl IntoFilter) -> Query;
    fn query_all(&self) -> Query;

    // Provided method
    fn query<T: ToFilter>(&self) -> Query { ... }
}
Expand description

A trait for queryable objects

Required Methods§

Source

fn query_filter(&self, filters: impl IntoFilter) -> Query

Run the query with filters

Source

fn query_all(&self) -> Query

Query for every entity

Provided Methods§

Source

fn query<T: ToFilter>(&self) -> Query

Run the query with filters T

Examples found in repository?
examples/query.rs (line 38)
18fn main() {
19    let mut world = World::new();
20
21    for i in 0..5 {
22        let ent = world.spawn();
23
24        world.add(ent, Tag);
25        world.add(ent, Name("Object"));
26
27        if i % 2 == 0 {
28            world.add(ent, Num(i));
29        }
30    }
31
32    {
33        let ent = world.spawn();
34        world.add(ent, Num(1337));
35    }
36
37    /// Query with component tuple
38    let query = world.query::<(Tag, Num)>();
39    for e in &query {
40        println!("Entity #{e} has both `Tag` and `Num`");
41    }
42
43    /// you can also use `Exclude` to ensure some components are not included
44    for e in &world.query::<(Tag, Exclude<(Num,)>)>() {
45        println!("Entity #{e} has `Tag` without `Num`");
46    }
47
48    // `Filter` allows for more fine-grained control.
49    // In fact, the (Component1, Component2, ...) tuple implements `ToFilter` so it can be used in a query
50    //
51    // `ComponentKey` is used to identify component types,
52    // the `component_id` macro can be used as a shorthand to `ComponentKey` functions.
53    let filter = Filter::new()
54        .with_include(&[ComponentKey::of::<Tag>(), ComponentKey::of::<Name>()])
55        .with_exclude(&[component_id!(Num)]);
56
57    for _ in &world.query_filter(filter) {
58        // do stuff
59    }
60}

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§