diff --git a/src/libextra/json.rs b/src/libextra/json.rs index 8c5af33cc38a99bdb7628089e5a80f55705465e0..5602964245f37a357b7b88eff6a781105c098b0c 100644 --- a/src/libextra/json.rs +++ b/src/libextra/json.rs @@ -1086,9 +1086,8 @@ fn read_map(&mut self, f: &fn(&mut Decoder, uint) -> T) -> T { 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 6a6f6ed62474e49b4181af222630643359726761..de2125c2e0ebe4604e09bcc46cb487fa182a973f 100644 --- a/src/librustc/rustc.rs +++ b/src/librustc/rustc.rs @@ -154,7 +154,7 @@ pub fn describe_warnings() { ")); 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 e3a32801ca90696312f4294192bc1a8790466539..276ad74e1d3a98fec37dd7a73952072d47028471 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 @@ fn main() { 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 @@ pub fn set_cache(&self) { /// 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 @@ pub fn register_new_vars(&mut self, blk: &ast::blk, tcx: ty::ctxt) { } // 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 7cf2c594202eb1c51fbb46544b4e0d52cddfe2b5..068db8805e8da5604012f740201ac14c2b3381af 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -438,31 +438,6 @@ pub fn insert_or_update_with<'a>(&'a mut self, k: K, v: V, 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 @@ pub fn iter<'a>(&'a self) -> HashMapIterator<'a, K, V> { 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 @@ pub fn reserve_at_least(&mut self, n: uint) { 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 @@ pub fn iter<'a>(&'a self) -> HashSetIterator<'a, T> { 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 @@ fn test_insert_or_update_with() { #[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 @@ fn test_consume_iter() { 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 @@ fn test_from_iter() { } #[test] - fn test_consume_iter() { + fn test_consume() { let hs = { let mut hs = HashSet::new(); @@ -1303,7 +1259,7 @@ fn test_consume_iter() { 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 7819fe00597556352b3b0e6232a715926a6f1a4f..f5dfa1feb9b1346922e9cfa49eaacc498676ed44 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 a6888460a3fc583651c0a4f72d9416bf8e187bcf..8a0d9bcead0fb1d27984ced1d5c8d0da6f9e16a6 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;