Struct beef::generic::Cow

pub struct Cow<'a, T: Beef + ?Sized + 'a, U: Capacity> { /* private fields */ }

A clone-on-write smart pointer, mostly compatible with std::borrow::Cow.

This type is using a generic U: Capacity. Use either beef::Cow or beef::lean::Cow in your code.

Implementations

impl<T, U> Cow<'_, T, U>

where T: Beef + ?Sized, U: Capacity,

pub fn owned(val: T::Owned) -> Self

Owned data.

Example

use beef::Cow;

let owned: Cow<str> = Cow::owned("I own my content".to_string());

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

where T: Beef + ?Sized, U: Capacity,

pub fn borrowed(val: &'a T) -> Self

Borrowed data.

Example

use beef::Cow;

let borrowed: Cow<str> = Cow::borrowed("I'm just a borrow");

pub fn into_owned(self) -> T::Owned

Extracts the owned data.

Clones the data if it is not already owned.

pub fn unwrap_borrowed(self) -> &'a T

Extracts borrowed data.

Panics: If the data is owned.

pub fn is_borrowed(&self) -> bool

Returns true if data is borrowed or had no capacity.

Example

use beef::Cow;

let borrowed: Cow<str> = Cow::borrowed("Borrowed");
let no_capacity: Cow<str> = Cow::owned(String::new());
let owned: Cow<str> = Cow::owned(String::from("Owned"));

assert_eq!(borrowed.is_borrowed(), true);
assert_eq!(no_capacity.is_borrowed(), true);
assert_eq!(owned.is_borrowed(), false);

pub fn is_owned(&self) -> bool

Returns true if data is owned and has non-0 capacity.

Example

use beef::Cow;

let borrowed: Cow<str> = Cow::borrowed("Borrowed");
let no_capacity: Cow<str> = Cow::owned(String::new());
let owned: Cow<str> = Cow::owned(String::from("Owned"));

assert_eq!(borrowed.is_owned(), false);
assert_eq!(no_capacity.is_owned(), false);
assert_eq!(owned.is_owned(), true);

impl<'a> Cow<'a, str, Wide>

pub const fn const_str(val: &'a str) -> Self

Borrowed data.

This is functionally identical to borrow. We use impl specialization to allow this function to be const.

Example

use beef::Cow;

const HELLO: Cow<str> = Cow::const_str("Hello");

impl<'a> Cow<'a, str, Lean>

pub const fn const_str(val: &'a str) -> Self

Borrowed data.

This is functionally identical to borrow. We use impl specialization to allow this function to be const.

Example

use beef::lean::Cow;

const HELLO: Cow<str> = Cow::const_str("Hello");

Trait Implementations

impl<T, U> AsRef<T> for Cow<'_, T, U>

where T: Beef + ?Sized, U: Capacity,

fn as_ref(&self) -> &T

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

impl<T, U> Borrow<T> for Cow<'_, T, U>

where T: Beef + ?Sized, U: Capacity,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

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

where T: Beef + ?Sized, U: Capacity,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, U> Debug for Cow<'_, T, U>

where T: Beef + Debug + ?Sized, U: Capacity,

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

Formats the value using the given formatter.

impl<'a, T, U> Default for Cow<'a, T, U>

where T: Beef + ?Sized, U: Capacity, &'a T: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T, U> Deref for Cow<'_, T, U>

where T: Beef + ?Sized, U: Capacity,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'de, 'a, T, U> Deserialize<'de> for Cow<'a, [T], U>

where [T]: Beef, U: Capacity, <[T] as ToOwned>::Owned: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, 'a, U> Deserialize<'de> for Cow<'a, str, U>

where U: Capacity, 'de: 'a,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, U> Display for Cow<'_, T, U>

where T: Beef + Display + ?Sized, U: Capacity,

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

Formats the value using the given formatter.

impl<T, U> Drop for Cow<'_, T, U>

where T: Beef + ?Sized, U: Capacity,

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T, U> From<&'a T> for Cow<'a, T, U>

where T: Beef + ?Sized, U: Capacity,

fn from(val: &'a T) -> Self

Converts to this type from the input type.

impl<'a, T, U> From<Cow<'a, T>> for Cow<'a, T, U>

where T: Beef + ?Sized, U: Capacity,

fn from(stdcow: StdCow<'a, T>) -> Self

Converts to this type from the input type.

impl<'a, T, U> From<Cow<'a, T, U>> for Cow<'a, T>

where T: Beef + ?Sized, U: Capacity,

fn from(cow: Cow<'a, T, U>) -> Self

Converts to this type from the input type.

impl<U> From<String> for Cow<'_, str, U>

where U: Capacity,

fn from(s: String) -> Self

Converts to this type from the input type.

impl<T, U> From<Vec<T>> for Cow<'_, [T], U>

where T: Clone, U: Capacity,

fn from(v: Vec<T>) -> Self

Converts to this type from the input type.

impl<T, U> Hash for Cow<'_, T, U>

where T: Hash + Beef + ?Sized, U: Capacity,

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

where T: Ord + Beef + ?Sized, U: Capacity,

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 + PartialOrd,

Restrict a value to a certain interval.

impl<U, T> PartialEq<&[T]> for Cow<'_, [T], U>

where U: Capacity, T: Clone + PartialEq,

fn eq(&self, other: &&[T]) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U> PartialEq<&str> for Cow<'_, str, U>

where U: Capacity,

fn eq(&self, other: &&str) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U, T> PartialEq<[T]> for Cow<'_, [T], U>

where U: Capacity, T: Clone + PartialEq,

fn eq(&self, other: &[T]) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U, T> PartialEq<Cow<'_, [T], U>> for &[T]

where U: Capacity, T: Clone + PartialEq,

fn eq(&self, other: &Cow<'_, [T], U>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U, T> PartialEq<Cow<'_, [T], U>> for [T]

where U: Capacity, T: Clone + PartialEq,

fn eq(&self, other: &Cow<'_, [T], U>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U, T> PartialEq<Cow<'_, [T], U>> for Vec<T>

where U: Capacity, T: Clone + PartialEq,

fn eq(&self, other: &Cow<'_, [T], U>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, B, U, V> PartialEq<Cow<'_, B, V>> for Cow<'_, A, U>

where A: Beef + ?Sized + PartialEq<B>, B: Beef + ?Sized, U: Capacity, V: Capacity,

fn eq(&self, other: &Cow<'_, B, V>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U> PartialEq<Cow<'_, str, U>> for &str

where U: Capacity,

fn eq(&self, other: &Cow<'_, str, U>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U> PartialEq<Cow<'_, str, U>> for String

where U: Capacity,

fn eq(&self, other: &Cow<'_, str, U>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U> PartialEq<Cow<'_, str, U>> for str

where U: Capacity,

fn eq(&self, other: &Cow<'_, str, U>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U> PartialEq<String> for Cow<'_, str, U>

where U: Capacity,

fn eq(&self, other: &String) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U, T> PartialEq<Vec<T>> for Cow<'_, [T], U>

where U: Capacity, T: Clone + PartialEq,

fn eq(&self, other: &Vec<T>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U> PartialEq<str> for Cow<'_, str, U>

where U: Capacity,

fn eq(&self, other: &str) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, B, U, V> PartialOrd<Cow<'_, B, V>> for Cow<'_, A, U>

where A: Beef + ?Sized + PartialOrd<B>, B: Beef + ?Sized, U: Capacity, V: Capacity,

fn partial_cmp(&self, other: &Cow<'_, B, V>) -> 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, U> Serialize for Cow<'_, T, U>

where T: Beef + Serialize + ?Sized, U: Capacity,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, U> Eq for Cow<'_, T, U>

where T: Eq + Beef + ?Sized, U: Capacity,

impl<T, U> Send for Cow<'_, T, U>

where U: Capacity, T: Beef + Sync + ?Sized, T::Owned: Send,

impl<T, U> Sync for Cow<'_, T, U>

where U: Capacity, T: Beef + Sync + ?Sized, T::Owned: Sync,

impl<T, U> Unpin for Cow<'_, T, U>

where U: Capacity, T: Beef + ?Sized, T::Owned: Unpin,