1 use crate::iter::plumbing::*;
2 use crate::iter::Either::{Left, Right};
3 use crate::iter::*;
4 
5 /// `Either<L, R>` is a parallel iterator if both `L` and `R` are parallel iterators.
6 impl<L, R> ParallelIterator for Either<L, R>
7 where
8     L: ParallelIterator,
9     R: ParallelIterator<Item = L::Item>,
10 {
11     type Item = L::Item;
12 
drive_unindexed<C>(self, consumer: C) -> C::Result where C: UnindexedConsumer<Self::Item>,13     fn drive_unindexed<C>(self, consumer: C) -> C::Result
14     where
15         C: UnindexedConsumer<Self::Item>,
16     {
17         match self {
18             Left(iter) => iter.drive_unindexed(consumer),
19             Right(iter) => iter.drive_unindexed(consumer),
20         }
21     }
22 
opt_len(&self) -> Option<usize>23     fn opt_len(&self) -> Option<usize> {
24         self.as_ref().either(L::opt_len, R::opt_len)
25     }
26 }
27 
28 impl<L, R> IndexedParallelIterator for Either<L, R>
29 where
30     L: IndexedParallelIterator,
31     R: IndexedParallelIterator<Item = L::Item>,
32 {
drive<C>(self, consumer: C) -> C::Result where C: Consumer<Self::Item>,33     fn drive<C>(self, consumer: C) -> C::Result
34     where
35         C: Consumer<Self::Item>,
36     {
37         match self {
38             Left(iter) => iter.drive(consumer),
39             Right(iter) => iter.drive(consumer),
40         }
41     }
42 
len(&self) -> usize43     fn len(&self) -> usize {
44         self.as_ref().either(L::len, R::len)
45     }
46 
with_producer<CB>(self, callback: CB) -> CB::Output where CB: ProducerCallback<Self::Item>,47     fn with_producer<CB>(self, callback: CB) -> CB::Output
48     where
49         CB: ProducerCallback<Self::Item>,
50     {
51         match self {
52             Left(iter) => iter.with_producer(callback),
53             Right(iter) => iter.with_producer(callback),
54         }
55     }
56 }
57 
58 /// `Either<L, R>` can be extended if both `L` and `R` are parallel extendable.
59 impl<L, R, T> ParallelExtend<T> for Either<L, R>
60 where
61     L: ParallelExtend<T>,
62     R: ParallelExtend<T>,
63     T: Send,
64 {
par_extend<I>(&mut self, par_iter: I) where I: IntoParallelIterator<Item = T>,65     fn par_extend<I>(&mut self, par_iter: I)
66     where
67         I: IntoParallelIterator<Item = T>,
68     {
69         match self.as_mut() {
70             Left(collection) => collection.par_extend(par_iter),
71             Right(collection) => collection.par_extend(par_iter),
72         }
73     }
74 }
75