[][src]Struct typed_arena::Arena

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

An arena of objects of type T.


use typed_arena::Arena;

struct Monster {
    level: u32,

let monsters = Arena::new();

let vegeta = monsters.alloc(Monster { level: 9001 });
assert!(vegeta.level > 9000);


impl<T> Arena<T>[src]

pub fn new() -> Arena<T>[src]

Construct a new arena.


use typed_arena::Arena;

let arena = Arena::new();

pub fn with_capacity(n: usize) -> Arena<T>[src]

Construct a new arena with capacity for n values pre-allocated.


use typed_arena::Arena;

let arena = Arena::with_capacity(1337);

pub fn len(&self) -> usize[src]

Return the size of the arena

This is useful for using the size of previous typed arenas to build new typed arenas with large enough spaces.


 use typed_arena::Arena;

 let arena = Arena::with_capacity(0);
 let a = arena.alloc(1);
 let b = arena.alloc(2);

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

pub fn alloc(&self, value: T) -> &mut T[src]

Allocates a value in the arena, and returns a mutable reference to that value.


use typed_arena::Arena;

let arena = Arena::new();
let x = arena.alloc(42);
assert_eq!(*x, 42);

pub fn alloc_extend<I>(&self, iterable: I) -> &mut [T] where
    I: IntoIterator<Item = T>, 

Uses the contents of an iterator to allocate values in the arena. Returns a mutable slice that contains these values.


use typed_arena::Arena;

let arena = Arena::new();
let abc = arena.alloc_extend("abcdefg".chars().take(3));
assert_eq!(abc, ['a', 'b', 'c']);

pub unsafe fn alloc_uninitialized(&self, num: usize) -> *mut [T][src]

Allocates space for a given number of values, but doesn't initialize it.

Unsafety and Undefined Behavior

The same caveats that apply to std::mem::uninitialized apply here:

This is incredibly dangerous and should not be done lightly. Deeply consider initializing your memory with a default value instead.

In particular, it is easy to trigger undefined behavior by allocating uninitialized values, failing to properly initialize them, and then the Arena will attempt to drop them when it is dropped. Initializing an uninitialized value is trickier than it might seem: a normal assignment to a field will attempt to drop the old, uninitialized value, which almost certainly also triggers undefined behavior. You must also consider all the places where your code might "unexpectedly" drop values earlier than it "should" because of unwinding during panics.

pub fn uninitialized_array(&self) -> *mut [T][src]

Returns unused space.

This unused space is still not considered "allocated". Therefore, it won't be dropped unless there are further calls to alloc, alloc_uninitialized, or alloc_extend which is why the method is safe.

pub fn into_vec(self) -> Vec<T>[src]

Convert this Arena into a Vec<T>.

Items in the resulting Vec<T> appear in the order that they were allocated in.


use typed_arena::Arena;

let arena = Arena::new();


let easy_as_123 = arena.into_vec();

assert_eq!(easy_as_123, vec!["a", "b", "c"]);

Important traits for IterMut<'a, T>
pub fn iter_mut(&mut self) -> IterMut<T>[src]

Returns an iterator that allows modifying each value.

Items are yielded in the order that they were allocated.


use typed_arena::Arena;

#[derive(Debug, PartialEq, Eq)]
struct Point { x: i32, y: i32 };

let mut arena = Arena::new();

arena.alloc(Point { x: 0, y: 0 });
arena.alloc(Point { x: 1, y: 1 });

for point in arena.iter_mut() {
    point.x += 10;

let points = arena.into_vec();

assert_eq!(points, vec![Point { x: 10, y: 0 }, Point { x: 11, y: 1 }]);

Immutable Iteration

Note that there is no corresponding iter method. Access to the arena's contents requries mutable access to the arena itself.

This example deliberately fails to compile
use typed_arena::Arena;

let mut arena = Arena::new();
let x = arena.alloc(1);

// borrow error!
for i in arena.iter_mut() {
    println!("i: {}", i);

// borrow error!
*x = 2;

Trait Implementations

impl<T> Default for Arena<T>[src]

Auto Trait Implementations

impl<T> Send for Arena<T> where
    T: Send

impl<T> !Sync for Arena<T>

impl<T> Unpin for Arena<T> where
    T: Unpin

impl<T> UnwindSafe for Arena<T> where
    T: UnwindSafe

impl<T> !RefUnwindSafe for Arena<T>

Blanket Implementations

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T> From<T> for T[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> Any for T where
    T: 'static + ?Sized