seedable_hash 0.2.3

The library for calculating seedable hashes and fast reduction of their ranges.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

#![doc = include_str!("../README.md")]

mod map;
pub use map::{map16_to_16, map32_to_32, map64_to_32, map64_to_64, map_usize};

use std::hash::{BuildHasher, Hash, Hasher};

/// Family of hash functions that allows the creation of
/// [`Hasher`] instances initialized with a given seed.
pub trait BuildSeededHasher {
    type Hasher: Hasher;

    /// Creates a new hasher initialized with the given 64-bit `seed`.
    fn build_hasher(&self, seed: u64) -> Self::Hasher;

    /// Calculates the hash of a single value `x`, using given 64-bit `seed`.
    #[inline(always)]
    fn hash_one<T: Hash>(&self, x: T, seed: u64) -> u64 {
        let mut h = self.build_hasher(seed);
        x.hash(&mut h);
        h.finish()
    }
}

/// [`BuildSeededHasher`] that uses standard [`BuildHasher`].
#[derive(Default, Copy, Clone)]
pub struct Seedable<BH: BuildHasher + Clone>(pub BH);

impl<BH: BuildHasher + Clone> BuildSeededHasher for Seedable<BH> {
    type Hasher = BH::Hasher;

    #[inline(always)]
    fn build_hasher(&self, seed: u64) -> Self::Hasher {
        let mut result = self.0.build_hasher();
        result.write_u64(seed);
        result
    }
}

/// [`BuildSeededHasher`] that uses [`std::hash::SipHasher13`].
#[cfg(feature = "sip13")]
#[derive(Default, Copy, Clone)]
pub struct BuildSip13;

#[cfg(feature = "sip13")]
#[allow(deprecated)]
impl BuildSeededHasher for BuildSip13 {
    #[allow(deprecated)]
    type Hasher = std::hash::SipHasher13;

    #[inline] fn build_hasher(&self, seed: u64) -> Self::Hasher {
        Self::Hasher::new_with_keys(seed, seed)
    }
}

/// [`BuildSeededHasher`] that uses `wyhash` crate.
#[cfg(feature = "wyhash")]
#[cfg_attr(feature = "epserde", derive(epserde::Epserde), repr(C), epserde_zero_copy)]
#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
#[derive(Default, Copy, Clone)]
pub struct BuildWyHash;

#[cfg(feature = "wyhash")]
impl BuildSeededHasher for BuildWyHash {
    type Hasher = wyhash::WyHash;

    #[inline]
    fn build_hasher(&self, seed: u64) -> Self::Hasher {
        Self::Hasher::with_seed(seed)
    }
}

/// [`BuildSeededHasher`] that uses `Xxh3` from `xxhash_rust` crate.
#[cfg(feature = "xxhash-rust")]
#[cfg_attr(feature = "epserde", derive(epserde::Epserde), repr(C), epserde_zero_copy)]
#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
#[derive(Default, Copy, Clone)]
pub struct BuildXxh3;

#[cfg(feature = "xxhash-rust")]
impl BuildSeededHasher for BuildXxh3 {
    type Hasher = xxhash_rust::xxh3::Xxh3;

    #[inline]
    fn build_hasher(&self, seed: u64) -> Self::Hasher {
        Self::Hasher::with_seed(seed)
    }
}

/// [`BuildSeededHasher`] that uses `fnv` crate.
#[cfg(feature = "fnv")]
impl BuildSeededHasher for fnv::FnvBuildHasher {
    type Hasher = fnv::FnvHasher;

    #[inline] fn build_hasher(&self, seed: u64) -> Self::Hasher {
        Self::Hasher::with_key(seed as u64)
    }
}

/// [`BuildSeededHasher`] that uses `GxHasher` from `gxhash` crate.
#[cfg(feature = "gxhash")]
#[cfg_attr(feature = "epserde", derive(epserde::Epserde), repr(C), epserde_zero_copy)]
#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
#[derive(Default, Copy, Clone)]
pub struct BuildGxHash;

//type BuildGxHash = gxhash::GxBuildHasher;

#[cfg(feature = "gxhash")]
impl BuildSeededHasher for BuildGxHash {
    type Hasher = gxhash::GxHasher;

    #[inline] fn build_hasher(&self, seed: u64) -> Self::Hasher {
        Self::Hasher::with_seed(seed as i64)
    }
}

/// [`BuildSeededHasher`] that uses `rapidhash::RapidHasher`.
#[cfg(feature = "rapidhash")]
#[cfg_attr(feature = "epserde", derive(epserde::Epserde), repr(C), epserde_zero_copy)]
#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
#[derive(Default, Copy, Clone)]
pub struct BuildRapidHash;

#[cfg(feature = "rapidhash")]
impl BuildSeededHasher for BuildRapidHash {
    type Hasher = rapidhash::RapidHasher;

    #[inline] fn build_hasher(&self, seed: u64) -> Self::Hasher {
        Self::Hasher::new(seed as u64)
    }
}

/// The default [`BuildSeededHasher`].
#[cfg(feature = "gxhash")]
pub type BuildDefaultSeededHasher = BuildGxHash;

/// The default [`BuildSeededHasher`].
#[cfg(all(feature = "wyhash", not(feature = "gxhash")))]
pub type BuildDefaultSeededHasher = BuildWyHash;

/// The default [`BuildSeededHasher`].
#[cfg(all(feature = "xxhash-rust", not(feature = "gxhash"), not(feature = "wyhash")))]
pub type BuildDefaultSeededHasher = BuildXxh3;

/// The default [`BuildSeededHasher`].
#[cfg(all(feature = "rapidhash", not(feature = "gxhash"), not(feature = "wyhash"), not(feature = "xxhash-rust")))]
pub type BuildDefaultSeededHasher = BuildRapidHash;

/// The default [`BuildSeededHasher`].
#[cfg(all(feature = "sip13", not(feature = "gxhash"), not(feature = "wyhash"), not(feature = "xxhash-rust"), not(feature = "rapidhash")))]
pub type BuildDefaultSeededHasher = BuildSip13;

/// The default [`BuildSeededHasher`].
#[cfg(all(feature = "fnv", not(feature = "gxhash"), not(feature = "wyhash"), not(feature = "xxhash-rust"), not(feature = "rapidhash"), not(feature = "sip13")))]
pub type BuildDefaultSeededHasher = fnv::FnvBuildHasher;

/// The default [`BuildSeededHasher`].
#[cfg(all(not(feature = "gxhash"), not(feature = "wyhash"), not(feature = "xxhash-rust"), not(feature = "rapidhash"), not(feature = "sip13"), not(feature = "fnv")))]
pub type BuildDefaultSeededHasher = Seedable<std::hash::BuildHasherDefault<std::collections::hash_map::DefaultHasher>>;