Struct Hasher

pub struct Hasher<'params>(/* private fields */);

A Hasher implements one of the two hash 64-bit functions defined by a specific Params struct, further tweaked by a seed. Construct Hashers with Params::hasher, Params::secondary_hasher, or Params::component_hasher.

The hash value is a function of the Params, the UmashComponent, the seed, and of the bytes written to the Hasher, but independent of the size of the individual slices written to the hasher.

In other words, it doesn’t matter how we partition an input, the Hasher computes the same hash value as a one-shot UMASH call for the parameters and the concatenated input bytes.

Implementations

impl<'params> Hasher<'params>

pub fn write(&mut self, bytes: &[u8]) -> &mut Self

Updates the hash state by conceptually concatenating bytes to the hash input.

Examples found in repository

examples/umash.rs (line 21)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let input = args
        .get(1)
        .cloned()
        .unwrap_or_else(|| "default input".to_string());
    let seed = 42u64;
    let my_params = umash::Params::derive(0, "hello example.c".as_bytes());
    let fprint = my_params
        .fingerprinter(seed)
        .write(input.as_bytes())
        .digest();

    println!("Input: {}", input);
    println!("Fingerprint: {:x}, {:x}", fprint.hash[0], fprint.hash[1]);
    println!(
        "Hash 0: {:x}",
        my_params.hasher(seed).write(input.as_bytes()).digest()
    );
    println!(
        "Hash 1: {:x}",
        my_params
            .secondary_hasher(seed)
            .write(input.as_bytes())
            .digest()
    );

    let mut h: umash::Hasher = (&my_params).into();
    h.write(input.as_bytes());
    println!("Hash: {:x}", h.finish());
}

pub fn digest(&self) -> u64

Returns the 64-bit hash value for the Hasher’s Params and the bytes passed to Hasher::write so far.

Examples found in repository

examples/umash.rs (line 21)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let input = args
        .get(1)
        .cloned()
        .unwrap_or_else(|| "default input".to_string());
    let seed = 42u64;
    let my_params = umash::Params::derive(0, "hello example.c".as_bytes());
    let fprint = my_params
        .fingerprinter(seed)
        .write(input.as_bytes())
        .digest();

    println!("Input: {}", input);
    println!("Fingerprint: {:x}, {:x}", fprint.hash[0], fprint.hash[1]);
    println!(
        "Hash 0: {:x}",
        my_params.hasher(seed).write(input.as_bytes()).digest()
    );
    println!(
        "Hash 1: {:x}",
        my_params
            .secondary_hasher(seed)
            .write(input.as_bytes())
            .digest()
    );

    let mut h: umash::Hasher = (&my_params).into();
    h.write(input.as_bytes());
    println!("Hash: {:x}", h.finish());
}

Trait Implementations

impl<'params> Clone for Hasher<'params>

fn clone(&self) -> Hasher<'params>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'params> From<&'params Params> for Hasher<'params>

Converts a &Params to Hasher by constructing a fresh Hasher for these Params and seed = 0.

fn from(params: &'params Params) -> Hasher<'params>

Converts to this type from the input type.

impl Hasher for Hasher<'_>

UMASH’s collision probability bounds only hold if different objects feed different byte streams to the hasher. The standard Rust [std::Hash::hash] implementations (and automatically generated ones) satisfy this requirement for values of the same type.

fn finish(&self) -> u64

Returns the hash value for the values written so far.

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

Writes some data into this Hasher.

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.

impl Write for Hasher<'_>

Hashers compute the same hash value for a given sequence of bytes, regardless of the number of bytes in each write call. This makes it possible to compute a hash by calling a serialisation function.

Call Hasher::digest to find the hash value for the concatenation of all the bytes written to the Hasher.

fn flush(&mut self) -> Result<()>

Flushing a Hasher cannot compute the fingerprint, due to the trait’s interface; the implementation is a no-op.

See Hasher::digest.

fn write(&mut self, bytes: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

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

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.