---

yaml
---
r: 62746
b: refs/heads/snap-stage3
c: 77de84b
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 0d5fdce82e1e09df96ea2ee190e9fffd91b2c714
+refs/heads/snap-stage3: 77de84b4f629b63c784903ed7cc08c024b10496b
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/arc.rs

@@ -17,7 +17,7 @@
  * In this example, a large vector of floats is shared between several tasks.
  * With simple pipes, without ARC, a copy would have to be made for each task.
  *
- * ~~~ {.rust}
+ * ~~~
  * extern mod std;
  * use std::arc;
  * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
@@ -370,10 +370,7 @@ pub impl<T:Const + Owned> RWARC<T> {
      * See sync::rwlock.write_downgrade(). The RWWriteMode token must be used
      * to obtain the &mut T, and can be transformed into a RWReadMode token by
      * calling downgrade(), after which a &T can be obtained instead.
-     *
-     * # Example
-     *
-     * ~~~ {.rust}
+     * ~~~
      * do arc.write_downgrade |write_mode| {
      *     do (&write_mode).write_cond |state, condvar| {
      *         ... exclusive access with mutable state ...

branches/snap-stage3/src/libextra/base64.rs

@@ -28,17 +28,17 @@ impl<'self> ToBase64 for &'self [u8] {
     /**
      * Turn a vector of `u8` bytes into a base64 string.
      *
-     * # Example
+     * *Example*:
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = [52,32].to_base64();
      *     println(fmt!("%s", str));
      * }
-     * ~~~
+     * ~~~~
      */
     fn to_base64(&self) -> ~str {
         let mut s = ~"";
@@ -91,17 +91,17 @@ impl<'self> ToBase64 for &'self str {
      * Convert any string (literal, `@`, `&`, or `~`) to base64 encoding.
      *
      *
-     * # Example
+     * *Example*:
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = "Hello, World".to_base64();
      *     println(fmt!("%s",str));
      * }
-     * ~~~
+     * ~~~~
      *
      */
     fn to_base64(&self) -> ~str {
@@ -118,9 +118,9 @@ impl FromBase64 for ~[u8] {
      * Convert base64 `u8` vector into u8 byte values.
      * Every 4 encoded characters is converted into 3 octets, modulo padding.
      *
-     * # Example
+     * *Example*:
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      * use std::base64::FromBase64;
@@ -131,7 +131,7 @@ impl FromBase64 for ~[u8] {
      *     let bytes = str.from_base64();
      *     println(fmt!("%?",bytes));
      * }
-     * ~~~
+     * ~~~~
      */
     fn from_base64(&self) -> ~[u8] {
         if self.len() % 4u != 0u { fail!("invalid base64 length"); }
@@ -196,11 +196,11 @@ impl FromBase64 for ~str {
      * You can use the `from_bytes` function in `core::str`
      * to turn a `[u8]` into a string with characters corresponding to those values.
      *
-     * # Example
+     * *Example*:
      *
      * This converts a string literal to base64 and back.
      *
-     * ~~~ {.rust}
+     * ~~~~
      * extern mod std;
      * use std::base64::ToBase64;
      * use std::base64::FromBase64;
@@ -214,7 +214,7 @@ impl FromBase64 for ~str {
      *     let result_str = str::from_bytes(bytes);
      *     println(fmt!("%s",result_str));
      * }
-     * ~~~
+     * ~~~~
      */
     fn from_base64(&self) -> ~[u8] {
         str::to_bytes(*self).from_base64()

branches/snap-stage3/src/libextra/deque.rs

@@ -125,6 +125,31 @@ pub impl<T> Deque<T> {
         self.hi = (self.hi + 1u) % self.elts.len();
         self.nelts += 1u;
     }
+
+    /// Reserve capacity for exactly `n` elements in the given deque,
+    /// doing nothing if `self`'s capacity is already equal to or greater
+    /// than the requested capacity
+    ///
+    /// # Arguments
+    ///
+    /// * n - The number of elements to reserve space for
+    fn reserve(&mut self, n: uint) {
+        vec::reserve(&mut self.elts, n);
+    }
+
+    /// Reserve capacity for at least `n` elements in the given deque,
+    /// over-allocating in case the caller needs to reserve additional
+    /// space.
+    ///
+    /// Do nothing if `self`'s capacity is already equal to or greater
+    /// than the requested capacity.
+    ///
+    /// # Arguments
+    ///
+    /// * n - The number of elements to reserve space for
+    fn reserve_at_least(&mut self, n: uint) {
+        vec::reserve_at_least(&mut self.elts, n);
+    }
 }
 
 /// Grow is only called on full elts, so nelts is also len(elts), unlike
@@ -149,6 +174,7 @@ mod tests {
     use super::*;
     use core::cmp::Eq;
     use core::kinds::Copy;
+    use core::vec::capacity;
 
     #[test]
     fn test_simple() {
@@ -328,4 +354,29 @@ mod tests {
         }
 
     }
+
+    #[test]
+    fn test_reserve() {
+        let mut d = Deque::new();
+        d.add_back(0u64);
+        d.reserve(50);
+        assert_eq!(capacity(&mut d.elts), 50);
+        let mut d = Deque::new();
+        d.add_back(0u32);
+        d.reserve(50);
+        assert_eq!(capacity(&mut d.elts), 50);
+    }
+
+    #[test]
+    fn test_reserve_at_least() {
+        let mut d = Deque::new();
+        d.add_back(0u64);
+        d.reserve_at_least(50);
+        assert_eq!(capacity(&mut d.elts), 64);
+        let mut d = Deque::new();
+        d.add_back(0u32);
+        d.reserve_at_least(50);
+        assert_eq!(capacity(&mut d.elts), 64);
+    }
+
 }

branches/snap-stage3/src/libextra/flatpipes.rs

@@ -25,7 +25,7 @@ ports and channels.
 
 This example sends boxed integers across tasks using serialization.
 
-~~~ {.rust}
+~~~
 let (port, chan) = serial::pipe_stream();
 
 do task::spawn || {

branches/snap-stage3/src/libextra/future.rs

@@ -14,7 +14,7 @@
  *
  * # Example
  *
- * ~~~ {.rust}
+ * ~~~
  * # fn fib(n: uint) -> uint {42};
  * # fn make_a_sandwich() {};
  * let mut delayed_fib = std::future::spawn (|| fib(5000) );

branches/snap-stage3/src/libextra/net_tcp.rs

@@ -466,7 +466,7 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  * Here, the `new_conn` is used in conjunction with `accept` from within
  * a task spawned by the `new_connect_cb` passed into `listen`
  *
- * ~~~ {.rust}
+ * ~~~~~~~~~~~
  * do net::tcp::listen(remote_ip, remote_port, backlog, iotask,
  *     // this callback is ran once after the connection is successfully
  *     // set up
@@ -497,7 +497,7 @@ fn read_future(sock: &TcpSocket, timeout_msecs: uint)
  *       None => ()
  *     }
  * };
- * ~~~
+ * ~~~~~~~~~~~
  *
  * # Arguments
  *

branches/snap-stage3/src/libextra/sync.rs

@@ -545,10 +545,7 @@ pub impl RWlock {
      * the meantime (such as unlocking and then re-locking as a reader would
      * do). The block takes a "write mode token" argument, which can be
      * transformed into a "read mode token" by calling downgrade(). Example:
-     *
-     * # Example
-     *
-     * ~~~ {.rust}
+     * ~~~
      * do lock.write_downgrade |write_mode| {
      *     do (&write_mode).write_cond |condvar| {
      *         ... exclusive access ...