total_order_multi_map/
iter.rs

1//TODO merge file with map_iter
2use std::hash::Hash;
3use std::cmp::Eq;
4use std::slice;
5use std::fmt::{ self, Debug };
6use std::ops::DerefMut;
7use std::iter::ExactSizeIterator;
8
9use stable_deref_trait::StableDeref;
10
11use super::TotalOrderMultiMap;
12
13impl<K, V> TotalOrderMultiMap<K, V>
14    where K: Hash + Eq + Copy,
15          V: StableDeref + DerefMut,
16{
17    /// Returns a iterator over the key value pairs in insertion order.
18    ///
19    /// As this is a multi map a key can appear more than one time.
20    pub fn iter(&self) -> Iter<K, V> {
21        Iter {
22            vec_iter: self.vec_data.iter()
23        }
24    }
25
26}
27
28/// Iterator over TotalOrderMultimap in insertion order.
29pub struct Iter<'a, K: 'a, V: 'a> {
30    vec_iter: slice::Iter<'a, (K, V)>
31}
32
33impl<'a, K, V> Clone for Iter<'a, K, V> {
34    fn clone(&self) -> Self {
35        Iter { vec_iter: self.vec_iter.clone() }
36    }
37}
38
39impl<'a, K, V> Debug for Iter<'a, K, V>
40    where K: Hash + Eq + Copy + Debug,
41          V: StableDeref + DerefMut,
42          V::Target: Debug
43{
44    fn fmt(&self, fter: &mut fmt::Formatter) -> fmt::Result {
45        fter.debug_list().entries(self.clone()).finish()
46    }
47}
48
49impl<'a, K, V> Iterator for Iter<'a, K,V>
50    where K: Hash + Eq + Copy,
51          V: StableDeref + DerefMut
52{
53    type Item = (K, &'a V::Target);
54
55    fn next(&mut self) -> Option<Self::Item> {
56        self.vec_iter.next()
57            .map( |&(ref key, ref value)| {
58                (*key, &**value)
59            } )
60    }
61
62    fn size_hint(&self) -> (usize, Option<usize>) {
63        self.vec_iter.size_hint()
64    }
65}
66
67impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V>
68    where K: Hash + Eq + Copy,
69          V: StableDeref + DerefMut
70{
71    fn len(&self) -> usize {
72        self.vec_iter.len()
73    }
74}
75
76
77impl<K, V> TotalOrderMultiMap<K, V>
78    where K: Hash + Eq + Copy,
79          V: StableDeref + DerefMut
80{
81    pub fn iter_mut(&mut self) -> IterMut<K, V> {
82        IterMut {
83            vec_iter: self.vec_data.iter_mut()
84        }
85    }
86}
87
88pub struct IterMut<'a, K: 'a, V: 'a> {
89    vec_iter: slice::IterMut<'a, (K, V)>
90}
91
92impl<'a, K: 'a, V: 'a> From<IterMut<'a, K, V>> for Iter<'a, K, V> {
93    fn from(valsmut: IterMut<'a, K, V>) -> Self {
94        let IterMut { vec_iter } = valsmut;
95        let as_slice = vec_iter.into_slice();
96        let vec_iter = as_slice.iter();
97        Iter { vec_iter }
98    }
99}
100
101impl<'a, K, V> Iterator for IterMut<'a, K, V>
102    where K: Hash + Eq + Copy,
103          V: StableDeref + DerefMut
104{
105    type Item = (K, &'a mut V::Target);
106
107    fn next(&mut self) -> Option<Self::Item> {
108        self.vec_iter.next()
109            .map(|&mut (ref key, ref mut value)| {
110                (*key, &mut **value)
111            })
112    }
113
114    fn size_hint(&self) -> (usize, Option<usize>) {
115        self.vec_iter.size_hint()
116    }
117}
118
119impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V>
120    where K: Hash + Eq + Copy,
121          V: StableDeref + DerefMut
122{
123    fn len(&self) -> usize {
124        self.vec_iter.len()
125    }
126}
127
128impl<'a, K, V> Debug for IterMut<'a, K, V>
129    where K: Hash + Eq + Copy + Debug,
130          V: StableDeref + DerefMut+ DerefMut,
131          V::Target: Debug
132{
133    fn fmt(&self, fter: &mut fmt::Formatter) -> fmt::Result {
134        fter.write_str("IterMut { .. }")
135    }
136}
137
138#[cfg(test)]
139mod tests {
140    use super::*;
141
142    #[test]
143    fn convert_iter_mut_to_non_mut() {
144        let mut map = TotalOrderMultiMap::new();
145        map.add("k1", "v1".to_owned());
146        let iter: Iter<_,_> = map.iter_mut().into();
147        assert_eq!(
148            vec![("k1", "v1")],
149            iter.collect::<Vec<_>>()
150        )
151    }
152
153}
total_order_multi_map/iter.rs

total_order_multi_map/
iter.rs
