ordered_hash_map/set/
iter.rs

1use core::fmt;
2use core::iter::FusedIterator;
3
4/// An ordered iterator over the elements.
5///
6/// Created by the [`iter`] method of [`OrderedHashSet`]. See its documentation for details.
7///
8/// [`iter`]: super::OrderedHashSet::iter
9/// [`OrderedHashSet`]: super::OrderedHashSet
10pub struct Iter<'a, T> {
11    inner: crate::ordered_map::Iter<'a, T, ()>,
12}
13
14impl<'a, T> Iter<'a, T> {
15    fn return_key(val: (&'a T, &())) -> &'a T {
16        val.0
17    }
18}
19
20impl<T> Clone for Iter<'_, T> {
21    fn clone(&self) -> Self {
22        Self {
23            inner: self.inner.clone(),
24        }
25    }
26}
27
28impl<T> fmt::Debug for Iter<'_, T>
29where
30    T: fmt::Debug,
31{
32    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
33        f.debug_list().entries((*self).clone()).finish()
34    }
35}
36
37impl<'a, T> Iterator for Iter<'a, T> {
38    type Item = &'a T;
39
40    #[inline]
41    fn next(&mut self) -> Option<Self::Item> {
42        self.inner.next().map(Self::return_key)
43    }
44
45    #[inline]
46    fn size_hint(&self) -> (usize, Option<usize>) {
47        self.inner.size_hint()
48    }
49}
50
51impl<T> DoubleEndedIterator for Iter<'_, T> {
52    fn next_back(&mut self) -> Option<Self::Item> {
53        self.inner.next_back().map(Self::return_key)
54    }
55}
56
57impl<T> ExactSizeIterator for Iter<'_, T> {}
58
59impl<T> FusedIterator for Iter<'_, T> {}
60
61impl<'a, T, S> IntoIterator for &'a super::OrderedHashSet<T, S> {
62    type Item = &'a T;
63    type IntoIter = Iter<'a, T>;
64
65    fn into_iter(self) -> Self::IntoIter {
66        Self::IntoIter {
67            inner: self.map.iter(),
68        }
69    }
70}
71
72/// An ordered iterator over the elements.
73///
74/// Created by the [`into_iter`] method of [`OrderedHashSet`]. See its documentation for details.
75///
76/// [`into_iter`]: super::OrderedHashSet::into_iter
77/// [`OrderedHashSet`]: super::OrderedHashSet
78pub struct IntoIter<T> {
79    inner: crate::ordered_map::IntoIter<T, ()>,
80}
81
82impl<T> IntoIter<T> {
83    fn return_key(val: (T, ())) -> T {
84        val.0
85    }
86}
87
88impl<T> IntoIter<T> {
89    fn iter(&self) -> Iter<'_, T> {
90        Iter {
91            inner: self.inner.iter(),
92        }
93    }
94}
95
96impl<T> fmt::Debug for IntoIter<T>
97where
98    T: fmt::Debug,
99{
100    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
101        f.debug_list().entries(self.iter()).finish()
102    }
103}
104
105impl<T> Iterator for IntoIter<T> {
106    type Item = T;
107
108    fn next(&mut self) -> Option<Self::Item> {
109        self.inner.next().map(Self::return_key)
110    }
111
112    fn size_hint(&self) -> (usize, Option<usize>) {
113        self.inner.size_hint()
114    }
115}
116
117impl<T> DoubleEndedIterator for IntoIter<T> {
118    fn next_back(&mut self) -> Option<Self::Item> {
119        self.inner.next_back().map(Self::return_key)
120    }
121}
122
123impl<T> ExactSizeIterator for IntoIter<T> {}
124
125impl<T> FusedIterator for IntoIter<T> {}
126
127impl<T, S> IntoIterator for super::OrderedHashSet<T, S> {
128    type Item = T;
129    type IntoIter = IntoIter<T>;
130
131    fn into_iter(self) -> Self::IntoIter {
132        Self::IntoIter {
133            inner: self.map.into_iter(),
134        }
135    }
136}
137
138/// An ordered, draining iterator over the elements.
139///
140/// Clears the container and leaves the capacity unchanged for re-use. If this iterator is dropped
141/// before fully consuming all the elements they are freed.
142/// Created by the [`drain`] method of [`OrderedHashSet`]. See its documentation for details.
143///
144/// [`drain`]: super::OrderedHashSet::drain
145/// [`OrderedHashSet`]: super::OrderedHashSet
146pub struct Drain<'a, T> {
147    pub(crate) inner: crate::ordered_map::Drain<'a, T, ()>,
148}
149
150impl<T> Drain<'_, T> {
151    fn iter(&self) -> Iter<'_, T> {
152        Iter {
153            inner: self.inner.iter(),
154        }
155    }
156}
157
158impl<T> fmt::Debug for Drain<'_, T>
159where
160    T: fmt::Debug,
161{
162    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
163        f.debug_list().entries(self.iter()).finish()
164    }
165}
166
167impl<T> Iterator for Drain<'_, T> {
168    type Item = T;
169
170    #[inline]
171    fn next(&mut self) -> Option<Self::Item> {
172        self.inner.next().map(|(x, _)| x)
173    }
174
175    #[inline]
176    fn size_hint(&self) -> (usize, Option<usize>) {
177        self.inner.size_hint()
178    }
179}
180
181impl<T> DoubleEndedIterator for Drain<'_, T> {
182    #[inline]
183    fn next_back(&mut self) -> Option<Self::Item> {
184        self.inner.next_back().map(|(x, _)| x)
185    }
186}
187
188impl<T> ExactSizeIterator for Drain<'_, T> {}
189
190impl<T> FusedIterator for Drain<'_, T> {}
191
192impl<'a, T, S> Extend<&'a T> for super::OrderedHashSet<T, S>
193where
194    T: 'a + Eq + core::hash::Hash + Copy,
195    S: core::hash::BuildHasher,
196{
197    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
198        self.map.extend(iter.into_iter().copied().map(|x| (x, ())));
199    }
200}
201
202impl<T, S> Extend<T> for super::OrderedHashSet<T, S>
203where
204    T: Eq + core::hash::Hash,
205    S: core::hash::BuildHasher,
206{
207    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
208        self.map.extend(iter.into_iter().map(|x| (x, ())));
209    }
210}
211
212impl<T, S> FromIterator<T> for super::OrderedHashSet<T, S>
213where
214    T: Eq + core::hash::Hash,
215    S: core::hash::BuildHasher + Default,
216{
217    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
218        let mut lhs = Self::default();
219        lhs.extend(iter);
220        lhs
221    }
222}
223
224impl<'a, T, S> FromIterator<&'a T> for super::OrderedHashSet<T, S>
225where
226    T: 'a + Eq + core::hash::Hash + Copy,
227    S: core::hash::BuildHasher + Default,
228{
229    fn from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Self {
230        let mut lhs = Self::default();
231        lhs.extend(iter);
232        lhs
233    }
234}
235
236#[cfg(test)]
237mod tests {
238    use super::super::OrderedHashSet;
239
240    #[test]
241    fn extend_and_drain() {
242        let mut set1: OrderedHashSet<i32> = [1, 2, 3].into_iter().collect();
243        let set2: OrderedHashSet<i32> = [4, 5, 6].into_iter().collect();
244
245        set1.extend(set2.into_iter());
246
247        assert_eq!(set1, [1, 2, 3, 4, 5, 6].into_iter().collect());
248
249        let mut drain = set1.drain();
250        assert_eq!(drain.size_hint(), (6, Some(6)));
251        assert_eq!(format!("{:?}", drain), "[1, 2, 3, 4, 5, 6]");
252        assert_eq!(drain.next(), Some(1));
253        drop(drain); //Drop without consuming all elements
254        assert_eq!(set1.len(), 0);
255    }
256
257    #[test]
258    fn iters() {
259        let set1: OrderedHashSet<i32> = [1, 2, 3].into_iter().collect();
260
261        let mut iter = set1.iter();
262        assert_eq!(iter.size_hint(), (3, Some(3)));
263        assert_eq!(format!("{:?}", iter), "[1, 2, 3]");
264        assert_eq!(iter.next(), Some(&1));
265
266        let mut into_iter = set1.into_iter();
267        assert_eq!(into_iter.size_hint(), (3, Some(3)));
268        assert_eq!(format!("{:?}", into_iter), "[1, 2, 3]");
269        assert_eq!(into_iter.next(), Some(1));
270    }
271}
ordered_hash_map/set/iter.rs

ordered_hash_map/set/
iter.rs
