Enum std::borrow::Cow1.0.0[−][src]

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: 'a> 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::Cow1.0.0[−][src]

Variants

Implementations

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

pub const fn is_borrowed(&self) -> bool

pub const 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>

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

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

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

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

pub 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,

pub fn as_ref(&self) -> &T

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

pub fn borrow(&self) -> &B

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

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

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

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

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

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

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

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

type Target = B

pub fn deref(&self) -> &B

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

pub 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

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

pub 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,

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

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

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

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

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

pub 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: Copy,

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

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

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

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

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

pub fn from(s: Cow<'a, [T]>) -> Vec<T, Global>ⓘNotable traits for Vec<u8, A>impl<A: Allocator> Write for Vec<u8, A>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn from(s: Cow<'a, [T]>) -> Vec<T, Global>ⓘ
Notable traits for Vec<u8, A>
`impl<A: Allocator> Write for Vec<u8, A>`

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

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

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

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

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

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

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

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

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

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

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

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

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

#[must_use]
fn max(self, other: Self) -> Self

#[must_use]
fn min(self, other: Self) -> Self

#[must_use]
fn clamp(self, min: Self, max: Self) -> Self

impl<'_, '_, T, U> PartialEq<&'_ [U]> for Cow<'_, [T]> where
T: PartialEq<U> + Clone,

impl<'_, '_, T, U> PartialEq<&'_ mut [U]> for Cow<'_, [T]> where
T: PartialEq<U> + Clone,