implement BaseIter for LinearMap

src/libcargo/cargo.rc

@@ -495,7 +495,7 @@ pub fn try_parse_sources(filename: &Path,
     let c = io::read_whole_file_str(filename);
     match json::from_str(c.get()) {
         Ok(json::Object(j)) => {
-            for j.each |k, v| {
+            for j.each |&(k, v)| {
                 sources.insert(copy *k, parse_source(*k, v));
                 debug!("source: %s", *k);
             }

src/libcore/hashmap.rs

@@ -235,6 +235,23 @@ pub mod linear {
         }
     }
 
+    impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: BaseIter<(&K, &V)> {
+        /// Visit all key-value pairs
+        pure fn each(&self, blk: fn(&(&self/K, &self/V)) -> bool) {
+            for uint::range(0, self.buckets.len()) |i| {
+                let mut broke = false;
+                do self.buckets[i].map |bucket| {
+                    if !blk(&(&bucket.key, &bucket.value)) {
+                        broke = true; // FIXME(#3064) just write "break;"
+                    }
+                };
+                if broke { break; }
+            }
+        }
+        pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
+    }
+
+
     impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: Container {
         /// Return the number of elements in the map
         pure fn len(&self) -> uint { self.size }
@@ -264,12 +281,12 @@ pub mod linear {
 
         /// Visit all keys
         pure fn each_key(&self, blk: fn(k: &K) -> bool) {
-            self.each(|k, _| blk(k))
+            self.each(|&(k, _)| blk(k))
         }
 
         /// Visit all values
         pure fn each_value(&self, blk: fn(v: &V) -> bool) {
-            self.each(|_, v| blk(v))
+            self.each(|&(_, v)| blk(v))
         }
 
         /// Return the value corresponding to the key in the map
@@ -322,19 +339,6 @@ pub mod linear {
             linear_map_with_capacity(INITIAL_CAPACITY)
         }
 
-        /// Visit all key-value pairs
-        pure fn each(&self, blk: fn(k: &K, v: &V) -> bool) {
-            for self.buckets.each |slot| {
-                let mut broke = false;
-                do slot.iter |bucket| {
-                    if !blk(&bucket.key, &bucket.value) {
-                        broke = true; // FIXME(#3064) just write "break;"
-                    }
-                }
-                if broke { break; }
-            }
-        }
-
         fn pop(&mut self, k: &K) -> Option<V> {
             let hash = k.hash_keyed(self.k0, self.k1) as uint;
             self.pop_internal(hash, k)
@@ -388,7 +392,7 @@ pub mod linear {
         pure fn eq(&self, other: &LinearMap<K, V>) -> bool {
             if self.len() != other.len() { return false; }
 
-            for self.each |key, value| {
+            for self.each |&(key, value)| {
                 match other.find(key) {
                     None => return false,
                     Some(v) => if value != v { return false },
@@ -603,7 +607,7 @@ mod test_map {
             assert m.insert(i, i*2);
         }
         let mut observed = 0;
-        for m.each |k, v| {
+        for m.each |&(k, v)| {
             assert *v == *k * 2;
             observed |= (1 << *k);
         }

src/libstd/json.rs

@@ -302,7 +302,7 @@ pub impl<S: serialize::Encoder> Json: serialize::Encodable<S> {
             Object(ref v) => {
                 do s.emit_rec || {
                     let mut idx = 0;
-                    for v.each |key, value| {
+                    for v.each |&(key, value)| {
                         do s.emit_field(*key, idx) {
                             value.encode(s);
                         }
@@ -936,7 +936,7 @@ impl Json : Eq {
                     &Object(ref d1) => {
                         if d0.len() == d1.len() {
                             let mut equal = true;
-                            for d0.each |k, v0| {
+                            for d0.each |&(k, v0)| {
                                 match d1.find(k) {
                                     Some(v1) if v0 == v1 => { },
                                     _ => { equal = false; break }
@@ -1000,12 +1000,12 @@ impl Json : Ord {
                             let mut d1_flat = ~[];
 
                             // FIXME #4430: this is horribly inefficient...
-                            for d0.each |k, v| {
+                            for d0.each |&(k, v)| {
                                  d0_flat.push((@copy *k, @copy *v));
                             }
                             d0_flat.qsort();
 
-                            for d1.each |k, v| {
+                            for d1.each |&(k, v)| {
                                 d1_flat.push((@copy *k, @copy *v));
                             }
                             d1_flat.qsort();
@@ -1146,7 +1146,7 @@ impl <A: ToJson> ~[A]: ToJson {
 impl <A: ToJson Copy> LinearMap<~str, A>: ToJson {
     fn to_json() -> Json {
         let mut d = LinearMap::new();
-        for self.each() |key, value| {
+        for self.each |&(key, value)| {
             d.insert(copy *key, value.to_json());
         }
         Object(~d)

src/libstd/net_url.rs

@@ -219,10 +219,10 @@ pub fn encode_form_urlencoded(m: &LinearMap<~str, ~[~str]>) -> ~str {
     let mut out = ~"";
     let mut first = true;
 
-    for m.each |key, values| {
+    for m.each |&(key, values)| {
         let key = encode_plus(*key);
 
-        for (*values).each |value| {
+        for values.each |value| {
             if first {
                 first = false;
             } else {

src/libstd/workcache.rs

@@ -142,7 +142,7 @@ type WorkMap = LinearMap<WorkKey, ~str>;
 pub impl<S: Encoder> WorkMap: Encodable<S> {
     fn encode(&self, s: &S) {
         let d = dvec::DVec();
-        for self.each |k, v| {
+        for self.each |&(k, v)| {
             d.push((copy *k, copy *v))
         }
         let mut v = d.get();
@@ -155,7 +155,7 @@ pub impl<D: Decoder> WorkMap: Decodable<D> {
     static fn decode(&self, d: &D) -> WorkMap {
         let v : ~[(WorkKey,~str)] = Decodable::decode(d);
         let mut w = LinearMap::new();
-        for v.each |&(k,v)| {
+        for v.each |&(k, v)| {
             w.insert(copy k, copy v);
         }
         w
@@ -312,7 +312,7 @@ impl @Mut<Prep> : TPrep {
     }
 
     fn all_fresh(&self, cat: &str, map: &WorkMap) -> bool {
-        for map.each |k,v| {
+        for map.each |&(k, v)| {
             if ! self.is_fresh(cat, k.kind, k.name, *v) {
                 return false;
             }