hashgrid 0.1.0

A 2D spatial-hash grid library
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

use std::hash::Hasher;

macro_rules! write_impl {
    (($self:ident, $i:ident) $body:block; $($name:ident($type:ty),)+) => {
        $(
            #[inline(always)]
            fn $name(&mut $self, $i: $type) $body
        )*
    }
}

/// A dummy hasher that always does nothing except returning the input.
#[derive(Default)]
pub struct DummyHasher {
    hash: u64,
}

impl Hasher for DummyHasher {
    #[inline]
    fn finish(&self) -> u64 {
        self.hash
    }

    #[inline(always)]
    fn write(&mut self, bytes: &[u8]) {
        self.hash = u64::from_ne_bytes(bytes.try_into().unwrap());
    }

    write_impl!(
        (self, i) {
            self.hash = self.hash | i as u64;
        };
        write_u8(u8),
        write_u16(u16),
        write_u32(u32),
        write_u64(u64),
        write_u128(u128),
        write_usize(usize),
    );
}

#[derive(Default)]
pub struct InterleaveHasher {
    hash: u64,
}

impl Hasher for InterleaveHasher {
    #[inline]
    fn finish(&self) -> u64 {
        self.hash
    }

    #[inline(always)]
    fn write(&mut self, _bytes: &[u8]) {
        panic!("No implementation");
    }

    write_impl!(
        (self, i) {
            self.hash = self.hash << 32 | i as u64;
        };
        write_u8(u8),
        write_u16(u16),
        write_u32(u32),
        write_u64(u64),
        write_u128(u128),
        write_usize(usize),
    );
}

#[cfg(feature = "morton")]
pub use morton::*;

#[cfg(feature = "morton")]
mod morton {
    use super::*;

    #[derive(Default)]
    pub struct MortonHasher {
        hash: [u32; 2],
        i: usize,
    }

    impl Hasher for MortonHasher {
        #[inline]
        fn finish(&self) -> u64 {
            morton_encoding::morton_encode(self.hash)
        }

        #[inline(always)]
        fn write(&mut self, _bytes: &[u8]) {
            panic!("No implementation");
        }

        write_impl!(
            (self, i) {
                self.hash[self.i] = i as u32;
                self.i += 1;
            };
            write_u8(u8),
            write_u16(u16),
            write_u32(u32),
            write_u64(u64),
            write_u128(u128),
            write_usize(usize),
        );
    }
}