Struct ConIterOfRange

pub struct ConIterOfRange<Idx>
where
    Idx: Send + Sync + Clone + Copy + From<usize> + Into<usize> + Add<Idx, Output = Idx> + Sub<Idx, Output = Idx> + Ord,
    Range<Idx>: Iterator<Item = Idx>,
{ /* private fields */ }

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

Implementations

impl<Idx> ConIterOfRange<Idx>

where Idx: Send + Sync + Clone + Copy + From<usize> + Into<usize> + Add<Idx, Output = Idx> + Sub<Idx, Output = Idx> + Ord, Range<Idx>: Iterator<Item = Idx>,

pub fn new(range: Range<Idx>) -> Self

Creates a concurrent iterator for the given range.

Trait Implementations

impl<Idx> Clone for ConIterOfRange<Idx>

where Idx: Send + Sync + Clone + Copy + From<usize> + Into<usize> + Add<Idx, Output = Idx> + Sub<Idx, Output = Idx> + Ord, Range<Idx>: Iterator<Item = Idx>,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Idx> ConcurrentIter for ConIterOfRange<Idx>

where Idx: Send + Sync + Clone + Copy + From<usize> + Into<usize> + Add<Idx, Output = Idx> + Sub<Idx, Output = Idx> + Ord, Range<Idx>: Iterator<Item = Idx>,

type BufferedIter = <ConIterOfRange<Idx> 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<Idx> ConcurrentIterX for ConIterOfRange<Idx>

where Idx: Send + Sync + Clone + Copy + From<usize> + Into<usize> + Add<Idx, Output = Idx> + Sub<Idx, Output = Idx> + Ord, Range<Idx>: Iterator<Item = Idx>,

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 range = 0..1024;
let con_iter = range.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);
}

type Item = Idx

Type of the items that the iterator yields.

type SeqIter = Range<Idx>

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

type BufferedIterX = BufferedRange

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<Idx> Debug for ConIterOfRange<Idx>

where Idx: Send + Sync + Clone + Copy + From<usize> + Into<usize> + Add<Idx, Output = Idx> + Sub<Idx, Output = Idx> + Ord, Range<Idx>: Iterator<Item = Idx>,

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

Formats the value using the given formatter.

impl<Idx> From<Range<Idx>> for ConIterOfRange<Idx>

where Idx: Send + Sync + Clone + Copy + From<usize> + Into<usize> + Add<Idx, Output = Idx> + Sub<Idx, Output = Idx> + Ord, Range<Idx>: Iterator<Item = Idx>,

fn from(range: Range<Idx>) -> Self

Creates a concurrent iterator for the given range.

impl<Idx> Send for ConIterOfRange<Idx>

where Idx: Send + Sync + Clone + Copy + From<usize> + Into<usize> + Add<Idx, Output = Idx> + Sub<Idx, Output = Idx> + Ord, Range<Idx>: Iterator<Item = Idx>,

impl<Idx> Sync for ConIterOfRange<Idx>

where Idx: Send + Sync + Clone + Copy + From<usize> + Into<usize> + Add<Idx, Output = Idx> + Sub<Idx, Output = Idx> + Ord, Range<Idx>: Iterator<Item = Idx>,