# Struct ahash::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.

## Implementations

source

### impl RandomState

source

#### pub fn set_random_source(
source: impl RandomSource + Send + Sync + 'static
) -> Result<(), bool>

Provides an optional way to manually supply a source of randomness for Hasher keys.

The provided [RandomSource] will be used to be used as a source of randomness by RandomState to generate new states. If this method is not invoked the standard source of randomness is used as described in the Readme.

The source of randomness can only be set once, and must be set before the first RandomState is created. If the source has already been specified `Err` is returned with a `bool` indicating if the set failed because method was previously invoked (true) or if the default source is already being used (false).

source

#### pub fn new() -> RandomState

Use randomly generated keys

source

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

Allows for supplying seeds, but each time it is called the resulting state will be different. This is done using a static counter, so it can safely be used with a fixed keys.

source

#### pub fn with_seed(key: usize) -> RandomState

Allows for explicitly setting a seed to 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.

Note: 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.

## 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.

##### Examples

    use ahash::{AHasher, RandomState};
    use std::hash::{Hasher, BuildHasher};

    let build_hasher = RandomState::new();
    let mut hasher_1 = build_hasher.build_hasher();
    let mut hasher_2 = build_hasher.build_hasher();

    hasher_1.write_u32(1234);
    hasher_2.write_u32(1234);

    assert_eq!(hasher_1.finish(), hasher_2.finish());

    let other_build_hasher = RandomState::new();
    let mut different_hasher = other_build_hasher.build_hasher();
    different_hasher.write_u32(1234);
    assert_ne!(different_hasher.finish(), hasher_1.finish());

#### type Hasher = AHasher

Type of the hasher that will be created.

source

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

🔬 This is a nightly-only experimental API. (`build_hasher_simple_hash_one`)

Calculates the hash of a single value. Read more

source

### impl Clone for RandomState

source

#### fn clone(&self) -> RandomState

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

source

### impl Debug for RandomState

source

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

Formats the value using the given formatter. Read more

source

### impl Default for RandomState

source

#### fn default() -> Self

Returns the “default value” for a type. Read more

## Auto Trait Implementations

### impl RefUnwindSafe for RandomState

### impl Send for RandomState

### impl Sync for RandomState

### impl Unpin for RandomState

### impl UnwindSafe for RandomState

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.