Trait bevy::ecs::query::WorldQuery

pub unsafe trait WorldQuery {
    type Item<'a>;
    type Fetch<'a>: Clone;
    type State: Send + Sync;

    const IS_DENSE: bool;

    // Required methods
    fn shrink<'wlong, 'wshort>(item: Self::Item<'wlong>) -> Self::Item<'wshort>
       where 'wlong: 'wshort;
    unsafe fn init_fetch<'w>(
        world: UnsafeWorldCell<'w>,
        state: &Self::State,
        last_run: Tick,
        this_run: Tick
    ) -> Self::Fetch<'w>;
    unsafe fn set_archetype<'w>(
        fetch: &mut Self::Fetch<'w>,
        state: &Self::State,
        archetype: &'w Archetype,
        table: &'w Table
    );
    unsafe fn set_table<'w>(
        fetch: &mut Self::Fetch<'w>,
        state: &Self::State,
        table: &'w Table
    );
    unsafe fn fetch<'w>(
        fetch: &mut Self::Fetch<'w>,
        entity: Entity,
        table_row: TableRow
    ) -> Self::Item<'w>;
    fn update_component_access(
        state: &Self::State,
        access: &mut FilteredAccess<ComponentId>
    );
    fn init_state(world: &mut World) -> Self::State;
    fn get_state(components: &Components) -> Option<Self::State>;
    fn matches_component_set(
        state: &Self::State,
        set_contains_id: &impl Fn(ComponentId) -> bool
    ) -> bool;

    // Provided method
    fn set_access(
        _state: &mut Self::State,
        _access: &FilteredAccess<ComponentId>
    ) { ... }
}

Types that can be used as parameters in a Query. Types that implement this should also implement either QueryData or QueryFilter

Safety

Implementor must ensure that update_component_access, matches_component_set, and fetch obey the following:

• For each component mutably accessed by fetch, update_component_access should add write access unless read or write access has already been added, in which case it should panic.
• For each component readonly accessed by fetch, update_component_access should add read access unless write access has already been added, in which case it should panic.
• If fetch mutably accesses the same component twice, update_component_access should panic.
• update_component_access may not add a Without filter for a component unless matches_component_set always returns false when the component set contains that component.
• update_component_access may not add a With filter for a component unless matches_component_set always returns false when the component set doesn’t contain that component.
• In cases where the query represents a disjunction (such as an Or filter) where each element is a valid WorldQuery, the following rules must be obeyed:
  • matches_component_set must be a disjunction of the element’s implementations
  • update_component_access must replace the filters with a disjunction of filters
  • Each filter in that disjunction must be a conjunction of the corresponding element’s filter with the previous access

When implementing update_component_access, note that add_read and add_write both also add a With filter, whereas extend_access does not change the filters.

Required Associated Types

type Item<'a>

The item returned by this WorldQuery For QueryData this will be the item returned by the query. For QueryFilter this will be either (), or a bool indicating whether the entity should be included or a tuple of such things.

type Fetch<'a>: Clone

Per archetype/table state used by this WorldQuery to fetch Self::Item

type State: Send + Sync

State used to construct a Self::Fetch. This will be cached inside QueryState, so it is best to move as much data / computation here as possible to reduce the cost of constructing Self::Fetch.

Required Associated Constants

const IS_DENSE: bool

Returns true if (and only if) every table of every archetype matched by this fetch contains all of the matched components. This is used to select a more efficient “table iterator” for “dense” queries. If this returns true, WorldQuery::set_table must be used before WorldQuery::fetch can be called for iterators. If this returns false, WorldQuery::set_archetype must be used before WorldQuery::fetch can be called for iterators.

Required Methods

fn shrink<'wlong, 'wshort>(item: Self::Item<'wlong>) -> Self::Item<'wshort>

where 'wlong: 'wshort,

This function manually implements subtyping for the query items.

unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, state: &Self::State, last_run: Tick, this_run: Tick ) -> Self::Fetch<'w>

Creates a new instance of this fetch.

Safety

• state must have been initialized (via WorldQuery::init_state) using the same world passed in to this function.

unsafe fn set_archetype<'w>( fetch: &mut Self::Fetch<'w>, state: &Self::State, archetype: &'w Archetype, table: &'w Table )

Adjusts internal state to account for the next Archetype. This will always be called on archetypes that match this WorldQuery.

Safety

• archetype and tables must be from the same World that WorldQuery::init_state was called on.
• table must correspond to archetype.
• state must be the State that fetch was initialized with.

unsafe fn set_table<'w>( fetch: &mut Self::Fetch<'w>, state: &Self::State, table: &'w Table )

Adjusts internal state to account for the next Table. This will always be called on tables that match this WorldQuery.

Safety

• table must be from the same World that WorldQuery::init_state was called on.
• state must be the State that fetch was initialized with.

unsafe fn fetch<'w>( fetch: &mut Self::Fetch<'w>, entity: Entity, table_row: TableRow ) -> Self::Item<'w>

Fetch Self::Item for either the given entity in the current Table, or for the given entity in the current Archetype. This must always be called after WorldQuery::set_table with a table_row in the range of the current Table or after WorldQuery::set_archetype with a entity in the current archetype.

Safety

Must always be called after WorldQuery::set_table or WorldQuery::set_archetype. entity and table_row must be in the range of the current table and archetype.

fn update_component_access( state: &Self::State, access: &mut FilteredAccess<ComponentId> )

Adds any component accesses used by this WorldQuery to access.

Used to check which queries are disjoint and can run in parallel

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

Creates and initializes a State for this WorldQuery type.

fn get_state(components: &Components) -> Option<Self::State>

Attempts to initialize a State for this WorldQuery type using read-only access to Components.

fn matches_component_set( state: &Self::State, set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

Returns true if this query matches a set of components. Otherwise, returns false.

Used to check which Archetypes can be skipped by the query (if none of the Components match)

Provided Methods

fn set_access(_state: &mut Self::State, _access: &FilteredAccess<ComponentId>)

Sets available accesses for implementors with dynamic access such as FilteredEntityRef or FilteredEntityMut.

Called when constructing a QueryLens or calling QueryState::from_builder

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl WorldQuery for ()

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = ()

type Item<'w> = ()

type State = ()

fn shrink<'wlong, 'wshort>( item: <() as WorldQuery>::Item<'wlong> ) -> <() as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<() as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <() as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = true

unsafe fn set_archetype<'w>( _fetch: &mut <() as WorldQuery>::Fetch<'w>, _state: &<() as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <() as WorldQuery>::Fetch<'w>, _state: &<() as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <() as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <() as WorldQuery>::Item<'w>

fn update_component_access( state: &<() as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state(world: &mut World) -> <() as WorldQuery>::State

fn get_state(components: &Components) -> Option<<() as WorldQuery>::State>

fn matches_component_set( state: &<() as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<'__w, T> WorldQuery for &'__w mut T

where T: Component,

SAFETY: fetch accesses a single component mutably. This is sound because update_component_access and update_archetype_component_access add write access for that component and panic when appropriate. update_component_access adds a With filter for a component. This is sound because matches_component_set returns whether the set contains that component.

type Item<'w> = Mut<'w, T>

type Fetch<'w> = WriteFetch<'w, T>

type State = ComponentId

fn shrink<'wlong, 'wshort>(item: Mut<'wlong, T>) -> Mut<'wshort, T>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, _: &ComponentId, last_run: Tick, this_run: Tick ) -> WriteFetch<'w, T>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( fetch: &mut WriteFetch<'w, T>, component_id: &ComponentId, _archetype: &'w Archetype, table: &'w Table )

unsafe fn set_table<'w>( fetch: &mut WriteFetch<'w, T>, _: &ComponentId, table: &'w Table )

unsafe fn fetch<'w>( fetch: &mut <&'__w mut T as WorldQuery>::Fetch<'w>, entity: Entity, table_row: TableRow ) -> <&'__w mut T as WorldQuery>::Item<'w>

fn update_component_access( _: &ComponentId, access: &mut FilteredAccess<ComponentId> )

fn init_state(world: &mut World) -> ComponentId

fn get_state( components: &Components ) -> Option<<&'__w mut T as WorldQuery>::State>

fn matches_component_set( _: &ComponentId, set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0> WorldQuery for (F0,)

where F0: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>,)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>,)

type State = (<F0 as WorldQuery>::State,)

fn shrink<'wlong, 'wshort>( item: <(F0,) as WorldQuery>::Item<'wlong> ) -> <(F0,) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0,) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0,) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0,) as WorldQuery>::Fetch<'w>, _state: &<(F0,) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0,) as WorldQuery>::Fetch<'w>, _state: &<(F0,) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0,) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0,) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0,) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state(world: &mut World) -> <(F0,) as WorldQuery>::State

fn get_state(components: &Components) -> Option<<(F0,) as WorldQuery>::State>

fn matches_component_set( state: &<(F0,) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1> WorldQuery for (F0, F1)

where F0: WorldQuery, F1: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1) as WorldQuery>::Item<'wlong> ) -> <(F0, F1) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state(world: &mut World) -> <(F0, F1) as WorldQuery>::State

fn get_state(components: &Components) -> Option<<(F0, F1) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2> WorldQuery for (F0, F1, F2)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state(world: &mut World) -> <(F0, F1, F2) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3> WorldQuery for (F0, F1, F2, F3)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state(world: &mut World) -> <(F0, F1, F2, F3) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4> WorldQuery for (F0, F1, F2, F3, F4)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state(world: &mut World) -> <(F0, F1, F2, F3, F4) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4, F5> WorldQuery for (F0, F1, F2, F3, F4, F5)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4, F5) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4, F5) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4, F5) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4, F5) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4, F5) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4, F5) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state( world: &mut World ) -> <(F0, F1, F2, F3, F4, F5) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4, F5) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4, F5) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6> WorldQuery for (F0, F1, F2, F3, F4, F5, F6)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state( world: &mut World ) -> <(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4, F5, F6) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6, F7> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state( world: &mut World ) -> <(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4, F5, F6, F7) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state( world: &mut World ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state( world: &mut World ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>, <F10 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>, <F10 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state( world: &mut World ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>, <F10 as WorldQuery>::Fetch<'w>, <F11 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>, <F10 as WorldQuery>::Item<'w>, <F11 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state( world: &mut World ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>, <F10 as WorldQuery>::Fetch<'w>, <F11 as WorldQuery>::Fetch<'w>, <F12 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>, <F10 as WorldQuery>::Item<'w>, <F11 as WorldQuery>::Item<'w>, <F12 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state( world: &mut World ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery, F13: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>, <F10 as WorldQuery>::Fetch<'w>, <F11 as WorldQuery>::Fetch<'w>, <F12 as WorldQuery>::Fetch<'w>, <F13 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>, <F10 as WorldQuery>::Item<'w>, <F11 as WorldQuery>::Item<'w>, <F12 as WorldQuery>::Item<'w>, <F13 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state( world: &mut World ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery, F13: WorldQuery, F14: WorldQuery,

SAFETY: fetch accesses are the conjunction of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access adds all With and Without filters from the subqueries. This is sound because matches_component_set always returns false if any the subqueries’ implementations return false.

type Fetch<'w> = (<F0 as WorldQuery>::Fetch<'w>, <F1 as WorldQuery>::Fetch<'w>, <F2 as WorldQuery>::Fetch<'w>, <F3 as WorldQuery>::Fetch<'w>, <F4 as WorldQuery>::Fetch<'w>, <F5 as WorldQuery>::Fetch<'w>, <F6 as WorldQuery>::Fetch<'w>, <F7 as WorldQuery>::Fetch<'w>, <F8 as WorldQuery>::Fetch<'w>, <F9 as WorldQuery>::Fetch<'w>, <F10 as WorldQuery>::Fetch<'w>, <F11 as WorldQuery>::Fetch<'w>, <F12 as WorldQuery>::Fetch<'w>, <F13 as WorldQuery>::Fetch<'w>, <F14 as WorldQuery>::Fetch<'w>)

type Item<'w> = (<F0 as WorldQuery>::Item<'w>, <F1 as WorldQuery>::Item<'w>, <F2 as WorldQuery>::Item<'w>, <F3 as WorldQuery>::Item<'w>, <F4 as WorldQuery>::Item<'w>, <F5 as WorldQuery>::Item<'w>, <F6 as WorldQuery>::Item<'w>, <F7 as WorldQuery>::Item<'w>, <F8 as WorldQuery>::Item<'w>, <F9 as WorldQuery>::Item<'w>, <F10 as WorldQuery>::Item<'w>, <F11 as WorldQuery>::Item<'w>, <F12 as WorldQuery>::Item<'w>, <F13 as WorldQuery>::Item<'w>, <F14 as WorldQuery>::Item<'w>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State, <F14 as WorldQuery>::State)

fn shrink<'wlong, 'wshort>( item: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::Item<'wlong> ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::Fetch<'w>, _state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::Item<'w>

fn update_component_access( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state( world: &mut World ) -> <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::State>

fn matches_component_set( state: &<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<T> WorldQuery for Option<T>

where T: WorldQuery,

SAFETY: fetch might access any components that T accesses. This is sound because update_component_access and update_archetype_component_access add the same accesses as T. Filters are unchanged.

type Item<'w> = Option<<T as WorldQuery>::Item<'w>>

type Fetch<'w> = OptionFetch<'w, T>

type State = <T as WorldQuery>::State

fn shrink<'wlong, 'wshort>( item: <Option<T> as WorldQuery>::Item<'wlong> ) -> <Option<T> as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, state: &<T as WorldQuery>::State, last_run: Tick, this_run: Tick ) -> OptionFetch<'w, T>

const IS_DENSE: bool = T::IS_DENSE

unsafe fn set_archetype<'w>( fetch: &mut OptionFetch<'w, T>, state: &<T as WorldQuery>::State, archetype: &'w Archetype, table: &'w Table )

unsafe fn set_table<'w>( fetch: &mut OptionFetch<'w, T>, state: &<T as WorldQuery>::State, table: &'w Table )

unsafe fn fetch<'w>( fetch: &mut <Option<T> as WorldQuery>::Fetch<'w>, entity: Entity, table_row: TableRow ) -> <Option<T> as WorldQuery>::Item<'w>

fn update_component_access( state: &<T as WorldQuery>::State, access: &mut FilteredAccess<ComponentId> )

fn init_state(world: &mut World) -> <T as WorldQuery>::State

fn get_state( components: &Components ) -> Option<<Option<T> as WorldQuery>::State>

fn matches_component_set( _state: &<T as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<T> WorldQuery for &T

where T: Component,

SAFETY: fetch accesses a single component in a readonly way. This is sound because update_component_access and update_archetype_component_access add read access for that component and panic when appropriate. update_component_access adds a With filter for a component. This is sound because matches_component_set returns whether the set contains that component.

type Item<'w> = &'w T

type Fetch<'w> = ReadFetch<'w, T>

type State = ComponentId

fn shrink<'wlong, 'wshort>(item: &'wlong T) -> &'wshort T

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, _: &ComponentId, _last_run: Tick, _this_run: Tick ) -> ReadFetch<'w, T>

const IS_DENSE: bool = _

unsafe fn set_archetype<'w>( fetch: &mut ReadFetch<'w, T>, component_id: &ComponentId, _archetype: &'w Archetype, table: &'w Table )

unsafe fn set_table<'w>( fetch: &mut ReadFetch<'w, T>, _: &ComponentId, table: &'w Table )

unsafe fn fetch<'w>( fetch: &mut <&T as WorldQuery>::Fetch<'w>, entity: Entity, table_row: TableRow ) -> <&T as WorldQuery>::Item<'w>

fn update_component_access( _: &ComponentId, access: &mut FilteredAccess<ComponentId> )

fn init_state(world: &mut World) -> ComponentId

fn get_state(components: &Components) -> Option<<&T as WorldQuery>::State>

fn matches_component_set( _: &ComponentId, set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

impl<T> WorldQuery for PhantomData<T>

where T: ?Sized,

SAFETY: update_component_access and update_archetype_component_access do nothing. This is sound because fetch does not access components.

type Item<'a> = ()

type Fetch<'a> = ()

type State = ()

fn shrink<'wlong, 'wshort>( _item: <PhantomData<T> as WorldQuery>::Item<'wlong> ) -> <PhantomData<T> as WorldQuery>::Item<'wshort>

where 'wlong: 'wshort,

unsafe fn init_fetch<'w>( _world: UnsafeWorldCell<'w>, _state: &<PhantomData<T> as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <PhantomData<T> as WorldQuery>::Fetch<'w>

const IS_DENSE: bool = true

unsafe fn set_archetype<'w>( _fetch: &mut <PhantomData<T> as WorldQuery>::Fetch<'w>, _state: &<PhantomData<T> as WorldQuery>::State, _archetype: &'w Archetype, _table: &'w Table )

unsafe fn set_table<'w>( _fetch: &mut <PhantomData<T> as WorldQuery>::Fetch<'w>, _state: &<PhantomData<T> as WorldQuery>::State, _table: &'w Table )

unsafe fn fetch<'w>( _fetch: &mut <PhantomData<T> as WorldQuery>::Fetch<'w>, _entity: Entity, _table_row: TableRow ) -> <PhantomData<T> as WorldQuery>::Item<'w>

fn update_component_access( _state: &<PhantomData<T> as WorldQuery>::State, _access: &mut FilteredAccess<ComponentId> )

fn init_state(_world: &mut World) -> <PhantomData<T> as WorldQuery>::State

fn get_state( _components: &Components ) -> Option<<PhantomData<T> as WorldQuery>::State>

fn matches_component_set( _state: &<PhantomData<T> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool

Implementors

impl WorldQuery for &Archetype

SAFETY: update_component_access and update_archetype_component_access do nothing. This is sound because fetch does not access components.

type Item<'w> = &'w Archetype

type Fetch<'w> = (&'w Entities, &'w Archetypes)

type State = ()

const IS_DENSE: bool = true

impl WorldQuery for DebugName

type Item<'__w> = DebugNameItem<'__w>

type Fetch<'__w> = DebugNameFetch<'__w>

type State = DebugNameState

const IS_DENSE: bool = true

impl WorldQuery for NodeQuery

type Item<'__w> = NodeQueryItem<'__w>

type Fetch<'__w> = NodeQueryFetch<'__w>

type State = NodeQueryState

const IS_DENSE: bool = true

impl WorldQuery for NodeQueryReadOnly

type Item<'__w> = NodeQueryReadOnlyItem<'__w>

type Fetch<'__w> = NodeQueryReadOnlyFetch<'__w>

type State = NodeQueryState

const IS_DENSE: bool = true

impl WorldQuery for EntityLocation

SAFETY: update_component_access and update_archetype_component_access do nothing. This is sound because fetch does not access components.

type Item<'w> = EntityLocation

type Fetch<'w> = &'w Entities

type State = ()

const IS_DENSE: bool = true

impl WorldQuery for AnyOf<()>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ()

type Item<'w> = ()

type State = ()

const IS_DENSE: bool = true

impl WorldQuery for Entity

SAFETY: update_component_access and update_archetype_component_access do nothing. This is sound because fetch does not access components.

type Item<'w> = Entity

type Fetch<'w> = ()

type State = ()

const IS_DENSE: bool = true

impl WorldQuery for Or<()>

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ()

type Item<'w> = bool

type State = ()

const IS_DENSE: bool = true

impl<'__w, T> WorldQuery for Mut<'__w, T>

where T: Component,

When Mut<T> is used in a query, it will be converted to Ref<T> when transformed into its read-only form, providing access to change detection methods.

By contrast &mut T will result in a Mut<T> item in mutable form to record mutations, but result in a bare &T in read-only form.

SAFETY: fetch accesses a single component mutably. This is sound because update_component_access and update_archetype_component_access add write access for that component and panic when appropriate. update_component_access adds a With filter for a component. This is sound because matches_component_set returns whether the set contains that component.

type Item<'w> = Mut<'w, T>

type Fetch<'w> = WriteFetch<'w, T>

type State = ComponentId

const IS_DENSE: bool = <&mut T as WorldQuery>::IS_DENSE

impl<'__w, T> WorldQuery for Ref<'__w, T>

where T: Component,

SAFETY: fetch accesses a single component in a readonly way. This is sound because update_component_access and update_archetype_component_access add read access for that component and panic when appropriate. update_component_access adds a With filter for a component. This is sound because matches_component_set returns whether the set contains that component.

type Item<'w> = Ref<'w, T>

type Fetch<'w> = RefFetch<'w, T>

type State = ComponentId

const IS_DENSE: bool = _

impl<'a> WorldQuery for EntityMut<'a>

SAFETY: The accesses of Self::ReadOnly are a subset of the accesses of Self

type Item<'w> = EntityMut<'w>

type Fetch<'w> = UnsafeWorldCell<'w>

type State = ()

const IS_DENSE: bool = true

impl<'a> WorldQuery for EntityRef<'a>

SAFETY: fetch accesses all components in a readonly way. This is sound because update_component_access and update_archetype_component_access set read access for all components and panic when appropriate. Filters are unchanged.

type Item<'w> = EntityRef<'w>

type Fetch<'w> = UnsafeWorldCell<'w>

type State = ()

const IS_DENSE: bool = true

impl<'a> WorldQuery for FilteredEntityMut<'a>

SAFETY: The accesses of Self::ReadOnly are a subset of the accesses of Self

type Fetch<'w> = (UnsafeWorldCell<'w>, Access<ComponentId>)

type Item<'w> = FilteredEntityMut<'w>

type State = FilteredAccess<ComponentId>

const IS_DENSE: bool = false

impl<'a> WorldQuery for FilteredEntityRef<'a>

SAFETY: The accesses of Self::ReadOnly are a subset of the accesses of Self

type Fetch<'w> = (UnsafeWorldCell<'w>, Access<ComponentId>)

type Item<'w> = FilteredEntityRef<'w>

type State = FilteredAccess<ComponentId>

const IS_DENSE: bool = false

impl<F0> WorldQuery for AnyOf<(F0,)>

where F0: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool),)

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>,)

type State = (<F0 as WorldQuery>::State,)

const IS_DENSE: bool = _

impl<F0> WorldQuery for Or<(F0,)>

where F0: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>,)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State,)

const IS_DENSE: bool = _

impl<F0, F1> WorldQuery for AnyOf<(F0, F1)>

where F0: WorldQuery, F1: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1> WorldQuery for Or<(F0, F1)>

where F0: QueryFilter, F1: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2> WorldQuery for AnyOf<(F0, F1, F2)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2> WorldQuery for Or<(F0, F1, F2)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3> WorldQuery for AnyOf<(F0, F1, F2, F3)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3> WorldQuery for Or<(F0, F1, F2, F3)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4> WorldQuery for AnyOf<(F0, F1, F2, F3, F4)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4> WorldQuery for Or<(F0, F1, F2, F3, F4)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5> WorldQuery for Or<(F0, F1, F2, F3, F4, F5)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>, Option<<F10 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>, Option<<F10 as WorldQuery>::Item<'w>>, Option<<F11 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter, F11: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool), (<F12 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>, Option<<F10 as WorldQuery>::Item<'w>>, Option<<F11 as WorldQuery>::Item<'w>>, Option<<F12 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter, F11: QueryFilter, F12: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery, F13: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool), (<F12 as WorldQuery>::Fetch<'w>, bool), (<F13 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>, Option<<F10 as WorldQuery>::Item<'w>>, Option<<F11 as WorldQuery>::Item<'w>>, Option<<F12 as WorldQuery>::Item<'w>>, Option<<F13 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter, F11: QueryFilter, F12: QueryFilter, F13: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery, F12: WorldQuery, F13: WorldQuery, F14: WorldQuery,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access and update_archetype_component_access adds accesses according to the implementations of all the subqueries. update_component_access replaces the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = ((<F0 as WorldQuery>::Fetch<'w>, bool), (<F1 as WorldQuery>::Fetch<'w>, bool), (<F2 as WorldQuery>::Fetch<'w>, bool), (<F3 as WorldQuery>::Fetch<'w>, bool), (<F4 as WorldQuery>::Fetch<'w>, bool), (<F5 as WorldQuery>::Fetch<'w>, bool), (<F6 as WorldQuery>::Fetch<'w>, bool), (<F7 as WorldQuery>::Fetch<'w>, bool), (<F8 as WorldQuery>::Fetch<'w>, bool), (<F9 as WorldQuery>::Fetch<'w>, bool), (<F10 as WorldQuery>::Fetch<'w>, bool), (<F11 as WorldQuery>::Fetch<'w>, bool), (<F12 as WorldQuery>::Fetch<'w>, bool), (<F13 as WorldQuery>::Fetch<'w>, bool), (<F14 as WorldQuery>::Fetch<'w>, bool))

type Item<'w> = (Option<<F0 as WorldQuery>::Item<'w>>, Option<<F1 as WorldQuery>::Item<'w>>, Option<<F2 as WorldQuery>::Item<'w>>, Option<<F3 as WorldQuery>::Item<'w>>, Option<<F4 as WorldQuery>::Item<'w>>, Option<<F5 as WorldQuery>::Item<'w>>, Option<<F6 as WorldQuery>::Item<'w>>, Option<<F7 as WorldQuery>::Item<'w>>, Option<<F8 as WorldQuery>::Item<'w>>, Option<<F9 as WorldQuery>::Item<'w>>, Option<<F10 as WorldQuery>::Item<'w>>, Option<<F11 as WorldQuery>::Item<'w>>, Option<<F12 as WorldQuery>::Item<'w>>, Option<<F13 as WorldQuery>::Item<'w>>, Option<<F14 as WorldQuery>::Item<'w>>)

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State, <F14 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>

where F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter, F11: QueryFilter, F12: QueryFilter, F13: QueryFilter, F14: QueryFilter,

SAFETY: fetch accesses are a subset of the subqueries’ accesses This is sound because update_component_access adds accesses according to the implementations of all the subqueries. update_component_access replace the filters with a disjunction where every element is a conjunction of the previous filters and the filters of one of the subqueries. This is sound because matches_component_set returns a disjunction of the results of the subqueries’ implementations.

type Fetch<'w> = (OrFetch<'w, F0>, OrFetch<'w, F1>, OrFetch<'w, F2>, OrFetch<'w, F3>, OrFetch<'w, F4>, OrFetch<'w, F5>, OrFetch<'w, F6>, OrFetch<'w, F7>, OrFetch<'w, F8>, OrFetch<'w, F9>, OrFetch<'w, F10>, OrFetch<'w, F11>, OrFetch<'w, F12>, OrFetch<'w, F13>, OrFetch<'w, F14>)

type Item<'w> = bool

type State = (<F0 as WorldQuery>::State, <F1 as WorldQuery>::State, <F2 as WorldQuery>::State, <F3 as WorldQuery>::State, <F4 as WorldQuery>::State, <F5 as WorldQuery>::State, <F6 as WorldQuery>::State, <F7 as WorldQuery>::State, <F8 as WorldQuery>::State, <F9 as WorldQuery>::State, <F10 as WorldQuery>::State, <F11 as WorldQuery>::State, <F12 as WorldQuery>::State, <F13 as WorldQuery>::State, <F14 as WorldQuery>::State)

const IS_DENSE: bool = _

impl<T> WorldQuery for Added<T>

where T: Component,

SAFETY: fetch accesses a single component in a readonly way. This is sound because update_component_access adds read access for that component and panics when appropriate. update_component_access adds a With filter for a component. This is sound because matches_component_set returns whether the set contains that component.

type Item<'w> = bool

type Fetch<'w> = AddedFetch<'w>

type State = ComponentId

const IS_DENSE: bool = _

impl<T> WorldQuery for Changed<T>

where T: Component,

SAFETY: fetch accesses a single component in a readonly way. This is sound because update_component_access add read access for that component and panics when appropriate. update_component_access adds a With filter for a component. This is sound because matches_component_set returns whether the set contains that component.

type Item<'w> = bool

type Fetch<'w> = ChangedFetch<'w>

type State = ComponentId

const IS_DENSE: bool = _

impl<T> WorldQuery for Has<T>

where T: Component,

SAFETY: update_component_access and update_archetype_component_access do nothing. This is sound because fetch does not access components.

type Item<'w> = bool

type Fetch<'w> = bool

type State = ComponentId

const IS_DENSE: bool = _

impl<T> WorldQuery for With<T>

where T: Component,

SAFETY: update_component_access does not add any accesses. This is sound because fetch does not access any components. update_component_access adds a With filter for T. This is sound because matches_component_set returns whether the set contains the component.

type Item<'w> = ()

type Fetch<'w> = ()

type State = ComponentId

const IS_DENSE: bool = _

impl<T> WorldQuery for Without<T>

where T: Component,

SAFETY: update_component_access does not add any accesses. This is sound because fetch does not access any components. update_component_access adds a Without filter for T. This is sound because matches_component_set returns whether the set does not contain the component.

type Item<'w> = ()

type Fetch<'w> = ()

type State = ComponentId

const IS_DENSE: bool = _