Merge pull request #61 from mlodato517/implement-keys-and-values-iterators

Adds keys and values iterators

Author: jonhoo

src/read/read_ref.rs

@@ -35,7 +35,27 @@ where
     /// refresh will block waiting on this reader to finish.
     pub fn iter(&self) -> ReadGuardIter<'_, K, V, S> {
         ReadGuardIter {
-            iter: Some(self.guard.data.iter()),
+            iter: self.guard.data.iter(),
+        }
+    }
+
+    /// Iterate over all keys in the map.
+    ///
+    /// Be careful with this function! While the iteration is ongoing, any writer that tries to
+    /// refresh will block waiting on this reader to finish.
+    pub fn keys(&self) -> KeysIter<'_, K, V, S> {
+        KeysIter {
+            iter: self.guard.data.iter(),
+        }
+    }
+
+    /// Iterate over all value sets in the map.
+    ///
+    /// Be careful with this function! While the iteration is ongoing, any writer that tries to
+    /// refresh will block waiting on this reader to finish.
+    pub fn values(&self) -> ValuesIter<'_, K, V, S> {
+        ValuesIter {
+            iter: self.guard.data.iter(),
         }
     }
 
@@ -157,9 +177,7 @@ where
     V: Eq + Hash,
     S: BuildHasher,
 {
-    iter: Option<
-        <&'rg crate::inner::MapImpl<K, Values<ManuallyDrop<V>, S>, S> as IntoIterator>::IntoIter,
-    >,
+    iter: <&'rg crate::inner::MapImpl<K, Values<ManuallyDrop<V>, S>, S> as IntoIterator>::IntoIter,
 }
 
 impl<'rg, K, V, S> Iterator for ReadGuardIter<'rg, K, V, S>
@@ -170,8 +188,52 @@ where
 {
     type Item = (&'rg K, &'rg Values<V, S>);
     fn next(&mut self) -> Option<Self::Item> {
-        self.iter
-            .as_mut()
-            .and_then(|iter| iter.next().map(|(k, v)| (k, v.user_friendly())))
+        self.iter.next().map(|(k, v)| (k, v.user_friendly()))
+    }
+}
+
+/// An [`Iterator`] over keys.
+#[derive(Debug)]
+pub struct KeysIter<'rg, K, V, S>
+where
+    K: Eq + Hash,
+    V: Eq + Hash,
+    S: BuildHasher,
+{
+    iter: <&'rg crate::inner::MapImpl<K, Values<ManuallyDrop<V>, S>, S> as IntoIterator>::IntoIter,
+}
+
+impl<'rg, K, V, S> Iterator for KeysIter<'rg, K, V, S>
+where
+    K: Eq + Hash,
+    V: Eq + Hash,
+    S: BuildHasher,
+{
+    type Item = &'rg K;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next().map(|(k, _)| k)
+    }
+}
+
+/// An [`Iterator`] over value sets.
+#[derive(Debug)]
+pub struct ValuesIter<'rg, K, V, S>
+where
+    K: Eq + Hash,
+    V: Eq + Hash,
+    S: BuildHasher,
+{
+    iter: <&'rg crate::inner::MapImpl<K, Values<ManuallyDrop<V>, S>, S> as IntoIterator>::IntoIter,
+}
+
+impl<'rg, K, V, S> Iterator for ValuesIter<'rg, K, V, S>
+where
+    K: Eq + Hash,
+    V: Eq + Hash,
+    S: BuildHasher,
+{
+    type Item = &'rg Values<V, S>;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next().map(|(_, v)| v.user_friendly())
     }
 }

tests/lib.rs

@@ -593,6 +593,45 @@ fn map_into() {
     assert!(copy[&2].contains(&"c"));
 }
 
+#[test]
+fn keys() {
+    let (r, mut w) = evmap::new();
+    w.insert(1, "a");
+    w.insert(1, "b");
+    w.insert(2, "c");
+    w.refresh();
+    w.insert(1, "x");
+
+    let mut keys = r.read().unwrap().keys().copied().collect::<Vec<_>>();
+    keys.sort();
+
+    assert_eq!(keys, vec![1, 2]);
+}
+
+#[test]
+fn values() {
+    let (r, mut w) = evmap::new();
+    w.insert(1, "a");
+    w.insert(1, "b");
+    w.insert(2, "c");
+    w.refresh();
+    w.insert(1, "x");
+
+    let mut values = r
+        .read()
+        .unwrap()
+        .values()
+        .map(|value_bag| {
+            let mut inner_items = value_bag.iter().copied().collect::<Vec<_>>();
+            inner_items.sort();
+            inner_items
+        })
+        .collect::<Vec<Vec<_>>>();
+    values.sort_by_key(|value_vec| value_vec.len());
+
+    assert_eq!(values, vec![vec!["c"], vec!["a", "b"]]);
+}
+
 #[test]
 #[cfg_attr(miri, ignore)]
 fn clone_churn() {

tests/quick.rs

@@ -62,7 +62,7 @@ fn insert_empty(insert: Vec<u8>, remove: Vec<u8>) -> bool {
     w.refresh();
     let elements = &set(&insert) - &set(&remove);
     r.len() == elements.len()
-        && r.map_into::<_, Vec<()>, _>(|_, _| ()).len() == elements.len()
+        && r.read().iter().map(|r| r.keys()).flatten().count() == elements.len()
         && elements.iter().all(|k| r.get(k).is_some())
 }
 
@@ -137,14 +137,13 @@ where
     S: BuildHasher,
 {
     assert_eq!(a.len(), b.len());
-    let keys = a.map_into::<_, Vec<K>, _>(|k, _| k.clone());
-    for key in &keys {
+    for key in a.read().iter().map(|r| r.keys()).flatten() {
         assert!(b.contains_key(key), "b does not contain {:?}", key);
     }
     for key in b.keys() {
         assert!(a.get(key).is_some(), "a does not contain {:?}", key);
     }
-    for key in &keys {
+    for key in a.read().iter().map(|r| r.keys()).flatten() {
         let mut ev_map_values: Vec<V> = a.get(key).unwrap().iter().copied().collect();
         ev_map_values.sort();
         let mut map_values = b[key].clone();
@@ -230,3 +229,36 @@ fn operations_string(ops: Vec<Op<Alphabet, i8>>) -> bool {
     w.refresh();
     assert_maps_equivalent(&r, &write_ref)
 }
+
+#[quickcheck]
+fn keys_values(ops: Large<Vec<Op<i8, i8>>>) -> bool {
+    let (r, mut w) = evmap::new();
+    let mut write_ref = HashMap::new();
+    let mut read_ref = HashMap::new();
+    do_ops(&ops, &mut w, &mut write_ref, &mut read_ref);
+
+    if let Some(read_guard) = r.read() {
+        let (r_visit, mut w_visit) = evmap::new();
+        for (k, v_set) in read_guard.keys().zip(read_guard.values()) {
+            assert!(read_guard[k].iter().all(|v| v_set.contains(v)));
+            assert!(v_set.iter().all(|v| read_guard[k].contains(v)));
+
+            assert!(!r_visit.contains_key(k));
+
+            // If the value set is empty, we still need to add the key.
+            // But we need to add the key with an empty value bag.
+            // Just add something and then remove the value, but leave the bag.
+            if v_set.is_empty() {
+                w_visit.insert(*k, 0);
+                w_visit.remove_value(*k, 0);
+            } else {
+                for value in v_set {
+                    w_visit.insert(*k, *value);
+                }
+            }
+            w_visit.refresh();
+        }
+        assert_eq!(r_visit.len(), read_ref.len());
+    }
+    true
+}