Struct StableHasher

pub struct StableHasher<H: ExtendedHasher> { /* private fields */ }

A Stable Hasher adapted for cross-platform independent hash.

When hashing something that ends up affecting properties like symbol names, we want these symbol names to be calculated independently of other factors like what architecture you’re compiling from.

To that end we always convert integers to little-endian format before hashing and the architecture dependent isize and usize types are extended to 64 bits if needed.

Example

use rustc_stable_hash::hashers::{StableSipHasher128, SipHasher128Hash};
use rustc_stable_hash::{StableHasher, FromStableHash};
use std::hash::Hasher;

struct Hash128([u64; 2]);
impl FromStableHash for Hash128 {
    type Hash = SipHasher128Hash;

    fn from(SipHasher128Hash(hash): SipHasher128Hash) -> Hash128 {
        Hash128(hash)
    }
}

let mut hasher = StableSipHasher128::new();
hasher.write_usize(0xFA);

let hash: Hash128 = hasher.finish();

Implementations

impl<H: ExtendedHasher + Default> StableHasher<H>

pub fn new() -> Self

Creates a new StableHasher.

To be used with the Hasher implementation and StableHasher::finish.

impl<H: ExtendedHasher> StableHasher<H>

pub fn with_hasher(state: H) -> Self

Creates a new StableHasher from an already created ExtendedHasher.

Useful when wanting to initialize a hasher with different parameters/keys.

Important: Any use of the hasher before being given to a StableHasher is not covered by this crate guarentees and will make the resulting hash NOT platform independent.

pub fn finish<W: FromStableHash<Hash = H::Hash>>(self) -> W

Returns the typed-hash value for the values written.

The resulting typed-hash value is constructed from an FromStableHash implemenation.

To be used in-place of Hasher::finish.

Trait Implementations

impl<H: Clone + ExtendedHasher> Clone for StableHasher<H>

fn clone(&self) -> StableHasher<H>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H: ExtendedHasher + Debug> Debug for StableHasher<H>

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

Formats the value using the given formatter.

impl<H: ExtendedHasher + Default> Default for StableHasher<H>

fn default() -> Self

Creates a new StableHasher.

To be used with the Hasher implementation and StableHasher::finish.

impl<H: ExtendedHasher> Hasher for StableHasher<H>

fn finish(&self) -> u64

Returns a combined hash.

For greater precision use instead StableHasher::finish.

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.