Struct reference_counted::Rc

pub struct Rc<T: ?Sized> { /* fields omitted */ }

A non-thread-safe reference-counted pointer.

Trait Implementations

impl<T: ?Sized> AsRef<T> for Rc<T>

fn as_ref(&self) -> &T

Performs the conversion.

impl<T: ?Sized> Borrow<T> for Rc<T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T: ?Sized> Clone for Rc<T>

fn clone(&self) -> Rc<T>

Makes a clone of the Rc pointer.

This creates another pointer to the same allocation, increasing the reference count.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: ?Sized + Debug> Debug for Rc<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Rc<T>

fn default() -> Rc<T>

Creates a new Rc<T>, with the Default value for T.

Examples

use std::sync::Rc;

let x: Rc<i32> = Default::default();
assert_eq!(*x, 0);

impl<T: ?Sized> Deref for Rc<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: ?Sized + Display> Display for Rc<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Drop for Rc<T>

fn drop(&mut self)

Drops the Rc.

This will decrement the reference count.

Examples

use std::sync::Rc;

struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {
        println!("dropped!");
    }
}

let foo  = Rc::new(Foo);
let foo2 = Rc::clone(&foo);

drop(foo);    // Doesn't print anything
drop(foo2);   // Prints "dropped!"

impl<T: ?Sized + Eq> Eq for Rc<T>

impl<T> From<T> for Rc<T>

fn from(t: T) -> Self

Performs the conversion.

impl<T: ?Sized + Hash> Hash for Rc<T>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T: ?Sized> Into<Rc<T>> for UniqueRc<T>

fn into(self) -> Rc<T>

Performs the conversion.

impl<T: ?Sized> IntoMut<T> for Rc<T>

type MutablePointer = UniqueRc<T>

fn can_make_mut(this: &Self) -> bool

Check whether converting into a mutable version would succeed.

unsafe fn into_mut_unchecked(this: Self) -> Self::MutablePointer

Convert into a mutable version without performing runtime checks for upholding any invariants.

unsafe fn get_mut_unchecked(this: &Self) -> &mut T

Obtain a mutable reference to the wrapped value without performing runtime checks for upholding any invariants.

Safety: Calling this is safe if and only if can_make_mut returns true.

fn into_mut(this: Self) -> Result<Self::MutablePointer, Self>

Try converting into a mutable version of the pointer.

fn get_mut(this: &Self) -> Option<&mut T>

Try obtaining a mutable reference to the wrapped value.

impl<T: ?Sized + Ord> Ord for Rc<T>

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

Comparison for two Rcs.

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

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

impl<T: ?Sized + PartialEq> PartialEq<Rc<T>> for Rc<T>

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

Equality for two Rcs.

Two Rcs are equal if their inner values are equal, even if they are stored in different allocation. This implementation does not check for pointer equality.

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

Inequality for two Rcs.

Two Rcs are unequal if their inner values are unequal. This implementation does not check for pointer equality.

impl<T: ?Sized + PartialOrd> PartialOrd<Rc<T>> for Rc<T>

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

Partial comparison for two Rcs.

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

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

Less-than comparison for two Rcs.

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

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

'Less than or equal to' comparison for two Rcs.

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

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

Greater-than comparison for two Rcs.

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

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

'Greater than or equal to' comparison for two Rcs.

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

impl<T: ?Sized> Pointer for Rc<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> ReferenceCounted<T> for Rc<T>

fn reference_count(this: &Self) -> usize

Get the number of owning pointers referring to the same allocation.

impl<T: ?Sized> SmartPointer<T> for Rc<T>

fn new(data: T) -> Rc<T> where
    T: Sized, 

Construct a new smart pointer, containing the given value.

fn try_unwrap(this: Self) -> Result<T, Self> where
    T: Sized, 

Try to obtain ownership of the wrapped value.

impl<T: ?Sized> Unpin for Rc<T>