pub struct UniqueArc<T, A = Global>where
A: Allocator,
T: ?Sized,{ /* private fields */ }
unique_rc_arc #112566)
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.
impl<T> UniqueArc<T>
pub fn new(value: T) -> UniqueArc<T>
unique_rc_arc #112566)
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.
pub fn map<U>(this: UniqueArc<T>, f: impl FnOnce(T) -> U) -> UniqueArc<U>
smart_pointer_try_map #144419)
Maps the value in a UniqueArc, reusing the allocation if possible.
f is called on a reference to the value in the UniqueArc, and the result is returned, also in a UniqueArc.
Note: this is an associated function, which means that you have to call it as UniqueArc::map(u, f) instead of u.map(f). This is so that there is no conflict with a method on the inner type.
#![feature(smart_pointer_try_map)] #![feature(unique_rc_arc)] use std::sync::UniqueArc; let r = UniqueArc::new(7); let new = UniqueArc::map(r, |i| i + 7); assert_eq!(*new, 14);
pub fn try_map<R>(
this: UniqueArc<T>,
f: impl FnOnce(T) -> R,
) -> <<R as Try>::Residual as Residual<UniqueArc<<R as Try>::Output>>>::TryTypewhere
R: Try,
<R as Try>::Residual: Residual<UniqueArc<<R as Try>::Output>>,smart_pointer_try_map #144419)
Attempts to map the value in a UniqueArc, reusing the allocation if possible.
f is called on a reference to the value in the UniqueArc, and if the operation succeeds, the result is returned, also in a UniqueArc.
Note: this is an associated function, which means that you have to call it as UniqueArc::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.
#![feature(smart_pointer_try_map)] #![feature(unique_rc_arc)] use std::sync::UniqueArc; let b = UniqueArc::new(7); let new = UniqueArc::try_map(b, u32::try_from).unwrap(); assert_eq!(*new, 7);
impl<T, A> UniqueArc<T, A>where
A: Allocator,pub fn new_in(data: T, alloc: A) -> UniqueArc<T, A>
unique_rc_arc #112566)
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>
unique_rc_arc #112566)
impl<T, A> UniqueArc<T, A>where
A: Allocator + Clone,
T: ?Sized,pub fn downgrade(this: &UniqueArc<T, A>) -> Weak<T, A>
unique_rc_arc #112566)
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.
impl<T, A> AsMut<T> for UniqueArc<T, A>where
A: Allocator,
T: ?Sized,fn as_mut(&mut self) -> &mut T
impl<T, A> AsRef<T> for UniqueArc<T, A>where
A: Allocator,
T: ?Sized,fn as_ref(&self) -> &T
impl<T, A> Borrow<T> for UniqueArc<T, A>where
A: Allocator,
T: ?Sized,impl<T, A> BorrowMut<T> for UniqueArc<T, A>where
A: Allocator,
T: ?Sized,impl<T, A> Debug for UniqueArc<T, A>where
T: Debug + ?Sized,
A: Allocator,fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
impl<T, A> Deref for UniqueArc<T, A>where
A: Allocator,
T: ?Sized,type Target = T
fn deref(&self) -> &T
impl<T, A> DerefMut for UniqueArc<T, A>where
A: Allocator,
T: ?Sized,fn deref_mut(&mut self) -> &mut T
impl<T, A> Display for UniqueArc<T, A>where
T: Display + ?Sized,
A: Allocator,fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
impl<T, A> Drop for UniqueArc<T, A>where
A: Allocator,
T: ?Sized,impl<T, A> Hash for UniqueArc<T, A>where
T: Hash + ?Sized,
A: Allocator,fn hash<H>(&self, state: &mut H)where
H: Hasher,fn hash_slice<H>(data: &[Self], state: &mut H)where
H: Hasher,
Self: Sized,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.
#![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) -> Selfwhere
Self: Sized,fn min(self, other: Self) -> Selfwhere
Self: Sized,fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized,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.
#![feature(unique_rc_arc)] use std::sync::UniqueArc; let five = UniqueArc::new(5); assert!(five == UniqueArc::new(5));
fn ne(&self, other: &Rhs) -> bool
!=. 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.
#![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.
#![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.
#![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.
#![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.
#![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>
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,impl<T, A> Freeze for UniqueArc<T, A>where
A: Freeze,
T: ?Sized,impl<T, A> RefUnwindSafe for UniqueArc<T, A>where
A: RefUnwindSafe,
T: RefUnwindSafe + ?Sized,impl<T, A> UnwindSafe for UniqueArc<T, A>where
A: UnwindSafe,
T: RefUnwindSafe + UnwindSafe + ?Sized,impl<T> Any for Twhere
T: 'static + ?Sized,impl<T> Borrow<T> for Twhere
T: ?Sized,impl<T> BorrowMut<T> for Twhere
T: ?Sized,impl<T> From<T> for T
fn from(t: T) -> T
Returns the argument unchanged.
impl<T, U> Into<U> for Twhere
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<P, T> Receiver for Pwhere
P: Deref<Target = T> + ?Sized,
T: ?Sized,type Target = T
arbitrary_self_types #44874)
impl<T> ToString for Twhere
T: Display + ?Sized,impl<T, U> TryFrom<U> for Twhere
U: Into<T>,type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/sync/struct.UniqueArc.html