diff options
author | Jakub Kotur <qtr@google.com> | 2021-03-16 20:22:30 +0000 |
---|---|---|
committer | Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com> | 2021-03-16 20:22:30 +0000 |
commit | 4c0b8e0ef78bcd80a4facc34c6a2158d83f96802 (patch) | |
tree | 13641ab7afc7aa43b586606c18d53084dedf7ace /src/iter/enumerate.rs | |
parent | a679e9b8b7e4ae27a19b81f216e375ea8a9cdb8e (diff) | |
parent | 7522a9ba008ac88224e0990932bdd298a43a2336 (diff) | |
download | rayon-4c0b8e0ef78bcd80a4facc34c6a2158d83f96802.tar.gz |
Initial import of rayon-1.5.0. am: 041839ceab am: d836dd6404 am: 7522a9ba00
Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/rayon/+/1622436
Change-Id: I94b0e06d9da131d6f98db436ad1a178dfff2ec90
Diffstat (limited to 'src/iter/enumerate.rs')
-rw-r--r-- | src/iter/enumerate.rs | 133 |
1 files changed, 133 insertions, 0 deletions
diff --git a/src/iter/enumerate.rs b/src/iter/enumerate.rs new file mode 100644 index 0000000..980ee7c --- /dev/null +++ b/src/iter/enumerate.rs @@ -0,0 +1,133 @@ +use super::plumbing::*; +use super::*; +use std::iter; +use std::ops::Range; +use std::usize; + +/// `Enumerate` is an iterator that returns the current count along with the element. +/// This struct is created by the [`enumerate()`] method on [`IndexedParallelIterator`] +/// +/// [`enumerate()`]: trait.IndexedParallelIterator.html#method.enumerate +/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html +#[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[derive(Debug, Clone)] +pub struct Enumerate<I: IndexedParallelIterator> { + base: I, +} + +impl<I> Enumerate<I> +where + I: IndexedParallelIterator, +{ + /// Creates a new `Enumerate` iterator. + pub(super) fn new(base: I) -> Self { + Enumerate { base } + } +} + +impl<I> ParallelIterator for Enumerate<I> +where + I: IndexedParallelIterator, +{ + type Item = (usize, I::Item); + + fn drive_unindexed<C>(self, consumer: C) -> C::Result + where + C: UnindexedConsumer<Self::Item>, + { + bridge(self, consumer) + } + + fn opt_len(&self) -> Option<usize> { + Some(self.len()) + } +} + +impl<I> IndexedParallelIterator for Enumerate<I> +where + I: IndexedParallelIterator, +{ + fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result { + bridge(self, consumer) + } + + fn len(&self) -> usize { + self.base.len() + } + + fn with_producer<CB>(self, callback: CB) -> CB::Output + where + CB: ProducerCallback<Self::Item>, + { + return self.base.with_producer(Callback { callback }); + + struct Callback<CB> { + callback: CB, + } + + impl<I, CB> ProducerCallback<I> for Callback<CB> + where + CB: ProducerCallback<(usize, I)>, + { + type Output = CB::Output; + fn callback<P>(self, base: P) -> CB::Output + where + P: Producer<Item = I>, + { + let producer = EnumerateProducer { base, offset: 0 }; + self.callback.callback(producer) + } + } + } +} + +/// //////////////////////////////////////////////////////////////////////// +/// Producer implementation + +struct EnumerateProducer<P> { + base: P, + offset: usize, +} + +impl<P> Producer for EnumerateProducer<P> +where + P: Producer, +{ + type Item = (usize, P::Item); + type IntoIter = iter::Zip<Range<usize>, P::IntoIter>; + + fn into_iter(self) -> Self::IntoIter { + // Enumerate only works for IndexedParallelIterators. Since those + // have a max length of usize::MAX, their max index is + // usize::MAX - 1, so the range 0..usize::MAX includes all + // possible indices. + // + // However, we should to use a precise end to the range, otherwise + // reversing the iterator may have to walk back a long ways before + // `Zip::next_back` can produce anything. + let base = self.base.into_iter(); + let end = self.offset + base.len(); + (self.offset..end).zip(base) + } + + fn min_len(&self) -> usize { + self.base.min_len() + } + fn max_len(&self) -> usize { + self.base.max_len() + } + + fn split_at(self, index: usize) -> (Self, Self) { + let (left, right) = self.base.split_at(index); + ( + EnumerateProducer { + base: left, + offset: self.offset, + }, + EnumerateProducer { + base: right, + offset: self.offset + index, + }, + ) + } +} |