Struct UniqueRc

pub struct UniqueRc<T: ?Sized, A: Allocator = Global> { pub(in ::rcs::rc) ptr: NonNull<RcInner<T>>, pub(in ::rcs::rc) _marker: PhantomData<RcInner<T>>, pub(in ::rcs::rc) _marker2: PhantomData<*mut T>, pub(in ::rcs::rc) alloc: A }

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.

Fields

ptr: NonNull<RcInner<T>>
_marker: PhantomData<RcInner<T>>
_marker2: PhantomData<*mut T>
alloc: A

Implementations

impl<T> UniqueRc<T>

fn new(value: T) -> Self

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.

fn try_new(value: T) -> Result<Self, AllocError>

Like new, but returns an error if the allocation fails, instead of calling handle_alloc_error.

impl<T, A: Allocator> UniqueRc<MaybeUninit<T>, A>

fn write(this: Self, value: T) -> UniqueRc<T, A>

Writes the value and converts to UniqueRc<T, A>.

This method converts similarly to assume_init but writes value into it before conversion, thus guaranteeing safety.

unsafe fn assume_init(self) -> UniqueRc<T, A>

Converts to UniqueRc<T, A>.

Safety

As with MaybeUninit::assume_init, it is up to the caller to guarantee that the value really is in an initialized state. Calling this when the content is not yet fully initialized causes immediate undefined behavior.

impl<T, A: Allocator> UniqueRc<T, A>

fn new_in(value: T, alloc: A) -> Self

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.

fn try_new_in(value: T, alloc: A) -> Result<Self, AllocError>

Like new_in, but returns an error if the allocation fails, instead of calling handle_alloc_error.

fn unwrap_with_allocator(this: Self) -> (T, A)

Consumes the UniqueRc, returning its wrapped value and allocator.

fn unwrap(this: Self) -> T

Consumes the UniqueRc, returning its wrapped value.

fn map<U>(this: Self, f: impl FnOnce(T) -> U) -> UniqueRc<U, A>

Maps the value in a UniqueRc, reusing the allocation if possible.

f is called on a reference to the value in the UniqueRc, and the result is returned, also in a UniqueRc.

Note: this is an associated function, which means that you have to call it as UniqueRc::map(u, f) instead of u.map(f). This is so that there is no conflict with a method on the inner type.

Examples

#![feature(unique_rc_arc)]

use std::rc::UniqueRc;

let r = UniqueRc::new(7);
let new = UniqueRc::map(r, |i| i + 7);
assert_eq!(*new, 14);

fn try_map<R>(this: Self, f: impl FnOnce(T) -> R) -> <R::Residual as Residual<UniqueRc<R::Output, A>>>::TryType
where
    R: Try,
    R::Residual: Residual<UniqueRc<R::Output, A>>,

Attempts to map the value in a UniqueRc, reusing the allocation if possible.

f is called on a reference to the value in the UniqueRc, and if the operation succeeds, the result is returned, also in a UniqueRc.

Note: this is an associated function, which means that you have to call it as UniqueRc::try_map(u, f) instead of u.try_map(f). This is so that there is no conflict with a method on the inner type.

Examples

#![feature(smart_pointer_try_map)]
#![feature(unique_rc_arc)]

use std::rc::UniqueRc;

let b = UniqueRc::new(7);
let new = UniqueRc::try_map(b, u32::try_from).unwrap();
assert_eq!(*new, 7);

impl<T: ?Sized, A: Allocator> UniqueRc<T, A>

unsafe fn from_raw_with_allocator(ptr: *const T, alloc: A) -> Self
fn into_raw_with_allocator(this: Self) -> (*const T, A)
fn into_rc(this: Self) -> Rc<T, A>

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.

fn weak_count(this: &Self) -> usize
fn inner(&self) -> &RcInner<T>
fn as_ptr(this: &Self) -> *const T
fn into_inner_with_allocator(this: Self) -> (NonNull<RcInner<T>>, A)
unsafe fn from_inner_in(ptr: NonNull<RcInner<T>>, alloc: A) -> Self

impl<T: ?Sized, A: AllocatorClone> UniqueRc<T, A>

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

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> From<T> for UniqueRc<T>

fn from(value: T) -> Self

impl<T: ?Sized + Debug, A: Allocator> Debug for UniqueRc<T, A>

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

impl<T: ?Sized + Display, A: Allocator> Display for UniqueRc<T, A>

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

impl<T: ?Sized + Eq, A: Allocator> Eq for UniqueRc<T, A>

impl<T: ?Sized + Hash, A: Allocator> Hash for UniqueRc<T, A>

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

impl<T: ?Sized + Ord, A: Allocator> Ord for UniqueRc<T, A>

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)));

impl<T: ?Sized + PartialEq, A: Allocator> PartialEq for UniqueRc<T, A>

fn eq(&self, other: &Self) -> 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: &Self) -> 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: ?Sized + PartialOrd, A: Allocator> PartialOrd for UniqueRc<T, A>

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: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<UniqueRc<U>> for UniqueRc<T>

impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<UniqueRc<U, A>> for UniqueRc<T, A>

impl<T: ?Sized, A: Allocator> !Send for UniqueRc<T, A>

impl<T: ?Sized, A: Allocator> !Sync for UniqueRc<T, A>

impl<T: ?Sized, A: Allocator> AsMut<T> for UniqueRc<T, A>

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

impl<T: ?Sized, A: Allocator> AsRef<T> for UniqueRc<T, A>

fn as_ref(&self) -> &T

impl<T: ?Sized, A: Allocator> Borrow<T> for UniqueRc<T, A>

fn borrow(&self) -> &T

impl<T: ?Sized, A: Allocator> BorrowMut<T> for UniqueRc<T, A>

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

impl<T: ?Sized, A: Allocator> Deref for UniqueRc<T, A>

type Target = T;
fn deref(&self) -> &T

impl<T: ?Sized, A: Allocator> DerefMut for UniqueRc<T, A>

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

impl<T: ?Sized, A: Allocator> DerefPure for UniqueRc<T, A>

impl<T: ?Sized, A: Allocator> Drop for UniqueRc<T, A>

fn drop(&mut self)

impl<T: ?Sized, A: Allocator> Pointer for UniqueRc<T, A>

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

impl<T: ?Sized, A: Allocator> Unpin for UniqueRc<T, A>

impl<T: ?Sized, A: StaticAllocator> PinSafePointer for UniqueRc<T, A>

Auto Trait Implementations

impl<T, A = Global> !RefUnwindSafe for UniqueRc<T, A>

impl<T, A = Global> !UnwindSafe for UniqueRc<T, A>

impl<T, A> Freeze for UniqueRc<T, A> where NonNull<RcInner<T>>: Freeze, PhantomData<RcInner<T>>: Freeze, PhantomData<*mut T>: Freeze, A: Freeze, T: ?Sized,

impl<T, A> UnsafeUnpin for UniqueRc<T, A> where NonNull<RcInner<T>>: UnsafeUnpin, PhantomData<RcInner<T>>: UnsafeUnpin, PhantomData<*mut T>: UnsafeUnpin, A: UnsafeUnpin, T: ?Sized,

Blanket Implementations

impl<P, T> Receiver for UniqueRc<T, A> where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T;

impl<T> Any for UniqueRc<T, A> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for UniqueRc<T, A> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for UniqueRc<T, A> where T: ?Sized,

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

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

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SizeHint for UniqueRc<T, A> where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

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

impl<T> ToString for UniqueRc<T, A> where T: Display + ?Sized,

fn to_string(&self) -> String

impl<T, U> Into<U> for UniqueRc<T, A> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for UniqueRc<T, A> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for UniqueRc<T, A> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>