GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/qdk

Public

mirrored fromhttps://github.com/microsoft/qdkAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
alex/second-test-harness-take

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

qdk/compiler/qsc_data_structures/src

compiler/qsc_data_structures/src/index_map.rs

316lines · modecode

RawDownload
Latest commit unavailable.
1// Copyright (c) Microsoft Corporation.
2// Licensed under the MIT License.
3
4use std::{
5 fmt::{self, Debug, Formatter},
6 iter::Enumerate,
7 marker::PhantomData,
8 option::Option,
9 slice, vec,
10};
11
12pub struct IndexMap<K, V> {
13 _keys: PhantomData<K>,
14 values: Vec<Option<V>>,
15}
16
17impl<K, V> IndexMap<K, V>
18where
19 K: Into<usize>,
20 V: Default,
21{
22 pub fn get_mut_or_default(&mut self, key: K) -> &mut V {
23 let index: usize = key.into();
24 if index >= self.values.len() {
25 self.values.resize_with(index + 1, Option::default);
26 }
27 self.values
28 .get_mut(index)
29 .expect("IndexMap::get_mut_or_default: index out of bounds")
30 .get_or_insert_with(Default::default)
31 }
32}
33
34impl<K, V> IndexMap<K, V> {
35 #[must_use]
36 pub fn new() -> Self {
37 Self::default()
38 }
39
40 #[must_use]
41 pub fn is_empty(&self) -> bool {
42 self.values.is_empty()
43 }
44
45 // `Iter` does implement `Iterator`, but it has an additional bound on `K`.
46 #[allow(clippy::iter_not_returning_iterator)]
47 #[must_use]
48 pub fn iter(&self) -> Iter<K, V> {
49 Iter {
50 _keys: PhantomData,
51 base: self.values.iter().enumerate(),
52 }
53 }
54
55 // `Iter` does implement `Iterator`, but it has an additional bound on `K`.
56 #[allow(clippy::iter_not_returning_iterator)]
57 pub fn iter_mut(&mut self) -> IterMut<K, V> {
58 IterMut {
59 _keys: PhantomData,
60 base: self.values.iter_mut().enumerate(),
61 }
62 }
63
64 pub fn drain(&mut self) -> Drain<K, V> {
65 Drain {
66 _keys: PhantomData,
67 base: self.values.drain(..).enumerate(),
68 }
69 }
70
71 #[must_use]
72 pub fn values(&self) -> Values<V> {
73 Values {
74 base: self.values.iter(),
75 }
76 }
77
78 pub fn values_mut(&mut self) -> ValuesMut<V> {
79 ValuesMut {
80 base: self.values.iter_mut(),
81 }
82 }
83
84 pub fn retain<F>(&mut self, mut f: F)
85 where
86 F: FnMut(K, &V) -> bool,
87 K: From<usize>,
88 {
89 for (k, v) in self.values.iter_mut().enumerate() {
90 let remove = if let Some(value) = v {
91 !f(K::from(k), value)
92 } else {
93 false
94 };
95 if remove {
96 *v = None;
97 }
98 }
99 }
100
101 pub fn clear(&mut self) {
102 self.values.clear();
103 }
104}
105
106impl<K: Into<usize>, V> IndexMap<K, V> {
107 pub fn insert(&mut self, key: K, value: V) {
108 let index = key.into();
109 if index >= self.values.len() {
110 self.values.resize_with(index + 1, || None);
111 }
112 self.values[index] = Some(value);
113 }
114
115 pub fn contains_key(&self, key: K) -> bool {
116 let index: usize = key.into();
117 self.values.get(index).map_or(false, Option::is_some)
118 }
119
120 pub fn get(&self, key: K) -> Option<&V> {
121 let index: usize = key.into();
122 self.values.get(index).and_then(Option::as_ref)
123 }
124
125 pub fn get_mut(&mut self, key: K) -> Option<&mut V> {
126 let index: usize = key.into();
127 self.values.get_mut(index).and_then(Option::as_mut)
128 }
129
130 pub fn remove(&mut self, key: K) {
131 let index: usize = key.into();
132 if index < self.values.len() {
133 self.values[index] = None;
134 }
135 }
136}
137
138impl<K, V: Clone> Clone for IndexMap<K, V> {
139 fn clone(&self) -> Self {
140 Self {
141 _keys: PhantomData,
142 values: self.values.clone(),
143 }
144 }
145}
146
147impl<K, V: Debug> Debug for IndexMap<K, V> {
148 fn fmt(&self, f: &mut Formatter) -> fmt::Result {
149 f.debug_struct("IndexMap")
150 .field(
151 "values",
152 &self
153 .values
154 .iter()
155 .enumerate()
156 .filter_map(|(k, v)| v.as_ref().map(|val| format!("{k:?}: {val:?}")))
157 .collect::<Vec<_>>(),
158 )
159 .finish()
160 }
161}
162
163impl<K, V> Default for IndexMap<K, V> {
164 fn default() -> Self {
165 Self {
166 _keys: PhantomData,
167 values: Vec::default(),
168 }
169 }
170}
171
172impl<K: From<usize>, V> IntoIterator for IndexMap<K, V> {
173 type Item = (K, V);
174
175 type IntoIter = IntoIter<K, V>;
176
177 fn into_iter(self) -> Self::IntoIter {
178 IntoIter {
179 _keys: PhantomData,
180 base: self.values.into_iter().enumerate(),
181 }
182 }
183}
184
185impl<'a, K: From<usize>, V> IntoIterator for &'a IndexMap<K, V> {
186 type Item = (K, &'a V);
187
188 type IntoIter = Iter<'a, K, V>;
189
190 fn into_iter(self) -> Self::IntoIter {
191 self.iter()
192 }
193}
194
195impl<K: Into<usize>, V> FromIterator<(K, V)> for IndexMap<K, V> {
196 fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
197 let iter = iter.into_iter();
198 let mut map = Self::new();
199 let (lo, hi) = iter.size_hint();
200 map.values.reserve(hi.unwrap_or(lo));
201 for (key, value) in iter {
202 map.insert(key, value);
203 }
204 map
205 }
206}
207
208pub struct Iter<'a, K, V> {
209 _keys: PhantomData<K>,
210 base: Enumerate<slice::Iter<'a, Option<V>>>,
211}
212
213impl<'a, K: From<usize>, V> Iterator for Iter<'a, K, V> {
214 type Item = (K, &'a V);
215
216 fn next(&mut self) -> Option<Self::Item> {
217 loop {
218 if let (index, Some(value)) = self.base.next()? {
219 break Some((index.into(), value));
220 }
221 }
222 }
223}
224
225pub struct IterMut<'a, K, V> {
226 _keys: PhantomData<K>,
227 base: Enumerate<slice::IterMut<'a, Option<V>>>,
228}
229
230impl<K: From<usize>, V> DoubleEndedIterator for Iter<'_, K, V> {
231 fn next_back(&mut self) -> Option<Self::Item> {
232 loop {
233 if let (index, Some(value)) = self.base.next_back()? {
234 break Some((index.into(), value));
235 }
236 }
237 }
238}
239
240impl<'a, K: From<usize>, V> Iterator for IterMut<'a, K, V> {
241 type Item = (K, &'a mut V);
242
243 fn next(&mut self) -> Option<Self::Item> {
244 loop {
245 if let (index, Some(value)) = self.base.next()? {
246 break Some((index.into(), value));
247 }
248 }
249 }
250}
251
252pub struct IntoIter<K, V> {
253 _keys: PhantomData<K>,
254 base: Enumerate<vec::IntoIter<Option<V>>>,
255}
256
257impl<K: From<usize>, V> Iterator for IntoIter<K, V> {
258 type Item = (K, V);
259
260 fn next(&mut self) -> Option<Self::Item> {
261 loop {
262 if let (index, Some(value)) = self.base.next()? {
263 break Some((index.into(), value));
264 }
265 }
266 }
267}
268
269pub struct Drain<'a, K, V> {
270 _keys: PhantomData<K>,
271 base: Enumerate<vec::Drain<'a, Option<V>>>,
272}
273
274impl<K: From<usize>, V> Iterator for Drain<'_, K, V> {
275 type Item = (K, V);
276
277 fn next(&mut self) -> Option<Self::Item> {
278 loop {
279 if let (index, Some(value)) = self.base.next()? {
280 break Some((index.into(), value));
281 }
282 }
283 }
284}
285
286pub struct Values<'a, V> {
287 base: slice::Iter<'a, Option<V>>,
288}
289
290impl<'a, V> Iterator for Values<'a, V> {
291 type Item = &'a V;
292
293 fn next(&mut self) -> Option<Self::Item> {
294 loop {
295 if let Some(value) = self.base.next()? {
296 break Some(value);
297 }
298 }
299 }
300}
301
302pub struct ValuesMut<'a, V> {
303 base: slice::IterMut<'a, Option<V>>,
304}
305
306impl<'a, V> Iterator for ValuesMut<'a, V> {
307 type Item = &'a mut V;
308
309 fn next(&mut self) -> Option<Self::Item> {
310 loop {
311 if let Some(value) = self.base.next()? {
312 break Some(value);
313 }
314 }
315 }
316}
317