Struct shared_arena::ArenaBox

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

A pointer to T in the arena

ArenaBox implements DerefMut so it is directly mutable (without mutex or other synchronization methods).

It is not clonable and can be sent to others threads.

Deref & DerefMut behavior

ArenaBox<T> automatically dereferences to T, so you can call T's methods on a value of type ArenaBox<T>.

let arena = SharedArena::new();
let mut my_opt: ArenaBox<Option<i32>> = arena.alloc(Some(10));

assert!(my_opt.is_some());
assert_eq!(my_opt.take(), Some(10));
assert!(my_opt.is_none());

Trait Implementations

impl<T: Debug> Debug for ArenaBox<T>

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

let arena = SharedArena::new();
let my_opt: ArenaBox<Option<i32>> = arena.alloc(Some(10));

println!("{:?}", my_opt);

impl<T> Deref for ArenaBox<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

let arena = SharedArena::new();
let mut my_opt: ArenaBox<Option<i32>> = arena.alloc(Some(10));

assert!(my_opt.is_some());

impl<T> DerefMut for ArenaBox<T>

fn deref_mut(&mut self) -> &mut T

let arena = SharedArena::new();
let mut my_opt: ArenaBox<Option<i32>> = arena.alloc(Some(10));

assert_eq!(my_opt.take(), Some(10));

impl<T: Display> Display for ArenaBox<T>

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

let arena = SharedArena::new();
let my_num = arena.alloc(10);

println!("{}", my_num);

impl<T> Drop for ArenaBox<T>

Drop the ArenaBox

The value pointed by this ArenaBox is also dropped

fn drop(&mut self)

let arena = SharedArena::new();
let mut my_num = arena.alloc(10);

assert_eq!(arena.stats(), (1, 62));
std::mem::drop(my_num);
assert_eq!(arena.stats(), (0, 63));

impl<T> Pointer for ArenaBox<T>

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

let arena = SharedArena::new();
let my_num = arena.alloc(10);

println!("{:p}", my_num);

impl<T: Send> Send for ArenaBox<T>

impl<T: Send + Sync> Sync for ArenaBox<T>