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 468890e  refactor(xor): align constructors, builder traits, and 
filter_type accessor (#351)
468890e is described below

commit 468890e99f048954e8927884160d50adbcad0081
Author: tison <[email protected]>
AuthorDate: Thu Nov 12 07:59:26 2026 +0800

    refactor(xor): align constructors, builder traits, and filter_type accessor 
(#351)
---
 benchmarks/xor/build.rs                    | 15 +++----
 benchmarks/xor/build_batches.rs            |  2 +-
 benchmarks/xor/query.rs                    | 12 ++---
 benchmarks/xor/query_shards.rs             |  2 +-
 datasketches/src/xor/filter.rs             | 43 +++++++++++++++---
 datasketches/src/xor/mod.rs                |  2 +-
 tests-integration/tests/serde_tests/xor.rs | 17 +++++---
 tests-integration/tests/xor_test/filter.rs | 70 ++++++++++++++++++++++--------
 8 files changed, 113 insertions(+), 50 deletions(-)

diff --git a/benchmarks/xor/build.rs b/benchmarks/xor/build.rs
index d3bcc15..05b1945 100644
--- a/benchmarks/xor/build.rs
+++ b/benchmarks/xor/build.rs
@@ -32,8 +32,7 @@ fn repeated_hashes(rows: usize) -> Vec<u64> {
 
 fn distinct_8(bencher: Bencher, cardinality: usize) {
     let keys = hashes(cardinality);
-    bencher
-        .bench_local(|| black_box(XorFilter::from_hashes(&keys, 
XorFilterType::Xor8, 0).unwrap()));
+    bencher.bench_local(|| black_box(XorFilter::from_hashes(&keys, 
XorFilterType::Xor8).unwrap()));
 }
 
 fn xorf_distinct_8(bencher: Bencher, cardinality: usize) {
@@ -44,7 +43,7 @@ fn xorf_distinct_8(bencher: Bencher, cardinality: usize) {
 fn deduplicate_8(bencher: Bencher, rows: usize) {
     let keys = repeated_hashes(rows);
     bencher.bench_local(|| {
-        let mut builder = XorFilterBuilder::new(XorFilterType::Xor8, 0);
+        let mut builder = XorFilterBuilder::new(XorFilterType::Xor8);
         builder.update_hashes(keys.iter().copied());
         black_box(builder.build().unwrap())
     });
@@ -63,8 +62,7 @@ fn xorf_deduplicate_8(bencher: Bencher, rows: usize) {
 
 fn distinct_16(bencher: Bencher, cardinality: usize) {
     let keys = hashes(cardinality);
-    bencher
-        .bench_local(|| black_box(XorFilter::from_hashes(&keys, 
XorFilterType::Xor16, 0).unwrap()));
+    bencher.bench_local(|| black_box(XorFilter::from_hashes(&keys, 
XorFilterType::Xor16).unwrap()));
 }
 
 fn xorf_distinct_16(bencher: Bencher, cardinality: usize) {
@@ -75,7 +73,7 @@ fn xorf_distinct_16(bencher: Bencher, cardinality: usize) {
 fn deduplicate_16(bencher: Bencher, rows: usize) {
     let keys = repeated_hashes(rows);
     bencher.bench_local(|| {
-        let mut builder = XorFilterBuilder::new(XorFilterType::Xor16, 0);
+        let mut builder = XorFilterBuilder::new(XorFilterType::Xor16);
         builder.update_hashes(keys.iter().copied());
         black_box(builder.build().unwrap())
     });
@@ -94,8 +92,7 @@ fn xorf_deduplicate_16(bencher: Bencher, rows: usize) {
 
 fn distinct_32(bencher: Bencher, cardinality: usize) {
     let keys = hashes(cardinality);
-    bencher
-        .bench_local(|| black_box(XorFilter::from_hashes(&keys, 
XorFilterType::Xor32, 0).unwrap()));
+    bencher.bench_local(|| black_box(XorFilter::from_hashes(&keys, 
XorFilterType::Xor32).unwrap()));
 }
 
 fn xorf_distinct_32(bencher: Bencher, cardinality: usize) {
@@ -106,7 +103,7 @@ fn xorf_distinct_32(bencher: Bencher, cardinality: usize) {
 fn deduplicate_32(bencher: Bencher, rows: usize) {
     let keys = repeated_hashes(rows);
     bencher.bench_local(|| {
-        let mut builder = XorFilterBuilder::new(XorFilterType::Xor32, 0);
+        let mut builder = XorFilterBuilder::new(XorFilterType::Xor32);
         builder.update_hashes(keys.iter().copied());
         black_box(builder.build().unwrap())
     });
diff --git a/benchmarks/xor/build_batches.rs b/benchmarks/xor/build_batches.rs
index 0d40bf0..fd2df8b 100644
--- a/benchmarks/xor/build_batches.rs
+++ b/benchmarks/xor/build_batches.rs
@@ -45,7 +45,7 @@ pub fn register(runner: &mut Runner) {
             &[
                 ("distinct", &|b| {
                     build(b, cardinality, |keys| {
-                        XorFilter::from_hashes(keys, XorFilterType::Xor8, 
1).unwrap()
+                        XorFilter::from_hashes_with_seed(keys, 
XorFilterType::Xor8, 1).unwrap()
                     })
                 }),
                 ("xorf", &|b| {
diff --git a/benchmarks/xor/query.rs b/benchmarks/xor/query.rs
index 36542b6..6bbe84d 100644
--- a/benchmarks/xor/query.rs
+++ b/benchmarks/xor/query.rs
@@ -27,7 +27,7 @@ use crate::xor::hashes;
 
 fn datasketches_8_present(bencher: Bencher, cardinality: usize) {
     let keys = hashes(cardinality * 2);
-    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor8, 0).unwrap();
+    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor8).unwrap();
     bencher.bench_local(|| {
         for key in &keys[..cardinality] {
             black_box(filter.contains_hash(black_box(*key)));
@@ -37,7 +37,7 @@ fn datasketches_8_present(bencher: Bencher, cardinality: 
usize) {
 
 fn datasketches_8_absent(bencher: Bencher, cardinality: usize) {
     let keys = hashes(cardinality * 2);
-    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor8, 0).unwrap();
+    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor8).unwrap();
     bencher.bench_local(|| {
         for key in &keys[cardinality..] {
             black_box(filter.contains_hash(black_box(*key)));
@@ -67,7 +67,7 @@ fn xorf_8_absent(bencher: Bencher, cardinality: usize) {
 
 fn datasketches_16_present(bencher: Bencher, cardinality: usize) {
     let keys = hashes(cardinality * 2);
-    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor16, 0).unwrap();
+    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor16).unwrap();
     bencher.bench_local(|| {
         for key in &keys[..cardinality] {
             black_box(filter.contains_hash(black_box(*key)));
@@ -77,7 +77,7 @@ fn datasketches_16_present(bencher: Bencher, cardinality: 
usize) {
 
 fn datasketches_16_absent(bencher: Bencher, cardinality: usize) {
     let keys = hashes(cardinality * 2);
-    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor16, 0).unwrap();
+    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor16).unwrap();
     bencher.bench_local(|| {
         for key in &keys[cardinality..] {
             black_box(filter.contains_hash(black_box(*key)));
@@ -107,7 +107,7 @@ fn xorf_16_absent(bencher: Bencher, cardinality: usize) {
 
 fn datasketches_32_present(bencher: Bencher, cardinality: usize) {
     let keys = hashes(cardinality * 2);
-    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor32, 0).unwrap();
+    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor32).unwrap();
     bencher.bench_local(|| {
         for key in &keys[..cardinality] {
             black_box(filter.contains_hash(black_box(*key)));
@@ -117,7 +117,7 @@ fn datasketches_32_present(bencher: Bencher, cardinality: 
usize) {
 
 fn datasketches_32_absent(bencher: Bencher, cardinality: usize) {
     let keys = hashes(cardinality * 2);
-    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor32, 0).unwrap();
+    let filter = XorFilter::from_hashes(&keys[..cardinality], 
XorFilterType::Xor32).unwrap();
     bencher.bench_local(|| {
         for key in &keys[cardinality..] {
             black_box(filter.contains_hash(black_box(*key)));
diff --git a/benchmarks/xor/query_shards.rs b/benchmarks/xor/query_shards.rs
index d0f9190..5bc50d0 100644
--- a/benchmarks/xor/query_shards.rs
+++ b/benchmarks/xor/query_shards.rs
@@ -105,7 +105,7 @@ pub fn register(runner: &mut Runner) {
                                 b,
                                 cardinality,
                                 present,
-                                |keys| XorFilter::from_hashes(keys, kind, 
1).unwrap(),
+                                |keys| XorFilter::from_hashes_with_seed(keys, 
kind, 1).unwrap(),
                                 XorFilter::contains_hash,
                             )
                         }),
diff --git a/datasketches/src/xor/filter.rs b/datasketches/src/xor/filter.rs
index 2122d06..af9c2ac 100644
--- a/datasketches/src/xor/filter.rs
+++ b/datasketches/src/xor/filter.rs
@@ -32,6 +32,7 @@ const NUM_HASHES: u8 = 3;
 const SERIAL_VERSION: u8 = 1;
 const PREAMBLE_BYTES: usize = 3 * size_of::<u64>();
 const HASH_SEED: u64 = 0;
+const DEFAULT_CONSTRUCTION_SEED: u64 = 0;
 const LOAD_FACTOR: f64 = 1.23;
 const CAPACITY_OFFSET: u64 = 32;
 const MAX_CONSTRUCTION_ATTEMPTS: usize = 100;
@@ -95,7 +96,7 @@ impl Fingerprints {
 /// [`XorFilter::contains_hash`].
 ///
 /// See the [module level documentation](super) for more.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct XorFilterBuilder {
     filter_type: XorFilterType,
     seed: u64,
@@ -103,11 +104,18 @@ pub struct XorFilterBuilder {
 }
 
 impl XorFilterBuilder {
+    /// Creates a builder with the given fingerprint width and the default 
construction seed (`0`).
+    ///
+    /// Values are hashed independently of the construction seed.
+    pub fn new(filter_type: XorFilterType) -> Self {
+        Self::with_seed(filter_type, DEFAULT_CONSTRUCTION_SEED)
+    }
+
     /// Creates a builder with the given fingerprint width and initial 
construction seed.
     ///
     /// The `seed` determines which layouts to try during construction. Values 
are hashed
     /// independently of it.
-    pub fn new(filter_type: XorFilterType, seed: u64) -> Self {
+    pub fn with_seed(filter_type: XorFilterType, seed: u64) -> Self {
         Self {
             filter_type,
             seed,
@@ -145,7 +153,7 @@ impl XorFilterBuilder {
     pub fn build(mut self) -> Result<XorFilter, Error> {
         self.hashes.sort_unstable();
         self.hashes.dedup();
-        XorFilter::from_hashes(&self.hashes, self.filter_type, self.seed)
+        XorFilter::from_hashes_with_seed(&self.hashes, self.filter_type, 
self.seed)
     }
 }
 
@@ -166,7 +174,25 @@ pub struct XorFilter {
 }
 
 impl XorFilter {
-    /// Creates a filter from distinct precomputed 64-bit hashes.
+    /// Creates a filter from distinct precomputed 64-bit hashes using the 
default construction
+    /// seed (`0`).
+    ///
+    /// The same set of hashes and filter type produce the same filter 
regardless of input order.
+    /// Query with [`contains_hash`](Self::contains_hash) using the same hash 
function.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`InvalidArgument`](crate::error::ErrorKind::InvalidArgument) 
in these cases:
+    ///
+    /// - The input contains duplicate hashes.
+    /// - The input is too large to build a filter.
+    /// - Construction cannot find a valid layout. For distinct hashes, try 
another seed with
+    ///   [`from_hashes_with_seed`](Self::from_hashes_with_seed).
+    pub fn from_hashes(keys: &[u64], filter_type: XorFilterType) -> 
Result<Self, Error> {
+        Self::from_hashes_with_seed(keys, filter_type, 
DEFAULT_CONSTRUCTION_SEED)
+    }
+
+    /// Creates a filter from distinct precomputed 64-bit hashes and an 
explicit construction seed.
     ///
     /// The initial `seed` determines which layouts to try during 
construction. The same set of
     /// hashes, filter type, and seed produce the same filter regardless of 
input order.
@@ -179,7 +205,11 @@ impl XorFilter {
     /// - The input contains duplicate hashes.
     /// - The input is too large to build a filter.
     /// - Construction cannot find a valid layout. For distinct hashes, try 
another `seed`.
-    pub fn from_hashes(keys: &[u64], filter_type: XorFilterType, seed: u64) -> 
Result<Self, Error> {
+    pub fn from_hashes_with_seed(
+        keys: &[u64],
+        filter_type: XorFilterType,
+        seed: u64,
+    ) -> Result<Self, Error> {
         let num_items = keys.len();
         let capacity = compute_capacity(num_items)?;
         let segment_length = capacity / usize::from(NUM_HASHES);
@@ -298,7 +328,8 @@ impl XorFilter {
         }
     }
 
-    fn filter_type(&self) -> XorFilterType {
+    /// Returns the fingerprint representation used by this filter.
+    pub fn filter_type(&self) -> XorFilterType {
         match &self.fingerprints {
             Fingerprints::Xor8(_) => XorFilterType::Xor8,
             Fingerprints::Xor16(_) => XorFilterType::Xor16,
diff --git a/datasketches/src/xor/mod.rs b/datasketches/src/xor/mod.rs
index f31448a..2d33090 100644
--- a/datasketches/src/xor/mod.rs
+++ b/datasketches/src/xor/mod.rs
@@ -41,7 +41,7 @@
 //! use datasketches::xor::XorFilterBuilder;
 //! use datasketches::xor::XorFilterType;
 //!
-//! let mut builder = XorFilterBuilder::new(XorFilterType::Xor8, 0);
+//! let mut builder = XorFilterBuilder::new(XorFilterType::Xor8);
 //! builder.update_values(["apple", "banana"]);
 //! let filter = builder.build().unwrap();
 //!
diff --git a/tests-integration/tests/serde_tests/xor.rs 
b/tests-integration/tests/serde_tests/xor.rs
index 6f99f3f..d66553a 100644
--- a/tests-integration/tests/serde_tests/xor.rs
+++ b/tests-integration/tests/serde_tests/xor.rs
@@ -41,11 +41,12 @@ fn java_images_round_trip_byte_for_byte() {
         (XorFilterType::Xor16, JAVA_XOR16_IMAGE),
     ] {
         let expected = decode_hex(image);
-        let mut builder = XorFilterBuilder::new(ty, 42);
+        let mut builder = XorFilterBuilder::with_seed(ty, 42);
         builder.update_values(values);
         let built = builder.build().unwrap();
 
         let restored = XorFilter::deserialize(&expected).unwrap();
+        assert_eq!(restored.filter_type(), ty);
         assert_eq!(restored.serialize(), expected);
         assert_eq!(built.serialize(), expected);
         for value in values {
@@ -67,10 +68,11 @@ fn serialization_round_trips_standard_fingerprint_types() {
     ] {
         for count in [0, 1, 10_000_u64] {
             let hashes: Vec<_> = (0..count).collect();
-            let original = XorFilter::from_hashes(&hashes, ty, 0).unwrap();
+            let original = XorFilter::from_hashes(&hashes, ty).unwrap();
             let bytes = original.serialize();
 
             let restored = XorFilter::deserialize(&bytes).unwrap();
+            assert_eq!(restored.filter_type(), ty);
             assert_eq!(restored, original);
             for hash in 0..count {
                 assert!(restored.contains_hash(hash));
@@ -87,7 +89,7 @@ fn every_truncated_image_is_rejected() {
         XorFilterType::Xor32,
     ] {
         let hashes: Vec<_> = (0..100_u64).collect();
-        let bytes = XorFilter::from_hashes(&hashes, ty, 
0).unwrap().serialize();
+        let bytes = XorFilter::from_hashes(&hashes, ty).unwrap().serialize();
         for end in 0..bytes.len() {
             let error = XorFilter::deserialize(&bytes[..end]).unwrap_err();
             assert_eq!(error.kind(), ErrorKind::InvalidData, "length {end}");
@@ -99,7 +101,7 @@ fn every_truncated_image_is_rejected() {
 #[test]
 fn invalid_preamble_fields_are_rejected() {
     let hashes: Vec<_> = (0..100_u64).collect();
-    let valid = XorFilter::from_hashes(&hashes, XorFilterType::Xor8, 0)
+    let valid = XorFilter::from_hashes(&hashes, XorFilterType::Xor8)
         .unwrap()
         .serialize();
 
@@ -124,7 +126,7 @@ fn invalid_preamble_fields_are_rejected() {
 #[test]
 fn unsafe_lengths_are_rejected_before_indexing() {
     let hashes: Vec<_> = (0..100_u64).collect();
-    let valid = XorFilter::from_hashes(&hashes, XorFilterType::Xor8, 0)
+    let valid = XorFilter::from_hashes(&hashes, XorFilterType::Xor8)
         .unwrap()
         .serialize();
 
@@ -146,7 +148,7 @@ fn trailing_storage_is_ignored() {
         XorFilterType::Xor32,
     ] {
         let hashes: Vec<_> = (0..100_u64).collect();
-        let original = XorFilter::from_hashes(&hashes, kind, 0).unwrap();
+        let original = XorFilter::from_hashes(&hashes, kind).unwrap();
         let mut bytes = original.serialize();
         bytes.extend_from_slice(&[0xaa; 16]);
 
@@ -181,7 +183,7 @@ fn java_utf8_and_raw_byte_inputs_match() {
         ),
     ];
     for (kind, image) in images {
-        let mut builder = XorFilterBuilder::new(kind, 42);
+        let mut builder = XorFilterBuilder::with_seed(kind, 42);
         for bytes in [b"hello".as_slice(), "数据🔎".as_bytes(), &[], &[0, 1, 
255]] {
             builder.update(raw_bytes::from_slice(bytes));
         }
@@ -208,6 +210,7 @@ fn xor32_image_preserves_full_width_little_endian_slots() {
         "67452301efcdab899c5f4186",
     ));
     let filter = XorFilter::deserialize(&bytes).unwrap();
+    assert_eq!(filter.filter_type(), XorFilterType::Xor32);
     assert!(filter.contains_hash(0));
     assert_eq!(filter.serialize(), bytes);
 }
diff --git a/tests-integration/tests/xor_test/filter.rs 
b/tests-integration/tests/xor_test/filter.rs
index 67e9304..3711155 100644
--- a/tests-integration/tests/xor_test/filter.rs
+++ b/tests-integration/tests/xor_test/filter.rs
@@ -23,11 +23,12 @@ use datasketches::xor::XorFilterType;
 
 #[test]
 fn values_have_no_false_negatives() {
-    let mut builder = XorFilterBuilder::new(XorFilterType::Xor8, 8123);
+    let mut builder = XorFilterBuilder::with_seed(XorFilterType::Xor8, 8123);
     for value in 0..10_000_u64 {
         builder.update(value);
     }
     let filter = builder.build().unwrap();
+    assert_eq!(filter.filter_type(), XorFilterType::Xor8);
 
     for value in 0..10_000_u64 {
         assert!(filter.contains(value), "false negative for {value}");
@@ -45,7 +46,8 @@ fn precomputed_hashes_have_no_false_negatives() {
         XorFilterType::Xor16,
         XorFilterType::Xor32,
     ] {
-        let filter = XorFilter::from_hashes(&hashes, ty, 0).unwrap();
+        let filter = XorFilter::from_hashes(&hashes, ty).unwrap();
+        assert_eq!(filter.filter_type(), ty);
         for &hash in &hashes {
             assert!(filter.contains_hash(hash), "false negative for {hash}");
         }
@@ -59,23 +61,50 @@ fn builder_deduplicates_values_and_hashes() {
         XorFilterType::Xor16,
         XorFilterType::Xor32,
     ] {
-        let mut duplicate_values = XorFilterBuilder::new(ty, 0);
+        let mut duplicate_values = XorFilterBuilder::new(ty);
         duplicate_values.update(7_u64);
         duplicate_values.update_values([11_u64, 7, 11]);
 
-        let mut distinct_values = XorFilterBuilder::new(ty, 0);
+        let mut distinct_values = XorFilterBuilder::new(ty);
         distinct_values.update_values([11_u64, 7]);
         assert_eq!(
             duplicate_values.build().unwrap(),
             distinct_values.build().unwrap(),
         );
 
-        let mut hashes = XorFilterBuilder::new(ty, 0);
+        let mut hashes = XorFilterBuilder::new(ty);
         hashes.update_hash(7);
         hashes.update_hashes([11, 7, 11]);
         assert_eq!(
             hashes.build().unwrap(),
-            XorFilter::from_hashes(&[7, 11], ty, 0).unwrap(),
+            XorFilter::from_hashes(&[7, 11], ty).unwrap(),
+        );
+    }
+}
+
+#[test]
+fn default_seed_constructors_and_builder_clone_behave_consistently() {
+    for ty in [
+        XorFilterType::Xor8,
+        XorFilterType::Xor16,
+        XorFilterType::Xor32,
+    ] {
+        let mut default_builder = XorFilterBuilder::new(ty);
+        default_builder.update_values([1_u64, 2, 3]);
+        let cloned_builder = default_builder.clone();
+        default_builder.update(4_u64);
+
+        let mut zero_seeded_builder = XorFilterBuilder::with_seed(ty, 0);
+        zero_seeded_builder.update_values([1_u64, 2, 3]);
+
+        let cloned_filter = cloned_builder.build().unwrap();
+        assert_eq!(cloned_filter, zero_seeded_builder.build().unwrap());
+        assert_eq!(cloned_filter.filter_type(), ty);
+        assert_ne!(cloned_filter, default_builder.build().unwrap());
+
+        assert_eq!(
+            XorFilter::from_hashes(&[10, 20, 30], ty).unwrap(),
+            XorFilter::from_hashes_with_seed(&[10, 20, 30], ty, 0).unwrap(),
         );
     }
 }
@@ -91,11 +120,11 @@ fn 
equivalent_borrowed_and_value_inputs_build_identical_filters() {
         XorFilterType::Xor16,
         XorFilterType::Xor32,
     ] {
-        let mut by_str_update = XorFilterBuilder::new(ty, 0);
+        let mut by_str_update = XorFilterBuilder::new(ty);
         for s in &strings {
             by_str_update.update(s);
         }
-        let mut by_str_batch = XorFilterBuilder::new(ty, 0);
+        let mut by_str_batch = XorFilterBuilder::new(ty);
         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());
@@ -104,11 +133,11 @@ fn 
equivalent_borrowed_and_value_inputs_build_identical_filters() {
             assert!(str_filter.contains(s.as_str()));
         }
 
-        let mut by_blob_update = XorFilterBuilder::new(ty, 0);
+        let mut by_blob_update = XorFilterBuilder::new(ty);
         for blob in &blobs {
             by_blob_update.update(blob);
         }
-        let mut by_blob_batch = XorFilterBuilder::new(ty, 0);
+        let mut by_blob_batch = XorFilterBuilder::new(ty);
         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());
@@ -117,12 +146,12 @@ fn 
equivalent_borrowed_and_value_inputs_build_identical_filters() {
             assert!(blob_filter.contains(blob.as_slice()));
         }
 
-        let mut by_mixed_update = XorFilterBuilder::new(ty, 0);
+        let mut by_mixed_update = XorFilterBuilder::new(ty);
         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);
+        let mut by_mixed_batch = XorFilterBuilder::new(ty);
         by_mixed_batch.update_values(ids);
         by_mixed_batch.update(raw_bytes::from_str("payload"));
         let mixed_filter = by_mixed_update.build().unwrap();
@@ -141,9 +170,9 @@ fn false_positive_rates_follow_fingerprint_width() {
     const NUM_QUERIES: u64 = 100_000;
 
     let hashes: Vec<_> = (0..NUM_ITEMS).collect();
-    let xor8 = XorFilter::from_hashes(&hashes, XorFilterType::Xor8, 
0).unwrap();
-    let xor16 = XorFilter::from_hashes(&hashes, XorFilterType::Xor16, 
0).unwrap();
-    let xor32 = XorFilter::from_hashes(&hashes, XorFilterType::Xor32, 
0).unwrap();
+    let xor8 = XorFilter::from_hashes(&hashes, XorFilterType::Xor8).unwrap();
+    let xor16 = XorFilter::from_hashes(&hashes, XorFilterType::Xor16).unwrap();
+    let xor32 = XorFilter::from_hashes(&hashes, XorFilterType::Xor32).unwrap();
 
     let false_positives8 = (NUM_ITEMS..NUM_ITEMS + NUM_QUERIES)
         .filter(|&hash| xor8.contains_hash(hash))
@@ -177,11 +206,11 @@ fn 
distinct_construction_is_bounded_and_does_not_deduplicate() {
         XorFilterType::Xor16,
         XorFilterType::Xor32,
     ] {
-        let error = XorFilter::from_hashes(&[1, 2, 1], kind, 0).unwrap_err();
+        let error = XorFilter::from_hashes(&[1, 2, 1], kind).unwrap_err();
         assert_eq!(error.kind(), ErrorKind::InvalidArgument);
         assert!(error.message().contains("duplicate hashes"));
         for keys in [vec![], vec![0], vec![u64::MAX], vec![0, u64::MAX]] {
-            let f = XorFilter::from_hashes(&keys, kind, 0).unwrap();
+            let f = XorFilter::from_hashes(&keys, kind).unwrap();
             for key in keys {
                 assert!(f.contains_hash(key));
             }
@@ -206,12 +235,15 @@ fn 
construction_recovers_after_an_unpeelable_first_attempt() {
         XorFilterType::Xor16,
         XorFilterType::Xor32,
     ] {
-        let filter = XorFilter::from_hashes(&keys, kind, 1).unwrap();
+        let filter = XorFilter::from_hashes_with_seed(&keys, kind, 1).unwrap();
         for &key in &keys {
             assert!(filter.contains_hash(key));
         }
         let mut reversed = keys.clone();
         reversed.reverse();
-        assert_eq!(filter, XorFilter::from_hashes(&reversed, kind, 
1).unwrap());
+        assert_eq!(
+            filter,
+            XorFilter::from_hashes_with_seed(&reversed, kind, 1).unwrap()
+        );
     }
 }


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

Reply via email to