Struct libreda_db::slab_alloc::SlabAlloc

pub struct SlabAlloc<T, IndexType = u32, IdType = u32> {
    data: Vec<Element<IdType, T>>,
    free_indices: Vec<IndexType>,
    len: usize,
}

Container which efficiently allocates space for its elements.

Fields

data: Vec<Element<IdType, T>>

free_indices: Vec<IndexType>

len: usize

Number of elements currently in the map.

Implementations

impl<T, IndexType, IdType> SlabAlloc<T, IndexType, IdType> where
    IndexType: PrimInt + Unsigned + ToPrimitive + FromPrimitive,
    IdType: PrimInt + Unsigned, 

pub fn new() -> Self

Create an empty container.

pub fn get(&self, index: SlabIndex<IndexType, IdType>) -> Option<&T>

Access an element.

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

Access an element.

pub fn contains_key(&self, index: SlabIndex<IndexType, IdType>) -> bool

pub fn insert(&mut self, value: T) -> SlabIndex<IndexType, IdType>

Insert an element and return the index of it.

Panics

Panics when the amount of indices is exhausted. This happens when there are already IndexType::max_value() elements in the container.

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

Allocate space to hold n elements.

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

Remove an element.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn shrink(&mut self)

Reclaim as much space as possible.

pub fn clear(&mut self)

Drop all data.

pub fn iter(&self) -> impl Iterator<Item = (SlabIndex<IndexType, IdType>, &T)>

Iterate over all key-value pairs.

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

Iterate over all key-value pairs.

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

Iterate over all values in the map.

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

Iterate over all mutable values in the map.

pub fn keys(&self) -> impl Iterator<Item = SlabIndex<IndexType, IdType>> + '_

Iterate over all keys in the map.

Trait Implementations

impl<T: Clone, IndexType: Clone, IdType: Clone> Clone for SlabAlloc<T, IndexType, IdType>

fn clone(&self) -> SlabAlloc<T, IndexType, IdType>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, IndexType: Debug, IdType: Debug> Debug for SlabAlloc<T, IndexType, IdType>

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

Formats the value using the given formatter.

impl<T: Default, IndexType: Default, IdType: Default> Default for SlabAlloc<T, IndexType, IdType>

fn default() -> SlabAlloc<T, IndexType, IdType>

Returns the “default value” for a type.

impl<'de, T, IndexType, IdType> Deserialize<'de> for SlabAlloc<T, IndexType, IdType> where
    T: Deserialize<'de>,
    IndexType: Deserialize<'de>,
    IdType: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T, IndexType, IdType> Serialize for SlabAlloc<T, IndexType, IdType> where
    T: Serialize,
    IndexType: Serialize,
    IdType: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.