Struct rayon::collections::drain_guard::DrainGuard

pub(super) struct DrainGuard<'a, T, C: From<Vec<T>>> {
    collection: &'a mut C,
    vec: Vec<T>,
}

A proxy for draining a collection by converting to a Vec and back.

This is used for draining BinaryHeap and VecDeque, which both have zero-allocation conversions to/from Vec, though not zero-cost:

• BinaryHeap will heapify from Vec, but at least that will be empty.
• VecDeque has to shift items to offset 0 when converting to Vec.

Fields

collection: &'a mut C

vec: Vec<T>

Implementations

impl<'a, T, C> DrainGuard<'a, T, C>

where C: Default + From<Vec<T>>, Vec<T>: From<C>,

pub(super) fn new(collection: &'a mut C) -> Self

Trait Implementations

impl<'a, T, C: From<Vec<T>>> Drop for DrainGuard<'a, T, C>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T, C> ParallelDrainRange for &'a mut DrainGuard<'_, T, C>

where T: Send, C: From<Vec<T>>,

type Iter = Drain<'a, T>

The draining parallel iterator type that will be created.

type Item = T

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

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

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