Change VecMap's iterators to use wrapper structs instead of typedefs.

Author: csouth3

src/libcollections/vec_map.rs

@@ -18,7 +18,7 @@ use core::prelude::*;
 use core::default::Default;
 use core::fmt;
 use core::iter;
-use core::iter::{Enumerate, FilterMap};
+use core::iter::{Enumerate, FilterMap, Map};
 use core::mem::replace;
 
 use hash::{Hash, Writer};
@@ -141,14 +141,14 @@ impl<V> VecMap<V> {
     /// The iterator's element type is `uint`.
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn keys<'r>(&'r self) -> Keys<'r, V> {
-        self.iter().map(|(k, _v)| k)
+        Keys { iter: self.iter().map(|(k, _v)| k) }
     }
 
     /// Returns an iterator visiting all values in ascending order by the keys.
     /// The iterator's element type is `&'r V`.
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn values<'r>(&'r self) -> Values<'r, V> {
-        self.iter().map(|(_k, v)| v)
+        Values { iter: self.iter().map(|(_k, v)| v) }
     }
 
     /// Returns an iterator visiting all key-value pairs in ascending order by the keys.
@@ -231,9 +231,11 @@ impl<V> VecMap<V> {
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn into_iter(&mut self) -> MoveItems<V> {
         let values = replace(&mut self.v, vec!());
-        values.into_iter().enumerate().filter_map(|(i, v)| {
-            v.map(|v| (i, v))
-        })
+        MoveItems {
+            iter: values.into_iter().enumerate().filter_map(|(i, v)| {
+                v.map(|v| (i, v))
+            })
+        }
     }
 
     /// Return the number of elements in the map.
@@ -598,7 +600,7 @@ macro_rules! double_ended_iterator {
     }
 }
 
-/// Forward iterator over a map.
+/// An iterator over the key-value pairs of a map.
 pub struct Entries<'a, V:'a> {
     front: uint,
     back: uint,
@@ -608,7 +610,7 @@ pub struct Entries<'a, V:'a> {
 iterator!(impl Entries -> (uint, &'a V), as_ref)
 double_ended_iterator!(impl Entries -> (uint, &'a V), as_ref)
 
-/// Forward iterator over the key-value pairs of a map, with the
+/// An iterator over the key-value pairs of a map, with the
 /// values being mutable.
 pub struct MutEntries<'a, V:'a> {
     front: uint,
@@ -619,17 +621,47 @@ pub struct MutEntries<'a, V:'a> {
 iterator!(impl MutEntries -> (uint, &'a mut V), as_mut)
 double_ended_iterator!(impl MutEntries -> (uint, &'a mut V), as_mut)
 
-/// Forward iterator over the keys of a map
-pub type Keys<'a, V> =
-    iter::Map<'static, (uint, &'a V), uint, Entries<'a, V>>;
+/// An iterator over the keys of a map.
+pub struct Keys<'a, V: 'a> {
+    iter: Map<'static, (uint, &'a V), uint, Entries<'a, V>>
+}
+
+impl<'a, V> Iterator<uint> for Keys<'a, V> {
+    fn next(&mut self) -> Option<uint> { self.iter.next() }
+    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+}
+
+impl<'a, V> DoubleEndedIterator<uint> for Keys<'a, V> {
+    fn next_back(&mut self) -> Option<uint> { self.iter.next_back() }
+}
+
+/// An iterator over the values of a map.
+pub struct Values<'a, V: 'a> {
+    iter: Map<'static, (uint, &'a V), &'a V, Entries<'a, V>>
+}
+
+impl<'a, V> Iterator<&'a V> for Values<'a, V> {
+    fn next(&mut self) -> Option<(&'a V)> { self.iter.next() }
+    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+}
+
+impl<'a, V> DoubleEndedIterator<&'a V> for Values<'a, V> {
+    fn next_back(&mut self) -> Option<(&'a V)> { self.iter.next_back() }
+}
+
+/// A consuming iterator over the key-value pairs of a map.
+pub struct MoveItems<V> {
+    iter: FilterMap<'static, (uint, Option<V>), (uint, V), Enumerate<vec::MoveItems<Option<V>>>>
+}
 
-/// Forward iterator over the values of a map
-pub type Values<'a, V> =
-    iter::Map<'static, (uint, &'a V), &'a V, Entries<'a, V>>;
+impl<V> Iterator<(uint, V)> for MoveItems<V> {
+    fn next(&mut self) -> Option<(uint, V)> { self.iter.next() }
+    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+}
 
-/// Iterator over the key-value pairs of a map, the iterator consumes the map
-pub type MoveItems<V> =
-    FilterMap<'static, (uint, Option<V>), (uint, V), Enumerate<vec::MoveItems<Option<V>>>>;
+impl<V> DoubleEndedIterator<(uint, V)> for MoveItems<V> {
+    fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
+}
 
 #[cfg(test)]
 mod test_map {