Struct Copied

pub struct Copied<'a, T, C>
where
    T: Send + Sync + Copy,
{ /* private fields */ }

An concurrent iterator, backed with an atomic iterator, that copies the elements of an underlying iterator.

This struct is created by the copied method on the concurrent iterator.

Trait Implementations

impl<'a, T, C> ConcurrentIter for Copied<'a, T, C>

where T: Send + Sync + Copy, C: ConcurrentIter<Item = &'a T>,

type BufferedIter = CopiedBufferedChunk<'a, T, <C as ConcurrentIter>::BufferedIter>

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, C> ConcurrentIterX for Copied<'a, T, C>

where T: Send + Sync + Copy, C: ConcurrentIterX<Item = &'a T>,

type Item = T

Type of the items that the iterator yields.

type SeqIter = Copied<<C as ConcurrentIterX>::SeqIter>

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

type BufferedIterX = CopiedBufferedChunk<'a, T, <C as ConcurrentIterX>::BufferedIterX>

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, C> Send for Copied<'_, T, C>

where T: Send + Sync + Copy,

impl<T, C> Sync for Copied<'_, T, C>

where T: Send + Sync + Copy,