This Rust module provides a memory allocation Arena for types that
implement Copy.
[Documentation](https://PeterReid.github.io/copy_arena)
# Examples
Basic usage is as follows:
```rust
extern crate copy_arena;
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");
```
This could be used for building a tree structure without heap allocations for each node:
```rust
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
}
#[test]
fn make_tree() {
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);
}
```
# Compared to std::arena::Arena
This differs from the (unstable) Arena in Rust's standard library in
a couple of ways:
- This Arena only supports `Copy`-able objects -- no destructors are
executed.
- This Arena does not use dynamic borrow checking, saving two RefCells
and an Rc before getting to the underlying data to allocate from but
leading to a slightly less convenient API.