Struct AllocVec

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

Simple wrapper for Vec that handles allocating / deallocating slots inside the vector, optimized for frequent indexing and frequent allocations / de-allocations.

The index obtained through allocation is guaranteed to remain the same and won’t be reused until deallocated

Implementations

impl<T> AllocVec<T>

pub const fn new() -> Self

Creates a new AllocVec backed by an empty Vec

pub fn with_capacity(capacity: usize) -> Self

Creates a new AllocVec backed by a Vec with the given capacity

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

Returns an immutable reference to an element at the given position

Arguments

• index - The index of the element

Returns

• Some if the element is present, allocated and not reserved
• None otherwise

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

Returns a mutable reference to an element at the given position

Arguments

• index - The index of the element

Returns

• Some if the element is present, allocated and not reserved
• None otherwise

pub fn into_vec(self) -> Vec<T>

Constructs a new vector containing all the elements of this AllocVec that are allocated and not reserved

pub fn allocate(&mut self, item: T) -> usize

Allocates a space and populates it with item. No guarantees are made about the value of the returned index, except that it will remain valid until deallocated.

Arguments

• item - The item to allocate

Returns

• The index of the newly allocated item

pub fn allocate_cyclic<F>(&mut self, f: F) -> usize

where F: FnOnce(usize) -> T,

Allocates a space and populates it with an item given by the closure f, which will receive the allocation index as a parameter. Useful for items that need to contain information about the index they are allocated in

Arguments

• f - A closure that will receive the index and return the item to populate with

Returns

• The index of the newly allocated space, equal to the index the closure sees

pub fn reserve(&mut self) -> usize

Reserves a space. No guarantees are made about the value of the returned index, except that it will remain valid until deallocated.

Returns

• The index of the newly reserved space

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

Deallocates the space at the given index if it is populated or reserved

Arguments

• index - The index of the space to deallocate

Returns

• Some if the space at the given index was populated
• None otherwise

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

Takes an element out of the space at the given index, possibly downgrading it from populated to just reserved. If this method returns Some, then the space at the given index is to be considered reserved. If None is returned instead, then it might have already been reserved or even unallocated

Arguments

• index - The index of the space whose item is to take

Returns

• Some if the element was populated
• None otherwise

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

Replaces the element in the space at index, with item.

Arguments

• index - The index of the space whose item to replace
• item - The item to replace with

Returns

• Ok if the space is populated or reserved, along with an Option that will be Some in case the space was populated, containing the previous value, None if the space was reserved. After this method returns Ok the space at index is to be considered populated with item.
• Err containing item if the space is unallocated.

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

Arguments

• index - The index of the space to check

Returns

• Whether the space at the given index is populated or reserved

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

Arguments

• index - The index of the space to check

Returns

• Whether the space at the given index is populated and not reserved

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

Arguments

• index - The index of the space to check

Returns

• Whether the space at the given index is reserved and not populated

pub fn len(&self) -> usize

Returns

• The total number of elements that are either reserved or populated

pub fn vec_len(&self) -> usize

Returns

• The length of the underlying Vec

pub fn capacity(&self) -> usize

Returns

• The capacity of the underlying Vec

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

Returns an immutable iterator over the populated spaces that acts in a way similar to .iter().enumerate() except the index actually represents an allocation

pub fn enumerate_mut(&mut self) -> impl Iterator<Item = (usize, &mut T)> + '_

Returns a mutable iterator over the populated spaces that acts in a way similar to .iter().enumerate() except the index actually represents an allocation

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

Returns an immutable iterator over the populated spaces

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

Returns a mutable iterator over the populated spaces

Trait Implementations

impl<T: Clone> Clone for AllocVec<T>

fn clone(&self) -> AllocVec<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> From<Vec<T>> for AllocVec<T>

fn from(value: Vec<T>) -> Self

Converts to this type from the input type.

impl<T> Index<usize> for AllocVec<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 AllocVec<T>

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

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