Struct RandomState

pub struct RandomState { pub(in ::hash::random) k0: u64, pub(in ::hash::random) k1: u64 }

RandomState is the default state for HashMap types.

A particular instance RandomState will create the same instances of Hasher, but the hashers created by two different RandomState instances are unlikely to produce the same result for the same values.

Examples

use std::collections::HashMap;
use std::hash::RandomState;

let s = RandomState::new();
let mut map = HashMap::with_hasher(s);
map.insert(1, 2);

Fields

k0: u64
k1: u64

Implementations

impl RandomState

fn new() -> RandomState

Constructs a new RandomState that is initialized with random keys.

Examples

use std::hash::RandomState;

let s = RandomState::new();

Trait Implementations

impl BuildHasher for RandomState

type Hasher = DefaultHasher;
fn build_hasher(&self) -> DefaultHasher

impl Clone for RandomState

fn clone(&self) -> RandomState

impl Debug for RandomState

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

impl Default for RandomState

fn default() -> RandomState

Constructs a new RandomState.

Auto Trait Implementations

impl Freeze for RandomState

impl RefUnwindSafe for RandomState

impl Send for RandomState

impl Sync for RandomState

impl Unpin for RandomState

impl UnsafeUnpin for RandomState

impl UnwindSafe for RandomState

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> CloneToUninit for RandomState where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for RandomState

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SizeHint for RandomState where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for RandomState

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

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

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

fn into(self) -> U

Calls U::from(self).

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

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

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

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

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