Struct cursive::reexports::ahash::RandomState

pub struct RandomState { /* private fields */ }

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

impl RandomState

pub fn new() -> RandomState

Use randomly generated keys

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.

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.

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.

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

Calculates the hash of a single value.

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

impl BuildHasher for RandomState

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());

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

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

Calculates the hash of a single value.

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.

type Hasher = AHasher

Type of the hasher that will be created.

impl Clone for RandomState

fn clone(&self) -> RandomState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RandomState

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

Formats the value using the given formatter.

impl Default for RandomState

fn default() -> RandomState

Returns the “default value” for a type.