src/vendor/rustc-rayon/src/iter/reduce.rs

   1 use super::ParallelIterator;
   2 use super::plumbing::*;
   3
   4 pub fn reduce<PI, R, ID, T>(pi: PI, identity: ID, reduce_op: R) -> T
   5     where PI: ParallelIterator<Item = T>,
   6           R: Fn(T, T) -> T + Sync,
   7           ID: Fn() -> T + Sync,
   8           T: Send
   9 {
  10     let consumer = ReduceConsumer {
  11         identity: &identity,
  12         reduce_op: &reduce_op,
  13     };
  14     pi.drive_unindexed(consumer)
  15 }
  16
  17 struct ReduceConsumer<'r, R: 'r, ID: 'r> {
  18     identity: &'r ID,
  19     reduce_op: &'r R,
  20 }
  21
  22 impl<'r, R, ID> Copy for ReduceConsumer<'r, R, ID> {}
  23
  24 impl<'r, R, ID> Clone for ReduceConsumer<'r, R, ID> {
  25     fn clone(&self) -> Self {
  26         *self
  27     }
  28 }
  29
  30 impl<'r, R, ID, T> Consumer<T> for ReduceConsumer<'r, R, ID>
  31     where R: Fn(T, T) -> T + Sync,
  32           ID: Fn() -> T + Sync,
  33           T: Send
  34 {
  35     type Folder = ReduceFolder<'r, R, T>;
  36     type Reducer = Self;
  37     type Result = T;
  38
  39     fn split_at(self, _index: usize) -> (Self, Self, Self) {
  40         (self, self, self)
  41     }
  42
  43     fn into_folder(self) -> Self::Folder {
  44         ReduceFolder {
  45             reduce_op: self.reduce_op,
  46             item: (self.identity)(),
  47         }
  48     }
  49
  50     fn full(&self) -> bool {
  51         false
  52     }
  53 }
  54
  55 impl<'r, R, ID, T> UnindexedConsumer<T> for ReduceConsumer<'r, R, ID>
  56     where R: Fn(T, T) -> T + Sync,
  57           ID: Fn() -> T + Sync,
  58           T: Send
  59 {
  60     fn split_off_left(&self) -> Self {
  61         *self
  62     }
  63
  64     fn to_reducer(&self) -> Self::Reducer {
  65         *self
  66     }
  67 }
  68
  69 impl<'r, R, ID, T> Reducer<T> for ReduceConsumer<'r, R, ID>
  70     where R: Fn(T, T) -> T + Sync
  71 {
  72     fn reduce(self, left: T, right: T) -> T {
  73         (self.reduce_op)(left, right)
  74     }
  75 }
  76
  77 struct ReduceFolder<'r, R: 'r, T> {
  78     reduce_op: &'r R,
  79     item: T,
  80 }
  81
  82 impl<'r, R, T> Folder<T> for ReduceFolder<'r, R, T>
  83     where R: Fn(T, T) -> T
  84 {
  85     type Result = T;
  86
  87     fn consume(self, item: T) -> Self {
  88         ReduceFolder {
  89             reduce_op: self.reduce_op,
  90             item: (self.reduce_op)(self.item, item),
  91         }
  92     }
  93
  94     fn consume_iter<I>(self, iter: I) -> Self
  95         where I: IntoIterator<Item = T>
  96     {
  97         ReduceFolder {
  98             reduce_op: self.reduce_op,
  99             item: iter.into_iter().fold(self.item, self.reduce_op),
 100         }
 101     }
 102
 103     fn complete(self) -> T {
 104         self.item
 105     }
 106
 107     fn full(&self) -> bool {
 108         false
 109     }
 110 }