Struct Marc 

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

Implementations

impl<T: ?Sized> Marc<T>

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

pub fn from_borrow<C>(c: C) -> Self

where C: Send + Borrow<T> + 'static,

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

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

impl<T: ?Sized> Marc<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, ) -> Marc<U>

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

This only changes what data this particular Marc refers to. It does not introduce mutability - any Marc<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 Marc<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<Marc<U>, Marc<T>>

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

This is simply a fallible version of Marc::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 Marc 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: Send + 'static> Marc<T>

pub fn from_arc(arc: Arc<T>) -> Self

Creates a new Marc from an Arc that shares ownership of the Arc’s data.

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

As long as the returned Marc is alive, the strong count of the Arc will be at least one. This is also the case if any Marc’s derived from the return value via Clone and Marc::map are alive. The strong count of the input Arc could be observed by another Arc 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 Marc that provides shared ownership of the T.

This method, like all ways of creating an Marc, has a Send + 'static bound that is not found on the corresponding Arc method. You can avoid the Send requirement by using Mrc::from_borrow to create an Mrc instead. The 'static requirement is fundamentally necessary for the soundness of this type and cannot be circumvented.

Trait Implementations

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

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

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

fn borrow(&self) -> &T

Immutably borrows from an owned value.

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

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T: Send + Default + 'static> Default for Marc<T>

fn default() -> Self

Returns the “default value” for a type.

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

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

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

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

Formats the value using the given formatter.

impl<T: Send + Clone + 'static> From<&[T]> for Marc<[T]>

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

Converts to this type from the input type.

impl<T: Send + 'static> From<Arc<T>> for Marc<T>

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

Converts to this type from the input type.

impl<T: Send + ?Sized + 'static> From<Box<T>> for Marc<T>

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

Converts to this type from the input type.

impl<'a, B> From<Cow<'a, B>> for Marc<B>

where B: ?Sized + ToOwned, &'a B: Into<Marc<B>>, <B as ToOwned>::Owned: Into<Marc<B>>,

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

Converts to this type from the input type.

impl From<String> for Marc<str>

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

Converts to this type from the input type.

impl<T: Send + 'static> From<T> for Marc<T>

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

Converts to this type from the input type.

impl<T: Send + 'static> From<Vec<T>> for Marc<[T]>

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

Converts to this type from the input type.

impl<T: Send + 'static> FromIterator<T> for Marc<[T]>

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

Creates a value from an iterator.

impl<T: ?Sized + Hash> Hash for Marc<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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

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

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: ?Sized + PartialOrd<T>> PartialOrd for Marc<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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

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

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

Formats the value using the given formatter.

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

type Error = Marc<[T]>

The type returned in the event of a conversion error.

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

Performs the conversion.

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

impl<T: Sync + ?Sized> Send for Marc<T>

impl<T: Sync + ?Sized> Sync for Marc<T>