Enum Cow

pub enum Cow<'b, T: ToOwnedIn<A> + ?Sized, A: Allocator> {
    Borrowed(&'b T),
    Owned(Owned<T, A>),
}

Representation of either an owned or borrowed instance of a type.

Variants

Borrowed(&'b T)

The borrowed variant, limited by a lifetime.

Owned(Owned<T, A>)

The owned variant.

Implementations

impl<'b, T: ToOwnedIn<A> + ?Sized, A: Allocator> Cow<'b, T, A>

pub fn is_borrowed(&self) -> bool

Determine if this instance is borrowed.

pub fn is_owned(&self) -> bool

Determine if this instance is owned.

pub fn to_mut(&mut self) -> &mut Owned<T, A>

where A: Default + Allocator,

If necessary, convert self into an owned instance. Return a mutable reference to the owned instance.

pub fn to_mut_in<I>(&mut self, alloc_in: I) -> &mut Owned<T, A>

where I: AllocateIn<Alloc = A>,

If necessary, convert self into an owned instance given an allocation target. Return a mutable reference to the owned instance.

pub fn into_owned(self) -> Owned<T, A>

where A: Default + Allocator,

If necessary, convert self into an owned instance. Unwrap and return the owned instance.

pub fn into_owned_in<I>(self, alloc_in: I) -> Owned<T, A>

where I: AllocateIn<Alloc = A>,

If necessary, convert self into an owned instance given an allocation target. Unwrap and return the owned instance.

pub fn try_into_owned(self) -> Result<Owned<T, A>, StorageError>

where A: Default + Allocator,

If necessary, try to convert self into an owned instance. Unwrap and return the owned instance or a storage error.

pub fn try_into_owned_in<I>( self, storage: I, ) -> Result<Owned<T, A>, StorageError>

where I: AllocateIn<Alloc = A>,

If necessary, try to convert self into an owned instance given an allocation target. Unwrap and return the owned instance or a storage error.

Trait Implementations

impl<T: ToOwnedIn<A> + ?Sized, A: Allocator> AsRef<T> for Cow<'_, T, A>

fn as_ref(&self) -> &T

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

impl<T: ToOwnedIn<A> + ?Sized, A: Allocator> Borrow<T> for Cow<'_, T, A>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T: ToOwnedIn<A> + ?Sized, A: Allocator> Clone for Cow<'_, T, A>

where Owned<T, A>: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, A: Allocator> ConstDefault for Cow<'_, T, A>

where T: ToOwnedIn<A> + ?Sized, T::Owned: ConstDefault,

const DEFAULT: Self = _

The constant default value.

impl<T, A: Allocator> Debug for Cow<'_, T, A>

where T: ToOwnedIn<A> + Debug + ?Sized, Owned<T, A>: Debug,

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

Formats the value using the given formatter.

impl<T: ToOwnedIn<A> + ?Sized, A: Allocator> Default for Cow<'_, T, A>

where Owned<T, A>: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T: ToOwnedIn<A> + ?Sized, A: Allocator> Deref for Cow<'_, T, A>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, A: Allocator> Display for Cow<'_, T, A>

where T: ToOwnedIn<A> + Display + ?Sized, Owned<T, A>: Display,

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

Formats the value using the given formatter.

impl<'a, T: Clone, A: Allocator, const N: usize> From<&'a [T; N]> for Cow<'a, [T], A>

fn from(s: &'a [T; N]) -> Cow<'a, [T], A>

Converts to this type from the input type.

impl<'b, T: ToOwnedIn<A> + ?Sized, A: Allocator> From<&'b T> for Cow<'b, T, A>

fn from(borrow: &'b T) -> Self

Converts to this type from the input type.

impl<'a, T: Clone, A: Allocator> From<&'a Vec<T, A>> for Cow<'a, [T], A>

fn from(vec: &'a Vec<T, A>) -> Cow<'a, [T], A>

Converts to this type from the input type.

impl<'a, T: Clone, A: Allocator, const N: usize> From<&'a mut [T; N]> for Cow<'a, [T], A>

fn from(s: &'a mut [T; N]) -> Cow<'a, [T], A>

Converts to this type from the input type.

impl<'b, T: ToOwnedIn<A> + ?Sized, A: Allocator> From<&'b mut T> for Cow<'b, T, A>

fn from(borrow: &'b mut T) -> Self

Converts to this type from the input type.

impl<'a, T: Clone, A: Allocator> From<Vec<T, A>> for Cow<'a, [T], A>

fn from(vec: Vec<T, A>) -> Cow<'a, [T], A>

Converts to this type from the input type.

impl<'a, T: Clone, A: AllocatorDefault> FromIterator<T> for Cow<'a, [T], A>

fn from_iter<I: IntoIterator<Item = T>>(it: I) -> Cow<'a, [T], A>

Creates a value from an iterator.

impl<'a, 'b, T, A: Allocator, U: ToOwnedIn<B> + ?Sized, B: Allocator> PartialEq<Cow<'b, U, B>> for Cow<'a, T, A>

where T: PartialEq<U> + ToOwnedIn<A> + ?Sized,

fn eq(&self, other: &Cow<'b, U, B>) -> 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: ToOwnedIn<A> + Eq + ?Sized, A: Allocator> Eq for Cow<'a, T, A>