Struct ArenaRc 

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

A single threaded reference-counting pointer to T in the arena.

It cannot be sent between threads.

When the last ArenaRc 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 ArenaRc, 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 ArenaRc<T>

Deref behavior

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

let arena = Arena::new();
let my_num: ArenaRc<i32> = arena.alloc_rc(100i32);

assert!(my_num.is_positive());

let value = 1 + *my_num;
assert_eq!(value, 101);

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

Trait Implementations

impl<T> Clone for ArenaRc<T>

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

Make a clone of the ArenaRc pointer.

This increase the reference counter.

let arena = SharedArena::new();
let my_num = arena.alloc_rc(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 ArenaRc<T>

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

let arena = SharedArena::new();
let my_opt = arena.alloc_rc(Some(10));

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

impl<T> Deref for ArenaRc<T>

fn deref(&self) -> &T

let arena = SharedArena::new();
let my_opt = arena.alloc_rc(Some(10));

assert!(my_opt.is_some());

type Target = T

The resulting type after dereferencing.

impl<T: Display> Display for ArenaRc<T>

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

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

println!("{}", my_num);

impl<T> Drop for ArenaRc<T>

Drop the ArenaRc 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_rc(10);

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

impl<T> Pointer for ArenaRc<T>

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

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

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