---

yaml
---
r: 66300
b: refs/heads/master
c: dfc9392
h: refs/heads/master
v: v3

Author: jedestep

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4f7a742a067dcd6e8dbcf1da2bbcf203147562cf
+refs/heads/master: dfc9392c381c9c5b3e4313e23765c4b04d128e99
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/libextra/deque.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 //! A double-ended queue implemented as a circular buffer
-
 use core::prelude::*;
 
 use core::uint;
@@ -156,98 +155,122 @@ impl<T> Deque<T> {
 
     /// Front-to-back iterator.
     pub fn iter<'a>(&'a self) -> DequeIterator<'a, T> {
-	DequeIterator { iter: self.elts.iter() }
+    DequeIterator { idx: self.lo, nelts: self.nelts, used: 0, vec: self.elts }
     }
 
     /// Front-to-back iterator which returns mutable values.
     pub fn mut_iter<'a>(&'a mut self) -> DequeMutIterator<'a, T> {
-	DequeMutIterator { iter: self.elts.mut_iter() }
+    DequeMutIterator { idx: self.lo, nelts: self.nelts, used: 0, vec: self.elts }
     }
 
     /// Back-to-front iterator.
     pub fn rev_iter<'a>(&'a self) -> DequeRevIterator<'a, T> {
-	DequeRevIterator { iter: self.elts.rev_iter() }
+    DequeRevIterator { idx: self.hi - 1u, nelts: self.nelts, used: 0, vec: self.elts }
     }
 
     /// Back-to-front iterator which returns mutable values.
     pub fn mut_rev_iter<'a>(&'a mut self) -> DequeMutRevIterator<'a, T> {
-	DequeMutRevIterator { iter: self.elts.mut_rev_iter() }
+    DequeMutRevIterator { idx: self.hi - 1u, nelts: self.nelts, used: 0, vec: self.elts }
     }
 }
 
 /// Deque iterator
 pub struct DequeIterator<'self, T> {
-	priv iter: vec::VecIterator<'self, Option<T>>
+    priv idx: uint,
+    priv nelts: uint,
+    priv used: uint,
+    priv vec: &'self [Option<T>]
 }
 
 /// Deque reverse iterator
 pub struct DequeRevIterator<'self, T> {
-	priv iter: vec::VecRevIterator<'self, Option<T>>
+    priv idx: uint,
+    priv nelts: uint,
+    priv used: uint,
+    priv vec: &'self [Option<T>]
 }
 /// Deque mutable iterator
 pub struct DequeMutIterator<'self, T> {
-	priv iter: vec::VecMutIterator<'self, Option<T>>
+    priv idx: uint,
+    priv nelts: uint,
+    priv used: uint,
+    priv vec: &'self mut [Option<T>]
+
 }
 
 /// Deque mutable reverse iterator
 pub struct DequeMutRevIterator<'self, T> {
-	priv iter: vec::VecMutRevIterator<'self, Option<T>>
+    priv idx: uint,
+    priv nelts: uint,
+    priv used: uint,
+    priv vec: &'self mut [Option<T>]
 }
 
 /// Iterator visiting elements of the deque from front to back
 impl<'self, T> Iterator<&'self T> for DequeIterator<'self, T> {
-	#[inline]
-	fn next(&mut self) -> Option<&'self T> {
-		for self.iter.advance |elt| {
-			match elt {
-				&Some(ref e) => return Some(e),
-				&None => {},
-			}
-		}
-		None
-	}
+    fn next(&mut self) -> Option<&'self T> {
+        if self.used >= self.nelts {
+            return None;
+        }
+        let ret = match self.vec[self.idx % self.vec.len()] {
+            Some(ref e) => Some(e),
+            None => None
+        };
+        self.idx += 1;
+        self.used += 1;
+        ret
+    }
 }
 
 /// Iterator visiting elements of the deque mutably from front to back
 impl<'self, T> Iterator<&'self mut T> for DequeMutIterator<'self, T> {
-	#[inline]
-	fn next(&mut self) -> Option<&'self mut T> {
-		for self.iter.advance |elt| {
-			match elt {
-				&Some(ref mut e) => return Some(e),
-				&None => {},
-			}
-		}
-		None
-	}
+    fn next(&mut self) -> Option<&'self mut T> {
+        if self.used >= self.nelts {
+            return None;
+        }
+        let ret = match self.vec[self.idx % self.vec.len()] {
+            Some(ref mut e) => Some(e),
+            None => None
+        };
+        self.idx += 1;
+        self.used += 1;
+        ret
+    }
 }
 
 /// Iterator visiting elements of the deque from back to front
 impl<'self, T> Iterator<&'self T> for DequeRevIterator<'self, T> {
-	#[inline]
-	fn next(&mut self) -> Option<&'self T> {
-		for self.iter.advance |elt| {
-			match elt {
-				&Some(ref e) => return Some(e),
-				&None => {},
-			}
-		}
-		None
-	}
+    #[inline]
+    fn next(&mut self) -> Option<&'self T> {
+        if self.used >= self.nelts {
+            return None;
+        }
+        let ret = match self.vec[self.idx % self.vec.len()] {
+            Some(ref e) => Some(e),
+            None => None
+        };
+        self.idx -= 1;
+        self.used += 1;
+        ret
+
+    }
 }
 
 /// Iterator visiting elements of the deque mutably from back to front
 impl<'self, T> Iterator<&'self mut T> for DequeMutRevIterator<'self, T> {
-	#[inline]
-	fn next(&mut self) -> Option<&'self mut T> {
-		for self.iter.advance |elt| {
-			match elt {
-				&Some(ref mut e) => return Some(e),
-				&None => {},
-			}
-		}
-		None
-	}
+    #[inline]
+    fn next(&mut self) -> Option<&'self mut T> {
+        if self.used >= self.nelts {
+            return None;
+        }
+        let ret = match self.vec[self.idx % self.vec.len()] {
+            Some(ref mut e) => Some(e),
+            None => None
+        };
+        self.idx -= 1;
+        self.used += 1;
+        ret
+    }
 }
 
 /// Grow is only called on full elts, so nelts is also len(elts), unlike