make most structures implement Send

Author: crepererum

src/countminsketch.rs

@@ -33,6 +33,20 @@ use crate::hash_utils::HashIterBuilder;
 /// assert_eq!(cms.query_point(&"another super long string"), 0);
 /// ```
 ///
+/// Note that the sketch is specific to `T`, so the following will not compile:
+///
+/// ```compile_fail
+/// use pdatastructs::countminsketch::CountMinSketch;
+///
+/// // set up filter
+/// let epsilon = 0.1;  // error threshold
+/// let delta = 0.2;  // epsilon is hit in (1 - 0.2) * 100% = 80%
+/// let mut cms1 = CountMinSketch::<u8, _>::with_point_query_properties(epsilon, delta);
+/// let cms2 = CountMinSketch::<i8, _>::with_point_query_properties(epsilon, delta);
+///
+/// cms1.merge(&cms2);
+/// ```
+///
 /// # Applications
 /// - when a lot of data is streamed in an approximative counter is good enough, e.g. for access
 ///   counts in network filters
@@ -119,7 +133,7 @@ where
     w: usize,
     d: usize,
     builder: HashIterBuilder<B>,
-    phantom: PhantomData<T>,
+    phantom: PhantomData<fn() -> T>,
 }
 
 impl<T, C> CountMinSketch<T, C>
@@ -307,7 +321,10 @@ where
 #[cfg(test)]
 mod tests {
     use super::CountMinSketch;
-    use crate::hash_utils::BuildHasherSeeded;
+    use crate::{
+        hash_utils::BuildHasherSeeded,
+        test_util::{assert_send, NotSend},
+    };
 
     #[test]
     fn getter() {
@@ -495,4 +512,10 @@ mod tests {
         assert_eq!(cms.query_point(&1), 2);
         assert_eq!(cms.query_point(&2), 0);
     }
+
+    #[test]
+    fn send() {
+        let cms = CountMinSketch::<NotSend>::with_params(10, 10);
+        assert_send(&cms);
+    }
 }

src/filters/bloomfilter.rs

@@ -32,6 +32,20 @@ use crate::hash_utils::HashIterBuilder;
 /// assert!(!filter.query(&"another super long string"));
 /// ```
 ///
+/// Note that the filter is specific to `T`, so the following will not compile:
+///
+/// ```compile_fail
+/// use pdatastructs::filters::Filter;
+/// use pdatastructs::filters::bloomfilter::BloomFilter;
+///
+/// let false_positive_rate = 0.02;  // = 2%
+/// let expected_elements = 1000;
+/// let mut filter1 = BloomFilter::<u8>::with_properties(expected_elements, false_positive_rate);
+/// let filter2 = BloomFilter::<i8>::with_properties(expected_elements, false_positive_rate);
+///
+/// filter1.union(&filter2);
+/// ```
+///
 /// # Applications
 /// - when a lot of data should be added to the set and a moderate false positive rate is
 ///   acceptable, was used for spell checking
@@ -149,7 +163,7 @@ where
     bs: FixedBitSet,
     k: usize,
     builder: HashIterBuilder<B>,
-    phantom: PhantomData<T>,
+    phantom: PhantomData<fn() -> T>,
 }
 
 impl<T> BloomFilter<T>
@@ -326,6 +340,7 @@ mod tests {
 
     use crate::filters::Filter;
     use crate::hash_utils::BuildHasherSeeded;
+    use crate::test_util::{assert_send, NotSend};
 
     #[test]
     fn getter() {
@@ -508,4 +523,10 @@ mod tests {
         assert!(bf.query("test1"));
         assert!(!bf.query("test2"));
     }
+
+    #[test]
+    fn send() {
+        let bf = BloomFilter::<NotSend>::with_params(100, 2);
+        assert_send(&bf);
+    }
 }

src/filters/cuckoofilter.rs

@@ -42,6 +42,24 @@ pub struct CuckooFilterFull;
 /// assert!(!filter.query(&"another super long string"));
 /// ```
 ///
+/// Note that the filter is specific to `T`, so the following will not compile:
+///
+/// ```compile_fail
+/// use pdatastructs::filters::Filter;
+/// use pdatastructs::filters::cuckoofilter::CuckooFilter;
+/// use pdatastructs::rand::SeedableRng;
+/// use rand_chacha::ChaChaRng;
+///
+/// // set up filter
+/// let false_positive_rate = 0.02;  // = 2%
+/// let expected_elements = 1000;
+/// let rng = ChaChaRng::from_seed([0; 32]);
+/// let mut filter1 = CuckooFilter::<u8, _>::with_properties_8(false_positive_rate, expected_elements, rng);
+/// let filter2 = CuckooFilter::<i8, _>::with_properties_8(false_positive_rate, expected_elements, rng);
+///
+/// filter1.union(&filter2);
+/// ```
+///
 /// # Applications
 /// Same as BloomFilter.
 ///
@@ -147,7 +165,7 @@ where
     n_buckets: usize,
     l_fingerprint: usize,
     rng: R,
-    phantom: PhantomData<T>,
+    phantom: PhantomData<fn() -> T>,
 }
 
 impl<T, R> CuckooFilter<T, R>
@@ -581,7 +599,11 @@ where
 #[cfg(test)]
 mod tests {
     use super::CuckooFilter;
-    use crate::{filters::Filter, hash_utils::BuildHasherSeeded};
+    use crate::{
+        filters::Filter,
+        hash_utils::BuildHasherSeeded,
+        test_util::{assert_send, NotSend},
+    };
     use rand::SeedableRng;
     use rand_chacha::ChaChaRng;
 
@@ -921,4 +943,10 @@ mod tests {
         assert!(cf.query("test1"));
         assert!(!cf.query("test2"));
     }
+
+    #[test]
+    fn send() {
+        let cf = CuckooFilter::<NotSend, _>::with_params(ChaChaRng::from_seed([0; 32]), 2, 16, 8);
+        assert_send(&cf);
+    }
 }

src/filters/quotientfilter.rs

@@ -61,6 +61,21 @@ impl ScanResult {
 /// assert!(!filter.query(&"another super long string"));
 /// ```
 ///
+/// Note that the filter is specific to `T`, so the following will not compile:
+///
+/// ```compile_fail
+/// use pdatastructs::filters::Filter;
+/// use pdatastructs::filters::quotientfilter::QuotientFilter;
+///
+/// // set up filter
+/// let bits_quotient = 16;
+/// let bits_remainder = 5;
+/// let mut filter1 = QuotientFilter::<u8>::with_params(bits_quotient, bits_remainder);
+/// let filter2 = QuotientFilter::<i8>::with_params(bits_quotient, bits_remainder);
+///
+/// filter1.union(&filter2);
+/// ```
+///
 /// # Applications
 /// - when a lot of data should be added to the set and a moderate false positive rate is
 ///   acceptable, was used for spell checking
@@ -250,7 +265,7 @@ where
     bits_quotient: usize,
     buildhasher: B,
     n_elements: usize,
-    phantom: PhantomData<T>,
+    phantom: PhantomData<fn() -> T>,
 }
 
 impl<T> QuotientFilter<T>
@@ -615,6 +630,7 @@ mod tests {
     use super::QuotientFilter;
     use crate::filters::Filter;
     use crate::hash_utils::BuildHasherSeeded;
+    use crate::test_util::{assert_send, NotSend};
 
     #[test]
     #[should_panic(expected = "bits_quotient (0) must be greater than 0")]
@@ -828,4 +844,10 @@ mod tests {
         assert!(qf.query("test1"));
         assert!(!qf.query("test2"));
     }
+
+    #[test]
+    fn send() {
+        let qf = QuotientFilter::<NotSend>::with_params(3, 16);
+        assert_send(&qf);
+    }
 }

src/hyperloglog.rs

@@ -29,6 +29,19 @@ use crate::hyperloglog_data::{
 /// assert_eq!(hll.count(), 2);
 /// ```
 ///
+/// Note that the HyperLogLog is specific to `T`, so the following will not compile:
+///
+/// ```compile_fail
+/// use pdatastructs::hyperloglog::HyperLogLog;
+///
+/// // set up filter
+/// let address_bits = 4;  // so we store 2^4 = 16 registers in total
+/// let mut hll1 = HyperLogLog::<u8>::new(address_bits);
+/// let hll2 = HyperLogLog::<i8>::new(address_bits);
+///
+/// hll1.merge(&hll2);
+/// ```
+///
 /// # Applications
 /// - an approximative `COUNT(DISTINCT x)` in SQL
 /// - count distinct elements in a data stream
@@ -75,7 +88,7 @@ where
     registers: Vec<u8>,
     b: usize,
     buildhasher: B,
-    phantom: PhantomData<T>,
+    phantom: PhantomData<fn() -> T>,
 }
 
 impl<T> HyperLogLog<T>
@@ -351,6 +364,7 @@ mod tests {
     use super::HyperLogLog;
     use crate::hash_utils::BuildHasherSeeded;
     use crate::hyperloglog_data::{RAW_ESTIMATE_DATA_OFFSET, RAW_ESTIMATE_DATA_VEC};
+    use crate::test_util::{assert_send, NotSend};
 
     #[test]
     #[should_panic(expected = "b (3) must be larger or equal than 4 and smaller or equal than 18")]
@@ -691,4 +705,10 @@ mod tests {
             (Some(4), Some(4))
         );
     }
+
+    #[test]
+    fn send() {
+        let hll: HyperLogLog<NotSend> = HyperLogLog::new(4);
+        assert_send(&hll);
+    }
 }

src/lib.rs

@@ -31,3 +31,6 @@ mod hyperloglog_data;
 pub mod reservoirsampling;
 pub mod tdigest;
 pub mod topk;
+
+#[cfg(test)]
+mod test_util;

src/test_util.rs

@@ -0,0 +1,20 @@
+use std::hash::Hash;
+
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub(crate) struct NotSend {
+    _marker: *const u8,
+}
+
+impl Default for NotSend {
+    fn default() -> Self {
+        Self {
+            _marker: std::ptr::null(),
+        }
+    }
+}
+
+pub(crate) fn assert_send<T>(_: &T)
+where
+    T: Send,
+{
+}