Struct dcc_lsystem::arena::Arena

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

A simple arena wrapping around a Vec.

Examples

use dcc_lsystem::Arena;

let mut arena = Arena::new();

let u = arena.push(1);
let v = arena.push(2);

assert_eq!(arena.len(), 2);
assert_eq!(arena.get(u), Some(&1));

Methods

impl<T> Arena<T>

pub fn new() -> Self

Creates a new empty arena.

Example

use dcc_lsystem::Arena;

let mut arena = Arena::new();

arena.push(1);
arena.push(3);

pub fn len(&self) -> usize

Returns the length of this arena.

Example

use dcc_lsystem::Arena;

let mut arena = Arena::new();

for i in 0..420 {
    arena.push(i);
}

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

pub fn is_empty(&self) -> bool

Returns true if the arena contains no elements.

Example

use dcc_lsystem::Arena;

let mut arena = Arena::new();

assert!(arena.is_empty());

arena.push(3);

assert!(!arena.is_empty());

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

Returns a reference to an entry of the arena, if the provided ArenaId is valid.

Example

use dcc_lsystem::Arena;

let mut arena = Arena::new();

let x = arena.push("x");
let y = arena.push("y");
let z = arena.push("z");

assert_eq!(arena.get(y), Some(&"y"));

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

Returns a mutable reference to the entry corresponding to the given index.

Example

use dcc_lsystem::Arena;

let mut arena = Arena::new();

let x = arena.push("x");

if let Some(entry) = arena.get_mut(x) {
    *entry = "y";
}

assert_eq!(arena.get(x), Some(&"y"));

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

Returns an iterator over this arena.

Example

use dcc_lsystem::Arena;

let mut arena = Arena::new();
let x = arena.push(3);
let y = arena.push(5);

let mut iterator = arena.iter();

assert_eq!(iterator.next(), Some(&3));
assert_eq!(iterator.next(), Some(&5));
assert_eq!(iterator.next(), None)

pub fn iter_mut(&mut self) -> IterMut<T>

Returns an iterator that allows modifying each value.

Example

use dcc_lsystem::Arena;

let mut arena = Arena::new();
let x = arena.push(3);
let y = arena.push(-4);

for entry in arena.iter_mut() {
    *entry = *entry * *entry;
}

let mut iterator = arena.iter();

assert_eq!(iterator.next(), Some(&9));
assert_eq!(iterator.next(), Some(&16));

pub fn is_valid(&self, id: ArenaId) -> bool

Returns true if the provided id corresponds to an element of this arena.

use dcc_lsystem::{Arena, ArenaId};

let mut arena = Arena::new();
let x = arena.push(17);
let y = arena.push(21);

assert!(arena.is_valid(x));
assert!(arena.is_valid(y));

assert!(!arena.is_valid(ArenaId(2)));

pub fn is_valid_slice(&self, slice: &[ArenaId]) -> bool

Returns true if the every id in the provided slice is valid.

Example

use dcc_lsystem::{Arena, ArenaId};

let mut arena = Arena::new();
let x = arena.push(1);
let y = arena.push(3);
let z = arena.push(7);

assert!(arena.is_valid_slice(&[x,y]));
assert!(arena.is_valid_slice(&[x,y,z]));
assert!(!arena.is_valid_slice(&[x,y,ArenaId(3)]));

pub fn push(&mut self, value: T) -> ArenaId

Add a new value to our arena.

Returns an ArenaId which uniquely identifies this element of the arena.

Example

use dcc_lsystem::Arena;

let mut arena = Arena::new(); let x = arena.push(11); let y = arena.push(-3);

assert_eq!(x, ArenaId(0)); assert_eq!(y, ArenaId(1));

Important traits for EnumerableArena<'a, T>

impl<'a, T> Iterator for EnumerableArena<'a, T> type Item = (ArenaId, &'a T);

pub fn enumerate(&self) -> EnumerableArena<T>

Returns an EnumerableArena.

Example

use dcc_lsystem::Arena;

let mut arena = Arena::new();
let x = arena.push(3);
let y = arena.push(5);
let z = arena.push(-7);

for (id, entry) in arena.enumerate() {
    /* do some work here */
}

impl Arena<Token>

pub fn render(&self, tokens: &[ArenaId]) -> String

Returns a string representation of the given slice of ArenaId's in terms of the contents of this arena.

Trait Implementations

impl<T: Clone> Clone for Arena<T>

fn clone(&self) -> Arena<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Default for Arena<T>

fn default() -> Self

Returns the "default value" for a type.

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

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

Formats the value using the given formatter.