Struct orx_split_vec::ConcurrentSplitVec

pub struct ConcurrentSplitVec<T, G: GrowthWithConstantTimeAccess = Doubling> { /* private fields */ }

Concurrent wrapper (orx_pinned_vec::ConcurrentPinnedVec) for the SplitVec.

Trait Implementations

impl<T, G: GrowthWithConstantTimeAccess> ConcurrentPinnedVec<T> for ConcurrentSplitVec<T, G>

type P = SplitVec<T, G>

Type of the wrapped pinned vector.

unsafe fn into_inner(self, len: usize) -> Self::P

Converts back to the underlying pinned vector with the given length.

unsafe fn clone_with_len(&self, len: usize) -> Self

where T: Clone,

Clones the concurrent pinned vector with for the first len elements. The created concurrent vector will have the same capacity and maximum capacity as this collection; however, only the values within 0..len will be cloned to the target.

fn slices<R: RangeBounds<usize>>( &self, range: R, ) -> <Self::P as PinnedVec<T>>::SliceIter<'_>

Returns an iterator of slices to the elements extending over positions range of the vector.

unsafe fn iter<'a>(&'a self, len: usize) -> impl Iterator<Item = &'a T> + 'a

where T: 'a,

Returns an iterator over positions 0..len of the vector.

unsafe fn iter_over_range<'a, R: RangeBounds<usize>>( &'a self, range: R, ) -> impl Iterator<Item = &'a T> + 'a

where T: 'a,

Returns an iterator over positions range of the vector.

unsafe fn slices_mut<R: RangeBounds<usize>>( &self, range: R, ) -> <Self::P as PinnedVec<T>>::SliceMutIter<'_>

Returns an iterator of mutable slices to the elements extending over positions range of the vector.

unsafe fn iter_mut<'a>( &'a mut self, len: usize, ) -> impl Iterator<Item = &'a mut T> + 'a

where T: 'a,

Returns a mutable iterator over positions 0..len of the vector.

unsafe fn get(&self, index: usize) -> Option<&T>

Returns a reference to the element at the index-th position.

unsafe fn get_mut(&mut self, index: usize) -> Option<&mut T>

Returns a reference to the element at the index-th position.

unsafe fn get_ptr_mut(&self, index: usize) -> *mut T

Returns a mutable reference to the element at the index-th position.

fn max_capacity(&self) -> usize

Returns the maximum possible capacity that the vector can concurrently grow to without requiring a &mut self reference.

fn capacity(&self) -> usize

Returns the current capacity of the vector, which is actually allocated.

fn grow_to(&self, new_capacity: usize) -> Result<usize, PinnedVecGrowthError>

Tries to concurrently grow the capacity of the vector to at least new_capacity. Returns:

fn grow_to_and_fill_with<F>( &self, new_capacity: usize, fill_with: F, ) -> Result<usize, PinnedVecGrowthError>

where F: Fn() -> T,

Tries to concurrently grow the capacity of the vector to at least new_capacity. Returns:

fn fill_with<F>(&self, range: Range<usize>, fill_with: F)

where F: Fn() -> T,

Fills the provided range with elements created by successively calling the fill_with function.

unsafe fn reserve_maximum_concurrent_capacity( &mut self, _current_len: usize, new_maximum_capacity: usize, ) -> usize

Increases the maximum_capacity to the new_maximum_capacity.

unsafe fn reserve_maximum_concurrent_capacity_fill_with<F>( &mut self, current_len: usize, new_maximum_capacity: usize, _fill_with: F, ) -> usize

where F: Fn() -> T,

Increases the maximum_capacity to the new_maximum_capacity. If capacity extension leads to allocation, allocated memory is filled with the given function.

unsafe fn set_pinned_vec_len(&mut self, len: usize)

Sets the length of the underlying pinned vector to the given len.

unsafe fn clear(&mut self, len: usize)

Clears the concurrent pinned vector.

impl<T, G: GrowthWithConstantTimeAccess> Drop for ConcurrentSplitVec<T, G>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, G: GrowthWithConstantTimeAccess> From<SplitVec<T, G>> for ConcurrentSplitVec<T, G>

fn from(value: SplitVec<T, G>) -> Self

Converts to this type from the input type.