Struct comrak::Arena [−][src]
pub struct Arena<T> { /* fields omitted */ }
Expand description
An arena of objects of type T
.
Example
use typed_arena::Arena; struct Monster { level: u32, } let monsters = Arena::new(); let vegeta = monsters.alloc(Monster { level: 9001 }); assert!(vegeta.level > 9000);
Implementations
Construct a new arena with capacity for n
values pre-allocated.
Example
use typed_arena::Arena; let arena = Arena::with_capacity(1337);
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.
Example
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);
Allocates a value in the arena, and returns a mutable reference to that value.
Example
use typed_arena::Arena; let arena = Arena::new(); let x = arena.alloc(42); assert_eq!(*x, 42);
Uses the contents of an iterator to allocate values in the arena. Returns a mutable slice that contains these values.
Example
use typed_arena::Arena; let arena = Arena::new(); let abc = arena.alloc_extend("abcdefg".chars().take(3)); assert_eq!(abc, ['a', 'b', 'c']);
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.
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.
Convert this Arena
into a Vec<T>
.
Items in the resulting Vec<T>
appear in the order that they were
allocated in.
Example
use typed_arena::Arena; let arena = Arena::new(); arena.alloc("a"); arena.alloc("b"); arena.alloc("c"); let easy_as_123 = arena.into_vec(); assert_eq!(easy_as_123, vec!["a", "b", "c"]);
Returns an iterator that allows modifying each value.
Items are yielded in the order that they were allocated.
Example
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.
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
Auto Trait Implementations
impl<T> !RefUnwindSafe for Arena<T>
impl<T> UnwindSafe for Arena<T> where
T: UnwindSafe,