From c403c1f18e987482a050299a647b0fbcdfea09ad Mon Sep 17 00:00:00 2001
From: Steven Fackler <sfackler@gmail.com>
Date: Mon, 25 Nov 2013 20:02:15 -0800
Subject: Clean up SmallVector use a bit

---
 src/libsyntax/util/small_vector.rs | 106 ++++++++++---------------------------
 1 file changed, 27 insertions(+), 79 deletions(-)

(limited to 'src/libsyntax/util')

diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs
index 0196a0212e2..71eee8b7ccc 100644
--- a/src/libsyntax/util/small_vector.rs
+++ b/src/libsyntax/util/small_vector.rs
@@ -54,42 +54,17 @@ impl<T> SmallVector<T> {
         match *self {
             Zero => *self = One(v),
             One(*) => {
-                let mut tmp = Many(~[]);
-                util::swap(self, &mut tmp);
-                match *self {
-                    Many(ref mut vs) => {
-                        match tmp {
-                            One(v1) => {
-                                vs.push(v1);
-                                vs.push(v);
-                            }
-                            _ => unreachable!()
-                        }
-                    }
+                let one = util::replace(self, Zero);
+                match one {
+                    One(v1) => util::replace(self, Many(~[v1, v])),
                     _ => unreachable!()
-                }
+                };
             }
             Many(ref mut vs) => vs.push(v)
         }
     }
 
-    pub fn pop(&mut self) -> T {
-        match *self {
-            Zero => fail!("attempted to pop from an empty SmallVector"),
-            One(*) => {
-                let mut tmp = Zero;
-                util::swap(self, &mut tmp);
-                match tmp {
-                    One(v) => v,
-                    _ => unreachable!()
-                }
-            }
-            // Should this reduce to a One if possible?
-            Many(ref mut vs) => vs.pop()
-        }
-    }
-
-    pub fn get<'a>(&'a self, idx: uint) -> &'a T {
+    fn get<'a>(&'a self, idx: uint) -> &'a T {
         match *self {
             One(ref v) if idx == 0 => v,
             Many(ref vs) => &vs[idx],
@@ -97,10 +72,11 @@ impl<T> SmallVector<T> {
         }
     }
 
-    pub fn iter<'a>(&'a self) -> SmallVectorIterator<'a, T> {
-        SmallVectorIterator {
-            vec: self,
-            idx: 0
+    pub fn expect_one(self, err: &'static str) -> T {
+        match self {
+            One(v) => v,
+            Many([v]) => v,
+            _ => fail!(err)
         }
     }
 
@@ -113,27 +89,6 @@ impl<T> SmallVector<T> {
     }
 }
 
-pub struct SmallVectorIterator<'vec, T> {
-    priv vec: &'vec SmallVector<T>,
-    priv idx: uint
-}
-
-impl<'vec, T> Iterator<&'vec T> for SmallVectorIterator<'vec, T> {
-    fn next(&mut self) -> Option<&'vec T> {
-        if self.idx == self.vec.len() {
-            return None;
-        }
-
-        self.idx += 1;
-        Some(self.vec.get(self.idx - 1))
-    }
-
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let rem = self.vec.len() - self.idx;
-        (rem, Some(rem))
-    }
-}
-
 pub enum SmallVectorMoveIterator<T> {
     priv ZeroIterator,
     priv OneIterator(T),
@@ -192,18 +147,6 @@ mod test {
         assert_eq!(&3, v.get(2));
     }
 
-    #[test]
-    fn test_pop() {
-        let mut v = SmallVector::one(1);
-        assert_eq!(1, v.pop());
-        assert_eq!(0, v.len());
-
-        let mut v= SmallVector::many(~[1, 2]);
-        assert_eq!(2, v.pop());
-        assert_eq!(1, v.pop());
-        assert_eq!(0, v.len());
-    }
-
     #[test]
     fn test_from_iterator() {
         let v: SmallVector<int> = (~[1, 2, 3]).move_iter().collect();
@@ -214,28 +157,33 @@ mod test {
     }
 
     #[test]
-    fn test_iter() {
+    fn test_move_iter() {
         let v = SmallVector::zero();
-        let v: ~[&int] = v.iter().collect();
+        let v: ~[int] = v.move_iter().collect();
         assert_eq!(~[], v);
 
         let v = SmallVector::one(1);
-        assert_eq!(~[&1], v.iter().collect());
+        assert_eq!(~[1], v.move_iter().collect());
 
         let v = SmallVector::many(~[1, 2, 3]);
-        assert_eq!(~[&1, &2, &3], v.iter().collect());
+        assert_eq!(~[1, 2, 3], v.move_iter().collect());
     }
 
     #[test]
-    fn test_move_iter() {
-        let v = SmallVector::zero();
-        let v: ~[int] = v.move_iter().collect();
-        assert_eq!(~[], v);
+    #[should_fail]
+    fn test_expect_one_zero() {
+        let _: int = SmallVector::zero().expect_one("");
+    }
 
-        let v = SmallVector::one(1);
-        assert_eq!(~[1], v.move_iter().collect());
+    #[test]
+    #[should_fail]
+    fn test_expect_one_many() {
+        SmallVector::many(~[1, 2]).expect_one("");
+    }
 
-        let v = SmallVector::many(~[1, 2, 3]);
-        assert_eq!(~[1, 2, 3], v.move_iter().collect());
+    #[test]
+    fn test_expect_one_one() {
+        assert_eq!(1, SmallVector::one(1).expect_one(""));
+        assert_eq!(1, SmallVector::many(~[1]).expect_one(""));
     }
 }
-- 
cgit 1.4.1-3-g733a5