Struct UniqueRc

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

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

Available on crate feature std only.

A uniquely owned Rc.

This represents an Rc 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 UniqueRc they point to has been converted into a regular Rc.

Because they are uniquely owned, the contents of a UniqueRc 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 Rc.

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

#![feature(unique_rc_arc)]
use std::rc::{Rc, Weak, UniqueRc};

struct Gadget {
    #[allow(dead_code)]
    me: Weak<Gadget>,
}

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

create_gadget().unwrap();

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

Implementations

impl<T> UniqueRc<T>

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

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

Available on crate feature alloc only.

Creates a new UniqueRc.

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

impl<T, A> UniqueRc<T, A>

where A: Allocator,

pub fn new_in(value: T, alloc: A) -> UniqueRc<T, A>

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

Available on crate feature alloc only.

Creates a new UniqueRc in the provided allocator.

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

impl<T, A> UniqueRc<T, A>

where A: Allocator, T: ?Sized,

pub fn into_rc(this: UniqueRc<T, A>) -> Rc<T, A>

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

Available on crate feature alloc only.

Converts the UniqueRc into a regular Rc.

This consumes the UniqueRc and returns a regular Rc that contains the value that is passed to into_rc.

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

impl<T, A> UniqueRc<T, A>

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

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

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

Available on crate feature alloc only.

Creates a new weak reference to the UniqueRc.

Attempting to upgrade this weak reference will fail before the UniqueRc has been converted to a Rc using UniqueRc::into_rc.

Trait Implementations

impl<T> AsFd for UniqueRc<T>

where T: AsFd + ?Sized,

fn as_fd(&self) -> BorrowedFd<'_>

Borrows the file descriptor.

impl<T, A> AsMut<T> for UniqueRc<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> AsRawFd for UniqueRc<T>

where T: AsRawFd + ?Sized,

fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl<T, A> AsRef<T> for UniqueRc<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 UniqueRc<T, A>

where A: Allocator, T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T, A> BorrowMut<T> for UniqueRc<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 UniqueRc<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 UniqueRc<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 UniqueRc<T, A>

where A: Allocator, T: ?Sized,

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

Mutably dereferences the value.

impl<T, A> Display for UniqueRc<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 UniqueRc<T, A>

where A: Allocator, T: ?Sized,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, A> Hash for UniqueRc<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 UniqueRc<T, A>

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

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

Comparison for two UniqueRcs.

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

Examples

#![feature(unique_rc_arc)]
use std::rc::UniqueRc;
use std::cmp::Ordering;

let five = UniqueRc::new(5);

assert_eq!(Ordering::Less, five.cmp(&UniqueRc::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 UniqueRc<T, A>

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

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

Equality for two UniqueRcs.

Two UniqueRcs are equal if their inner values are equal.

Examples

#![feature(unique_rc_arc)]
use std::rc::UniqueRc;

let five = UniqueRc::new(5);

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

fn ne(&self, other: &UniqueRc<T, A>) -> bool

Inequality for two UniqueRcs.

Two UniqueRcs are not equal if their inner values are not equal.

Examples

#![feature(unique_rc_arc)]
use std::rc::UniqueRc;

let five = UniqueRc::new(5);

assert!(five != UniqueRc::new(6));

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

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

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

Partial comparison for two UniqueRcs.

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

Examples

#![feature(unique_rc_arc)]
use std::rc::UniqueRc;
use std::cmp::Ordering;

let five = UniqueRc::new(5);

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

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

Less-than comparison for two UniqueRcs.

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

Examples

#![feature(unique_rc_arc)]
use std::rc::UniqueRc;

let five = UniqueRc::new(5);

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

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

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

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

Examples

#![feature(unique_rc_arc)]
use std::rc::UniqueRc;

let five = UniqueRc::new(5);

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

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

Greater-than comparison for two UniqueRcs.

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

Examples

#![feature(unique_rc_arc)]
use std::rc::UniqueRc;

let five = UniqueRc::new(5);

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

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

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

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

Examples

#![feature(unique_rc_arc)]
use std::rc::UniqueRc;

let five = UniqueRc::new(5);

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

impl<T, A> Pointer for UniqueRc<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<UniqueRc<U, A>> for UniqueRc<T, A>

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

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

where A: Allocator, T: ?Sized,

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

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

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

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

impl<T, A> PinCoerceUnsized for UniqueRc<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> !Send for UniqueRc<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> !Sync for UniqueRc<T, A>

where A: Allocator, T: ?Sized,

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

where A: Allocator, T: ?Sized,