Struct ext_sort::buffer::LimitedBuffer

pub struct LimitedBuffer<T> { /* fields omitted */ }

Buffer limited by elements count.

Implementations

impl<T> LimitedBuffer<T>

pub fn new(limit: usize) -> Self

pub fn with_capacity(limit: usize) -> Self

Trait Implementations

impl<T: Send> ChunkBuffer<T> for LimitedBuffer<T>

fn push(&mut self, item: T)

Adds a new element to the buffer.

fn len(&self) -> usize

Returns buffer length

fn is_full(&self) -> bool

Checks if the buffer reached the limit.

impl<T> IntoIterator for LimitedBuffer<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = <Vec<T> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Send> ParallelSliceMut<T> for LimitedBuffer<T>

fn as_parallel_slice_mut(&mut self) -> &mut [T]

Returns a plain mutable slice, which is used to implement the rest of the parallel methods.

fn par_split_mut<P>(&mut self, separator: P) -> SplitMut<'_, T, P> where
    P: Fn(&T) -> bool + Sync + Send, 

Returns a parallel iterator over mutable subslices separated by elements that match the separator.

fn par_chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T>

Returns a parallel iterator over at most chunk_size elements of self at a time. The chunks are mutable and do not overlap.

fn par_chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<'_, T>

Returns a parallel iterator over chunk_size elements of self at a time. The chunks are mutable and do not overlap.

fn par_sort(&mut self) where
    T: Ord, 

Sorts the slice in parallel.

fn par_sort_by<F>(&mut self, compare: F) where
    F: Fn(&T, &T) -> Ordering + Sync, 

Sorts the slice in parallel with a comparator function.

fn par_sort_by_key<B, F>(&mut self, f: F) where
    B: Ord,
    F: Fn(&T) -> B + Sync, 

Sorts the slice in parallel with a key extraction function.

fn par_sort_unstable(&mut self) where
    T: Ord, 

Sorts the slice in parallel, but may not preserve the order of equal elements.

fn par_sort_unstable_by<F>(&mut self, compare: F) where
    F: Fn(&T, &T) -> Ordering + Sync, 

Sorts the slice in parallel with a comparator function, but may not preserve the order of equal elements.

fn par_sort_unstable_by_key<B, F>(&mut self, f: F) where
    B: Ord,
    F: Fn(&T) -> B + Sync, 

Sorts the slice in parallel with a key extraction function, but may not preserve the order of equal elements.