Struct RapidInlineHasher

pub struct RapidInlineHasher { /* private fields */ }

A Hasher trait compatible hasher that uses the rapidhash algorithm, and uses #[inline(always)] for all methods.

Using #[inline(always)] can deliver a large performance improvement when hashing complex objects, but should be benchmarked for your specific use case. If you have HashMaps for many different types this may come at the cost of some binary size increase.

See crate::RapidHasher for default non-forced inline methods.

See RapidInlineHashBuilder for usage with std::collections::HashMap.

Example

use std::hash::Hasher;
use rapidhash::RapidInlineHasher;

let mut hasher = RapidInlineHasher::default();
hasher.write(b"hello world");
let hash = hasher.finish();

Implementations

impl RapidInlineHasher

pub const DEFAULT_SEED: u64 = 13_679_853_920_966_426_665u64

Default RapidHasher seed.

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

Create a new RapidInlineHasher with a custom seed.

pub const fn default_const() -> Self

Create a new RapidInlineHasher using the default seed.

pub const fn write_const(&self, bytes: &[u8]) -> Self

Const equivalent to Hasher::write, and marked as #[inline(always)].

This can deliver a large performance improvement when the bytes length is known at compile time.

pub const fn finish_const(&self) -> u64

Const equivalent to Hasher::finish, and marked as #[inline(always)].

Trait Implementations

impl Clone for RapidInlineHasher

fn clone(&self) -> RapidInlineHasher

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for RapidInlineHasher

fn default() -> Self

Create a new RapidInlineHasher with the default seed.

See crate::RapidRandomState for a std::hash::BuildHasher that initialises with a random seed.

impl Hasher for RapidInlineHasher

This implementation implements methods for all integer types as the compiler will (hopefully…) inline and heavily optimize the rapidhash_core for each. Where the bytes length is known the compiler can make significant optimisations and saves us writing them out by hand.

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

Write a byte slice to the hasher, marked as #[inline(always)].

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.

impl PartialEq for RapidInlineHasher

fn eq(&self, other: &RapidInlineHasher) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for RapidInlineHasher

impl Eq for RapidInlineHasher

impl StructuralPartialEq for RapidInlineHasher