Struct orx_concurrent_iter::Cloned

pub struct Cloned<'a, T, A>
where
    T: Send + Sync + Clone,
    A: AtomicIter<&'a T>,
{ /* private fields */ }

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

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

Trait Implementations

impl<'a, T, A> AtomicIter<T> for Cloned<'a, T, A>

where T: Send + Sync + Clone, A: AtomicIter<&'a T>,

fn counter(&self) -> &AtomicCounter

Returns a reference to the underlying advanced item counter.

fn progress_and_get_begin_idx(&self, number_to_fetch: usize) -> Option<usize>

Progresses the atomic counter by number_to_fetch elements and returns the beginning index of the elements to be fetched. Returns None if the iterator is terminated and there are no more elements to be fetched.

fn get(&self, item_idx: usize) -> Option<T>

Returns the item_idx-th item that the iterator yields; returns None if the iterator completes before.

fn fetch_n( &self, n: usize, ) -> Option<NextChunk<T, impl ExactSizeIterator<Item = T>>>

Returns an iterator of the next n consecutive items that the iterator yields. It might return an iterator of less or no items if the iteration does not have sufficient elements left.

fn early_exit(&self)

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

fn fetch_one(&self) -> Option<Next<T>>

Returns the next item that the iterator yields; returns None if the iteration has completed.

impl<'a, T, A> AtomicIterWithInitialLen<T> for Cloned<'a, T, A>

where T: Send + Sync + Clone, A: AtomicIter<&'a T> + AtomicIterWithInitialLen<&'a T>,

fn initial_len(&self) -> usize

Returns the initial length of the atomic iterator.

impl<'a, T, A> ConcurrentIter for Cloned<'a, T, A>

where T: Send + Sync + Clone, A: AtomicIter<&'a T> + ConcurrentIter<Item = &'a T>,

type Item = T

Type of the items that the iterator yields.

type BufferedIter = ClonedBufferedChunk<'a, T, <A as ConcurrentIter>::BufferedIter>

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

type SeqIter = Cloned<<A as ConcurrentIter>::SeqIter>

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

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_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 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.

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 next(&self) -> Option<Self::Item>

Advances the iterator and returns the next value.

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

where Self: Sized,

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

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 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.

impl<'a, T, A> Send for Cloned<'a, T, A>

where T: Send + Sync + Clone, A: AtomicIter<&'a T>,

impl<'a, T, A> Sync for Cloned<'a, T, A>

where T: Send + Sync + Clone, A: AtomicIter<&'a T>,