Struct DefaultHasher 

pub struct DefaultHasher { /* private fields */ }

A fast, non-cryptographic 64-bit hasher with strong avalanche behaviour.

DefaultHasher folds the input eight bytes at a time through a 64x64-bit multiply-fold and mixes the total length into the finalizer, so inputs that differ only by trailing zero bytes do not collide. It is not suitable for authentication or any setting where collision resistance against an adversary is required; use a cryptographic hash for that.

You rarely construct this directly. It is produced by DefaultHashBuilder, which the structures use by default.

Examples

use core::hash::{Hash, Hasher};
use bloom_lib::hash::DefaultHasher;

let mut hasher = DefaultHasher::default();
"probabilistic".hash(&mut hasher);
let digest = hasher.finish();

// Hashing the same value again yields the same digest.
let mut again = DefaultHasher::default();
"probabilistic".hash(&mut again);
assert_eq!(digest, again.finish());

Implementations

impl DefaultHasher

pub const fn with_seed(seed: u64) -> Self

Creates a hasher seeded with the given value.

Two hashers created with the same seed produce identical digests for identical inputs. DefaultHasher::default uses a fixed library seed.

Examples

use core::hash::Hasher;
use bloom_lib::hash::DefaultHasher;

let mut a = DefaultHasher::with_seed(42);
let mut b = DefaultHasher::with_seed(7);
a.write(b"payload");
b.write(b"payload");
assert_ne!(a.finish(), b.finish());

Trait Implementations

impl Clone for DefaultHasher

fn clone(&self) -> DefaultHasher

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DefaultHasher

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DefaultHasher

fn default() -> Self

Returns the “default value” for a type.

impl Hasher for DefaultHasher

fn write(&mut self, bytes: &[u8])

Writes some data into this Hasher.

fn finish(&self) -> u64

Returns the hash value for the values written so far.

fn write_u8(&mut self, i: u8)

Writes a single u8 into this hasher.

fn write_u16(&mut self, i: u16)

Writes a single u16 into this hasher.

fn write_u32(&mut self, i: u32)

Writes a single u32 into this hasher.

fn write_u64(&mut self, i: u64)

Writes a single u64 into this hasher.

fn write_u128(&mut self, i: u128)

Writes a single u128 into this hasher.

fn write_usize(&mut self, i: usize)

Writes a single usize into this hasher.

fn write_i8(&mut self, i: i8)

Writes a single i8 into this hasher.

fn write_i16(&mut self, i: i16)

Writes a single i16 into this hasher.

fn write_i32(&mut self, i: i32)

Writes a single i32 into this hasher.

fn write_i64(&mut self, i: i64)

Writes a single i64 into this hasher.

fn write_i128(&mut self, i: i128)

Writes a single i128 into this hasher.

fn write_isize(&mut self, i: isize)

Writes a single isize into this hasher.

fn write_length_prefix(&mut self, len: usize)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras)

Writes a length prefix into this hasher, as part of being prefix-free.

fn write_str(&mut self, s: &str)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras)

Writes a single str into this hasher.