Struct ahash::random_state::RandomState

source · [−]

pub struct RandomState { /* private fields */ }

Expand description

Provides a Hasher factory. This is typically used (e.g. by HashMap) to create AHashers in order to hash the keys of the map. See build_hasher below.

There are multiple constructors each is documented in more detail below:

Constructor	Dynamically random?	Seed
`new`	Each instance unique	RandomSource
`generate_with`	Each instance unique	`u64` x 4 + RandomSource
`with_seed`	Fixed per process	`u64` + static random number
`with_seeds`	Fixed	`u64` x 4

Implementations

source

impl RandomState

source

pub fn new() -> RandomState

Create a new RandomState BuildHasher using random keys.

Each instance will have a unique set of keys derived from RandomSource.

source

pub fn generate_with(k0: u64, k1: u64, k2: u64, k3: u64) -> RandomState

Create a new RandomState BuildHasher based on the provided seeds, but in such a way that each time it is called the resulting state will be different and of high quality. This allows fixed constant or poor quality seeds to be provided without the problem of different BuildHashers being identical or weak.

This is done via permuting the provided values with the value of a static counter and memory address. (This makes this method somewhat more expensive than with_seeds below which does not do this).

The provided values (k0-k3) do not need to be of high quality but they should not all be the same value.

source

pub fn with_seed(key: usize) -> RandomState

Build a RandomState from a single key. The provided key does not need to be of high quality, but all RandomStates created from the same key will produce identical hashers. (In contrast to generate_with above)

This allows for explicitly setting the seed to be used.

Note: This method does not require the provided seed to be strong.

source

pub const fn with_seeds(k0: u64, k1: u64, k2: u64, k3: u64) -> RandomState

Allows for explicitly setting the seeds to used. All RandomStates created with the same set of keys key will produce identical hashers. (In contrast to generate_with above)

Note: If DOS resistance is desired one of these should be a decent quality random number. If 4 high quality random number are not cheaply available this method is robust against 0s being passed for one or more of the parameters or the same value being passed for more than one parameter. It is recommended to pass numbers in order from highest to lowest quality (if there is any difference).

source

pub fn hash_one<T: Hash>(&self, x: T) -> u64where
Self: Sized,

Calculates the hash of a single value. This provides a more convenient (and faster) way to obtain a hash: For example: This is similar to: (Note that these two ways to get a hash may not produce the same value for the same data)

This is intended as a convenience for code which consumes hashes, such as the implementation of a hash table or in unit tests that check whether a custom Hash implementation behaves as expected.

This must not be used in any code which creates hashes, such as in an implementation of Hash. The way to create a combined hash of multiple values is to call Hash::hash multiple times using the same Hasher, not to call this method repeatedly and combine the results.

Trait Implementations

source

impl BuildHasher for RandomState

source

fn build_hasher(&self) -> AHasher

Constructs a new AHasher with keys based on this RandomState object. This means that two different RandomStates will will generate AHashers that will return different hashcodes, but Hashers created from the same BuildHasher will generate the same hashes for the same input data.