---

yaml
---
r: 83956
b: refs/heads/dist-snap
c: 37494d3
h: refs/heads/master
v: v3

Author: glinscott

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: fc17d4371f1d3e0c40ebcb6de0b9e7cbb89fa0c9
+refs/heads/dist-snap: 37494d39d38be33a589a1f46dae38fe2ceb9d94f
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libextra/json.rs

@@ -481,22 +481,30 @@ pub fn to_pretty_str(json: &Json) -> ~str {
     io::with_str_writer(|wr| to_pretty_writer(wr, json))
 }
 
+static BUF_SIZE : uint = 64000;
+
 #[allow(missing_doc)]
 pub struct Parser {
     priv rdr: @io::Reader,
+    priv buf: ~[char],
+    priv buf_idx: uint,
     priv ch: char,
     priv line: uint,
     priv col: uint,
 }
 
 /// Decode a json value from an io::reader
 pub fn Parser(rdr: @io::Reader) -> Parser {
-    Parser {
+    let mut p = Parser {
         rdr: rdr,
-        ch: rdr.read_char(),
+        buf: rdr.read_chars(BUF_SIZE),
+        buf_idx: 0,
+        ch: 0 as char,
         line: 1,
-        col: 1,
-    }
+        col: 0,
+    };
+    p.bump();
+    p
 }
 
 impl Parser {
@@ -521,13 +529,26 @@ impl Parser {
     fn eof(&self) -> bool { self.ch == -1 as char }
 
     fn bump(&mut self) {
-        self.ch = self.rdr.read_char();
+        if self.eof() {
+            return;
+        }
+
+        self.col += 1u;
+
+        if self.buf_idx >= self.buf.len() {
+            self.buf = self.rdr.read_chars(BUF_SIZE);
+            if self.buf.len() == 0 {
+                self.ch = -1 as char;
+                return;
+            }
+            self.buf_idx = 0;
+        }
+        self.ch = self.buf[self.buf_idx];
+        self.buf_idx += 1;
 
         if self.ch == '\n' {
             self.line += 1u;
             self.col = 1u;
-        } else {
-            self.col += 1u;
         }
     }
 

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

@@ -1091,9 +1091,7 @@ pub trait OwnedVector<T> {
 
     fn push_all_move(&mut self, rhs: ~[T]);
     fn pop(&mut self) -> T;
-    fn pop_opt(&mut self) -> Option<T>;
     fn shift(&mut self) -> T;
-    fn shift_opt(&mut self) -> Option<T>;
     fn unshift(&mut self, x: T);
     fn insert(&mut self, i: uint, x:T);
     fn remove(&mut self, i: uint) -> T;
@@ -1283,49 +1281,35 @@ impl<T> OwnedVector<T> for ~[T] {
         }
     }
 
-    /// Remove the last element from a vector and return it, or `None` if it is empty
-    fn pop_opt(&mut self) -> Option<T> {
-        match self.len() {
-            0  => None,
-            ln => {
-                let valptr = ptr::to_mut_unsafe_ptr(&mut self[ln - 1u]);
-                unsafe {
-                    let val = ptr::replace_ptr(valptr, intrinsics::init());
-                    raw::set_len(self, ln - 1u);
-                    Some(val)
-                }
-            }
-        }
-    }
-
-
-    /// Remove the last element from a vector and return it, failing if it is empty
-    #[inline]
+    /// Remove the last element from a vector and return it
     fn pop(&mut self) -> T {
-        self.pop_opt().expect("pop: empty vector")
+        let ln = self.len();
+        if ln == 0 {
+            fail!("sorry, cannot pop an empty vector")
+        }
+        let valptr = ptr::to_mut_unsafe_ptr(&mut self[ln - 1u]);
+        unsafe {
+            let val = ptr::replace_ptr(valptr, intrinsics::init());
+            raw::set_len(self, ln - 1u);
+            val
+        }
     }
 
     /// Removes the first element from a vector and return it
-    #[inline]
     fn shift(&mut self) -> T {
-        self.shift_opt().expect("shift: empty vector")
-    }
-
-    /// Removes the first element from a vector and return it, or `None` if it is empty
-    fn shift_opt(&mut self) -> Option<T> {
         unsafe {
-            let ln = match self.len() {
-                0 => return None,
-                1 => return self.pop_opt(),
-                2 =>  {
-                    let last = self.pop();
-                    let first = self.pop_opt();
-                    self.push(last);
-                    return first;
-                }
-                x => x
-            };
+            assert!(!self.is_empty());
+
+            if self.len() == 1 { return self.pop() }
+
+            if self.len() == 2 {
+                let last = self.pop();
+                let first = self.pop();
+                self.push(last);
+                return first;
+            }
 
+            let ln = self.len();
             let next_ln = self.len() - 1;
 
             // Save the last element. We're going to overwrite its position
@@ -1361,7 +1345,7 @@ impl<T> OwnedVector<T> for ~[T] {
             let vp = raw::to_mut_ptr(*self);
             let vp = ptr::mut_offset(vp, next_ln - 1);
 
-            Some(ptr::replace_ptr(vp, work_elt))
+            ptr::replace_ptr(vp, work_elt)
         }
     }
 
@@ -2105,13 +2089,18 @@ impl<T> Iterator<T> for VecConsumeIterator<T> {
         //
         // [1,2,3,4,5] => 1, [5,2,3,4] => 2, [5,4,3] => 3, [5,4] => 4,
         // [5] -> 5, []
-        let l = self.v.len();
-        if self.idx < l {
-            self.v.swap(self.idx, l - 1);
-            self.idx += 1;
-        }
 
-        self.v.pop_opt()
+        if self.v.is_empty() {
+            None
+        } else {
+            let l = self.v.len();
+            if self.idx < l {
+                self.v.swap(self.idx, l - 1);
+                self.idx += 1;
+            }
+
+            Some(self.v.pop())
+        }
     }
 }
 
@@ -2122,7 +2111,8 @@ pub struct VecConsumeRevIterator<T> {
 
 impl<T> Iterator<T> for VecConsumeRevIterator<T> {
     fn next(&mut self) -> Option<T> {
-        self.v.pop_opt()
+        if self.v.is_empty() { None }
+        else { Some(self.v.pop()) }
     }
 }
 
@@ -2425,17 +2415,6 @@ mod tests {
     }
 
     #[test]
-    fn test_pop_opt() {
-        let mut v = ~[5];
-        let e = v.pop_opt();
-        assert_eq!(v.len(), 0);
-        assert_eq!(e, Some(5));
-        let f = v.pop_opt();
-        assert_eq!(f, None);
-        let g = v.pop_opt();
-        assert_eq!(g, None);
-    }
-
     fn test_swap_remove() {
         let mut v = ~[1, 2, 3, 4, 5];
         let mut e = v.swap_remove(0);
@@ -2770,27 +2749,6 @@ mod tests {
         assert_eq!([&[1], &[2], &[3]].connect_vec(&0), ~[1, 0, 2, 0, 3]);
     }
 
-    #[test]
-    fn test_shift() {
-        let mut x = ~[1, 2, 3];
-        assert_eq!(x.shift(), 1);
-        assert_eq!(&x, &~[2, 3]);
-        assert_eq!(x.shift(), 2);
-        assert_eq!(x.shift(), 3);
-        assert_eq!(x.len(), 0);
-    }
-
-    #[test]
-    fn test_shift_opt() {
-        let mut x = ~[1, 2, 3];
-        assert_eq!(x.shift_opt(), Some(1));
-        assert_eq!(&x, &~[2, 3]);
-        assert_eq!(x.shift_opt(), Some(2));
-        assert_eq!(x.shift_opt(), Some(3));
-        assert_eq!(x.shift_opt(), None);
-        assert_eq!(x.len(), 0);
-    }
-
     #[test]
     fn test_unshift() {
         let mut x = ~[1, 2, 3];