Enum Cow 

pub enum Cow<'a, B>
where
    B: 'a + ToOwned + ?Sized,
{
    Borrowed(&'a B),
    Owned(<B as ToOwned>::Owned),
}

Available on crate feature wayland and Linux only.

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. The type is designed to work with general borrowed data via the Borrow trait.

Cow implements Deref, which means that you can call non-mutating methods directly on the data it encloses. If mutation is desired, to_mut will obtain a mutable reference to an owned value, cloning if necessary.

If you need reference-counting pointers, note that Rc::make_mut and Arc::make_mut can provide clone-on-write functionality as well.

Examples

use std::borrow::Cow;

fn abs_all(input: &mut Cow<'_, [i32]>) {
    for i in 0..input.len() {
        let v = input[i];
        if v < 0 {
            // Clones into a vector if not already owned.
            input.to_mut()[i] = -v;
        }
    }
}

// No clone occurs because `input` doesn't need to be mutated.
let slice = [0, 1, 2];
let mut input = Cow::from(&slice[..]);
abs_all(&mut input);

// Clone occurs because `input` needs to be mutated.
let slice = [-1, 0, 1];
let mut input = Cow::from(&slice[..]);
abs_all(&mut input);

// No clone occurs because `input` is already owned.
let mut input = Cow::from(vec![-1, 0, 1]);
abs_all(&mut input);

Another example showing how to keep Cow in a struct:

use std::borrow::Cow;

struct Items<'a, X> where [X]: ToOwned<Owned = Vec<X>> {
    values: Cow<'a, [X]>,
}

impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned<Owned = Vec<X>> {
    fn new(v: Cow<'a, [X]>) -> Self {
        Items { values: v }
    }
}

// Creates a container from borrowed values of a slice
let readonly = [1, 2];
let borrowed = Items::new((&readonly[..]).into());
match borrowed {
    Items { values: Cow::Borrowed(b) } => println!("borrowed {b:?}"),
    _ => panic!("expect borrowed value"),
}

let mut clone_on_write = borrowed;
// Mutates the data from slice into owned vec and pushes a new value on top
clone_on_write.values.to_mut().push(3);
println!("clone_on_write = {:?}", clone_on_write.values);

// The data was mutated. Let's check it out.
match clone_on_write {
    Items { values: Cow::Owned(_) } => println!("clone_on_write contains owned data"),
    _ => panic!("expect owned data"),
}

Variants

Borrowed(&'a B)

Borrowed data.

Owned(<B as ToOwned>::Owned)

Owned data.

Implementations

impl<B> Cow<'_, B>

where B: ToOwned + ?Sized,

pub const fn is_borrowed(c: &Cow<'_, B>) -> 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.

Note: this is an associated function, which means that you have to call it as Cow::is_borrowed(&c) instead of c.is_borrowed(). This is so that there is no conflict with a method on the inner type.

Examples

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

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

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

pub const fn is_owned(c: &Cow<'_, B>) -> 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.

Note: this is an associated function, which means that you have to call it as Cow::is_owned(&c) instead of c.is_owned(). This is so that there is no conflict with a method on the inner type.

Examples

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

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

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

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<'i> Accumulate<&'i str> for Cow<'i, str>

Available on crate feature alloc only.

fn initial(_capacity: Option<usize>) -> Cow<'i, str>

Create a new Extend of the correct type

fn accumulate(&mut self, acc: &'i str)

Accumulate the input into an accumulator

impl<'i> Accumulate<Cow<'i, str>> for Cow<'i, str>

Available on crate feature alloc only.

fn initial(_capacity: Option<usize>) -> Cow<'i, str>

Create a new Extend of the correct type

fn accumulate(&mut self, acc: Cow<'i, str>)

Accumulate the input into an accumulator

impl<'i> Accumulate<Cow<'i, str>> for String

Available on crate feature alloc only.

fn initial(capacity: Option<usize>) -> String

Create a new Extend of the correct type

fn accumulate(&mut self, acc: Cow<'i, str>)

Accumulate the input into an accumulator

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

Available on crate feature alloc only.

fn initial(_capacity: Option<usize>) -> Cow<'_, str>

Create a new Extend of the correct type

fn accumulate(&mut self, acc: String)

Accumulate the input into an accumulator

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

Available on crate feature alloc only.

fn initial(_capacity: Option<usize>) -> Cow<'_, str>

Create a new Extend of the correct type

fn accumulate(&mut self, acc: char)

Accumulate the input into an accumulator

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

Available on non-no_global_oom_handling only.

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>

Available on non-no_global_oom_handling only.

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>

Available on non-no_global_oom_handling only.

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

Performs the += operation.

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

Available on non-no_global_oom_handling only.

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

Performs the += operation.

impl<'a> Arg for Cow<'a, CStr>

Available on crate feature alloc only.

fn as_str(&self) -> Result<&str, Errno>

Returns a view of this string as a string slice.

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

Returns a potentially-lossy rendering of this string as a Cow<'_, str>.

fn as_cow_c_str(&self) -> Result<Cow<'_, CStr>, Errno>

Returns a view of this string as a maybe-owned CStr.

fn into_c_str<'b>(self) -> Result<Cow<'b, CStr>, Errno>

where Cow<'a, CStr>: 'b,

Consumes self and returns a view of this string as a maybe-owned CStr.

fn into_with_c_str<T, F>(self, f: F) -> Result<T, Errno>

where Cow<'a, CStr>: Sized, F: FnOnce(&CStr) -> Result<T, Errno>,

Runs a closure with self passed in as a &CStr.

impl<'a> Arg for Cow<'a, CStr>

Available on crate feature alloc only.

fn as_str(&self) -> Result<&str, Errno>

Returns a view of this string as a string slice.

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

Returns a potentially-lossy rendering of this string as a Cow<'_, str>.

fn as_cow_c_str(&self) -> Result<Cow<'_, CStr>, Errno>

Returns a view of this string as a maybe-owned CStr.

fn into_c_str<'b>(self) -> Result<Cow<'b, CStr>, Errno>

where Cow<'a, CStr>: 'b,

Consumes self and returns a view of this string as a maybe-owned CStr.

fn into_with_c_str<T, F>(self, f: F) -> Result<T, Errno>

where Cow<'a, CStr>: Sized, F: FnOnce(&CStr) -> Result<T, Errno>,

Runs a closure with self passed in as a &CStr.

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

Available on crate feature std only.

fn as_str(&self) -> Result<&str, Errno>

Returns a view of this string as a string slice.

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

Available on crate feature alloc only.

Returns a potentially-lossy rendering of this string as a Cow<'_, str>.

fn as_cow_c_str(&self) -> Result<Cow<'_, CStr>, Errno>

Available on crate feature alloc only.

Returns a view of this string as a maybe-owned CStr.

fn into_c_str<'b>(self) -> Result<Cow<'b, CStr>, Errno>

where Cow<'a, OsStr>: 'b,

Available on crate feature alloc only.

Consumes self and returns a view of this string as a maybe-owned CStr.

fn into_with_c_str<T, F>(self, f: F) -> Result<T, Errno>

where Cow<'a, OsStr>: Sized, F: FnOnce(&CStr) -> Result<T, Errno>,

Runs a closure with self passed in as a &CStr.

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

Available on crate features std and alloc only.

fn as_str(&self) -> Result<&str, Errno>

Returns a view of this string as a string slice.

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

Returns a potentially-lossy rendering of this string as a Cow<'_, str>.

fn as_cow_c_str(&self) -> Result<Cow<'_, CStr>, Errno>

Returns a view of this string as a maybe-owned CStr.

fn into_c_str<'b>(self) -> Result<Cow<'b, CStr>, Errno>

where Cow<'a, OsStr>: 'b,

Consumes self and returns a view of this string as a maybe-owned CStr.

fn into_with_c_str<T, F>(self, f: F) -> Result<T, Errno>

where Cow<'a, OsStr>: Sized, F: FnOnce(&CStr) -> Result<T, Errno>,

Runs a closure with self passed in as a &CStr.

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

Available on crate feature alloc only.

fn as_str(&self) -> Result<&str, Errno>

Returns a view of this string as a string slice.

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

Returns a potentially-lossy rendering of this string as a Cow<'_, str>.

fn as_cow_c_str(&self) -> Result<Cow<'_, CStr>, Errno>

Returns a view of this string as a maybe-owned CStr.

fn into_c_str<'b>(self) -> Result<Cow<'b, CStr>, Errno>

where Cow<'a, str>: 'b,

Consumes self and returns a view of this string as a maybe-owned CStr.

fn into_with_c_str<T, F>(self, f: F) -> Result<T, Errno>

where Cow<'a, str>: Sized, F: FnOnce(&CStr) -> Result<T, Errno>,

Runs a closure with self passed in as a &CStr.

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

Available on crate feature alloc only.

fn as_str(&self) -> Result<&str, Errno>

Returns a view of this string as a string slice.

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

Returns a potentially-lossy rendering of this string as a Cow<'_, str>.

fn as_cow_c_str(&self) -> Result<Cow<'_, CStr>, Errno>

Returns a view of this string as a maybe-owned CStr.

fn into_c_str<'b>(self) -> Result<Cow<'b, CStr>, Errno>

where Cow<'a, str>: 'b,

Consumes self and returns a view of this string as a maybe-owned CStr.

fn into_with_c_str<T, F>(self, f: F) -> Result<T, Errno>

where Cow<'a, str>: Sized, F: FnOnce(&CStr) -> Result<T, Errno>,

Runs a closure with self passed in as a &CStr.

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

where T: AsRawXcbConnection + ToOwned + ?Sized,

Available on crate feature alloc only.

fn as_raw_xcb_connection(&self) -> *mut xcb_connection_t

Get a raw xcb connection pointer from this object.

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

where T: Basic + ToOwned + ?Sized,

const SIGNATURE_CHAR: char = T::SIGNATURE_CHAR

The type signature, as a character.

const SIGNATURE_STR: &'static str = T::SIGNATURE_STR

The type signature, as a string.

fn alignment(format: Format) -> usize

The required padding alignment for the given format.

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 duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Connection for Cow<'_, C>

where C: Connection + ToOwned + ?Sized,

fn wait_for_event(&self) -> Result<Event, ConnectionError>

Wait for a new event from the X11 server.

fn wait_for_raw_event( &self, ) -> Result<<Cow<'_, C> as RequestConnection>::Buf, ConnectionError>

Wait for a new raw/unparsed event from the X11 server.

fn wait_for_event_with_sequence(&self) -> Result<(Event, u64), ConnectionError>

Wait for a new event from the X11 server.

fn wait_for_raw_event_with_sequence( &self, ) -> Result<(<Cow<'_, C> as RequestConnection>::Buf, u64), ConnectionError>

Wait for a new raw/unparsed event from the X11 server.

fn poll_for_event(&self) -> Result<Option<Event>, ConnectionError>

Poll for a new event from the X11 server.

fn poll_for_raw_event( &self, ) -> Result<Option<<Cow<'_, C> as RequestConnection>::Buf>, ConnectionError>

Poll for a new raw/unparsed event from the X11 server.

fn poll_for_event_with_sequence( &self, ) -> Result<Option<(Event, u64)>, ConnectionError>

Poll for a new event from the X11 server.

fn poll_for_raw_event_with_sequence( &self, ) -> Result<Option<(<Cow<'_, C> as RequestConnection>::Buf, u64)>, ConnectionError>

Poll for a new unparsed/raw event from the X11 server.

fn flush(&self) -> Result<(), ConnectionError>

Send all pending requests to the server.

fn setup(&self) -> &Setup

Get the setup information sent by the X11 server.

fn generate_id(&self) -> Result<u32, ReplyOrIdError>

Generate a new X11 identifier.

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<B> Deref for Cow<'_, B>

where B: ToOwned + ?Sized,

type Target = B

The resulting type after dereferencing.

fn deref(&self) -> &B

Dereferences the value.

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

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

Available on crate features std or alloc only.

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,

Available on crate feature alloc only.

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<'a> Extend<Cow<'a, str>> for String

Available on non-no_global_oom_handling only.

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = Cow<'a, str>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, s: Cow<'a, str>)

🔬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> From<&'a [T]> for Cow<'a, [T]>

where T: Clone,

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

Creates a Borrowed variant of Cow from a slice.

This conversion does not allocate or clone the data.

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

where T: Clone,

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

Creates a Borrowed variant of Cow from a reference to an array.

This conversion does not allocate or clone the data.

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

Available on crate feature alloc only.

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

Converts to this type from the input type.

impl<'a> From<&'a BString> for Cow<'a, BStr>

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<'a> From<&'a ByteString> for Cow<'a, ByteStr>

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

Converts to this type from the input type.

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

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

Converts a CStr into a borrowed Cow without copying or allocating.

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

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

Converts a &CString into a borrowed Cow without copying or allocating.

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

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

Converts the string reference into a Cow::Borrowed.

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

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

Converts the string reference into a Cow::Borrowed.

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

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

Creates a clone-on-write pointer from a reference to Path.

This conversion does not clone or allocate.

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

fn from(p: &'a PathBuf) -> Cow<'a, Path>

Creates a clone-on-write pointer from a reference to PathBuf.

This conversion does not clone or allocate.

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

Available on non-no_global_oom_handling only.

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, T> From<&'a Vec<T>> for Cow<'a, [T]>

where T: Clone,

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

Creates a Borrowed variant of Cow from a reference to Vec.

This conversion does not allocate or clone the data.

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

Available on non-no_global_oom_handling only.

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<'a> From<BString> for Cow<'a, BStr>

fn from(s: BString) -> Cow<'a, BStr>

Converts to this type from the input type.

impl<'a> From<ByteString> for Cow<'a, ByteStr>

fn from(s: ByteString) -> Cow<'a, ByteStr>

Converts to this type from the input type.

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

fn from(s: CString) -> Cow<'a, CStr>

Converts a CString into an owned Cow without copying or allocating.

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

where T: Clone,

Available on non-no_global_oom_handling only.

fn from(cow: Cow<'_, [T]>) -> Box<[T]>

Converts a Cow<'_, [T]> into a Box<[T]>

When cow is the Cow::Borrowed variant, this conversion allocates on the heap and copies the underlying slice. Otherwise, it will try to reuse the owned Vec’s allocation.

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

fn from(cow: Cow<'_, CStr>) -> Box<CStr>

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

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

fn from(cow: Cow<'_, OsStr>) -> Box<OsStr>

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

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

fn from(cow: Cow<'_, Path>) -> Box<Path>

Creates a boxed Path from a clone-on-write pointer.

Converting from a Cow::Owned does not clone or allocate.

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

Available on non-no_global_oom_handling only.

fn from(cow: Cow<'_, str>) -> Box<str>

Converts a Cow<'_, str> into a Box<str>

When cow is the Cow::Borrowed variant, this conversion allocates on the heap and copies the underlying str. Otherwise, it will try to reuse the owned String’s allocation.

Examples

use std::borrow::Cow;

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

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

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

where [T]: ToOwned<Owned = Vec<T>>,

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

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

If s already owns a Vec<T>, it will be returned directly. If s is borrowing a slice, a new Vec<T> will be allocated and filled by cloning s’s items into it.

Examples

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

impl<'a, B> From<Cow<'a, B>> for Arc<B>

where B: ToOwned + ?Sized, Arc<B>: From<&'a B> + From<<B as ToOwned>::Owned>,

fn from(cow: Cow<'a, B>) -> Arc<B>

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

Example

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

impl<'a, B> From<Cow<'a, B>> for Rc<B>

where B: ToOwned + ?Sized, Rc<B>: From<&'a B> + From<<B as ToOwned>::Owned>,

fn from(cow: Cow<'a, B>) -> Rc<B>

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

Example

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

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

fn from(s: Cow<'a, CStr>) -> CString

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

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

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

Converts to this type from the input type.

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

Available on non-no_global_oom_handling only.

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

Converts a clone-on-write string to an owned instance of String.

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

Example

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

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

fn from(v: Cow<'a, str>) -> Value<'a>

Converts to this type from the input type.

impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>

Available on non-no_global_oom_handling only.

fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a>

Converts a Cow into a box of dyn Error.

Examples

use std::error::Error;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
assert!(size_of::<Box<dyn Error>>() == size_of_val(&a_boxed_error))

impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Sync + Send + 'a>

Available on non-no_global_oom_handling only.

fn from(err: Cow<'b, str>) -> Box<dyn Error + Sync + Send + 'a>

Converts a Cow into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
    size_of::<Box<dyn Error + Send + Sync>>() == size_of_val(&a_boxed_error))

impl<'a> From<FontData<'a>> for Cow<'a, [u8]>

Available on crate feature std only.

fn from(src: FontData<'a>) -> Cow<'a, [u8]>

Converts to this type from the input type.

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

fn from(s: OsString) -> Cow<'a, OsStr>

Moves the string into a Cow::Owned.

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

fn from(s: PathBuf) -> Cow<'a, Path>

Creates a clone-on-write pointer from an owned instance of PathBuf.

This conversion does not clone or allocate.

impl<'a> From<PercentDecode<'a>> for Cow<'a, [u8]>

Available on crate feature alloc only.

fn from(iter: PercentDecode<'a>) -> Cow<'a, [u8]>

Converts to this type from the input type.

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

Available on crate feature alloc only.

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

Converts to this type from the input type.

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

Available on non-no_global_oom_handling only.

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, T> From<Vec<T>> for Cow<'a, [T]>

where T: Clone,

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

Creates an Owned variant of Cow from an owned instance of Vec.

This conversion does not allocate or clone the data.

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

Available on non-no_global_oom_handling only.

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

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

Creates a value from an iterator.

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

Available on non-no_global_oom_handling only.

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

where T: IntoIterator<Item = AsciiChar>,

Creates a value from an iterator.

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

Available on non-no_global_oom_handling only.

fn from_iter<T>(iter: T) -> Box<str>

where T: IntoIterator<Item = Cow<'a, str>>,

Creates a value from an iterator.

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

Available on non-no_global_oom_handling only.

fn from_iter<I>(iter: I) -> String

where I: IntoIterator<Item = Cow<'a, str>>,

Creates a value from an iterator.

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

Available on non-no_global_oom_handling only.

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

where I: IntoIterator<Item = String>,

Creates a value from an iterator.

impl<'a, T> FromIterator<T> for Cow<'a, [T]>

where T: Clone,

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

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

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

Available on non-no_global_oom_handling only.

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

where I: IntoIterator<Item = char>,

Creates a value from an iterator.

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

where T: IdentFragment + ToOwned + ?Sized,

fn span(&self) -> Option<Span>

Span associated with this IdentFragment.

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

Format this value as an identifier fragment.

impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>

where E: Error,

Available on crate features std or alloc only.

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<'a> IntoFragment<'a> for &'a Cow<'_, str>

fn into_fragment(self) -> Cow<'a, str>

Converts the value to some text Fragment.

impl<'a> IntoFragment<'a> for &'a Cow<'_, str>

fn into_fragment(self) -> Cow<'a, str>

Converts the value to some text [Fragment].

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

fn into_fragment(self) -> Cow<'a, str>

Converts the value to some text Fragment.

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

fn into_fragment(self) -> Cow<'a, str>

Converts the value to some text [Fragment].

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<T, U> PartialEq<&[U]> for Cow<'_, [T]>

where T: PartialEq<U> + Clone,

fn eq(&self, other: &&[U]) -> bool

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

fn ne(&self, other: &&[U]) -> bool

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

impl<'a> PartialEq<&'a BStr> for Cow<'a, [u8]>

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

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

fn eq(&self, other: &&'a BStr) -> 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 PartialEq<&ByteStr> for Cow<'_, [u8]>

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

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

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

Available on non-no_global_oom_handling only.

fn eq(&self, other: &&CStr) -> bool

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

fn ne(&self, other: &&CStr) -> bool

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

impl PartialEq<&OsStr> for Cow<'_, 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 PartialEq<&OsStr> for Cow<'_, 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 PartialEq<&Path> for Cow<'_, 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 PartialEq<&Path> for Cow<'_, 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<T, U> PartialEq<&mut [U]> for Cow<'_, [T]>

where T: PartialEq<U> + Clone,

fn eq(&self, other: &&mut [U]) -> bool

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

fn ne(&self, other: &&mut [U]) -> bool

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

impl PartialEq<&str> for Cow<'_, 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 PartialEq<ByteString> for Cow<'_, [u8]>

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

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

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

Available on non-no_global_oom_handling only.

fn eq(&self, other: &CStr) -> bool

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

fn ne(&self, other: &CStr) -> bool

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

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

Available on non-no_global_oom_handling only.

fn eq(&self, other: &CString) -> bool

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

fn ne(&self, other: &CString) -> bool

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

impl PartialEq<Cow<'_, [u8]>> for &ByteStr

fn eq(&self, other: &Cow<'_, [u8]>) -> 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 PartialEq<Cow<'_, [u8]>> for ByteString

fn eq(&self, other: &Cow<'_, [u8]>) -> 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 PartialEq<Cow<'_, ByteStr>> for &ByteStr

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

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

Available on non-no_global_oom_handling only.

fn eq(&self, other: &Cow<'_, CStr>) -> bool

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

fn ne(&self, other: &Cow<'_, CStr>) -> bool

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

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

Available on non-no_global_oom_handling only.

fn eq(&self, other: &Cow<'_, CStr>) -> bool

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

fn ne(&self, other: &Cow<'_, CStr>) -> bool

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

impl PartialEq<Cow<'_, OsStr>> for &OsStr

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

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

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

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

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

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

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

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

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

fn eq(&self, other: &Cow<'_, str>) -> bool

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

fn ne(&self, other: &Cow<'_, str>) -> bool

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

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

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

fn eq(&self, other: &Cow<'_, str>) -> bool

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

fn ne(&self, other: &Cow<'_, str>) -> bool

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

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

fn eq(&self, other: &Cow<'_, str>) -> bool

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

fn ne(&self, other: &Cow<'_, 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 PartialEq<OsStr> for Cow<'_, 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 PartialEq<OsStr> for Cow<'_, 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 PartialEq<OsString> for Cow<'_, 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 PartialEq<OsString> for Cow<'_, 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 PartialEq<Path> for Cow<'_, 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 PartialEq<Path> for Cow<'_, 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 PartialEq<PathBuf> for Cow<'_, 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 PartialEq<PathBuf> for Cow<'_, 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 PartialEq<String> for Cow<'_, 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<T, U, A> PartialEq<Vec<U, A>> for Cow<'_, [T]>

where A: Allocator, T: PartialEq<U> + Clone,

fn eq(&self, other: &Vec<U, A>) -> bool

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

fn ne(&self, other: &Vec<U, A>) -> bool

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

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

where A: Allocator, T: PartialEq<U> + Clone,

fn eq(&self, other: &Vec<U, A>) -> bool

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

fn ne(&self, other: &Vec<U, A>) -> bool

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

impl PartialEq<str> for Cow<'_, 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 PartialOrd<&ByteStr> for Cow<'_, [u8]>

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

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

fn partial_cmp(&self, other: &&ByteStr) -> 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 PartialOrd<&OsStr> for Cow<'_, OsStr>

fn partial_cmp(&self, other: &&OsStr) -> 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 PartialOrd<&OsStr> for Cow<'_, Path>

fn partial_cmp(&self, other: &&OsStr) -> 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 PartialOrd<&Path> for Cow<'_, OsStr>

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

fn partial_cmp(&self, other: &&Path) -> 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 PartialOrd<ByteString> for Cow<'_, [u8]>

fn partial_cmp(&self, other: &ByteString) -> 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 PartialOrd<ByteString> for Cow<'_, ByteStr>

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

fn partial_cmp(&self, other: &ByteString) -> 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 PartialOrd<Cow<'_, [u8]>> for &ByteStr

fn partial_cmp(&self, other: &Cow<'_, [u8]>) -> 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 PartialOrd<Cow<'_, [u8]>> for ByteString

fn partial_cmp(&self, other: &Cow<'_, [u8]>) -> 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 PartialOrd<Cow<'_, ByteStr>> for &ByteStr

fn partial_cmp(&self, other: &Cow<'_, ByteStr>) -> 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 PartialOrd<Cow<'_, ByteStr>> for ByteString

fn partial_cmp(&self, other: &Cow<'_, ByteStr>) -> 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 PartialOrd<Cow<'_, OsStr>> for &OsStr

fn partial_cmp(&self, other: &Cow<'_, OsStr>) -> 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 PartialOrd<Cow<'_, OsStr>> for &Path

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

fn partial_cmp(&self, other: &Cow<'_, OsStr>) -> 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 PartialOrd<Cow<'_, OsStr>> for Path

fn partial_cmp(&self, other: &Cow<'_, OsStr>) -> 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 PartialOrd<Cow<'_, Path>> for &OsStr

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

fn partial_cmp(&self, other: &Cow<'_, Path>) -> 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 PartialOrd<Cow<'_, Path>> for OsStr

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

fn partial_cmp(&self, other: &Cow<'_, Path>) -> 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 PartialOrd<Cow<'_, str>> for &ByteStr

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

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

fn partial_cmp(&self, other: &OsStr) -> 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 PartialOrd<OsStr> for Cow<'_, Path>

fn partial_cmp(&self, other: &OsStr) -> 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 PartialOrd<OsString> for Cow<'_, OsStr>

fn partial_cmp(&self, other: &OsString) -> 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 PartialOrd<OsString> for Cow<'_, Path>

fn partial_cmp(&self, other: &OsString) -> 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 PartialOrd<Path> for Cow<'_, OsStr>

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

fn partial_cmp(&self, other: &Path) -> 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 PartialOrd<PathBuf> for Cow<'_, OsStr>

fn partial_cmp(&self, other: &PathBuf) -> 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 PartialOrd<PathBuf> for Cow<'_, Path>

fn partial_cmp(&self, other: &PathBuf) -> 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> Replacer for &'a Cow<'a, [u8]>

fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>)

Appends possibly empty data to dst to replace the current match.

fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>>

Return a fixed unchanging replacement byte string.

fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self>

Returns a type that implements Replacer, but that borrows and wraps this Replacer.

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

fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String)

Appends possibly empty data to dst to replace the current match.

fn no_expansion(&mut self) -> Option<Cow<'_, str>>

Return a fixed unchanging replacement string.

fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self>

Returns a type that implements Replacer, but that borrows and wraps this Replacer.

impl<'a> Replacer for Cow<'a, [u8]>

fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>)

Appends possibly empty data to dst to replace the current match.

fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>>

Return a fixed unchanging replacement byte string.

fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self>

Returns a type that implements Replacer, but that borrows and wraps this Replacer.

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

fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String)

Appends possibly empty data to dst to replace the current match.

fn no_expansion(&mut self) -> Option<Cow<'_, str>>

Return a fixed unchanging replacement string.

fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self>

Returns a type that implements Replacer, but that borrows and wraps this Replacer.

impl<C> RequestConnection for Cow<'_, C>

where C: RequestConnection + ToOwned + ?Sized,

type Buf = <C as RequestConnection>::Buf

Type used as buffer to store raw replies or events before they are parsed.

fn send_request_with_reply<R>( &self, bufs: &[IoSlice<'_>], fds: Vec<OwnedFd>, ) -> Result<Cookie<'_, Cow<'_, C>, R>, ConnectionError>

where R: TryParse,

Send a request with a reply to the server.

fn send_trait_request_with_reply<R>( &self, request: R, ) -> Result<Cookie<'_, Cow<'_, C>, <R as ReplyRequest>::Reply>, ConnectionError>

where R: ReplyRequest,

Send a request with a reply to the server.

fn send_request_with_reply_with_fds<R>( &self, bufs: &[IoSlice<'_>], fds: Vec<OwnedFd>, ) -> Result<CookieWithFds<'_, Cow<'_, C>, R>, ConnectionError>

where R: TryParseFd,

Send a request with a reply containing file descriptors to the server.

fn send_trait_request_with_reply_with_fds<R>( &self, request: R, ) -> Result<CookieWithFds<'_, Cow<'_, C>, <R as ReplyFDsRequest>::Reply>, ConnectionError>

where R: ReplyFDsRequest,

Send a request with a reply containing file descriptors to the server.

fn send_request_without_reply( &self, bufs: &[IoSlice<'_>], fds: Vec<OwnedFd>, ) -> Result<VoidCookie<'_, Cow<'_, C>>, ConnectionError>

Send a request without a reply to the server.

fn send_trait_request_without_reply<R>( &self, request: R, ) -> Result<VoidCookie<'_, Cow<'_, C>>, ConnectionError>

where R: VoidRequest,

Send a request without a reply to the server.

fn discard_reply(&self, sequence: u64, kind: RequestKind, mode: DiscardMode)

A reply to an error should be discarded.

fn prefetch_extension_information( &self, extension_name: &'static str, ) -> Result<(), ConnectionError>

Prefetches information about an extension.

fn extension_information( &self, extension_name: &'static str, ) -> Result<Option<ExtensionInformation>, ConnectionError>

Get information about an extension.

fn wait_for_reply_or_error( &self, sequence: u64, ) -> Result<<Cow<'_, C> as RequestConnection>::Buf, ReplyError>

Wait for the reply to a request.

fn wait_for_reply_or_raw_error( &self, sequence: u64, ) -> Result<ReplyOrError<<Cow<'_, C> as RequestConnection>::Buf>, ConnectionError>

Wait for the reply to a request.

fn wait_for_reply( &self, sequence: u64, ) -> Result<Option<<Cow<'_, C> as RequestConnection>::Buf>, ConnectionError>

Wait for the reply to a request.

fn wait_for_reply_with_fds( &self, sequence: u64, ) -> Result<(<Cow<'_, C> as RequestConnection>::Buf, Vec<OwnedFd>), ReplyError>

Wait for the reply to a request that has FDs.

fn wait_for_reply_with_fds_raw( &self, sequence: u64, ) -> Result<ReplyOrError<(<Cow<'_, C> as RequestConnection>::Buf, Vec<OwnedFd>), <Cow<'_, C> as RequestConnection>::Buf>, ConnectionError>

Wait for the reply to a request that has FDs.

fn check_for_error(&self, sequence: u64) -> Result<(), ReplyError>

Check whether a request that does not have a reply caused an X11 error.

fn check_for_raw_error( &self, sequence: u64, ) -> Result<Option<<Cow<'_, C> as RequestConnection>::Buf>, ConnectionError>

Check whether a request that does not have a reply caused an X11 error.

fn prefetch_maximum_request_bytes(&self)

Prefetches the maximum request length.

fn maximum_request_bytes(&self) -> usize

The maximum number of bytes that the X11 server accepts in a request.

fn parse_error(&self, error: &[u8]) -> Result<X11Error, ParseError>

Parse a generic error.

fn parse_event(&self, event: &[u8]) -> Result<Event, ParseError>

Parse a generic event.

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

where T: Serialize + ToOwned + ?Sized,

Available on crate features std or alloc only.

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

where T: ToTokens + ToOwned + ?Sized,

fn to_tokens(&self, tokens: &mut TokenStream)

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

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

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

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

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

Convert self directly into a TokenStream object.

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

where T: ToOwned + ToTokens + ?Sized,

fn to_tokens(&self, tokens: &mut TokenStream)

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self directly into a TokenStream object.

impl<'a> TryFrom<Cow<'a, str>> for ObjectPath<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Cow<'a, str>) -> Result<ObjectPath<'a>, Error>

Performs the conversion.

impl<'g> TryFrom<Cow<'g, str>> for Guid<'g>

type Error = Error

The type returned in the event of a conversion error.

fn try_from( value: Cow<'g, str>, ) -> Result<Guid<'g>, <Guid<'g> as TryFrom<Cow<'g, str>>>::Error>

Performs the conversion.

impl<'name> TryFrom<Cow<'name, str>> for BusName<'name>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Cow<'name, str>) -> Result<BusName<'name>, Error>

Performs the conversion.

impl<'s> TryFrom<Cow<'s, str>> for ErrorName<'s>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Cow<'s, str>) -> Result<ErrorName<'s>, Error>

Performs the conversion.

impl<'s> TryFrom<Cow<'s, str>> for InterfaceName<'s>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Cow<'s, str>) -> Result<InterfaceName<'s>, Error>

Performs the conversion.

impl<'s> TryFrom<Cow<'s, str>> for MemberName<'s>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Cow<'s, str>) -> Result<MemberName<'s>, Error>

Performs the conversion.

impl<'s> TryFrom<Cow<'s, str>> for PropertyName<'s>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Cow<'s, str>) -> Result<PropertyName<'s>, Error>

Performs the conversion.

impl<'s> TryFrom<Cow<'s, str>> for UniqueName<'s>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Cow<'s, str>) -> Result<UniqueName<'s>, Error>

Performs the conversion.

impl<'s> TryFrom<Cow<'s, str>> for WellKnownName<'s>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Cow<'s, str>) -> Result<WellKnownName<'s>, Error>

Performs the conversion.

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

where T: Type + ToOwned + ?Sized,

const SIGNATURE: &'static Signature = T::SIGNATURE

The signature for the implementing type, in parsed format.

impl<T> DerefPure for Cow<'_, [T]>

where T: Clone,

Available on non-no_global_oom_handling only.

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

where T: Clone,

impl DerefPure for Cow<'_, str>

Available on non-no_global_oom_handling only.

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

where B: Eq + ToOwned + ?Sized,

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

where T: Clone + IoSafe,