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 allocated at the index
• 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 allocated at the index
• None otherwise

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

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

pub fn alloc(&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 alloc_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 dealloc(&mut self, index: usize) -> Option<T>

Deallocates the space at the given index if it is allocated.

Arguments

• index - The index of the space to deallocate

Returns

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

pub fn realloc(&mut self, index: usize, item: T) -> Result<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<T> if the space was allocated, where T is the previous value. After this method returns Ok the space at index is to be considered populated with item.
• Err containing item if the space was unallocated.

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

Arguments

• index - The index of the space to check

Returns

• Whether an element is allocated at the given index

pub fn len(&self) -> usize

Returns

• The total number of allocated elements

pub fn is_empty(&self) -> bool

Returns

• True if there are no allocated elements

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_mut().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

pub fn clear(&mut self)

Clears the allocvec, removing all values and resetting the internal linked list.

Allocations will begin at index 0 again after this.

impl<T: Eq> AllocVec<T>

pub fn contains(&self, value: &T) -> bool

Iterates through the vector searching for a slot that’s populated with an item that is equal to the provided value.

Requires T to implement Eq

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: Debug> Debug for AllocVec<T>

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

Formats the value using the given formatter.

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.