use super::plumbing::*; use super::*; use std::fmt::{self, Debug}; /// `Update` is an iterator that mutates the elements of an /// underlying iterator before they are yielded. /// /// This struct is created by the [`update()`] method on [`ParallelIterator`] /// /// [`update()`]: trait.ParallelIterator.html#method.update /// [`ParallelIterator`]: trait.ParallelIterator.html #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[derive(Clone)] pub struct Update { base: I, update_op: F, } impl Debug for Update { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("Update").field("base", &self.base).finish() } } impl Update where I: ParallelIterator, { /// Creates a new `Update` iterator. pub(super) fn new(base: I, update_op: F) -> Self { Update { base, update_op } } } impl ParallelIterator for Update where I: ParallelIterator, F: Fn(&mut I::Item) + Send + Sync, { type Item = I::Item; fn drive_unindexed(self, consumer: C) -> C::Result where C: UnindexedConsumer, { let consumer1 = UpdateConsumer::new(consumer, &self.update_op); self.base.drive_unindexed(consumer1) } fn opt_len(&self) -> Option { self.base.opt_len() } } impl IndexedParallelIterator for Update where I: IndexedParallelIterator, F: Fn(&mut I::Item) + Send + Sync, { fn drive(self, consumer: C) -> C::Result where C: Consumer, { let consumer1 = UpdateConsumer::new(consumer, &self.update_op); self.base.drive(consumer1) } fn len(&self) -> usize { self.base.len() } fn with_producer(self, callback: CB) -> CB::Output where CB: ProducerCallback, { return self.base.with_producer(Callback { callback, update_op: self.update_op, }); struct Callback { callback: CB, update_op: F, } impl ProducerCallback for Callback where CB: ProducerCallback, F: Fn(&mut T) + Send + Sync, { type Output = CB::Output; fn callback

(self, base: P) -> CB::Output where P: Producer, { let producer = UpdateProducer { base, update_op: &self.update_op, }; self.callback.callback(producer) } } } } /// //////////////////////////////////////////////////////////////////////// struct UpdateProducer<'f, P, F> { base: P, update_op: &'f F, } impl<'f, P, F> Producer for UpdateProducer<'f, P, F> where P: Producer, F: Fn(&mut P::Item) + Send + Sync, { type Item = P::Item; type IntoIter = UpdateSeq; fn into_iter(self) -> Self::IntoIter { UpdateSeq { base: self.base.into_iter(), update_op: self.update_op, } } 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); ( UpdateProducer { base: left, update_op: self.update_op, }, UpdateProducer { base: right, update_op: self.update_op, }, ) } fn fold_with(self, folder: G) -> G where G: Folder, { let folder1 = UpdateFolder { base: folder, update_op: self.update_op, }; self.base.fold_with(folder1).base } } /// //////////////////////////////////////////////////////////////////////// /// Consumer implementation struct UpdateConsumer<'f, C, F> { base: C, update_op: &'f F, } impl<'f, C, F> UpdateConsumer<'f, C, F> { fn new(base: C, update_op: &'f F) -> Self { UpdateConsumer { base, update_op } } } impl<'f, T, C, F> Consumer for UpdateConsumer<'f, C, F> where C: Consumer, F: Fn(&mut T) + Send + Sync, { type Folder = UpdateFolder<'f, C::Folder, F>; type Reducer = C::Reducer; type Result = C::Result; fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) { let (left, right, reducer) = self.base.split_at(index); ( UpdateConsumer::new(left, self.update_op), UpdateConsumer::new(right, self.update_op), reducer, ) } fn into_folder(self) -> Self::Folder { UpdateFolder { base: self.base.into_folder(), update_op: self.update_op, } } fn full(&self) -> bool { self.base.full() } } impl<'f, T, C, F> UnindexedConsumer for UpdateConsumer<'f, C, F> where C: UnindexedConsumer, F: Fn(&mut T) + Send + Sync, { fn split_off_left(&self) -> Self { UpdateConsumer::new(self.base.split_off_left(), self.update_op) } fn to_reducer(&self) -> Self::Reducer { self.base.to_reducer() } } struct UpdateFolder<'f, C, F> { base: C, update_op: &'f F, } fn apply(update_op: impl Fn(&mut T)) -> impl Fn(T) -> T { move |mut item| { update_op(&mut item); item } } impl<'f, T, C, F> Folder for UpdateFolder<'f, C, F> where C: Folder, F: Fn(&mut T), { type Result = C::Result; fn consume(self, mut item: T) -> Self { (self.update_op)(&mut item); UpdateFolder { base: self.base.consume(item), update_op: self.update_op, } } fn consume_iter(mut self, iter: I) -> Self where I: IntoIterator, { let update_op = self.update_op; self.base = self .base .consume_iter(iter.into_iter().map(apply(update_op))); self } fn complete(self) -> C::Result { self.base.complete() } fn full(&self) -> bool { self.base.full() } } /// Standard Update adaptor, based on `itertools::adaptors::Update` #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[derive(Debug, Clone)] struct UpdateSeq { base: I, update_op: F, } impl Iterator for UpdateSeq where I: Iterator, F: Fn(&mut I::Item), { type Item = I::Item; fn next(&mut self) -> Option { let mut v = self.base.next()?; (self.update_op)(&mut v); Some(v) } fn size_hint(&self) -> (usize, Option) { self.base.size_hint() } fn fold(self, init: Acc, g: G) -> Acc where G: FnMut(Acc, Self::Item) -> Acc, { self.base.map(apply(self.update_op)).fold(init, g) } // if possible, re-use inner iterator specializations in collect fn collect(self) -> C where C: ::std::iter::FromIterator, { self.base.map(apply(self.update_op)).collect() } } impl ExactSizeIterator for UpdateSeq where I: ExactSizeIterator, F: Fn(&mut I::Item), { } impl DoubleEndedIterator for UpdateSeq where I: DoubleEndedIterator, F: Fn(&mut I::Item), { fn next_back(&mut self) -> Option { let mut v = self.base.next_back()?; (self.update_op)(&mut v); Some(v) } }