GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/qdk

Public

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

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
alex/merge-mines-changes

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

306lines · 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<'a, K: From<usize>, V> Iterator for IterMut<'a, K, V> {
231 type Item = (K, &'a mut V);
232
233 fn next(&mut self) -> Option<Self::Item> {
234 loop {
235 if let (index, Some(value)) = self.base.next()? {
236 break Some((index.into(), value));
237 }
238 }
239 }
240}
241
242pub struct IntoIter<K, V> {
243 _keys: PhantomData<K>,
244 base: Enumerate<vec::IntoIter<Option<V>>>,
245}
246
247impl<K: From<usize>, V> Iterator for IntoIter<K, V> {
248 type Item = (K, V);
249
250 fn next(&mut self) -> Option<Self::Item> {
251 loop {
252 if let (index, Some(value)) = self.base.next()? {
253 break Some((index.into(), value));
254 }
255 }
256 }
257}
258
259pub struct Drain<'a, K, V> {
260 _keys: PhantomData<K>,
261 base: Enumerate<vec::Drain<'a, Option<V>>>,
262}
263
264impl<K: From<usize>, V> Iterator for Drain<'_, K, V> {
265 type Item = (K, V);
266
267 fn next(&mut self) -> Option<Self::Item> {
268 loop {
269 if let (index, Some(value)) = self.base.next()? {
270 break Some((index.into(), value));
271 }
272 }
273 }
274}
275
276pub struct Values<'a, V> {
277 base: slice::Iter<'a, Option<V>>,
278}
279
280impl<'a, V> Iterator for Values<'a, V> {
281 type Item = &'a V;
282
283 fn next(&mut self) -> Option<Self::Item> {
284 loop {
285 if let Some(value) = self.base.next()? {
286 break Some(value);
287 }
288 }
289 }
290}
291
292pub struct ValuesMut<'a, V> {
293 base: slice::IterMut<'a, Option<V>>,
294}
295
296impl<'a, V> Iterator for ValuesMut<'a, V> {
297 type Item = &'a mut V;
298
299 fn next(&mut self) -> Option<Self::Item> {
300 loop {
301 if let Some(value) = self.base.next()? {
302 break Some(value);
303 }
304 }
305 }
306}
307