Struct ConIterOfSlice

pub struct ConIterOfSlice<'a, T: Send + Sync> { /* private fields */ }

A concurrent iterator over a slice yielding references to the elements.

Implementations

impl<'a, T: Send + Sync> ConIterOfSlice<'a, T>

pub fn new(slice: &'a [T]) -> Self

Creates a concurrent iterator for the given slice.

Trait Implementations

impl<T: Send + Sync> Clone for ConIterOfSlice<'_, T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Send + Sync> ConcurrentIter for ConIterOfSlice<'_, T>

type BufferedIter = <ConIterOfSlice<'_, T> as ConcurrentIterX>::BufferedIterX

Type of the buffered iterator returned by the chunk_iter method when elements are fetched in chunks by each thread.

fn next_id_and_value(&self) -> Option<Next<Self::Item>>

Advances the iterator and returns the next value together with its enumeration index.

fn next_chunk( &self, chunk_size: usize, ) -> Option<NextChunk<Self::Item, impl ExactSizeIterator<Item = Self::Item>>>

Advances the iterator chunk_size times and returns an iterator of at most chunk_size consecutive next values. Further, the beginning enumeration index of the yielded values is returned.

fn into_con_iter_x(self) -> impl ConcurrentIterX<Item = Self::Item>

where Self: Sized,

Converts the ConcurrentIter into a ConcurrentIterX.

fn ids_and_values(&self) -> ConIterIdsAndValues<'_, Self>

where Self: Sized,

Returns an Iterator over the ids and values of elements of the concurrent iterator.

fn for_each<Fun: FnMut(Self::Item)>(&self, chunk_size: usize, fun: Fun)

where Self: Sized,

Applies the function fun to each element of the iterator concurrently.

fn enumerate_for_each<Fun: FnMut(usize, Self::Item)>( &self, chunk_size: usize, fun: Fun, )

where Self: Sized,

Applies the function fun to each index and corresponding element of the iterator concurrently.

fn buffered_iter( &self, chunk_size: usize, ) -> BufferedIter<'_, Self::Item, Self::BufferedIter>

Creates an iterator which pulls elements from this iterator as chunks of the given chunk_size.

impl<'a, T: Send + Sync> ConcurrentIterX for ConIterOfSlice<'a, T>

type Item = &'a T

Type of the items that the iterator yields.

type SeqIter = Skip<Iter<'a, T>>

Inner type which is the source of the data to be iterated, which in addition is a regular sequential Iterator.

type BufferedIterX = BufferedSlice<T>

Type of the buffered iterator returned by the buffered_iter_x method when elements are fetched in chunks by each thread.

fn into_seq_iter(self) -> Self::SeqIter

Converts the concurrent iterator back to the original wrapped type which is the source of the elements to be iterated. Already progressed elements are skipped.

fn next_chunk_x( &self, chunk_size: usize, ) -> Option<impl ExactSizeIterator<Item = Self::Item>>

Advances the iterator chunk_size times and returns an iterator of at most chunk_size consecutive next values.

fn next(&self) -> Option<Self::Item>

Advances the iterator and returns the next value.

fn try_get_len(&self) -> Option<usize>

Returns Some of the remaining length of the iterator if it is known; returns None otherwise.

fn try_get_initial_len(&self) -> Option<usize>

Returns Some of the initial length of the iterator when it was constructed if it is known; returns None otherwise.

fn skip_to_end(&self)

Skips all remaining elements of the iterator and assumes that the end of the iterator is reached.

fn values(&self) -> ConIterValuesX<'_, Self>

where Self: Sized,

Returns an Iterator over the values of elements of the concurrent iterator.

fn for_each_x<Fun: FnMut(Self::Item)>(&self, chunk_size: usize, fun: Fun)

where Self: Sized,

Applies the function fun to each element of the iterator concurrently.

fn fold<B, Fold>(&self, chunk_size: usize, neutral: B, fold: Fold) -> B

where Fold: FnMut(B, Self::Item) -> B, Self: Sized,

Folds the elements of the iterator pulled concurrently using fold function.

fn has_more(&self) -> HasMore

Returns whether or not the concurrent iterator has more elements to yield.

fn buffered_iter_x( &self, chunk_size: usize, ) -> BufferedIter<'_, Self::Item, Self::BufferedIterX>

Creates an iterator which pulls elements from this iterator as chunks of the given chunk_size.

impl<T: Send + Sync> Debug for ConIterOfSlice<'_, T>

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

Formats the value using the given formatter.

impl<'a, T: Send + Sync> From<&'a [T]> for ConIterOfSlice<'a, T>

fn from(slice: &'a [T]) -> Self

Creates a concurrent iterator for the given slice.

impl<T: Send + Sync> Send for ConIterOfSlice<'_, T>

impl<T: Send + Sync> Sync for ConIterOfSlice<'_, T>