Crate copy_arena

A memory allocation arena specialized for types implement Copy.

An Arena can allocate objects more efficiently than a general-purpose allocator, but the objects cannot be deallocated until the Arena itself is destroyed.

To actually allocate out of an Arena after creating it, use its allocator() method to create an Allocator.

Examples

Basic usage works as follows:

use copy_arena::Arena;

let mut arena = Arena::new();
let mut allocator = arena.allocator();

let a: &mut i32 = allocator.alloc(5);
let b: &mut f64 = allocator.alloc_default();
let c: &mut [u8] = allocator.alloc_slice(b"some text");
let b: &mut [usize] = allocator.alloc_slice_fn(10, |idx| idx + 1);
let e: &mut [u32] = allocator.alloc_slice_default(10);

A slightly more realistic use case would be to create a tree without allocating from the heap for each node.

use copy_arena::{Arena, Allocator};

#[derive(Copy, Clone)]
struct Tree<'a> {
    left: Option<&'a Tree<'a>>,
    right: Option<&'a Tree<'a>>,
    content: u32
}

fn build_little_tree<'a>(allocator: &mut Allocator<'a>) -> &'a Tree<'a> {
    let left = allocator.alloc(Tree { left: None, right: None, content: 8 });
    let right = allocator.alloc(Tree { left: None, right: None, content: 16 });
    let parent = allocator.alloc(Tree { left: Some(left), right: Some(right), content: 13 });

    parent
}


let mut arena = Arena::new();
let mut allocator = arena.allocator();

let root = build_little_tree(&mut allocator);
assert_eq!(root.content, 13);
assert_eq!(root.left.unwrap().content, 8);
assert_eq!(root.right.unwrap().content, 16);

Structs

Allocator	Allows allocation out of arena.
Arena	Holds the backing memory for allocated objects out of itself.