Trait rayon::par_iter::IndexedParallelIterator [−] [src]

pub trait IndexedParallelIterator: ExactParallelIterator {
    fn zip<ZIP_OP>(self, zip_op: ZIP_OP) -> ZipIter<Self, ZIP_OP::Iter> where ZIP_OP: IntoParallelIterator,
              ZIP_OP::Iter: IndexedParallelIterator { ... }
    fn cmp<I>(self, other: I) -> Ordering where I: IntoParallelIterator<Item=Self::Item>,
              I::Iter: IndexedParallelIterator,
              Self::Item: Ord { ... }
    fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoParallelIterator,
              I::Iter: IndexedParallelIterator,
              Self::Item: PartialOrd<I::Item> { ... }
    fn eq<I>(self, other: I) -> bool where I: IntoParallelIterator,
              I::Iter: IndexedParallelIterator,
              Self::Item: PartialEq<I::Item> { ... }
    fn ne<I>(self, other: I) -> bool where I: IntoParallelIterator,
              I::Iter: IndexedParallelIterator,
              Self::Item: PartialEq<I::Item> { ... }
    fn lt<I>(self, other: I) -> bool where I: IntoParallelIterator,
              I::Iter: IndexedParallelIterator,
              Self::Item: PartialOrd<I::Item> { ... }
    fn le<I>(self, other: I) -> bool where I: IntoParallelIterator,
              I::Iter: IndexedParallelIterator,
              Self::Item: PartialOrd<I::Item> { ... }
    fn gt<I>(self, other: I) -> bool where I: IntoParallelIterator,
              I::Iter: IndexedParallelIterator,
              Self::Item: PartialOrd<I::Item> { ... }
    fn ge<I>(self, other: I) -> bool where I: IntoParallelIterator,
              I::Iter: IndexedParallelIterator,
              Self::Item: PartialOrd<I::Item> { ... }
    fn enumerate(self) -> Enumerate<Self> { ... }
    fn skip(self, n: usize) -> Skip<Self> { ... }
    fn take(self, n: usize) -> Take<Self> { ... }
    fn position_any<POSITION_OP>(self, predicate: POSITION_OP) -> Option<usize> where POSITION_OP: Fn(Self::Item) -> bool + Sync { ... }
}

An iterator that supports "random access" to its data, meaning that you can split it at arbitrary indices and draw data from those points.

Provided Methods

Iterate over tuples (A, B), where the items A are from this iterator and B are from the iterator given as argument. Like the zip method on ordinary iterators, if the two iterators are of unequal length, you only get the items they have in common.

Lexicographically compares the elements of this ParallelIterator with those of another.

Lexicographically compares the elements of this ParallelIterator with those of another.

Determines if the elements of this ParallelIterator are equal to those of another

Determines if the elements of this ParallelIterator are unequal to those of another

Determines if the elements of this ParallelIterator are lexicographically less than those of another.

Determines if the elements of this ParallelIterator are less or equal to those of another.

Determines if the elements of this ParallelIterator are lexicographically greater than those of another.

Determines if the elements of this ParallelIterator are less or equal to those of another.

Yields an index along with each item.

Creates an iterator that skips the first n elements.

Creates an iterator that yields the first n elements.

Searches for some item in the parallel iterator that matches the given predicate, and returns its index. Like ParallelIterator::find_any, the parallel search will not necessarily find the first match, and once a match is found we'll attempt to stop processing any more.

Implementors