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

Note: this is an associated function, which means that you have to callit asCow::is_borrowed(&c) instead ofc.is_borrowed(). This is sothat there is no conflict with a method on the inner type.

§Examples

#![feature(cow_is_borrowed)]usestd::borrow::Cow;letcow = Cow::Borrowed("moo");assert!(Cow::is_borrowed(&cow));letbull: Cow<'_, str> = Cow::Owned("...moo?".to_string());assert!(!Cow::is_borrowed(&bull));

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

Note: this is an associated function, which means that you have to callit asCow::is_owned(&c) instead ofc.is_owned(). This is so thatthere is no conflict with a method on the inner type.

§Examples

#![feature(cow_is_borrowed)]usestd::borrow::Cow;letcow: Cow<'_, str> = Cow::Owned("moo".to_string());assert!(Cow::is_owned(&cow));letbull = Cow::Borrowed("...moo?");assert!(!Cow::is_owned(&bull));

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

Clones the data if it is not already owned.

§Examples

usestd::borrow::Cow;letmutcow = Cow::Borrowed("foo");cow.to_mut().make_ascii_uppercase();assert_eq!(  cow,  Cow::Owned(String::from("FOO"))asCow<'_, str>);

Extracts the owned data.

Clones the data if it is not already owned.

§Examples

Callinginto_owned on aCow::Borrowed returns a clone of the borrowed data:

usestd::borrow::Cow;lets ="Hello world!";letcow = Cow::Borrowed(s);assert_eq!(  cow.into_owned(),  String::from(s));

Callinginto_owned on aCow::Owned returns the owned data. The data is moved out of theCow without being cloned.

usestd::borrow::Cow;lets ="Hello world!";letcow: Cow<'_, str> = Cow::Owned(String::from(s));assert_eq!(  cow.into_owned(),  String::from(s));

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

Creates aBorrowed variant ofCowfrom a slice.

This conversion does not allocate or clone the data.

Creates aBorrowed variant ofCowfrom a reference to an array.

This conversion does not allocate or clone the data.

Converts aCStr into a borrowedCow without copying or allocating.

Converts a&CString into a borrowedCow without copying or allocating.

Converts the string reference into aCow::Borrowed.

Converts the string reference into aCow::Borrowed.

Creates a clone-on-write pointer from a reference toPath.

This conversion does not clone or allocate.

Creates a clone-on-write pointer from a reference toPathBuf.

This conversion does not clone or allocate.

Converts aString reference into aBorrowed variant.No heap allocation is performed, and the stringis not copied.

§Example

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

Creates aBorrowed variant ofCowfrom a reference toVec.

This conversion does not allocate or clone the data.

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

§Example

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

Converts aCString into an ownedCow without copying or allocating.

Converts aCow<'_, [T]> into aBox<[T]>

Whencow is theCow::Borrowed variant, thisconversion allocates on the heap and copies theunderlying slice. Otherwise, it will try to reuse the ownedVec’s allocation.

Converts aCow<'a, CStr> into aBox<CStr>,by copying the contents if they are borrowed.

Converts aCow<'a, OsStr> into aBox<OsStr>,by copying the contents if they are borrowed.

Creates a boxedPath from a clone-on-write pointer.

Converting from aCow::Owned does not clone or allocate.

Converts aCow<'_, str> into aBox<str>

Whencow is theCow::Borrowed variant, thisconversion allocates on the heap and copies theunderlyingstr. Otherwise, it will try to reuse the ownedString’s allocation.

§Examples

usestd::borrow::Cow;letunboxed = Cow::Borrowed("hello");letboxed: Box<str> = Box::from(unboxed);println!("{boxed}");

letunboxed = Cow::Owned("hello".to_string());letboxed: Box<str> = Box::from(unboxed);println!("{boxed}");

Converts a clone-on-write slice into a vector.

Ifs already owns aVec<T>, it will be returned directly.Ifs is borrowing a slice, a newVec<T> will be allocated andfilled by clonings’s items into it.

§Examples

leto: Cow<'_, [i32]> = Cow::Owned(vec![1,2,3]);letb: Cow<'_, [i32]> = Cow::Borrowed(&[1,2,3]);assert_eq!(Vec::from(o), Vec::from(b));

Creates an atomically reference-counted pointer from a clone-on-writepointer by copying its content.

§Example

letcow: Cow<'_, str> = Cow::Borrowed("eggplant");letshared: Arc<str> = Arc::from(cow);assert_eq!("eggplant",&shared[..]);

Creates a reference-counted pointer from a clone-on-write pointer bycopying its content.

§Example

letcow: Cow<'_, str> = Cow::Borrowed("eggplant");letshared: Rc<str> = Rc::from(cow);assert_eq!("eggplant",&shared[..]);

Converts aCow<'a, CStr> into aCString, by copying the contents if they areborrowed.

Converts aCow<'a, OsStr> into anOsString,by copying the contents if they are borrowed.

Converts a clone-on-write pointer to an owned path.

Converting from aCow::Owned does not clone or allocate.

Converts a clone-on-write string to an ownedinstance ofString.

This extracts the owned string,clones the string if it is not already owned.

§Example

// If the string is not owned...letcow: Cow<'_, str> = Cow::Borrowed("eggplant");// It will allocate on the heap and copy the string.letowned: String = String::from(cow);assert_eq!(&owned[..],"eggplant");

Converts aCow into a box of dynError.

§Examples

usestd::error::Error;usestd::borrow::Cow;leta_cow_str_error = Cow::from("a str error");leta_boxed_error = Box::<dynError>::from(a_cow_str_error);assert!(size_of::<Box<dynError>>() == size_of_val(&a_boxed_error))

Converts aCow into a box of dynError +Send +Sync.

§Examples

usestd::error::Error;usestd::borrow::Cow;leta_cow_str_error = Cow::from("a str error");leta_boxed_error = Box::<dynError + Send + Sync>::from(a_cow_str_error);assert!(    size_of::<Box<dynError + Send + Sync>>() == size_of_val(&a_boxed_error))

Moves the string into aCow::Owned.

Creates a clone-on-write pointer from an ownedinstance ofPathBuf.

This conversion does not clone or allocate.

Converts aString into anOwned variant.No heap allocation is performed, and the stringis not copied.

§Example

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

Creates anOwned variant ofCowfrom an owned instance ofVec.

This conversion does not allocate or clone the data.

Returns the argument unchanged.

CallsU::from(self).

That is, this conversion is whatever the implementation ofFrom<T> for U chooses to do.