Struct Cow 

pub struct Cow<'a, T>
where
    T: ?Sized + Dairy<'a>,
{ /* private fields */ }

A clone-on-write smart pointer.

The type Cow is a smart pointer providing clone-on-write functionality: it can enclose and provide immutable access to borrowed data, and clone the data lazily when mutation or ownership is required.

Cow implements Deref, which means that you can call non-mutating methods directly on the data it encloses.

Implementations

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

where T: ?Sized + Dairy<'a>,

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

Construct from borrowed data.

Examples

use dairy::Cow;
let cow: Cow<str> = Cow::borrowed("moo");

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

Construct from owned data.

Examples

use dairy::Cow;
let cow: Cow<str> = Cow::owned(String::from("moo"));

pub fn is_borrowed(&self) -> bool

Returns true if the data is borrowed.

Examples

use dairy::Cow;

let cow: Cow<str> = Cow::borrowed("moo");
assert!(cow.is_borrowed());

let cow: Cow<str> = Cow::owned(String::from("...moo?"));
assert!(!cow.is_borrowed());

pub fn is_owned(&self) -> bool

Returns true if the data is owned.

Examples

use dairy::Cow;

let cow: Cow<str> = Cow::owned(String::from("moo"));
assert!(cow.is_owned());

let cow: Cow<str> = Cow::borrowed("...moo?");
assert!(!cow.is_owned());

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

Converts into owned data.

Clones the data if it is not already owned.

Examples

Calling .into_owned() on a borrowed Cow clones the underlying data.

use dairy::Cow;

let cow = Cow::borrowed("Moo!");
assert_eq!(cow.into_owned(), String::from("Moo!"));

Calling .into_owned() on an owned Cow is a noop.

use dairy::Cow;

let cow: Cow<str> = Cow::owned(String::from("Moo!"));
assert_eq!(cow.into_owned(), String::from("Moo!"));

pub fn into_boxed(self) -> Box<T>

where T: ToBoxed,

Converts into boxed data.

Clones the data if it is not already owned.

Examples

Calling .into_boxed() on a borrowed Cow clones the underlying data.

use dairy::Cow;

let cow = Cow::borrowed("Moo!");
assert_eq!(cow.into_boxed(), String::from("Moo!").into_boxed_str());

Calling .into_boxed() on an owned Cow is a noop.

use dairy::Cow;

let cow: Cow<str> = Cow::owned(String::from("Moo!"));
assert_eq!(cow.into_boxed(), String::from("Moo!").into_boxed_str());

pub fn apply<F>(&mut self, f: F)

where F: FnOnce(&mut T::Owned),

Applies the given function to the owned data.

Clones the data if it is not already owned. This is useful because the compact implementation is not able to provide a .to_mut() method like the standard library. This function allows you to modify the Cow without moving it.

Examples

use dairy::Cow;

let mut cow = Cow::borrowed("Moo!");
cow.apply(|s| s.make_ascii_uppercase());
assert_eq!(cow, "MOO!");

Trait Implementations

impl AsRef<[u8]> for Cow<'_, str>

fn as_ref(&self) -> &[u8]

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

impl AsRef<OsStr> for Cow<'_, Path>

fn as_ref(&self) -> &OsStr

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

impl AsRef<OsStr> for Cow<'_, str>

fn as_ref(&self) -> &OsStr

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

impl AsRef<Path> for Cow<'_, OsStr>

fn as_ref(&self) -> &Path

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

impl AsRef<Path> for Cow<'_, str>

fn as_ref(&self) -> &Path

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

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

where T: ?Sized + Dairy<'a>,

fn as_ref(&self) -> &T

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

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

where T: ?Sized + Dairy<'a>,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

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

where T: ?Sized + Dairy<'a>,

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: ?Sized + Dairy<'a> + Debug, T::Owned: Debug,

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

Formats the value using the given formatter.

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

where T: ?Sized + Dairy<'a>, T::Owned: Default,

fn default() -> Self

Returns the “default value” for a type.

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

where T: ?Sized + Dairy<'a>,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

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

where T: ?Sized + Dairy<'a> + Display, T::Owned: Display,

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

Formats the value using the given formatter.

impl<'a, 'b> Extend<&'b OsStr> for Cow<'a, OsStr>

fn extend<I: IntoIterator<Item = &'b OsStr>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b> Extend<&'b OsString> for Cow<'a, OsStr>

fn extend<I: IntoIterator<Item = &'b OsString>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b> Extend<&'b Path> for Cow<'a, Path>

fn extend<I: IntoIterator<Item = &'b Path>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b> Extend<&'b PathBuf> for Cow<'a, Path>

fn extend<I: IntoIterator<Item = &'b PathBuf>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b> Extend<&'b String> for Cow<'a, str>

fn extend<I: IntoIterator<Item = &'b String>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b, T: 'a + 'b + Copy> Extend<&'b T> for Cow<'a, [T]>

fn extend<I: IntoIterator<Item = &'b T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b> Extend<&'b char> for Cow<'a, str>

fn extend<I: IntoIterator<Item = &'b char>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b> Extend<&'b str> for Cow<'a, str>

fn extend<I: IntoIterator<Item = &'b str>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<Box<OsStr>> for Cow<'_, OsStr>

fn extend<I: IntoIterator<Item = Box<OsStr>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<Box<Path>> for Cow<'_, Path>

fn extend<I: IntoIterator<Item = Box<Path>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<Box<str>> for Cow<'_, str>

fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b> Extend<Cow<'b, OsStr>> for Cow<'a, OsStr>

fn extend<I: IntoIterator<Item = Cow<'b, OsStr>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b> Extend<Cow<'b, Path>> for Cow<'a, Path>

fn extend<I: IntoIterator<Item = Cow<'b, Path>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b> Extend<Cow<'b, str>> for Cow<'a, str>

fn extend<I: IntoIterator<Item = Cow<'b, str>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<OsString> for Cow<'_, OsStr>

fn extend<I: IntoIterator<Item = OsString>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<PathBuf> for Cow<'_, Path>

fn extend<I: IntoIterator<Item = PathBuf>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<String> for Cow<'_, str>

fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, 'b, T: 'a + Clone> Extend<T> for Cow<'a, [T]>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<char> for Cow<'_, str>

fn extend<I: IntoIterator<Item = char>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, T: 'a + Clone> From<&'a [T]> for Cow<'a, [T]>

fn from(v: &'a [T]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a CStr> for Cow<'a, CStr>

fn from(s: &'a CStr) -> Self

Converts to this type from the input type.

impl<'a> From<&'a CString> for Cow<'a, CStr>

fn from(s: &'a CString) -> Self

Converts to this type from the input type.

impl<'a> From<&'a OsStr> for Cow<'a, OsStr>

fn from(s: &'a OsStr) -> Self

Converts to this type from the input type.

impl<'a> From<&'a OsStr> for Cow<'a, Path>

fn from(p: &'a OsStr) -> Self

Converts to this type from the input type.

impl<'a> From<&'a OsString> for Cow<'a, OsStr>

fn from(s: &'a OsString) -> Self

Converts to this type from the input type.

impl<'a> From<&'a OsString> for Cow<'a, Path>

fn from(p: &'a OsString) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Path> for Cow<'a, OsStr>

fn from(s: &'a Path) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Path> for Cow<'a, Path>

fn from(p: &'a Path) -> Self

Converts to this type from the input type.

impl<'a> From<&'a PathBuf> for Cow<'a, OsStr>

fn from(s: &'a PathBuf) -> Self

Converts to this type from the input type.

impl<'a> From<&'a PathBuf> for Cow<'a, Path>

fn from(p: &'a PathBuf) -> Self

Converts to this type from the input type.

impl<'a> From<&'a String> for Cow<'a, OsStr>

fn from(s: &'a String) -> Self

Converts to this type from the input type.

impl<'a> From<&'a String> for Cow<'a, Path>

fn from(p: &'a String) -> Self

Converts to this type from the input type.

impl<'a> From<&'a String> for Cow<'a, str>

fn from(s: &'a String) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<'a> From<&'a str> for Cow<'a, OsStr>

fn from(p: &'a str) -> Self

Converts to this type from the input type.

impl<'a> From<&'a str> for Cow<'a, Path>

fn from(p: &'a str) -> Self

Converts to this type from the input type.

impl<'a> From<&'a str> for Cow<'a, str>

fn from(s: &'a str) -> Self

Converts to this type from the input type.

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

fn from(v: [T; N]) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + Clone> From<Box<[T]>> for Cow<'a, [T]>

fn from(v: Box<[T]>) -> Self

Converts to this type from the input type.

impl From<Box<CStr>> for Cow<'_, CStr>

fn from(s: Box<CStr>) -> Self

Converts to this type from the input type.

impl From<Box<OsStr>> for Cow<'_, OsStr>

fn from(s: Box<OsStr>) -> Self

Converts to this type from the input type.

impl From<Box<OsStr>> for Cow<'_, Path>

fn from(p: Box<OsStr>) -> Self

Converts to this type from the input type.

impl From<Box<Path>> for Cow<'_, OsStr>

fn from(s: Box<Path>) -> Self

Converts to this type from the input type.

impl From<Box<Path>> for Cow<'_, Path>

fn from(p: Box<Path>) -> Self

Converts to this type from the input type.

impl From<Box<str>> for Cow<'_, OsStr>

fn from(s: Box<str>) -> Self

Converts to this type from the input type.

impl From<Box<str>> for Cow<'_, Path>

fn from(p: Box<str>) -> Self

Converts to this type from the input type.

impl From<Box<str>> for Cow<'_, str>

fn from(s: Box<str>) -> Self

Converts to this type from the input type.

impl From<CString> for Cow<'_, CStr>

fn from(s: CString) -> Self

Converts to this type from the input type.

impl From<Cow<'_, CStr>> for Box<CStr>

fn from(s: Cow<'_, CStr>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, CStr>> for CString

fn from(s: Cow<'_, CStr>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, OsStr>> for Box<OsStr>

fn from(s: Cow<'_, OsStr>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, OsStr>> for OsString

fn from(s: Cow<'_, OsStr>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, Path>> for Box<Path>

fn from(p: Cow<'_, Path>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, Path>> for PathBuf

fn from(p: Cow<'_, Path>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, str>> for Box<str>

fn from(s: Cow<'_, str>) -> Self

Converts to this type from the input type.

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

fn from(s: Cow<'_, str>) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + Clone> From<Cow<'a, [T]>> for Box<[T]>

fn from(v: Cow<'a, [T]>) -> Self

Converts to this type from the input type.

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

fn from(v: Cow<'a, [T]>) -> Self

Converts to this type from the input type.

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

where T: Dairy<'a>,

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

Converts to this type from the input type.

impl From<OsString> for Cow<'_, OsStr>

fn from(s: OsString) -> Self

Converts to this type from the input type.

impl From<OsString> for Cow<'_, Path>

fn from(p: OsString) -> Self

Converts to this type from the input type.

impl From<PathBuf> for Cow<'_, Path>

fn from(p: PathBuf) -> Self

Converts to this type from the input type.

impl<'a> From<PathBuf> for Cow<'a, OsStr>

fn from(s: PathBuf) -> Self

Converts to this type from the input type.

impl From<String> for Cow<'_, OsStr>

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<String> for Cow<'_, Path>

fn from(p: String) -> Self

Converts to this type from the input type.

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

fn from(s: String) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl From<char> for Cow<'_, OsStr>

fn from(c: char) -> Self

Converts to this type from the input type.

impl From<char> for Cow<'_, str>

fn from(c: char) -> Self

Converts to this type from the input type.

impl<'a, 'b> FromIterator<&'b OsStr> for Cow<'a, OsStr>

fn from_iter<I: IntoIterator<Item = &'b OsStr>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, 'b> FromIterator<&'b OsString> for Cow<'a, OsStr>

fn from_iter<I: IntoIterator<Item = &'b OsString>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, 'b> FromIterator<&'b Path> for Cow<'a, Path>

fn from_iter<I: IntoIterator<Item = &'b Path>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, 'b> FromIterator<&'b PathBuf> for Cow<'a, Path>

fn from_iter<I: IntoIterator<Item = &'b PathBuf>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, 'b> FromIterator<&'b String> for Cow<'a, str>

fn from_iter<I: IntoIterator<Item = &'b String>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, 'b, T: 'a + 'b + Copy> FromIterator<&'b T> for Cow<'a, [T]>

fn from_iter<I: IntoIterator<Item = &'b T>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, 'b> FromIterator<&'b char> for Cow<'a, str>

fn from_iter<I: IntoIterator<Item = &'b char>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>

fn from_iter<I: IntoIterator<Item = &'b str>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Box<OsStr>> for Cow<'_, OsStr>

fn from_iter<I: IntoIterator<Item = Box<OsStr>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Box<Path>> for Cow<'_, Path>

fn from_iter<I: IntoIterator<Item = Box<Path>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Box<str>> for Cow<'_, str>

fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<Cow<'a, OsStr>> for Cow<'a, OsStr>

fn from_iter<I: IntoIterator<Item = Cow<'a, OsStr>>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<Cow<'a, Path>> for Cow<'a, Path>

fn from_iter<I: IntoIterator<Item = Cow<'a, Path>>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<Cow<'a, str>> for Cow<'a, str>

fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<OsString> for Cow<'_, OsStr>

fn from_iter<I: IntoIterator<Item = OsString>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<PathBuf> for Cow<'_, Path>

fn from_iter<I: IntoIterator<Item = PathBuf>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<String> for Cow<'_, str>

fn from_iter<I: IntoIterator<Item = String>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, 'b, T: 'a + Clone> FromIterator<T> for Cow<'a, [T]>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<char> for Cow<'_, str>

fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromStr for Cow<'a, OsStr>

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<'a> FromStr for Cow<'a, Path>

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<'a> FromStr for Cow<'a, str>

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

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

where T: ?Sized + Dairy<'a> + 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: ?Sized + Dairy<'a> + Ord,

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: 'a + Clone + PartialEq<U>, U> PartialEq<&[U]> for Cow<'a, [T]>

fn eq(&self, other: &&[U]) -> 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: 'a + Clone + PartialEq<U>, U, const N: usize> PartialEq<&[U; N]> for Cow<'a, [T]>

fn eq(&self, other: &&[U; N]) -> 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> PartialEq<&CStr> for Cow<'a, CStr>

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

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

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

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

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

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

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

fn eq(&self, other: &&OsString) -> 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> PartialEq<&Path> for Cow<'a, OsStr>

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

fn eq(&self, other: &&Path) -> 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> PartialEq<&PathBuf> for Cow<'a, OsStr>

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

fn eq(&self, other: &&PathBuf) -> 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> PartialEq<&String> for Cow<'a, str>

fn eq(&self, other: &&String) -> 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: 'a + Clone + PartialEq<U>, U> PartialEq<&Vec<U>> for Cow<'a, [T]>

fn eq(&self, other: &&Vec<U>) -> 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> PartialEq<&str> for Cow<'a, str>

fn eq(&self, other: &&str) -> 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: 'a + Clone + PartialEq<U>, U> PartialEq<[U]> for Cow<'a, [T]>

fn eq(&self, other: &[U]) -> 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: 'a + Clone + PartialEq<U>, U, const N: usize> PartialEq<[U; N]> for Cow<'a, [T]>

fn eq(&self, other: &[U; N]) -> 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> PartialEq<CStr> for Cow<'a, CStr>

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

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

where T: ?Sized + Dairy<'a> + PartialEq<U>, U: ?Sized + Dairy<'b>,

fn eq(&self, other: &Cow<'b, U>) -> 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> PartialEq<OsStr> for Cow<'a, OsStr>

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

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

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

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

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

fn eq(&self, other: &OsString) -> 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> PartialEq<Path> for Cow<'a, OsStr>

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

fn eq(&self, other: &Path) -> 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> PartialEq<PathBuf> for Cow<'a, OsStr>

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

fn eq(&self, other: &PathBuf) -> 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> PartialEq<String> for Cow<'a, str>

fn eq(&self, other: &String) -> 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: 'a + Clone + PartialEq<U>, U> PartialEq<Vec<U>> for Cow<'a, [T]>

fn eq(&self, other: &Vec<U>) -> 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> PartialEq<str> for Cow<'a, str>

fn eq(&self, other: &str) -> 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: ?Sized + Dairy<'a> + PartialOrd,

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

where T: ?Sized + Dairy<'a> + Eq,

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

where T: ?Sized + Dairy<'a> + Sync, T::Owned: Send,

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

where T: ?Sized + Dairy<'a> + Sync, T::Owned: Sync,

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

where T: ?Sized + Dairy<'a>, T::Owned: Unpin,