This is an automated email from the ASF dual-hosted git repository.

tisonkun pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datasketches-rust.git


The following commit(s) were added to refs/heads/main by this push:
     new 9de0bbe  refactor(bloom,xor): accept hash inputs by value across 
filters (#349)
9de0bbe is described below

commit 9de0bbe9081014114fbd3dcb801d56b42370e947
Author: tison <[email protected]>
AuthorDate: Thu Nov 12 07:32:42 2026 +0800

    refactor(bloom,xor): accept hash inputs by value across filters (#349)
---
 CHANGELOG.md                                 |  1 +
 benchmarks/bloom/update.rs                   |  2 +-
 datasketches/examples/bloom_difference.rs    |  4 +-
 datasketches/src/bloom/mod.rs                | 12 ++---
 datasketches/src/bloom/sketch.rs             | 32 +++++------
 datasketches/src/xor/filter.rs               |  8 +--
 tests-integration/tests/bloom_test/sketch.rs | 76 +++++++++++++++++++-------
 tests-integration/tests/serde_tests/bloom.rs |  6 +--
 tests-integration/tests/serde_tests/xor.rs   | 12 ++---
 tests-integration/tests/xor_test/filter.rs   | 79 ++++++++++++++++++++++++----
 10 files changed, 167 insertions(+), 65 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 73afc88..95d631a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@ All significant changes to this project will be documented in 
this file.
 
 ### Breaking changes
 
+* `BloomFilter::contains` and `BloomFilter::contains_and_insert` now take 
`item: T` (`T: Hash`) by value instead of `&T`, matching `BloomFilter::insert`. 
Pass `&item` to retain owned values such as `String` or `Vec<u8>` without 
cloning, and remove explicit turbofish type arguments (or change `T` to `&T`) 
on borrowed calls such as `contains::<u64>(&value)`.
 * `CountMinSketch::new` and `CountMinSketch::with_seed` now create serial 
version 2 sketches, require `num_hashes` in `1..=127`, and emit images that 
require a version 2 reader. Version 2 enables cross-language interchange when 
using `i64` counters and the documented input encodings, while existing version 
1 images remain readable, updatable, and serializable as version 1. 
`CountMinSketch::merge` rejects mixing version 1 and version 2 sketches; 
upgrade readers before writers and rebuild  [...]
 * `CpcSketch::max_serialized_bytes` and `ReqSketch::serialized_size_bytes` are 
removed; serialize the sketch and inspect `len()` on the returned byte buffer 
when the encoded size is needed.
 
diff --git a/benchmarks/bloom/update.rs b/benchmarks/bloom/update.rs
index a71a86a..b6212ae 100644
--- a/benchmarks/bloom/update.rs
+++ b/benchmarks/bloom/update.rs
@@ -62,7 +62,7 @@ fn contains_and_insert_present_u64(bencher: Bencher) {
     bencher.bench_local(|| {
         let mut filter = populated.clone();
         for value in 0..ITEMS as u64 {
-            black_box(filter.contains_and_insert(black_box(&value)));
+            black_box(filter.contains_and_insert(black_box(value)));
         }
         filter
     });
diff --git a/datasketches/examples/bloom_difference.rs 
b/datasketches/examples/bloom_difference.rs
index ad8d375..9d5e99a 100644
--- a/datasketches/examples/bloom_difference.rs
+++ b/datasketches/examples/bloom_difference.rs
@@ -61,7 +61,7 @@ fn main() {
 
     // The guarantee that matters for takedowns: a purged object is never 
served again.
     for object in purged_objects() {
-        assert!(!cached.contains(&object));
+        assert!(!cached.contains(object));
     }
 
     // Count how many still-valid objects survived; dropped ones cost an 
origin refetch,
@@ -69,7 +69,7 @@ fn main() {
     let valid = CACHED_OBJECTS - purged_objects().count() as u64;
     let mut retained = 0_u64;
     for object in (0..CACHED_OBJECTS).filter(|object| object % 200 != 0) {
-        if cached.contains(&object) {
+        if cached.contains(object) {
             retained += 1;
         }
     }
diff --git a/datasketches/src/bloom/mod.rs b/datasketches/src/bloom/mod.rs
index e5d6765..90f23ed 100644
--- a/datasketches/src/bloom/mod.rs
+++ b/datasketches/src/bloom/mod.rs
@@ -62,8 +62,8 @@
 //! filter.insert(42_u64);
 //!
 //! // Check membership
-//! assert!(filter.contains(&"apple")); // true - possibly present (and known 
to be inserted here)
-//! assert!(!filter.contains(&"grape")); // false - definitely not present
+//! assert!(filter.contains("apple")); // true - possibly present (and known 
to be inserted here)
+//! assert!(!filter.contains("grape")); // false - definitely not present
 //!
 //! // Get statistics
 //! println!("Capacity: {} bits", filter.capacity());
@@ -137,16 +137,16 @@
 //!
 //! // Union: recognizes items from either filter
 //! filter1.union(&filter2).unwrap();
-//! assert!(filter1.contains(&"a"));
-//! assert!(filter1.contains(&"b"));
+//! assert!(filter1.contains("a"));
+//! assert!(filter1.contains("b"));
 //!
 //! // Intersect: recognizes only items in both filters
 //! // filter1.intersect(&filter2).unwrap();
 //!
 //! // Difference: recognizes items in filter1 that are definitely not in 
filter2
 //! filter1.difference(&filter2).unwrap();
-//! assert!(filter1.contains(&"a"));
-//! assert!(!filter1.contains(&"b"));
+//! assert!(filter1.contains("a"));
+//! assert!(!filter1.contains("b"));
 //! ```
 //!
 //! # Implementation Details
diff --git a/datasketches/src/bloom/sketch.rs b/datasketches/src/bloom/sketch.rs
index b6dfbe1..678801c 100644
--- a/datasketches/src/bloom/sketch.rs
+++ b/datasketches/src/bloom/sketch.rs
@@ -68,10 +68,10 @@ impl BloomFilter {
     ///     .unwrap();
     /// filter.insert("apple");
     ///
-    /// assert!(filter.contains(&"apple")); // true - possibly present (and 
known to be inserted here)
-    /// assert!(!filter.contains(&"grape")); // false - definitely not present
+    /// assert!(filter.contains("apple")); // true - possibly present (and 
known to be inserted here)
+    /// assert!(!filter.contains("grape")); // false - definitely not present
     /// ```
-    pub fn contains<T: Hash>(&self, item: &T) -> bool {
+    pub fn contains<T: Hash>(&self, item: T) -> bool {
         if self.is_empty() {
             return false;
         }
@@ -93,13 +93,13 @@ impl BloomFilter {
     ///     .build()
     ///     .unwrap();
     ///
-    /// let was_present = filter.contains_and_insert(&"apple");
+    /// let was_present = filter.contains_and_insert("apple");
     /// assert!(!was_present); // First insertion
     ///
-    /// let was_present = filter.contains_and_insert(&"apple");
+    /// let was_present = filter.contains_and_insert("apple");
     /// assert!(was_present); // Now it's in the set
     /// ```
-    pub fn contains_and_insert<T: Hash>(&mut self, item: &T) -> bool {
+    pub fn contains_and_insert<T: Hash>(&mut self, item: T) -> bool {
         let (h0, h1) = self.compute_hash(item);
         let mut were_all_set = true;
         for i in 1..=self.num_hashes {
@@ -135,10 +135,10 @@ impl BloomFilter {
     /// filter.insert(42_u64);
     /// filter.insert(&[1, 2, 3]);
     ///
-    /// assert!(filter.contains(&"apple"));
+    /// assert!(filter.contains("apple"));
     /// ```
     pub fn insert<T: Hash>(&mut self, item: T) {
-        let (h0, h1) = self.compute_hash(&item);
+        let (h0, h1) = self.compute_hash(item);
         for i in 1..=self.num_hashes {
             let bit_index = self.compute_bit_index(h0, h1, i);
             let word_index = bit_index >> 6;
@@ -169,7 +169,7 @@ impl BloomFilter {
     ///
     /// filter.reset();
     /// assert!(filter.is_empty());
-    /// assert!(!filter.contains(&"apple"));
+    /// assert!(!filter.contains("apple"));
     /// ```
     pub fn reset(&mut self) {
         self.bit_array.fill(0);
@@ -205,8 +205,8 @@ impl BloomFilter {
     /// f2.insert("b");
     ///
     /// f1.union(&f2).unwrap();
-    /// assert!(f1.contains(&"a"));
-    /// assert!(f1.contains(&"b"));
+    /// assert!(f1.contains("a"));
+    /// assert!(f1.contains("b"));
     /// ```
     pub fn union(&mut self, other: &BloomFilter) -> Result<(), Error> {
         if !self.is_compatible(other) {
@@ -255,7 +255,7 @@ impl BloomFilter {
     /// f2.insert("c");
     ///
     /// f1.intersect(&f2).unwrap();
-    /// assert!(f1.contains(&"b")); // In both
+    /// assert!(f1.contains("b")); // In both
     /// // "a" and "c" likely return false now
     /// ```
     pub fn intersect(&mut self, other: &BloomFilter) -> Result<(), Error> {
@@ -315,8 +315,8 @@ impl BloomFilter {
     /// right.insert("shared");
     ///
     /// left.difference(&right).unwrap();
-    /// assert!(left.contains(&"apple")); // Only in the left filter
-    /// assert!(!left.contains(&"shared")); // In both filters: excluded 
exactly
+    /// assert!(left.contains("apple")); // Only in the left filter
+    /// assert!(!left.contains("shared")); // In both filters: excluded exactly
     /// ```
     pub fn difference(&mut self, other: &BloomFilter) -> Result<(), Error> {
         if !self.is_compatible(other) {
@@ -423,7 +423,7 @@ impl BloomFilter {
     ///
     /// let bytes = filter.serialize();
     /// let restored = BloomFilter::deserialize(&bytes).unwrap();
-    /// assert!(restored.contains(&"test"));
+    /// assert!(restored.contains("test"));
     /// ```
     pub fn serialize(&self) -> Vec<u8> {
         let is_empty = self.is_empty();
@@ -598,7 +598,7 @@ impl BloomFilter {
     /// Uses a two-hash approach:
     /// * h0 = XXHash64(item, seed)
     /// * h1 = XXHash64(item, h0)
-    fn compute_hash<T: Hash>(&self, item: &T) -> (u64, u64) {
+    fn compute_hash<T: Hash>(&self, item: T) -> (u64, u64) {
         // First hash with the configured seed
         let mut hasher = XxHash64::with_seed(self.seed);
         item.hash(&mut hasher);
diff --git a/datasketches/src/xor/filter.rs b/datasketches/src/xor/filter.rs
index 53c270f..2122d06 100644
--- a/datasketches/src/xor/filter.rs
+++ b/datasketches/src/xor/filter.rs
@@ -117,7 +117,7 @@ impl XorFilterBuilder {
 
     /// Adds a value.
     #[inline]
-    pub fn update<T: Hash + ?Sized>(&mut self, item: &T) {
+    pub fn update<T: Hash>(&mut self, item: T) {
         self.update_hash(hash_item(item));
     }
 
@@ -129,7 +129,7 @@ impl XorFilterBuilder {
 
     /// Adds a batch of values.
     pub fn update_values<T: Hash>(&mut self, items: impl IntoIterator<Item = 
T>) {
-        self.update_hashes(items.into_iter().map(|item| hash_item(&item)));
+        self.update_hashes(items.into_iter().map(hash_item));
     }
 
     /// Adds a batch of precomputed 64-bit hashes.
@@ -272,7 +272,7 @@ impl XorFilter {
     /// A `false` result means the item was definitely absent; a `true` result 
may be a false
     /// positive.
     #[inline]
-    pub fn contains<T: Hash + ?Sized>(&self, item: &T) -> bool {
+    pub fn contains<T: Hash>(&self, item: T) -> bool {
         self.contains_hash(hash_item(item))
     }
 
@@ -461,7 +461,7 @@ impl XorFilter {
     }
 }
 
-fn hash_item<T: Hash + ?Sized>(item: &T) -> u64 {
+fn hash_item<T: Hash>(item: T) -> u64 {
     let mut hasher = XxHash64::with_seed(HASH_SEED);
     item.hash(&mut hasher);
     hasher.finish()
diff --git a/tests-integration/tests/bloom_test/sketch.rs 
b/tests-integration/tests/bloom_test/sketch.rs
index b6fe2c3..3db1292 100644
--- a/tests-integration/tests/bloom_test/sketch.rs
+++ b/tests-integration/tests/bloom_test/sketch.rs
@@ -18,6 +18,7 @@
 use datasketches::bloom::BloomFilter;
 use datasketches::bloom::BloomFilterBuilder;
 use datasketches::error::ErrorKind;
+use datasketches::hash::value::raw_bytes;
 use googletest::assert_that;
 use googletest::prelude::ge;
 use googletest::prelude::gt;
@@ -41,10 +42,10 @@ fn test_membership_statistics_and_reset() {
     assert_eq!(filter.num_hashes(), NUM_HASHES);
     assert_eq!(filter.seed(), SEED);
     assert!(filter.is_empty());
-    assert!(!filter.contains(&"apple"));
+    assert!(!filter.contains("apple"));
 
-    assert!(!filter.contains_and_insert(&"apple"));
-    assert!(filter.contains_and_insert(&"apple"));
+    assert!(!filter.contains_and_insert("apple"));
+    assert!(filter.contains_and_insert("apple"));
     assert_that!(filter.bits_used(), gt(0));
     assert_that!(filter.load_factor(), gt(0.0));
     assert_that!(filter.estimated_fpp(), gt(0.0));
@@ -52,7 +53,7 @@ fn test_membership_statistics_and_reset() {
     filter.reset();
     assert!(filter.is_empty());
     assert_eq!(filter.bits_used(), 0);
-    assert!(!filter.contains(&"apple"));
+    assert!(!filter.contains("apple"));
 }
 
 #[test]
@@ -61,14 +62,53 @@ fn test_insert_matches_membership_and_insert() {
     let mut checked = inserted.clone();
 
     for value in 0..128_u64 {
-        let was_present = inserted.contains(&value);
-        assert_eq!(checked.contains_and_insert(&value), was_present);
+        let was_present = inserted.contains(value);
+        assert_eq!(checked.contains_and_insert(value), was_present);
         inserted.insert(value);
-        assert!(inserted.contains(&value));
+        assert!(inserted.contains(value));
         assert_eq!(checked, inserted);
     }
 }
 
+#[test]
+fn test_equivalent_borrowed_and_owned_inputs_match() {
+    let owned_text = String::from("apple");
+    let owned_bytes = vec![1_u8, 2, 3, 4];
+    let ids = [7_u64, 11_u64];
+
+    let mut from_borrows = filter();
+    from_borrows.insert(&owned_text);
+    from_borrows.insert(&owned_bytes);
+    for id in &ids {
+        from_borrows.insert(id);
+    }
+    from_borrows.insert(raw_bytes::from_string(String::from("payload")));
+
+    let mut from_slices_and_values = filter();
+    assert!(!from_slices_and_values.contains_and_insert(owned_text.as_str()));
+    
assert!(!from_slices_and_values.contains_and_insert(owned_bytes.as_slice()));
+    for id in ids {
+        assert!(!from_slices_and_values.contains_and_insert(id));
+    }
+    
assert!(!from_slices_and_values.contains_and_insert(raw_bytes::from_str("payload")));
+
+    assert_eq!(from_borrows, from_slices_and_values);
+
+    assert!(from_borrows.contains(&owned_text));
+    assert!(from_borrows.contains(owned_text.as_str()));
+    assert!(from_borrows.contains(&owned_bytes));
+    assert!(from_borrows.contains(owned_bytes.as_slice()));
+    for id in &ids {
+        assert!(from_borrows.contains(id));
+        assert!(from_borrows.contains(*id));
+    }
+    assert!(from_borrows.contains(raw_bytes::from_slice(b"payload")));
+
+    assert!(from_slices_and_values.contains_and_insert(&owned_text));
+    assert!(from_slices_and_values.contains_and_insert(&owned_bytes));
+    assert_eq!(from_slices_and_values, from_borrows);
+}
+
 #[test]
 fn test_collisions_and_repeated_inserts_do_not_overcount_bits() {
     // Exercise one hash and force within-item collisions: 65 hashes cannot
@@ -79,13 +119,13 @@ fn 
test_collisions_and_repeated_inserts_do_not_overcount_bits() {
             .unwrap();
         let mut checked = inserted.clone();
         inserted.insert(42_u64);
-        assert!(!checked.contains_and_insert(&42_u64));
+        assert!(!checked.contains_and_insert(42_u64));
 
         for filter in [&mut inserted, &mut checked] {
             let before_repeat = filter.clone();
             filter.insert(42_u64);
             assert_eq!(*filter, before_repeat);
-            assert!(filter.contains_and_insert(&42_u64));
+            assert!(filter.contains_and_insert(42_u64));
             assert_eq!(*filter, before_repeat);
 
             // Recount the backing bits independently of either insertion path.
@@ -112,16 +152,16 @@ fn test_union_and_intersection() {
 
     let mut intersection = left.clone();
     intersection.intersect(&right).unwrap();
-    assert!(intersection.contains(&"shared"));
+    assert!(intersection.contains("shared"));
     let intersection_bits = intersection.bits_used();
     assert_that!(intersection_bits, le(left_bits));
     assert_that!(intersection_bits, le(right_bits));
 
     let mut union = left;
     union.union(&right).unwrap();
-    assert!(union.contains(&"shared"));
-    assert!(union.contains(&"left"));
-    assert!(union.contains(&"right"));
+    assert!(union.contains("shared"));
+    assert!(union.contains("left"));
+    assert!(union.contains("right"));
     assert_that!(union.bits_used(), ge(left_bits));
     assert_that!(union.bits_used(), ge(right_bits));
 }
@@ -143,7 +183,7 @@ fn test_difference_excludes_right_items_exactly() {
 
     // Items inserted into the right filter are excluded exactly.
     for i in 0..100_u64 {
-        assert!(!left.contains(&i));
+        assert!(!left.contains(i));
     }
     assert_that!(left.bits_used(), le(left_bits));
 
@@ -163,9 +203,9 @@ fn test_difference_keeps_disjoint_items() {
     right.insert("right");
 
     left.difference(&right).unwrap();
-    assert!(left.contains(&"left"));
-    assert!(!left.contains(&"shared"));
-    assert!(!left.contains(&"right"));
+    assert!(left.contains("left"));
+    assert!(!left.contains("shared"));
+    assert!(!left.contains("right"));
 }
 
 #[test]
@@ -178,7 +218,7 @@ fn test_difference_with_self_clears_filter() {
     left.difference(&same).unwrap();
     assert!(left.is_empty());
     assert_eq!(left.bits_used(), 0);
-    assert!(!left.contains(&"apple"));
+    assert!(!left.contains("apple"));
 }
 
 #[test]
diff --git a/tests-integration/tests/serde_tests/bloom.rs 
b/tests-integration/tests/serde_tests/bloom.rs
index a7bd340..fe35297 100644
--- a/tests-integration/tests/serde_tests/bloom.rs
+++ b/tests-integration/tests/serde_tests/bloom.rs
@@ -45,7 +45,7 @@ fn test_bloom_filter_file(path: PathBuf, expected_num_items: 
u64, expected_num_h
     // TCK fixtures insert integers 0..n/10. Bound the sample for large 
fixtures.
     for item in 0..(expected_num_items / 10).min(100) {
         assert!(
-            filter1.contains(&item),
+            filter1.contains(item),
             "Missing item {item} in {}",
             path.display()
         );
@@ -145,8 +145,8 @@ fn test_cached_num_bits_set_is_validated_or_recomputed() {
         .copy_from_slice(&u64::MAX.to_le_bytes());
     let restored = BloomFilter::deserialize(&dirty).unwrap();
     assert_eq!(restored.bits_used(), actual_bits_set);
-    assert!(restored.contains(&"apple"));
-    assert!(restored.contains(&"banana"));
+    assert!(restored.contains("apple"));
+    assert!(restored.contains("banana"));
 }
 
 #[test]
diff --git a/tests-integration/tests/serde_tests/xor.rs 
b/tests-integration/tests/serde_tests/xor.rs
index 684fcd5..6f99f3f 100644
--- a/tests-integration/tests/serde_tests/xor.rs
+++ b/tests-integration/tests/serde_tests/xor.rs
@@ -42,16 +42,16 @@ fn java_images_round_trip_byte_for_byte() {
     ] {
         let expected = decode_hex(image);
         let mut builder = XorFilterBuilder::new(ty, 42);
-        builder.update_values(values.iter());
+        builder.update_values(values);
         let built = builder.build().unwrap();
 
         let restored = XorFilter::deserialize(&expected).unwrap();
         assert_eq!(restored.serialize(), expected);
         assert_eq!(built.serialize(), expected);
         for value in values {
-            assert!(built.contains(&value));
+            assert!(built.contains(value));
             assert!(
-                restored.contains(&value),
+                restored.contains(value),
                 "{ty:?} image did not contain {value}"
             );
         }
@@ -183,7 +183,7 @@ fn java_utf8_and_raw_byte_inputs_match() {
     for (kind, image) in images {
         let mut builder = XorFilterBuilder::new(kind, 42);
         for bytes in [b"hello".as_slice(), "数据🔎".as_bytes(), &[], &[0, 1, 
255]] {
-            builder.update(&raw_bytes::from_slice(bytes));
+            builder.update(raw_bytes::from_slice(bytes));
         }
         let built = builder.build().unwrap();
         let expected = decode_hex(image);
@@ -191,8 +191,8 @@ fn java_utf8_and_raw_byte_inputs_match() {
         assert_eq!(restored.serialize(), expected);
         assert_eq!(built.serialize(), expected);
         for bytes in [b"hello".as_slice(), "数据🔎".as_bytes(), &[], &[0, 1, 
255]] {
-            assert!(built.contains(&raw_bytes::from_slice(bytes)));
-            assert!(restored.contains(&raw_bytes::from_slice(bytes)));
+            assert!(built.contains(raw_bytes::from_slice(bytes)));
+            assert!(restored.contains(raw_bytes::from_slice(bytes)));
         }
     }
 }
diff --git a/tests-integration/tests/xor_test/filter.rs 
b/tests-integration/tests/xor_test/filter.rs
index 780ac2d..67e9304 100644
--- a/tests-integration/tests/xor_test/filter.rs
+++ b/tests-integration/tests/xor_test/filter.rs
@@ -16,6 +16,7 @@
 // under the License.
 
 use datasketches::error::ErrorKind;
+use datasketches::hash::value::raw_bytes;
 use datasketches::xor::XorFilter;
 use datasketches::xor::XorFilterBuilder;
 use datasketches::xor::XorFilterType;
@@ -24,12 +25,12 @@ use datasketches::xor::XorFilterType;
 fn values_have_no_false_negatives() {
     let mut builder = XorFilterBuilder::new(XorFilterType::Xor8, 8123);
     for value in 0..10_000_u64 {
-        builder.update(&value);
+        builder.update(value);
     }
     let filter = builder.build().unwrap();
 
     for value in 0..10_000_u64 {
-        assert!(filter.contains(&value), "false negative for {value}");
+        assert!(filter.contains(value), "false negative for {value}");
     }
 }
 
@@ -58,22 +59,82 @@ fn builder_deduplicates_values_and_hashes() {
         XorFilterType::Xor16,
         XorFilterType::Xor32,
     ] {
-        let mut values = XorFilterBuilder::new(ty, 0);
+        let mut duplicate_values = XorFilterBuilder::new(ty, 0);
+        duplicate_values.update(7_u64);
+        duplicate_values.update_values([11_u64, 7, 11]);
+
+        let mut distinct_values = XorFilterBuilder::new(ty, 0);
+        distinct_values.update_values([11_u64, 7]);
+        assert_eq!(
+            duplicate_values.build().unwrap(),
+            distinct_values.build().unwrap(),
+        );
+
         let mut hashes = XorFilterBuilder::new(ty, 0);
-        values.update(&7_u64);
-        values.update_values([11_u64, 7, 11]);
         hashes.update_hash(7);
         hashes.update_hashes([11, 7, 11]);
-        let filter = values.build().unwrap();
-        assert!(filter.contains(&7_u64));
-        assert!(filter.contains(&11_u64));
         assert_eq!(
             hashes.build().unwrap(),
-            XorFilter::from_hashes(&[7, 11], ty, 0).unwrap()
+            XorFilter::from_hashes(&[7, 11], ty, 0).unwrap(),
         );
     }
 }
 
+#[test]
+fn equivalent_borrowed_and_value_inputs_build_identical_filters() {
+    let strings = [String::from("alpha"), String::from("beta")];
+    let blobs = [vec![0_u8, 1, 2], vec![3_u8, 4, 5]];
+    let ids = [7_u64, 11_u64];
+
+    for ty in [
+        XorFilterType::Xor8,
+        XorFilterType::Xor16,
+        XorFilterType::Xor32,
+    ] {
+        let mut by_str_update = XorFilterBuilder::new(ty, 0);
+        for s in &strings {
+            by_str_update.update(s);
+        }
+        let mut by_str_batch = XorFilterBuilder::new(ty, 0);
+        by_str_batch.update_values(strings.iter().map(String::as_str));
+        let str_filter = by_str_update.build().unwrap();
+        assert_eq!(str_filter, by_str_batch.build().unwrap());
+        for s in &strings {
+            assert!(str_filter.contains(s));
+            assert!(str_filter.contains(s.as_str()));
+        }
+
+        let mut by_blob_update = XorFilterBuilder::new(ty, 0);
+        for blob in &blobs {
+            by_blob_update.update(blob);
+        }
+        let mut by_blob_batch = XorFilterBuilder::new(ty, 0);
+        by_blob_batch.update_values(blobs.iter().map(Vec::as_slice));
+        let blob_filter = by_blob_update.build().unwrap();
+        assert_eq!(blob_filter, by_blob_batch.build().unwrap());
+        for blob in &blobs {
+            assert!(blob_filter.contains(blob));
+            assert!(blob_filter.contains(blob.as_slice()));
+        }
+
+        let mut by_mixed_update = XorFilterBuilder::new(ty, 0);
+        for id in &ids {
+            by_mixed_update.update(id);
+        }
+        
by_mixed_update.update(raw_bytes::from_string(String::from("payload")));
+        let mut by_mixed_batch = XorFilterBuilder::new(ty, 0);
+        by_mixed_batch.update_values(ids);
+        by_mixed_batch.update(raw_bytes::from_str("payload"));
+        let mixed_filter = by_mixed_update.build().unwrap();
+        assert_eq!(mixed_filter, by_mixed_batch.build().unwrap());
+        for id in &ids {
+            assert!(mixed_filter.contains(id));
+            assert!(mixed_filter.contains(*id));
+        }
+        assert!(mixed_filter.contains(raw_bytes::from_slice(b"payload")));
+    }
+}
+
 #[test]
 fn false_positive_rates_follow_fingerprint_width() {
     const NUM_ITEMS: u64 = 50_000;


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to