Struct ndsparse::ParallelProducerWrapper

pub struct ParallelProducerWrapper<I>(_);

Parallel producer for Rayon implementation. This is mostly an internal detail.

Trait Implementations

impl<I: Debug> Debug for ParallelProducerWrapper<I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T, const D: usize> IntoIterator for ParallelProducerWrapper<CslLineIterRef<'a, T, D>> where
    T: 'a, 

type IntoIter = CslLineIterRef<'a, T, D>

Which kind of iterator are we turning this into?

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const D: usize> IntoIterator for ParallelProducerWrapper<CslLineIterMut<'a, T, D>> where
    T: 'a, 

type IntoIter = CslLineIterMut<'a, T, D>

Which kind of iterator are we turning this into?

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const D: usize> Producer for ParallelProducerWrapper<CslLineIterRef<'a, T, D>> where
    T: Send + Sync + 'a, 

type IntoIter = CslLineIterRef<'a, T, D>

The type of iterator we will become.

type Item = <Self::IntoIter as Iterator>::Item

The type of item that will be produced by this producer once it is converted into an iterator.

fn into_iter(self) -> Self::IntoIter

Convert self into an iterator; at this point, no more parallel splits are possible.

fn split_at(self, i: usize) -> (Self, Self)

Split into two producers; one produces items 0..index, the other index..N. Index must be less than or equal to N.

fn min_len(&self) -> usize

The minimum number of items that we will process sequentially. Defaults to 1, which means that we will split all the way down to a single item. This can be raised higher using the with_min_len method, which will force us to create sequential tasks at a larger granularity. Note that Rayon automatically normally attempts to adjust the size of parallel splits to reduce overhead, so this should not be needed.

fn max_len(&self) -> usize

The maximum number of items that we will process sequentially. Defaults to MAX, which means that we can choose not to split at all. This can be lowered using the with_max_len method, which will force us to create more parallel tasks. Note that Rayon automatically normally attempts to adjust the size of parallel splits to reduce overhead, so this should not be needed.

fn fold_with<F>(self, folder: F) -> F where
    F: Folder<Self::Item>, 

Iterate the producer, feeding each element to folder, and stop when the folder is full (or all elements have been consumed).

impl<'a, T, const D: usize> Producer for ParallelProducerWrapper<CslLineIterMut<'a, T, D>> where
    T: Send + Sync + 'a, 

type IntoIter = CslLineIterMut<'a, T, D>

The type of iterator we will become.

type Item = <Self::IntoIter as Iterator>::Item

The type of item that will be produced by this producer once it is converted into an iterator.

fn into_iter(self) -> Self::IntoIter

Convert self into an iterator; at this point, no more parallel splits are possible.

fn split_at(self, i: usize) -> (Self, Self)

Split into two producers; one produces items 0..index, the other index..N. Index must be less than or equal to N.

fn min_len(&self) -> usize

The minimum number of items that we will process sequentially. Defaults to 1, which means that we will split all the way down to a single item. This can be raised higher using the with_min_len method, which will force us to create sequential tasks at a larger granularity. Note that Rayon automatically normally attempts to adjust the size of parallel splits to reduce overhead, so this should not be needed.

fn max_len(&self) -> usize

The maximum number of items that we will process sequentially. Defaults to MAX, which means that we can choose not to split at all. This can be lowered using the with_max_len method, which will force us to create more parallel tasks. Note that Rayon automatically normally attempts to adjust the size of parallel splits to reduce overhead, so this should not be needed.

fn fold_with<F>(self, folder: F) -> F where
    F: Folder<Self::Item>, 

Iterate the producer, feeding each element to folder, and stop when the folder is full (or all elements have been consumed).