pub struct QueryIter<'w, 's, D: QueryData, F: QueryFilter> { /* private fields */ }
Expand description
An Iterator
over query results of a Query
.
This struct is created by the Query::iter
and
Query::iter_mut
methods.
Implementations§
source§impl<'w, 's, D: QueryData, F: QueryFilter> QueryIter<'w, 's, D, F>
impl<'w, 's, D: QueryData, F: QueryFilter> QueryIter<'w, 's, D, F>
sourcepub fn sort<L: ReadOnlyQueryData + 'w>(
self
) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘ
pub fn sort<L: ReadOnlyQueryData + 'w>( self ) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘ
Sorts all query items into a new iterator, using the query lens as a key.
This sort is stable (i.e., does not reorder equal elements).
This uses slice::sort
internally.
Defining the lens works like transmute_lens
.
This includes the allowed parameter type changes listed under allowed transmutes.
However, the lens uses the filter of the original query when present.
The sort is not cached across system runs.
§Panics
This will panic if next
has been called on QueryIter
before, unless the underlying Query
is empty.
§Examples
// We can ensure that a query always returns in the same order.
fn system_1(query: Query<(Entity, &PartIndex)>) {
let parts: Vec<(Entity, &PartIndex)> = query.iter().sort::<&PartIndex>().collect();
}
// We can freely rearrange query components in the key.
fn system_2(query: Query<(&Length, &Width, &Height), With<PartMarker>>) {
for (length, width, height) in query.iter().sort::<(&Height, &Length, &Width)>() {
println!("height: {height:?}, width: {width:?}, length: {length:?}")
}
}
// We can sort by Entity without including it in the original Query.
// Here, we match iteration orders between query iterators.
fn system_3(
part_query: Query<(&PartValue, &ParentEntity)>,
mut parent_query: Query<(&ChildPartCount, &mut ParentValue)>,
) {
let part_values = &mut part_query
.into_iter()
.sort::<&ParentEntity>()
.map(|(&value, parent_entity)| *value);
for (&child_count, mut parent_value) in parent_query.iter_mut().sort::<Entity>() {
**parent_value = part_values.take(*child_count).sum();
}
}
sourcepub fn sort_unstable<L: ReadOnlyQueryData + 'w>(
self
) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘ
pub fn sort_unstable<L: ReadOnlyQueryData + 'w>( self ) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘ
Sorts all query items into a new iterator, using the query lens as a key.
This sort is unstable (i.e., may reorder equal elements).
This uses slice::sort_unstable
internally.
Defining the lens works like transmute_lens
.
This includes the allowed parameter type changes listed under allowed transmutes..
However, the lens uses the filter of the original query when present.
The sort is not cached across system runs.
§Panics
This will panic if next
has been called on QueryIter
before, unless the underlying Query
is empty.
§Example
#[derive(Component, PartialEq, Eq, PartialOrd, Ord)]
enum Flying {
Enabled,
Disabled
};
// We perform an unstable sort by a Component with few values.
fn system_1(query: Query<&Flying, With<PartMarker>>) {
let part_values: Vec<&Flying> = query.iter().sort_unstable::<&Flying>().collect();
}
sourcepub fn sort_by<L: ReadOnlyQueryData + 'w>(
self,
compare: impl FnMut(&L::Item<'w>, &L::Item<'w>) -> Ordering
) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘ
pub fn sort_by<L: ReadOnlyQueryData + 'w>( self, compare: impl FnMut(&L::Item<'w>, &L::Item<'w>) -> Ordering ) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘ
Sorts all query items into a new iterator with a comparator function over the query lens.
This sort is stable (i.e., does not reorder equal elements).
This uses slice::sort_by
internally.
Defining the lens works like transmute_lens
.
This includes the allowed parameter type changes listed under allowed transmutes.
However, the lens uses the filter of the original query when present.
The sort is not cached across system runs.
§Panics
This will panic if next
has been called on QueryIter
before, unless the underlying Query
is empty.
§Example
#[derive(Component)]
struct PartValue(f32);
// We can use a cmp function on components do not implement Ord.
fn system_1(query: Query<&PartValue>) {
// Sort part values according to `f32::total_comp`.
let part_values: Vec<&PartValue> = query
.iter()
.sort_by::<&PartValue>(|value_1, value_2| value_1.total_cmp(*value_2))
.collect();
}
sourcepub fn sort_unstable_by<L: ReadOnlyQueryData + 'w>(
self,
compare: impl FnMut(&L::Item<'w>, &L::Item<'w>) -> Ordering
) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘ
pub fn sort_unstable_by<L: ReadOnlyQueryData + 'w>( self, compare: impl FnMut(&L::Item<'w>, &L::Item<'w>) -> Ordering ) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘ
Sorts all query items into a new iterator with a comparator function over the query lens.
This sort is unstable (i.e., may reorder equal elements).
This uses slice::sort_unstable_by
internally.
Defining the lens works like transmute_lens
.
This includes the allowed parameter type changes listed under allowed transmutes.
However, the lens uses the filter of the original query when present.
The sort is not cached across system runs.
§Panics
This will panic if next
has been called on QueryIter
before, unless the underlying Query
is empty.
sourcepub fn sort_by_key<L: ReadOnlyQueryData + 'w, K>(
self,
f: impl FnMut(&L::Item<'w>) -> K
) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘwhere
K: Ord,
pub fn sort_by_key<L: ReadOnlyQueryData + 'w, K>(
self,
f: impl FnMut(&L::Item<'w>) -> K
) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘwhere
K: Ord,
Sorts all query items into a new iterator with a key extraction function over the query lens.
This sort is stable (i.e., does not reorder equal elements).
This uses slice::sort_by_key
internally.
Defining the lens works like transmute_lens
.
This includes the allowed parameter type changes listed under allowed transmutes.
However, the lens uses the filter of the original query when present.
The sort is not cached across system runs.
§Panics
This will panic if next
has been called on QueryIter
before, unless the underlying Query
is empty.
§Example
#[derive(Component)]
struct AvailableMarker;
#[derive(Component, PartialEq, Eq, PartialOrd, Ord)]
enum Rarity {
Common,
Rare,
Epic,
Legendary
};
#[derive(Component)]
struct PartValue(f32);
// We can sort with the internals of components that do not implement Ord.
fn system_1(query: Query<(Entity, &PartValue)>) {
// Sort by the sines of the part values.
let parts: Vec<(Entity, &PartValue)> = query
.iter()
.sort_by_key::<&PartValue, _>(|value| value.sin() as usize)
.collect();
}
// We can define our own custom comparison functions over an EntityRef.
fn system_2(query: Query<EntityRef, With<PartMarker>>) {
// Sort by whether parts are available and their rarity.
// We want the available legendaries to come first, so we reverse the iterator.
let parts: Vec<EntityRef> = query.iter()
.sort_by_key::<EntityRef, _>(|entity_ref| {
(
entity_ref.contains::<AvailableMarker>(),
entity_ref.get::<Rarity>()
)
})
.rev()
.collect();
}
sourcepub fn sort_unstable_by_key<L: ReadOnlyQueryData + 'w, K>(
self,
f: impl FnMut(&L::Item<'w>) -> K
) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘwhere
K: Ord,
pub fn sort_unstable_by_key<L: ReadOnlyQueryData + 'w, K>(
self,
f: impl FnMut(&L::Item<'w>) -> K
) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘwhere
K: Ord,
Sorts all query items into a new iterator with a key extraction function over the query lens.
This sort is unstable (i.e., may reorder equal elements).
This uses slice::sort_unstable_by_key
internally.
Defining the lens works like transmute_lens
.
This includes the allowed parameter type changes listed under allowed transmutes.
However, the lens uses the filter of the original query when present.
The sort is not cached across system runs.
§Panics
This will panic if next
has been called on QueryIter
before, unless the underlying Query
is empty.
sourcepub fn sort_by_cached_key<L: ReadOnlyQueryData + 'w, K>(
self,
f: impl FnMut(&L::Item<'w>) -> K
) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘwhere
K: Ord,
pub fn sort_by_cached_key<L: ReadOnlyQueryData + 'w, K>(
self,
f: impl FnMut(&L::Item<'w>) -> K
) -> QuerySortedIter<'w, 's, D, F, impl ExactSizeIterator<Item = Entity> + DoubleEndedIterator + FusedIterator + 'w> ⓘwhere
K: Ord,
Sort all query items into a new iterator with a key extraction function over the query lens.
This sort is stable (i.e., does not reorder equal elements).
This uses slice::sort_by_cached_key
internally.
Defining the lens works like transmute_lens
.
This includes the allowed parameter type changes listed under allowed transmutes.
However, the lens uses the filter of the original query when present.
The sort is not cached across system runs.
§Panics
This will panic if next
has been called on QueryIter
before, unless the underlying Query
is empty.
Trait Implementations§
source§impl<'w, 's, D: QueryData, F> ExactSizeIterator for QueryIter<'w, 's, D, F>where
F: ArchetypeFilter + QueryFilter,
impl<'w, 's, D: QueryData, F> ExactSizeIterator for QueryIter<'w, 's, D, F>where
F: ArchetypeFilter + QueryFilter,
source§impl<'w, 's, D: QueryData, F: QueryFilter> Iterator for QueryIter<'w, 's, D, F>
impl<'w, 's, D: QueryData, F: QueryFilter> Iterator for QueryIter<'w, 's, D, F>
§type Item = <D as WorldQuery>::Item<'w>
type Item = <D as WorldQuery>::Item<'w>
source§fn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
source§fn fold<B, Func>(self, init: B, func: Func) -> B
fn fold<B, Func>(self, init: B, func: Func) -> B
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk
)N
values. Read more1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where
Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by
)n
elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
n
th element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n
elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
iter_map_windows
)f
for each contiguous window of size N
over
self
and returns an iterator over the outputs of f
. Like slice::windows()
,
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into
)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce
)1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find
)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>
fn copied<'a, T>(self) -> Copied<Self>
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
PartialOrd
elements of
this Iterator
with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by
)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted
)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted
)impl<'w, 's, D: QueryData, F: QueryFilter> FusedIterator for QueryIter<'w, 's, D, F>
Auto Trait Implementations§
impl<'w, 's, D, F> Freeze for QueryIter<'w, 's, D, F>
impl<'w, 's, D, F> !RefUnwindSafe for QueryIter<'w, 's, D, F>
impl<'w, 's, D, F> !Send for QueryIter<'w, 's, D, F>
impl<'w, 's, D, F> !Sync for QueryIter<'w, 's, D, F>
impl<'w, 's, D, F> Unpin for QueryIter<'w, 's, D, F>
impl<'w, 's, D, F> !UnwindSafe for QueryIter<'w, 's, D, F>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
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
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§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.source§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.