---

yaml
---
r: 73709
b: refs/heads/dist-snap
c: 61ac5fd
h: refs/heads/master
i:
  73707: 1882e9d
v: v3

Author: thestinger

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 979b037e5a7541a1d77453091839cb7dcf124ba7
+refs/heads/dist-snap: 61ac5fdab73878584053b79457eed34cf5b7055d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libstd/clone.rs

@@ -90,8 +90,7 @@ clone_impl!(char)
 /// managed boxes which would otherwise not be copied.
 pub trait DeepClone {
     /// Return a deep copy of the value. Unlike `Clone`, the contents of shared pointer types
-    /// *are* copied. Note that this is currently unimplemented for managed boxes, as
-    /// it would need to handle cycles, but it is implemented for other smart-pointer types.
+    /// *are* copied.
     fn deep_clone(&self) -> Self;
 }
 

branches/dist-snap/src/libstd/unstable/atomics.rs

@@ -75,15 +75,15 @@ pub enum Ordering {
 
 impl AtomicFlag {
 
-    pub fn new() -> AtomicFlag {
+    fn new() -> AtomicFlag {
         AtomicFlag { v: 0 }
     }
 
     /**
      * Clears the atomic flag
      */
     #[inline(always)]
-    pub fn clear(&mut self, order: Ordering) {
+    fn clear(&mut self, order: Ordering) {
         unsafe {atomic_store(&mut self.v, 0, order)}
     }
 
@@ -92,37 +92,37 @@ impl AtomicFlag {
      * flag.
      */
     #[inline(always)]
-    pub fn test_and_set(&mut self, order: Ordering) -> bool {
+    fn test_and_set(&mut self, order: Ordering) -> bool {
         unsafe {atomic_compare_and_swap(&mut self.v, 0, 1, order) > 0}
     }
 }
 
 impl AtomicBool {
-    pub fn new(v: bool) -> AtomicBool {
+    fn new(v: bool) -> AtomicBool {
         AtomicBool { v: if v { 1 } else { 0 } }
     }
 
     #[inline(always)]
-    pub fn load(&self, order: Ordering) -> bool {
+    fn load(&self, order: Ordering) -> bool {
         unsafe { atomic_load(&self.v, order) > 0 }
     }
 
     #[inline(always)]
-    pub fn store(&mut self, val: bool, order: Ordering) {
+    fn store(&mut self, val: bool, order: Ordering) {
         let val = if val { 1 } else { 0 };
 
         unsafe { atomic_store(&mut self.v, val, order); }
     }
 
     #[inline(always)]
-    pub fn swap(&mut self, val: bool, order: Ordering) -> bool {
+    fn swap(&mut self, val: bool, order: Ordering) -> bool {
         let val = if val { 1 } else { 0 };
 
         unsafe { atomic_swap(&mut self.v, val, order) > 0}
     }
 
     #[inline(always)]
-    pub fn compare_and_swap(&mut self, old: bool, new: bool, order: Ordering) -> bool {
+    fn compare_and_swap(&mut self, old: bool, new: bool, order: Ordering) -> bool {
         let old = if old { 1 } else { 0 };
         let new = if new { 1 } else { 0 };
 
@@ -131,113 +131,113 @@ impl AtomicBool {
 }
 
 impl AtomicInt {
-    pub fn new(v: int) -> AtomicInt {
+    fn new(v: int) -> AtomicInt {
         AtomicInt { v:v }
     }
 
     #[inline(always)]
-    pub fn load(&self, order: Ordering) -> int {
+    fn load(&self, order: Ordering) -> int {
         unsafe { atomic_load(&self.v, order) }
     }
 
     #[inline(always)]
-    pub fn store(&mut self, val: int, order: Ordering) {
+    fn store(&mut self, val: int, order: Ordering) {
         unsafe { atomic_store(&mut self.v, val, order); }
     }
 
     #[inline(always)]
-    pub fn swap(&mut self, val: int, order: Ordering) -> int {
+    fn swap(&mut self, val: int, order: Ordering) -> int {
         unsafe { atomic_swap(&mut self.v, val, order) }
     }
 
     #[inline(always)]
-    pub fn compare_and_swap(&mut self, old: int, new: int, order: Ordering) -> int {
+    fn compare_and_swap(&mut self, old: int, new: int, order: Ordering) -> int {
         unsafe { atomic_compare_and_swap(&mut self.v, old, new, order) }
     }
 
     #[inline(always)]
-    pub fn fetch_add(&mut self, val: int, order: Ordering) -> int {
+    fn fetch_add(&mut self, val: int, order: Ordering) -> int {
         unsafe { atomic_add(&mut self.v, val, order) }
     }
 
     #[inline(always)]
-    pub fn fetch_sub(&mut self, val: int, order: Ordering) -> int {
+    fn fetch_sub(&mut self, val: int, order: Ordering) -> int {
         unsafe { atomic_sub(&mut self.v, val, order) }
     }
 }
 
 impl AtomicUint {
-    pub fn new(v: uint) -> AtomicUint {
+    fn new(v: uint) -> AtomicUint {
         AtomicUint { v:v }
     }
 
     #[inline(always)]
-    pub fn load(&self, order: Ordering) -> uint {
+    fn load(&self, order: Ordering) -> uint {
         unsafe { atomic_load(&self.v, order) }
     }
 
     #[inline(always)]
-    pub fn store(&mut self, val: uint, order: Ordering) {
+    fn store(&mut self, val: uint, order: Ordering) {
         unsafe { atomic_store(&mut self.v, val, order); }
     }
 
     #[inline(always)]
-    pub fn swap(&mut self, val: uint, order: Ordering) -> uint {
+    fn swap(&mut self, val: uint, order: Ordering) -> uint {
         unsafe { atomic_swap(&mut self.v, val, order) }
     }
 
     #[inline(always)]
-    pub fn compare_and_swap(&mut self, old: uint, new: uint, order: Ordering) -> uint {
+    fn compare_and_swap(&mut self, old: uint, new: uint, order: Ordering) -> uint {
         unsafe { atomic_compare_and_swap(&mut self.v, old, new, order) }
     }
 
     #[inline(always)]
-    pub fn fetch_add(&mut self, val: uint, order: Ordering) -> uint {
+    fn fetch_add(&mut self, val: uint, order: Ordering) -> uint {
         unsafe { atomic_add(&mut self.v, val, order) }
     }
 
     #[inline(always)]
-    pub fn fetch_sub(&mut self, val: uint, order: Ordering) -> uint {
+    fn fetch_sub(&mut self, val: uint, order: Ordering) -> uint {
         unsafe { atomic_sub(&mut self.v, val, order) }
     }
 }
 
 impl<T> AtomicPtr<T> {
-    pub fn new(p: *mut T) -> AtomicPtr<T> {
+    fn new(p: *mut T) -> AtomicPtr<T> {
         AtomicPtr { p:p }
     }
 
     #[inline(always)]
-    pub fn load(&self, order: Ordering) -> *mut T {
+    fn load(&self, order: Ordering) -> *mut T {
         unsafe { atomic_load(&self.p, order) }
     }
 
     #[inline(always)]
-    pub fn store(&mut self, ptr: *mut T, order: Ordering) {
+    fn store(&mut self, ptr: *mut T, order: Ordering) {
         unsafe { atomic_store(&mut self.p, ptr, order); }
     }
 
     #[inline(always)]
-    pub fn swap(&mut self, ptr: *mut T, order: Ordering) -> *mut T {
+    fn swap(&mut self, ptr: *mut T, order: Ordering) -> *mut T {
         unsafe { atomic_swap(&mut self.p, ptr, order) }
     }
 
     #[inline(always)]
-    pub fn compare_and_swap(&mut self, old: *mut T, new: *mut T, order: Ordering) -> *mut T {
+    fn compare_and_swap(&mut self, old: *mut T, new: *mut T, order: Ordering) -> *mut T {
         unsafe { atomic_compare_and_swap(&mut self.p, old, new, order) }
     }
 }
 
 impl<T> AtomicOption<T> {
-    pub fn new(p: ~T) -> AtomicOption<T> {
+    fn new(p: ~T) -> AtomicOption<T> {
         unsafe {
             AtomicOption {
                 p: cast::transmute(p)
             }
         }
     }
 
-    pub fn empty() -> AtomicOption<T> {
+    fn empty() -> AtomicOption<T> {
         unsafe {
             AtomicOption {
                 p: cast::transmute(0)
@@ -246,7 +246,7 @@ impl<T> AtomicOption<T> {
     }
 
     #[inline(always)]
-    pub fn swap(&mut self, val: ~T, order: Ordering) -> Option<~T> {
+    fn swap(&mut self, val: ~T, order: Ordering) -> Option<~T> {
         unsafe {
             let val = cast::transmute(val);
 
@@ -262,7 +262,7 @@ impl<T> AtomicOption<T> {
     }
 
     #[inline(always)]
-    pub fn take(&mut self, order: Ordering) -> Option<~T> {
+    fn take(&mut self, order: Ordering) -> Option<~T> {
         unsafe {
             self.swap(cast::transmute(0), order)
         }