Struct generational_cache::arena::Arena

pub struct Arena<V, T> { /* private fields */ }

A generational arena for allocating memory based off a vector. Every entry is associated with a generation counter to uniquely identify newer allocations from older reclaimed allocations at the same position in the vector.

This is inspired from the crate “generational-arena”

Usage

#[no_std]

use generational_cache::prelude::*;

const CAPACITY: usize = 5;

let mut arena = Arena::<_, i32>::with_vector(Array::<_, CAPACITY>::new());
let index = arena.insert(78).unwrap(); // allocate new element in arena
let i_ref = arena.get(&index);
assert_eq!(i_ref, Some(&78));
let i_m_ref = arena.get_mut(&index).unwrap();
*i_m_ref = -68418;
assert_eq!(arena.get(&index), Some(&-68418));

arena.remove(&index).unwrap();

assert!(arena.get(&index).is_none());

Implementations

impl<V, T> Arena<V, T>

where V: Vector<Entry<T>>,

A generational arena.

pub fn reserve(&mut self, additional: usize) -> Result<(), ArenaError<V::Error>>

Reserves space for the given number of additional items in this arena.

pub fn clear(&mut self) -> Result<(), ArenaError<V::Error>>

Removes all items from this arena and reclaims all allocated memory.

pub fn with_vector(vector: V) -> Self

Creates an Arena instance with the given Vector implemenation instance as the backing memory.

pub fn insert(&mut self, item: T) -> Result<Index, ArenaError<V::Error>>

Allocates space for the given items and inserts it into this arena.

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

Reclaims the allocated space for the item at the given index and removes it from the arena.

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

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

pub fn capacity(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize