Struct rand_seeder::SipHasher

pub struct SipHasher { /* fields omitted */ }

A portable implementation of SipHash 2-4.

This implementation will produce 8-byte (u64) output compliant with the reference implementation. Additionally, it can be extended into an RNG able to produce unlimited output via SipHasher::into_rng.

See: https://131002.net/siphash/

SipHash is a general-purpose hashing function: it runs at a good speed (competitive with Spooky and City) and permits strong keyed hashing.

Although the SipHash algorithm is considered strong, it is not intended for cryptographic uses (e.g. authentication).

Implementations

impl SipHasher

pub fn new() -> Self

Create a new SipHasher (equivalent to from_keys(0, 0)).

pub fn from_keys(key0: u64, key1: u64) -> Self

Create a SipHasher using the given keys.

pub fn into_rng(self) -> SipRng

Finish writes and convert the hasher's core into a generator.

This offers a fast, elegant transition from hash function to generator which maintains (up to) 256 bits of entropy.

Note that this transition has not been reviewed for cryptographic strength, and might break SipHash's security.

Trait Implementations

impl Clone for SipHasher

fn clone(&self) -> SipHasher

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SipHasher

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

Formats the value using the given formatter.

impl Default for SipHasher

fn default() -> SipHasher

Returns the "default value" for a type.

impl<H: Hash> From<H> for SipHasher

fn from(h: H) -> SipHasher

Performs the conversion.

impl Hasher for SipHasher

Implements the standard library's Hasher trait.

Note that all methods are implemented directly to fix Endianness, unlike the default implementations in the standard library.

fn finish(&self) -> u64

Returns the hash value for the values written so far.

fn write(&mut self, msg: &[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)

For portability reasons, the usize input is interpreted as a u128.

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)

For portability reasons, the isize input is interpreted as a i128.