vecset/map/
iter.rs

1use super::{Slot, VecMap};
2use alloc::vec::{self, Vec};
3use core::fmt;
4use core::iter::FusedIterator;
5use core::slice;
6
7macro_rules! impl_iterator {
8    ($ty:ident<$($lt:lifetime,)*$($gen:ident),+>, $item:ty, $map:expr) => {
9        impl<$($lt,)*$($gen),+> Iterator for $ty<$($lt,)*$($gen),+> {
10            type Item = $item;
11
12            fn next(&mut self) -> Option<Self::Item> {
13                self.iter.next().map($map)
14            }
15
16            fn size_hint(&self) -> (usize, Option<usize>) {
17                self.iter.size_hint()
18            }
19        }
20
21        impl<$($lt,)*$($gen),+> DoubleEndedIterator for $ty<$($lt,)*$($gen),+> {
22            fn next_back(&mut self) -> Option<Self::Item> {
23                self.iter.next_back().map($map)
24            }
25        }
26
27        impl<$($lt,)*$($gen),+> ExactSizeIterator for $ty<$($lt,)*$($gen),+> {
28            fn len(&self) -> usize {
29                self.iter.len()
30            }
31        }
32
33        impl<$($lt,)*$($gen),+> FusedIterator for $ty<$($lt,)*$($gen),+> {}
34
35        impl<$($lt,)*$($gen),+> fmt::Debug for $ty<$($lt,)*$($gen),+>
36        where
37            K: fmt::Debug,
38            V: fmt::Debug,
39        {
40            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
41                let iter = self.iter.as_slice().iter().map(VecMap::refs);
42                f.debug_list().entries(iter).finish()
43            }
44        }
45    };
46}
47
48impl<K, V> IntoIterator for VecMap<K, V> {
49    type Item = (K, V);
50
51    type IntoIter = IntoIter<K, V>;
52
53    fn into_iter(self) -> Self::IntoIter {
54        IntoIter::new(self.base.into_vec())
55    }
56}
57
58impl<'a, K, V> IntoIterator for &'a VecMap<K, V> {
59    type Item = (&'a K, &'a V);
60
61    type IntoIter = Iter<'a, K, V>;
62
63    fn into_iter(self) -> Self::IntoIter {
64        self.iter()
65    }
66}
67
68impl<'a, K, V> IntoIterator for &'a mut VecMap<K, V> {
69    type Item = (&'a K, &'a mut V);
70
71    type IntoIter = IterMut<'a, K, V>;
72
73    fn into_iter(self) -> Self::IntoIter {
74        self.iter_mut()
75    }
76}
77
78/// An iterator over the entries of a `VecMap`.
79///
80/// This `struct` is created by the [`iter`] method on [`VecMap`]. See its documentation for more.
81///
82/// [`iter`]: VecMap::iter
83pub struct Iter<'a, K, V> {
84    iter: slice::Iter<'a, Slot<K, V>>,
85}
86
87impl<'a, K, V> Iter<'a, K, V> {
88    pub(super) fn new(entries: &'a [Slot<K, V>]) -> Iter<'a, K, V> {
89        Iter {
90            iter: entries.iter(),
91        }
92    }
93}
94
95impl<K, V> Clone for Iter<'_, K, V> {
96    fn clone(&self) -> Self {
97        Iter {
98            iter: self.iter.clone(),
99        }
100    }
101}
102
103impl_iterator!(Iter<'a, K, V>, (&'a K, &'a V), VecMap::refs);
104
105/// A mutable iterator over the entries of a `VecMap`.
106///
107/// This `struct` is created by the [`iter_mut`] method on [`VecMap`]. See its documentation for
108/// more.
109///
110/// [`iter_mut`]: VecMap::iter_mut
111pub struct IterMut<'a, K, V> {
112    iter: slice::IterMut<'a, Slot<K, V>>,
113}
114
115impl<'a, K, V> IterMut<'a, K, V> {
116    pub(super) fn new(entries: &'a mut [Slot<K, V>]) -> IterMut<'a, K, V> {
117        IterMut {
118            iter: entries.iter_mut(),
119        }
120    }
121}
122
123impl_iterator!(IterMut<'a, K, V>, (&'a K, &'a mut V), VecMap::ref_mut);
124
125/// An owning iterator over the entries of a `VecMap`.
126///
127/// This `struct` is created by the [`into_iter`] method on [`VecMap`] (provided by the
128/// [`IntoIterator`] trait). See its documentation for more.
129///
130/// [`into_iter`]: IntoIterator::into_iter
131/// [`IntoIterator`]: core::iter::IntoIterator
132pub struct IntoIter<K, V> {
133    iter: vec::IntoIter<Slot<K, V>>,
134}
135
136impl<K, V> IntoIter<K, V> {
137    pub(super) fn new(entries: Vec<Slot<K, V>>) -> IntoIter<K, V> {
138        IntoIter {
139            iter: entries.into_iter(),
140        }
141    }
142}
143
144impl<K, V> Clone for IntoIter<K, V>
145where
146    K: Clone,
147    V: Clone,
148{
149    fn clone(&self) -> Self {
150        IntoIter {
151            iter: self.iter.clone(),
152        }
153    }
154}
155
156impl_iterator!(IntoIter<K, V>, (K, V), |slot| (slot.0, slot.1));
157
158/// An iterator over the keys of a `VecMap`.
159///
160/// This `struct` is created by the [`keys`] method on [`VecMap`]. See its documentation for more.
161///
162/// [`keys`]: VecMap::keys
163pub struct Keys<'a, K, V> {
164    iter: slice::Iter<'a, Slot<K, V>>,
165}
166
167impl<'a, K, V> Keys<'a, K, V> {
168    pub(super) fn new(entries: &'a [Slot<K, V>]) -> Keys<'a, K, V> {
169        Keys {
170            iter: entries.iter(),
171        }
172    }
173}
174
175impl<K, V> Clone for Keys<'_, K, V> {
176    fn clone(&self) -> Self {
177        Keys {
178            iter: self.iter.clone(),
179        }
180    }
181}
182
183impl_iterator!(Keys<'a, K, V>, &'a K, |slot| &slot.0);
184
185/// An owning iterator over the keys of a `VecMap`.
186///
187/// This `struct` is created by the [`into_keys`] method on [`VecMap`]. See its documentation for
188/// more.
189///
190/// [`into_keys`]: VecMap::into_keys
191pub struct IntoKeys<K, V> {
192    iter: vec::IntoIter<Slot<K, V>>,
193}
194
195impl<K, V> IntoKeys<K, V> {
196    pub(super) fn new(entries: Vec<Slot<K, V>>) -> IntoKeys<K, V> {
197        IntoKeys {
198            iter: entries.into_iter(),
199        }
200    }
201}
202
203impl<K, V> Clone for IntoKeys<K, V>
204where
205    K: Clone,
206    V: Clone,
207{
208    fn clone(&self) -> Self {
209        IntoKeys {
210            iter: self.iter.clone(),
211        }
212    }
213}
214
215impl_iterator!(IntoKeys<K, V>, K, |slot| slot.0);
216
217/// An iterator over the values of a `VecMap`.
218///
219/// This `struct` is created by the [`values`] method on [`VecMap`]. See its documentation for
220/// more.
221///
222/// [`values`]: VecMap::values
223pub struct Values<'a, K, V> {
224    iter: slice::Iter<'a, Slot<K, V>>,
225}
226
227impl<'a, K, V> Values<'a, K, V> {
228    pub(super) fn new(entries: &'a [Slot<K, V>]) -> Values<'a, K, V> {
229        Values {
230            iter: entries.iter(),
231        }
232    }
233}
234
235impl<K, V> Clone for Values<'_, K, V> {
236    fn clone(&self) -> Self {
237        Values {
238            iter: self.iter.clone(),
239        }
240    }
241}
242
243impl_iterator!(Values<'a, K, V>, &'a V, |slot| &slot.1);
244
245/// A mutable iterator over the values of a `VecMap`.
246///
247/// This `struct` is created by the [`values_mut`] method on [`VecMap`]. See its documentation for
248/// more.
249///
250/// [`values_mut`]: VecMap::values_mut
251pub struct ValuesMut<'a, K, V> {
252    iter: slice::IterMut<'a, Slot<K, V>>,
253}
254
255impl<'a, K, V> ValuesMut<'a, K, V> {
256    pub(super) fn new(entries: &'a mut [Slot<K, V>]) -> ValuesMut<'a, K, V> {
257        ValuesMut {
258            iter: entries.iter_mut(),
259        }
260    }
261}
262
263impl_iterator!(ValuesMut<'a, K, V>, &'a mut V, |slot| &mut slot.1);
264
265/// An owning iterator over the values of a `VecMap`.
266///
267/// This `struct` is created by the [`into_values`] method on [`VecMap`]. See its documentation
268/// for more.
269///
270/// [`into_values`]: VecMap::into_values
271pub struct IntoValues<K, V> {
272    iter: vec::IntoIter<Slot<K, V>>,
273}
274
275impl<K, V> IntoValues<K, V> {
276    pub(super) fn new(entries: Vec<Slot<K, V>>) -> IntoValues<K, V> {
277        IntoValues {
278            iter: entries.into_iter(),
279        }
280    }
281}
282
283impl<K, V> Clone for IntoValues<K, V>
284where
285    K: Clone,
286    V: Clone,
287{
288    fn clone(&self) -> Self {
289        IntoValues {
290            iter: self.iter.clone(),
291        }
292    }
293}
294
295impl_iterator!(IntoValues<K, V>, V, |slot| slot.1);
vecset/map/iter.rs

vecset/map/
iter.rs
