---

yaml
---
r: 32217
b: refs/heads/dist-snap
c: e9b7ce6
h: refs/heads/master
i:
  32215: 83b9998
v: v3

Author: nikomatsakis

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 0031617f30f159df2cef301c9d574cd219e16b16
+refs/heads/dist-snap: e9b7ce6f57e8ca74dfdb16ba91fcae38d2c44798
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/libcore/send_map.rs

@@ -13,19 +13,38 @@ Sendable hash maps.  Very much a work in progress.
 type HashFn<K> = pure fn~(K) -> uint;
 type EqFn<K> = pure fn~(K, K) -> bool;
 
+trait send_map<K, V: copy> {
+    // FIXME(#3148)  ^^^^ once find_ref() works, we can drop V:copy
+
+    fn insert(&mut self, +k: K, +v: V) -> bool;
+    fn remove(&mut self, k: &K) -> bool;
+    fn clear(&mut self);
+    pure fn len(&const self) -> uint;
+    pure fn is_empty(&const self) -> bool;
+    fn contains_key(&const self, k: &K) -> bool;
+    fn each_ref(&self, blk: fn(k: &K, v: &V) -> bool);
+    fn each_key_ref(&self, blk: fn(k: &K) -> bool);
+    fn each_value_ref(&self, blk: fn(v: &V) -> bool);
+    fn find(&const self, k: &K) -> Option<V>;
+    fn get(&const self, k: &K) -> V;
+}
+
 /// Open addressing with linear probing.
 mod linear {
     export LinearMap, linear_map, linear_map_with_capacity, public_methods;
 
     const initial_capacity: uint = 32u; // 2^5
-    type Bucket<K,V> = {hash: uint, key: K, value: V};
-    enum LinearMap<K,V> {
-        LinearMap_({
-            hashfn: pure fn~(x: &K) -> uint,
-            eqfn: pure fn~(x: &K, y: &K) -> bool,
-            resize_at: uint,
-            size: uint,
-            buckets: ~[Option<Bucket<K,V>>]})
+    struct Bucket<K,V> {
+        hash: uint;
+        key: K;
+        value: V;
+    }
+    struct LinearMap<K,V> {
+        hashfn: pure fn~(x: &K) -> uint;
+        eqfn: pure fn~(x: &K, y: &K) -> bool;
+        resize_at: uint;
+        size: uint;
+        buckets: ~[Option<Bucket<K,V>>];
     }
 
     // FIXME(#3148) -- we could rewrite found_entry
@@ -51,12 +70,13 @@ mod linear {
         +eqfn: pure fn~(x: &K, y: &K) -> bool,
         initial_capacity: uint) -> LinearMap<K,V> {
 
-        LinearMap_({
+        LinearMap {
             hashfn: hashfn,
             eqfn: eqfn,
             resize_at: resize_at(initial_capacity),
             size: 0,
-            buckets: vec::from_fn(initial_capacity, |_i| None)})
+            buckets: vec::from_fn(initial_capacity, |_i| None)
+        }
     }
 
     priv impl<K, V> LinearMap<K,V> {
@@ -136,15 +156,19 @@ mod linear {
             for uint::range(0, old_capacity) |i| {
                 let mut bucket = None;
                 bucket <-> old_buckets[i];
-                if bucket.is_some() {
-                    self.insert_bucket(bucket);
-                }
+                self.insert_opt_bucket(bucket);
             }
         }
 
-        fn insert_bucket(&mut self, +bucket: Option<Bucket<K,V>>) {
-            let {hash, key, value} <- option::unwrap(bucket);
-            let _ = self.insert_internal(hash, key, value);
+        fn insert_opt_bucket(&mut self, +bucket: Option<Bucket<K,V>>) {
+            match move bucket {
+              Some(Bucket {hash: move hash,
+                           key: move key,
+                           value: move value}) => {
+                self.insert_internal(hash, key, value);
+              }
+              None => {}
+            }
         }
 
         /// Inserts the key value pair into the buckets.
@@ -156,14 +180,18 @@ mod linear {
               FoundHole(idx) => {
                 debug!("insert fresh (%?->%?) at idx %?, hash %?",
                        k, v, idx, hash);
-                self.buckets[idx] = Some({hash: hash, key: k, value: v});
+                self.buckets[idx] = Some(Bucket {hash: hash,
+                                                 key: k,
+                                                 value: v});
                 self.size += 1;
                 return true;
               }
               FoundEntry(idx) => {
                 debug!("insert overwrite (%?->%?) at idx %?, hash %?",
                        k, v, idx, hash);
-                self.buckets[idx] = Some({hash: hash, key: k, value: v});
+                self.buckets[idx] = Some(Bucket {hash: hash,
+                                                 key: k,
+                                                 value: v});
                 return false;
               }
             }
@@ -223,7 +251,7 @@ mod linear {
             while self.buckets[idx].is_some() {
                 let mut bucket = None;
                 bucket <-> self.buckets[idx];
-                self.insert_bucket(bucket);
+                self.insert_opt_bucket(bucket);
                 idx = self.next_bucket(idx, len_buckets);
             }
             self.size -= 1;