Trait ExactSizeConcurrentIter 

pub trait ExactSizeConcurrentIter: ConcurrentIter {
    // Required method
    fn len(&self) -> usize;

    // Provided methods
    fn is_empty(&self) -> bool { ... }
    fn chain<C>(
        self,
        other: C,
    ) -> ChainKnownLenI<Self, <C as IntoConcurrentIter>::IntoIter>
       where C: IntoConcurrentIter<Item = Self::Item>,
             Self: Sized { ... }
}

A concurrent iterator which has a certain information of the number of remaining elements.

It can be considered as the concurrent counterpart of the ExactSizeIterator.

Examples

use orx_concurrent_iter::*;

let vec = vec!['x', 'y'];

let con_iter = vec.con_iter();
assert_eq!(con_iter.len(), 2);

assert_eq!(con_iter.next(), Some(&'x'));
assert_eq!(con_iter.len(), 1);

assert_eq!(con_iter.next(), Some(&'y'));
assert_eq!(con_iter.len(), 0);
assert!(con_iter.is_empty());

assert_eq!(con_iter.next(), None);
assert_eq!(con_iter.len(), 0);
assert!(con_iter.is_empty());

Required Methods

fn len(&self) -> usize

Returns the number remaining elements in the concurrent iterator.

Examples

use orx_concurrent_iter::*;

let vec = vec!['x', 'y'];

let con_iter = vec.con_iter();
assert_eq!(con_iter.len(), 2);

assert_eq!(con_iter.next(), Some(&'x'));
assert_eq!(con_iter.len(), 1);

assert_eq!(con_iter.next(), Some(&'y'));
assert_eq!(con_iter.len(), 0);
assert!(con_iter.is_empty());

assert_eq!(con_iter.next(), None);
assert_eq!(con_iter.len(), 0);
assert!(con_iter.is_empty());

Provided Methods

fn is_empty(&self) -> bool

Returns true if there are no elements left in the concurrent iterator. Returns false otherwise.

Examples

use orx_concurrent_iter::*;

let vec = vec!['x', 'y'];

let con_iter = vec.con_iter();
assert!(!con_iter.is_empty());

assert_eq!(con_iter.next(), Some(&'x'));
assert!(!con_iter.is_empty());

assert_eq!(con_iter.next(), Some(&'y'));
assert!(con_iter.is_empty());

assert_eq!(con_iter.next(), None);
assert!(con_iter.is_empty());

fn chain<C>( self, other: C, ) -> ChainKnownLenI<Self, <C as IntoConcurrentIter>::IntoIter>

where C: IntoConcurrentIter<Item = Self::Item>, Self: Sized,

Creates a chain of this and other concurrent iterators.

It is preferable to call chain over chain_inexact whenever the first iterator implements ExactSizeConcurrentIter.

Examples

use orx_concurrent_iter::*;

let s1 = "abc".chars(); // exact iter
let s2 = vec!['d', 'e', 'f'];

let chain = s1.iter_into_con_iter().chain_inexact(s2);

assert_eq!(chain.next(), Some('a'));
assert_eq!(chain.next(), Some('b'));
assert_eq!(chain.next(), Some('c'));
assert_eq!(chain.next(), Some('d'));
assert_eq!(chain.next(), Some('e'));
assert_eq!(chain.next(), Some('f'));
assert_eq!(chain.next(), None);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, I, T> ExactSizeConcurrentIter for ConIterCloned<'a, I, T>

where T: Clone + Send, I: ExactSizeConcurrentIter<Item = &'a T>,

impl<'a, I, T> ExactSizeConcurrentIter for ConIterCopied<'a, I, T>

where T: Copy + Send, I: ExactSizeConcurrentIter<Item = &'a T>,

impl<'a, T, S, X> ExactSizeConcurrentIter for ConIterJaggedRef<'a, T, S, X>

where T: Sync, X: JaggedIndexer, S: Slices<'a, T>,

impl<I> ExactSizeConcurrentIter for ConIterOfIter<I>

where I: ExactSizeIterator, <I as Iterator>::Item: Send,

impl<I, J> ExactSizeConcurrentIter for ChainKnownLenI<I, J>

where I: ExactSizeConcurrentIter, J: ExactSizeConcurrentIter<Item = <I as ConcurrentIter>::Item>,

impl<I, J> ExactSizeConcurrentIter for ChainUnknownLenI<I, J>

where I: ExactSizeConcurrentIter, J: ExactSizeConcurrentIter<Item = <I as ConcurrentIter>::Item>,

impl<T> ExactSizeConcurrentIter for ConIterEmpty<T>

where T: Send,

impl<T> ExactSizeConcurrentIter for ConIterRange<T>

where T: Send + From<usize> + Into<usize>, Range<T>: Default + Clone + ExactSizeIterator<Item = T>,

impl<T> ExactSizeConcurrentIter for ConIterSlice<'_, T>

where T: Sync,

impl<T> ExactSizeConcurrentIter for ConIterVec<T>

where T: Send,

impl<T> ExactSizeConcurrentIter for ConIterVecDequeRef<'_, T>

where T: Sync,

impl<T, E, I, P> ExactSizeConcurrentIter for ConcurrentRecursiveIterCore<ExactSize, T, E, I, P>

where T: Send, E: Fn(&T) -> I + Sync, I: IntoIterator<Item = T>, I::IntoIter: ExactSizeIterator, P: ConcurrentPinnedVec<T>, <P as ConcurrentPinnedVec<T>>::P: IntoConcurrentPinnedVec<T, ConPinnedVec = P>,

impl<T, X> ExactSizeConcurrentIter for ConIterJaggedOwned<T, X>

where T: Send + Sync, X: JaggedIndexer + Send + Sync,