1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. //! A module for working with borrowed data. //! //! # The `BorrowFrom` traits //! //! In general, there may be several ways to "borrow" a piece of data. The //! typical ways of borrowing a type `T` are `&T` (a shared borrow) and `&mut T` //! (a mutable borrow). But types like `Vec<T>` provide additional kinds of //! borrows: the borrowed slices `&[T]` and `&mut [T]`. //! //! When writing generic code, it is often desirable to abstract over all ways //! of borrowing data from a given type. That is the role of the `BorrowFrom` //! trait: if `T: BorrowFrom<U>`, then `&T` can be borrowed from `&U`. A given //! type can be borrowed as multiple different types. In particular, `Vec<T>: //! BorrowFrom<Vec<T>>` and `[T]: BorrowFrom<Vec<T>>`. //! //! # The `ToOwned` trait //! //! Some types make it possible to go from borrowed to owned, usually by //! implementing the `Clone` trait. But `Clone` works only for going from `&T` //! to `T`. The `ToOwned` trait generalizes `Clone` to construct owned data //! from any borrow of a given type. //! //! # The `Cow` (clone-on-write) type //! //! 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 `BorrowFrom` trait. //! //! `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"] use clone::Clone; use kinds::Sized; use ops::Deref; use self::Cow::*; /// A trait for borrowing data. pub trait BorrowFrom<Sized? Owned> for Sized? { /// Immutably borrow from an owned value. fn borrow_from(owned: &Owned) -> &Self; } /// A trait for mutably borrowing data. pub trait BorrowFromMut<Sized? Owned> for Sized? : BorrowFrom<Owned> { /// Mutably borrow from an owned value. fn borrow_from_mut(owned: &mut Owned) -> &mut Self; } impl<Sized? T> BorrowFrom<T> for T { fn borrow_from(owned: &T) -> &T { owned } } impl<Sized? T> BorrowFromMut<T> for T { fn borrow_from_mut(owned: &mut T) -> &mut T { owned } } impl<'a, Sized? T> BorrowFrom<&'a T> for T { fn borrow_from<'b>(owned: &'b &'a T) -> &'b T { &**owned } } impl<'a, Sized? T> BorrowFrom<&'a mut T> for T { fn borrow_from<'b>(owned: &'b &'a mut T) -> &'b T { &**owned } } impl<'a, Sized? T> BorrowFromMut<&'a mut T> for T { fn borrow_from_mut<'b>(owned: &'b mut &'a mut T) -> &'b mut T { &mut **owned } } /// A generalization of Clone to borrowed data. pub trait ToOwned<Owned> for Sized?: BorrowFrom<Owned> { /// Create owned data from borrowed data, usually by copying. fn to_owned(&self) -> Owned; } impl<T> ToOwned<T> for T where T: Clone { fn to_owned(&self) -> T { self.clone() } } /// A clone-on-write smart pointer. /// /// # 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 data. Owned(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. pub fn to_mut(&mut self) -> &mut T { match *self { Borrowed(borrowed) => { *self = Owned(borrowed.to_owned()); self.to_mut() } Owned(ref mut owned) => owned } } /// Extract the owned data. /// /// Copies the data if it is not already owned. pub fn into_owned(self) -> T { match self { Borrowed(borrowed) => borrowed.to_owned(), Owned(owned) => owned } } } 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, Owned(ref owned) => BorrowFrom::borrow_from(owned) } } }