micromap_rawl/
values.rs

1use crate::{IntoValues, Map, Values, ValuesMut};
2use core::iter::FusedIterator;
3
4impl<K: PartialEq, V, const N: usize> Map<K, V, N> {
5    /// An iterator visiting all values in arbitrary order.
6    #[inline]
7    pub fn values(&self) -> Values<'_, K, V> {
8        Values { iter: self.iter() }
9    }
10
11    /// An iterator visiting all values mutably in arbitrary order.
12    #[inline]
13    pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
14        ValuesMut {
15            iter: self.iter_mut(),
16        }
17    }
18
19    /// Consuming iterator visiting all the values in arbitrary order.
20    #[inline]
21    pub fn into_values(self) -> IntoValues<K, V, N> {
22        IntoValues {
23            iter: self.into_iter(),
24        }
25    }
26}
27
28impl<'a, K, V> Iterator for Values<'a, K, V> {
29    type Item = &'a V;
30
31    #[inline]
32    fn next(&mut self) -> Option<Self::Item> {
33        self.iter.next().map(|p| p.1)
34    }
35
36    #[inline]
37    fn size_hint(&self) -> (usize, Option<usize>) {
38        self.iter.size_hint()
39    }
40}
41
42impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
43    type Item = &'a mut V;
44
45    #[inline]
46    fn next(&mut self) -> Option<Self::Item> {
47        self.iter.next().map(|p| p.1)
48    }
49
50    #[inline]
51    fn size_hint(&self) -> (usize, Option<usize>) {
52        self.iter.size_hint()
53    }
54}
55
56impl<K: PartialEq, V, const N: usize> Iterator for IntoValues<K, V, N> {
57    type Item = V;
58
59    #[inline]
60    fn next(&mut self) -> Option<V> {
61        self.iter.next().map(|p| p.1)
62    }
63
64    #[inline]
65    fn size_hint(&self) -> (usize, Option<usize>) {
66        self.iter.size_hint()
67    }
68}
69
70impl<K, V> ExactSizeIterator for Values<'_, K, V> {
71    fn len(&self) -> usize {
72        self.iter.len()
73    }
74}
75
76impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V> {
77    fn len(&self) -> usize {
78        self.iter.len()
79    }
80}
81
82impl<K: PartialEq, V, const N: usize> ExactSizeIterator for IntoValues<K, V, N> {
83    fn len(&self) -> usize {
84        self.iter.len()
85    }
86}
87
88impl<K, V> FusedIterator for Values<'_, K, V> {}
89
90impl<K, V> FusedIterator for ValuesMut<'_, K, V> {}
91
92impl<K: PartialEq, V, const N: usize> FusedIterator for IntoValues<K, V, N> {}
93
94#[cfg(test)]
95mod test {
96    use super::*;
97
98    #[test]
99    fn iterate_values() {
100        let mut m: Map<String, i32, 10> = Map::new();
101        m.insert("one".to_string(), 42);
102        m.insert("two".to_string(), 16);
103        assert_eq!(58, m.values().sum());
104    }
105
106    #[test]
107    fn iterate_values_mut() {
108        let mut m: Map<String, i32, 10> = Map::new();
109        m.insert("one".to_string(), 42);
110        m.insert("two".to_string(), 16);
111        m.values_mut().for_each(|v| *v *= 2);
112        assert_eq!(116, m.values().sum());
113    }
114
115    #[test]
116    fn iterate_values_with_blanks() {
117        let mut m: Map<String, i32, 10> = Map::new();
118        m.insert("one".to_string(), 1);
119        m.insert("two".to_string(), 3);
120        m.insert("three".to_string(), 5);
121        m.remove("two");
122        assert_eq!(m.values().collect::<Vec<_>>(), [&1, &5]);
123    }
124
125    #[test]
126    fn into_values_drop() {
127        use std::rc::Rc;
128        let mut m: Map<i32, Rc<()>, 8> = Map::new();
129        let v = Rc::new(());
130        for i in 0..8 {
131            m.insert(i, Rc::clone(&v));
132        }
133        assert_eq!(9, Rc::strong_count(&v));
134        m.into_values();
135        assert_eq!(1, Rc::strong_count(&v));
136    }
137}
micromap_rawl/values.rs

micromap_rawl/
values.rs
