Struct ChainUnknownLenI 

pub struct ChainUnknownLenI<I, J>
where
    I: ConcurrentIter,
    J: ConcurrentIter<Item = <I as ConcurrentIter>::Item>,
{ /* private fields */ }

Chain of two concurrent iterators where the length of the first iterator is not known with certainly; i.e., I does not implement ExactSizeConcurrentIter.

Trait Implementations

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

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

type Item = <I as ConcurrentIter>::Item

Type of the element that the concurrent iterator yields.

type SequentialIter = Chain<<I as ConcurrentIter>::SequentialIter, <J as ConcurrentIter>::SequentialIter>

Type of the sequential iterator that the concurrent iterator can be converted into using the into_seq_iter method.

type ChunkPuller<'i> = ChainedChunkPullerUnknownLenI<'i, I, J> where ChainUnknownLenI<I, J>: 'i

Type of the chunk puller that can be created using the chunk_puller method.

fn into_seq_iter( self, ) -> <ChainUnknownLenI<I, J> as ConcurrentIter>::SequentialIter

Converts the concurrent iterator into its sequential regular counterpart. Note that the sequential iterator is a regular Iterator, and hence, does not have any overhead related with atomic states. Therefore, it is useful where the program decides to iterate over a single thread rather than concurrently by multiple threads.

fn skip_to_end(&self)

Immediately jumps to the end of the iterator, skipping the remaining elements.

fn next(&self) -> Option<<ChainUnknownLenI<I, J> as ConcurrentIter>::Item>

Returns the next element of the iterator. It returns None if there are no more elements left.

fn next_with_idx( &self, ) -> Option<(usize, <ChainUnknownLenI<I, J> as ConcurrentIter>::Item)>

Returns the next element of the iterator together its index. It returns None if there are no more elements left.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn is_completed_when_none_returned(&self) -> bool

Returns true if the concurrent iterator which has returned None for a next or pull call will continue to return None.

fn chunk_puller( &self, chunk_size: usize, ) -> <ChainUnknownLenI<I, J> as ConcurrentIter>::ChunkPuller<'_>

Creates a ChunkPuller from the concurrent iterator. The created chunk puller can be used to pull chunk_size elements at once from the data source, rather than pulling one by one.

fn try_get_len(&self) -> Option<usize>

Returns Some(x) if the number of remaining items is known with certainly and if it is equal to x.

fn item_puller(&self) -> ItemPuller<'_, Self>

where Self: Sized,

Creates a ItemPuller from the concurrent iterator. The created item puller can be used to pull elements one by one from the data source.

fn item_puller_with_idx(&self) -> EnumeratedItemPuller<'_, Self>

where Self: Sized,

Creates a EnumeratedItemPuller from the concurrent iterator. The created item puller can be used to pull elements one by one from the data source together with the index of the elements.

fn copied<'a, T>(self) -> ConIterCopied<'a, Self, T>

where T: Copy, Self: Sized + ConcurrentIter<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> ConIterCloned<'a, Self, T>

where T: Clone, Self: Sized + ConcurrentIter<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn chain_inexact<C>( self, other: C, ) -> ChainUnknownLenI<Self, <C as IntoConcurrentIter>::IntoIter>

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

Creates a chain of this and other concurrent iterators.

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

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

fn len(&self) -> usize

Returns the number remaining elements in the concurrent iterator.

fn is_empty(&self) -> bool

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

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.