pub unsafe trait WorldQuery {
type Item<'a>;
type Fetch<'a>: Clone;
type State: Send + Sync + Sized;
const IS_DENSE: bool;
// Required methods
fn shrink<'wlong: 'wshort, 'wshort>(
item: Self::Item<'wlong>,
) -> Self::Item<'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>,
) { ... }
}
Expand description
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 aWithout
filter for a component unlessmatches_component_set
always returnsfalse
when the component set contains that component.update_component_access
may not add aWith
filter for a component unlessmatches_component_set
always returnsfalse
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 validWorldQuery
, the following rules must be obeyed:matches_component_set
must be a disjunction of the element’s implementationsupdate_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 Constants§
Sourceconst IS_DENSE: bool
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 Associated Types§
Sourcetype Item<'a>
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.
Sourcetype Fetch<'a>: Clone
type Fetch<'a>: Clone
Per archetype/table state used by this WorldQuery
to fetch Self::Item
Sourcetype State: Send + Sync + Sized
type State: Send + Sync + Sized
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 Methods§
Sourcefn shrink<'wlong: 'wshort, 'wshort>(
item: Self::Item<'wlong>,
) -> Self::Item<'wshort>
fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>
This function manually implements subtyping for the query items.
Sourceunsafe fn init_fetch<'w>(
world: UnsafeWorldCell<'w>,
state: &Self::State,
last_run: Tick,
this_run: Tick,
) -> Self::Fetch<'w>
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 (viaWorldQuery::init_state
) using the sameworld
passed in to this function.
Sourceunsafe fn set_archetype<'w>(
fetch: &mut Self::Fetch<'w>,
state: &Self::State,
archetype: &'w Archetype,
table: &'w Table,
)
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
andtables
must be from the sameWorld
thatWorldQuery::init_state
was called on.table
must correspond toarchetype
.state
must be theState
thatfetch
was initialized with.
Sourceunsafe fn set_table<'w>(
fetch: &mut Self::Fetch<'w>,
state: &Self::State,
table: &'w Table,
)
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 sameWorld
thatWorldQuery::init_state
was called on.state
must be theState
thatfetch
was initialized with.
Sourceunsafe fn fetch<'w>(
fetch: &mut Self::Fetch<'w>,
entity: Entity,
table_row: TableRow,
) -> Self::Item<'w>
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.
Sourcefn update_component_access(
state: &Self::State,
access: &mut FilteredAccess<ComponentId>,
)
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
Sourcefn init_state(world: &mut World) -> Self::State
fn init_state(world: &mut World) -> Self::State
Creates and initializes a State
for this WorldQuery
type.
Sourcefn get_state(components: &Components) -> Option<Self::State>
fn get_state(components: &Components) -> Option<Self::State>
Attempts to initialize a State
for this WorldQuery
type using read-only
access to Components
.
Sourcefn matches_component_set(
state: &Self::State,
set_contains_id: &impl Fn(ComponentId) -> bool,
) -> bool
fn matches_component_set( state: &Self::State, set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool
Provided Methods§
Sourcefn set_access(_state: &mut Self::State, _access: &FilteredAccess<ComponentId>)
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
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.
Implementations on Foreign Types§
Source§impl WorldQuery for ()
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
.
const IS_DENSE: bool = true
type Fetch<'w> = ()
type Item<'w> = ()
type State = ()
fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<'__w, T: Component> WorldQuery for &'__w mut T
impl<'__w, T: Component> WorldQuery for &'__w mut T
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.
const IS_DENSE: bool = _
type Item<'w> = Mut<'w, T>
type Fetch<'w> = WriteFetch<'w, T>
type State = ComponentId
fn shrink<'wlong: 'wshort, 'wshort>(item: Mut<'wlong, T>) -> Mut<'wshort, T>
unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, component_id: &ComponentId, last_run: Tick, this_run: Tick, ) -> WriteFetch<'w, T>
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>, component_id: &ComponentId, table: &'w Table, )
unsafe fn fetch<'w>( fetch: &mut Self::Fetch<'w>, entity: Entity, table_row: TableRow, ) -> Self::Item<'w>
fn update_component_access( component_id: &ComponentId, access: &mut FilteredAccess<ComponentId>, )
fn init_state(world: &mut World) -> ComponentId
fn get_state(components: &Components) -> Option<Self::State>
fn matches_component_set( state: &ComponentId, set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool
Source§impl<F0: WorldQuery> WorldQuery for (F0,)
impl<F0: WorldQuery> WorldQuery for (F0,)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery> WorldQuery for (F0, F1)
impl<F0: WorldQuery, F1: WorldQuery> WorldQuery for (F0, F1)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery> WorldQuery for (F0, F1, F2)
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery> WorldQuery for (F0, F1, F2)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery> WorldQuery for (F0, F1, F2, F3)
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery> WorldQuery for (F0, F1, F2, F3)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4)
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5)
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6)
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7)
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8)
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<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> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
impl<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> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<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> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
impl<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> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<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> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
impl<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> WorldQuery for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
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
.
const IS_DENSE: bool = _
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'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
Source§impl<T: Component> WorldQuery for &T
impl<T: Component> WorldQuery for &T
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.
const IS_DENSE: bool = _
type Item<'w> = &'w T
type Fetch<'w> = ReadFetch<'w, T>
type State = ComponentId
fn shrink<'wlong: 'wshort, 'wshort>(item: &'wlong T) -> &'wshort T
unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, component_id: &ComponentId, _last_run: Tick, _this_run: Tick, ) -> ReadFetch<'w, T>
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>, component_id: &ComponentId, table: &'w Table, )
unsafe fn fetch<'w>( fetch: &mut Self::Fetch<'w>, entity: Entity, table_row: TableRow, ) -> Self::Item<'w>
fn update_component_access( component_id: &ComponentId, access: &mut FilteredAccess<ComponentId>, )
fn init_state(world: &mut World) -> ComponentId
fn get_state(components: &Components) -> Option<Self::State>
fn matches_component_set( state: &ComponentId, set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool
Source§impl<T: WorldQuery> WorldQuery for Option<T>
impl<T: WorldQuery> WorldQuery for Option<T>
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.
const IS_DENSE: bool = T::IS_DENSE
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, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>
unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, state: &T::State, last_run: Tick, this_run: Tick, ) -> OptionFetch<'w, T>
unsafe fn set_archetype<'w>( fetch: &mut OptionFetch<'w, T>, state: &T::State, archetype: &'w Archetype, table: &'w Table, )
unsafe fn set_table<'w>( fetch: &mut OptionFetch<'w, T>, state: &T::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: &T::State, access: &mut FilteredAccess<ComponentId>, )
fn init_state(world: &mut World) -> T::State
fn get_state(components: &Components) -> Option<Self::State>
fn matches_component_set( _state: &T::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool
Source§impl<T: ?Sized> WorldQuery for PhantomData<T>
impl<T: ?Sized> WorldQuery for PhantomData<T>
SAFETY:
update_component_access
and update_archetype_component_access
do nothing.
This is sound because fetch
does not access components.
const IS_DENSE: bool = true
type Item<'a> = ()
type Fetch<'a> = ()
type State = ()
fn shrink<'wlong: 'wshort, 'wshort>( _item: Self::Item<'wlong>, ) -> Self::Item<'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
Implementors§
Source§impl WorldQuery for &Archetype
impl WorldQuery for &Archetype
SAFETY:
update_component_access
and update_archetype_component_access
do nothing.
This is sound because fetch
does not access components.
Source§impl WorldQuery for Entity
impl WorldQuery for Entity
SAFETY:
update_component_access
and update_archetype_component_access
do nothing.
This is sound because fetch
does not access components.
Source§impl WorldQuery for EntityLocation
impl WorldQuery for EntityLocation
SAFETY:
update_component_access
and update_archetype_component_access
do nothing.
This is sound because fetch
does not access components.
Source§impl WorldQuery for AnyOf<()>
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.
Source§impl WorldQuery for Or<()>
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.
Source§impl<'__w, T: Component> WorldQuery for Mut<'__w, T>
impl<'__w, T: Component> WorldQuery for Mut<'__w, T>
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.
Source§impl<'__w, T: Component> WorldQuery for Ref<'__w, T>
impl<'__w, T: Component> WorldQuery for Ref<'__w, T>
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.
Source§impl<'a> WorldQuery for EntityMut<'a>
impl<'a> WorldQuery for EntityMut<'a>
SAFETY: The accesses of Self::ReadOnly
are a subset of the accesses of Self
Source§impl<'a> WorldQuery for EntityRef<'a>
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.
Source§impl<'a> WorldQuery for FilteredEntityMut<'a>
impl<'a> WorldQuery for FilteredEntityMut<'a>
SAFETY: The accesses of Self::ReadOnly
are a subset of the accesses of Self
const IS_DENSE: bool = false
type Fetch<'w> = (UnsafeWorldCell<'w>, Access<ComponentId>)
type Item<'w> = FilteredEntityMut<'w>
type State = FilteredAccess<ComponentId>
Source§impl<'a> WorldQuery for FilteredEntityRef<'a>
impl<'a> WorldQuery for FilteredEntityRef<'a>
SAFETY: The accesses of Self::ReadOnly
are a subset of the accesses of Self
const IS_DENSE: bool = false
type Fetch<'w> = (UnsafeWorldCell<'w>, Access<ComponentId>)
type Item<'w> = FilteredEntityRef<'w>
type State = FilteredAccess<ComponentId>
Source§impl<F0: QueryFilter> WorldQuery for Or<(F0,)>
impl<F0: QueryFilter> WorldQuery for Or<(F0,)>
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.
Source§impl<F0: QueryFilter, F1: QueryFilter> WorldQuery for Or<(F0, F1)>
impl<F0: QueryFilter, F1: QueryFilter> WorldQuery for Or<(F0, F1)>
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.
Source§impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter> WorldQuery for Or<(F0, F1, F2)>
impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter> WorldQuery for Or<(F0, F1, F2)>
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.
Source§impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3)>
impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3)>
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.
Source§impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4)>
impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5)>
impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6)>
impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7)>
impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>
impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>
impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>
impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter, F11: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>
impl<F0: QueryFilter, F1: QueryFilter, F2: QueryFilter, F3: QueryFilter, F4: QueryFilter, F5: QueryFilter, F6: QueryFilter, F7: QueryFilter, F8: QueryFilter, F9: QueryFilter, F10: QueryFilter, F11: QueryFilter> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>
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.
const IS_DENSE: bool = _
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)
Source§impl<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> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>
impl<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> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>
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.
const IS_DENSE: bool = _
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)
Source§impl<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> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>
impl<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> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>
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.
const IS_DENSE: bool = _
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)
Source§impl<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> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>
impl<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> WorldQuery for Or<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery> WorldQuery for AnyOf<(F0,)>
impl<F0: WorldQuery> WorldQuery for AnyOf<(F0,)>
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.
Source§impl<F0: WorldQuery, F1: WorldQuery> WorldQuery for AnyOf<(F0, F1)>
impl<F0: WorldQuery, F1: WorldQuery> WorldQuery for AnyOf<(F0, F1)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2)>
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3)>
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4)>
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5)>
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)>
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.
const IS_DENSE: bool = _
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)
Source§impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>
impl<F0: WorldQuery, F1: WorldQuery, F2: WorldQuery, F3: WorldQuery, F4: WorldQuery, F5: WorldQuery, F6: WorldQuery, F7: WorldQuery, F8: WorldQuery, F9: WorldQuery, F10: WorldQuery, F11: WorldQuery> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)>
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.
const IS_DENSE: bool = _
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)
Source§impl<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> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>
impl<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> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)>
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.
const IS_DENSE: bool = _
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)
Source§impl<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> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>
impl<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> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)>
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.
const IS_DENSE: bool = _
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)
Source§impl<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> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>
impl<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> WorldQuery for AnyOf<(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)>
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.
const IS_DENSE: bool = _
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)
Source§impl<T: Component> WorldQuery for Added<T>
impl<T: Component> WorldQuery for Added<T>
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.
Source§impl<T: Component> WorldQuery for Changed<T>
impl<T: Component> WorldQuery for Changed<T>
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.
Source§impl<T: Component> WorldQuery for Has<T>
impl<T: Component> WorldQuery for Has<T>
SAFETY:
update_component_access
and update_archetype_component_access
do nothing.
This is sound because fetch
does not access components.
Source§impl<T: Component> WorldQuery for With<T>
impl<T: Component> WorldQuery for With<T>
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.
Source§impl<T: Component> WorldQuery for Without<T>
impl<T: Component> WorldQuery for Without<T>
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.