Struct triomphe::UniqueArc

#[repr(transparent)]pub struct UniqueArc<T: ?Sized>(_);

An Arc that is known to be uniquely owned

When Arcs are constructed, they are known to be uniquely owned. In such a case it is safe to mutate the contents of the Arc. Normally, one would just handle this by mutating the data on the stack before allocating the Arc, however it's possible the data is large or unsized and you need to heap-allocate it earlier in such a way that it can be freely converted into a regular Arc once you're done.

UniqueArc exists for this purpose, when constructed it performs the same allocations necessary for an Arc, however it allows mutable access. Once the mutation is finished, you can call .shareable() and get a regular Arc out of it.

let data = [1, 2, 3, 4, 5];
let mut x = UniqueArc::new(data);
x[4] = 7; // mutate!
let y = x.shareable(); // y is an Arc<T>

Implementations

impl<T> UniqueArc<T>

pub fn new(data: T) -> Self

Construct a new UniqueArc

pub fn shareable(self) -> Arc<T>

Convert to a shareable Arc once we're done mutating it

pub fn new_uninit() -> UniqueArc<MaybeUninit<T>>

Construct an uninitialized arc

impl<T> UniqueArc<MaybeUninit<T>>

pub unsafe fn assume_init(this: Self) -> UniqueArc<T>

Convert to an initialized Arc.

Safety

This function is equivalent to MaybeUninit::assume_init and has the same safety requirements. You are responsible for ensuring that the T has actually been initialized before calling this method.

Trait Implementations

impl<T> Deref for UniqueArc<T>

type Target = T

The resulting type after dereferencing.

pub fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for UniqueArc<T>

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

Mutably dereferences the value.