icentral_mindexed_map/
maybe_indexed_map.rs

1crate::ix!();
2
3pub trait CreateEmptyIndexed {
4
5    fn empty_indexed(name: &str) -> Self;
6}
7
8pub trait CreateEmptyMapped {
9
10    fn empty_mapped(name: &str) -> Self;
11}
12
13error_tree!{
14
15    pub enum InitMapError {
16        TriedReinitMappedObject,
17    }
18}
19
20#[derive(Clone)]
21pub enum MaybeIndexedMap<T: Clone> {
22    Indexed(Vec<T>),
23    Mapped(HashMap<NodeId,T>),
24}
25
26impl<T: Clone + Debug> fmt::Debug for MaybeIndexedMap<T> {
27
28    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
29
30        match self {
31            MaybeIndexedMap::Indexed(v) => {
32                fmt.debug_map()
33                    .entries(v.iter().enumerate())
34                    .finish()
35            }
36            MaybeIndexedMap::Mapped(m) => {
37                fmt.debug_map()
38                    .entries(m.iter())
39                    .finish()
40            }
41        }
42    }
43}
44
45impl<T: Clone> GetNodeIdRange for MaybeIndexedMap<T> {
46
47    fn nodeid_range(&self)
48    -> Vec<NodeId>
49    {
50        let keys = self.keys();
51
52        let len = keys.len();
53
54        keys[0..len].into_iter().cloned().collect()
55    }
56}
57
58impl<T: Clone> GetLimitedNodeIdRange for MaybeIndexedMap<T> {
59
60    fn limited_nodeid_range(&self, cap: Option<usize>) 
61    -> Vec<NodeId>
62    {
63        match cap {
64            None => {
65                self.nodeid_range()
66            }
67            Some(n) => {
68
69                let keys = self.keys();
70
71                let top  = min(n,keys.len());
72
73                keys[0..top].into_iter().cloned().collect()
74            }
75        }
76    }
77}
78
79impl<T: Clone> MaybeIndexedMap<T> {
80
81    pub fn set(&mut self, node: NodeId, rhs: T) {
82        match self {
83            MaybeIndexedMap::Indexed(v) => {
84
85                if node.val() < v.len() {
86                    v[node.val()] = rhs;
87                } else {
88                    panic!("attempt to set OOB for Indexed Map. NodeId: {}, len: {}", node, v.len());
89                }
90            }
91            MaybeIndexedMap::Mapped(m) => {
92                m.insert(node,rhs);
93            }
94        }
95    }
96
97    pub fn empty_indexed() -> Self {
98        Self::Indexed(vec![])
99    }
100
101    pub fn empty_mapped() -> Self {
102        Self::Mapped(HashMap::new())
103    }
104
105    pub fn new(len: usize, val: T) -> Self {
106        Self::Indexed(vec![val;len])
107    }
108
109    pub fn iter(&self) -> MaybeIndexedMapIterator<'_,T> {
110        match self {
111            MaybeIndexedMap::Indexed(v) => {
112                MaybeIndexedMapIterator::new_indexed(v.iter())
113            }
114            MaybeIndexedMap::Mapped(m) => {
115                MaybeIndexedMapIterator::new_mapped(m.iter())
116            }
117        }
118    }
119
120    pub fn extend(&mut self, other: &MaybeIndexedMap<T>) {
121        match (self,other) {
122            (MaybeIndexedMap::Mapped(ref mut m1), MaybeIndexedMap::Mapped(ref m2)) => {
123                m1.extend(m2.clone());
124            }
125            _ => {
126                panic!("this should probably not be supported because it implies we may be mixing apples with oranges");
127            }
128        }
129    }
130
131    pub fn contains(&self, node: NodeId) -> bool {
132        match self {
133            MaybeIndexedMap::Indexed(v) => {
134                v.len() > node.val()
135            }
136            MaybeIndexedMap::Mapped(m) => {
137                m.contains_key(&node)
138            }
139        }
140    }
141
142    pub fn remove(&mut self, node: NodeId) {
143        match self {
144            MaybeIndexedMap::Indexed(v) => {
145                v.remove(node.val());
146            }
147            MaybeIndexedMap::Mapped(m) => {
148                m.remove(&node);
149            }
150        }
151    }
152
153    pub fn fill(&mut self, val: T) {
154        match self {
155            MaybeIndexedMap::Indexed(v) => {
156                v.fill(val);
157            }
158            MaybeIndexedMap::Mapped(m) => {
159                m.values_mut().for_each(|v| *v = val.clone());
160            }
161        }
162    }
163
164    pub fn reserve(&mut self, len: usize) {
165        match self {
166            MaybeIndexedMap::Indexed(v) => {
167                v.reserve(len);
168            }
169            MaybeIndexedMap::Mapped(m) => {
170                m.reserve(len);
171            }
172        }
173    }
174
175    pub fn refill(&mut self, len: usize, val: T) {
176
177        self.clear();
178
179        match self {
180            MaybeIndexedMap::Indexed(v) => {
181
182                trace!("refilling Indexed Map");
183                v.reserve(1);
184
185                v.resize(len,val);
186            }
187            MaybeIndexedMap::Mapped(m) => {
188
189                let additional = len - m.len();
190
191                trace!(
192                    "refilling KV Mapped Map, len: {}. m.len(): {}, additional: {}", 
193                    len, 
194                    m.len(),
195                    additional
196                );
197
198                m.reserve(additional);
199
200                m.values_mut().for_each(|v| *v = val.clone());
201            }
202        }
203    }
204
205    pub fn clear(&mut self) {
206
207        match self {
208            MaybeIndexedMap::Indexed(v) => {
209                v.clear();
210            }
211            MaybeIndexedMap::Mapped(m) => {
212                m.clear();
213            }
214        }
215    }
216
217    pub fn len(&self) -> usize {
218        match self {
219            MaybeIndexedMap::Indexed(v) => {
220                v.len()
221            }
222            MaybeIndexedMap::Mapped(m) => {
223                m.len()
224            }
225        }
226    }
227
228    pub fn keys(&self) -> Vec<NodeId> 
229    {
230        match self {
231            MaybeIndexedMap::Indexed(v) => (0..v.len()).map(|x| nodeid![x]).collect(),
232            MaybeIndexedMap::Mapped(m)  => m.keys().cloned().collect(),
233        }
234    }
235}
236
237impl<T: Clone> Default for MaybeIndexedMap<T> {
238
239    fn default() -> Self {
240        Self::Mapped(HashMap::new())
241    }
242}
243
244impl<T: Clone> Index<NodeId> for MaybeIndexedMap<T> {
245
246    type Output = T;
247
248    fn index(&self, idx: NodeId) -> &Self::Output {
249
250        match self {
251            MaybeIndexedMap::Indexed(v) => {
252                &v[idx.val()]
253            }
254            MaybeIndexedMap::Mapped(m) => {
255                &m[&idx]
256            }
257        }
258    }
259}
260
261impl<T: Clone + Default> IndexMut<NodeId> for MaybeIndexedMap<T> {
262
263    fn index_mut(&mut self, idx: NodeId) 
264    -> &mut Self::Output 
265    {
266        match self {
267            MaybeIndexedMap::Indexed(ref mut v) => {
268                &mut v[idx.val()]
269            }
270            MaybeIndexedMap::Mapped(ref mut m) => {
271
272                //autovivify
273                if m.get(&idx).is_none() {
274                    m.insert(idx, T::default());
275                }
276
277                m.get_mut(&idx).unwrap()
278            }
279        }
280    }
281}
282
283impl<T: Clone> Index<Range<NodeId>> for MaybeIndexedMap<T> {
284
285    type Output = [T];
286
287    fn index(&self, range: Range<NodeId>) -> &Self::Output {
288        match self {
289            MaybeIndexedMap::Indexed(ref v) => {
290                &v.as_slice()[range.start.val()..range.end.val()]
291            }
292            MaybeIndexedMap::Mapped(ref m) => {
293                unimplemented!();
294            }
295        }
296    }
297}
298
299impl<T: Clone> IndexMut<Range<NodeId>> for MaybeIndexedMap<T> {
300
301    fn index_mut(&mut self, range: Range<NodeId>) -> &mut Self::Output {
302        match self {
303            MaybeIndexedMap::Indexed(ref mut v) => {
304                &mut v.as_mut_slice()[range.start.val()..range.end.val()]
305            }
306            MaybeIndexedMap::Mapped(ref mut m) => {
307                unimplemented!();
308            }
309        }
310    }
311}
312
313impl MaybeIndexedMap<f64> {
314
315    pub fn halve(&mut self) {
316        match self {
317            MaybeIndexedMap::Indexed(v) => {
318                for item in v.iter_mut() {
319                    *item /= 2.0;
320                }
321            }
322            MaybeIndexedMap::Mapped(m) => {
323                for (k,v) in m.iter_mut() {
324                    *v /= 2.0;
325                }
326            }
327        }
328    }
329}
icentral_mindexed_map/maybe_indexed_map.rs

icentral_mindexed_map/
maybe_indexed_map.rs
