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
|
package bjc.utils.funcutils;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import bjc.utils.data.IHolder;
import bjc.utils.data.IPair;
import bjc.utils.data.Identity;
import bjc.utils.data.Pair;
final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1, FinalType2>
implements
Collector<InitialType, IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>> {
private Set<java.util.stream.Collector.Characteristics> characteristicSet;
private Collector<InitialType, AuxType1, FinalType1> firstCollector;
private Collector<InitialType, AuxType2, FinalType2> secondCollector;
public CompoundCollector(
Collector<InitialType, AuxType1, FinalType1> firstCollector,
Collector<InitialType, AuxType2, FinalType2> secondCollector) {
this.firstCollector = firstCollector;
this.secondCollector = secondCollector;
characteristicSet = firstCollector.characteristics();
characteristicSet.addAll(secondCollector.characteristics());
}
@Override
public BiConsumer<IHolder<IPair<AuxType1, AuxType2>>, InitialType> accumulator() {
BiConsumer<AuxType1, InitialType> firstAccumulator = firstCollector
.accumulator();
BiConsumer<AuxType2, InitialType> secondAccumulator = secondCollector
.accumulator();
return (state, value) -> {
state.doWith((statePair) -> {
statePair.doWith((leftState, rightState) -> {
firstAccumulator.accept(leftState, value);
secondAccumulator.accept(rightState, value);
});
});
};
}
@Override
public Set<java.util.stream.Collector.Characteristics> characteristics() {
return characteristicSet;
}
@Override
public BinaryOperator<IHolder<IPair<AuxType1, AuxType2>>> combiner() {
BinaryOperator<AuxType1> firstCombiner = firstCollector.combiner();
BinaryOperator<AuxType2> secondCombiner = secondCollector
.combiner();
return (leftState, rightState) -> {
return leftState.unwrap((leftPair) -> {
return rightState.transform((rightPair) -> {
return leftPair.combine(rightPair, firstCombiner,
secondCombiner);
});
});
};
}
@Override
public Function<IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>> finisher() {
return (state) -> {
return state.unwrap((pair) -> {
return pair.bind((leftVal, rightVal) -> {
return new Pair<>(
firstCollector.finisher().apply(leftVal),
secondCollector.finisher().apply(rightVal));
});
});
};
}
@Override
public Supplier<IHolder<IPair<AuxType1, AuxType2>>> supplier() {
return () -> new Identity<>(
new Pair<>(firstCollector.supplier().get(),
secondCollector.supplier().get()));
}
}
|
