Struct bevy_ecs::ParIter

pub struct ParIter<'q, 'w, Q: HecsQuery> { /* fields omitted */ }

Batched version of QueryIter

Trait Implementations

impl<'q, 'w, Q: HecsQuery> ParallelIterator<Batch<'q, Q>> for ParIter<'q, 'w, Q>

type Item = <Q::Fetch as Fetch<'q>>::Item

fn next_batch(&mut self) -> Option<Batch<'q, Q>>

Returns the next batch of items for processing.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining number of items in the parallel iterator.

fn count(self, pool: &TaskPool) -> usize

Consumes the parallel iterator and returns the number of items.

fn last(self, _pool: &TaskPool) -> Option<Self::Item>

Consumes the parallel iterator and returns the last item.

fn nth(self, _pool: &TaskPool, n: usize) -> Option<Self::Item>

Consumes the parallel iterator and returns the nth item.

fn chain<U>(self, other: U) -> Chain<Self, U> where
    U: ParallelIterator<B, Item = Self::Item>, 

Takes two parallel iterators and returns a parallel iterators over both in sequence.

fn map<T, F>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Item) -> T + Send + Clone, 

Takes a closure and creates a parallel iterator which calls that closure on each item.

fn for_each<F>(self, pool: &TaskPool, f: F) where
    F: FnMut(Self::Item) + Send + Clone + Sync, 

Calls a closure on each item of a parallel iterator.

fn filter<F>(self, predicate: F) -> Filter<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

Creates a parallel iterator which uses a closure to determine if an element should be yielded.

fn filter_map<R, F>(self, f: F) -> FilterMap<Self, F> where
    F: FnMut(Self::Item) -> Option<R>, 

Creates a parallel iterator that both filters and maps.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, F> where
    F: FnMut(Self::Item) -> U,
    U: IntoIterator, 

Creates a parallel iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoIterator, 

Creates a parallel iterator that flattens nested structure.

fn fuse(self) -> Fuse<Self>

Creates a parallel iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnMut(&Self::Item), 

Does something with each item of a parallel iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

Borrows a parallel iterator, rather than consuming it.

fn collect<C>(self, pool: &TaskPool) -> C where
    C: FromIterator<Self::Item>,
    Self::Item: Send,
    Self::Item: 'static, 

Transforms a parallel iterator into a collection.

fn partition<C, F>(self, pool: &TaskPool, f: F) -> (C, C) where
    C: Default + Extend<Self::Item> + Send,
    F: FnMut(&Self::Item) -> bool + Send + Sync + Clone,
    Self::Item: Send,
    Self::Item: 'static, 

Consumes a parallel iterator, creating two collections from it.

fn fold<C, F, D>(self, pool: &TaskPool, init: C, f: F) -> Vec<C> where
    C: Clone + Send + Sync + 'static,
    F: FnMut(C, Self::Item) -> C + Send + Sync + Clone, 

Repeatedly applies a function to items of each batch of a parallel iterator, producing a Vec of final values.

fn all<F>(self, pool: &TaskPool, f: F) -> bool where
    F: FnMut(Self::Item) -> bool + Send + Sync + Clone, 

Tests if every element of the parallel iterator matches a predicate.

fn any<F>(self, pool: &TaskPool, f: F) -> bool where
    F: FnMut(Self::Item) -> bool + Send + Sync + Clone, 

Tests if any element of the parallel iterator matches a predicate.

fn position<F>(self, pool: &TaskPool, f: F) -> Option<usize> where
    F: FnMut(Self::Item) -> bool + Send + Sync + Clone, 

Searches for an element in a parallel iterator, returning its index.

fn max(self, pool: &TaskPool) -> Option<Self::Item> where
    Self::Item: Ord,
    Self::Item: Send,
    Self::Item: 'static, 

Returns the maximum item of a parallel iterator.

fn min(self, pool: &TaskPool) -> Option<Self::Item> where
    Self::Item: Ord,
    Self::Item: Send,
    Self::Item: 'static, 

Returns the minimum item of a parallel iterator.

fn max_by_key<R, F>(self, pool: &TaskPool, f: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item) -> R + Send + Sync + Clone,
    R: Ord,
    Self::Item: Send,
    Self::Item: 'static, 

Returns the item that gives the maximum value from the specified function.

fn max_by<F>(self, pool: &TaskPool, f: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering + Send + Sync + Clone,
    Self::Item: Send,
    Self::Item: 'static, 

Returns the item that gives the maximum value with respect to the specified comparison function.

fn min_by_key<R, F>(self, pool: &TaskPool, f: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item) -> R + Send + Sync + Clone,
    R: Ord,
    Self::Item: Send,
    Self::Item: 'static, 

Returns the item that gives the minimum value from the specified function.

fn min_by<F>(self, pool: &TaskPool, f: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering + Send + Sync + Clone,
    Self::Item: Send,
    Self::Item: 'static, 

Returns the item that gives the minimum value with respect to the specified comparison function.

fn copied<'a, T>(self) -> Copied<Self> where
    Self: ParallelIterator<B, Item = &'a T>,
    T: 'a + Copy, 

Creates a parallel iterator which copies all of its items.

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: ParallelIterator<B, Item = &'a T>,
    T: 'a + Copy, 

Creates a parallel iterator which clones all of its items.

fn cycle(self) -> Cycle<Self> where
    Self: Clone, 

Repeats a parallel iterator endlessly.

fn sum<S, R>(self, pool: &TaskPool) -> R where
    R: Sum<S>,
    S: Sum<Self::Item> + Send + 'static, 

Sums the items of a parallel iterator.

fn product<S, R>(self, pool: &TaskPool) -> R where
    R: Product<S>,
    S: Product<Self::Item> + Send + 'static, 

Multiplies all the items of a parallel iterator.