Struct object_lib::collections::pvec::PVec

#[repr(C)]
pub struct PVec<T> { /* private fields */ }

A persistable dynamic array type, which is safely movable between runtime instances.

This vector implementation trades off some complexity and space to eliminate internal fragmentation within the object it is stored in. More specifically, it models its buffer as (essentially) a linked list of sections (i.e. fixed-length arrays) of type T. See the corresponding book chapter for more details.

Implementations

impl<T> PVec<T>where T: Persistable,

pub fn new() -> Self

pub fn is_empty(&self) -> bool

fn get_allocator_internal(&self) -> &Arc<RwLock<BumpAllocator>>

pub fn resize_to_capacity(&mut self, capacity: usize)

This call will set the initial capacity of the vector. This should be called with an argument that is (roughly) of the same order-of-magnitude as the expected number of elements this vector is expected to hold at its largest, to minimize the number of sections that will have to be allocated.

pub fn push(&mut self, e: T) -> *mut T

Appends an element to the end of the vector, potentially allocating more space if the current capacity has already been exhausted.

pub fn pop(&mut self) -> Option<T>

Returns the last element from the vector (if not empty).

pub fn push_at(&mut self, e: T, idx: usize)

pub fn last(&self) -> Option<&mut T>

pub fn get_ref(&self, idx: usize) -> Option<*const T>

pub fn truncate(&mut self, len: usize)

Shortens the vector, keeping the first len elements and dropping the rest.

The allocated space of the vector remains unaffected.

pub fn len(&self) -> usize

Returns the number of elements in the vector.

pub fn find<P>(&self, predicate: P) -> Option<usize>where P: Fn(&T) -> bool,

pub fn iter(&self) -> PVecIter<'_, T>

pub fn iter_mut(&mut self) -> PVecIterMut<'_, T>

pub fn buf_offset(&self) -> isize

pub fn get_slice<'a>( &'a self, slice_range: Range<usize> ) -> SegmentedSlice<'a, T>

unsafe fn get_section_marker_for_idx( &self, idx: usize ) -> (*const SectionMarker, usize)

unsafe fn get_section_end_marker( &mut self, marker: *const SectionMarker ) -> *mut SectionMarker

unsafe fn is_last_section(&self, marker: *const SectionMarker) -> bool

unsafe fn get_next_section_marker( &self, marker: *const SectionMarker ) -> Option<*const SectionMarker>

fn elements_in_same_segment(&self, idx_1: usize, idx_2: usize) -> bool

pub unsafe fn get_slice_as_ptr_range<'a>( &'a self, slice_range: Range<usize> ) -> Result<Range<*const T>, usize>

pub unsafe fn copy_from_vec(&mut self, other: &Vec<T>) -> bool

pub fn copy_from_pvec( &mut self, other: &PVec<T>, dst_start_idx: Option<usize>, source_start_idx: Option<usize> ) -> bool

Fast copy between PVec instances.

This method tries to repeatedly memcpy the largest possible chunks of data between two PVec instances, potentially allocating new sections in self. The segmented layout of PVec makes this method necessary if we want to have fast copying.

Trait Implementations

impl<T> Debug for PVec<T>where T: Persistable + Debug + ToString,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Index<usize> for PVec<T>where T: Persistable,

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for PVec<T>where T: Persistable,

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, T> IntoIterator for &'a PVec<T>where T: Persistable,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = PVecIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> Ord for PVec<T>where T: Persistable + Ord,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T> PartialEq for PVec<T>where T: Persistable + PartialEq,

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> PartialOrd for PVec<T>where T: PartialOrd + Persistable,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Persistable for PVec<T>where T: Persistable,

fn adjust_from(&mut self, other: &Self)

Used for object moves.

fn as_bytes(&self) -> &[u8] where Self: Sized,

fn from_bytes(src: *mut [u8]) -> *mut Selfwhere Self: Sized,

fn from_bytes_ref(src: *const [u8]) -> &'static Selfwhere Self: Sized,

impl<T> PersistentlyAllocatable for PVec<T>where T: Persistable,

fn set_allocator(&mut self, allocator: Arc<RwLock<BumpAllocator>>)

Sets the allocator that is going to be used by the PVec instance whenever it needs to extend its internal capacity.

NOTE This needs to be set before any subsequent calls are made that would trigger an allocation.

fn get_allocator(&self) -> Option<Arc<RwLock<BumpAllocator>>>

impl<T> Eq for PVec<T>where T: Persistable + Ord,