Struct std::rc::Rc 1.0.0
[−]
[src]
pub struct Rc<T> where T: ?Sized { /* fields omitted */ }
A single-threaded reference-counting pointer.
See the module-level documentation for more details.
The inherent methods of Rc
are all associated functions, which means
that you have to call them as e.g. Rc::get_mut(&value)
instead of
value.get_mut()
. This avoids conflicts with methods of the inner
type T
.
Methods
impl<T> Rc<T>
fn new(value: T) -> Rc<T>
Constructs a new Rc<T>
.
Examples
fn main() { use std::rc::Rc; let five = Rc::new(5); }use std::rc::Rc; let five = Rc::new(5);Run
fn try_unwrap(this: Rc<T>) -> Result<T, Rc<T>>
1.4.0
Returns the contained value, if the Rc
has exactly one strong reference.
Otherwise, an Err
is returned with the same Rc
that was passed in.
This will succeed even if there are outstanding weak references.
Examples
fn main() { use std::rc::Rc; let x = Rc::new(3); assert_eq!(Rc::try_unwrap(x), Ok(3)); let x = Rc::new(4); let _y = x.clone(); assert_eq!(*Rc::try_unwrap(x).unwrap_err(), 4); }use std::rc::Rc; let x = Rc::new(3); assert_eq!(Rc::try_unwrap(x), Ok(3)); let x = Rc::new(4); let _y = x.clone(); assert_eq!(*Rc::try_unwrap(x).unwrap_err(), 4);Run
fn would_unwrap(this: &Rc<T>) -> bool
Checks whether Rc::try_unwrap
would return Ok
.
Examples
#![feature(rc_would_unwrap)] fn main() { use std::rc::Rc; let x = Rc::new(3); assert!(Rc::would_unwrap(&x)); assert_eq!(Rc::try_unwrap(x), Ok(3)); let x = Rc::new(4); let _y = x.clone(); assert!(!Rc::would_unwrap(&x)); assert_eq!(*Rc::try_unwrap(x).unwrap_err(), 4); }#![feature(rc_would_unwrap)] use std::rc::Rc; let x = Rc::new(3); assert!(Rc::would_unwrap(&x)); assert_eq!(Rc::try_unwrap(x), Ok(3)); let x = Rc::new(4); let _y = x.clone(); assert!(!Rc::would_unwrap(&x)); assert_eq!(*Rc::try_unwrap(x).unwrap_err(), 4);Run
impl<T> Rc<T> where T: ?Sized
fn downgrade(this: &Rc<T>) -> Weak<T>
1.4.0
Creates a new Weak
pointer to this value.
Examples
fn main() { use std::rc::Rc; let five = Rc::new(5); let weak_five = Rc::downgrade(&five); }use std::rc::Rc; let five = Rc::new(5); let weak_five = Rc::downgrade(&five);Run
fn weak_count(this: &Rc<T>) -> usize
Gets the number of Weak
pointers to this value.
Examples
#![feature(rc_counts)] fn main() { use std::rc::Rc; let five = Rc::new(5); let _weak_five = Rc::downgrade(&five); assert_eq!(1, Rc::weak_count(&five)); }#![feature(rc_counts)] use std::rc::Rc; let five = Rc::new(5); let _weak_five = Rc::downgrade(&five); assert_eq!(1, Rc::weak_count(&five));Run
fn strong_count(this: &Rc<T>) -> usize
Gets the number of strong (Rc
) pointers to this value.
Examples
#![feature(rc_counts)] fn main() { use std::rc::Rc; let five = Rc::new(5); let _also_five = five.clone(); assert_eq!(2, Rc::strong_count(&five)); }#![feature(rc_counts)] use std::rc::Rc; let five = Rc::new(5); let _also_five = five.clone(); assert_eq!(2, Rc::strong_count(&five));Run
fn is_unique(this: &Rc<T>) -> bool
Returns true if there are no other Rc
or Weak
pointers to
this inner value.
Examples
#![feature(rc_counts)] fn main() { use std::rc::Rc; let five = Rc::new(5); assert!(Rc::is_unique(&five)); }#![feature(rc_counts)] use std::rc::Rc; let five = Rc::new(5); assert!(Rc::is_unique(&five));Run
fn get_mut(this: &mut Rc<T>) -> Option<&mut T>
1.4.0
Returns a mutable reference to the inner value, if there are
no other Rc
or Weak
pointers to the same value.
Returns None
otherwise, because it is not safe to
mutate a shared value.
See also make_mut
, which will clone
the inner value when it's shared.
Examples
fn main() { use std::rc::Rc; let mut x = Rc::new(3); *Rc::get_mut(&mut x).unwrap() = 4; assert_eq!(*x, 4); let _y = x.clone(); assert!(Rc::get_mut(&mut x).is_none()); }use std::rc::Rc; let mut x = Rc::new(3); *Rc::get_mut(&mut x).unwrap() = 4; assert_eq!(*x, 4); let _y = x.clone(); assert!(Rc::get_mut(&mut x).is_none());Run
fn ptr_eq(this: &Rc<T>, other: &Rc<T>) -> bool
Returns true if the two Rc
s point to the same value (not
just values that compare as equal).
Examples
#![feature(ptr_eq)] fn main() { use std::rc::Rc; let five = Rc::new(5); let same_five = five.clone(); let other_five = Rc::new(5); assert!(Rc::ptr_eq(&five, &same_five)); assert!(!Rc::ptr_eq(&five, &other_five)); }#![feature(ptr_eq)] use std::rc::Rc; let five = Rc::new(5); let same_five = five.clone(); let other_five = Rc::new(5); assert!(Rc::ptr_eq(&five, &same_five)); assert!(!Rc::ptr_eq(&five, &other_five));Run
impl<T> Rc<T> where T: Clone
fn make_mut(this: &mut Rc<T>) -> &mut T
1.4.0
Makes a mutable reference into the given Rc
.
If there are other Rc
or Weak
pointers to the same value,
then make_mut
will invoke clone
on the inner value to
ensure unique ownership. This is also referred to as clone-on-write.
See also get_mut
, which will fail rather than cloning.
Examples
fn main() { use std::rc::Rc; let mut data = Rc::new(5); *Rc::make_mut(&mut data) += 1; // Won't clone anything let mut other_data = data.clone(); // Won't clone inner data *Rc::make_mut(&mut data) += 1; // Clones inner data *Rc::make_mut(&mut data) += 1; // Won't clone anything *Rc::make_mut(&mut other_data) *= 2; // Won't clone anything // Now `data` and `other_data` point to different values. assert_eq!(*data, 8); assert_eq!(*other_data, 12); }use std::rc::Rc; let mut data = Rc::new(5); *Rc::make_mut(&mut data) += 1; // Won't clone anything let mut other_data = data.clone(); // Won't clone inner data *Rc::make_mut(&mut data) += 1; // Clones inner data *Rc::make_mut(&mut data) += 1; // Won't clone anything *Rc::make_mut(&mut other_data) *= 2; // Won't clone anything // Now `data` and `other_data` point to different values. assert_eq!(*data, 8); assert_eq!(*other_data, 12);Run
Trait Implementations
impl<T> PartialOrd<Rc<T>> for Rc<T> where T: PartialOrd<T> + ?Sized
fn partial_cmp(&self, other: &Rc<T>) -> Option<Ordering>
Partial comparison for two Rc
s.
The two are compared by calling partial_cmp()
on their inner values.
Examples
fn main() { use std::rc::Rc; use std::cmp::Ordering; let five = Rc::new(5); assert_eq!(Some(Ordering::Less), five.partial_cmp(&Rc::new(6))); }use std::rc::Rc; use std::cmp::Ordering; let five = Rc::new(5); assert_eq!(Some(Ordering::Less), five.partial_cmp(&Rc::new(6)));Run
fn lt(&self, other: &Rc<T>) -> bool
Less-than comparison for two Rc
s.
The two are compared by calling <
on their inner values.
Examples
fn main() { use std::rc::Rc; let five = Rc::new(5); assert!(five < Rc::new(6)); }use std::rc::Rc; let five = Rc::new(5); assert!(five < Rc::new(6));Run
fn le(&self, other: &Rc<T>) -> bool
'Less than or equal to' comparison for two Rc
s.
The two are compared by calling <=
on their inner values.
Examples
fn main() { use std::rc::Rc; let five = Rc::new(5); assert!(five <= Rc::new(5)); }use std::rc::Rc; let five = Rc::new(5); assert!(five <= Rc::new(5));Run
fn gt(&self, other: &Rc<T>) -> bool
Greater-than comparison for two Rc
s.
The two are compared by calling >
on their inner values.
Examples
fn main() { use std::rc::Rc; let five = Rc::new(5); assert!(five > Rc::new(4)); }use std::rc::Rc; let five = Rc::new(5); assert!(five > Rc::new(4));Run
fn ge(&self, other: &Rc<T>) -> bool
impl<T> Clone for Rc<T> where T: ?Sized
fn clone(&self) -> Rc<T>
Makes a clone of the Rc
pointer.
This creates another pointer to the same inner value, increasing the strong reference count.
Examples
fn main() { use std::rc::Rc; let five = Rc::new(5); five.clone(); }use std::rc::Rc; let five = Rc::new(5); five.clone();Run
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<T> Default for Rc<T> where T: Default
impl<T> Pointer for Rc<T> where T: ?Sized
impl<T> PartialEq<Rc<T>> for Rc<T> where T: PartialEq<T> + ?Sized
fn eq(&self, other: &Rc<T>) -> bool
Equality for two Rc
s.
Two Rc
s are equal if their inner values are equal.
Examples
fn main() { use std::rc::Rc; let five = Rc::new(5); assert!(five == Rc::new(5)); }use std::rc::Rc; let five = Rc::new(5); assert!(five == Rc::new(5));Run
fn ne(&self, other: &Rc<T>) -> bool
impl<T> Ord for Rc<T> where T: Ord + ?Sized
fn cmp(&self, other: &Rc<T>) -> Ordering
Comparison for two Rc
s.
The two are compared by calling cmp()
on their inner values.
Examples
fn main() { use std::rc::Rc; use std::cmp::Ordering; let five = Rc::new(5); assert_eq!(Ordering::Less, five.cmp(&Rc::new(6))); }use std::rc::Rc; use std::cmp::Ordering; let five = Rc::new(5); assert_eq!(Ordering::Less, five.cmp(&Rc::new(6)));Run
impl<T> Drop for Rc<T> where T: ?Sized
fn drop(&mut self)
Drops the Rc
.
This will decrement the strong reference count. If the strong reference
count reaches zero then the only other references (if any) are Weak
,
so we drop
the inner value.
Examples
fn main() { use std::rc::Rc; struct Foo; impl Drop for Foo { fn drop(&mut self) { println!("dropped!"); } } let foo = Rc::new(Foo); let foo2 = foo.clone(); drop(foo); // Doesn't print anything drop(foo2); // Prints "dropped!" }use std::rc::Rc; struct Foo; impl Drop for Foo { fn drop(&mut self) { println!("dropped!"); } } let foo = Rc::new(Foo); let foo2 = foo.clone(); drop(foo); // Doesn't print anything drop(foo2); // Prints "dropped!"Run
impl<T> Hash for Rc<T> where T: Hash + ?Sized
fn hash<H>(&self, state: &mut H) where H: Hasher
Feeds this value into the state given, updating the hasher as necessary.
fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher
1.3.0
Feeds a slice of this type into the state provided.
impl<T> Eq for Rc<T> where T: Eq + ?Sized
impl<T> !Sync for Rc<T> where T: ?Sized
impl<T> !Send for Rc<T> where T: ?Sized
impl<T> From<T> for Rc<T>
1.6.0
impl<T> Display for Rc<T> where T: Display + ?Sized
impl<T> AsRef<T> for Rc<T> where T: ?Sized
1.5.0
fn as_ref(&self) -> &T
Performs the conversion.
impl<T, U> CoerceUnsized<Rc<U>> for Rc<T> where T: Unsize<U> + ?Sized, U: ?Sized
impl<T> Deref for Rc<T> where T: ?Sized
type Target = T
The resulting type after dereferencing
fn deref(&self) -> &T
The method called to dereference a value