| 1 |
//! Minimal support for `rustc-rayon`, not intended for general use. |
| 2 |
|
| 3 |
use crate::vec::Vec; |
| 4 |
use crate::{Bucket, Entries, IndexMap, IndexSet}; |
| 5 |
|
| 6 |
use rustc_rayon::iter::plumbing::{Consumer, ProducerCallback, UnindexedConsumer}; |
| 7 |
use rustc_rayon::iter::{IndexedParallelIterator, IntoParallelIterator, ParallelIterator}; |
| 8 |
|
| 9 |
mod map { |
| 10 |
use super::*; |
| 11 |
|
| 12 |
impl<K, V, S> IntoParallelIterator for IndexMap<K, V, S> |
| 13 |
where |
| 14 |
K: Send, |
| 15 |
V: Send, |
| 16 |
{ |
| 17 |
type Item = (K, V); |
| 18 |
type Iter = IntoParIter<K, V>; |
| 19 |
|
| 20 |
fn into_par_iter(self) -> Self::Iter { |
| 21 |
IntoParIter { |
| 22 |
entries: self.into_entries(), |
| 23 |
} |
| 24 |
} |
| 25 |
} |
| 26 |
|
| 27 |
pub struct IntoParIter<K, V> { |
| 28 |
entries: Vec<Bucket<K, V>>, |
| 29 |
} |
| 30 |
|
| 31 |
impl<K: Send, V: Send> ParallelIterator for IntoParIter<K, V> { |
| 32 |
type Item = (K, V); |
| 33 |
|
| 34 |
parallel_iterator_methods!(Bucket::key_value); |
| 35 |
} |
| 36 |
|
| 37 |
impl<K: Send, V: Send> IndexedParallelIterator for IntoParIter<K, V> { |
| 38 |
indexed_parallel_iterator_methods!(Bucket::key_value); |
| 39 |
} |
| 40 |
|
| 41 |
impl<'a, K, V, S> IntoParallelIterator for &'a IndexMap<K, V, S> |
| 42 |
where |
| 43 |
K: Sync, |
| 44 |
V: Sync, |
| 45 |
{ |
| 46 |
type Item = (&'a K, &'a V); |
| 47 |
type Iter = ParIter<'a, K, V>; |
| 48 |
|
| 49 |
fn into_par_iter(self) -> Self::Iter { |
| 50 |
ParIter { |
| 51 |
entries: self.as_entries(), |
| 52 |
} |
| 53 |
} |
| 54 |
} |
| 55 |
|
| 56 |
pub struct ParIter<'a, K, V> { |
| 57 |
entries: &'a [Bucket<K, V>], |
| 58 |
} |
| 59 |
|
| 60 |
impl<'a, K: Sync, V: Sync> ParallelIterator for ParIter<'a, K, V> { |
| 61 |
type Item = (&'a K, &'a V); |
| 62 |
|
| 63 |
parallel_iterator_methods!(Bucket::refs); |
| 64 |
} |
| 65 |
|
| 66 |
impl<K: Sync, V: Sync> IndexedParallelIterator for ParIter<'_, K, V> { |
| 67 |
indexed_parallel_iterator_methods!(Bucket::refs); |
| 68 |
} |
| 69 |
|
| 70 |
impl<'a, K, V, S> IntoParallelIterator for &'a mut IndexMap<K, V, S> |
| 71 |
where |
| 72 |
K: Sync + Send, |
| 73 |
V: Send, |
| 74 |
{ |
| 75 |
type Item = (&'a K, &'a mut V); |
| 76 |
type Iter = ParIterMut<'a, K, V>; |
| 77 |
|
| 78 |
fn into_par_iter(self) -> Self::Iter { |
| 79 |
ParIterMut { |
| 80 |
entries: self.as_entries_mut(), |
| 81 |
} |
| 82 |
} |
| 83 |
} |
| 84 |
|
| 85 |
pub struct ParIterMut<'a, K, V> { |
| 86 |
entries: &'a mut [Bucket<K, V>], |
| 87 |
} |
| 88 |
|
| 89 |
impl<'a, K: Sync + Send, V: Send> ParallelIterator for ParIterMut<'a, K, V> { |
| 90 |
type Item = (&'a K, &'a mut V); |
| 91 |
|
| 92 |
parallel_iterator_methods!(Bucket::ref_mut); |
| 93 |
} |
| 94 |
|
| 95 |
impl<K: Sync + Send, V: Send> IndexedParallelIterator for ParIterMut<'_, K, V> { |
| 96 |
indexed_parallel_iterator_methods!(Bucket::ref_mut); |
| 97 |
} |
| 98 |
} |
| 99 |
|
| 100 |
mod set { |
| 101 |
use super::*; |
| 102 |
|
| 103 |
impl<T, S> IntoParallelIterator for IndexSet<T, S> |
| 104 |
where |
| 105 |
T: Send, |
| 106 |
{ |
| 107 |
type Item = T; |
| 108 |
type Iter = IntoParIter<T>; |
| 109 |
|
| 110 |
fn into_par_iter(self) -> Self::Iter { |
| 111 |
IntoParIter { |
| 112 |
entries: self.into_entries(), |
| 113 |
} |
| 114 |
} |
| 115 |
} |
| 116 |
|
| 117 |
pub struct IntoParIter<T> { |
| 118 |
entries: Vec<Bucket<T, ()>>, |
| 119 |
} |
| 120 |
|
| 121 |
impl<T: Send> ParallelIterator for IntoParIter<T> { |
| 122 |
type Item = T; |
| 123 |
|
| 124 |
parallel_iterator_methods!(Bucket::key); |
| 125 |
} |
| 126 |
|
| 127 |
impl<T: Send> IndexedParallelIterator for IntoParIter<T> { |
| 128 |
indexed_parallel_iterator_methods!(Bucket::key); |
| 129 |
} |
| 130 |
|
| 131 |
impl<'a, T, S> IntoParallelIterator for &'a IndexSet<T, S> |
| 132 |
where |
| 133 |
T: Sync, |
| 134 |
{ |
| 135 |
type Item = &'a T; |
| 136 |
type Iter = ParIter<'a, T>; |
| 137 |
|
| 138 |
fn into_par_iter(self) -> Self::Iter { |
| 139 |
ParIter { |
| 140 |
entries: self.as_entries(), |
| 141 |
} |
| 142 |
} |
| 143 |
} |
| 144 |
|
| 145 |
pub struct ParIter<'a, T> { |
| 146 |
entries: &'a [Bucket<T, ()>], |
| 147 |
} |
| 148 |
|
| 149 |
impl<'a, T: Sync> ParallelIterator for ParIter<'a, T> { |
| 150 |
type Item = &'a T; |
| 151 |
|
| 152 |
parallel_iterator_methods!(Bucket::key_ref); |
| 153 |
} |
| 154 |
|
| 155 |
impl<T: Sync> IndexedParallelIterator for ParIter<'_, T> { |
| 156 |
indexed_parallel_iterator_methods!(Bucket::key_ref); |
| 157 |
} |
| 158 |
} |