Struct mappable_rc::Mrc

pub struct Mrc<T: ?Sized + 'static> { /* private fields */ }

Implementations

impl<T: ?Sized> Mrc<T>

pub fn ptr_eq(this: &Self, other: &Self) -> bool

pub fn from_borrow<C>(c: C) -> Self where
    C: Borrow<T> + 'static, 

Creates a Mrc<T> from a value that borrows T.

This is just implemented as Mrc::map(Mrc::new(c), |c| c.borrow()).

impl<T: ?Sized> Mrc<T>

pub fn as_ptr(&self) -> *const T

Returns a read-only pointer to the referred to data.

The pointer is valid for as long as this value is alive.

pub fn map<U: ?Sized + 'static, F: FnOnce(&T) -> &U>(
    self_: Self,
    f: F
) -> Mrc<U>

Maps the value to a new Mrc that refers to the data returned by the closure.

This only changes what data this particular Mrc refers to. It does not introduce mutability - any Mrc<T>s you’ve cloned from this one in the past still point to the same thing. Of course, if you clone the value returned by this function, then the resulting Mrc<U>s will also point to the mapped value.

This does not cause the T to be dropped early. Even if the &U refers to only a part of the &T, no part of the T is dropped until all references to or into the T are gone, at which point the entire T is dropped at once.

pub fn try_map<U: ?Sized + 'static, F: FnOnce(&T) -> Option<&U>>(
    self_: Self,
    f: F
) -> Result<Mrc<U>, Mrc<T>>

Attempts to map the Mrc<T> , returning the new value on success and the old value otherwise.

This is simply a fallible version of Mrc::map , and generally has all the same properties.

pub fn map_in_place<F: FnOnce(&T) -> &T>(self_: &mut Self, f: F)

Maps the value that the Mrc refers to, without taking ownership.

This is equivalent to cloning, mapping, and then writing to self, except that it is slightly more efficient because it avoids the clone.

self is left unchanged if f panics.

impl<T: 'static> Mrc<T>

pub fn from_rc(rc: Rc<T>) -> Self

Creates a new Mrc from an Rc that shares ownership of the Rc’s data.

Like Mrc::new, this method requires T: Sized + 'static. If you have an Rc<T> where T: ?Sized, then you can create an Mrc<T> via Mrc::from_borrow.

As long as the returned Mrc is alive, the strong count of the Rc will be at least one. This is also the case if any Mrc’s derived from the return value via Clone and Mrc::map are alive. The strong count of the input Rc could be observed by another Rc also sharing ownership of the data. It is not specified whether clones of the return value will be reflected in that strong count.

This function is essentially free to call. After inlining, it will consist of one to two pointer copies.

pub fn new(t: T) -> Self

Creates a new Mrc that provides shared ownership of the T.

This method, like all ways of creating an Mrc, has a 'static bound that is not found on the corresponding Rc method. That requirement is fundamentally necessary for the soundness of this type and cannot be circumvented.

Trait Implementations

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

fn as_ref(&self) -> &T

Performs the conversion.

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

fn borrow(&self) -> &T

Immutably borrows from an owned value.

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

Creates a new Mrc<T> sharing ownership of the same data.

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T: Default + 'static> Default for Mrc<T>

fn default() -> Self

Returns the “default value” for a type.

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

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

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

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

Formats the value using the given formatter.

impl<T: Clone + 'static> From<&'_ [T]> for Mrc<[T]>

fn from(r: &[T]) -> Self

Performs the conversion.

impl<T: ?Sized + 'static> From<Box<T, Global>> for Mrc<T>

fn from(b: Box<T>) -> Mrc<T>

Performs the conversion.

impl<'a, B> From<Cow<'a, B>> for Mrc<B> where
    B: ?Sized + ToOwned,
    &'a B: Into<Mrc<B>>,
    <B as ToOwned>::Owned: Into<Mrc<B>>, 

fn from(b: Cow<'a, B>) -> Mrc<B>

Performs the conversion.

impl<T: 'static> From<Rc<T>> for Mrc<T>

fn from(a: Rc<T>) -> Self

Performs the conversion.

impl From<String> for Mrc<str>

fn from(s: String) -> Mrc<str>

Performs the conversion.

impl<T: 'static> From<T> for Mrc<T>

fn from(t: T) -> Mrc<T>

Performs the conversion.

impl<T: 'static> From<Vec<T, Global>> for Mrc<[T]>

fn from(v: Vec<T>) -> Mrc<[T]>

Performs the conversion.

impl<T: 'static> FromIterator<T> for Mrc<[T]>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Mrc<[T]>

Creates a value from an iterator.

impl<T: ?Sized + Hash> Hash for Mrc<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 + Ord> Ord for Mrc<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

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

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

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

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

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

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

Formats the value using the given formatter.

impl<T, const N: usize> TryFrom<Mrc<[T]>> for Mrc<[T; N]>

type Error = Mrc<[T]>

The type returned in the event of a conversion error.

fn try_from(s: Mrc<[T]>) -> Result<Mrc<[T; N]>, Mrc<[T]>>

Performs the conversion.

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