Struct servo_arc::UniqueArc

pub struct UniqueArc<T: ?Sized>(pub(crate) Arc<T>);

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.

Ignore the doctest below there’s no way to skip building with refcount logging during doc tests (see rust-lang/rust#45599).

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>

Tuple Fields

0: Arc<T>

Implementations

impl<T> UniqueArc<T>

pub fn new(data: T) -> Self

Construct a new UniqueArc

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

Construct an uninitialized arc

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

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

impl<T> UniqueArc<MaybeUninit<T>>

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

Convert to an initialized Arc.

impl<H, T> UniqueArc<HeaderSlice<H, T>>

pub fn from_header_and_iter<I>(header: H, items: I) -> Self

where I: Iterator<Item = T> + ExactSizeIterator,

pub fn from_header_and_iter_with_size<I>( header: H, items: I, num_items: usize, ) -> Self

where I: Iterator<Item = T>,

pub fn header_mut(&mut self) -> &mut H

Returns a mutable reference to the header.

pub fn data_mut(&mut self) -> &mut [T]

Returns a mutable reference to the slice.

Trait Implementations

impl<T> Deref for UniqueArc<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for UniqueArc<T>

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

Mutably dereferences the value.