1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
use serde::{Deserialize, Serialize}; use std::marker::PhantomData; use super::{DistributedIteratorMulti, DistributedReducer, ReduceFactory, Reducer, ReducerA}; use crate::pool::ProcessSend; #[must_use] pub struct All<I, F> { i: I, f: F, } impl<I, F> All<I, F> { pub(super) fn new(i: I, f: F) -> Self { Self { i, f } } } impl<I: DistributedIteratorMulti<Source>, Source, F> DistributedReducer<I, Source, bool> for All<I, F> where F: FnMut(I::Item) -> bool + Clone + ProcessSend, I::Item: 'static, { type ReduceAFactory = AllReducerFactory<I::Item, F>; type ReduceA = AllReducer<I::Item, F>; type ReduceB = BoolAndReducer; fn reducers(self) -> (I, Self::ReduceAFactory, Self::ReduceB) { ( self.i, AllReducerFactory(self.f, PhantomData), BoolAndReducer(true), ) } } pub struct AllReducerFactory<A, F>(F, PhantomData<fn(A)>); impl<A, F> ReduceFactory for AllReducerFactory<A, F> where F: FnMut(A) -> bool + Clone, { type Reducer = AllReducer<A, F>; fn make(&self) -> Self::Reducer { AllReducer(self.0.clone(), true, PhantomData) } } #[derive(Serialize, Deserialize)] #[serde( bound(serialize = "F: Serialize"), bound(deserialize = "F: Deserialize<'de>") )] pub struct AllReducer<A, F>(F, bool, PhantomData<fn(A)>); impl<A, F> Reducer for AllReducer<A, F> where F: FnMut(A) -> bool, { type Item = A; type Output = bool; #[inline(always)] fn push(&mut self, item: Self::Item) -> bool { self.1 = self.1 && self.0(item); self.1 } fn ret(self) -> Self::Output { self.1 } } impl<A, F> ReducerA for AllReducer<A, F> where A: 'static, F: FnMut(A) -> bool + ProcessSend, { type Output = bool; } #[derive(Serialize, Deserialize)] pub struct BoolAndReducer(bool); impl Reducer for BoolAndReducer { type Item = bool; type Output = bool; #[inline(always)] fn push(&mut self, item: Self::Item) -> bool { self.0 = self.0 && item; self.0 } fn ret(self) -> Self::Output { self.0 } } impl ReducerA for BoolAndReducer { type Output = bool; }