vecmap/set/
iter.rs

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

vecmap/set/
iter.rs
