Struct UniqueArc 

pub struct UniqueArc<T, A = Global>
where
    A: Allocator,
    T: ?Sized,
{ /* private fields */ }

🔬This is a nightly-only experimental API. (unique_rc_arc)

A uniquely owned Arc.

This represents an Arc that is known to be uniquely owned – that is, have exactly one strong reference. Multiple weak pointers can be created, but attempts to upgrade those to strong references will fail unless the UniqueArc they point to has been converted into a regular Arc.

Because it is uniquely owned, the contents of a UniqueArc can be freely mutated. A common use case is to have an object be mutable during its initialization phase but then have it become immutable and converted to a normal Arc.

This can be used as a flexible way to create cyclic data structures, as in the example below.

#![feature(unique_rc_arc)]
use std::sync::{Arc, Weak, UniqueArc};

struct Gadget {
    me: Weak<Gadget>,
}

fn create_gadget() -> Option<Arc<Gadget>> {
    let mut rc = UniqueArc::new(Gadget {
        me: Weak::new(),
    });
    rc.me = UniqueArc::downgrade(&rc);
    Some(UniqueArc::into_arc(rc))
}

create_gadget().unwrap();

An advantage of using UniqueArc over Arc::new_cyclic to build cyclic data structures is that Arc::new_cyclic’s data_fn parameter cannot be async or return a Result. As shown in the previous example, UniqueArc allows for more flexibility in the construction of cyclic data, including fallible or async constructors.

Implementations

impl<T> UniqueArc<T>

pub fn new(value: T) -> UniqueArc<T>

🔬This is a nightly-only experimental API. (unique_rc_arc)

Creates a new UniqueArc.

Weak references to this UniqueArc can be created with UniqueArc::downgrade. Upgrading these weak references will fail before the UniqueArc has been converted into an Arc. After converting the UniqueArc into an Arc, any weak references created beforehand will point to the new Arc.

impl<T, A> UniqueArc<T, A>

where A: Allocator,

pub fn new_in(data: T, alloc: A) -> UniqueArc<T, A>

🔬This is a nightly-only experimental API. (unique_rc_arc)

Creates a new UniqueArc in the provided allocator.

Weak references to this UniqueArc can be created with UniqueArc::downgrade. Upgrading these weak references will fail before the UniqueArc has been converted into an Arc. After converting the UniqueArc into an Arc, any weak references created beforehand will point to the new Arc.

impl<T, A> UniqueArc<T, A>

where A: Allocator, T: ?Sized,

pub fn into_arc(this: UniqueArc<T, A>) -> Arc<T, A>

🔬This is a nightly-only experimental API. (unique_rc_arc)

Converts the UniqueArc into a regular Arc.

This consumes the UniqueArc and returns a regular Arc that contains the value that is passed to into_arc.

Any weak references created before this method is called can now be upgraded to strong references.

impl<T, A> UniqueArc<T, A>

where A: Allocator + Clone, T: ?Sized,

pub fn downgrade(this: &UniqueArc<T, A>) -> Weak<T, A>

🔬This is a nightly-only experimental API. (unique_rc_arc)

Creates a new weak reference to the UniqueArc.

Attempting to upgrade this weak reference will fail before the UniqueArc has been converted to a Arc using UniqueArc::into_arc.

Trait Implementations

impl<T, A> AsMut<T> for UniqueArc<T, A>

where A: Allocator, T: ?Sized,

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, A> AsRef<T> for UniqueArc<T, A>

where A: Allocator, T: ?Sized,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, A> Borrow<T> for UniqueArc<T, A>

where A: Allocator, T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T, A> BorrowMut<T> for UniqueArc<T, A>

where A: Allocator, T: ?Sized,

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

Mutably borrows from an owned value.

impl<T, A> Debug for UniqueArc<T, A>

where T: Debug + ?Sized, A: Allocator,

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

Formats the value using the given formatter.

impl<T, A> Deref for UniqueArc<T, A>

where A: Allocator, T: ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, A> DerefMut for UniqueArc<T, A>

where A: Allocator, T: ?Sized,

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

Mutably dereferences the value.

impl<T, A> Display for UniqueArc<T, A>

where T: Display + ?Sized, A: Allocator,

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

Formats the value using the given formatter.

impl<T, A> Drop for UniqueArc<T, A>

where A: Allocator, T: ?Sized,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, A> Hash for UniqueArc<T, A>

where T: Hash + ?Sized, A: Allocator,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, A> Ord for UniqueArc<T, A>

where T: Ord + ?Sized, A: Allocator,

fn cmp(&self, other: &UniqueArc<T, A>) -> Ordering

Comparison for two UniqueArcs.

The two are compared by calling cmp() on their inner values.

Examples

#![feature(unique_rc_arc)]
use std::sync::UniqueArc;
use std::cmp::Ordering;

let five = UniqueArc::new(5);

assert_eq!(Ordering::Less, five.cmp(&UniqueArc::new(6)));

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T, A> PartialEq for UniqueArc<T, A>

where T: PartialEq + ?Sized, A: Allocator,

fn eq(&self, other: &UniqueArc<T, A>) -> bool

Equality for two UniqueArcs.

Two UniqueArcs are equal if their inner values are equal.

Examples

#![feature(unique_rc_arc)]
use std::sync::UniqueArc;

let five = UniqueArc::new(5);

assert!(five == UniqueArc::new(5));

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, A> PartialOrd for UniqueArc<T, A>

where T: PartialOrd + ?Sized, A: Allocator,

fn partial_cmp(&self, other: &UniqueArc<T, A>) -> Option<Ordering>

Partial comparison for two UniqueArcs.

The two are compared by calling partial_cmp() on their inner values.

Examples

#![feature(unique_rc_arc)]
use std::sync::UniqueArc;
use std::cmp::Ordering;

let five = UniqueArc::new(5);

assert_eq!(Some(Ordering::Less), five.partial_cmp(&UniqueArc::new(6)));

fn lt(&self, other: &UniqueArc<T, A>) -> bool

Less-than comparison for two UniqueArcs.

The two are compared by calling < on their inner values.

Examples

#![feature(unique_rc_arc)]
use std::sync::UniqueArc;

let five = UniqueArc::new(5);

assert!(five < UniqueArc::new(6));

fn le(&self, other: &UniqueArc<T, A>) -> bool

‘Less than or equal to’ comparison for two UniqueArcs.

The two are compared by calling <= on their inner values.

Examples

#![feature(unique_rc_arc)]
use std::sync::UniqueArc;

let five = UniqueArc::new(5);

assert!(five <= UniqueArc::new(5));

fn gt(&self, other: &UniqueArc<T, A>) -> bool

Greater-than comparison for two UniqueArcs.

The two are compared by calling > on their inner values.

Examples

#![feature(unique_rc_arc)]
use std::sync::UniqueArc;

let five = UniqueArc::new(5);

assert!(five > UniqueArc::new(4));

fn ge(&self, other: &UniqueArc<T, A>) -> bool

‘Greater than or equal to’ comparison for two UniqueArcs.

The two are compared by calling >= on their inner values.

Examples

#![feature(unique_rc_arc)]
use std::sync::UniqueArc;

let five = UniqueArc::new(5);

assert!(five >= UniqueArc::new(5));

impl<T, A> Pointer for UniqueArc<T, A>

where A: Allocator, T: ?Sized,

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

Formats the value using the given formatter.

impl<T, U, A> CoerceUnsized<UniqueArc<U, A>> for UniqueArc<T, A>

where T: Unsize<U> + ?Sized, A: Allocator, U: ?Sized,

impl<T, A> DerefPure for UniqueArc<T, A>

where A: Allocator, T: ?Sized,

impl<T, U> DispatchFromDyn<UniqueArc<U>> for UniqueArc<T>

where T: Unsize<U> + ?Sized, U: ?Sized,

impl<T, A> Eq for UniqueArc<T, A>

where T: Eq + ?Sized, A: Allocator,

impl<T> PinCoerceUnsized for UniqueArc<T>

where T: ?Sized,

impl<T, A> Send for UniqueArc<T, A>

where T: Sync + Send + ?Sized, A: Allocator + Send,

impl<T, A> Sync for UniqueArc<T, A>

where T: Sync + Send + ?Sized, A: Allocator + Sync,

impl<T, A> Unpin for UniqueArc<T, A>

where A: Allocator, T: ?Sized,