Struct id_arena::Arena

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

An arena of objects of type T.

let mut arena = id_arena::Arena::new();

let a = arena.alloc("Albert");
assert_eq!(arena[a], "Albert");

arena[a] = "Alice";
assert_eq!(arena[a], "Alice");

Implementations

impl<T> Arena<T>

pub fn new() -> Arena<T>

Construct a new, empty Arena.

let mut arena = id_arena::Arena::new();
arena.alloc(42);

pub fn alloc(&mut self, item: T) -> Id<T>

Allocate item within this arena and return its id.

let mut arena = id_arena::Arena::new();
arena.alloc(42);

pub fn get(&self, id: Id<T>) -> Option<&T>

Get a shared reference to the object associated with the given id if it exists.

If there is no object associated with id (for example, it might reference an object allocated within a different arena) then return None.

let mut arena = id_arena::Arena::new();
let id = arena.alloc(42);
assert!(arena.get(id).is_some());

let other_arena = id_arena::Arena::new();
assert!(other_arena.get(id).is_none());

pub fn get_mut(&mut self, id: Id<T>) -> Option<&mut T>

Get an exclusive reference to the object associated with the given id if it exists.

If there is no object associated with id (for example, it might reference an object allocated within a different arena) then return None.

let mut arena = id_arena::Arena::new();
let id = arena.alloc(42);
assert!(arena.get_mut(id).is_some());

let mut other_arena = id_arena::Arena::new();
assert!(other_arena.get_mut(id).is_none());

pub fn iter(&self) -> Iter<'_, T>

Iterate over this arena’s items and their ids.

let mut arena = id_arena::Arena::new();
arena.alloc("hello");
arena.alloc("hi");
arena.alloc("yo");

for (id, s) in arena.iter() {
    assert_eq!(arena.get(id).unwrap(), s);
    println!("{:?} -> {}", id, s);
}

pub fn len(&self) -> usize

Get the number of objects allocated in this arena.

let mut arena = id_arena::Arena::new();
arena.alloc("hello");
arena.alloc("hi");

assert_eq!(arena.len(), 2);

Trait Implementations

impl<T: Debug> Debug for Arena<T>

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

Formats the value using the given formatter.

impl<T> Default for Arena<T>

fn default() -> Arena<T>

Returns the “default value” for a type.

impl<T> Index<Id<T>> for Arena<T>

type Output = T

The returned type after indexing.

fn index(&self, id: Id<T>) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<Id<T>> for Arena<T>

fn index_mut(&mut self, id: Id<T>) -> &mut T

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

impl<'a, T> IntoIterator for &'a Arena<T>

type Item = (Id<T>, &'a T)

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.