use self::Direction::*;
use alloc::boxed::Box;
-use core::borrow::{BorrowFrom, BorrowFromMut};
+use core::borrow::{BorrowFrom, BorrowFromMut, ToOwned};
use core::cmp;
use core::kinds::Sized;
use core::mem::size_of;
fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { owned[mut] }
}
+#[unstable = "trait is unstable"]
+impl<T: Clone> ToOwned<Vec<T>> for [T] {
+ fn to_owned(&self) -> Vec<T> { self.to_vec() }
+}
+
/// Unsafe operations
pub mod raw {
pub use core::slice::raw::{buf_as_slice, mut_buf_as_slice};
pub use self::MaybeOwned::*;
use self::RecompositionState::*;
use self::DecompositionType::*;
-use core::borrow::BorrowFrom;
+use core::borrow::{BorrowFrom, ToOwned};
use core::default::Default;
use core::fmt;
use core::cmp;
use hash;
use ring_buf::RingBuf;
-use string::String;
+use string::{String, ToString};
use unicode;
use vec::Vec;
fn borrow_from(owned: &String) -> &str { owned[] }
}
+#[unstable = "trait is unstable"]
+impl ToOwned<String> for str {
+ fn to_owned(&self) -> String { self.to_string() }
+}
+
/// Unsafe string operations.
pub mod raw {
pub use core::str::raw::{from_utf8, c_str_to_static_slice, slice_bytes};
//! data lazily when mutation or ownership is required. The type is designed to
//! work with general borrowed data via the `BorrowFrom` trait.
//!
-//! `Cow` implements both `Deref` and `DerefMut`, which means that you can call
-//! methods directly on the data it encloses. The first time a mutable reference
-//! is required, the data will be cloned (via `to_owned`) if it is not
-//! already owned.
+//! `Cow` implements both `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 references to an owned
+//! value, cloning if necessary.
#![unstable = "recently added as part of collections reform"]
}
/// A clone-on-write smart pointer.
-pub enum Cow<'a, T, B: 'a> where B: ToOwned<T> {
+///
+/// # Example
+///
+/// ```rust
+/// use std::borrow::Cow;
+///
+/// fn abs_all(input: &mut Cow<Vec<int>, [int]>) {
+/// for i in range(0, input.len()) {
+/// let v = input[i];
+/// if v < 0 {
+/// // clones into a vector the first time (if not already owned)
+/// input.to_mut()[i] = -v;
+/// }
+/// }
+/// }
+/// ```
+pub enum Cow<'a, T, Sized? B: 'a> where B: ToOwned<T> {
/// Borrowed data.
Borrowed(&'a B),
Owned(T)
}
-impl<'a, T, B> Cow<'a, T, B> where B: ToOwned<T> {
+impl<'a, T, Sized? B> Cow<'a, T, B> where B: ToOwned<T> {
/// Acquire a mutable reference to the owned form of the data.
///
/// Copies the data if it is not already owned.
}
}
-impl<'a, T, B> Deref<B> for Cow<'a, T, B> where B: ToOwned<T> {
+impl<'a, T, Sized? B> Deref<B> for Cow<'a, T, B> where B: ToOwned<T> {
fn deref(&self) -> &B {
match *self {
Borrowed(borrowed) => borrowed,