Struct bevy_ecs::query::QueryState
source · #[repr(C)]pub struct QueryState<Q: WorldQuery, F: ReadOnlyWorldQuery = ()> { /* private fields */ }
Expand description
Provides scoped access to a World
state according to a given WorldQuery
and query filter.
Implementations§
source§impl<Q: WorldQuery, F: ReadOnlyWorldQuery> QueryState<Q, F>
impl<Q: WorldQuery, F: ReadOnlyWorldQuery> QueryState<Q, F>
sourcepub fn as_readonly(&self) -> &QueryState<Q::ReadOnly, F::ReadOnly>
pub fn as_readonly(&self) -> &QueryState<Q::ReadOnly, F::ReadOnly>
Converts this QueryState
reference to a QueryState
that does not access anything mutably.
sourcepub fn as_nop(&self) -> &QueryState<NopWorldQuery<Q>, F>
pub fn as_nop(&self) -> &QueryState<NopWorldQuery<Q>, F>
Converts this QueryState
reference to a QueryState
that does not return any data
which can be faster.
This doesn’t use NopWorldQuery
as it loses filter functionality, for example
NopWorldQuery<Changed<T>>
is functionally equivalent to With<T>
.
source§impl<Q: WorldQuery, F: ReadOnlyWorldQuery> QueryState<Q, F>
impl<Q: WorldQuery, F: ReadOnlyWorldQuery> QueryState<Q, F>
sourcepub fn new(world: &mut World) -> Self
pub fn new(world: &mut World) -> Self
Creates a new QueryState
from a given World
and inherits the result of world.id()
.
sourcepub fn is_empty(
&self,
world: &World,
last_change_tick: u32,
change_tick: u32
) -> bool
pub fn is_empty(
&self,
world: &World,
last_change_tick: u32,
change_tick: u32
) -> bool
Checks if the query is empty for the given World
, where the last change and current tick are given.
sourcepub fn update_archetypes(&mut self, world: &World)
pub fn update_archetypes(&mut self, world: &World)
Takes a query for the given World
, checks if the given world is the same as the query, and
generates new archetypes for the given world.
Panics
Panics if the world.id()
does not equal the current QueryState
internal id.
pub fn validate_world(&self, world: &World)
sourcepub fn new_archetype(&mut self, archetype: &Archetype)
pub fn new_archetype(&mut self, archetype: &Archetype)
Creates a new Archetype
.
sourcepub fn get<'w>(
&mut self,
world: &'w World,
entity: Entity
) -> Result<ROQueryItem<'w, Q>, QueryEntityError>
pub fn get<'w>(
&mut self,
world: &'w World,
entity: Entity
) -> Result<ROQueryItem<'w, Q>, QueryEntityError>
Gets the query result for the given World
and Entity
.
This can only be called for read-only queries, see Self::get_mut
for write-queries.
sourcepub fn get_many<'w, const N: usize>(
&mut self,
world: &'w World,
entities: [Entity; N]
) -> Result<[ROQueryItem<'w, Q>; N], QueryEntityError>
pub fn get_many<'w, const N: usize>(
&mut self,
world: &'w World,
entities: [Entity; N]
) -> Result<[ROQueryItem<'w, Q>; N], QueryEntityError>
Returns the read-only query results for the given array of Entity
.
In case of a nonexisting entity or mismatched component, a QueryEntityError
is
returned instead.
Note that the unlike QueryState::get_many_mut
, the entities passed in do not need to be unique.
Examples
use bevy_ecs::prelude::*;
use bevy_ecs::query::QueryEntityError;
#[derive(Component, PartialEq, Debug)]
struct A(usize);
let mut world = World::new();
let entity_vec: Vec<Entity> = (0..3).map(|i|world.spawn(A(i)).id()).collect();
let entities: [Entity; 3] = entity_vec.try_into().unwrap();
world.spawn(A(73));
let mut query_state = world.query::<&A>();
let component_values = query_state.get_many(&world, entities).unwrap();
assert_eq!(component_values, [&A(0), &A(1), &A(2)]);
let wrong_entity = Entity::from_raw(365);
assert_eq!(query_state.get_many(&world, [wrong_entity]), Err(QueryEntityError::NoSuchEntity(wrong_entity)));
sourcepub fn get_mut<'w>(
&mut self,
world: &'w mut World,
entity: Entity
) -> Result<Q::Item<'w>, QueryEntityError>
pub fn get_mut<'w>(
&mut self,
world: &'w mut World,
entity: Entity
) -> Result<Q::Item<'w>, QueryEntityError>
sourcepub fn get_many_mut<'w, const N: usize>(
&mut self,
world: &'w mut World,
entities: [Entity; N]
) -> Result<[Q::Item<'w>; N], QueryEntityError>
pub fn get_many_mut<'w, const N: usize>(
&mut self,
world: &'w mut World,
entities: [Entity; N]
) -> Result<[Q::Item<'w>; N], QueryEntityError>
Returns the query results for the given array of Entity
.
In case of a nonexisting entity or mismatched component, a QueryEntityError
is
returned instead.
use bevy_ecs::prelude::*;
use bevy_ecs::query::QueryEntityError;
#[derive(Component, PartialEq, Debug)]
struct A(usize);
let mut world = World::new();
let entities: Vec<Entity> = (0..3).map(|i|world.spawn(A(i)).id()).collect();
let entities: [Entity; 3] = entities.try_into().unwrap();
world.spawn(A(73));
let mut query_state = world.query::<&mut A>();
let mut mutable_component_values = query_state.get_many_mut(&mut world, entities).unwrap();
for mut a in &mut mutable_component_values {
a.0 += 5;
}
let component_values = query_state.get_many(&world, entities).unwrap();
assert_eq!(component_values, [&A(5), &A(6), &A(7)]);
let wrong_entity = Entity::from_raw(57);
let invalid_entity = world.spawn_empty().id();
assert_eq!(query_state.get_many_mut(&mut world, [wrong_entity]).unwrap_err(), QueryEntityError::NoSuchEntity(wrong_entity));
assert_eq!(query_state.get_many_mut(&mut world, [invalid_entity]).unwrap_err(), QueryEntityError::QueryDoesNotMatch(invalid_entity));
assert_eq!(query_state.get_many_mut(&mut world, [entities[0], entities[0]]).unwrap_err(), QueryEntityError::AliasedMutability(entities[0]));
pub fn get_manual<'w>(
&self,
world: &'w World,
entity: Entity
) -> Result<ROQueryItem<'w, Q>, QueryEntityError>
sourcepub unsafe fn get_unchecked<'w>(
&mut self,
world: &'w World,
entity: Entity
) -> Result<Q::Item<'w>, QueryEntityError>
pub unsafe fn get_unchecked<'w>(
&mut self,
world: &'w World,
entity: Entity
) -> Result<Q::Item<'w>, QueryEntityError>
sourcepub fn iter<'w, 's>(
&'s mut self,
world: &'w World
) -> QueryIter<'w, 's, Q::ReadOnly, F::ReadOnly> ⓘ
pub fn iter<'w, 's>(
&'s mut self,
world: &'w World
) -> QueryIter<'w, 's, Q::ReadOnly, F::ReadOnly> ⓘ
Returns an Iterator
over the query results for the given World
.
This can only be called for read-only queries, see Self::iter_mut
for write-queries.
sourcepub fn iter_manual<'w, 's>(
&'s self,
world: &'w World
) -> QueryIter<'w, 's, Q::ReadOnly, F::ReadOnly> ⓘ
pub fn iter_manual<'w, 's>(
&'s self,
world: &'w World
) -> QueryIter<'w, 's, Q::ReadOnly, F::ReadOnly> ⓘ
Returns an Iterator
over the query results for the given World
without updating the query’s archetypes.
Archetypes must be manually updated before by using Self::update_archetypes
.
This can only be called for read-only queries.
sourcepub fn iter_combinations<'w, 's, const K: usize>(
&'s mut self,
world: &'w World
) -> QueryCombinationIter<'w, 's, Q::ReadOnly, F::ReadOnly, K> ⓘ
pub fn iter_combinations<'w, 's, const K: usize>(
&'s mut self,
world: &'w World
) -> QueryCombinationIter<'w, 's, Q::ReadOnly, F::ReadOnly, K> ⓘ
Returns an Iterator
over all possible combinations of K
query results without repetition.
This can only be called for read-only queries.
A combination is an arrangement of a collection of items where order does not matter.
K
is the number of items that make up each subset, and the number of items returned by the iterator.
N
is the number of total entities output by query.
For example, given the list [1, 2, 3, 4], where K
is 2, the combinations without repeats are
[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4].
And in this case, N
would be defined as 4 since the size of the input list is 4.
For combinations of size K
of query taking N
inputs, you will get:
- if
K == N
: one combination of all query results - if
K < N
: all possibleK
-sized combinations of query results, without repetition - if
K > N
: empty set (noK
-sized combinations exist)
The iter_combinations
method does not guarantee order of iteration.
This can only be called for read-only queries, see Self::iter_combinations_mut
for
write-queries.
sourcepub fn iter_combinations_mut<'w, 's, const K: usize>(
&'s mut self,
world: &'w mut World
) -> QueryCombinationIter<'w, 's, Q, F, K> ⓘ
pub fn iter_combinations_mut<'w, 's, const K: usize>(
&'s mut self,
world: &'w mut World
) -> QueryCombinationIter<'w, 's, Q, F, K> ⓘ
Returns an Iterator
over all possible combinations of K
query results without repetition.
A combination is an arrangement of a collection of items where order does not matter.
K
is the number of items that make up each subset, and the number of items returned by the iterator.
N
is the number of total entities output by query.
For example, given the list [1, 2, 3, 4], where K
is 2, the combinations without repeats are
[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4].
And in this case, N
would be defined as 4 since the size of the input list is 4.
For combinations of size K
of query taking N
inputs, you will get:
- if
K == N
: one combination of all query results - if
K < N
: all possibleK
-sized combinations of query results, without repetition - if
K > N
: empty set (noK
-sized combinations exist)
The iter_combinations_mut
method does not guarantee order of iteration.
sourcepub fn iter_many<'w, 's, EntityList: IntoIterator>(
&'s mut self,
world: &'w World,
entities: EntityList
) -> QueryManyIter<'w, 's, Q::ReadOnly, F::ReadOnly, EntityList::IntoIter> ⓘwhere
EntityList::Item: Borrow<Entity>,
pub fn iter_many<'w, 's, EntityList: IntoIterator>(
&'s mut self,
world: &'w World,
entities: EntityList
) -> QueryManyIter<'w, 's, Q::ReadOnly, F::ReadOnly, EntityList::IntoIter> ⓘwhere
EntityList::Item: Borrow<Entity>,
Returns an Iterator
over the read-only query items generated from an Entity
list.
Items are returned in the order of the list of entities. Entities that don’t match the query are skipped.
See also
iter_many_mut
to get mutable query items.
sourcepub fn iter_many_mut<'w, 's, EntityList: IntoIterator>(
&'s mut self,
world: &'w mut World,
entities: EntityList
) -> QueryManyIter<'w, 's, Q, F, EntityList::IntoIter> ⓘwhere
EntityList::Item: Borrow<Entity>,
pub fn iter_many_mut<'w, 's, EntityList: IntoIterator>(
&'s mut self,
world: &'w mut World,
entities: EntityList
) -> QueryManyIter<'w, 's, Q, F, EntityList::IntoIter> ⓘwhere
EntityList::Item: Borrow<Entity>,
Returns an iterator over the query items generated from an Entity
list.
Items are returned in the order of the list of entities. Entities that don’t match the query are skipped.
sourcepub unsafe fn iter_unchecked<'w, 's>(
&'s mut self,
world: &'w World
) -> QueryIter<'w, 's, Q, F> ⓘ
pub unsafe fn iter_unchecked<'w, 's>(
&'s mut self,
world: &'w World
) -> QueryIter<'w, 's, Q, F> ⓘ
sourcepub unsafe fn iter_combinations_unchecked<'w, 's, const K: usize>(
&'s mut self,
world: &'w World
) -> QueryCombinationIter<'w, 's, Q, F, K> ⓘ
pub unsafe fn iter_combinations_unchecked<'w, 's, const K: usize>(
&'s mut self,
world: &'w World
) -> QueryCombinationIter<'w, 's, Q, F, K> ⓘ
Returns an Iterator
over all possible combinations of K
query results for the
given World
without repetition.
This can only be called for read-only queries.
Safety
This does not check for mutable query correctness. To be safe, make sure mutable queries have unique access to the components they query.
sourcepub fn for_each<'w, FN: FnMut(ROQueryItem<'w, Q>)>(
&mut self,
world: &'w World,
func: FN
)
pub fn for_each<'w, FN: FnMut(ROQueryItem<'w, Q>)>(
&mut self,
world: &'w World,
func: FN
)
Runs func
on each query result for the given World
. This is faster than the equivalent
iter() method, but cannot be chained like a normal Iterator
.
This can only be called for read-only queries, see Self::for_each_mut
for write-queries.
sourcepub fn for_each_mut<'w, FN: FnMut(Q::Item<'w>)>(
&mut self,
world: &'w mut World,
func: FN
)
pub fn for_each_mut<'w, FN: FnMut(Q::Item<'w>)>(
&mut self,
world: &'w mut World,
func: FN
)
sourcepub unsafe fn for_each_unchecked<'w, FN: FnMut(Q::Item<'w>)>(
&mut self,
world: &'w World,
func: FN
)
pub unsafe fn for_each_unchecked<'w, FN: FnMut(Q::Item<'w>)>(
&mut self,
world: &'w World,
func: FN
)
Runs func
on each query result for the given World
. This is faster than the equivalent
iter() method, but cannot be chained like a normal Iterator
.
This can only be called for read-only queries.
Safety
This does not check for mutable query correctness. To be safe, make sure mutable queries have unique access to the components they query.
sourcepub fn par_for_each<'w, FN: Fn(ROQueryItem<'w, Q>) + Send + Sync + Clone>(
&mut self,
world: &'w World,
batch_size: usize,
func: FN
)
pub fn par_for_each<'w, FN: Fn(ROQueryItem<'w, Q>) + Send + Sync + Clone>(
&mut self,
world: &'w World,
batch_size: usize,
func: FN
)
Runs func
on each query result in parallel.
This can only be called for read-only queries, see Self::par_for_each_mut
for
write-queries.
Panics
The ComputeTaskPool
is not initialized. If using this from a query that is being
initialized and run from the ECS scheduler, this should never panic.
sourcepub fn par_for_each_mut<'w, FN: Fn(Q::Item<'w>) + Send + Sync + Clone>(
&mut self,
world: &'w mut World,
batch_size: usize,
func: FN
)
pub fn par_for_each_mut<'w, FN: Fn(Q::Item<'w>) + Send + Sync + Clone>(
&mut self,
world: &'w mut World,
batch_size: usize,
func: FN
)
Runs func
on each query result in parallel.
Panics
The ComputeTaskPool
is not initialized. If using this from a query that is being
initialized and run from the ECS scheduler, this should never panic.
sourcepub unsafe fn par_for_each_unchecked<'w, FN: Fn(Q::Item<'w>) + Send + Sync + Clone>(
&mut self,
world: &'w World,
batch_size: usize,
func: FN
)
pub unsafe fn par_for_each_unchecked<'w, FN: Fn(Q::Item<'w>) + Send + Sync + Clone>(
&mut self,
world: &'w World,
batch_size: usize,
func: FN
)
Runs func
on each query result in parallel.
This can only be called for read-only queries.
Panics
The ComputeTaskPool
is not initialized. If using this from a query that is being
initialized and run from the ECS scheduler, this should never panic.
Safety
This does not check for mutable query correctness. To be safe, make sure mutable queries have unique access to the components they query.
sourcepub fn single<'w>(&mut self, world: &'w World) -> ROQueryItem<'w, Q>
pub fn single<'w>(&mut self, world: &'w World) -> ROQueryItem<'w, Q>
Returns a single immutable query result when there is exactly one entity matching the query.
This can only be called for read-only queries,
see single_mut
for write-queries.
Panics
Panics if the number of query results is not exactly one. Use
get_single
to return a Result
instead of panicking.
sourcepub fn get_single<'w>(
&mut self,
world: &'w World
) -> Result<ROQueryItem<'w, Q>, QuerySingleError>
pub fn get_single<'w>(
&mut self,
world: &'w World
) -> Result<ROQueryItem<'w, Q>, QuerySingleError>
Returns a single immutable query result when there is exactly one entity matching the query.
This can only be called for read-only queries,
see get_single_mut
for write-queries.
If the number of query results is not exactly one, a QuerySingleError
is returned
instead.
sourcepub fn single_mut<'w>(&mut self, world: &'w mut World) -> Q::Item<'w>
pub fn single_mut<'w>(&mut self, world: &'w mut World) -> Q::Item<'w>
Returns a single mutable query result when there is exactly one entity matching the query.
Panics
Panics if the number of query results is not exactly one. Use
get_single_mut
to return a Result
instead of panicking.
sourcepub fn get_single_mut<'w>(
&mut self,
world: &'w mut World
) -> Result<Q::Item<'w>, QuerySingleError>
pub fn get_single_mut<'w>(
&mut self,
world: &'w mut World
) -> Result<Q::Item<'w>, QuerySingleError>
Returns a single mutable query result when there is exactly one entity matching the query.
If the number of query results is not exactly one, a QuerySingleError
is returned
instead.
sourcepub unsafe fn get_single_unchecked<'w>(
&mut self,
world: &'w World
) -> Result<Q::Item<'w>, QuerySingleError>
pub unsafe fn get_single_unchecked<'w>(
&mut self,
world: &'w World
) -> Result<Q::Item<'w>, QuerySingleError>
Returns a query result when there is exactly one entity matching the query.
If the number of query results is not exactly one, a QuerySingleError
is returned
instead.
Safety
This does not check for mutable query correctness. To be safe, make sure mutable queries have unique access to the components they query.
sourcepub unsafe fn get_single_unchecked_manual<'w>(
&self,
world: &'w World,
last_change_tick: u32,
change_tick: u32
) -> Result<Q::Item<'w>, QuerySingleError>
pub unsafe fn get_single_unchecked_manual<'w>(
&self,
world: &'w World,
last_change_tick: u32,
change_tick: u32
) -> Result<Q::Item<'w>, QuerySingleError>
Returns a query result when there is exactly one entity matching the query, where the last change and the current change tick are given.
If the number of query results is not exactly one, a QuerySingleError
is returned
instead.
Safety
This does not check for mutable query correctness. To be safe, make sure mutable queries have unique access to the components they query.
Trait Implementations§
source§impl<Q: WorldQuery, F: ReadOnlyWorldQuery> Debug for QueryState<Q, F>
impl<Q: WorldQuery, F: ReadOnlyWorldQuery> Debug for QueryState<Q, F>
source§impl<'a, Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> ExclusiveSystemParam for &'a mut QueryState<Q, F>
impl<'a, Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> ExclusiveSystemParam for &'a mut QueryState<Q, F>
type Fetch = QueryState<Q, F>
source§impl<'s, Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> ExclusiveSystemParamFetch<'s> for QueryState<Q, F>
impl<'s, Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> ExclusiveSystemParamFetch<'s> for QueryState<Q, F>
type Item = &'s mut QueryState<Q, F>
fn get_param(state: &'s mut Self, _system_meta: &SystemMeta) -> Self::Item
source§impl<Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> ExclusiveSystemParamState for QueryState<Q, F>
impl<Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> ExclusiveSystemParamState for QueryState<Q, F>
source§impl<Q: WorldQuery, F: ReadOnlyWorldQuery> FromWorld for QueryState<Q, F>
impl<Q: WorldQuery, F: ReadOnlyWorldQuery> FromWorld for QueryState<Q, F>
source§fn from_world(world: &mut World) -> Self
fn from_world(world: &mut World) -> Self
Self
using data from the given Worldsource§impl<'w, 's, Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> SystemParamFetch<'w, 's> for QueryState<Q, F>
impl<'w, 's, Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> SystemParamFetch<'w, 's> for QueryState<Q, F>
source§impl<Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> SystemParamState for QueryState<Q, F>
impl<Q: WorldQuery + 'static, F: ReadOnlyWorldQuery + 'static> SystemParamState for QueryState<Q, F>
fn init(world: &mut World, system_meta: &mut SystemMeta) -> Self
fn new_archetype(&mut self, archetype: &Archetype, system_meta: &mut SystemMeta)
fn apply(&mut self, _world: &mut World)
impl<Q: ReadOnlyWorldQuery, F: ReadOnlyWorldQuery> ReadOnlySystemParamFetch for QueryState<Q, F>
Auto Trait Implementations§
impl<Q, F> RefUnwindSafe for QueryState<Q, F>where
<F as WorldQuery>::State: RefUnwindSafe,
<Q as WorldQuery>::State: RefUnwindSafe,
impl<Q, F> Send for QueryState<Q, F>
impl<Q, F> Sync for QueryState<Q, F>
impl<Q, F> Unpin for QueryState<Q, F>where
<F as WorldQuery>::State: Unpin,
<Q as WorldQuery>::State: Unpin,
impl<Q, F> UnwindSafe for QueryState<Q, F>where
<F as WorldQuery>::State: UnwindSafe,
<Q as WorldQuery>::State: UnwindSafe,
Blanket Implementations§
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read moresource§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read moresource§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read moresource§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more