Struct ConIterOfVec

pub struct ConIterOfVec<T: Send + Sync> { /* private fields */ }

A concurrent iterator over a vector, consuming the vector and yielding its elements.

Implementations

impl<T: Send + Sync> ConIterOfVec<T>

pub fn new(vec: Vec<T>) -> Self

Consumes and creates a concurrent iterator of the given vec.

Trait Implementations

impl<T: Send + Sync> ConcurrentIter for ConIterOfVec<T>

type BufferedIter = <ConIterOfVec<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<T: Send + Sync> ConcurrentIterX for ConIterOfVec<T>

type Item = T

Type of the items that the iterator yields.

type SeqIter = IntoIter<T>

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

type BufferedIterX = BufferedVec<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 skip_to_end(&self)

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

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 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 ConIterOfVec<T>

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

Formats the value using the given formatter.

impl<T: Send + Sync> Drop for ConIterOfVec<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Send + Sync> From<Vec<T>> for ConIterOfVec<T>

fn from(vec: Vec<T>) -> Self

Consumes and creates a concurrent iterator of the given vec.

impl<T: Send + Sync> Send for ConIterOfVec<T>

impl<T: Send + Sync> Sync for ConIterOfVec<T>