Struct rayon::iter::collect::consumer::CollectResult

pub(super) struct CollectResult<'c, T> {
    start: SendPtr<T>,
    total_len: usize,
    initialized_len: usize,
    invariant_lifetime: PhantomData<&'c mut &'c mut [T]>,
}

CollectResult represents an initialized part of the target slice.

This is a proxy owner of the elements in the slice; when it drops, the elements will be dropped, unless its ownership is released before then.

Fields

start: SendPtr<T>

This pointer and length has the same representation as a slice, but retains the provenance of the entire array so that we can merge these regions together in CollectReducer.

total_len: usize

initialized_len: usize

The current initialized length after start

invariant_lifetime: PhantomData<&'c mut &'c mut [T]>

Lifetime invariance guarantees that the data flows from consumer to result, especially for the scope_fn callback in Collect::with_consumer.

Implementations

impl<'c, T> CollectResult<'c, T>

pub(super) fn len(&self) -> usize

The current length of the collect result

pub(super) fn release_ownership(self) -> usize

Release ownership of the slice of elements, and return the length

Trait Implementations

impl<'c, T> Drop for CollectResult<'c, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'c, T: Send + 'c> Folder<T> for CollectResult<'c, T>

type Result = CollectResult<'c, T>

The type of result that will ultimately be produced by the folder.

fn consume(self, item: T) -> Self

Consume next item and return new sequential state.

fn complete(self) -> Self::Result

Finish consuming items, produce final result.

fn full(&self) -> bool

Hint whether this Folder would like to stop processing further items, e.g. if a search has been completed.

fn consume_iter<I>(self, iter: I) -> Self

where I: IntoIterator<Item = Item>,

Consume items from the iterator until full, and return new sequential state.

impl<'c, T> Reducer<CollectResult<'c, T>> for CollectReducer

fn reduce( self, left: CollectResult<'c, T>, right: CollectResult<'c, T>, ) -> CollectResult<'c, T>

Reduce two final results into one; this is executed after a split.

impl<'c, T> Send for CollectResult<'c, T>

where T: Send,