micromap_rawl/
keys.rs

1use crate::{IntoKeys, Keys, Map};
2use core::iter::FusedIterator;
3
4impl<K: PartialEq, V, const N: usize> Map<K, V, N> {
5    /// An iterator visiting all keys in arbitrary order.
6    #[inline]
7    pub fn keys(&self) -> Keys<'_, K, V> {
8        Keys { iter: self.iter() }
9    }
10
11    /// Consuming iterator visiting all keys in arbitrary order.
12    #[inline]
13    pub fn into_keys(self) -> IntoKeys<K, V, N> {
14        IntoKeys {
15            iter: self.into_iter(),
16        }
17    }
18}
19
20impl<'a, K, V> Iterator for Keys<'a, K, V> {
21    type Item = &'a K;
22
23    #[inline]
24    fn next(&mut self) -> Option<Self::Item> {
25        self.iter.next().map(|p| p.0)
26    }
27
28    #[inline]
29    fn size_hint(&self) -> (usize, Option<usize>) {
30        self.iter.size_hint()
31    }
32}
33
34impl<K: PartialEq, V, const N: usize> Iterator for IntoKeys<K, V, N> {
35    type Item = K;
36
37    #[inline]
38    fn next(&mut self) -> Option<K> {
39        self.iter.next().map(|p| p.0)
40    }
41
42    #[inline]
43    fn size_hint(&self) -> (usize, Option<usize>) {
44        self.iter.size_hint()
45    }
46}
47
48impl<K, V> ExactSizeIterator for Keys<'_, K, V> {
49    fn len(&self) -> usize {
50        self.iter.len()
51    }
52}
53
54impl<K: PartialEq, V, const N: usize> ExactSizeIterator for IntoKeys<K, V, N> {
55    fn len(&self) -> usize {
56        self.iter.len()
57    }
58}
59
60impl<K, V> FusedIterator for Keys<'_, K, V> {}
61
62impl<K: PartialEq, V, const N: usize> FusedIterator for IntoKeys<K, V, N> {}
63
64#[cfg(test)]
65mod test {
66    use super::*;
67
68    #[test]
69    fn iterate_keys() {
70        let mut m: Map<String, i32, 10> = Map::new();
71        m.insert("foo".to_string(), 0);
72        m.insert("bar".to_string(), 0);
73        assert_eq!(m.keys().collect::<Vec<_>>(), [&"foo", &"bar"]);
74    }
75
76    #[test]
77    fn iterate_into_keys() {
78        let mut m: Map<String, i32, 10> = Map::new();
79        m.insert("foo".to_string(), 0);
80        m.insert("bar".to_string(), 0);
81        assert_eq!(
82            m.into_keys().collect::<Vec<_>>(),
83            ["bar".to_string(), "foo".to_string()]
84        );
85    }
86}