Trait bevy::tasks::ParallelIterator

pub trait ParallelIterator<BatchIter>: Sized + Sendwhere
    BatchIter: Iterator + Send,{
    // Required method
    fn next_batch(&mut self) -> Option<BatchIter>;

    // Provided methods
    fn size_hint(&self) -> (usize, Option<usize>) { ... }
    fn count(self, pool: &TaskPool) -> usize { ... }
    fn last(self, _pool: &TaskPool) -> Option<<BatchIter as Iterator>::Item> { ... }
    fn nth(
        self,
        _pool: &TaskPool,
        n: usize
    ) -> Option<<BatchIter as Iterator>::Item> { ... }
    fn chain<U>(self, other: U) -> Chain<Self, U>
       where U: ParallelIterator<BatchIter> { ... }
    fn map<T, F>(self, f: F) -> Map<Self, F>
       where F: FnMut(<BatchIter as Iterator>::Item) -> T + Send + Clone { ... }
    fn for_each<F>(self, pool: &TaskPool, f: F)
       where F: FnMut(<BatchIter as Iterator>::Item) + Send + Clone + Sync { ... }
    fn filter<F>(self, predicate: F) -> Filter<Self, F>
       where F: FnMut(&<BatchIter as Iterator>::Item) -> bool { ... }
    fn filter_map<R, F>(self, f: F) -> FilterMap<Self, F>
       where F: FnMut(<BatchIter as Iterator>::Item) -> Option<R> { ... }
    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, F>
       where F: FnMut(<BatchIter as Iterator>::Item) -> U,
             U: IntoIterator { ... }
    fn flatten(self) -> Flatten<Self>
       where <BatchIter as Iterator>::Item: IntoIterator { ... }
    fn fuse(self) -> Fuse<Self> { ... }
    fn inspect<F>(self, f: F) -> Inspect<Self, F>
       where F: FnMut(&<BatchIter as Iterator>::Item) { ... }
    fn by_ref(&mut self) -> &mut Self { ... }
    fn collect<C>(self, pool: &TaskPool) -> C
       where C: FromIterator<<BatchIter as Iterator>::Item>,
             <BatchIter as Iterator>::Item: Send + 'static { ... }
    fn partition<C, F>(self, pool: &TaskPool, f: F) -> (C, C)
       where C: Default + Extend<<BatchIter as Iterator>::Item> + Send,
             F: FnMut(&<BatchIter as Iterator>::Item) -> bool + Send + Sync + Clone,
             <BatchIter as Iterator>::Item: Send + 'static { ... }
    fn fold<C, F, D>(self, pool: &TaskPool, init: C, f: F) -> Vec<C, Global>
       where F: FnMut(C, <BatchIter as Iterator>::Item) -> C + Send + Sync + Clone,
             C: Clone + Send + Sync + 'static { ... }
    fn all<F>(self, pool: &TaskPool, f: F) -> bool
       where F: FnMut(<BatchIter as Iterator>::Item) -> bool + Send + Sync + Clone { ... }
    fn any<F>(self, pool: &TaskPool, f: F) -> bool
       where F: FnMut(<BatchIter as Iterator>::Item) -> bool + Send + Sync + Clone { ... }
    fn position<F>(self, pool: &TaskPool, f: F) -> Option<usize>
       where F: FnMut(<BatchIter as Iterator>::Item) -> bool + Send + Sync + Clone { ... }
    fn max(self, pool: &TaskPool) -> Option<<BatchIter as Iterator>::Item>
       where <BatchIter as Iterator>::Item: Ord + Send + 'static { ... }
    fn min(self, pool: &TaskPool) -> Option<<BatchIter as Iterator>::Item>
       where <BatchIter as Iterator>::Item: Ord + Send + 'static { ... }
    fn max_by_key<R, F>(
        self,
        pool: &TaskPool,
        f: F
    ) -> Option<<BatchIter as Iterator>::Item>
       where R: Ord,
             F: FnMut(&<BatchIter as Iterator>::Item) -> R + Send + Sync + Clone,
             <BatchIter as Iterator>::Item: Send + 'static { ... }
    fn max_by<F>(
        self,
        pool: &TaskPool,
        f: F
    ) -> Option<<BatchIter as Iterator>::Item>
       where F: FnMut(&<BatchIter as Iterator>::Item, &<BatchIter as Iterator>::Item) -> Ordering + Send + Sync + Clone,
             <BatchIter as Iterator>::Item: Send + 'static { ... }
    fn min_by_key<R, F>(
        self,
        pool: &TaskPool,
        f: F
    ) -> Option<<BatchIter as Iterator>::Item>
       where R: Ord,
             F: FnMut(&<BatchIter as Iterator>::Item) -> R + Send + Sync + Clone,
             <BatchIter as Iterator>::Item: Send + 'static { ... }
    fn min_by<F>(
        self,
        pool: &TaskPool,
        f: F
    ) -> Option<<BatchIter as Iterator>::Item>
       where F: FnMut(&<BatchIter as Iterator>::Item, &<BatchIter as Iterator>::Item) -> Ordering + Send + Sync + Clone,
             <BatchIter as Iterator>::Item: Send + 'static { ... }
    fn copied<'a, T>(self) -> Copied<Self>
       where Self: ParallelIterator<BatchIter>,
             T: 'a + Copy { ... }
    fn cloned<'a, T>(self) -> Cloned<Self>
       where Self: ParallelIterator<BatchIter>,
             T: 'a + Copy { ... }
    fn cycle(self) -> Cycle<Self>
       where Self: Clone { ... }
    fn sum<S, R>(self, pool: &TaskPool) -> R
       where S: Sum<<BatchIter as Iterator>::Item> + Send + 'static,
             R: Sum<S> { ... }
    fn product<S, R>(self, pool: &TaskPool) -> R
       where S: Product<<BatchIter as Iterator>::Item> + Send + 'static,
             R: Product<S> { ... }
}

ParallelIterator closely emulates the std::iter::Iterator interface. However, it uses bevy_task to compute batches in parallel.

Note that the overhead of ParallelIterator is high relative to some workloads. In particular, if the batch size is too small or task being run in parallel is inexpensive, a ParallelIterator could take longer than a normal Iterator. Therefore, you should profile your code before using ParallelIterator.

Required Methods

fn next_batch(&mut self) -> Option<BatchIter>

Returns the next batch of items for processing.

Each batch is an iterator with items of the same type as the ParallelIterator. Returns None when there are no batches left.

Provided Methods

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

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

See Iterator::size_hint()

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

Consumes the parallel iterator and returns the number of items.

See Iterator::count()

fn last(self, _pool: &TaskPool) -> Option<<BatchIter as Iterator>::Item>

Consumes the parallel iterator and returns the last item.

See Iterator::last()

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

Consumes the parallel iterator and returns the nth item.

See Iterator::nth()

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

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

See Iterator::chain()

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

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

See Iterator::map()

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

Calls a closure on each item of a parallel iterator.

See Iterator::for_each()

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

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

See Iterator::filter()

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

Creates a parallel iterator that both filters and maps.

See Iterator::filter_map()

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

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

See Iterator::flat_map()

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

Creates a parallel iterator that flattens nested structure.

See Iterator::flatten()

fn fuse(self) -> Fuse<Self>

Creates a parallel iterator which ends after the first None.

See Iterator::fuse()

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

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

See Iterator::inspect()

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

Borrows a parallel iterator, rather than consuming it.

See Iterator::by_ref()

fn collect<C>(self, pool: &TaskPool) -> Cwhere C: FromIterator<<BatchIter as Iterator>::Item>, <BatchIter as Iterator>::Item: Send + 'static,

Transforms a parallel iterator into a collection.

See Iterator::collect()

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

Consumes a parallel iterator, creating two collections from it.

See Iterator::partition()

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

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

Note that this folds each batch independently and returns a Vec of results (in batch order).

See Iterator::fold()

fn all<F>(self, pool: &TaskPool, f: F) -> boolwhere F: FnMut(<BatchIter as Iterator>::Item) -> bool + Send + Sync + Clone,

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

Note that all is not short circuiting.

See Iterator::all()

fn any<F>(self, pool: &TaskPool, f: F) -> boolwhere F: FnMut(<BatchIter as Iterator>::Item) -> bool + Send + Sync + Clone,

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

Note that any is not short circuiting.

See Iterator::any()

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

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

Note that position consumes the whole iterator.

See Iterator::position()

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

Returns the maximum item of a parallel iterator.

See Iterator::max()

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

Returns the minimum item of a parallel iterator.

See Iterator::min()

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

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

See Iterator::max_by_key()

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

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

See Iterator::max_by()

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

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

See Iterator::min_by_key()

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

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

See Iterator::min_by()

fn copied<'a, T>(self) -> Copied<Self>where Self: ParallelIterator<BatchIter>, T: 'a + Copy,

Creates a parallel iterator which copies all of its items.

See Iterator::copied()

fn cloned<'a, T>(self) -> Cloned<Self>where Self: ParallelIterator<BatchIter>, T: 'a + Copy,

Creates a parallel iterator which clones all of its items.

See Iterator::cloned()

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

Repeats a parallel iterator endlessly.

See Iterator::cycle()

fn sum<S, R>(self, pool: &TaskPool) -> Rwhere S: Sum<<BatchIter as Iterator>::Item> + Send + 'static, R: Sum<S>,

Sums the items of a parallel iterator.

See Iterator::sum()

fn product<S, R>(self, pool: &TaskPool) -> Rwhere S: Product<<BatchIter as Iterator>::Item> + Send + 'static, R: Product<S>,

Multiplies all the items of a parallel iterator.

See Iterator::product()

Implementors