Alter entries iterator behavior

The old setup would have locked the implementation to storing keys and values together
rust-phf · Nov 29, 2014 · 14627f5 · 14627f5
1 parent f0cb91d
commit 14627f5
Show file tree

Hide file tree

Showing 4 changed files with 28 additions and 30 deletions.
diff --git a/phf/src/map.rs b/phf/src/map.rs
@@ -43,7 +43,7 @@ impl<K, V> fmt::Show for Map<K, V> where K: fmt::Show, V: fmt::Show {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(fmt, "{{"));
         let mut first = true;
-        for &(ref k, ref v) in self.entries() {
+        for (k, v) in self.entries() {
             if !first {
                 try!(write!(fmt, ", "));
             }
@@ -107,31 +107,31 @@ impl<K, V> Map<K, V> {
     ///
     /// Entries are retuned in an arbitrary but fixed order.
     pub fn entries<'a>(&'a self) -> Entries<'a, K, V> {
-        Entries { iter: self.entries.iter() }
+        Entries { iter: self.entries.iter().map(|&(ref k, ref v)| (k, v)) }
     }
 
     /// Returns an iterator over the keys in the map.
     ///
     /// Keys are returned in an arbitrary but fixed order.
     pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
-        Keys { iter: self.entries().map(|e| &e.0) }
+        Keys { iter: self.entries().map(|e| e.0) }
     }
 
     /// Returns an iterator over the values in the map.
     ///
     /// Values are returned in an arbitrary but fixed order.
     pub fn values<'a>(&'a self) -> Values<'a, K, V> {
-        Values { iter: self.entries().map(|e | &e.1) }
+        Values { iter: self.entries().map(|e | e.1) }
     }
 }
 
 /// An iterator over the key/value pairs in a `Map`.
 pub struct Entries<'a, K:'a, V:'a> {
-    iter: slice::Items<'a, (K, V)>,
+    iter: iter::Map<'a, &'a (K, V), (&'a K, &'a V), slice::Items<'a, (K, V)>>,
 }
 
-impl<'a, K, V> Iterator<&'a (K, V)> for Entries<'a, K, V> {
-    fn next(&mut self) -> Option<&'a (K, V)> {
+impl<'a, K, V> Iterator<(&'a K, &'a V)> for Entries<'a, K, V> {
+    fn next(&mut self) -> Option<(&'a K, &'a V)> {
         self.iter.next()
     }
 
@@ -140,17 +140,17 @@ impl<'a, K, V> Iterator<&'a (K, V)> for Entries<'a, K, V> {
     }
 }
 
-impl<'a, K, V> DoubleEndedIterator<&'a (K, V)> for Entries<'a, K, V> {
-    fn next_back(&mut self) -> Option<&'a (K, V)> {
+impl<'a, K, V> DoubleEndedIterator<(&'a K, &'a V)> for Entries<'a, K, V> {
+    fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
         self.iter.next_back()
     }
 }
 
-impl<'a, K, V> ExactSizeIterator<&'a (K, V)> for Entries<'a, K, V> {}
+impl<'a, K, V> ExactSizeIterator<(&'a K, &'a V)> for Entries<'a, K, V> {}
 
 /// An iterator over the keys in a `Map`.
 pub struct Keys<'a, K:'a, V:'a> {
-    iter: iter::Map<'a, &'a (K, V), &'a K, Entries<'a, K, V>>,
+    iter: iter::Map<'a, (&'a K, &'a V), &'a K, Entries<'a, K, V>>,
 }
 
 impl<'a, K, V> Iterator<&'a K> for Keys<'a, K, V> {
@@ -173,7 +173,7 @@ impl<'a, K, V> ExactSizeIterator<&'a K> for Keys<'a, K, V> {}
 
 /// An iterator over the values in a `Map`.
 pub struct Values<'a, K:'a, V:'a> {
-    iter: iter::Map<'a, &'a (K, V), &'a V, Entries<'a, K, V>>,
+    iter: iter::Map<'a, (&'a K, &'a V), &'a V, Entries<'a, K, V>>,
 }
 
 impl<'a, K, V> Iterator<&'a V> for Values<'a, K, V> {

diff --git a/phf/src/ordered_map.rs b/phf/src/ordered_map.rs
@@ -49,7 +49,7 @@ impl<K, V> fmt::Show for OrderedMap<K, V> where K: fmt::Show, V: fmt::Show {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(fmt, "{{"));
         let mut first = true;
-        for &(ref k, ref v) in self.entries() {
+        for (k, v) in self.entries() {
             if !first {
                 try!(write!(fmt, ", "));
             }
@@ -126,31 +126,31 @@ impl<K, V> OrderedMap<K, V> {
     ///
     /// Entries are returned in the same order in which they were defined.
     pub fn entries<'a>(&'a self) -> Entries<'a, K, V> {
-        Entries { iter: self.entries.iter() }
+        Entries { iter: self.entries.iter().map(|&(ref k, ref v)| (k, v)) }
     }
 
     /// Returns an iterator over the keys in the map.
     ///
     /// Keys are returned in the same order in which they were defined.
     pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
-        Keys { iter: self.entries().map(|e| &e.0) }
+        Keys { iter: self.entries().map(|e| e.0) }
     }
 
     /// Returns an iterator over the values in the map.
     ///
     /// Values are returned in the same order in which they were defined.
     pub fn values<'a>(&'a self) -> Values<'a, K, V> {
-        Values { iter: self.entries().map(|e| &e.1) }
+        Values { iter: self.entries().map(|e| e.1) }
     }
 }
 
 /// An iterator over the entries in a `OrderedMap`.
 pub struct Entries<'a, K:'a, V:'a> {
-    iter: slice::Items<'a, (K, V)>,
+    iter: iter::Map<'a, &'a (K, V), (&'a K, &'a V), slice::Items<'a, (K, V)>>,
 }
 
-impl<'a, K, V> Iterator<&'a (K, V)> for Entries<'a, K, V> {
-    fn next(&mut self) -> Option<&'a (K, V)> {
+impl<'a, K, V> Iterator<(&'a K, &'a V)> for Entries<'a, K, V> {
+    fn next(&mut self) -> Option<(&'a K, &'a V)> {
         self.iter.next()
     }
 
@@ -159,27 +159,27 @@ impl<'a, K, V> Iterator<&'a (K, V)> for Entries<'a, K, V> {
     }
 }
 
-impl<'a, K, V> DoubleEndedIterator<&'a (K, V)> for Entries<'a, K, V> {
-    fn next_back(&mut self) -> Option<&'a (K, V)> {
+impl<'a, K, V> DoubleEndedIterator<(&'a K, &'a V)> for Entries<'a, K, V> {
+    fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
         self.iter.next_back()
     }
 }
 
-impl<'a, K, V> RandomAccessIterator<&'a (K, V)> for Entries<'a, K, V> {
+impl<'a, K, V> RandomAccessIterator<(&'a K, &'a V)> for Entries<'a, K, V> {
     fn indexable(&self) -> uint {
         self.iter.indexable()
     }
 
-    fn idx(&mut self, index: uint) -> Option<&'a (K, V)> {
+    fn idx(&mut self, index: uint) -> Option<(&'a K, &'a V)> {
         self.iter.idx(index)
     }
 }
 
-impl<'a, K, V> ExactSizeIterator<&'a (K, V)> for Entries<'a, K, V> {}
+impl<'a, K, V> ExactSizeIterator<(&'a K, &'a V)> for Entries<'a, K, V> {}
 
 /// An iterator over the keys in a `OrderedMap`.
 pub struct Keys<'a, K:'a, V:'a> {
-    iter: iter::Map<'a, &'a (K, V), &'a K, Entries<'a, K, V>>,
+    iter: iter::Map<'a, (&'a K, &'a V), &'a K, Entries<'a, K, V>>,
 }
 
 impl<'a, K, V> Iterator<&'a K> for Keys<'a, K, V> {
@@ -212,7 +212,7 @@ impl<'a, K, V> ExactSizeIterator<&'a K> for Keys<'a, K, V> {}
 
 /// An iterator over the values in a `OrderedMap`.
 pub struct Values<'a, K:'a, V:'a> {
-    iter: iter::Map<'a, &'a (K, V), &'a V, Entries<'a, K, V>>,
+    iter: iter::Map<'a, (&'a K, &'a V), &'a V, Entries<'a, K, V>>,
 }
 
 impl<'a, K, V> Iterator<&'a V> for Values<'a, K, V> {

diff --git a/phf/tests/test.rs b/phf/tests/test.rs
@@ -36,7 +36,7 @@ mod map {
             "foo" => 10,
             "bar" => 11,
         );
-        let hash = MAP.entries().map(|&e| e).collect::<HashMap<_, int>>();
+        let hash = MAP.entries().map(|(&k, &v)| (k, v)).collect::<HashMap<_, int>>();
         assert!(Some(&10) == hash.get(&("foo")));
         assert!(Some(&11) == hash.get(&("bar")));
         assert_eq!(2, hash.len());
@@ -301,7 +301,7 @@ mod ordered_map {
             "bar" => 11,
             "baz" => 12,
         );
-        let vec = MAP.entries().map(|&(k, v)| (k, v)).collect::<Vec<_>>();
+        let vec = MAP.entries().map(|(&k, &v)| (k, v)).collect::<Vec<_>>();
         assert_eq!(vec, vec!(("foo", 10i), ("bar", 11), ("baz", 12)));
     }
 

diff --git a/phf_mac/Cargo.toml b/phf_mac/Cargo.toml
@@ -1,13 +1,11 @@
 [package]
-
 name = "phf_mac"
 authors = ["Steven Fackler <sfackler@gmail.com>"]
 version = "0.1.0"
 license = "MIT"
 description = "Compiler plugin for perfect hash function data structures"
 
 [lib]
-
 name = "phf_mac"
 path = "src/lib.rs"
 plugin = true