Struct eightfold::vec::StableVec

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

A vector type with indices stable across removes & inserts, and which reuses deleted indices; comparable to Vec<Option>.

This is very similar to the Slab crate, which we aren’t using because Slab’s Vec entries are at least size_of<usize>() + 1 bytes – since we’re using this primarily to store things smaller than usize, it’s much more efficient to use this.

There’s also a stable-vec crate but that was last updated in 2019, so I think it’s unmaintained.

Honestly, at the moment, I’m not really happy with this. It’s all a bit haphazard.

Implementations

impl<T> StableVec<T>

pub unsafe fn from_parts(
    data: NonNull<MaybeUninit<T>>,
    flags: BitVec,
    cap: usize,
    init_amt: usize,
    farthest_init: Option<usize>
) -> Self

Safety

• data must be allocated
• flags must have length = length of data allocation
• cap = length of data allocation
• init_amt = number of initialized entries in data
• farthest_init = index of initialized value at highest index, or None if no initialized values

pub fn new() -> Self

pub fn farthest_init_index(&self) -> Option<usize>

pub fn with_capacity(cap: usize) -> Self

pub fn spare_slots(&self) -> usize

Get the number of empty spaces within this StableVec

pub fn spare_capacity(&self) -> usize

Get the number of elements that can be added to this StableVec without allocation

pub fn len_init(&self) -> usize

Get the number of initialized elements in the StableVec

pub unsafe fn get_raw_unsafe(&self, index: usize) -> &MaybeUninit<T>

Safety

• index < self.cap

pub unsafe fn get_raw_unsafe_mut(&mut self, index: usize) -> &mut MaybeUninit<T>

Safety

• index < self.cap

pub unsafe fn get_unsafe(&self, index: usize) -> &T

Safety

• index < self.cap
• self[index] must already be initialized

pub unsafe fn get_unsafe_mut(&mut self, index: usize) -> &mut T

Safety

• index < self.cap
• self[index] must already be initialized

pub fn get_unchecked(&self, index: usize) -> &T

pub fn get_unchecked_mut(&mut self, index: usize) -> &mut T

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

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

pub fn clear(&mut self)

Drop everything.

pub fn dealloc(&mut self)

Drop everything and shrink to minimum size.

pub fn shrink_to_fit(&mut self)

pub fn from_vec(data: Vec<T>) -> Self

pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>]

pub fn next_push_index(&self) -> usize

pub fn push(&mut self, data: T) -> usize

pub fn remove(&mut self, index: usize) -> Option<T>

pub fn replace(&mut self, index: usize, data: T) -> Option<T>

pub fn reserve_exact(&mut self, amt: usize)

pub fn reserve(&mut self, amt: usize)

pub fn push_iter<'s, Idx: PrimInt + 'static>(
    &'s mut self,
    iter: impl IntoIterator<Item = T> + 's
) -> impl Iterator<Item = Idx> + 'swhere
    usize: AsPrimitive<Idx>,

pub fn extend_from_iter(
    &mut self,
    iter: impl IntoIterator<Item = T>
) -> Vec<usize>

pub fn extend_from_other(&mut self, other: Self) -> HashMap<usize, usize>

pub unsafe fn prepare_raw_array<'s, const LEN: usize>(
    &'s mut self
) -> [&'s mut MaybeUninit<T>; LEN]

Safety

• Must initialize all returned values

pub fn extend_from_slice_cloned(&mut self, slice: &[T]) -> Vec<usize>where
    T: Clone,

pub fn extend_from_slice_copied(&mut self, slice: &[T]) -> Vec<usize>where
    T: Copy,

pub fn as_uninit_slice(&self) -> &[MaybeUninit<T>]

pub fn as_uninit_slice_mut(&mut self) -> &mut [MaybeUninit<T>]

pub fn iter(&self) -> impl Iterator<Item = &T>

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

pub fn enumerate(&self) -> impl Iterator<Item = (usize, &T)>

pub fn is_init(&self, index: usize) -> bool

pub fn is_fragmented(&self) -> bool

pub unsafe fn swap_unchecked(&mut self, a: usize, b: usize)

Safety

• a < self.cap
• b < self.cap

pub fn swap(&mut self, a: usize, b: usize)

pub fn defragment(&mut self) -> Vec<(usize, usize)>

Partition self such that initialized values are stored contiguously from index 0; return the new locations of each value in the form (from, to).

pub fn compress(&mut self) -> Vec<(usize, usize)>

Defragment & reallocate self such that self.cap == self.init_amt.

pub fn as_slice(&self) -> Option<&[T]>

pub fn as_slice_mut(&mut self) -> Option<&mut [T]>

pub fn init_flags(&self) -> &BitVec

Trait Implementations

impl<T: Copy> Clone for StableVec<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for StableVec<T>

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

Formats the value using the given formatter.

impl<T> Default for StableVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for StableVec<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> FromIterator<T> for StableVec<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> Index<usize> for StableVec<T>

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 StableVec<T>

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

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