total_order_multi_map/
map_iter.rs

1use std::collections::hash_map;
2use std::slice;
3use std::hash::Hash;
4use std::cmp::Eq;
5use std::ops::DerefMut;
6use std::fmt::{self, Debug};
7use std::iter::{Iterator, ExactSizeIterator};
8
9use stable_deref_trait::StableDeref;
10
11
12use super::TotalOrderMultiMap;
13
14
15impl<K, V> TotalOrderMultiMap<K, V>
16    where K: Hash+Eq+Copy,
17          V: StableDeref + DerefMut
18{
19    /// Return an iterator the keys of this multi map.
20    ///
21    /// each key will only be returned once, there is
22    /// no specific order in which they keys are returned
23    pub fn keys(&self) -> Keys<K, V::Target> {
24        Keys { inner_iter: self.map_access.keys() }
25    }
26
27    /// Returns a iterator over all values grouped by key.
28    pub fn group_iter(&self) -> GroupedValues<K, V::Target> {
29        GroupedValues { inner_iter: self.map_access.iter() }
30    }
31
32    /// Returns a iterator over all values grouped by key
33    pub fn group_iter_mut(&mut self) -> GroupedValuesMut<K, V::Target> {
34        GroupedValuesMut { inner_iter: self.map_access.iter_mut() }
35    }
36
37    /// Returns a iterator over the inner-values in this multi map.
38    ///
39    /// Inner-Values are returned in the order they where inserted into
40    /// the map. Note that
41    pub fn values(&self) -> Values<K, V> {
42        Values { inner_iter: self.vec_data.iter() }
43    }
44
45
46    /// Returns a iterator over the values in this multi map.
47    pub fn values_mut(&mut self) -> ValuesMut<K, V> {
48        ValuesMut { inner_iter: self.vec_data.iter_mut() }
49    }
50}
51
52#[derive(Clone)]
53pub struct Keys<'a, K: 'a, T: ?Sized + 'a> {
54    inner_iter: hash_map::Keys<'a, K, Vec<*mut T>>
55}
56
57impl<'a, K: Debug+'a, T: 'a> Debug for Keys<'a, K, T> {
58    fn fmt(&self, fter: &mut fmt::Formatter) -> fmt::Result {
59        self.inner_iter.fmt(fter)
60    }
61}
62
63impl<'a, K: 'a, T: 'a> Iterator for Keys<'a, K, T>
64    where K: Copy
65{
66    type Item = K;
67
68    #[inline]
69    fn next(&mut self) -> Option<Self::Item> {
70        self.inner_iter.next().map(|&k|k)
71    }
72
73    #[inline]
74    fn size_hint(&self) -> (usize, Option<usize>) {
75        self.inner_iter.size_hint()
76    }
77}
78
79impl<'a, K, T> ExactSizeIterator for Keys<'a, K, T>
80    where K: Copy + 'a, T: 'a
81{
82    #[inline]
83    fn len(&self) -> usize {
84        self.inner_iter.len()
85    }
86}
87
88//TODO consider merging this with EntryValues
89/// A iterator over `&V::Target` values returned by `GroupedValues`.
90///
91/// It will iterate over all values associated with a specific key
92/// in the order they where inserted.
93pub struct Group<'a, K, T>
94    where K: Copy + 'a,
95          T: ?Sized + 'a,
96{
97    /// Note: we have a & to an *mut so we can only use it as *const/&
98    inner_iter: slice::Iter<'a, *mut T>,
99    key: K
100}
101
102impl<'a, K, T> Clone for Group<'a, K, T>
103    where K: Copy + 'a,
104          T: ?Sized + 'a,
105{
106    fn clone(&self) -> Self {
107        Group {
108            key: self.key.clone(),
109            inner_iter: self.inner_iter.clone(),
110        }
111    }
112}
113
114impl<'a, K, T> Group<'a, K, T>
115    where K: Copy + 'a,
116          T: ?Sized + 'a,
117{
118    pub fn key(&self) -> K {
119        self.key
120    }
121}
122
123impl<'a, K, T> Iterator for Group<'a, K, T>
124    where K: Copy + 'a,
125          T: ?Sized + 'a
126{
127    type Item = &'a T;
128
129    #[inline]
130    fn next(&mut self) -> Option<Self::Item> {
131        //SAFE see TotalOrderMultiMap safety guarantees/constraints
132        self.inner_iter.next().map(|&ptr| unsafe { &*ptr } )
133    }
134
135    #[inline]
136    fn size_hint(&self) -> (usize, Option<usize>) {
137        self.inner_iter.size_hint()
138    }
139}
140
141/// A iterator over `&mut V::Target` values returned by `GroupedValues`.
142///
143/// It will iterate over all values associated with a specific key
144/// in the order they where inserted.
145pub struct GroupMut<'a, K, T>
146    where K: Copy + 'a,
147          T: ?Sized + 'a,
148{
149    /// Note: we have a & to an *mut so we can only use it as *const/&
150    inner_iter: slice::IterMut<'a, *mut T>,
151    key: K
152}
153
154impl<'a, K, T> GroupMut<'a, K, T>
155    where K: Copy + 'a,
156          T: ?Sized + 'a,
157{
158    pub fn key(&self) -> K {
159        self.key
160    }
161}
162
163impl<'a, K, T> Iterator for GroupMut<'a, K, T>
164    where K: Copy + 'a,
165          T: ?Sized + 'a
166{
167    type Item = &'a mut T;
168
169    #[inline]
170    fn next(&mut self) -> Option<Self::Item> {
171        //SAFE see TotalOrderMultiMap safety guarantees/constraints
172        self.inner_iter.next().map(|&mut ptr| unsafe { &mut *ptr } )
173    }
174
175    #[inline]
176    fn size_hint(&self) -> (usize, Option<usize>) {
177        self.inner_iter.size_hint()
178    }
179}
180
181
182impl<'a, K, T> ExactSizeIterator for GroupMut<'a, K, T>
183    where K: Copy + 'a,
184          T: ?Sized + 'a,
185{
186    #[inline]
187    fn len(&self) -> usize {
188        self.inner_iter.len()
189    }
190}
191
192impl<'a, K, T> Debug for Group<'a, K, T>
193    where K: Debug + Copy + 'a,
194          T: Debug + ?Sized + 'a,
195{
196    fn fmt(&self, fter: &mut fmt::Formatter) -> fmt::Result {
197        fter.write_str("Group { .. }")
198    }
199}
200
201
202/// An iterator of Groups (no fixed iteration order).
203pub struct GroupedValues<
204    'a,
205    K: Copy + 'a,
206    T: ?Sized + 'a,
207> {
208    /// Note: we have a `&` to an `*mut` so we can only use it as `*const`
209    inner_iter: hash_map::Iter<'a, K, Vec<*mut T>>
210}
211
212impl<'a, K, T> Clone for GroupedValues<'a, K, T>
213    where K: Copy + 'a,
214          T: ?Sized + 'a,
215{
216    #[inline]
217    fn clone(&self) -> Self {
218        GroupedValues { inner_iter: self.inner_iter.clone() }
219    }
220
221}
222
223impl<'a, K, T> Debug for GroupedValues<'a, K, T>
224    where K: Copy + 'a,
225          T: Debug + ?Sized + 'a,
226{
227    fn fmt(&self, fter: &mut fmt::Formatter) -> fmt::Result {
228        fter.debug_list()
229            .entry(&self.clone())
230            .finish()
231    }
232}
233
234impl<'a, K, T> Iterator for GroupedValues<'a, K, T>
235    where K: Copy + 'a,
236          T: ?Sized + 'a,
237{
238    type Item = Group<'a, K, T>;
239
240    #[inline]
241    fn next(&mut self) -> Option<Self::Item> {
242        self.inner_iter.next().map(|(k, values)| {
243            Group {
244                inner_iter: values.iter(),
245                key: *k,
246            }
247        })
248    }
249}
250
251/// An iterator of Groups (no fixed iteration order).
252pub struct GroupedValuesMut<
253    'a,
254    K: Copy + 'a,
255    T: ?Sized + 'a,
256> {
257    inner_iter: hash_map::IterMut<'a, K, Vec<*mut T>>
258}
259
260impl<'a, K, T> Debug for GroupedValuesMut<'a, K, T>
261    where K: Copy + 'a,
262          T: Debug + ?Sized + 'a,
263{
264    fn fmt(&self, fter: &mut fmt::Formatter) -> fmt::Result {
265        fter.write_str("GroupedValuesMut { .. }")
266    }
267}
268
269impl<'a, K, T> Iterator for GroupedValuesMut<'a, K, T>
270    where K: Copy + 'a,
271          T: ?Sized + 'a,
272{
273    type Item = GroupMut<'a, K, T>;
274
275    #[inline]
276    fn next(&mut self) -> Option<Self::Item> {
277        self.inner_iter.next().map(|(k, values)| {
278            GroupMut {
279                inner_iter: values.iter_mut(),
280                key: *k,
281            }
282        })
283    }
284}
285
286
287
288pub struct Values<'a, K: 'a, V: 'a> {
289    inner_iter: slice::Iter<'a, (K, V)>
290}
291
292pub struct ValuesMut<'a, K: 'a, V: 'a> {
293    inner_iter: slice::IterMut<'a, (K, V)>
294}
295
296impl<'a, K: 'a, V: 'a> From<ValuesMut<'a, K, V>> for Values<'a, K, V> {
297    fn from(valsmut: ValuesMut<'a, K, V>) -> Self {
298        let ValuesMut { inner_iter } = valsmut;
299        let as_slice = inner_iter.into_slice();
300        let inner_iter = as_slice.iter();
301        Values { inner_iter }
302    }
303}
304
305impl<'a, K: 'a, V: 'a> Clone for Values<'a, K, V> {
306    fn clone(&self) -> Self {
307        Values { inner_iter: self.inner_iter.clone() }
308    }
309}
310
311impl<'a, K: 'a, V: 'a> Iterator for Values<'a, K, V>
312    where V: StableDeref + DerefMut
313{
314    type Item = &'a V::Target;
315
316    #[inline]
317    fn next(&mut self) -> Option<Self::Item> {
318        self.inner_iter.next()
319            .map(|&(_, ref v)| &**v)
320    }
321
322    #[inline]
323    fn size_hint(&self) -> (usize, Option<usize>) {
324        self.inner_iter.size_hint()
325    }
326}
327
328impl<'a, K: 'a, V: 'a> ExactSizeIterator for Values<'a, K, V>
329    where V: StableDeref + DerefMut
330{
331    fn len(&self) -> usize {
332        self.inner_iter.len()
333    }
334}
335
336impl<'a, K: 'a, V: 'a> Debug for Values<'a, K, V>
337    where V: StableDeref + DerefMut, V::Target: Debug
338{
339    fn fmt(&self, fter: &mut fmt::Formatter) -> fmt::Result {
340        fter.debug_list().entries(self.clone()).finish()
341    }
342}
343
344
345impl<'a, K: 'a, V: 'a> Iterator for ValuesMut<'a, K, V>
346    where V: StableDeref + DerefMut
347{
348    type Item = &'a mut V::Target;
349
350    #[inline]
351    fn next(&mut self) -> Option<Self::Item> {
352        self.inner_iter.next().map(|&mut (_, ref mut v)| {
353            &mut **v
354        })
355    }
356
357    #[inline]
358    fn size_hint(&self) -> (usize, Option<usize>) {
359        self.inner_iter.size_hint()
360    }
361
362}
363
364impl<'a, K: 'a, V: 'a> ExactSizeIterator for ValuesMut<'a, K, V>
365    where V: StableDeref + DerefMut
366{
367    fn len(&self) -> usize {
368        self.inner_iter.len()
369    }
370}
371
372impl<'a, K: 'a, V: 'a> Debug for ValuesMut<'a, K, V>
373    where V: StableDeref + DerefMut, V::Target: Debug
374{
375    fn fmt(&self, fter: &mut fmt::Formatter) -> fmt::Result {
376        fter.write_str("ValuesMut { .. }")
377    }
378}
379
380#[cfg(test)]
381mod tests {
382    use super::*;
383
384    #[test]
385    fn convert_mut_values_to_non_mut() {
386        let mut map = TotalOrderMultiMap::new();
387        map.add("k1", "v1".to_owned());
388        map.add("k0", "v2".to_owned());
389
390        let iter: Values<_, _> = map.values_mut().into();
391        assert_eq!(
392            vec!["v1", "v2"],
393            iter.collect::<Vec<_>>()
394        )
395    }
396}
total_order_multi_map/map_iter.rs

total_order_multi_map/
map_iter.rs
