Struct SparseArray

pub struct SparseArray<'a, T> { /* private fields */ }

Sparse array of T.

Can operate with less memory than a FixedVec of the same length, since the array length and the backing T storage have separate capacities. Useful for cases where stable indices are important, but having the entire array in-memory is infeasible.

Implementations

impl<T> SparseArray<'_, T>

pub fn new<'a>( allocator: &'a LinearAllocator<'_>, array_len: u32, loaded_len: u32, ) -> Option<SparseArray<'a, T>>

Creates a new sparse array of T with length array_len, allowing for loaded_len elements to be loaded at a time.

pub fn increment_ages(&mut self)

Increments the age of each loaded element.

These ages are used to determine which elements get discarded first when calling SparseArray::insert. SparseArray::get resets the age of the returned element.

pub fn unload(&mut self, index: u32)

Removes the value from the index, freeing space for another value to be inserted anywhere.

pub fn insert( &mut self, index: u32, init_fn: impl FnOnce() -> Option<T>, ) -> Option<&mut T>

Allocates space for the index, returning a mutable borrow to fill it with.

If reusing an old unloaded T is not possible, but there’s and a new T needs to be created, init_fn is used. init_fn can fail by returning None, in which case nothing else happens and None is returned.

If the backing memory is full, the least recently used T is assigned to this index and returned, implicitly “unloading the value at its old index.”

If the backing memory is full, and every T has been used since the last call to SparseArray::increment_ages, this returns None.

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

Returns the value at the index if it’s loaded.

pub fn array_len(&self) -> usize

Returns the length of the whole array (not the amount of loaded elements).