Enum collections::borrow::Cow

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

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.

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);

Variants

Borrowed data.

Owned data.

Methods

impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned [src]

fn to_mut(&mut self) -> &mut B::Owned

use std::borrow::Cow;

let mut cow: Cow<[_]> = Cow::Owned(vec![1, 2, 3]);

let hello = cow.to_mut();

assert_eq!(hello, &[1, 2, 3]);

fn into_owned(self) -> B::Owned

use std::borrow::Cow;

let cow: Cow<[_]> = Cow::Owned(vec![1, 2, 3]);

let hello = cow.into_owned();

assert_eq!(vec![1, 2, 3], hello);

Trait Implementations

impl<'a, B: ?Sized> Borrow<B> for Cow<'a, B> where B: ToOwned, B::Owned: 'a [src]

fn borrow(&self) -> &B

impl<'a, B: ?Sized> Clone for Cow<'a, B> where B: ToOwned [src]

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

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

impl<'a, B: ?Sized> Deref for Cow<'a, B> where B: ToOwned [src]

type Target = B

fn deref(&self) -> &B

impl<'a, B: ?Sized> Eq for Cow<'a, B> where B: Eq + ToOwned [src]

impl<'a, B: ?Sized> Ord for Cow<'a, B> where B: Ord + ToOwned [src]

fn cmp(&self, other: &Cow<'a, B>) -> Ordering

impl<'a, 'b, B: ?Sized, C: ?Sized> PartialEq<Cow<'b, C>> for Cow<'a, B> where B: PartialEq<C> + ToOwned,
        C: ToOwned [src]

fn eq(&self, other: &Cow<'b, C>) -> bool

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

impl<'a, B: ?Sized> PartialOrd for Cow<'a, B> where B: PartialOrd + ToOwned [src]

fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering>

fn lt(&self, other: &Rhs) -> bool

fn le(&self, other: &Rhs) -> bool

fn gt(&self, other: &Rhs) -> bool

fn ge(&self, other: &Rhs) -> bool

impl<'a, B: ?Sized> Debug for Cow<'a, B> where B: Debug + ToOwned,
        B::Owned: Debug [src]

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

impl<'a, B: ?Sized> Display for Cow<'a, B> where B: Display + ToOwned,
        B::Owned: Display [src]

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

impl<'a, B: ?Sized> Default for Cow<'a, B> where B: ToOwned, B::Owned: Default

1.11.0

[src]

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

impl<'a, B: ?Sized> Hash for Cow<'a, B> where B: Hash + ToOwned [src]

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

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

1.3.0

impl<'a, T: ?Sized + ToOwned> AsRef<T> for Cow<'a, T> [src]

fn as_ref(&self) -> &T

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

1.14.0

[src]

type Output = Cow<'a, str>

fn add(self, rhs: &'a str) -> Self::Output

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

1.14.0

[src]

type Output = Cow<'a, str>

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

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

1.14.0

[src]

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

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

1.14.0

[src]

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

impl<'a, 'b> PartialEq<str> for Cow<'a, str> [src]

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

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

impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str> [src]

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

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

impl<'a, 'b> PartialEq<String> for Cow<'a, str> [src]

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

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

impl<'a> From<&'a str> for Cow<'a, str> [src]

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

impl<'a> From<String> for Cow<'a, str> [src]

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

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

1.12.0

[src]

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

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

1.12.0

[src]

fn from_iter<I: IntoIterator<Item=&'b str>>(it: I) -> Cow<'a, str>

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

1.12.0

[src]

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

impl<'a, 'b, A: Clone, B> PartialEq<&'b [B]> for Cow<'a, [A]> where A: PartialEq<B> [src]

fn eq(&self, other: &&'b [B]) -> bool

fn ne(&self, other: &&'b [B]) -> bool

impl<'a, 'b, A: Clone, B> PartialEq<&'b mut [B]> for Cow<'a, [A]> where A: PartialEq<B> [src]

fn eq(&self, other: &&'b mut [B]) -> bool

fn ne(&self, other: &&'b mut [B]) -> bool

impl<'a, 'b, A: Clone, B> PartialEq<Vec<B>> for Cow<'a, [A]> where A: PartialEq<B> [src]

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

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

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

1.7.0

[src]

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

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

1.7.0

[src]

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

impl<'a, T> FromIterator<T> for Cow<'a, [T]> where T: Clone [src]

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