Struct RandomState 

pub struct RandomState<const AVALANCHE: bool, const SPONGE: bool, const COMPACT: bool, const PROTECTED: bool> { /* private fields */ }

A [std::hash::RandomState] compatible hasher that initializes a RapidHasher with a random seed and random global secrets.

This is designed to provide some HashDoS resistance by using a random seed per hashmap, and a global random set of secrets.

Portability

On most target platforms, the secrets are randomly initialized once and cached globally for the lifetime of the program using a mix of ASLR and other entropy sources. The seed is randomly initialized for each new instance of RandomState using only ASLR and a mixing step.

On targets without atomic pointer support, the global secrets will not be randomized, and instead will fall back to the default secrets. This means these platforms will not have minimal HashDoS resistance guarantees. If this is important for your application, please raise a GitHub issue to improve support for these platforms.

Example

use std::collections::HashMap;
use std::hash::Hasher;

use rapidhash::quality::RandomState;

let mut map = HashMap::with_hasher(RandomState::default());
map.insert(42, "the answer");

Implementations

impl<const AVALANCHE: bool, const SPONGE: bool, const COMPACT: bool, const PROTECTED: bool> RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>

pub fn new() -> Self

Create a new random state with a random seed.

The seed is always randomized by using ASLR on every new instance of RandomState.

With the rand feature enabled, the secrets will be randomized using [rand::random]. Otherwise, a mix of ASLR and some other poorer sources of entropy will be mixed together to generate the secrets. The secrets are statically cached for the lifetime of the program after their initial generation.

On platforms that do not support atomic pointers, the secrets will be the default rapidhash secrets, which are not randomized. Therefore, targets without atomic pointer support will not have minimal HashDoS resistance guarantees.

Trait Implementations

impl<const AVALANCHE: bool, const SPONGE: bool, const COMPACT: bool, const PROTECTED: bool> BuildHasher for RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>

type Hasher = RapidHasher<'static, AVALANCHE, SPONGE, COMPACT, PROTECTED>

Type of the hasher that will be created.

fn build_hasher(&self) -> Self::Hasher

Creates a new hasher.

fn hash_one<T>(&self, x: T) -> u64

where T: Hash, Self: Sized, Self::Hasher: Hasher,

Calculates the hash of a single value.

impl<const AVALANCHE: bool, const SPONGE: bool, const COMPACT: bool, const PROTECTED: bool> Clone for RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>

fn clone(&self) -> RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const AVALANCHE: bool, const SPONGE: bool, const COMPACT: bool, const PROTECTED: bool> Copy for RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>

impl<const AVALANCHE: bool, const SPONGE: bool, const COMPACT: bool, const PROTECTED: bool> Debug for RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>

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

Formats the value using the given formatter.

impl<const AVALANCHE: bool, const SPONGE: bool, const COMPACT: bool, const PROTECTED: bool> Default for RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>

Warning that RandomState only randomizes the seed on platforms that support atomic pointers.

fn default() -> Self

Returns the “default value” for a type.

impl<const AVALANCHE: bool, const SPONGE: bool, const COMPACT: bool, const PROTECTED: bool> Eq for RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>

impl<const AVALANCHE: bool, const SPONGE: bool, const COMPACT: bool, const PROTECTED: bool> PartialEq for RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>

fn eq(&self, other: &RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>) -> 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<const AVALANCHE: bool, const SPONGE: bool, const COMPACT: bool, const PROTECTED: bool> StructuralPartialEq for RandomState<AVALANCHE, SPONGE, COMPACT, PROTECTED>