From 7ef9e722b8a499cd0b84ab175a366cbe536a86e4 Mon Sep 17 00:00:00 2001 From: blake2-ppc Date: Tue, 16 Jul 2013 16:39:24 +0200 Subject: [PATCH] hashmap: Remove .consume() has rename .consume_iter() to .consume() Updated all users of HashMap, HashSet old .consume() to use .consume() with a for loop. Since .consume() takes the map or set by value, it needs awkward extra code to in librusti's use of @mut HashMap, where the map value can not be directly moved out. --- src/libextra/json.rs | 3 +- src/librustc/rustc.rs | 2 +- src/librusti/program.rs | 10 ++-- src/libstd/hashmap.rs | 84 ++++++++------------------------ src/libstd/unstable/weak_task.rs | 2 +- src/test/bench/graph500-bfs.rs | 6 +-- 6 files changed, 33 insertions(+), 74 deletions(-) diff --git a/src/libextra/json.rs b/src/libextra/json.rs index 8c5af33cc38..5602964245f 100644 --- a/src/libextra/json.rs +++ b/src/libextra/json.rs @@ -1086,9 +1086,8 @@ impl serialize::Decoder for Decoder { debug!("read_map()"); let len = match self.stack.pop() { Object(obj) => { - let mut obj = obj; let len = obj.len(); - do obj.consume |key, value| { + for obj.consume().advance |(key, value)| { self.stack.push(value); self.stack.push(String(key)); } diff --git a/src/librustc/rustc.rs b/src/librustc/rustc.rs index 6a6f6ed6247..de2125c2e0e 100644 --- a/src/librustc/rustc.rs +++ b/src/librustc/rustc.rs @@ -154,7 +154,7 @@ Available lint options: ")); let lint_dict = lint::get_lint_dict(); - let mut lint_dict = lint_dict.consume_iter() + let mut lint_dict = lint_dict.consume() .transform(|(k, v)| (v, k)) .collect::<~[(lint::LintSpec, &'static str)]>(); lint_dict.qsort(); diff --git a/src/librusti/program.rs b/src/librusti/program.rs index e3a32801ca9..276ad74e1d3 100644 --- a/src/librusti/program.rs +++ b/src/librusti/program.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::cast; +use std::util; use std::hashmap::HashMap; use std::local_data; @@ -165,7 +166,8 @@ impl Program { None => {} } - do self.newvars.consume |name, var| { + let newvars = util::replace(&mut self.newvars, HashMap::new()); + for newvars.consume().advance |(name, var)| { self.local_vars.insert(name, var); } @@ -230,7 +232,8 @@ impl Program { /// it updates this cache with the new values of each local variable. pub fn consume_cache(&mut self) { let map = local_data::pop(tls_key).expect("tls is empty"); - do map.consume |name, value| { + let cons_map = util::replace(map, HashMap::new()); + for cons_map.consume().advance |(name, value)| { match self.local_vars.find_mut(&name) { Some(v) => { v.data = (*value).clone(); } None => { fail!("unknown variable %s", name) } @@ -341,7 +344,8 @@ impl Program { } // I'm not an @ pointer, so this has to be done outside. - do newvars.consume |k, v| { + let cons_newvars = util::replace(newvars, HashMap::new()); + for cons_newvars.consume().advance |(k, v)| { self.newvars.insert(k, v); } diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index 7cf2c594202..068db8805e8 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -438,31 +438,6 @@ impl HashMap { self.mangle(k, v, |_k,a| a, |k,v,_a| f(k,v)) } - /// Calls a function on each element of a hash map, destroying the hash - /// map in the process. - pub fn consume(&mut self, f: &fn(K, V)) { - let buckets = replace(&mut self.buckets, - vec::from_fn(INITIAL_CAPACITY, |_| None)); - self.size = 0; - - for buckets.consume_iter().advance |bucket| { - match bucket { - None => {}, - Some(Bucket{key, value, _}) => { - f(key, value) - } - } - } - } - - /// Creates a consuming iterator, that is, one that moves each key-value - /// pair out of the map in arbitrary order. The map cannot be used after - /// calling this. - pub fn consume_iter(self) -> HashMapConsumeIterator { - // `consume_rev_iter` is more efficient than `consume_iter` for vectors - HashMapConsumeIterator {iter: self.buckets.consume_rev_iter()} - } - /// Retrieves a value for the given key, failing if the key is not /// present. pub fn get<'a>(&'a self, k: &K) -> &'a V { @@ -522,6 +497,15 @@ impl HashMap { pub fn mut_iter<'a>(&'a mut self) -> HashMapMutIterator<'a, K, V> { HashMapMutIterator { iter: self.buckets.mut_iter() } } + + /// Creates a consuming iterator, that is, one that moves each key-value + /// pair out of the map in arbitrary order. The map cannot be used after + /// calling this. + pub fn consume(self) -> HashMapConsumeIterator { + // `consume_rev_iter` is more efficient than `consume_iter` for vectors + HashMapConsumeIterator {iter: self.buckets.consume_rev_iter()} + } + } impl HashMap { @@ -761,19 +745,6 @@ impl HashSet { self.map.reserve_at_least(n) } - /// Consumes all of the elements in the set, emptying it out - pub fn consume(&mut self, f: &fn(T)) { - self.map.consume(|k, _| f(k)) - } - - /// Creates a consuming iterator, that is, one that moves each value out - /// of the set in arbitrary order. The set cannot be used after calling - /// this. - pub fn consume_iter(self) -> HashSetConsumeIterator { - // `consume_rev_iter` is more efficient than `consume_iter` for vectors - HashSetConsumeIterator {iter: self.map.buckets.consume_rev_iter()} - } - /// Returns true if the hash set contains a value equivalent to the /// given query value. pub fn contains_equiv>(&self, value: &Q) -> bool { @@ -786,6 +757,14 @@ impl HashSet { HashSetIterator { iter: self.map.buckets.iter() } } + /// Creates a consuming iterator, that is, one that moves each value out + /// of the set in arbitrary order. The set cannot be used after calling + /// this. + pub fn consume(self) -> HashSetConsumeIterator { + // `consume_rev_iter` is more efficient than `consume_iter` for vectors + HashSetConsumeIterator {iter: self.map.buckets.consume_rev_iter()} + } + /// Visit the values representing the difference pub fn difference_iter<'a>(&'a self, other: &'a HashSet) -> SetAlgebraIter<'a, T> { @@ -975,29 +954,6 @@ mod test_map { #[test] fn test_consume() { - let mut m = HashMap::new(); - assert!(m.insert(1, 2)); - assert!(m.insert(2, 3)); - let mut m2 = HashMap::new(); - do m.consume |k, v| { - m2.insert(k, v); - } - assert_eq!(m.len(), 0); - assert_eq!(m2.len(), 2); - assert_eq!(m2.get(&1), &2); - assert_eq!(m2.get(&2), &3); - } - - #[test] - fn test_consume_still_usable() { - let mut m = HashMap::new(); - assert!(m.insert(1, 2)); - do m.consume |_, _| {} - assert!(m.insert(1, 2)); - } - - #[test] - fn test_consume_iter() { let hm = { let mut hm = HashMap::new(); @@ -1007,7 +963,7 @@ mod test_map { hm }; - let v = hm.consume_iter().collect::<~[(char, int)]>(); + let v = hm.consume().collect::<~[(char, int)]>(); assert!([('a', 1), ('b', 2)] == v || [('b', 2), ('a', 1)] == v); } @@ -1293,7 +1249,7 @@ mod test_set { } #[test] - fn test_consume_iter() { + fn test_consume() { let hs = { let mut hs = HashSet::new(); @@ -1303,7 +1259,7 @@ mod test_set { hs }; - let v = hs.consume_iter().collect::<~[char]>(); + let v = hs.consume().collect::<~[char]>(); assert!(['a', 'b'] == v || ['b', 'a'] == v); } } diff --git a/src/libstd/unstable/weak_task.rs b/src/libstd/unstable/weak_task.rs index 7819fe00597..f5dfa1feb9b 100644 --- a/src/libstd/unstable/weak_task.rs +++ b/src/libstd/unstable/weak_task.rs @@ -122,7 +122,7 @@ fn run_weak_task_service(port: Port) { } } - do shutdown_map.consume |_, shutdown_chan| { + for shutdown_map.consume().advance |(_, shutdown_chan)| { // Weak task may have already exited shutdown_chan.send(()); } diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index a6888460a3f..8a0d9bcead0 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -96,9 +96,9 @@ fn make_graph(N: uint, edges: ~[(node_id, node_id)]) -> graph { } } - do graph.consume_iter().transform |mut v| { + do graph.consume_iter().transform |v| { let mut vec = ~[]; - do v.consume |i| { + for v.consume().advance |i| { vec.push(i); } vec @@ -119,7 +119,7 @@ fn gen_search_keys(graph: &[~[node_id]], n: uint) -> ~[node_id] { } } let mut vec = ~[]; - do keys.consume |i| { + for keys.consume().advance |i| { vec.push(i); } return vec;