Enum Cow 

pub enum Cow<'a, T>
where
    T: Cowable,
{
    Borrowed(CowableBorrowed<'a, T>),
    Owned(CowableOwned<T>),
}

A clone-on-write container that contains either the owned or borrowed version of some data.

Unlike std::borrow::Cow, this type may hold non-reference types with internal references in the borrowed variant. T is required to implement Cowable.

Notes

• Important: The implementations of PartialEq, Eq, PartialOrd and Ord assume that the results are the same regardless of which combination of borrowed and owned versions are being compared.
• Some traits cannot have blanket implementations without support for specialization in Rust, such as the From trait. Where possible the functionality is provided by intrinsic methods instead.

Variants

Borrowed(CowableBorrowed<'a, T>)

Borrowed variant.

Owned(CowableOwned<T>)

Owned variant.

Implementations

impl<'a, T> Cow<'a, T>

where T: Cowable,

pub fn borrowed(borrowed: impl Into<CowableBorrowed<'a, T>>) -> Self

Create a new Cow containing borrowed data.

pub fn owned(owned: impl Into<CowableOwned<T>>) -> Self

Create a new Cow containing owned data.

pub fn is_borrowed(&self) -> bool

Return true if the data is borrowed.

pub fn is_owned(&self) -> bool

Return true if the data is owned.

pub fn unwrap_borrowed(self) -> CowableBorrowed<'a, T>

Unwrap the borrowed data, panicking if the data is owned.

pub fn unwrap_owned(self) -> CowableOwned<T>

Unwrap the owned data, panicking if the data is borrowed.

impl<'a, T> Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: ToOwned<Owned = CowableOwned<T>>,

pub fn to_mut(&mut self) -> &mut CowableOwned<T>

If this Cow contains and owned value, return a mutable reference to it. If it contains a borrowed value, make it owned and return a mutable reference to this new value.

pub fn into_inner(self) -> CowableOwned<T>

Unwrap this Cow into and owned value, calling ToOwned::into_owned if the data is borrowed.

Trait Implementations

impl<'a, T> Borrow<'a, BorrowCow<T>> for Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: Borrow<'a, T::BorrowHkt>, CowableOwned<T>: Borrow<'a, T::BorrowHkt>,

fn borrow<'b>(&'a self) -> Borrowed<'b, BorrowCow<T>>

where 'a: 'b,

Create a borrowed version of this type.

impl<'a, T> Clone for Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: Clone, CowableOwned<T>: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T> Debug for Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: Debug, CowableOwned<T>: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Cow<'_, T>

where T: Cowable, CowableOwned<T>: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> Hash for Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: Hash, CowableOwned<T>: Hash,

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<'a, T> Ord for Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: Ord + PartialOrd<CowableOwned<T>>, CowableOwned<T>: Ord + PartialOrd<CowableBorrowed<'a, 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<'a, T> PartialEq for Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: PartialEq + PartialEq<CowableOwned<T>>, CowableOwned<T>: PartialEq + PartialEq<CowableBorrowed<'a, T>>,

fn eq(&self, other: &Cow<'a, T>) -> 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<'a, T> PartialOrd for Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: PartialOrd + PartialOrd<CowableOwned<T>>, CowableOwned<T>: PartialOrd + PartialOrd<CowableBorrowed<'a, T>>,

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

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

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

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

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

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

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

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

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

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

impl<'a, T> ToOwned for Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: ToOwned<Owned = CowableOwned<T>>, CowableOwned<T>: Clone,

type Owned = Cow<'static, T>

Owned type.

fn to_owned(&self) -> Cow<'static, T>

Create an owned version of this type by cloning if necessary.

fn into_owned(self) -> Cow<'static, T>

Create an owned version of this type, consuming self.

impl<'a, T> Copy for Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: Copy, CowableOwned<T>: Copy,

impl<'a, T> Eq for Cow<'a, T>

where T: Cowable, CowableBorrowed<'a, T>: Eq + PartialEq<CowableOwned<T>>, CowableOwned<T>: Eq + PartialEq<CowableBorrowed<'a, T>>,