Struct orx_concurrent_iter::ConIterOfRange

pub struct ConIterOfRange<Idx>
where
    Idx: Send + Sync + Clone + Copy + From<usize> + Into<usize> + Add<Idx, Output = Idx> + Sub<Idx, Output = Idx> + Ord,
{ /* 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,

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

Creates a concurrent iterator for the given range.

Trait Implementations

impl<Idx> AtomicIter<Idx> for ConIterOfRange<Idx>

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

fn counter(&self) -> &AtomicCounter

Returns a reference to the underlying advanced item counter.

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

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

fn fetch_n(&self, n: usize) -> impl NextChunk<Idx>

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 for_each_n<F: FnMut(Idx)>(&self, chunk_size: usize, f: F)

Applies the function f to each element of the iterator concurrently.

fn enumerate_for_each_n<F: FnMut(usize, Idx)>(&self, chunk_size: usize, f: F)

Applies the function f to each element and its corresponding index of the iterator concurrently. It may be considered as the concurrent counterpart of the chain of enumerate and for_each_n calls.

fn fold<B, F: FnMut(B, Idx) -> B>( &self, chunk_size: usize, initial: B, f: F ) -> B

Folds the elements of the iterator pulled concurrently using fold function.

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

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

impl<Idx> AtomicIterWithInitialLen<Idx> for ConIterOfRange<Idx>

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

fn initial_len(&self) -> usize

Returns the initial length of the atomic iterator.

fn fetch_n_with_exact_len( &self, n: usize ) -> NextManyExact<Idx, impl ExactSizeIterator<Item = Idx>>

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

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 + Clone,

fn clone(&self) -> ConIterOfRange<Idx>

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,

type Item = Idx

Type of the items that the iterator yields.

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) -> impl NextChunk<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 for_each_n<F: FnMut(Self::Item)>(&self, chunk_size: usize, f: F)

Applies the function fun to each element of the iterator concurrently.

fn enumerate_for_each_n<F: FnMut(usize, Self::Item)>( &self, chunk_size: usize, f: F )

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,

Folds the elements of the iterator pulled concurrently using fold function.

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, fun: Fun)

Applies the function fun to each element of the iterator concurrently.

fn enumerate_for_each<Fun: FnMut(usize, Self::Item)>(&self, fun: Fun)

Applies the function fun to each index and corresponding element of the iterator concurrently. It may be considered as the concurrent counterpart of the chain of enumerate and for_each calls.

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 + Debug,

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

Formats the value using the given formatter.

impl<Idx> ExactSizeConcurrentIter for ConIterOfRange<Idx>

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

fn len(&self) -> usize

Returns the exact remaining length of the concurrent iterator.

fn next_exact_chunk( &self, chunk_size: usize ) -> Option<NextManyExact<Self::Item, impl ExactSizeIterator<Item = Self::Item>>>

Returns the next chunk with the requested chunk_size:

fn is_empty(&self) -> bool

Returns true if the iterator is empty.

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,

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,

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,