diff options
author | Jakub Kotur <qtr@google.com> | 2021-03-16 19:18:10 +0000 |
---|---|---|
committer | Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com> | 2021-03-16 19:18:10 +0000 |
commit | 7522a9ba008ac88224e0990932bdd298a43a2336 (patch) | |
tree | 13641ab7afc7aa43b586606c18d53084dedf7ace /src/collections/hash_set.rs | |
parent | a679e9b8b7e4ae27a19b81f216e375ea8a9cdb8e (diff) | |
parent | d836dd6404274950f96f77057b550390b889412a (diff) | |
download | rayon-7522a9ba008ac88224e0990932bdd298a43a2336.tar.gz |
Initial import of rayon-1.5.0. am: 041839ceab am: d836dd6404
Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/rayon/+/1622436
Change-Id: Iee83340711b66329b879dd9f178df4fa3690886a
Diffstat (limited to 'src/collections/hash_set.rs')
-rw-r--r-- | src/collections/hash_set.rs | 80 |
1 files changed, 80 insertions, 0 deletions
diff --git a/src/collections/hash_set.rs b/src/collections/hash_set.rs new file mode 100644 index 0000000..b6ee1c1 --- /dev/null +++ b/src/collections/hash_set.rs @@ -0,0 +1,80 @@ +//! This module contains the parallel iterator types for hash sets +//! (`HashSet<T>`). You will rarely need to interact with it directly +//! unless you have need to name one of the iterator types. + +use std::collections::HashSet; +use std::hash::{BuildHasher, Hash}; +use std::marker::PhantomData; + +use crate::iter::plumbing::*; +use crate::iter::*; + +use crate::vec; + +/// Parallel iterator over a hash set +#[derive(Debug)] // std doesn't Clone +pub struct IntoIter<T: Hash + Eq + Send> { + inner: vec::IntoIter<T>, +} + +into_par_vec! { + HashSet<T, S> => IntoIter<T>, + impl<T: Hash + Eq + Send, S: BuildHasher> +} + +delegate_iterator! { + IntoIter<T> => T, + impl<T: Hash + Eq + Send> +} + +/// Parallel iterator over an immutable reference to a hash set +#[derive(Debug)] +pub struct Iter<'a, T: Hash + Eq + Sync> { + inner: vec::IntoIter<&'a T>, +} + +impl<'a, T: Hash + Eq + Sync> Clone for Iter<'a, T> { + fn clone(&self) -> Self { + Iter { + inner: self.inner.clone(), + } + } +} + +into_par_vec! { + &'a HashSet<T, S> => Iter<'a, T>, + impl<'a, T: Hash + Eq + Sync, S: BuildHasher> +} + +delegate_iterator! { + Iter<'a, T> => &'a T, + impl<'a, T: Hash + Eq + Sync + 'a> +} + +// `HashSet` doesn't have a mutable `Iterator` + +/// Draining parallel iterator that moves out of a hash set, +/// but keeps the total capacity. +#[derive(Debug)] +pub struct Drain<'a, T: Hash + Eq + Send> { + inner: vec::IntoIter<T>, + marker: PhantomData<&'a mut HashSet<T>>, +} + +impl<'a, T: Hash + Eq + Send, S: BuildHasher> ParallelDrainFull for &'a mut HashSet<T, S> { + type Iter = Drain<'a, T>; + type Item = T; + + fn par_drain(self) -> Self::Iter { + let vec: Vec<_> = self.drain().collect(); + Drain { + inner: vec.into_par_iter(), + marker: PhantomData, + } + } +} + +delegate_iterator! { + Drain<'_, T> => T, + impl<T: Hash + Eq + Send> +} |