Type Alias CollectionName

pub type CollectionName = Cow<'static, str>;

Aliased Type

enum CollectionName {
    Borrowed(&'static str),
    Owned(String),
}

Variants

Borrowed(&'static str)

Borrowed data.

Owned(String)

Owned data.

Implementations

impl<B> Cow<'_, B>

where B: ToOwned + ?Sized,

pub const fn is_borrowed(&self) -> bool

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

Returns true if the data is borrowed, i.e. if to_mut would require additional work.

Examples

#![feature(cow_is_borrowed)]
use std::borrow::Cow;

let cow = Cow::Borrowed("moo");
assert!(cow.is_borrowed());

let bull: Cow<'_, str> = Cow::Owned("...moo?".to_string());
assert!(!bull.is_borrowed());

pub const fn is_owned(&self) -> bool

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

Returns true if the data is owned, i.e. if to_mut would be a no-op.

Examples

#![feature(cow_is_borrowed)]
use std::borrow::Cow;

let cow: Cow<'_, str> = Cow::Owned("moo".to_string());
assert!(cow.is_owned());

let bull = Cow::Borrowed("...moo?");
assert!(!bull.is_owned());

pub fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned

Acquires a mutable reference to the owned form of the data.

Clones the data if it is not already owned.

Examples

use std::borrow::Cow;

let mut cow = Cow::Borrowed("foo");
cow.to_mut().make_ascii_uppercase();

assert_eq!(
  cow,
  Cow::Owned(String::from("FOO")) as Cow<'_, str>
);

pub fn into_owned(self) -> <B as ToOwned>::Owned

Extracts the owned data.

Clones the data if it is not already owned.

Examples

Calling into_owned on a Cow::Borrowed returns a clone of the borrowed data:

use std::borrow::Cow;

let s = "Hello world!";
let cow = Cow::Borrowed(s);

assert_eq!(
  cow.into_owned(),
  String::from(s)
);

Calling into_owned on a Cow::Owned returns the owned data. The data is moved out of the Cow without being cloned.

use std::borrow::Cow;

let s = "Hello world!";
let cow: Cow<'_, str> = Cow::Owned(String::from(s));

assert_eq!(
  cow.into_owned(),
  String::from(s)
);

Trait Implementations

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

type Output = Cow<'a, str>

The resulting type after applying the + operator.

fn add(self, rhs: &'a str) -> <Cow<'a, str> as Add<&'a str>>::Output

Performs the + operation.

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

type Output = Cow<'a, str>

The resulting type after applying the + operator.

fn add(self, rhs: Cow<'a, str>) -> <Cow<'a, str> as Add>::Output

Performs the + operation.

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

fn add_assign(&mut self, rhs: &'a str)

Performs the += operation.

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

fn add_assign(&mut self, rhs: Cow<'a, str>)

Performs the += operation.

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

where T: ToOwned + ?Sized,

fn as_ref(&self) -> &T

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

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

where B: ToOwned + ?Sized,

fn borrow(&self) -> &B

Immutably borrows from an owned value.

impl<B> Clone for Cow<'_, B>

where B: ToOwned + ?Sized,

fn clone(&self) -> Cow<'_, B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Cow<'_, B>)

Performs copy-assignment from source.

impl<B> Debug for Cow<'_, B>

where B: Debug + ToOwned + ?Sized, <B as ToOwned>::Owned: Debug,

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

Formats the value using the given formatter.

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

where B: ToOwned + ?Sized, <B as ToOwned>::Owned: Default,

fn default() -> Cow<'_, B>

Creates an owned Cow<’a, B> with the default value for the contained owned value.

impl<'de, 'a, T> Deserialize<'de> for Cow<'a, T>

where T: ToOwned + ?Sized, <T as ToOwned>::Owned: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<Cow<'a, T>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<B> Display for Cow<'_, B>

where B: Display + ToOwned + ?Sized, <B as ToOwned>::Owned: Display,

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

Formats the value using the given formatter.

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

where T: VarULE + ToOwned + ?Sized,

fn encode_var_ule_as_slices<R>(&self, cb: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated produce the memory pattern of the corresponding instance of T.

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should be the size of [Self::encode_var_ule_len()]

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

where T: FastWritable + ToOwned,

fn write_into<W>(&self, dest: &mut W) -> Result<(), Error>

where W: Write + ?Sized,

Used internally by rinja to speed up writing some types.

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

fn from(s: &'a String) -> Cow<'a, str>

Converts a String reference into a Borrowed variant. No heap allocation is performed, and the string is not copied.

Example

let s = "eggplant".to_string();
assert_eq!(Cow::from(&s), Cow::Borrowed("eggplant"));

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

fn from(s: &'a str) -> Cow<'a, str>

Converts a string slice into a Borrowed variant. No heap allocation is performed, and the string is not copied.

Example

assert_eq!(Cow::from("eggplant"), Cow::Borrowed("eggplant"));

impl From<HeaderName> for Cow<'static, str>

fn from(h: HeaderName) -> Cow<'static, str>

Converts to this type from the input type.

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

fn from(iter: PercentEncode<'a>) -> Cow<'a, str>

Converts to this type from the input type.

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

fn from(s: String) -> Cow<'a, str>

Converts a String into an Owned variant. No heap allocation is performed, and the string is not copied.

Example

let s = "eggplant".to_string();
let s2 = "eggplant".to_string();
assert_eq!(Cow::from(s), Cow::<'static, str>::Owned(s2));

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

fn from_iter<I>(it: I) -> Cow<'a, str>

where I: IntoIterator<Item = &'b str>,

Creates a value from an iterator.

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

fn from_iter<I>(it: I) -> Cow<'a, str>

where I: IntoIterator<Item = String>,

Creates a value from an iterator.

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

fn from_iter<I>(it: I) -> Cow<'a, str>

where I: IntoIterator<Item = char>,

Creates a value from an iterator.

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

where T: ToOwned + ?Sized, <T as ToOwned>::Owned: FromSql,

fn column_result(value: ValueRef<'_>) -> Result<Cow<'_, T>, FromSqlError>

Converts SQLite value into Rust value.

impl<B> Hash for Cow<'_, B>

where B: Hash + ToOwned + ?Sized,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>

where E: Error,

type Deserializer = CowStrDeserializer<'a, E>

The type of the deserializer being converted into.

fn into_deserializer(self) -> CowStrDeserializer<'a, E>

Convert this value into a deserializer.

impl<B> Ord for Cow<'_, B>

where B: Ord + ToOwned + ?Sized,

fn cmp(&self, other: &Cow<'_, B>) -> 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, 'b> PartialEq<&'a Utf8Path> for Cow<'b, str>

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

fn eq(&self, other: &&'b str) -> bool

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

fn ne(&self, other: &&'b str) -> bool

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

impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B>

where B: PartialEq<C> + ToOwned + ?Sized, C: ToOwned + ?Sized,

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

fn eq(&self, other: &HeaderName) -> 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> 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: &String) -> bool

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

impl<'a, 'b> PartialEq<Utf8Path> for Cow<'a, str>

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

fn eq(&self, other: &Utf8PathBuf) -> 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> 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: &str) -> bool

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

impl<'a, 'b> PartialOrd<&'a Utf8Path> for Cow<'b, str>

fn partial_cmp(&self, other: &&'a Utf8Path) -> 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, 'b> PartialOrd<Utf8Path> for Cow<'a, str>

fn partial_cmp(&self, other: &Utf8Path) -> 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, 'b> PartialOrd<Utf8PathBuf> for Cow<'a, str>

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

where B: PartialOrd + ToOwned + ?Sized,

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

where T: Serialize + ToOwned + ?Sized,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

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

where T: ToSql + ToOwned + ?Sized,

fn to_sql(&self) -> Result<ToSqlOutput<'_>, Error>

Converts Rust value to SQLite value

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

where T: Writeable + ToOwned + ?Sized,

fn write_to<W>(&self, sink: &mut W) -> Result<(), Error>

where W: Write + ?Sized,

Writes a string to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to_parts, and discards any Part annotations.

fn write_to_parts<W>(&self, sink: &mut W) -> Result<(), Error>

where W: PartsWrite + ?Sized,

Write bytes and Part annotations to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to, and doesn’t produce any Part annotations.

fn writeable_length_hint(&self) -> LengthHint

Returns a hint for the number of UTF-8 bytes that will be written to the sink.

fn write_to_string(&self) -> Cow<'_, str>

Creates a new String with the data from this Writeable. Like ToString, but smaller and faster.

fn writeable_cmp_bytes(&self, other: &[u8]) -> Ordering

Compares the contents of this Writeable to the given bytes without allocating a String to hold the Writeable contents.

impl<'a, T> Yokeable<'a> for Cow<'static, T>

where T: 'static + ToOwned + ?Sized, <T as ToOwned>::Owned: Sized,

type Output = Cow<'a, T>

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>

fn transform(&'a self) -> &'a Cow<'a, T>

This method must cast self between &'a Self<'static> and &'a Self<'a>.

fn transform_owned(self) -> Cow<'a, T>

This method must cast self between Self<'static> and Self<'a>.

unsafe fn make(from: Cow<'a, T>) -> Cow<'static, T>

This method can be used to cast away Self<'a>’s lifetime.

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <Cow<'static, T> as Yokeable<'a>>::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>, and pass it to f.

impl<'zf, B> ZeroFrom<'zf, Cow<'_, B>> for Cow<'zf, B>

where B: ToOwned + ?Sized,

fn zero_from(other: &'zf Cow<'_, B>) -> Cow<'zf, B>

Clone the other C into a struct that may retain references into C.

impl<'zf> ZeroFrom<'zf, String> for Cow<'zf, str>

fn zero_from(other: &'zf String) -> Cow<'zf, str>

Clone the other C into a struct that may retain references into C.

impl<'zf> ZeroFrom<'zf, str> for Cow<'zf, str>

fn zero_from(other: &'zf str) -> Cow<'zf, str>

Clone the other C into a struct that may retain references into C.

impl<B> Deref for Cow<'_, B>

where B: ToOwned + ?Sized, <B as ToOwned>::Owned: Borrow<B>,

type Target = B

The resulting type after dereferencing.

fn deref(&self) -> &B

Dereferences the value.

impl<B> DerefPure for Cow<'_, B>

where B: ToOwned + ?Sized, <B as ToOwned>::Owned: Borrow<B>,

impl<B> Eq for Cow<'_, B>

where B: Eq + ToOwned + ?Sized,

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

where T: HtmlSafe + ToOwned + ?Sized, <T as ToOwned>::Owned: HtmlSafe,