---

yaml
---
r: 65511
b: refs/heads/master
c: 023861c
h: refs/heads/master
i:
  65509: a1c79a4
  65507: 4a1c11c
  65503: c416e1b
v: v3

Author: emberian

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 44af5064d0ac3d45223f1555b299f10fd4902f5c
+refs/heads/master: 023861cbd1c817fd092029141bef96639df8c6d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/libextra/arc.rs

@@ -56,10 +56,10 @@ pub struct Condvar<'self> {
     cond: &'self sync::Condvar<'self>
 }
 
-impl<'self> Condvar<'self> {
+pub impl<'self> Condvar<'self> {
     /// Atomically exit the associated ARC and block until a signal is sent.
     #[inline(always)]
-    pub fn wait(&self) { self.wait_on(0) }
+    fn wait(&self) { self.wait_on(0) }
 
     /**
      * Atomically exit the associated ARC and block on a specified condvar
@@ -68,7 +68,7 @@ impl<'self> Condvar<'self> {
      * wait() is equivalent to wait_on(0).
      */
     #[inline(always)]
-    pub fn wait_on(&self, condvar_id: uint) {
+    fn wait_on(&self, condvar_id: uint) {
         assert!(!*self.failed);
         self.cond.wait_on(condvar_id);
         // This is why we need to wrap sync::condvar.
@@ -77,28 +77,28 @@ impl<'self> Condvar<'self> {
 
     /// Wake up a blocked task. Returns false if there was no blocked task.
     #[inline(always)]
-    pub fn signal(&self) -> bool { self.signal_on(0) }
+    fn signal(&self) -> bool { self.signal_on(0) }
 
     /**
      * Wake up a blocked task on a specified condvar (as
      * sync::cond.signal_on). Returns false if there was no blocked task.
      */
     #[inline(always)]
-    pub fn signal_on(&self, condvar_id: uint) -> bool {
+    fn signal_on(&self, condvar_id: uint) -> bool {
         assert!(!*self.failed);
         self.cond.signal_on(condvar_id)
     }
 
     /// Wake up all blocked tasks. Returns the number of tasks woken.
     #[inline(always)]
-    pub fn broadcast(&self) -> uint { self.broadcast_on(0) }
+    fn broadcast(&self) -> uint { self.broadcast_on(0) }
 
     /**
      * Wake up all blocked tasks on a specified condvar (as
      * sync::cond.broadcast_on). Returns Returns the number of tasks woken.
      */
     #[inline(always)]
-    pub fn broadcast_on(&self, condvar_id: uint) -> uint {
+    fn broadcast_on(&self, condvar_id: uint) -> uint {
         assert!(!*self.failed);
         self.cond.broadcast_on(condvar_id)
     }
@@ -120,8 +120,8 @@ pub fn ARC<T:Const + Owned>(data: T) -> ARC<T> {
  * Access the underlying data in an atomically reference counted
  * wrapper.
  */
-impl<T:Const+Owned> ARC<T> {
-    pub fn get<'a>(&'a self) -> &'a T {
+pub impl<T:Const+Owned> ARC<T> {
+    fn get<'a>(&'a self) -> &'a T {
         unsafe { &*self.x.get_immut() }
     }
 }
@@ -173,7 +173,7 @@ impl<T:Owned> Clone for MutexARC<T> {
     }
 }
 
-impl<T:Owned> MutexARC<T> {
+pub impl<T:Owned> MutexARC<T> {
 
     /**
      * Access the underlying mutable data with mutual exclusion from other
@@ -199,7 +199,7 @@ impl<T:Owned> MutexARC<T> {
      * blocked on the mutex) will also fail immediately.
      */
     #[inline(always)]
-    pub unsafe fn access<U>(&self, blk: &fn(x: &mut T) -> U) -> U {
+    unsafe fn access<U>(&self, blk: &fn(x: &mut T) -> U) -> U {
         unsafe {
             let state = self.x.get();
             // Borrowck would complain about this if the function were
@@ -214,10 +214,10 @@ impl<T:Owned> MutexARC<T> {
 
     /// As access(), but with a condvar, as sync::mutex.lock_cond().
     #[inline(always)]
-    pub unsafe fn access_cond<'x, 'c, U>(&self,
-                                         blk: &fn(x: &'x mut T,
-                                                  c: &'c Condvar) -> U)
-                                         -> U {
+    unsafe fn access_cond<'x, 'c, U>(
+        &self,
+        blk: &fn(x: &'x mut T, c: &'c Condvar) -> U) -> U
+    {
         let state = self.x.get();
         do (&(*state).lock).lock_cond |cond| {
             check_poison(true, (*state).failed);
@@ -302,18 +302,16 @@ pub fn rw_arc_with_condvars<T:Const + Owned>(
     RWARC { x: UnsafeAtomicRcBox::new(data), cant_nest: () }
 }
 
-impl<T:Const + Owned> RWARC<T> {
+pub impl<T:Const + Owned> RWARC<T> {
     /// Duplicate a rwlock-protected ARC, as arc::clone.
-    pub fn clone(&self) -> RWARC<T> {
-        RWARC {
-            x: self.x.clone(),
-            cant_nest: (),
-        }
+    fn clone(&self) -> RWARC<T> {
+        RWARC { x: self.x.clone(),
+                cant_nest: () }
     }
 
 }
 
-impl<T:Const + Owned> RWARC<T> {
+pub impl<T:Const + Owned> RWARC<T> {
     /**
      * Access the underlying data mutably. Locks the rwlock in write mode;
      * other readers and writers will block.
@@ -325,7 +323,7 @@ impl<T:Const + Owned> RWARC<T> {
      * poison the ARC, so subsequent readers and writers will both also fail.
      */
     #[inline(always)]
-    pub fn write<U>(&self, blk: &fn(x: &mut T) -> U) -> U {
+    fn write<U>(&self, blk: &fn(x: &mut T) -> U) -> U {
         unsafe {
             let state = self.x.get();
             do (*borrow_rwlock(state)).write {
@@ -335,12 +333,11 @@ impl<T:Const + Owned> RWARC<T> {
             }
         }
     }
-
     /// As write(), but with a condvar, as sync::rwlock.write_cond().
     #[inline(always)]
-    pub fn write_cond<'x, 'c, U>(&self,
-                                 blk: &fn(x: &'x mut T, c: &'c Condvar) -> U)
-                                 -> U {
+    fn write_cond<'x, 'c, U>(&self,
+                             blk: &fn(x: &'x mut T, c: &'c Condvar) -> U)
+                          -> U {
         unsafe {
             let state = self.x.get();
             do (*borrow_rwlock(state)).write_cond |cond| {
@@ -353,7 +350,6 @@ impl<T:Const + Owned> RWARC<T> {
             }
         }
     }
-
     /**
      * Access the underlying data immutably. May run concurrently with other
      * reading tasks.
@@ -363,7 +359,7 @@ impl<T:Const + Owned> RWARC<T> {
      * Failing will unlock the ARC while unwinding. However, unlike all other
      * access modes, this will not poison the ARC.
      */
-    pub fn read<U>(&self, blk: &fn(x: &T) -> U) -> U {
+    fn read<U>(&self, blk: &fn(x: &T) -> U) -> U {
         unsafe {
             let state = self.x.get();
             do (*state).lock.read {
@@ -393,7 +389,7 @@ impl<T:Const + Owned> RWARC<T> {
      * }
      * ~~~
      */
-    pub fn write_downgrade<U>(&self, blk: &fn(v: RWWriteMode<T>) -> U) -> U {
+    fn write_downgrade<U>(&self, blk: &fn(v: RWWriteMode<T>) -> U) -> U {
         unsafe {
             let state = self.x.get();
             do (*borrow_rwlock(state)).write_downgrade |write_mode| {
@@ -408,8 +404,7 @@ impl<T:Const + Owned> RWARC<T> {
     }
 
     /// To be called inside of the write_downgrade block.
-    pub fn downgrade<'a>(&self, token: RWWriteMode<'a, T>)
-                         -> RWReadMode<'a, T> {
+    fn downgrade<'a>(&self, token: RWWriteMode<'a, T>) -> RWReadMode<'a, T> {
         unsafe {
             // The rwlock should assert that the token belongs to us for us.
             let state = self.x.get();
@@ -456,9 +451,9 @@ pub struct RWReadMode<'self, T> {
     token: sync::RWlockReadMode<'self>,
 }
 
-impl<'self, T:Const + Owned> RWWriteMode<'self, T> {
+pub impl<'self, T:Const + Owned> RWWriteMode<'self, T> {
     /// Access the pre-downgrade RWARC in write mode.
-    pub fn write<U>(&mut self, blk: &fn(x: &mut T) -> U) -> U {
+    fn write<U>(&mut self, blk: &fn(x: &mut T) -> U) -> U {
         match *self {
             RWWriteMode {
                 data: &ref mut data,
@@ -471,11 +466,10 @@ impl<'self, T:Const + Owned> RWWriteMode<'self, T> {
             }
         }
     }
-
     /// Access the pre-downgrade RWARC in write mode with a condvar.
-    pub fn write_cond<'x, 'c, U>(&mut self,
-                                 blk: &fn(x: &'x mut T, c: &'c Condvar) -> U)
-                                 -> U {
+    fn write_cond<'x, 'c, U>(&mut self,
+                             blk: &fn(x: &'x mut T, c: &'c Condvar) -> U)
+                          -> U {
         match *self {
             RWWriteMode {
                 data: &ref mut data,
@@ -497,9 +491,9 @@ impl<'self, T:Const + Owned> RWWriteMode<'self, T> {
     }
 }
 
-impl<'self, T:Const + Owned> RWReadMode<'self, T> {
+pub impl<'self, T:Const + Owned> RWReadMode<'self, T> {
     /// Access the post-downgrade rwlock in read mode.
-    pub fn read<U>(&self, blk: &fn(x: &T) -> U) -> U {
+    fn read<U>(&self, blk: &fn(x: &T) -> U) -> U {
         match *self {
             RWReadMode {
                 data: data,

trunk/src/libextra/arena.rs

@@ -166,9 +166,9 @@ unsafe fn un_bitpack_tydesc_ptr(p: uint) -> (*TypeDesc, bool) {
     (transmute(p & !1), p & 1 == 1)
 }
 
-impl Arena {
+pub impl Arena {
     // Functions for the POD part of the arena
-    fn alloc_pod_grow(&mut self, n_bytes: uint, align: uint) -> *u8 {
+    priv fn alloc_pod_grow(&mut self, n_bytes: uint, align: uint) -> *u8 {
         // Allocate a new chunk.
         let chunk_size = at_vec::capacity(self.pod_head.data);
         let new_min_chunk_size = uint::max(n_bytes, chunk_size);
@@ -180,7 +180,7 @@ impl Arena {
     }
 
     #[inline(always)]
-    fn alloc_pod_inner(&mut self, n_bytes: uint, align: uint) -> *u8 {
+    priv fn alloc_pod_inner(&mut self, n_bytes: uint, align: uint) -> *u8 {
         unsafe {
             // XXX: Borrow check
             let head = transmute_mut_region(&mut self.pod_head);
@@ -200,7 +200,7 @@ impl Arena {
     }
 
     #[inline(always)]
-    fn alloc_pod<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
+    priv fn alloc_pod<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
         unsafe {
             let tydesc = sys::get_type_desc::<T>();
             let ptr = self.alloc_pod_inner((*tydesc).size, (*tydesc).align);
@@ -211,8 +211,8 @@ impl Arena {
     }
 
     // Functions for the non-POD part of the arena
-    fn alloc_nonpod_grow(&mut self, n_bytes: uint, align: uint)
-                         -> (*u8, *u8) {
+    priv fn alloc_nonpod_grow(&mut self, n_bytes: uint, align: uint)
+                             -> (*u8, *u8) {
         // Allocate a new chunk.
         let chunk_size = at_vec::capacity(self.head.data);
         let new_min_chunk_size = uint::max(n_bytes, chunk_size);
@@ -224,8 +224,8 @@ impl Arena {
     }
 
     #[inline(always)]
-    fn alloc_nonpod_inner(&mut self, n_bytes: uint, align: uint)
-                          -> (*u8, *u8) {
+    priv fn alloc_nonpod_inner(&mut self, n_bytes: uint, align: uint)
+                               -> (*u8, *u8) {
         unsafe {
             let head = transmute_mut_region(&mut self.head);
 
@@ -247,7 +247,7 @@ impl Arena {
     }
 
     #[inline(always)]
-    fn alloc_nonpod<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
+    priv fn alloc_nonpod<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
         unsafe {
             let tydesc = sys::get_type_desc::<T>();
             let (ty_ptr, ptr) =
@@ -269,7 +269,7 @@ impl Arena {
 
     // The external interface
     #[inline(always)]
-    pub fn alloc<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
+    fn alloc<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
         unsafe {
             // XXX: Borrow check
             let this = transmute_mut_region(self);