frozen_collections_core/maps/
iterators.rs

1use core::fmt::{Debug, Formatter};
2use core::iter::FusedIterator;
3
4#[cfg(not(feature = "std"))]
5use alloc::boxed::Box;
6
7/// An iterator over the entries of a map.
8pub struct Iter<'a, K, V> {
9    inner: core::slice::Iter<'a, (K, V)>,
10}
11
12impl<'a, K, V> Iter<'a, K, V> {
13    pub(crate) fn new(entries: &'a [(K, V)]) -> Self {
14        Self { inner: entries.iter() }
15    }
16}
17
18impl<'a, K, V> Iterator for Iter<'a, K, V> {
19    type Item = (&'a K, &'a V);
20
21    fn next(&mut self) -> Option<Self::Item> {
22        self.inner.next().map(|entry| (&entry.0, &entry.1))
23    }
24
25    fn size_hint(&self) -> (usize, Option<usize>) {
26        self.inner.size_hint()
27    }
28
29    fn count(self) -> usize {
30        self.inner.count()
31    }
32
33    fn fold<B, F>(self, init: B, mut f: F) -> B
34    where
35        F: FnMut(B, Self::Item) -> B,
36    {
37        self.inner.fold(init, |acc, (k, v)| f(acc, (k, v)))
38    }
39}
40
41impl<K, V> DoubleEndedIterator for Iter<'_, K, V> {
42    fn next_back(&mut self) -> Option<Self::Item> {
43        self.inner.next_back().map(|entry| (&entry.0, &entry.1))
44    }
45
46    fn rfold<B, F>(self, init: B, mut f: F) -> B
47    where
48        F: FnMut(B, Self::Item) -> B,
49    {
50        self.inner.rfold(init, |acc, (k, v)| f(acc, (k, v)))
51    }
52}
53
54impl<K, V> ExactSizeIterator for Iter<'_, K, V> {
55    fn len(&self) -> usize {
56        self.inner.len()
57    }
58}
59
60impl<K, V> FusedIterator for Iter<'_, K, V> {}
61
62impl<K, V> Clone for Iter<'_, K, V> {
63    fn clone(&self) -> Self {
64        Self { inner: self.inner.clone() }
65    }
66}
67
68impl<K, V> Debug for Iter<'_, K, V>
69where
70    K: Debug,
71    V: Debug,
72{
73    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
74        f.debug_list().entries(self.clone()).finish()
75    }
76}
77
78/// An iterator over the entries of a map providing mutable values.
79pub struct IterMut<'a, K, V> {
80    inner: core::slice::IterMut<'a, (K, V)>,
81}
82
83impl<'a, K, V> IterMut<'a, K, V> {
84    pub(crate) fn new(entries: &'a mut [(K, V)]) -> Self {
85        Self { inner: entries.iter_mut() }
86    }
87}
88
89impl<'a, K, V> Iterator for IterMut<'a, K, V> {
90    type Item = (&'a K, &'a mut V);
91
92    fn next(&mut self) -> Option<Self::Item> {
93        self.inner.next().map(|entry| (&entry.0, &mut entry.1))
94    }
95
96    fn size_hint(&self) -> (usize, Option<usize>) {
97        self.inner.size_hint()
98    }
99
100    fn count(self) -> usize {
101        self.inner.count()
102    }
103
104    fn fold<B, F>(self, init: B, mut f: F) -> B
105    where
106        F: FnMut(B, Self::Item) -> B,
107    {
108        self.inner.fold(init, |acc, (k, v)| f(acc, (k, v)))
109    }
110}
111
112impl<K, V> DoubleEndedIterator for IterMut<'_, K, V> {
113    fn next_back(&mut self) -> Option<Self::Item> {
114        self.inner.next_back().map(|entry| (&entry.0, &mut entry.1))
115    }
116
117    fn rfold<B, F>(self, init: B, mut f: F) -> B
118    where
119        F: FnMut(B, Self::Item) -> B,
120    {
121        self.inner.rfold(init, |acc, (k, v)| f(acc, (k, v)))
122    }
123}
124
125impl<K, V> ExactSizeIterator for IterMut<'_, K, V> {
126    fn len(&self) -> usize {
127        self.inner.len()
128    }
129}
130
131impl<K, V> FusedIterator for IterMut<'_, K, V> {}
132
133impl<K, V> Debug for IterMut<'_, K, V>
134where
135    K: Debug,
136    V: Debug,
137{
138    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
139        self.inner.fmt(f)
140    }
141}
142
143/// An iterator over the keys of a map.
144pub struct Keys<'a, K, V> {
145    inner: Iter<'a, K, V>,
146}
147
148impl<'a, K, V> Keys<'a, K, V> {
149    #[must_use]
150    pub(crate) fn new(entries: &'a [(K, V)]) -> Self {
151        Self { inner: Iter::new(entries) }
152    }
153}
154
155impl<'a, K, V> Iterator for Keys<'a, K, V> {
156    type Item = &'a K;
157
158    fn next(&mut self) -> Option<Self::Item> {
159        self.inner.next().map(|x| x.0)
160    }
161
162    fn size_hint(&self) -> (usize, Option<usize>) {
163        self.inner.size_hint()
164    }
165
166    fn count(self) -> usize {
167        self.inner.count()
168    }
169
170    fn fold<B, F>(self, init: B, mut f: F) -> B
171    where
172        F: FnMut(B, Self::Item) -> B,
173    {
174        self.inner.fold(init, |acc, (k, _)| f(acc, k))
175    }
176}
177
178impl<K, V> DoubleEndedIterator for Keys<'_, K, V> {
179    fn next_back(&mut self) -> Option<Self::Item> {
180        self.inner.next_back().map(|x| x.0)
181    }
182
183    fn rfold<B, F>(self, init: B, mut f: F) -> B
184    where
185        F: FnMut(B, Self::Item) -> B,
186    {
187        self.inner.rfold(init, |acc, (k, _)| f(acc, k))
188    }
189}
190
191impl<K, V> ExactSizeIterator for Keys<'_, K, V> {
192    fn len(&self) -> usize {
193        self.inner.len()
194    }
195}
196
197impl<K, V> FusedIterator for Keys<'_, K, V> {}
198
199impl<K, V> Clone for Keys<'_, K, V> {
200    fn clone(&self) -> Self {
201        Self { inner: self.inner.clone() }
202    }
203}
204
205impl<K, V> Debug for Keys<'_, K, V>
206where
207    K: Debug,
208{
209    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
210        f.debug_list().entries(self.clone()).finish()
211    }
212}
213
214/// An iterator over the values of a map.
215pub struct Values<'a, K, V> {
216    inner: Iter<'a, K, V>,
217}
218
219impl<'a, K, V> Values<'a, K, V> {
220    #[must_use]
221    pub(crate) fn new(entries: &'a [(K, V)]) -> Self {
222        Self { inner: Iter::new(entries) }
223    }
224}
225
226impl<'a, K, V> Iterator for Values<'a, K, V> {
227    type Item = &'a V;
228
229    fn next(&mut self) -> Option<Self::Item> {
230        self.inner.next().map(|x| x.1)
231    }
232
233    fn size_hint(&self) -> (usize, Option<usize>) {
234        self.inner.size_hint()
235    }
236
237    fn count(self) -> usize {
238        self.inner.count()
239    }
240
241    fn fold<B, F>(self, init: B, mut f: F) -> B
242    where
243        F: FnMut(B, Self::Item) -> B,
244    {
245        self.inner.fold(init, |acc, (_, v)| f(acc, v))
246    }
247}
248
249impl<K, V> DoubleEndedIterator for Values<'_, K, V> {
250    fn next_back(&mut self) -> Option<Self::Item> {
251        self.inner.next_back().map(|x| x.1)
252    }
253
254    fn rfold<B, F>(self, init: B, mut f: F) -> B
255    where
256        F: FnMut(B, Self::Item) -> B,
257    {
258        self.inner.rfold(init, |acc, (_, v)| f(acc, v))
259    }
260}
261
262impl<K, V> ExactSizeIterator for Values<'_, K, V> {
263    fn len(&self) -> usize {
264        self.inner.len()
265    }
266}
267
268impl<K, V> FusedIterator for Values<'_, K, V> {}
269
270impl<K, V> Clone for Values<'_, K, V> {
271    fn clone(&self) -> Self {
272        Self { inner: self.inner.clone() }
273    }
274}
275
276impl<K, V> Debug for Values<'_, K, V>
277where
278    V: Debug,
279{
280    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
281        f.debug_list().entries(self.clone()).finish()
282    }
283}
284
285/// An iterator over the mutable values of a map.
286pub struct ValuesMut<'a, K, V> {
287    inner: IterMut<'a, K, V>,
288}
289
290impl<'a, K, V> ValuesMut<'a, K, V> {
291    pub(crate) fn new(entries: &'a mut [(K, V)]) -> Self {
292        Self {
293            inner: IterMut::new(entries),
294        }
295    }
296}
297
298impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
299    type Item = &'a mut V;
300
301    fn next(&mut self) -> Option<Self::Item> {
302        self.inner.next().map(|entry| entry.1)
303    }
304
305    fn size_hint(&self) -> (usize, Option<usize>) {
306        self.inner.size_hint()
307    }
308
309    fn count(self) -> usize {
310        self.inner.count()
311    }
312
313    fn fold<B, F>(self, init: B, mut f: F) -> B
314    where
315        F: FnMut(B, Self::Item) -> B,
316    {
317        self.inner.fold(init, |acc, (_, v)| f(acc, v))
318    }
319}
320
321impl<K, V> DoubleEndedIterator for ValuesMut<'_, K, V> {
322    fn next_back(&mut self) -> Option<Self::Item> {
323        self.inner.next_back().map(|entry| entry.1)
324    }
325
326    fn rfold<B, F>(self, init: B, mut f: F) -> B
327    where
328        F: FnMut(B, Self::Item) -> B,
329    {
330        self.inner.rfold(init, |acc, (_, v)| f(acc, v))
331    }
332}
333
334impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V> {
335    fn len(&self) -> usize {
336        self.inner.len()
337    }
338}
339
340impl<K, V> FusedIterator for ValuesMut<'_, K, V> {}
341
342impl<K, V> Debug for ValuesMut<'_, K, V>
343where
344    K: Debug,
345    V: Debug,
346{
347    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
348        self.inner.fmt(f)
349    }
350}
351
352/// A consuming iterator over the entries in a map.
353pub struct IntoIter<K, V> {
354    inner: alloc::vec::IntoIter<(K, V)>,
355}
356
357impl<K, V> IntoIter<K, V> {
358    pub(crate) fn new(entries: Box<[(K, V)]>) -> Self {
359        Self {
360            inner: entries.into_vec().into_iter(),
361        }
362    }
363}
364
365impl<K, V> Iterator for IntoIter<K, V> {
366    type Item = (K, V);
367
368    fn next(&mut self) -> Option<Self::Item> {
369        self.inner.next()
370    }
371
372    fn size_hint(&self) -> (usize, Option<usize>) {
373        self.inner.size_hint()
374    }
375
376    fn count(self) -> usize {
377        self.inner.count()
378    }
379
380    fn fold<B, F>(self, init: B, mut f: F) -> B
381    where
382        F: FnMut(B, Self::Item) -> B,
383    {
384        self.inner.fold(init, |acc, (k, v)| f(acc, (k, v)))
385    }
386}
387
388impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
389    fn next_back(&mut self) -> Option<Self::Item> {
390        self.inner.next_back()
391    }
392
393    fn rfold<B, F>(self, init: B, mut f: F) -> B
394    where
395        F: FnMut(B, Self::Item) -> B,
396    {
397        self.inner.rfold(init, |acc, (k, v)| f(acc, (k, v)))
398    }
399}
400
401impl<K, V> ExactSizeIterator for IntoIter<K, V> {
402    fn len(&self) -> usize {
403        self.inner.len()
404    }
405}
406
407impl<K, V> FusedIterator for IntoIter<K, V> {}
408
409impl<K, V> Debug for IntoIter<K, V>
410where
411    K: Debug,
412    V: Debug,
413{
414    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
415        self.inner.fmt(f)
416    }
417}
418
419/// A consuming iterator over the keys in a map.
420#[derive(Debug)]
421pub struct IntoKeys<K, V> {
422    inner: IntoIter<K, V>,
423}
424
425impl<K, V> IntoKeys<K, V> {
426    pub(crate) fn new(entries: Box<[(K, V)]>) -> Self {
427        Self {
428            inner: IntoIter::new(entries),
429        }
430    }
431}
432
433impl<K, V> Iterator for IntoKeys<K, V> {
434    type Item = K;
435
436    fn next(&mut self) -> Option<Self::Item> {
437        self.inner.next().map(|x| x.0)
438    }
439
440    fn size_hint(&self) -> (usize, Option<usize>) {
441        self.inner.size_hint()
442    }
443
444    fn count(self) -> usize {
445        self.inner.count()
446    }
447
448    fn fold<B, F>(self, init: B, mut f: F) -> B
449    where
450        F: FnMut(B, Self::Item) -> B,
451    {
452        self.inner.fold(init, |acc, (k, _)| f(acc, k))
453    }
454}
455
456impl<K, V> DoubleEndedIterator for IntoKeys<K, V> {
457    fn next_back(&mut self) -> Option<Self::Item> {
458        self.inner.next_back().map(|x| x.0)
459    }
460
461    fn rfold<B, F>(self, init: B, mut f: F) -> B
462    where
463        F: FnMut(B, Self::Item) -> B,
464    {
465        self.inner.rfold(init, |acc, (k, _)| f(acc, k))
466    }
467}
468
469impl<K, V> ExactSizeIterator for IntoKeys<K, V> {
470    fn len(&self) -> usize {
471        self.inner.len()
472    }
473}
474
475impl<K, V> FusedIterator for IntoKeys<K, V> {}
476
477/// A consuming iterator over the values in a map.
478#[derive(Debug)]
479pub struct IntoValues<K, V> {
480    inner: IntoIter<K, V>,
481}
482
483impl<K, V> IntoValues<K, V> {
484    pub(crate) fn new(entries: Box<[(K, V)]>) -> Self {
485        Self {
486            inner: IntoIter::new(entries),
487        }
488    }
489}
490
491impl<K, V> Iterator for IntoValues<K, V> {
492    type Item = V;
493
494    fn next(&mut self) -> Option<Self::Item> {
495        self.inner.next().map(|x| x.1)
496    }
497
498    fn size_hint(&self) -> (usize, Option<usize>) {
499        self.inner.size_hint()
500    }
501
502    fn count(self) -> usize {
503        self.inner.count()
504    }
505
506    fn fold<B, F>(self, init: B, mut f: F) -> B
507    where
508        F: FnMut(B, Self::Item) -> B,
509    {
510        self.inner.fold(init, |acc, (_, v)| f(acc, v))
511    }
512}
513
514impl<K, V> DoubleEndedIterator for IntoValues<K, V> {
515    fn next_back(&mut self) -> Option<Self::Item> {
516        self.inner.next_back().map(|x| x.1)
517    }
518
519    fn rfold<B, F>(self, init: B, mut f: F) -> B
520    where
521        F: FnMut(B, Self::Item) -> B,
522    {
523        self.inner.rfold(init, |acc, (_, v)| f(acc, v))
524    }
525}
526
527impl<K, V> ExactSizeIterator for IntoValues<K, V> {
528    fn len(&self) -> usize {
529        self.inner.len()
530    }
531}
532
533impl<K, V> FusedIterator for IntoValues<K, V> {}
534
535#[cfg(test)]
536mod tests {
537    use super::*;
538    use alloc::{format, vec};
539
540    #[test]
541    fn test_iter() {
542        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3), ("Tom", 4)];
543        let iter = Iter::new(&entries);
544        assert_eq!(entries.len(), iter.len());
545
546        let collected: Vec<_> = iter.collect();
547        assert_eq!(collected, vec![(&"Alice", &1), (&"Bob", &2), (&"Sandy", &3), (&"Tom", &4)]);
548    }
549
550    #[test]
551    fn test_iter_count() {
552        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3), ("Tom", 4)];
553        let iter = Iter::new(&entries);
554        assert_eq!(entries.len(), iter.len());
555        assert_eq!(entries.len(), iter.count());
556    }
557
558    #[test]
559    fn test_iter_empty() {
560        let entries: Vec<(&str, i32)> = vec![];
561        let mut iter = Iter::new(&entries);
562        assert_eq!(0, iter.len());
563        assert!(iter.next().is_none());
564    }
565
566    #[test]
567    fn test_iter_debug() {
568        let entries = vec![("Alice", 1), ("Bob", 2)];
569        let iter = Iter::new(&entries);
570
571        let debug_str = format!("{iter:?}");
572        assert!(debug_str.contains("Alice"));
573        assert!(debug_str.contains("Bob"));
574    }
575
576    #[test]
577    fn test_iter_mut() {
578        let mut entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3), ("Tom", 4)];
579        let iter_mut = IterMut::new(&mut entries);
580
581        for (_, v) in iter_mut {
582            *v += 1;
583        }
584
585        let expected = vec![("Alice", 2), ("Bob", 3), ("Sandy", 4), ("Tom", 5)];
586        assert_eq!(entries, expected);
587    }
588
589    #[test]
590    fn test_iter_mut_count() {
591        let mut entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3), ("Tom", 4)];
592        let iter_mut = IterMut::new(&mut entries);
593        assert_eq!(4, iter_mut.count());
594    }
595
596    #[test]
597    fn test_iter_mut_empty() {
598        let mut entries: Vec<(&str, i32)> = vec![];
599        let mut iter_mut = IterMut::new(&mut entries);
600        assert_eq!(0, iter_mut.len());
601        assert!(iter_mut.next().is_none());
602    }
603
604    #[test]
605    fn test_iter_size_hint() {
606        let entries = vec![("Alice", 1), ("Bob", 2)];
607        let iter = Iter::new(&entries);
608
609        assert_eq!(iter.size_hint(), (2, Some(2)));
610    }
611
612    #[test]
613    fn test_iter_mut_size_hint() {
614        let mut entries = vec![("Alice", 1), ("Bob", 2)];
615        let iter_mut = IterMut::new(&mut entries);
616
617        assert_eq!(iter_mut.size_hint(), (2, Some(2)));
618    }
619
620    #[test]
621    fn test_iter_clone() {
622        let entries = vec![("Alice", 1), ("Bob", 2)];
623        let iter = Iter::new(&entries);
624        let iter_clone = iter.clone();
625
626        let collected: Vec<_> = iter_clone.collect();
627        assert_eq!(collected, vec![(&"Alice", &1), (&"Bob", &2)]);
628    }
629
630    #[test]
631    fn test_iter_mut_debug() {
632        let mut entries = vec![("Alice", 1), ("Bob", 2)];
633        let iter_mut = IterMut::new(&mut entries);
634
635        let debug_str = format!("{iter_mut:?}");
636        assert!(debug_str.contains("Alice"));
637        assert!(debug_str.contains("Bob"));
638    }
639
640    #[test]
641    fn test_keys() {
642        let entries = vec![("Alice", 1), ("Bob", 2)];
643        let keys = Keys::new(&entries);
644        assert_eq!(entries.len(), keys.len());
645
646        let collected: Vec<_> = keys.collect();
647        assert_eq!(collected, vec![&"Alice", &"Bob"]);
648    }
649
650    #[test]
651    fn test_keys_count() {
652        let entries = vec![("Alice", 1), ("Bob", 2)];
653        let keys = Keys::new(&entries);
654        assert_eq!(2, keys.count());
655    }
656
657    #[test]
658    fn test_keys_empty() {
659        let entries: Vec<(&str, i32)> = vec![];
660        let mut keys = Keys::new(&entries);
661        assert_eq!(0, keys.len());
662        assert!(keys.next().is_none());
663    }
664
665    #[test]
666    fn test_keys_size_hint() {
667        let entries = vec![("Alice", 1), ("Bob", 2)];
668        let keys = Keys::new(&entries);
669
670        assert_eq!(keys.size_hint(), (2, Some(2)));
671    }
672
673    #[test]
674    fn test_keys_clone() {
675        let entries = vec![("Alice", 1), ("Bob", 2)];
676        let keys = Keys::new(&entries);
677        let keys_clone = keys.clone();
678
679        let collected: Vec<_> = keys_clone.collect();
680        assert_eq!(collected, vec![&"Alice", &"Bob"]);
681    }
682
683    #[test]
684    fn test_keys_debug() {
685        let entries = vec![("Alice", 1), ("Bob", 2)];
686        let keys = Keys::new(&entries);
687
688        let debug_str = format!("{keys:?}");
689        assert!(debug_str.contains("Alice"));
690        assert!(debug_str.contains("Bob"));
691    }
692
693    #[test]
694    fn test_values() {
695        let entries = vec![("Alice", 1), ("Bob", 2)];
696        let values = Values::new(&entries);
697        assert_eq!(entries.len(), values.len());
698
699        let collected: Vec<_> = values.collect();
700        assert_eq!(collected, vec![&1, &2]);
701    }
702
703    #[test]
704    fn test_values_count() {
705        let entries = vec![("Alice", 1), ("Bob", 2)];
706        let values = Values::new(&entries);
707        assert_eq!(2, values.count());
708    }
709
710    #[test]
711    fn test_values_empty() {
712        let entries: Vec<(&str, i32)> = vec![];
713        let mut values = Values::new(&entries);
714        assert_eq!(0, values.len());
715        assert!(values.next().is_none());
716    }
717
718    #[test]
719    fn test_values_size_hint() {
720        let entries = vec![("Alice", 1), ("Bob", 2)];
721        let values = Values::new(&entries);
722
723        assert_eq!(values.size_hint(), (2, Some(2)));
724    }
725
726    #[test]
727    fn test_values_clone() {
728        let entries = vec![("Alice", 1), ("Bob", 2)];
729        let values = Values::new(&entries);
730        let values_clone = values.clone();
731
732        let collected: Vec<_> = values_clone.collect();
733        assert_eq!(collected, vec![&1, &2]);
734    }
735
736    #[test]
737    fn test_values_debug() {
738        let entries = vec![("Alice", 1), ("Bob", 2)];
739        let values = Values::new(&entries);
740
741        let debug_str = format!("{values:?}");
742        assert!(debug_str.contains('1'));
743        assert!(debug_str.contains('2'));
744    }
745
746    #[test]
747    fn test_into_keys() {
748        let entries = vec![("Alice", 1), ("Bob", 2)];
749        let into_keys = IntoKeys::new(entries.into_boxed_slice());
750        assert_eq!(2, into_keys.len());
751
752        let collected: Vec<_> = into_keys.collect();
753        assert_eq!(collected, vec!["Alice", "Bob"]);
754    }
755
756    #[test]
757    fn test_into_keys_count() {
758        let entries = vec![("Alice", 1), ("Bob", 2)];
759        let into_keys = IntoKeys::new(entries.into_boxed_slice());
760        assert_eq!(2, into_keys.count());
761    }
762
763    #[test]
764    fn test_into_keys_empty() {
765        let entries: Vec<(&str, i32)> = vec![];
766        let mut into_keys = IntoKeys::new(entries.into_boxed_slice());
767        assert_eq!(0, into_keys.len());
768        assert!(into_keys.next().is_none());
769    }
770
771    #[test]
772    fn test_into_keys_size_hint() {
773        let entries = vec![("Alice", 1), ("Bob", 2)];
774        let into_keys = IntoKeys::new(entries.into_boxed_slice());
775
776        assert_eq!(into_keys.size_hint(), (2, Some(2)));
777    }
778
779    #[test]
780    fn test_into_values() {
781        let entries = vec![("Alice", 1), ("Bob", 2)];
782        let into_values = IntoValues::new(entries.into_boxed_slice());
783        assert_eq!(2, into_values.len());
784
785        let collected: Vec<_> = into_values.collect();
786        assert_eq!(collected, vec![1, 2]);
787    }
788
789    #[test]
790    fn test_into_values_count() {
791        let entries = vec![("Alice", 1), ("Bob", 2)];
792        let into_values = IntoValues::new(entries.into_boxed_slice());
793        assert_eq!(2, into_values.count());
794    }
795
796    #[test]
797    fn test_into_values_empty() {
798        let entries: Vec<(&str, i32)> = vec![];
799        let mut into_values = IntoValues::new(entries.into_boxed_slice());
800        assert_eq!(0, into_values.len());
801        assert!(into_values.next().is_none());
802    }
803
804    #[test]
805    fn test_into_values_size_hint() {
806        let entries = vec![("Alice", 1), ("Bob", 2)];
807        let into_values = IntoValues::new(entries.into_boxed_slice());
808        assert_eq!(into_values.size_hint(), (2, Some(2)));
809    }
810
811    #[test]
812    fn test_values_mut() {
813        let mut entries = vec![("Alice", 1), ("Bob", 2)];
814        let values_mut = ValuesMut::new(&mut entries);
815        assert_eq!(2, values_mut.len());
816
817        for v in values_mut {
818            *v += 1;
819        }
820
821        let expected = vec![("Alice", 2), ("Bob", 3)];
822        assert_eq!(entries, expected);
823    }
824
825    #[test]
826    fn test_values_mut_count() {
827        let mut entries = vec![("Alice", 1), ("Bob", 2)];
828        let values_mut = ValuesMut::new(&mut entries);
829        assert_eq!(2, values_mut.count());
830    }
831
832    #[test]
833    fn test_values_mut_empty() {
834        let mut entries: Vec<(&str, i32)> = vec![];
835        let mut values_mut = ValuesMut::new(&mut entries);
836        assert_eq!(0, values_mut.len());
837        assert!(values_mut.next().is_none());
838    }
839
840    #[test]
841    fn test_values_mut_size_hint() {
842        let mut entries = vec![("Alice", 1), ("Bob", 2)];
843        let values_mut = ValuesMut::new(&mut entries);
844        assert_eq!(values_mut.size_hint(), (2, Some(2)));
845    }
846
847    #[test]
848    fn test_values_mut_debug() {
849        let mut entries = vec![("Alice", 1), ("Bob", 2)];
850        let values_mut = ValuesMut::new(&mut entries);
851
852        let debug_str = format!("{values_mut:?}");
853        assert!(debug_str.contains("Alice"));
854        assert!(debug_str.contains("Bob"));
855    }
856
857    #[test]
858    fn test_into_iter() {
859        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3), ("Tom", 4)];
860        let into_iter = IntoIter::new(entries.into_boxed_slice());
861        assert_eq!(4, into_iter.len());
862
863        let collected: Vec<_> = into_iter.collect();
864        assert_eq!(collected, vec![("Alice", 1), ("Bob", 2), ("Sandy", 3), ("Tom", 4)]);
865    }
866
867    #[test]
868    fn test_into_iter_count() {
869        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3), ("Tom", 4)];
870        let into_iter = IntoIter::new(entries.into_boxed_slice());
871        assert_eq!(4, into_iter.count());
872    }
873
874    #[test]
875    fn test_into_iter_empty() {
876        let entries: Vec<(&str, i32)> = vec![];
877        let mut into_iter = IntoIter::new(entries.into_boxed_slice());
878        assert_eq!(0, into_iter.len());
879        assert!(into_iter.next().is_none());
880    }
881
882    #[test]
883    fn test_into_iter_size_hint() {
884        let entries = vec![("Alice", 1), ("Bob", 2)];
885        let into_iter = IntoIter::new(entries.into_boxed_slice());
886
887        assert_eq!(into_iter.size_hint(), (2, Some(2)));
888    }
889
890    #[test]
891    fn test_into_iter_debug() {
892        let entries = vec![("Alice", 1), ("Bob", 2)];
893        let into_iter = IntoIter::new(entries.into_boxed_slice());
894
895        let debug_str = format!("{into_iter:?}");
896        assert!(debug_str.contains("Alice"));
897        assert!(debug_str.contains("Bob"));
898    }
899
900    #[test]
901    fn test_iter_rev() {
902        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3), ("Tom", 4)];
903        let iter = Iter::new(&entries);
904        let collected: Vec<_> = iter.rev().collect();
905        assert_eq!(collected, vec![(&"Tom", &4), (&"Sandy", &3), (&"Bob", &2), (&"Alice", &1)]);
906    }
907
908    #[test]
909    fn test_iter_next_back() {
910        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
911        let mut iter = Iter::new(&entries);
912        assert_eq!(iter.next(), Some((&"Alice", &1)));
913        assert_eq!(iter.next_back(), Some((&"Sandy", &3)));
914        assert_eq!(iter.next(), Some((&"Bob", &2)));
915        assert_eq!(iter.next_back(), None);
916    }
917
918    #[test]
919    fn test_iter_rfold() {
920        let entries = vec![("Alice", 1), ("Bob", 2)];
921        let iter = Iter::new(&entries);
922        let result: Vec<_> = iter.rfold(Vec::new(), |mut acc, (k, v)| {
923            acc.push((k, v));
924            acc
925        });
926        assert_eq!(result, vec![(&"Bob", &2), (&"Alice", &1)]);
927    }
928
929    #[test]
930    fn test_iter_fold() {
931        let entries = vec![("Alice", 1), ("Bob", 2)];
932        let iter = Iter::new(&entries);
933        let result: Vec<_> = iter.fold(Vec::new(), |mut acc, (k, v)| {
934            acc.push((k, v));
935            acc
936        });
937        assert_eq!(result, vec![(&"Alice", &1), (&"Bob", &2)]);
938    }
939
940    #[test]
941    fn test_iter_mut_rev() {
942        let mut entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
943        let iter_mut = IterMut::new(&mut entries);
944        let collected: Vec<_> = iter_mut.rev().map(|(k, v)| (*k, *v)).collect();
945        assert_eq!(collected, vec![("Sandy", 3), ("Bob", 2), ("Alice", 1)]);
946    }
947
948    #[test]
949    fn test_iter_mut_next_back() {
950        let mut entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
951        let mut iter_mut = IterMut::new(&mut entries);
952        assert_eq!(iter_mut.next().map(|(k, v)| (*k, *v)), Some(("Alice", 1)));
953        assert_eq!(iter_mut.next_back().map(|(k, v)| (*k, *v)), Some(("Sandy", 3)));
954        assert_eq!(iter_mut.next().map(|(k, v)| (*k, *v)), Some(("Bob", 2)));
955        assert_eq!(iter_mut.next_back(), None);
956    }
957
958    #[test]
959    fn test_iter_mut_rfold() {
960        let mut entries = vec![("Alice", 1), ("Bob", 2)];
961        let iter_mut = IterMut::new(&mut entries);
962        let result: Vec<_> = iter_mut.rfold(Vec::new(), |mut acc, (k, v)| {
963            acc.push((*k, *v));
964            acc
965        });
966        assert_eq!(result, vec![("Bob", 2), ("Alice", 1)]);
967    }
968
969    #[test]
970    fn test_iter_mut_fold() {
971        let mut entries = vec![("Alice", 1), ("Bob", 2)];
972        let iter_mut = IterMut::new(&mut entries);
973        let result: Vec<_> = iter_mut.fold(Vec::new(), |mut acc, (k, v)| {
974            acc.push((*k, *v));
975            acc
976        });
977        assert_eq!(result, vec![("Alice", 1), ("Bob", 2)]);
978    }
979
980    #[test]
981    fn test_keys_rev() {
982        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
983        let keys = Keys::new(&entries);
984        let collected: Vec<_> = keys.rev().collect();
985        assert_eq!(collected, vec![&"Sandy", &"Bob", &"Alice"]);
986    }
987
988    #[test]
989    fn test_keys_next_back() {
990        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
991        let mut keys = Keys::new(&entries);
992        assert_eq!(keys.next(), Some(&"Alice"));
993        assert_eq!(keys.next_back(), Some(&"Sandy"));
994        assert_eq!(keys.next(), Some(&"Bob"));
995        assert_eq!(keys.next_back(), None);
996    }
997
998    #[test]
999    fn test_keys_rfold() {
1000        let entries = vec![("Alice", 1), ("Bob", 2)];
1001        let keys = Keys::new(&entries);
1002        let result: Vec<_> = keys.rfold(Vec::new(), |mut acc, k| {
1003            acc.push(k);
1004            acc
1005        });
1006        assert_eq!(result, vec![&"Bob", &"Alice"]);
1007    }
1008
1009    #[test]
1010    fn test_keys_fold() {
1011        let entries = vec![("Alice", 1), ("Bob", 2)];
1012        let keys = Keys::new(&entries);
1013        let result: Vec<_> = keys.fold(Vec::new(), |mut acc, k| {
1014            acc.push(k);
1015            acc
1016        });
1017        assert_eq!(result, vec![&"Alice", &"Bob"]);
1018    }
1019
1020    #[test]
1021    fn test_values_rev() {
1022        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
1023        let values = Values::new(&entries);
1024        let collected: Vec<_> = values.rev().collect();
1025        assert_eq!(collected, vec![&3, &2, &1]);
1026    }
1027
1028    #[test]
1029    fn test_values_next_back() {
1030        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
1031        let mut values = Values::new(&entries);
1032        assert_eq!(values.next(), Some(&1));
1033        assert_eq!(values.next_back(), Some(&3));
1034        assert_eq!(values.next(), Some(&2));
1035        assert_eq!(values.next_back(), None);
1036    }
1037
1038    #[test]
1039    fn test_values_rfold() {
1040        let entries = vec![("Alice", 1), ("Bob", 2)];
1041        let values = Values::new(&entries);
1042        let result: Vec<_> = values.rfold(Vec::new(), |mut acc, v| {
1043            acc.push(v);
1044            acc
1045        });
1046        assert_eq!(result, vec![&2, &1]);
1047    }
1048
1049    #[test]
1050    fn test_values_fold() {
1051        let entries = vec![("Alice", 1), ("Bob", 2)];
1052        let values = Values::new(&entries);
1053        let result: Vec<_> = values.fold(Vec::new(), |mut acc, v| {
1054            acc.push(v);
1055            acc
1056        });
1057        assert_eq!(result, vec![&1, &2]);
1058    }
1059
1060    #[test]
1061    fn test_values_mut_rev() {
1062        let mut entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
1063        let values_mut = ValuesMut::new(&mut entries);
1064        let collected: Vec<_> = values_mut.rev().map(|v| *v).collect();
1065        assert_eq!(collected, vec![3, 2, 1]);
1066    }
1067
1068    #[test]
1069    fn test_values_mut_next_back() {
1070        let mut entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
1071        let mut values_mut = ValuesMut::new(&mut entries);
1072        assert_eq!(values_mut.next().map(|v| *v), Some(1));
1073        assert_eq!(values_mut.next_back().map(|v| *v), Some(3));
1074        assert_eq!(values_mut.next().map(|v| *v), Some(2));
1075        assert_eq!(values_mut.next_back(), None);
1076    }
1077
1078    #[test]
1079    fn test_values_mut_rfold() {
1080        let mut entries = vec![("Alice", 1), ("Bob", 2)];
1081        let values_mut = ValuesMut::new(&mut entries);
1082        let result: Vec<_> = values_mut.rfold(Vec::new(), |mut acc, v| {
1083            acc.push(*v);
1084            acc
1085        });
1086        assert_eq!(result, vec![2, 1]);
1087    }
1088
1089    #[test]
1090    fn test_values_mut_fold() {
1091        let mut entries = vec![("Alice", 1), ("Bob", 2)];
1092        let values_mut = ValuesMut::new(&mut entries);
1093        let result: Vec<_> = values_mut.fold(Vec::new(), |mut acc, v| {
1094            acc.push(*v);
1095            acc
1096        });
1097        assert_eq!(result, vec![1, 2]);
1098    }
1099
1100    #[test]
1101    fn test_into_iter_rev() {
1102        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
1103        let into_iter = IntoIter::new(entries.into_boxed_slice());
1104        let collected: Vec<_> = into_iter.rev().collect();
1105        assert_eq!(collected, vec![("Sandy", 3), ("Bob", 2), ("Alice", 1)]);
1106    }
1107
1108    #[test]
1109    fn test_into_iter_next_back() {
1110        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
1111        let mut into_iter = IntoIter::new(entries.into_boxed_slice());
1112        assert_eq!(into_iter.next(), Some(("Alice", 1)));
1113        assert_eq!(into_iter.next_back(), Some(("Sandy", 3)));
1114        assert_eq!(into_iter.next(), Some(("Bob", 2)));
1115        assert_eq!(into_iter.next_back(), None);
1116    }
1117
1118    #[test]
1119    fn test_into_iter_rfold() {
1120        let entries = vec![("Alice", 1), ("Bob", 2)];
1121        let into_iter = IntoIter::new(entries.into_boxed_slice());
1122        let result: Vec<_> = into_iter.rfold(Vec::new(), |mut acc, (k, v)| {
1123            acc.push((k, v));
1124            acc
1125        });
1126        assert_eq!(result, vec![("Bob", 2), ("Alice", 1)]);
1127    }
1128
1129    #[test]
1130    fn test_into_iter_fold() {
1131        let entries = vec![("Alice", 1), ("Bob", 2)];
1132        let into_iter = IntoIter::new(entries.into_boxed_slice());
1133        let result: Vec<_> = into_iter.fold(Vec::new(), |mut acc, (k, v)| {
1134            acc.push((k, v));
1135            acc
1136        });
1137        assert_eq!(result, vec![("Alice", 1), ("Bob", 2)]);
1138    }
1139
1140    #[test]
1141    fn test_into_keys_rev() {
1142        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
1143        let into_keys = IntoKeys::new(entries.into_boxed_slice());
1144        let collected: Vec<_> = into_keys.rev().collect();
1145        assert_eq!(collected, vec!["Sandy", "Bob", "Alice"]);
1146    }
1147
1148    #[test]
1149    fn test_into_keys_next_back() {
1150        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
1151        let mut into_keys = IntoKeys::new(entries.into_boxed_slice());
1152        assert_eq!(into_keys.next(), Some("Alice"));
1153        assert_eq!(into_keys.next_back(), Some("Sandy"));
1154        assert_eq!(into_keys.next(), Some("Bob"));
1155        assert_eq!(into_keys.next_back(), None);
1156    }
1157
1158    #[test]
1159    fn test_into_keys_rfold() {
1160        let entries = vec![("Alice", 1), ("Bob", 2)];
1161        let into_keys = IntoKeys::new(entries.into_boxed_slice());
1162        let result: Vec<_> = into_keys.rfold(Vec::new(), |mut acc, k| {
1163            acc.push(k);
1164            acc
1165        });
1166        assert_eq!(result, vec!["Bob", "Alice"]);
1167    }
1168
1169    #[test]
1170    fn test_into_keys_fold() {
1171        let entries = vec![("Alice", 1), ("Bob", 2)];
1172        let into_keys = IntoKeys::new(entries.into_boxed_slice());
1173        let result: Vec<_> = into_keys.fold(Vec::new(), |mut acc, k| {
1174            acc.push(k);
1175            acc
1176        });
1177        assert_eq!(result, vec!["Alice", "Bob"]);
1178    }
1179
1180    #[test]
1181    fn test_into_values_rev() {
1182        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
1183        let into_values = IntoValues::new(entries.into_boxed_slice());
1184        let collected: Vec<_> = into_values.rev().collect();
1185        assert_eq!(collected, vec![3, 2, 1]);
1186    }
1187
1188    #[test]
1189    fn test_into_values_next_back() {
1190        let entries = vec![("Alice", 1), ("Bob", 2), ("Sandy", 3)];
1191        let mut into_values = IntoValues::new(entries.into_boxed_slice());
1192        assert_eq!(into_values.next(), Some(1));
1193        assert_eq!(into_values.next_back(), Some(3));
1194        assert_eq!(into_values.next(), Some(2));
1195        assert_eq!(into_values.next_back(), None);
1196    }
1197
1198    #[test]
1199    fn test_into_values_rfold() {
1200        let entries = vec![("Alice", 1), ("Bob", 2)];
1201        let into_values = IntoValues::new(entries.into_boxed_slice());
1202        let result: Vec<_> = into_values.rfold(Vec::new(), |mut acc, v| {
1203            acc.push(v);
1204            acc
1205        });
1206        assert_eq!(result, vec![2, 1]);
1207    }
1208
1209    #[test]
1210    fn test_into_values_fold() {
1211        let entries = vec![("Alice", 1), ("Bob", 2)];
1212        let into_values = IntoValues::new(entries.into_boxed_slice());
1213        let result: Vec<_> = into_values.fold(Vec::new(), |mut acc, v| {
1214            acc.push(v);
1215            acc
1216        });
1217        assert_eq!(result, vec![1, 2]);
1218    }
1219}
frozen_collections_core/maps/iterators.rs

frozen_collections_core/maps/
iterators.rs
