Enum arenatree::Arena

pub enum Arena<'a, T: 'a> {
    Owned(Vec<Option<T>>),
    Borrowed(&'a mut Vec<Option<T>>),
}

Arenas are efficient ways of storing trees: All nodes are actually on a flat surface, but have IDs to other nodes.

Variants

Owned(Vec<Option<T>>)

Borrowed(&'a mut Vec<Option<T>>)

Implementations

impl<'a, T> Arena<'a, T>

pub fn new() -> Self

Create a new arena instance

pub fn with_arena(arena: &'a mut Vec<Option<T>>) -> Self

Create a new arena instance that reuses an existing vector

pub fn reference<'b>(&'b mut self) -> Arena<'b, T>

Create a new arena reference that shares the inner vector. This reference will make the existing instance invalid for use while the reference is active.

pub fn into_inner(self) -> Vec<Option<T>>

Return the arena instance

Panics

Panics if this arena instance was created with Borrowed

pub fn get_ref(&self) -> &[Option<T>]

Return a slice pointing to the inner arena representation

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

Return an iterator over the nodes in this arena

pub fn insert(&mut self, elem: T) -> NodeId

Place an element into the arena

pub fn take(&mut self, index: NodeId) -> T

Move out of an element in the arena. This will make following indexing calls on that index panic. This will not deallocate any space. This is due to the fact that all indexes need to stay the same. We could use a different data type instead of a tree to prevent this, but that instead means lookup will be slightly slower.

pub fn ids(&'a self) -> impl Iterator<Item = NodeId> + 'a

Get an iterator over all existing NodeIds in the arena.

Trait Implementations

impl<'a, T> Clone for Arena<'a, T>where
    T: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug + 'a> Debug for Arena<'a, T>

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

Formats the value using the given formatter.

impl<'a, T> Default for Arena<'a, T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> Index<NodeId> for Arena<'a, T>

type Output = T

The returned type after indexing.

fn index(&self, index: NodeId) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, T> IndexMut<NodeId> for Arena<'a, T>

fn index_mut(&mut self, index: NodeId) -> &mut Self::Output

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

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

type Item = &'r T

The type of the elements being iterated over.

type IntoIter = ArenaIter<'r, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.