Struct ArenaArc 

pub struct ArenaArc<T> { /* private fields */ }

A reference-counting pointer to T in the arena

The type ArenaArc<T> provides shared ownership of a value of type T in the arena.
Invoking Clone on ArenaArc produces a new ArenaArc instance, which points to the same value, while increasing a reference count.

When the last ArenaArc pointer to a given value is dropped, the pointed-to value is also dropped and its dedicated memory in the arena is marked as available for future allocation.

Shared mutable references in Rust is not allowed, if you need to mutate through an ArenaArc, use a Mutex, RwLock or one of the atomic types.

If you don’t need to share the value, you should use ArenaBox.

Cloning references

Creating a new reference from an existing reference counted pointer is done using the Clone trait implemented for ArenaArc<T>

Deref behavior

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

let arena = SharedArena::new();
let my_num: ArenaArc<i64> = arena.alloc_arc(-100i64);

assert!(my_num.is_negative());
assert_eq!(*my_num.clone(), -100);

Trait Implementations

impl<T> Clone for ArenaArc<T>

fn clone(&self) -> ArenaArc<T>

Make a clone of the ArenaArc pointer.

This increase the reference counter.

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

assert_eq!(*my_num, *my_num.clone());

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ArenaArc<T>

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

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

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

impl<T> Deref for ArenaArc<T>

fn deref(&self) -> &T

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

assert!(my_opt.is_some());

type Target = T

The resulting type after dereferencing.

impl<T: Display> Display for ArenaArc<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 ArenaArc<T>

Drop the ArenaArc and decrement its reference counter

If it is the last reference to that value, the value is also dropped

fn drop(&mut self)

let arena = Arena::new();
let my_num = arena.alloc_arc(10);

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

impl<T> Pointer for ArenaArc<T>

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

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

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

impl<T: Send> Send for ArenaArc<T>

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