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
109
110
111
112
113
114

use std::{marker::PhantomData, ops::RangeInclusive};

use smallvec::{Array, SmallVec};

use crate::{IntoCellIter, range::Range};

pub trait Mapper<T, A> {
    type Entry;
    type Input;
    type Output: IntoCellIter<A>;

    fn insert(
        vec: &mut SmallVec<impl Array<Item = Self::Entry>>,
        key: T,
        entity: Self::Input,
    ) -> Self::Output;
    fn remove(vec: &mut SmallVec<impl Array<Item = Self::Entry>>, key: &T) -> Option<Self::Output>;
}

pub struct RangeMapper<T, A>(PhantomData<(T, A)>);

impl<T: Copy + Eq, A: Copy + Eq> Mapper<T, A> for RangeMapper<T, A>
where
    RangeInclusive<A>: Iterator<Item = A>,
{
    type Entry = (T, Range<A>);
    type Input = Range<A>;
    type Output = Range<A>;

    #[inline(always)]
    fn insert(
        vec: &mut SmallVec<impl Array<Item = Self::Entry>>,
        key: T,
        range: Self::Input,
    ) -> Self::Output {
        vec.push((key, range));
        range
    }

    #[inline(always)]
    fn remove(vec: &mut SmallVec<impl Array<Item = Self::Entry>>, key: &T) -> Option<Self::Output> {
        let i = vec.iter().position(|(id, _)| id == key)?;
        let (_, range) = vec.swap_remove(i);
        Some(range)
    }
}

pub struct RangeOneMapper<T, A>(PhantomData<(T, A)>);

impl<T: Copy + Eq, A: Copy + Eq> Mapper<T, A> for RangeOneMapper<T, A>
where
    RangeInclusive<A>: Iterator<Item = A>,
{
    type Entry = (T, [A; 2]);
    type Input = Range<A>;
    type Output = Range<A>;

    #[inline(always)]
    fn insert(
        vec: &mut SmallVec<impl Array<Item = Self::Entry>>,
        key: T,
        range: Self::Input,
    ) -> Self::Output {
        // assert!(vec.iter().all(|(id, _)| *id != key));
        vec.push((key, range.min));
        if range.min != range.max {
            vec.push((key, range.max));
        }
        range
    }

    #[inline(always)]
    fn remove(vec: &mut SmallVec<impl Array<Item = Self::Entry>>, key: &T) -> Option<Self::Output> {
        let i = vec.iter().position(|(id, _)| id == key)?;
        let (_, min) = vec.remove(i);
        let max = if let Some((id, _)) = vec.get(i)
            && id == key
        {
            let (_, max) = vec.remove(i);
            max
        } else {
            min
        };
        Some(Range::new(min, max))
    }
}

pub struct OneMapper<T, A>(PhantomData<(T, A)>);

impl<T: Copy + Eq, A: Copy + Eq> Mapper<T, A> for OneMapper<T, A>
where
    RangeInclusive<A>: Iterator<Item = A>,
{
    type Entry = (T, [A; 2]);
    type Input = [A; 2];
    type Output = [[A; 2]; 1];

    #[inline(always)]
    fn insert(
        vec: &mut SmallVec<impl Array<Item = Self::Entry>>,
        key: T,
        entity: Self::Input,
    ) -> Self::Output {
        vec.push((key, entity));
        [entity]
    }

    #[inline(always)]
    fn remove(vec: &mut SmallVec<impl Array<Item = Self::Entry>>, key: &T) -> Option<Self::Output> {
        let i = vec.iter().position(|(id, _)| id == key)?;
        let (_, entity) = vec.swap_remove(i);
        Some([entity])
    }
}