building_blocks_storage 0.7.1

Efficient storage for maps on sparse or dense, 2D and 3D integer lattices.
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
115
116
117

use crate::{ChunkMap, ChunkMapBuilder, SmallKeyHashMap};

use super::{ChunkKey, ChunkReadStorage, ChunkWriteStorage, IterChunkKeys};

use core::hash::Hash;
use std::collections::hash_map;

impl<N, Ch> ChunkReadStorage<N, Ch> for SmallKeyHashMap<ChunkKey<N>, Ch>
where
    ChunkKey<N>: Hash + Eq,
{
    #[inline]
    fn get(&self, key: ChunkKey<N>) -> Option<&Ch> {
        self.get(&key)
    }
}

impl<N, Ch> ChunkWriteStorage<N, Ch> for SmallKeyHashMap<ChunkKey<N>, Ch>
where
    ChunkKey<N>: Hash + Eq,
{
    #[inline]
    fn get_mut(&mut self, key: ChunkKey<N>) -> Option<&mut Ch> {
        self.get_mut(&key)
    }

    #[inline]
    fn get_mut_or_insert_with(
        &mut self,
        key: ChunkKey<N>,
        create_chunk: impl FnOnce() -> Ch,
    ) -> &mut Ch {
        self.entry(key).or_insert_with(create_chunk)
    }

    #[inline]
    fn replace(&mut self, key: ChunkKey<N>, chunk: Ch) -> Option<Ch> {
        self.insert(key, chunk)
    }

    #[inline]
    fn write(&mut self, key: ChunkKey<N>, chunk: Ch) {
        self.insert(key, chunk);
    }

    #[inline]
    fn delete(&mut self, key: ChunkKey<N>) {
        self.remove(&key);
    }

    #[inline]
    fn pop(&mut self, key: ChunkKey<N>) -> Option<Ch> {
        self.remove(&key)
    }
}

impl<'a, N, Ch> IterChunkKeys<'a, N> for SmallKeyHashMap<ChunkKey<N>, Ch>
where
    ChunkKey<N>: 'a,
    Ch: 'a,
{
    type Iter = hash_map::Keys<'a, ChunkKey<N>, Ch>;

    fn chunk_keys(&'a self) -> Self::Iter {
        self.keys()
    }
}

/// A `ChunkMap` using `HashMap` as chunk storage.
pub type ChunkHashMap<N, T, Bldr> =
    ChunkMap<N, T, Bldr, SmallKeyHashMap<ChunkKey<N>, <Bldr as ChunkMapBuilder<N, T>>::Chunk>>;
/// A 2-dimensional `ChunkHashMap`.
pub type ChunkHashMap2<T, Bldr> = ChunkHashMap<[i32; 2], T, Bldr>;
/// A 3-dimensional `ChunkHashMap`.
pub type ChunkHashMap3<T, Bldr> = ChunkHashMap<[i32; 3], T, Bldr>;

pub mod multichannel_aliases {
    use super::*;
    use crate::chunk::map::multichannel_aliases::*;

    /// An N-dimensional, 1-channel `ChunkHashMap`.
    pub type ChunkHashMapNx1<N, A> = ChunkHashMap<N, A, ChunkMapBuilderNx1<N, A>>;

    /// A 2-dimensional, 1-channel `ChunkHashMap`.
    pub type ChunkHashMap2x1<A> = ChunkHashMap2<A, ChunkMapBuilder2x1<A>>;
    /// A 2-dimensional, 2-channel `ChunkHashMap`.
    pub type ChunkHashMap2x2<A, B> = ChunkHashMap2<(A, B), ChunkMapBuilder2x2<A, B>>;
    /// A 2-dimensional, 3-channel `ChunkHashMap`.
    pub type ChunkHashMap2x3<A, B, C> = ChunkHashMap2<(A, B, C), ChunkMapBuilder2x3<A, B, C>>;
    /// A 2-dimensional, 4-channel `ChunkHashMap`.
    pub type ChunkHashMap2x4<A, B, C, D> =
        ChunkHashMap2<(A, B, C, D), ChunkMapBuilder2x4<A, B, C, D>>;
    /// A 2-dimensional, 5-channel `ChunkHashMap`.
    pub type ChunkHashMap2x5<A, B, C, D, E> =
        ChunkHashMap2<(A, B, C, D, E), ChunkMapBuilder2x5<A, B, C, D, E>>;
    /// A 2-dimensional, 6-channel `ChunkHashMap`.
    pub type ChunkHashMap2x6<A, B, C, D, E, F> =
        ChunkHashMap2<(A, B, C, D, E, F), ChunkMapBuilder2x6<A, B, C, D, E, F>>;

    /// A 3-dimensional, 1-channel `ChunkHashMap`.
    pub type ChunkHashMap3x1<A> = ChunkHashMap3<A, ChunkMapBuilder3x1<A>>;
    /// A 3-dimensional, 2-channel `ChunkHashMap`.
    pub type ChunkHashMap3x2<A, B> = ChunkHashMap3<(A, B), ChunkMapBuilder3x2<A, B>>;
    /// A 3-dimensional, 3-channel `ChunkHashMap`.
    pub type ChunkHashMap3x3<A, B, C> = ChunkHashMap3<(A, B, C), ChunkMapBuilder3x3<A, B, C>>;
    /// A 3-dimensional, 4-channel `ChunkHashMap`.
    pub type ChunkHashMap3x4<A, B, C, D> =
        ChunkHashMap3<(A, B, C, D), ChunkMapBuilder3x4<A, B, C, D>>;
    /// A 3-dimensional, 5-channel `ChunkHashMap`.
    pub type ChunkHashMap3x5<A, B, C, D, E> =
        ChunkHashMap3<(A, B, C, D, E), ChunkMapBuilder3x5<A, B, C, D, E>>;
    /// A 3-dimensional, 6-channel `ChunkHashMap`.
    pub type ChunkHashMap3x6<A, B, C, D, E, F> =
        ChunkHashMap3<(A, B, C, D, E, F), ChunkMapBuilder3x6<A, B, C, D, E, F>>;
}

pub use multichannel_aliases::*;