(index<- ) ./libstd/clone.rs
git branch: * master c7553ea auto merge of #13609 : richo/rust/str-type-vim, r=alexcrichton
modified: Wed Mar 26 11:50:03 2014
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 /*! The `Clone` trait for types that cannot be 'implicitly copied'
12
13 In Rust, some simple types are "implicitly copyable" and when you
14 assign them or pass them as arguments, the receiver will get a copy,
15 leaving the original value in place. These types do not require
16 allocation to copy and do not have finalizers (i.e. they do not
17 contain owned boxes or implement `Drop`), so the compiler considers
18 them cheap and safe to copy. For other types copies must be made
19 explicitly, by convention implementing the `Clone` trait and calling
20 the `clone` method.
21
22 */
23
24 /// A common trait for cloning an object.
25 pub trait Clone {
26 /// Returns a copy of the value. The contents of owned pointers
27 /// are copied to maintain uniqueness, while the contents of
28 /// managed pointers are not copied.
29 fn clone(&self) -> Self;
30
31 /// Perform copy-assignment from `source`.
32 ///
33 /// `a.clone_from(&b)` is equivalent to `a = b.clone()` in functionality,
34 /// but can be overridden to reuse the resources of `a` to avoid unnecessary
35 /// allocations.
36 #[inline(always)]
37 fn clone_from(&mut self, source: &Self) {
38 *self = source.clone()
39 }
40 }
41
42 impl<T: Clone> Clone for ~T {
43 /// Return a copy of the owned box.
44 #[inline]
45 fn clone(&self) -> ~T { ~(**self).clone() }
46
47 /// Perform copy-assignment from `source` by reusing the existing allocation.
48 #[inline]
49 fn clone_from(&mut self, source: &~T) {
50 (**self).clone_from(&(**source));
51 }
52 }
53
54 impl<T> Clone for @T {
55 /// Return a shallow copy of the managed box.
56 #[inline]
57 fn clone(&self) -> @T { *self }
58 }
59
60 impl<'a, T> Clone for &'a T {
61 /// Return a shallow copy of the reference.
62 #[inline]
63 fn clone(&self) -> &'a T { *self }
64 }
65
66 impl<'a, T> Clone for &'a [T] {
67 /// Return a shallow copy of the slice.
68 #[inline]
69 fn clone(&self) -> &'a [T] { *self }
70 }
71
72 impl<'a> Clone for &'a str {
73 /// Return a shallow copy of the slice.
74 #[inline]
75 fn clone(&self) -> &'a str { *self }
76 }
77
78 macro_rules! clone_impl(
79 ($t:ty) => {
80 impl Clone for $t {
81 /// Return a deep copy of the value.
82 #[inline]
83 fn clone(&self) -> $t { *self }
84 }
85 }
86 )
87
88 clone_impl!(int)
89 clone_impl!(i8)
90 clone_impl!(i16)
91 clone_impl!(i32)
92 clone_impl!(i64)
93
94 clone_impl!(uint)
95 clone_impl!(u8)
96 clone_impl!(u16)
97 clone_impl!(u32)
98 clone_impl!(u64)
99
100 clone_impl!(f32)
101 clone_impl!(f64)
102
103 clone_impl!(())
104 clone_impl!(bool)
105 clone_impl!(char)
106
107 macro_rules! extern_fn_clone(
108 ($($A:ident),*) => (
109 impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType {
110 /// Return a copy of a function pointer
111 #[inline]
112 fn clone(&self) -> extern "Rust" fn($($A),*) -> ReturnType { *self }
113 }
114 )
115 )
116
117 extern_fn_clone!()
118 extern_fn_clone!(A)
119 extern_fn_clone!(A, B)
120 extern_fn_clone!(A, B, C)
121 extern_fn_clone!(A, B, C, D)
122 extern_fn_clone!(A, B, C, D, E)
123 extern_fn_clone!(A, B, C, D, E, F)
124 extern_fn_clone!(A, B, C, D, E, F, G)
125 extern_fn_clone!(A, B, C, D, E, F, G, H)
126
127 #[test]
128 fn test_owned_clone() {
129 let a = ~5i;
130 let b: ~int = a.clone();
131 assert_eq!(a, b);
132 }
133
134 #[test]
135 fn test_managed_clone() {
136 let a = @5i;
137 let b: @int = a.clone();
138 assert_eq!(a, b);
139 }
140
141 #[test]
142 fn test_borrowed_clone() {
143 let x = 5i;
144 let y: &int = &x;
145 let z: &int = (&y).clone();
146 assert_eq!(*z, 5);
147 }
148
149 #[test]
150 fn test_clone_from() {
151 let a = ~5;
152 let mut b = ~10;
153 b.clone_from(&a);
154 assert_eq!(*b, 5);
155 }
156
157 #[test]
158 fn test_extern_fn_clone() {
159 trait Empty {}
160 impl Empty for int {}
161
162 fn test_fn_a() -> f64 { 1.0 }
163 fn test_fn_b<T: Empty>(x: T) -> T { x }
164 fn test_fn_c(_: int, _: f64, _: ~[int], _: int, _: int, _: int) {}
165
166 let _ = test_fn_a.clone();
167 let _ = test_fn_b::<int>.clone();
168 let _ = test_fn_c.clone();
169 }