Struct ext_sort::buffer::LimitedBuffer

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

Buffer limited by elements count.

Implementations

impl<T> LimitedBuffer<T>

pub fn new(limit: usize) -> Self

Creates a new buffer instance.

Arguments

• limit - Buffer elements count limit

pub fn with_capacity(limit: usize) -> Self

Creates a new buffer instance with provided capacity.

Arguments

• limit - Buffer elements count limit

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 the 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, Global> 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_rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T>

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

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

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

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<K, F>(&mut self, f: F)where K: Ord, F: Fn(&T) -> K + Sync,

Sorts the slice in parallel with a key extraction function.

fn par_sort_by_cached_key<K, F>(&mut self, f: F)where F: Fn(&T) -> K + Sync, K: Ord + Send,

Sorts the slice in parallel with a key extraction function.

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 might not preserve the order of equal elements.

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

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