From cf4127f503b58823a7cd287ddebeb6f0f3de5794 Mon Sep 17 00:00:00 2001 From: blake2-ppc Date: Tue, 16 Jul 2013 03:55:52 +0200 Subject: [PATCH 1/2] hashmap: Remove .mutate_values() which is replaced by .mut_iter() --- src/libstd/hashmap.rs | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index 3b3b71d7297..0131c3b540a 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -510,19 +510,6 @@ impl HashMap { self.iter().advance(|(_, v)| blk(v)) } - /// Iterate over the map and mutate the contained values - pub fn mutate_values(&mut self, blk: &fn(&K, &mut V) -> bool) -> bool { - for uint::range(0, self.buckets.len()) |i| { - match self.buckets[i] { - Some(Bucket{key: ref key, value: ref mut value, _}) => { - if !blk(key, value) { return false; } - } - None => () - } - } - return true; - } - /// An iterator visiting all key-value pairs in arbitrary order. /// Iterator element type is (&'a K, &'a V). pub fn iter<'a>(&'a self) -> HashMapIterator<'a, K, V> { From 750f32dbb5d550959d356821d757c03524367219 Mon Sep 17 00:00:00 2001 From: blake2-ppc Date: Tue, 16 Jul 2013 03:55:52 +0200 Subject: [PATCH 2/2] hashmap: Iterators for hashset diff, sym. diff, intersec, union Implement the difference, union, etc iterators with the help of a custom iterator combinator with explicit closure environment. Reported issue #7814 to be able to use the std::iterator filter combinator. --- src/libstd/hashmap.rs | 80 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 70 insertions(+), 10 deletions(-) diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index 0131c3b540a..79c6c4fb21d 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -16,9 +16,10 @@ #[mutable_doc]; use container::{Container, Mutable, Map, MutableMap, Set, MutableSet}; +use clone::Clone; use cmp::{Eq, Equiv}; use hash::Hash; -use iterator::{Iterator, IteratorUtil, FromIterator}; +use iterator::{Iterator, IteratorUtil, FromIterator, ChainIterator}; use num; use option::{None, Option, Some}; use rand::RngUtil; @@ -703,25 +704,24 @@ impl Set for HashSet { /// Visit the values representing the difference fn difference(&self, other: &HashSet, f: &fn(&T) -> bool) -> bool { - self.iter().advance(|v| other.contains(v) || f(v)) + self.difference_iter(other).advance(f) } /// Visit the values representing the symmetric difference fn symmetric_difference(&self, other: &HashSet, f: &fn(&T) -> bool) -> bool { - self.difference(other, |t| f(t)) && other.difference(self, |t| f(t)) + self.symmetric_difference_iter(other).advance(f) } /// Visit the values representing the intersection fn intersection(&self, other: &HashSet, f: &fn(&T) -> bool) -> bool { - self.iter().advance(|v| !other.contains(v) || f(v)) + self.intersection_iter(other).advance(f) } /// Visit the values representing the union fn union(&self, other: &HashSet, f: &fn(&T) -> bool) -> bool { - self.iter().advance(|t| f(t)) && - other.iter().advance(|v| self.contains(v) || f(v)) + self.union_iter(other).advance(f) } } @@ -776,6 +776,33 @@ impl HashSet { pub fn iter<'a>(&'a self) -> HashSetIterator<'a, T> { HashSetIterator { iter: self.map.buckets.iter() } } + + /// Visit the values representing the difference + pub fn difference_iter<'a>(&'a self, other: &'a HashSet) + -> SetAlgebraIter<'a, T> { + EnvFilterIterator{iter: self.iter(), env: other, + filter: |elt, other| !other.contains(elt) } + } + + /// Visit the values representing the symmetric difference + pub fn symmetric_difference_iter<'a>(&'a self, other: &'a HashSet) + -> ChainIterator<&'a T, SetAlgebraIter<'a, T>, SetAlgebraIter<'a, T>> { + self.difference_iter(other).chain_(other.difference_iter(self)) + } + + /// Visit the values representing the intersection + pub fn intersection_iter<'a>(&'a self, other: &'a HashSet) + -> SetAlgebraIter<'a, T> { + EnvFilterIterator{iter: self.iter(), env: other, + filter: |elt, other| other.contains(elt) } + } + + /// Visit the values representing the union + pub fn union_iter<'a>(&'a self, other: &'a HashSet) + -> ChainIterator<&'a T, HashSetIterator<'a, T>, SetAlgebraIter<'a, T>> { + self.iter().chain_(other.difference_iter(self)) + } + } impl> FromIterator for HashSet { @@ -791,6 +818,39 @@ impl> FromIterator for HashSet { } } +// FIXME #7814: use std::iterator::FilterIterator +/// Building block for Set operation iterators +pub struct EnvFilterIterator { + priv env: Env, + priv filter: &'static fn(&A, Env) -> bool, + priv iter: I, +} + +impl<'self, A, Env: Clone, I: Iterator<&'self A>> Iterator<&'self A> + for EnvFilterIterator { + #[inline] + fn next(&mut self) -> Option<&'self A> { + loop { + match self.iter.next() { + Some(elt) => if (self.filter)(elt, self.env.clone()) { + return Some(elt) + }, + None => return None, + } + } + } + + #[inline] + fn size_hint(&self) -> (uint, Option) { + let (_, upper) = self.iter.size_hint(); + (0, upper) + } +} + +/// Set operations iterator +pub type SetAlgebraIter<'self, T> = + EnvFilterIterator, HashSetIterator<'self, T>>; + #[cfg(test)] mod test_map { @@ -1126,7 +1186,7 @@ mod test_set { let mut i = 0; let expected = [3, 5, 11, 77]; - for a.intersection(&b) |x| { + for a.intersection_iter(&b).advance |x| { assert!(expected.contains(x)); i += 1 } @@ -1149,7 +1209,7 @@ mod test_set { let mut i = 0; let expected = [1, 5, 11]; - for a.difference(&b) |x| { + for a.difference_iter(&b).advance |x| { assert!(expected.contains(x)); i += 1 } @@ -1175,7 +1235,7 @@ mod test_set { let mut i = 0; let expected = [-2, 1, 5, 11, 14, 22]; - for a.symmetric_difference(&b) |x| { + for a.symmetric_difference_iter(&b).advance |x| { assert!(expected.contains(x)); i += 1 } @@ -1205,7 +1265,7 @@ mod test_set { let mut i = 0; let expected = [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]; - for a.union(&b) |x| { + for a.union_iter(&b).advance |x| { assert!(expected.contains(x)); i += 1 }