Add more public functionality and unit tests for CollideMap and CollideSet

Refactor and simplify set operations

Author: skazemi

src/collidea.rs

@@ -25,8 +25,12 @@ impl<K: Hash, V> CollideMap<K, V> {
         }
     }
 
+    pub fn capacity(&self) -> usize {
+        self.inner.capacity()
+    }
+
     pub fn clear(&mut self) {
-        self.inner.clear();
+        self.inner.clear()
     }
 
     pub fn contains_key(&self, k: &K) -> bool {
@@ -45,6 +49,10 @@ impl<K: Hash, V> CollideMap<K, V> {
         self.inner.insert(get_hash_xxh(k), v)
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
     pub fn len(&self) -> usize {
         self.inner.len()
     }
@@ -53,6 +61,14 @@ impl<K: Hash, V> CollideMap<K, V> {
         self.inner.remove(&get_hash_xxh(k))
     }
 
+    pub fn reserve(&mut self, additional: usize) {
+        self.inner.reserve(additional)
+    }
+
+    pub fn shrink_to_fit(&mut self) {
+        self.inner.shrink_to_fit()
+    }
+
     pub fn values(&self) -> impl Iterator<Item = &V> {
         self.inner.values()
     }
@@ -76,8 +92,12 @@ impl<K: Hash> CollideSet<K> {
         }
     }
 
+    pub fn capacity(&self) -> usize {
+        self.inner.capacity()
+    }
+
     pub fn clear(&mut self) {
-        self.inner.clear();
+        self.inner.clear()
     }
 
     pub fn contains(&self, k: &K) -> bool {
@@ -88,6 +108,18 @@ impl<K: Hash> CollideSet<K> {
         self.inner.insert(get_hash_xxh(&k))
     }
 
+    pub fn is_disjoint(&self, other: &CollideSet<K>) -> bool {
+        self.inner.is_disjoint(&other.inner)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
+    pub fn is_subset(&self, other: &CollideSet<K>) -> bool {
+        self.inner.is_subset(&other.inner)
+    }
+
     pub fn len(&self) -> usize {
         self.inner.len()
     }
@@ -96,17 +128,35 @@ impl<K: Hash> CollideSet<K> {
         self.inner.remove(&get_hash_xxh(k))
     }
 
-    pub fn union(&self, other: &CollideSet<K>) -> CollideSet<K> {
-        let union_m = self.inner.union(&other.inner);
-        let mut union: CollideSet<K> = CollideSet::new();
-        union.inner = union_m.map(|k| k.clone()).collect();
-        union
+    pub fn reserve(&mut self, additional: usize) {
+        self.inner.reserve(additional)
+    }
+
+    pub fn difference(&self, other: &CollideSet<K>) -> CollideSet<K> {
+        let mut result: CollideSet<K> = CollideSet::new();
+        result.inner = self.inner.difference(&other.inner).cloned().collect();
+        result
+    }
+
+    pub fn symmetric_difference(&self, other: &CollideSet<K>) -> CollideSet<K> {
+        let mut result: CollideSet<K> = CollideSet::new();
+        result.inner = self
+            .inner
+            .symmetric_difference(&other.inner)
+            .cloned()
+            .collect();
+        result
     }
 
     pub fn intersection(&self, other: &CollideSet<K>) -> CollideSet<K> {
-        let intersection_m = self.inner.intersection(&other.inner);
-        let mut intersection: CollideSet<K> = CollideSet::new();
-        intersection.inner = intersection_m.map(|k| k.clone()).collect();
-        intersection
+        let mut result: CollideSet<K> = CollideSet::new();
+        result.inner = self.inner.intersection(&other.inner).cloned().collect();
+        result
+    }
+
+    pub fn union(&self, other: &CollideSet<K>) -> CollideSet<K> {
+        let mut result: CollideSet<K> = CollideSet::new();
+        result.inner = self.inner.union(&other.inner).cloned().collect();
+        result
     }
 }

tests/collidea_test.rs

@@ -61,7 +61,13 @@ fn collide_set_operator_test() {
     let intersection_b_a = set_b.intersection(&set_a);
     let union_a_b = set_a.union(&set_b);
     let union_b_a = set_b.union(&set_a);
+    let difference_a_b = set_a.difference(&set_b);
+    let difference_b_a = set_b.difference(&set_a);
+    let symmetric_difference_a_b = set_a.symmetric_difference(&set_b);
+    let symmetric_difference_b_a = set_b.symmetric_difference(&set_a);
 
+    assert_eq!(set_a.is_empty(), false);
+    assert_eq!(set_b.is_empty(), false);
     assert_eq!(union_a_b.len(), size);
     assert_eq!(union_b_a.len(), size);
     assert_eq!(intersection_a_b.len(), a_end - b_start);
@@ -81,5 +87,63 @@ fn collide_set_operator_test() {
             intersection_b_a.contains(&element),
             i >= b_start && i < a_end
         );
+        assert_eq!(difference_a_b.contains(&element), i < b_start);
+        assert_eq!(difference_b_a.contains(&element), i >= a_end);
+        assert_eq!(
+            difference_a_b.contains(&element) && difference_b_a.contains(&element),
+            false
+        );
+        assert_eq!(
+            symmetric_difference_a_b.contains(&element),
+            i < b_start || i >= a_end
+        );
+        assert_eq!(
+            symmetric_difference_a_b.contains(&element),
+            symmetric_difference_b_a.contains(&element)
+        );
+        assert_eq!(
+            intersection_a_b.contains(&element) ^ symmetric_difference_a_b.contains(&element),
+            true
+        );
     }
+
+    assert_eq!(
+        set_a.is_subset(&union_a_b) && set_b.is_subset(&union_a_b),
+        true
+    );
+    assert_eq!(
+        union_a_b.is_subset(&union_b_a) && union_b_a.is_subset(&union_a_b),
+        true
+    );
+    assert_eq!(
+        intersection_a_b.is_subset(&set_a) && intersection_a_b.is_subset(&set_b),
+        true
+    );
+    assert_eq!(
+        intersection_a_b.is_subset(&intersection_b_a)
+            && intersection_b_a.is_subset(&intersection_a_b),
+        true
+    );
+    assert_eq!(difference_a_b.is_subset(&set_a), true);
+    assert_eq!(difference_b_a.is_subset(&set_b), true);
+    assert_eq!(difference_a_b.is_subset(&symmetric_difference_a_b), true);
+    assert_eq!(difference_b_a.is_subset(&symmetric_difference_b_a), true);
+    assert_eq!(intersection_a_b.is_subset(&union_a_b), true);
+    assert_eq!(symmetric_difference_a_b.is_subset(&union_a_b), true);
+    assert_eq!(
+        symmetric_difference_a_b.is_subset(&symmetric_difference_b_a)
+            && symmetric_difference_b_a.is_subset(&symmetric_difference_a_b),
+        true
+    );
+    assert_eq!(
+        set_a.is_disjoint(&difference_b_a) && set_b.is_disjoint(&difference_a_b),
+        true
+    );
+    assert_eq!(
+        intersection_a_b.is_disjoint(&symmetric_difference_a_b),
+        true
+    );
+    assert_eq!(difference_a_b.is_disjoint(&difference_b_a), true);
+    assert_eq!(difference_a_b.is_disjoint(&intersection_a_b), true);
+    assert_eq!(difference_b_a.is_disjoint(&intersection_b_a), true);
 }