Trait Query

pub unsafe trait Query {
    type Item<'a>;
    type ArchState: Send + Sync + Debug + 'static;
    type State: Debug + 'static;

    // Required methods
    fn init(
        world: &mut World,
        config: &mut HandlerConfig,
    ) -> Result<(ComponentAccess, Self::State), InitError>;
    fn new_state(world: &mut World) -> Self::State;
    fn new_arch_state(
        arch: &Archetype,
        state: &mut Self::State,
    ) -> Option<Self::ArchState>;
    unsafe fn get<'a>(
        state: &Self::ArchState,
        row: ArchetypeRow,
    ) -> Self::Item<'a>;
}

Expand description

Types that can be fetched from an entity.

For more information, see the relevant tutorial chapter.

§Deriving

This trait can be safely implemented using the Query derive macro. For a struct to derive Query, all fields must also implement Query.

use evenio::prelude::*;

#[derive(Component, Debug)]
struct A(i32);

#[derive(Component, Debug)]
struct B;

#[derive(Query, Debug)]
struct CustomQuery<'a> {
    foo: &'a mut A,
    bar: EntityId,
    baz: Has<&'static B>,
}

let mut world = World::new();

world.add_handler(|_: Receiver<MyEvent>, q: Fetcher<CustomQuery>| {
    for item in q {
        println!("{item:?}");
    }
});

world.send(MyEvent);

§Safety

Implementors must ensure that Query::init correctly registers the data accessed in Query::get.

Required Associated Types§

The item returned by this query. This is usually the same type as Self, but with a modified lifetime.

Per-archetype state, e.g. pointers to archetype columns.

Cached data for fetch initialization, e.g. component indices.

Required Methods§

Initialize the query. Returns an expression describing the components accessed by the query and a new instance of Self::State.

Returns a new Self::State instance.

Gets the query item at the given row in the archetype.

row must be in bounds.
Must have the appropriate component access permissions described by the ComponentAccess returned by init.
The lifetime of the item is chosen by the caller. The item must not outlive the data it references.

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.

Implementations on Foreign Types§

Returns the result of Q as Some, or None if Q does not match.

Like (), the PhantomData<T> query always succeeds.

Implementors§

Returns the EntityId of the matched entity.

Trait QueryCopy item path

§Deriving

§Safety

Required Associated Types§

type Item<'a>

type ArchState: Send + Sync + Debug + 'static

type State: Debug + 'static

Required Methods§

fn init( world: &mut World, config: &mut HandlerConfig, ) -> Result<(ComponentAccess, Self::State), InitError>

fn new_state(world: &mut World) -> Self::State

fn new_arch_state( arch: &Archetype, state: &mut Self::State, ) -> Option<Self::ArchState>

unsafe fn get<'a>(state: &Self::ArchState, row: ArchetypeRow) -> Self::Item<'a>

§Safety

Dyn Compatibility§

Implementations on Foreign Types§

impl Query for ()

type Item<'a> = ()

type ArchState = ()

type State = ()

fn init( world: &mut World, config: &mut HandlerConfig, ) -> Result<(ComponentAccess, <() as Query>::State), InitError>

fn new_state(world: &mut World) -> <() as Query>::State

fn new_arch_state( arch: &Archetype, _: &mut <() as Query>::State, ) -> Option<<() as Query>::ArchState>

unsafe fn get<'a>( _: &<() as Query>::ArchState, row: ArchetypeRow, ) -> <() as Query>::Item<'a>

impl<C> Query for &Cwhere C: Component,

type Item<'a> = &'a C

type ArchState = ColumnPtr<C>

type State = ComponentIdx

fn init( world: &mut World, config: &mut HandlerConfig, ) -> Result<(ComponentAccess, <&C as Query>::State), InitError>

fn new_state(world: &mut World) -> <&C as Query>::State

fn new_arch_state( arch: &Archetype, state: &mut <&C as Query>::State, ) -> Option<<&C as Query>::ArchState>

unsafe fn get<'a>( state: &<&C as Query>::ArchState, row: ArchetypeRow, ) -> <&C as Query>::Item<'a>

impl<C> Query for &mut Cwhere C: Component<Mutability = Mutable>,

type Item<'a> = &'a mut C

type ArchState = ColumnPtr<C>

type State = ComponentIdx

fn init( world: &mut World, config: &mut HandlerConfig, ) -> Result<(ComponentAccess, <&mut C as Query>::State), InitError>

fn new_state(world: &mut World) -> <&mut C as Query>::State

fn new_arch_state( arch: &Archetype, state: &mut <&mut C as Query>::State, ) -> Option<<&mut C as Query>::ArchState>

unsafe fn get<'a>( state: &<&mut C as Query>::ArchState, row: ArchetypeRow, ) -> <&mut C as Query>::Item<'a>

impl<Q0> Query for (Q0,)where Q0: Query,

type Item<'a> = (<Q0 as Query>::Item<'a>,)

type ArchState = (<Q0 as Query>::ArchState,)

type State = (<Q0 as Query>::State,)

fn init( world: &mut World, config: &mut HandlerConfig, ) -> Result<(ComponentAccess, <(Q0,) as Query>::State), InitError>

fn new_state(world: &mut World) -> <(Q0,) as Query>::State

fn new_arch_state( arch: &Archetype, _: &mut <(Q0,) as Query>::State, ) -> Option<<(Q0,) as Query>::ArchState>

unsafe fn get<'a>( _: &<(Q0,) as Query>::ArchState, row: ArchetypeRow, ) -> <(Q0,) as Query>::Item<'a>

impl<Q0, Q1> Query for (Q0, Q1)where Q0: Query, Q1: Query,

type Item<'a> = (<Q0 as Query>::Item<'a>, <Q1 as Query>::Item<'a>)

type ArchState = (<Q0 as Query>::ArchState, <Q1 as Query>::ArchState)

type State = (<Q0 as Query>::State, <Q1 as Query>::State)

fn init( world: &mut World, config: &mut HandlerConfig, ) -> Result<(ComponentAccess, <(Q0, Q1) as Query>::State), InitError>

fn new_state(world: &mut World) -> <(Q0, Q1) as Query>::State

fn new_arch_state( arch: &Archetype, _: &mut <(Q0, Q1) as Query>::State, ) -> Option<<(Q0, Q1) as Query>::ArchState>

unsafe fn get<'a>( _: &<(Q0, Q1) as Query>::ArchState, row: ArchetypeRow, ) -> <(Q0, Q1) as Query>::Item<'a>

impl<Q0, Q1, Q2> Query for (Q0, Q1, Q2)where Q0: Query, Q1: Query, Q2: Query,

type Item<'a> = (<Q0 as Query>::Item<'a>, <Q1 as Query>::Item<'a>, <Q2 as Query>::Item<'a>)

type ArchState = (<Q0 as Query>::ArchState, <Q1 as Query>::ArchState, <Q2 as Query>::ArchState)

type State = (<Q0 as Query>::State, <Q1 as Query>::State, <Q2 as Query>::State)

fn init( world: &mut World, config: &mut HandlerConfig, ) -> Result<(ComponentAccess, <(Q0, Q1, Q2) as Query>::State), InitError>

fn new_state(world: &mut World) -> <(Q0, Q1, Q2) as Query>::State

fn new_arch_state( arch: &Archetype, _: &mut <(Q0, Q1, Q2) as Query>::State, ) -> Option<<(Q0, Q1, Q2) as Query>::ArchState>

unsafe fn get<'a>( _: &<(Q0, Q1, Q2) as Query>::ArchState, row: ArchetypeRow, ) -> <(Q0, Q1, Q2) as Query>::Item<'a>

impl<Q0, Q1, Q2, Q3> Query for (Q0, Q1, Q2, Q3)where Q0: Query, Q1: Query, Q2: Query, Q3: Query,

type Item<'a> = (<Q0 as Query>::Item<'a>, <Q1 as Query>::Item<'a>, <Q2 as Query>::Item<'a>, <Q3 as Query>::Item<'a>)

type ArchState = (<Q0 as Query>::ArchState, <Q1 as Query>::ArchState, <Q2 as Query>::ArchState, <Q3 as Query>::ArchState)

type State = (<Q0 as Query>::State, <Q1 as Query>::State, <Q2 as Query>::State, <Q3 as Query>::State)

fn init( world: &mut World, config: &mut HandlerConfig, ) -> Result<(ComponentAccess, <(Q0, Q1, Q2, Q3) as Query>::State), InitError>

fn new_state(world: &mut World) -> <(Q0, Q1, Q2, Q3) as Query>::State

fn new_arch_state( arch: &Archetype, _: &mut <(Q0, Q1, Q2, Q3) as Query>::State, ) -> Option<<(Q0, Q1, Q2, Q3) as Query>::ArchState>

unsafe fn get<'a>( _: &<(Q0, Q1, Q2, Q3) as Query>::ArchState, row: ArchetypeRow, ) -> <(Q0, Q1, Q2, Q3) as Query>::Item<'a>

impl<Q0, Q1, Q2, Q3, Q4> Query for (Q0, Q1, Q2, Q3, Q4)where Q0: Query, Q1: Query, Q2: Query, Q3: Query, Q4: Query,

type Item<'a> = (<Q0 as Query>::Item<'a>, <Q1 as Query>::Item<'a>, <Q2 as Query>::Item<'a>, <Q3 as Query>::Item<'a>, <Q4 as Query>::Item<'a>)

type ArchState = (<Q0 as Query>::ArchState, <Q1 as Query>::ArchState, <Q2 as Query>::ArchState, <Q3 as Query>::ArchState, <Q4 as Query>::ArchState)

type State = (<Q0 as Query>::State, <Q1 as Query>::State, <Q2 as Query>::State, <Q3 as Query>::State, <Q4 as Query>::State)

fn init( world: &mut World, config: &mut HandlerConfig, ) -> Result<(ComponentAccess, <(Q0, Q1, Q2, Q3, Q4) as Query>::State), InitError>

fn new_state(world: &mut World) -> <(Q0, Q1, Q2, Q3, Q4) as Query>::State

fn new_arch_state( arch: &Archetype, _: &mut <(Q0, Q1, Q2, Q3, Q4) as Query>::State, ) -> Option<<(Q0, Q1, Q2, Q3, Q4) as Query>::ArchState>

unsafe fn get<'a>( _: &<(Q0, Q1, Q2, Q3, Q4) as Query>::ArchState, row: ArchetypeRow, ) -> <(Q0, Q1, Q2, Q3, Q4) as Query>::Item<'a>

impl<Q0, Q1, Q2, Q3, Q4, Q5> Query for (Q0, Q1, Q2, Q3, Q4, Q5)where Q0: Query, Q1: Query, Q2: Query, Q3: Query, Q4: Query, Q5: Query,

Trait Query

impl<C> Query for &C
where C: Component,

impl<C> Query for &mut C
where C: Component<Mutability = Mutable>,

impl<Q0> Query for (Q0,)
where Q0: Query,

impl<Q0, Q1> Query for (Q0, Q1)
where Q0: Query, Q1: Query,

impl<Q0, Q1, Q2> Query for (Q0, Q1, Q2)
where Q0: Query, Q1: Query, Q2: Query,

impl<Q0, Q1, Q2, Q3> Query for (Q0, Q1, Q2, Q3)
where Q0: Query, Q1: Query, Q2: Query, Q3: Query,

impl<Q0, Q1, Q2, Q3, Q4> Query for (Q0, Q1, Q2, Q3, Q4)
where Q0: Query, Q1: Query, Q2: Query, Q3: Query, Q4: Query,

impl<Q0, Q1, Q2, Q3, Q4, Q5> Query for (Q0, Q1, Q2, Q3, Q4, Q5)
where Q0: Query, Q1: Query, Q2: Query, Q3: Query, Q4: Query, Q5: Query,

impl<Q0, Q1, Q2, Q3, Q4, Q5, Q6> Query for (Q0, Q1, Q2, Q3, Q4, Q5, Q6)
where Q0: Query, Q1: Query, Q2: Query, Q3: Query, Q4: Query, Q5: Query, Q6: Query,

impl<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7> Query for (Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7)
where Q0: Query, Q1: Query, Q2: Query, Q3: Query, Q4: Query, Q5: Query, Q6: Query, Q7: Query,

impl<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8> Query for (Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8)
where Q0: Query, Q1: Query, Q2: Query, Q3: Query, Q4: Query, Q5: Query, Q6: Query, Q7: Query, Q8: Query,

impl<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9> Query for (Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9)
where Q0: Query, Q1: Query, Q2: Query, Q3: Query, Q4: Query, Q5: Query, Q6: Query, Q7: Query, Q8: Query, Q9: Query,

impl<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, Q10> Query for (Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, Q10)
where Q0: Query, Q1: Query, Q2: Query, Q3: Query, Q4: Query, Q5: Query, Q6: Query, Q7: Query, Q8: Query, Q9: Query, Q10: Query,

impl<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, Q10, Q11> Query for (Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, Q10, Q11)
where Q0: Query, Q1: Query, Q2: Query, Q3: Query, Q4: Query, Q5: Query, Q6: Query, Q7: Query, Q8: Query, Q9: Query, Q10: Query, Q11: Query,

impl<Q> Query for Option<Q>
where Q: Query,