too 0.2.0

too - a tui framework
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

use std::hash::BuildHasherDefault;

/// A hasher that uses a `u64` as-in.
///
/// This doesn't actually hash the value.
///
/// This is useful if you already have a pre-hashed value
#[derive(Default)]
pub struct IntHasher(u64);

impl std::hash::Hasher for IntHasher {
    #[inline(always)]
    fn finish(&self) -> u64 {
        self.0
    }

    #[inline(always)]
    fn write_u64(&mut self, i: u64) {
        self.0 = i
    }

    #[inline(never)]
    fn write(&mut self, _: &[u8]) {
        unreachable!()
    }
}

/// A [`BuildHasher`](std::hash::BuildHasher) for [`IntHasher`]
#[derive(Default)]
pub struct BuildIntHasher;

impl std::hash::BuildHasher for BuildIntHasher {
    type Hasher = IntHasher;

    fn build_hasher(&self) -> Self::Hasher {
        IntHasher(0)
    }
}

/// A [`BuildHasherDefault`] for [`IntHasher`]
pub type DefaultIntHasher = BuildHasherDefault<IntHasher>;

#[inline(always)]
pub(crate) const fn hash_fnv_1a(bytes: &[u8]) -> u64 {
    let mut hash = 0xcbf29ce484222325;
    let mut index = 0;
    while index < bytes.len() {
        hash ^= bytes[index] as u64;
        hash = hash.wrapping_mul(0x100000001b3);
        index += 1;
    }
    hash
}