1 //! This module contains the parallel iterator types for hash maps 2 //! (`HashMap<K, V>`). You will rarely need to interact with it directly 3 //! unless you have need to name one of the iterator types. 4 5 use std::collections::HashMap; 6 use std::hash::{BuildHasher, Hash}; 7 use std::marker::PhantomData; 8 9 use crate::iter::plumbing::*; 10 use crate::iter::*; 11 12 use crate::vec; 13 14 /// Parallel iterator over a hash map 15 #[derive(Debug)] // std doesn't Clone 16 pub struct IntoIter<K: Hash + Eq + Send, V: Send> { 17 inner: vec::IntoIter<(K, V)>, 18 } 19 20 into_par_vec! { 21 HashMap<K, V, S> => IntoIter<K, V>, 22 impl<K: Hash + Eq + Send, V: Send, S: BuildHasher> 23 } 24 25 delegate_iterator! { 26 IntoIter<K, V> => (K, V), 27 impl<K: Hash + Eq + Send, V: Send> 28 } 29 30 /// Parallel iterator over an immutable reference to a hash map 31 #[derive(Debug)] 32 pub struct Iter<'a, K: Hash + Eq + Sync, V: Sync> { 33 inner: vec::IntoIter<(&'a K, &'a V)>, 34 } 35 36 impl<'a, K: Hash + Eq + Sync, V: Sync> Clone for Iter<'a, K, V> { clone(&self) -> Self37 fn clone(&self) -> Self { 38 Iter { 39 inner: self.inner.clone(), 40 } 41 } 42 } 43 44 into_par_vec! { 45 &'a HashMap<K, V, S> => Iter<'a, K, V>, 46 impl<'a, K: Hash + Eq + Sync, V: Sync, S: BuildHasher> 47 } 48 49 delegate_iterator! { 50 Iter<'a, K, V> => (&'a K, &'a V), 51 impl<'a, K: Hash + Eq + Sync + 'a, V: Sync + 'a> 52 } 53 54 /// Parallel iterator over a mutable reference to a hash map 55 #[derive(Debug)] 56 pub struct IterMut<'a, K: Hash + Eq + Sync, V: Send> { 57 inner: vec::IntoIter<(&'a K, &'a mut V)>, 58 } 59 60 into_par_vec! { 61 &'a mut HashMap<K, V, S> => IterMut<'a, K, V>, 62 impl<'a, K: Hash + Eq + Sync, V: Send, S: BuildHasher> 63 } 64 65 delegate_iterator! { 66 IterMut<'a, K, V> => (&'a K, &'a mut V), 67 impl<'a, K: Hash + Eq + Sync + 'a, V: Send + 'a> 68 } 69 70 /// Draining parallel iterator that moves out of a hash map, 71 /// but keeps the total capacity. 72 #[derive(Debug)] 73 pub struct Drain<'a, K: Hash + Eq + Send, V: Send> { 74 inner: vec::IntoIter<(K, V)>, 75 marker: PhantomData<&'a mut HashMap<K, V>>, 76 } 77 78 impl<'a, K: Hash + Eq + Send, V: Send, S: BuildHasher> ParallelDrainFull 79 for &'a mut HashMap<K, V, S> 80 { 81 type Iter = Drain<'a, K, V>; 82 type Item = (K, V); 83 par_drain(self) -> Self::Iter84 fn par_drain(self) -> Self::Iter { 85 let vec: Vec<_> = self.drain().collect(); 86 Drain { 87 inner: vec.into_par_iter(), 88 marker: PhantomData, 89 } 90 } 91 } 92 93 delegate_iterator! { 94 Drain<'_, K, V> => (K, V), 95 impl<K: Hash + Eq + Send, V: Send> 96 } 97