Trait ParIterUsing

pub trait ParIterUsing<U, R = DefaultRunner>:
    Sized
    + Send
    + Sync
where
    R: ParallelRunner,
    U: Using,
{
    type Item: Send + Sync;

    // Required methods
    fn con_iter(&self) -> &impl ConcurrentIter;
    fn params(&self) -> Params;
    fn num_threads(self, num_threads: impl Into<NumThreads>) -> Self;
    fn chunk_size(self, chunk_size: impl Into<ChunkSize>) -> Self;
    fn iteration_order(self, collect: IterationOrder) -> Self;
    fn with_runner<Q: ParallelRunner>(
        self,
    ) -> impl ParIterUsing<U, Q, Item = Self::Item>;
    fn map<Out, Map>(self, map: Map) -> impl ParIterUsing<U, R, Item = Out>
       where Out: Send + Sync,
             Map: Fn(&mut U::Item, Self::Item) -> Out + Send + Sync + Clone;
    fn filter<Filter>(
        self,
        filter: Filter,
    ) -> impl ParIterUsing<U, R, Item = Self::Item>
       where Filter: Fn(&mut U::Item, &Self::Item) -> bool + Send + Sync + Clone;
    fn flat_map<IOut, FlatMap>(
        self,
        flat_map: FlatMap,
    ) -> impl ParIterUsing<U, R, Item = IOut::Item>
       where IOut: IntoIterator + Send + Sync,
             IOut::IntoIter: Send + Sync,
             IOut::Item: Send + Sync,
             FlatMap: Fn(&mut U::Item, Self::Item) -> IOut + Send + Sync + Clone;
    fn filter_map<Out, FilterMap>(
        self,
        filter_map: FilterMap,
    ) -> impl ParIterUsing<U, R, Item = Out>
       where Out: Send + Sync,
             FilterMap: Fn(&mut U::Item, Self::Item) -> Option<Out> + Send + Sync + Clone;
    fn collect_into<C>(self, output: C) -> C
       where C: ParCollectInto<Self::Item>;
    fn reduce<Reduce>(self, reduce: Reduce) -> Option<Self::Item>
       where Reduce: Fn(&mut U::Item, Self::Item, Self::Item) -> Self::Item + Send + Sync;
    fn first(self) -> Option<Self::Item>;

    // Provided methods
    fn inspect<Operation>(
        self,
        operation: Operation,
    ) -> impl ParIterUsing<U, R, Item = Self::Item>
       where Operation: Fn(&mut U::Item, &Self::Item) + Sync + Send + Clone { ... }
    fn copied<'a, T>(self) -> impl ParIterUsing<U, R, Item = T>
       where T: 'a + Copy + Send + Sync,
             Self: ParIterUsing<U, R, Item = &'a T> { ... }
    fn cloned<'a, T>(self) -> impl ParIterUsing<U, R, Item = T>
       where T: 'a + Clone + Send + Sync,
             Self: ParIterUsing<U, R, Item = &'a T> { ... }
    fn flatten(
        self,
    ) -> impl ParIterUsing<U, R, Item = <Self::Item as IntoIterator>::Item>
       where Self::Item: IntoIterator,
             <Self::Item as IntoIterator>::IntoIter: Send + Sync,
             <Self::Item as IntoIterator>::Item: Send + Sync,
             R: Send + Sync,
             Self: Send + Sync { ... }
    fn collect<C>(self) -> C
       where C: ParCollectInto<Self::Item> { ... }
    fn all<Predicate>(self, predicate: Predicate) -> bool
       where Predicate: Fn(&mut U::Item, &Self::Item) -> bool + Send + Sync + Clone { ... }
    fn any<Predicate>(self, predicate: Predicate) -> bool
       where Predicate: Fn(&mut U::Item, &Self::Item) -> bool + Send + Sync + Clone { ... }
    fn count(self) -> usize { ... }
    fn for_each<Operation>(self, operation: Operation)
       where Operation: Fn(&mut U::Item, Self::Item) + Sync + Send { ... }
    fn max(self) -> Option<Self::Item>
       where Self::Item: Ord { ... }
    fn max_by<Compare>(self, compare: Compare) -> Option<Self::Item>
       where Compare: Fn(&Self::Item, &Self::Item) -> Ordering + Sync { ... }
    fn max_by_key<Key, GetKey>(self, key: GetKey) -> Option<Self::Item>
       where Key: Ord,
             GetKey: Fn(&Self::Item) -> Key + Sync { ... }
    fn min(self) -> Option<Self::Item>
       where Self::Item: Ord { ... }
    fn min_by<Compare>(self, compare: Compare) -> Option<Self::Item>
       where Compare: Fn(&Self::Item, &Self::Item) -> Ordering + Sync { ... }
    fn min_by_key<Key, GetKey>(self, get_key: GetKey) -> Option<Self::Item>
       where Key: Ord,
             GetKey: Fn(&Self::Item) -> Key + Sync { ... }
    fn sum<Out>(self) -> Out
       where Self::Item: Sum<Out>,
             Out: Send + Sync { ... }
    fn find<Predicate>(self, predicate: Predicate) -> Option<Self::Item>
       where Predicate: Fn(&mut U::Item, &Self::Item) -> bool + Send + Sync + Clone { ... }
}

Parallel iterator which allows mutable access to a variable of type U within its iterator methods.

Note that one variable will be created per thread used by the parallel computation.

Required Associated Types

type Item: Send + Sync

Element type of the parallel iterator.

Required Methods

fn con_iter(&self) -> &impl ConcurrentIter

Returns a reference to the input concurrent iterator.

fn params(&self) -> Params

Parameters of the parallel iterator.

See crate::ParIter::params for details.

fn num_threads(self, num_threads: impl Into<NumThreads>) -> Self

Sets the number of threads to be used in the parallel execution. Integers can be used as the argument with the following mapping:

• 0 -> NumThreads::Auto

• 1 -> NumThreads::sequential()

• n > 0 -> NumThreads::Max(n)

  /// Parameters of the parallel iterator.

See crate::ParIter::num_threads for details.

fn chunk_size(self, chunk_size: impl Into<ChunkSize>) -> Self

Sets the number of elements to be pulled from the concurrent iterator during the parallel execution. When integers are used as argument, the following mapping applies:

• 0 -> ChunkSize::Auto
• n > 0 -> ChunkSize::Exact(n)

Please use the default enum constructor for creating ChunkSize::Min variant.

See crate::ParIter::chunk_size for details.

fn iteration_order(self, collect: IterationOrder) -> Self

Sets the iteration order of the parallel computation.

See crate::ParIter::iteration_order for details.

fn with_runner<Q: ParallelRunner>( self, ) -> impl ParIterUsing<U, Q, Item = Self::Item>

Rather than the DefaultRunner, uses the parallel runner Q which implements ParallelRunner.

See crate::ParIter::with_runner for details.

fn map<Out, Map>(self, map: Map) -> impl ParIterUsing<U, R, Item = Out>

where Out: Send + Sync, Map: Fn(&mut U::Item, Self::Item) -> Out + Send + Sync + Clone,

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

Unlike crate::ParIter::map, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn filter<Filter>( self, filter: Filter, ) -> impl ParIterUsing<U, R, Item = Self::Item>

where Filter: Fn(&mut U::Item, &Self::Item) -> bool + Send + Sync + Clone,

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

Unlike crate::ParIter::filter, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn flat_map<IOut, FlatMap>( self, flat_map: FlatMap, ) -> impl ParIterUsing<U, R, Item = IOut::Item>

where IOut: IntoIterator + Send + Sync, IOut::IntoIter: Send + Sync, IOut::Item: Send + Sync, FlatMap: Fn(&mut U::Item, Self::Item) -> IOut + Send + Sync + Clone,

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

Unlike crate::ParIter::flat_map, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn filter_map<Out, FilterMap>( self, filter_map: FilterMap, ) -> impl ParIterUsing<U, R, Item = Out>

where Out: Send + Sync, FilterMap: Fn(&mut U::Item, Self::Item) -> Option<Out> + Send + Sync + Clone,

Creates an iterator that both filters and maps.

The returned iterator yields only the values for which the supplied closure filter_map returns Some(value).

filter_map can be used to make chains of filter and map more concise. The example below shows how a map().filter().map() can be shortened to a single call to filter_map.

Unlike crate::ParIter::filter_map, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn collect_into<C>(self, output: C) -> C

where C: ParCollectInto<Self::Item>,

Collects all the items from an iterator into a collection.

Unlike crate::ParIter::collect_into, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn reduce<Reduce>(self, reduce: Reduce) -> Option<Self::Item>

where Reduce: Fn(&mut U::Item, Self::Item, Self::Item) -> Self::Item + Send + Sync,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

See the details here: crate::ParIter::reduce.

fn first(self) -> Option<Self::Item>

Returns the first (or any) element of the iterator; returns None if it is empty.

• first element is returned if default iteration order IterationOrder::Ordered is used,
• any element is returned if IterationOrder::Arbitrary is set.

See the details here: crate::ParIter::first.

Provided Methods

fn inspect<Operation>( self, operation: Operation, ) -> impl ParIterUsing<U, R, Item = Self::Item>

where Operation: Fn(&mut U::Item, &Self::Item) + Sync + Send + Clone,

Does something with each element of an iterator, passing the value on.

Unlike crate::ParIter::inspect, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn copied<'a, T>(self) -> impl ParIterUsing<U, R, Item = T>

where T: 'a + Copy + Send + Sync, Self: ParIterUsing<U, R, Item = &'a T>,

Creates an iterator which copies all of its elements.

Unlike crate::ParIter::copied, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn cloned<'a, T>(self) -> impl ParIterUsing<U, R, Item = T>

where T: 'a + Clone + Send + Sync, Self: ParIterUsing<U, R, Item = &'a T>,

Creates an iterator which clones all of its elements.

Unlike crate::ParIter::cloned, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn flatten( self, ) -> impl ParIterUsing<U, R, Item = <Self::Item as IntoIterator>::Item>

where Self::Item: IntoIterator, <Self::Item as IntoIterator>::IntoIter: Send + Sync, <Self::Item as IntoIterator>::Item: Send + Sync, R: Send + Sync, Self: Send + Sync,

Creates an iterator that flattens nested structure.

Unlike crate::ParIter::flatten, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn collect<C>(self) -> C

where C: ParCollectInto<Self::Item>,

Transforms an iterator into a collection.

Unlike crate::ParIter::collect, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn all<Predicate>(self, predicate: Predicate) -> bool

where Predicate: Fn(&mut U::Item, &Self::Item) -> bool + Send + Sync + Clone,

Tests if every element of the iterator matches a predicate.

Unlike crate::ParIter::all, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn any<Predicate>(self, predicate: Predicate) -> bool

where Predicate: Fn(&mut U::Item, &Self::Item) -> bool + Send + Sync + Clone,

Tests if any element of the iterator matches a predicate.

Unlike crate::ParIter::any, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it.

See the details here: crate::ParIter::count.

fn for_each<Operation>(self, operation: Operation)

where Operation: Fn(&mut U::Item, Self::Item) + Sync + Send,

Calls a closure on each element of an iterator.

Unlike crate::ParIter::for_each, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

fn max(self) -> Option<Self::Item>

where Self::Item: Ord,

Returns the maximum element of an iterator.

See the details here: crate::ParIter::max.

fn max_by<Compare>(self, compare: Compare) -> Option<Self::Item>

where Compare: Fn(&Self::Item, &Self::Item) -> Ordering + Sync,

Returns the element that gives the maximum value with respect to the specified compare function.

See the details here: crate::ParIter::max_by.

fn max_by_key<Key, GetKey>(self, key: GetKey) -> Option<Self::Item>

where Key: Ord, GetKey: Fn(&Self::Item) -> Key + Sync,

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

See the details here: crate::ParIter::max_by_key.

fn min(self) -> Option<Self::Item>

where Self::Item: Ord,

Returns the minimum element of an iterator.

See the details here: crate::ParIter::min.

fn min_by<Compare>(self, compare: Compare) -> Option<Self::Item>

where Compare: Fn(&Self::Item, &Self::Item) -> Ordering + Sync,

Returns the element that gives the minimum value with respect to the specified compare function.

See the details here: crate::ParIter::min_by.

fn min_by_key<Key, GetKey>(self, get_key: GetKey) -> Option<Self::Item>

where Key: Ord, GetKey: Fn(&Self::Item) -> Key + Sync,

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

See the details here: crate::ParIter::min_by_key.

fn sum<Out>(self) -> Out

where Self::Item: Sum<Out>, Out: Send + Sync,

Sums the elements of an iterator.

See the details here: crate::ParIter::sum.

fn find<Predicate>(self, predicate: Predicate) -> Option<Self::Item>

where Predicate: Fn(&mut U::Item, &Self::Item) -> bool + Send + Sync + Clone,

Searches for an element of an iterator that satisfies a predicate.

Unlike crate::ParIter::find, the closure allows access to mutable reference of the used variable.

Please see crate::ParIter::using transformation for details and examples.

Further documentation can be found here: using.md.

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.

Implementors

impl<U, I, O, M1, R> ParIterUsing<U, R> for UParMap<U, I, O, M1, R>

where R: ParallelRunner, U: Using, I: ConcurrentIter, O: Send + Sync, M1: Fn(&mut U::Item, I::Item) -> O + Send + Sync + Clone,

type Item = O

impl<U, I, R> ParIterUsing<U, R> for UPar<U, I, R>

where U: Using, R: ParallelRunner, I: ConcurrentIter,

type Item = <I as ConcurrentIter>::Item

impl<U, I, Vo, M1, R> ParIterUsing<U, R> for UParXap<U, I, Vo, M1, R>

where R: ParallelRunner, U: Using, I: ConcurrentIter, Vo: Values + Send + Sync, Vo::Item: Send + Sync, M1: Fn(&mut U::Item, I::Item) -> Vo + Send + Sync,

type Item = <Vo as Values>::Item

impl<U, I, Vt, Vo, M1, F, M2, R> ParIterUsing<U, R> for UParXapFilterXap<U, I, Vt, Vo, M1, F, M2, R>

where R: ParallelRunner, U: Using, I: ConcurrentIter, Vt: Values + Send + Sync, Vt::Item: Send + Sync, Vo: Values + Send + Sync, Vo::Item: Send + Sync, M1: Fn(&mut U::Item, I::Item) -> Vt + Send + Sync, F: Fn(&mut U::Item, &Vt::Item) -> bool + Send + Sync, M2: Fn(&mut U::Item, Vt::Item) -> Vo + Send + Sync,

type Item = <Vo as Values>::Item