Enum std::borrow::Cow

1.0.0 · source ·

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

Expand description

写时克隆智能指针。

Cow 类型是一种智能指针，提供了写时克隆功能：它可以封装并提供对借用数据的不可变访问，并在需要可变的或所有权时懒惰地克隆数据。

该类型旨在通过 Borrow trait 处理常规借用数据。

Cow 实现了 Deref，这意味着您可以直接在它包含的数据上调用非可变方法。如果需要进行可变的，则 to_mut 将获得一个拥有值的变量引用，必要时进行克隆。

如果需要引用计数指针，请注意 Rc::make_mut 和 Arc::make_mut 也可以提供写时克隆功能。

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 {
            // 如果尚未拥有，则克隆到 vector 中。
            input.to_mut()[i] = -v;
        }
    }
}

// 因为 `input` 不需要可变的，所以不会发生克隆。
let slice = [0, 1, 2];
let mut input = Cow::from(&slice[..]);
abs_all(&mut input);

// 发生克隆是因为需要对 `input` 进行可变的。
let slice = [-1, 0, 1];
let mut input = Cow::from(&slice[..]);
abs_all(&mut input);

// 因为 `input` 已被拥有，所以不会发生克隆。
let mut input = Cow::from(vec![-1, 0, 1]);
abs_all(&mut input);

Run

另一个示例显示如何将 Cow 保留在结构体中：

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 }
    }
}

// 根据切片的借用值创建容器
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;
// 将切片中的数据可变的为拥有的 vec，并在顶部推入新值
clone_on_write.values.to_mut().push(3);
println!("clone_on_write = {:?}", clone_on_write.values);

// 数据被可变的。让我们来看看。
match clone_on_write {
    Items { values: Cow::Owned(_) } => println!("clone_on_write contains owned data"),
    _ => panic!("expect owned data"),
}

Run

Variants§

§

Borrowed(&'a B)

借用的数据。

§

Owned(::Owned)

拥有的数据。

Enum std::borrow::Cow

Variants§

Borrowed(&'a B)

Owned(<B as ToOwned>::Owned)

Implementations§

impl<B> Cow<'_, B>where B: ToOwned + ?Sized,

pub fn is_borrowed(&self) -> bool

pub fn is_owned(&self) -> bool

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

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

Trait Implementations§

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

type Output = Cow<'a, str>

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

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

type Output = Cow<'a, str>

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

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

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

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

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

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

fn as_ref(&self) -> &Path

impl<T> AsRef<T> for Cow<'_, T>where T: ToOwned + ?Sized,

fn as_ref(&self) -> &T

impl<'a, B> Borrow<B> for Cow<'a, B>where B: ToOwned + ?Sized,

fn borrow(&self) -> &B

impl<B> Clone for Cow<'_, B>where B: ToOwned + ?Sized,

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

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

impl<B> Debug for Cow<'_, B>where B: Debug + ToOwned + ?Sized, <B as ToOwned>::Owned: Debug,

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

impl<B> Default for Cow<'_, B>where B: ToOwned + ?Sized, <B as ToOwned>::Owned: Default,

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

impl<B> Deref for Cow<'_, B>where B: ToOwned + ?Sized, <B as ToOwned>::Owned: Borrow<B>,

type Target = B

fn deref(&self) -> &B

impl<B> Display for Cow<'_, B>where B: Display + ToOwned + ?Sized, <B as ToOwned>::Owned: Display,

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

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

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

fn extend_one(&mut self, item: A)

fn extend_reserve(&mut self, additional: usize)

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

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

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

fn extend_reserve(&mut self, additional: usize)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> From<Cow<'_, [T]>> for Box<[T], Global>where T: Clone,

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

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

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

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

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

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

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

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

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

impl<'a, T> From<Cow<'a, [T]>> for Vec<T, Global>where [T]: ToOwned<Owned = Vec<T, Global>>,