[−][src]Trait asparit::ParallelDrainRange

pub trait ParallelDrainRange<'a, Idx = usize> {
    type Iter: ParallelIterator<'a, Item = Self::Item>;
    type Item: Send + 'a;
    pub fn par_drain<R: RangeBounds<Idx>>(self, range: R) -> Self::Iter;
}

ParallelDrainRange creates a parallel iterator that moves a range of items from a collection while retaining the original capacity.

Types which are not indexable may implement ParallelDrainFull instead.

Associated Types

type Iter: ParallelIterator<'a, Item = Self::Item>

The draining parallel iterator type that will be created.

type Item: Send + 'a

The type of item that the parallel iterator will produce. This is usually the same as IntoParallelIterator::Item.

Loading content...

Required methods

pub fn par_drain<R: RangeBounds<Idx>>(self, range: R) -> Self::Iter

Returns a draining parallel iterator over a range of the collection.

When the iterator is dropped, all items in the range are removed, even if the iterator was not fully consumed. If the iterator is leaked, for example using std::mem::forget, it is unspecified how many items are removed.

Examples

use asparit::*;

let squares: Vec<i32> = (0..10).map(|x| x * x).collect();

println!("RangeFull");
let mut vec = squares.clone();
assert!(vec.par_drain(..).eq(squares.par_iter().copied()).exec());
assert!(vec.is_empty());
assert!(vec.capacity() >= squares.len());

println!("RangeFrom");
let mut vec = squares.clone();
assert!(vec
    .par_drain(5..)
    .eq(squares[5..].par_iter().copied())
    .exec());
assert_eq!(&vec[..], &squares[..5]);
assert!(vec.capacity() >= squares.len());

println!("RangeTo");
let mut vec = squares.clone();
assert!(vec
    .par_drain(..5)
    .eq(squares[..5].par_iter().copied())
    .exec());
assert_eq!(&vec[..], &squares[5..]);
assert!(vec.capacity() >= squares.len());

println!("RangeToInclusive");
let mut vec = squares.clone();
assert!(vec
    .par_drain(..=5)
    .eq(squares[..=5].par_iter().copied())
    .exec());
assert_eq!(&vec[..], &squares[6..]);
assert!(vec.capacity() >= squares.len());

println!("Range");
let mut vec = squares.clone();
assert!(vec
    .par_drain(3..7)
    .eq(squares[3..7].par_iter().copied())
    .exec());
assert_eq!(&vec[..3], &squares[..3]);
assert_eq!(&vec[3..], &squares[7..]);
assert!(vec.capacity() >= squares.len());

println!("RangeInclusive");
let mut vec = squares.clone();
assert!(vec
    .par_drain(3..=7)
    .eq(squares[3..=7].par_iter().copied())
    .exec());
assert_eq!(&vec[..3], &squares[..3]);
assert_eq!(&vec[3..], &squares[8..]);
assert!(vec.capacity() >= squares.len());
Loading content...

Implementations on Foreign Types

impl<'a, T> ParallelDrainRange<'a, usize> for &'a mut Vec<T> where
    T: Send, [src]

type Iter = Drain<'a, T>

type Item = T

Loading content...

Implementors

Loading content...