1
use std::hash::BuildHasher;
2
use std::hash::Hasher;
3

            
4
/// A hasher that directly uses the value provided to write_u64 as the hash
5
pub struct NoHasher(pub u64);
6

            
7
impl Hasher for NoHasher {
8
    /// Returns the current value as the hash
9
715641060
    fn finish(&self) -> u64 {
10
715641060
        self.0
11
715641060
    }
12

            
13
    fn write(&mut self, _bytes: &[u8]) {
14
        unimplemented!("NoHasher only supports write_u64");
15
    }
16

            
17
715641059
    fn write_u64(&mut self, i: u64) {
18
715641059
        self.0 = i;
19
715641059
    }
20
}
21

            
22
/// A builder for NoHasher. Starts with a hash of 0 and returns whatever value is passed to write_u64
23
#[derive(Default)]
24
pub struct NoHasherBuilder;
25

            
26
impl BuildHasher for NoHasherBuilder {
27
    type Hasher = NoHasher;
28

            
29
715641059
    fn build_hasher(&self) -> Self::Hasher {
30
715641059
        NoHasher(0)
31
715641059
    }
32
}
33

            
34
#[cfg(test)]
35
mod tests {
36
    use std::hash::BuildHasher;
37
    use std::hash::Hasher;
38

            
39
    use crate::NoHasher;
40
    use crate::NoHasherBuilder;
41

            
42
    #[test]
43
1
    fn test_no_hasher() {
44
1
        let mut hasher = NoHasher(0);
45
1
        hasher.write_u64(42);
46
1
        assert_eq!(
47
1
            hasher.finish(),
48
            42,
49
            "NoHasher should return the value passed to write_u64"
50
        );
51

            
52
1
        let builder = NoHasherBuilder;
53
1
        let hasher = builder.build_hasher();
54
1
        assert_eq!(
55
1
            hasher.finish(),
56
            0,
57
            "NoHasherBuilder should create a hasher with initial value 0"
58
        );
59
1
    }
60
}