Struct ConIterOfIter

pub struct ConIterOfIter<T: Send + Sync, Iter>
where
    Iter: Iterator<Item = T>,
{ /* private fields */ }

A regular Iter: Iterator ascended to the concurrent programs with use of atomics.

Since ConIterOfIter can wrap up any Iterator and enable concurrent iteration, it might be considered as the most general ConcurrentIter implementation.

In performance critical scenarios and whenever possible, it might be preferable to use a more specific implementation such as crate::ConIterOfSlice.

Implementations

impl<T: Send + Sync, Iter> ConIterOfIter<T, Iter>

where Iter: Iterator<Item = T>,

pub fn new(iter: Iter) -> Self

Creates a concurrent iterator for the given iter.

Trait Implementations

impl<T: Send + Sync, Iter> ConcurrentIter for ConIterOfIter<T, Iter>

where Iter: Iterator<Item = T>,

type BufferedIter = <ConIterOfIter<T, Iter> as ConcurrentIterX>::BufferedIterX

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

fn into_con_iter_x(self) -> ConIterOfIterX<T, Iter>

where Self: Sized,

Converts the ConcurrentIter into a ConcurrentIterX.

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 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, Iter> ConcurrentIterX for ConIterOfIter<T, Iter>

where Iter: Iterator<Item = T>,

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.

Examples

use orx_concurrent_iter::*;

let iter = (0..1024).map(|x| x.to_string());
let con_iter = iter.into_con_iter();

std::thread::scope(|s| {
    s.spawn(|| {
        for _ in 0..42 {
            _ = con_iter.next();
        }

        let mut buffered = con_iter.buffered_iter(32);
        let _chunk = buffered.next().unwrap();
    });
});

let num_used = 42 + 32;

// converts the remaining elements into a sequential iterator
let seq_iter = con_iter.into_seq_iter();

assert_eq!(seq_iter.len(), 1024 - num_used);
for (i, x) in seq_iter.enumerate() {
    assert_eq!(x, (num_used + i).to_string());
}

type Item = T

Type of the items that the iterator yields.

type SeqIter = Iter

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

type BufferedIterX = BufferIter<T, Iter>

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

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, Iter> Debug for ConIterOfIter<T, Iter>

where Iter: Iterator<Item = T>,

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

Formats the value using the given formatter.

impl<T: Send + Sync, Iter> From<Iter> for ConIterOfIter<T, Iter>

where Iter: Iterator<Item = T>,

fn from(iter: Iter) -> Self

Converts to this type from the input type.

impl<T: Send + Sync, Iter> Send for ConIterOfIter<T, Iter>

where Iter: Iterator<Item = T>,

impl<T: Send + Sync, Iter> Sync for ConIterOfIter<T, Iter>

where Iter: Iterator<Item = T>,