Struct stack_graphs::arena::SupplementalArena

pub struct SupplementalArena<H, T> { /* fields omitted */ }

A supplemental arena lets you store additional data about some data type that is itself stored in an Arena.

We implement Index and IndexMut for a more ergonomic syntax. Please note that when indexing in an immutable context, we panic if you try to access data for a handle that doesn’t exist in the arena. (Use the get method if you don’t know whether the value exists or not.) In a mutable context, we automatically create a Default instance of the type if there isn’t already an instance for that handle in the arena.

// We need an Arena to create handles.
let mut arena = Arena::<u32>::new();
let handle = arena.add(1);

let mut supplemental = SupplementalArena::<u32, String>::new();

// But indexing will panic if the element doesn't already exist.
// assert_eq!(supplemental[handle].as_str(), "");

// The `get` method is always safe, since it returns an Option.
assert_eq!(supplemental.get(handle), None);

// Once we've added the element to the supplemental arena, indexing
// won't panic anymore.
supplemental[handle] = "hello".to_string();
assert_eq!(supplemental[handle].as_str(), "hello");

Implementations

impl<H, T> SupplementalArena<H, T>

pub fn new() -> SupplementalArena<H, T>

Creates a new, empty supplemental arena.

pub fn with_capacity(arena: &Arena<H>) -> SupplementalArena<H, T>

Creates a new, empty supplemental arena, preallocating enough space to store supplemental data for all of the instances that have already been allocated in a (regular) arena.

pub fn get(&self, handle: Handle<H>) -> Option<&T>

Returns the item belonging to a particular handle, if it exists.

pub fn get_mut(&mut self, handle: Handle<H>) -> Option<&mut T>

Returns a mutable reference to the item belonging to a particular handle, if it exists.

pub fn len(&self) -> usize

Returns the number of instances stored in this arena.

impl<H, T> SupplementalArena<H, T> where
    T: Default, 

pub fn get_mut_or_default(&mut self, handle: Handle<H>) -> &mut T

Returns a mutable reference to the item belonging to a particular handle, creating it first (using the type’s Default implementation) if it doesn’t already exist.

Trait Implementations

impl<H, T> Default for SupplementalArena<H, T>

fn default() -> SupplementalArena<H, T>

Returns the “default value” for a type.

impl<H, T> Drop for SupplementalArena<H, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<H, T> Index<Handle<H>> for SupplementalArena<H, T>

type Output = T

The returned type after indexing.

fn index(&self, handle: Handle<H>) -> &T

Performs the indexing (container[index]) operation.

impl<H, T> IndexMut<Handle<H>> for SupplementalArena<H, T> where
    T: Default, 

fn index_mut(&mut self, handle: Handle<H>) -> &mut T

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