stdlib-rs 0.0.2

A Personal Standard Library in Rust
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

use std::hash::Hasher;

pub struct Fnv32Hasher(u32);
pub struct Fnv64Hasher(u64);

impl Fnv32Hasher {
    pub fn seed(seed: u32) -> Fnv32Hasher {
        Fnv32Hasher(seed)
    }
}

impl Default for Fnv32Hasher {
    fn default() -> Fnv32Hasher {
        Fnv32Hasher(2166136261)
    }
}

impl Hasher for Fnv32Hasher {
    fn write(&mut self, bytes: &[u8]) {
        for byte in bytes.iter() {
            self.0 = self.0 ^ (*byte as u32);
            self.0 = self.0.wrapping_mul(16777619);
        }
    }
    fn finish(&self) -> u64 {
        self.0.into()
    }
}

impl Fnv64Hasher {
    pub fn seed(seed: u64) -> Fnv64Hasher {
        Fnv64Hasher(seed)
    }
}

impl Default for Fnv64Hasher {
    fn default() -> Fnv64Hasher {
        Fnv64Hasher(14695981039346656037)
    }
}

impl Hasher for Fnv64Hasher {
    fn write(&mut self, bytes: &[u8]) {
        for byte in bytes.iter() {
            self.0 = self.0 ^ (*byte as u64);
            self.0 = self.0.wrapping_mul(1099511628211);
        }
    }
    fn finish(&self) -> u64 {
        self.0
    }
}

#[cfg(test)]
mod test {
    use super::*;

    fn fnv_64(bytes: &[u8]) -> u64 {
        let mut hasher = Fnv64Hasher::default();
        hasher.write(bytes);
        hasher.finish()
    }

    fn fnv_32(bytes: &[u8]) -> u64 {
        let mut hasher = Fnv32Hasher::default();
        hasher.write(bytes);
        hasher.finish()
    }

    #[test]
    fn empty() {
        assert_eq!(fnv_64(b""), 14695981039346656037);
        assert_eq!(fnv_32(b""), 2166136261);
    }
}