Trait core::hash::BuildHasher

pub trait BuildHasher {
    type Hasher: Hasher;

    // Required method
    fn build_hasher(&self) -> Self::Hasher;

    // Provided method
    fn hash_one<T: Hash>(&self, x: T) -> u64
       where Self: Sized,
             Self::Hasher: Hasher { ... }
}

用于创建 Hasher 实例的 trait。

BuildHasher 通常用于 (例如，由 HashMap 来) 为每个键创建 Hasher，使得它们彼此独立地进行哈希处理，因为 Hasher 包含状态。

对于 BuildHasher 的每个实例，由 build_hasher 创建的 Hasher 应该相同。 也就是说，如果将相同的字节流馈送到每个哈希器中，则还将生成相同的输出。

Examples

use std::collections::hash_map::RandomState;
use std::hash::{BuildHasher, Hasher};

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

hasher_1.write_u32(8128);
hasher_2.write_u32(8128);

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

Required Associated Types

type Hasher: Hasher

将创建的哈希器的类型。

Required Methods

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

创建一个新的哈希器。

在同一实例上对 build_hasher 的每次调用都应产生相同的 Hasher。

Examples

use std::collections::hash_map::RandomState;
use std::hash::BuildHasher;

let s = RandomState::new();
let new_s = s.build_hasher();

Provided Methods

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

计算单个值的哈希值。

这是为了方便消耗哈希的代码，例如哈希表的实现或在单元测试中检查自定义 Hash 实现是否按预期运行。

这不能用在任何创建哈希的代码中，例如在 Hash 的实现中。 创建多个值的组合哈希的方法是使用同一个 Hasher 多次调用 Hash::hash，而不是重复调用此方法并组合结果。

Example

use std::cmp::{max, min};
use std::hash::{BuildHasher, Hash, Hasher};
struct OrderAmbivalentPair<T: Ord>(T, T);
impl<T: Ord + Hash> Hash for OrderAmbivalentPair<T> {
    fn hash<H: Hasher>(&self, hasher: &mut H) {
        min(&self.0, &self.1).hash(hasher);
        max(&self.0, &self.1).hash(hasher);
    }
}

// 然后，在 `#[test]` 类型中...
let bh = std::collections::hash_map::RandomState::new();
assert_eq!(
    bh.hash_one(OrderAmbivalentPair(1, 2)),
    bh.hash_one(OrderAmbivalentPair(2, 1))
);
assert_eq!(
    bh.hash_one(OrderAmbivalentPair(10, 2)),
    bh.hash_one(&OrderAmbivalentPair(2, 10))
);

Implementors

impl<H: Default + Hasher> BuildHasher for BuildHasherDefault<H>

type Hasher = H