ordinal_map/map/
iter.rs

1use std::fmt::Debug;
2use std::fmt::Formatter;
3use std::marker::PhantomData;
4use std::mem;
5
6use crate::map::total;
7use crate::Ordinal;
8
9/// Iterator over the entries of
10/// [`OrdinalMap`](crate::map::OrdinalMap) and [`OrdinalArrayMap`](crate::map::OrdinalArrayMap).
11pub struct Iter<'a, K, V> {
12    iter: total::Iter<'a, K, Option<V>>,
13}
14
15impl<'a, K, V> Iter<'a, K, V> {
16    #[inline]
17    pub(crate) fn new(iter: total::Iter<'a, K, Option<V>>) -> Self {
18        Iter { iter }
19    }
20}
21
22impl<'a, K: Ordinal, V> Iterator for Iter<'a, K, V> {
23    type Item = (K, &'a V);
24
25    #[inline]
26    fn next(&mut self) -> Option<Self::Item> {
27        loop {
28            let next = self.iter.next()?;
29            if let (k, Some(v)) = next {
30                return Some((k, v));
31            }
32        }
33    }
34
35    #[inline]
36    fn size_hint(&self) -> (usize, Option<usize>) {
37        (0, Some(self.iter.len()))
38    }
39}
40
41impl<'a, K: Ordinal, V> DoubleEndedIterator for Iter<'a, K, V> {
42    #[inline]
43    fn next_back(&mut self) -> Option<Self::Item> {
44        loop {
45            let next = self.iter.next_back()?;
46            if let (k, Some(v)) = next {
47                return Some((k, v));
48            }
49        }
50    }
51}
52
53impl<'a, K, V> Clone for Iter<'a, K, V> {
54    #[inline]
55    fn clone(&self) -> Self {
56        Iter {
57            iter: self.iter.clone(),
58        }
59    }
60}
61
62impl<'a, K: Ordinal + Debug, V: Debug> Debug for Iter<'a, K, V> {
63    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
64        f.debug_list().entries(self.clone()).finish()
65    }
66}
67
68/// Iterator over mutable references to the entries of
69/// [`OrdinalMap`](crate::map::OrdinalMap) and [`OrdinalArrayMap`](crate::map::OrdinalArrayMap).
70pub struct IterMut<'a, K, V> {
71    iter: total::IterMut<'a, K, Option<V>>,
72}
73
74impl<'a, K: Ordinal, V> IterMut<'a, K, V> {
75    #[inline]
76    pub(crate) fn new(iter: total::IterMut<'a, K, Option<V>>) -> Self {
77        IterMut { iter }
78    }
79
80    fn iter(&self) -> Iter<'_, K, V> {
81        Iter::new(self.iter.iter())
82    }
83}
84
85impl<'a, K: Ordinal, V> Iterator for IterMut<'a, K, V> {
86    type Item = (K, &'a mut V);
87
88    #[inline]
89    fn next(&mut self) -> Option<Self::Item> {
90        loop {
91            let next = self.iter.next()?;
92            if let (k, Some(v)) = next {
93                return Some((k, v));
94            }
95        }
96    }
97
98    #[inline]
99    fn size_hint(&self) -> (usize, Option<usize>) {
100        (0, Some(self.iter.len()))
101    }
102}
103
104impl<'a, K: Ordinal, V> DoubleEndedIterator for IterMut<'a, K, V> {
105    #[inline]
106    fn next_back(&mut self) -> Option<Self::Item> {
107        loop {
108            let next = self.iter.next_back()?;
109            if let (k, Some(v)) = next {
110                return Some((k, v));
111            }
112        }
113    }
114}
115
116impl<'a, K: Ordinal + Debug, V: Debug> Debug for IterMut<'a, K, V> {
117    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
118        f.debug_list().entries(self.iter()).finish()
119    }
120}
121
122/// Iterator over the keys of [`OrdinalMap`](crate::map::OrdinalMap)
123/// and [`OrdinalArrayMap`](crate::map::OrdinalArrayMap).
124pub struct Keys<'a, K, V> {
125    iter: Iter<'a, K, V>,
126}
127
128impl<'a, K: Ordinal, V> Keys<'a, K, V> {
129    #[inline]
130    pub(crate) fn new(iter: Iter<'a, K, V>) -> Self {
131        Keys { iter }
132    }
133}
134
135impl<'a, K: Ordinal, V> Iterator for Keys<'a, K, V> {
136    type Item = K;
137
138    #[inline]
139    fn next(&mut self) -> Option<Self::Item> {
140        self.iter.next().map(|(k, _)| k)
141    }
142
143    #[inline]
144    fn size_hint(&self) -> (usize, Option<usize>) {
145        self.iter.size_hint()
146    }
147}
148
149impl<'a, K: Ordinal, V> DoubleEndedIterator for Keys<'a, K, V> {
150    #[inline]
151    fn next_back(&mut self) -> Option<Self::Item> {
152        self.iter.next_back().map(|(k, _)| k)
153    }
154}
155
156impl<'a, K: Ordinal, V> Clone for Keys<'a, K, V> {
157    #[inline]
158    fn clone(&self) -> Self {
159        Keys {
160            iter: self.iter.clone(),
161        }
162    }
163}
164
165impl<'a, K: Ordinal + Debug> Debug for Keys<'a, K, ()> {
166    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
167        f.debug_list().entries(self.clone()).finish()
168    }
169}
170
171/// Iterator over the values of [`OrdinalMap`](crate::map::OrdinalMap)
172/// and [`OrdinalArrayMap`](crate::map::OrdinalArrayMap).
173pub struct Values<'a, K, V> {
174    iter: Iter<'a, K, V>,
175}
176
177impl<'a, K: Ordinal, V> Values<'a, K, V> {
178    #[inline]
179    pub(crate) fn new(iter: Iter<'a, K, V>) -> Self {
180        Values { iter }
181    }
182}
183
184impl<'a, K: Ordinal, V> Iterator for Values<'a, K, V> {
185    type Item = &'a V;
186
187    #[inline]
188    fn next(&mut self) -> Option<Self::Item> {
189        self.iter.next().map(|(_, v)| v)
190    }
191
192    #[inline]
193    fn size_hint(&self) -> (usize, Option<usize>) {
194        self.iter.size_hint()
195    }
196}
197
198impl<'a, K: Ordinal, V> DoubleEndedIterator for Values<'a, K, V> {
199    #[inline]
200    fn next_back(&mut self) -> Option<Self::Item> {
201        self.iter.next_back().map(|(_, v)| v)
202    }
203}
204
205impl<'a, K: Ordinal, V> Clone for Values<'a, K, V> {
206    #[inline]
207    fn clone(&self) -> Self {
208        Values {
209            iter: self.iter.clone(),
210        }
211    }
212}
213
214impl<'a, K: Ordinal + Debug, V: Debug> Debug for Values<'a, K, V> {
215    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
216        f.debug_list().entries(self.clone()).finish()
217    }
218}
219
220/// Iterator over mutable references to the values of
221/// [`OrdinalMap`](crate::map::OrdinalMap) and [`OrdinalArrayMap`](crate::map::OrdinalArrayMap).
222pub struct ValuesMut<'a, K, V> {
223    iter: IterMut<'a, K, V>,
224}
225
226impl<'a, K: Ordinal, V> ValuesMut<'a, K, V> {
227    #[inline]
228    pub(crate) fn new(iter: IterMut<'a, K, V>) -> Self {
229        ValuesMut { iter }
230    }
231
232    fn iter(&self) -> Values<'_, K, V> {
233        Values {
234            iter: self.iter.iter(),
235        }
236    }
237}
238
239impl<'a, K: Ordinal, V> Iterator for ValuesMut<'a, K, V> {
240    type Item = &'a mut V;
241
242    #[inline]
243    fn next(&mut self) -> Option<Self::Item> {
244        self.iter.next().map(|(_, v)| v)
245    }
246
247    #[inline]
248    fn size_hint(&self) -> (usize, Option<usize>) {
249        self.iter.size_hint()
250    }
251}
252
253impl<'a, K: Ordinal, V> DoubleEndedIterator for ValuesMut<'a, K, V> {
254    #[inline]
255    fn next_back(&mut self) -> Option<Self::Item> {
256        self.iter.next_back().map(|(_, v)| v)
257    }
258}
259
260impl<'a, K: Ordinal + Debug, V: Debug> Debug for ValuesMut<'a, K, V> {
261    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
262        f.debug_list().entries(self.iter()).finish()
263    }
264}
265
266/// Iterator that removes all key-value pairs from [`OrdinalMap`](crate::map::OrdinalMap)
267/// or [`OrdinalArrayMap`](crate::map::OrdinalArrayMap).
268pub struct Drain<'a, K: Ordinal, V> {
269    iter: total::IterMut<'a, K, Option<V>>,
270}
271
272impl<'a, K: Ordinal, V> Drain<'a, K, V> {
273    pub(crate) fn new(iter: total::IterMut<'a, K, Option<V>>) -> Self {
274        Drain { iter }
275    }
276}
277
278impl<'a, K: Ordinal, V> Drop for Drain<'a, K, V> {
279    fn drop(&mut self) {
280        for _ in self {}
281    }
282}
283
284impl<'a, K: Ordinal, V> Iterator for Drain<'a, K, V> {
285    type Item = (K, V);
286
287    fn next(&mut self) -> Option<Self::Item> {
288        loop {
289            let (k, v) = self.iter.next()?;
290            if let Some(v) = mem::take(v) {
291                return Some((k, v));
292            }
293        }
294    }
295
296    fn size_hint(&self) -> (usize, Option<usize>) {
297        (0, Some(self.iter.len()))
298    }
299}
300
301impl<'a, K: Ordinal, V> DoubleEndedIterator for Drain<'a, K, V> {
302    fn next_back(&mut self) -> Option<Self::Item> {
303        loop {
304            let (k, v) = self.iter.next_back()?;
305            if let Some(v) = mem::take(v) {
306                return Some((k, v));
307            }
308        }
309    }
310}
311
312/// Iterator created from [`OrdinalInitArrayMap`](total::OrdinalTotalArrayMap).
313pub struct IntoIterArray<K, V, const S: usize> {
314    iter: total::IntoIterArray<K, Option<V>, S>,
315    _phantom: PhantomData<K>,
316}
317
318impl<K: Ordinal, V, const S: usize> IntoIterArray<K, V, S> {
319    #[inline]
320    pub(crate) fn new(iter: total::IntoIterArray<K, Option<V>, S>) -> Self {
321        IntoIterArray {
322            iter,
323            _phantom: PhantomData,
324        }
325    }
326
327    fn iter(&self) -> Iter<'_, K, V> {
328        Iter::new(self.iter.iter())
329    }
330}
331
332impl<K: Ordinal, V, const S: usize> Iterator for IntoIterArray<K, V, S> {
333    type Item = (K, V);
334
335    #[inline]
336    fn next(&mut self) -> Option<Self::Item> {
337        loop {
338            let (k, v) = self.iter.next()?;
339            if let Some(v) = v {
340                return Some((k, v));
341            }
342        }
343    }
344}
345
346impl<K: Ordinal, V, const S: usize> DoubleEndedIterator for IntoIterArray<K, V, S> {
347    #[inline]
348    fn next_back(&mut self) -> Option<Self::Item> {
349        loop {
350            let (k, v) = self.iter.next_back()?;
351            if let Some(v) = v {
352                return Some((k, v));
353            }
354        }
355    }
356}
357
358impl<K: Ordinal + Debug, V: Debug, const S: usize> Debug for IntoIterArray<K, V, S> {
359    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
360        f.debug_list().entries(self.iter()).finish()
361    }
362}
363
364impl<K, V: Clone, const S: usize> Clone for IntoIterArray<K, V, S> {
365    fn clone(&self) -> Self {
366        IntoIterArray {
367            iter: self.iter.clone(),
368            _phantom: PhantomData,
369        }
370    }
371}
372
373/// Iterator created from [`OrdinalMap`](crate::map::OrdinalMap).
374pub struct IntoIter<K, V> {
375    iter: total::IntoIter<K, Option<V>>,
376}
377
378impl<K, V> IntoIter<K, V> {
379    pub(crate) fn new(iter: total::IntoIter<K, Option<V>>) -> Self {
380        IntoIter { iter }
381    }
382
383    fn iter(&self) -> Iter<'_, K, V> {
384        Iter::new(self.iter.iter())
385    }
386}
387
388impl<K: Ordinal, V> Iterator for IntoIter<K, V> {
389    type Item = (K, V);
390
391    #[inline]
392    fn next(&mut self) -> Option<Self::Item> {
393        loop {
394            let (k, v) = self.iter.next()?;
395            if let Some(v) = v {
396                return Some((k, v));
397            }
398        }
399    }
400
401    fn size_hint(&self) -> (usize, Option<usize>) {
402        (0, Some(self.iter.len()))
403    }
404}
405
406impl<K: Ordinal, V> DoubleEndedIterator for IntoIter<K, V> {
407    fn next_back(&mut self) -> Option<Self::Item> {
408        loop {
409            let (k, v) = self.iter.next_back()?;
410            if let Some(v) = v {
411                return Some((k, v));
412            }
413        }
414    }
415}
416
417impl<K: Ordinal + Debug, V: Debug> Debug for IntoIter<K, V> {
418    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
419        f.debug_list().entries(self.iter()).finish()
420    }
421}
422
423impl<K, V: Clone> Clone for IntoIter<K, V> {
424    fn clone(&self) -> Self {
425        IntoIter {
426            iter: self.iter.clone(),
427        }
428    }
429}
ordinal_map/map/iter.rs

ordinal_map/map/
iter.rs
