feat: implement hashmap and hashset support (#11)

thevilledev · web-flow · commit 67d07a23f9a6 · 2024-11-25T22:22:26.000+02:00
diff --git a/README.md b/README.md
@@ -18,10 +18,11 @@ All credit for the algorithm goes to [N-R-K](https://github.com/N-R-K).
   1. **Direct Hashing**: One-shot hashing using `chibi_hash64()`
   2. **Simple Hasher**: Basic implementation using `ChibiHasher` (implements `std::hash::Hasher`)
   3. **Streaming Hasher**: Memory-efficient streaming with `StreamingChibiHasher` (implements `std::hash::Hasher`)
+  4. **BuildHasher**: `ChibiHasher` implements `BuildHasher`. This allows using ChibiHash as the default hasher for `std::collections::HashMap` and `std::collections::HashSet`. Use `ChibiHashMap` and `ChibiHashSet` types.
 ## Example
 
 ```rust
-use chibihash::{chibi_hash64, ChibiHasher, StreamingChibiHasher};
+use chibihash::{chibi_hash64, ChibiHasher, StreamingChibiHasher, ChibiHashMap, ChibiHashSet};
 use std::hash::Hasher;
 
 fn main() {
@@ -39,6 +40,11 @@ fn main() {
     hasher.update(b"yellow ");
     hasher.update(b"world");
     println!("Streaming: {:016x}", hasher.finalize());
+
+    // Method 4: BuildHasher
+    let mut set: ChibiHashSet<String> = ChibiHashSet::default();
+    set.insert("hello".to_string());
+    println!("BuildHasher: {}", set.contains("hello"));
 }
 ```
 
diff --git a/benches/bench.rs b/benches/bench.rs
@@ -50,13 +50,9 @@ pub fn bench_streaming(c: &mut Criterion) {
         let input = vec![0u8; *size];
 
         // Single-shot benchmark
-        group.bench_with_input(
-            BenchmarkId::new("single_shot", size),
-            &input,
-            |b, input| {
-                b.iter(|| chibi_hash64(black_box(input), black_box(0)))
-            }
-        );
+        group.bench_with_input(BenchmarkId::new("single_shot", size), &input, |b, input| {
+            b.iter(|| chibi_hash64(black_box(input), black_box(0)))
+        });
 
         // Streaming benchmark - single update
         group.bench_with_input(
@@ -68,7 +64,7 @@ pub fn bench_streaming(c: &mut Criterion) {
                     hasher.update(black_box(input));
                     hasher.finalize()
                 })
-            }
+            },
         );
 
         // Streaming benchmark - split updates
@@ -85,7 +81,7 @@ pub fn bench_streaming(c: &mut Criterion) {
                         hasher.update(black_box(second));
                         hasher.finalize()
                     })
-                }
+                },
             );
         }
     }
@@ -112,7 +108,7 @@ pub fn bench_streaming_small_chunks(c: &mut Criterion) {
                     }
                     hasher.finalize()
                 })
-            }
+            },
         );
     }
 
@@ -128,7 +124,8 @@ pub fn bench_streaming_realistic(c: &mut Criterion) {
     group.bench_function("file_chunks_32k", |b| {
         b.iter(|| {
             let mut hasher = StreamingChibiHasher::new(0);
-            for chunk in large_input.chunks(32 * 1024) { // 32KB chunks
+            for chunk in large_input.chunks(32 * 1024) {
+                // 32KB chunks
                 hasher.update(black_box(chunk));
             }
             hasher.finalize()
diff --git a/benches/rust_vs_c.rs b/benches/rust_vs_c.rs
@@ -12,7 +12,7 @@ extern "C" {
 #[cfg(feature = "ffi")]
 fn bench_cross_language(c: &mut Criterion) {
     let mut group = c.benchmark_group("rust_vs_c");
-    
+
     // Test different input patterns
     let test_cases = vec![
         ("zeros", vec![0u8; 1024]),
@@ -34,18 +34,13 @@ fn bench_cross_language(c: &mut Criterion) {
     for (pattern_name, pattern) in test_cases {
         for size in sizes.iter() {
             let input = &pattern[..*size];
-            
+
             // Benchmark Rust implementation
             group.bench_with_input(
                 BenchmarkId::new(format!("rust_{}", pattern_name), size),
                 &input,
                 |b, input| {
-                    b.iter(|| {
-                        black_box(chibihash::chibi_hash64(
-                            black_box(input),
-                            black_box(0)
-                        ))
-                    })
+                    b.iter(|| black_box(chibihash::chibi_hash64(black_box(input), black_box(0))))
                 },
             );
 
@@ -58,7 +53,7 @@ fn bench_cross_language(c: &mut Criterion) {
                         black_box(chibihash64(
                             black_box(input.as_ptr() as *const c_void),
                             black_box(input.len() as isize),
-                            black_box(0)
+                            black_box(0),
                         ))
                     })
                 },
@@ -75,17 +70,13 @@ fn bench_cross_language(c: &mut Criterion) {
         group.bench_with_input(
             BenchmarkId::new("rust_aligned", size),
             &aligned_data[..*size],
-            |b, input| {
-                b.iter(|| black_box(chibihash::chibi_hash64(black_box(input), 0)))
-            },
+            |b, input| b.iter(|| black_box(chibihash::chibi_hash64(black_box(input), 0))),
         );
 
         group.bench_with_input(
             BenchmarkId::new("rust_unaligned", size),
             &unaligned_data[..*size],
-            |b, input| {
-                b.iter(|| black_box(chibihash::chibi_hash64(black_box(input), 0)))
-            },
+            |b, input| b.iter(|| black_box(chibihash::chibi_hash64(black_box(input), 0))),
         );
 
         // Same for C implementation
@@ -97,7 +88,7 @@ fn bench_cross_language(c: &mut Criterion) {
                     black_box(chibihash64(
                         black_box(input.as_ptr() as *const c_void),
                         black_box(input.len() as isize),
-                        0
+                        0,
                     ))
                 })
             },
@@ -111,7 +102,7 @@ fn bench_cross_language(c: &mut Criterion) {
                     black_box(chibihash64(
                         black_box(input.as_ptr() as *const c_void),
                         black_box(input.len() as isize),
-                        0
+                        0,
                     ))
                 })
             },
@@ -132,4 +123,4 @@ criterion_main!(benches);
 fn main() {
     println!("This benchmark requires the 'ffi' feature to be enabled.");
     println!("Please run with: cargo bench --features ffi");
-}
+}
diff --git a/build.rs b/build.rs
@@ -9,4 +9,4 @@ fn main() {
     println!("cargo:rerun-if-changed=csrc/chibihash.h");
     #[cfg(feature = "ffi")]
     println!("cargo:rerun-if-changed=csrc/chibihash.c");
-}
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -7,7 +7,7 @@
 //!
 //! Basic usage:
 //! ```rust
-//! use chibihash::{chibi_hash64, ChibiHasher, StreamingChibiHasher};
+//! use chibihash::{chibi_hash64, ChibiHasher, StreamingChibiHasher, ChibiHashMap, ChibiHashSet};
 //! use std::hash::Hasher;
 //!
 //! // Direct hashing
@@ -26,9 +26,25 @@
 //! hasher1.update(b"Hello, ");
 //! hasher1.update(b"World!");
 //! println!("{:016x}", hasher1.finalize());
+//!
+//! // Using BuildHasher as HashMap
+//! let mut map: ChibiHashMap<String, i32> = ChibiHashMap::default();
+//! map.insert("hello".to_string(), 42);
+//! println!("{:?}", map.get("hello"));
+//!
+//! // Using BuildHasher as HashSet
+//! let mut set: ChibiHashSet<String> = ChibiHashSet::default();
+//! set.insert("hello".to_string());
+//! println!("{}", set.contains("hello"));
+//!
+//! // Using BuildHasher as HashMap with custom seed
+//! let builder = ChibiHasher::new(42);
+//! let mut map: ChibiHashMap<String, i32> = ChibiHashMap::with_hasher(builder);
+//! map.insert("hello".to_string(), 42);
+//! println!("{:?}", map.get("hello"));
 //! ```
 
-use std::hash::{Hash, Hasher};
+use std::hash::{BuildHasher, Hash, Hasher};
 
 const P1: u64 = 0x2B7E151628AED2A5;
 const P2: u64 = 0x9E3793492EEDC3F7;
@@ -104,7 +120,7 @@ fn load_u64_le(bytes: &[u8]) -> u64 {
 }
 
 /// Configuration for the hash function
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
 pub struct ChibiHasher {
     seed: u64,
     buffer: Vec<u8>,
@@ -135,6 +151,20 @@ impl Hasher for ChibiHasher {
     }
 }
 
+impl BuildHasher for ChibiHasher {
+    type Hasher = ChibiHasher;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        ChibiHasher::new(self.seed)
+    }
+}
+
+/// A HashMap that uses ChibiHash by default
+pub type ChibiHashMap<K, V> = std::collections::HashMap<K, V, ChibiHasher>;
+
+/// A HashSet that uses ChibiHash by default
+pub type ChibiHashSet<T> = std::collections::HashSet<T, ChibiHasher>;
+
 /// Streaming ChibiHasher that processes data incrementally
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StreamingChibiHasher {
@@ -221,7 +251,8 @@ impl StreamingChibiHasher {
         h[0] ^= h[0] >> 31;
 
         let mut i = 1;
-        while l >= 8 && i < 4 { // bounds check
+        while l >= 8 && i < 4 {
+            // bounds check
             h[i] ^= load_u64_le(p);
             h[i] = h[i].wrapping_mul(P2);
             h[i] ^= h[i] >> 31;
@@ -276,4 +307,4 @@ mod tests {
         let bytes = [1, 2, 3, 4, 5, 6, 7, 8];
         assert_eq!(load_u64_le(&bytes), 0x0807060504030201);
     }
-}
+}
diff --git a/tests/hash_tests.rs b/tests/hash_tests.rs
@@ -1,7 +1,7 @@
 //! Tests for the ChibiHash algorithm
 //! Direct hashing
 
-use chibihash::{chibi_hash64, ChibiHasher, StreamingChibiHasher};
+use chibihash::{chibi_hash64, ChibiHashMap, ChibiHashSet, ChibiHasher, StreamingChibiHasher};
 use std::hash::{Hash, Hasher};
 
 #[test]
@@ -48,11 +48,11 @@ fn test_streaming_matches_direct() {
     // Helper function to test streaming vs direct
     fn test_streaming(input: &[u8], seed: u64) {
         let direct = chibi_hash64(input, seed);
-        
+
         let mut streaming = StreamingChibiHasher::new(seed);
         streaming.update(input);
         let streaming_result = streaming.finalize();
-        
+
         assert_eq!(
             direct, streaming_result,
             "Streaming and direct hashing mismatch for input: {:?}, seed: {}",
@@ -80,3 +80,17 @@ fn test_streaming_matches_direct() {
         "Split streaming should match direct"
     );
 }
+
+#[test]
+fn test_chibi_hash_map() {
+    let mut map: ChibiHashMap<String, i32> = ChibiHashMap::default();
+    map.insert("hello".to_string(), 42);
+    assert_eq!(map.get("hello"), Some(&42));
+}
+
+#[test]
+fn test_chibi_hash_set() {
+    let mut set: ChibiHashSet<String> = ChibiHashSet::default();
+    set.insert("hello".to_string());
+    assert!(set.contains("hello"));
+}
diff --git a/tests/streaming_tests.rs b/tests/streaming_tests.rs
@@ -10,11 +10,11 @@ fn test_streaming_matches_direct() {
     // Helper function to test streaming vs direct
     fn test_streaming(input: &[u8], seed: u64) {
         let direct = chibi_hash64(input, seed);
-        
+
         let mut streaming = StreamingChibiHasher::new(seed);
         streaming.update(input);
         let streaming_result = streaming.finalize();
-        
+
         assert_eq!(
             direct, streaming_result,
             "Streaming and direct hashing mismatch for input: {:?}, seed: {}",
