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
|
package bjc.utils.funcutils;
import bjc.utils.data.IHolder;
import bjc.utils.data.IPair;
import bjc.utils.data.Identity;
import bjc.utils.data.Pair;
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;
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> first;
private Collector<InitialType, AuxType2, FinalType2> second;
public CompoundCollector(Collector<InitialType, AuxType1, FinalType1> first,
Collector<InitialType, AuxType2, FinalType2> second) {
this.first = first;
this.second = second;
characteristicSet = first.characteristics();
characteristicSet.addAll(second.characteristics());
}
@Override
public BiConsumer<IHolder<IPair<AuxType1, AuxType2>>, InitialType> accumulator() {
BiConsumer<AuxType1, InitialType> firstAccumulator = first.accumulator();
BiConsumer<AuxType2, InitialType> secondAccumulator = second.accumulator();
return (state, value) -> {
state.doWith(statePair -> {
statePair.doWith((left, right) -> {
firstAccumulator.accept(left, value);
secondAccumulator.accept(right, value);
});
});
};
}
@Override
public Set<java.util.stream.Collector.Characteristics> characteristics() {
return characteristicSet;
}
@Override
public BinaryOperator<IHolder<IPair<AuxType1, AuxType2>>> combiner() {
BinaryOperator<AuxType1> firstCombiner = first.combiner();
BinaryOperator<AuxType2> secondCombiner = second.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((left, right) -> {
FinalType1 finalLeft = first.finisher().apply(left);
FinalType2 finalRight = second.finisher().apply(right);
return new Pair<>(finalLeft, finalRight);
});
});
};
}
@Override
public Supplier<IHolder<IPair<AuxType1, AuxType2>>> supplier() {
return () -> {
AuxType1 initialLeft = first.supplier().get();
AuxType2 initialRight = second.supplier().get();
return new Identity<>(new Pair<>(initialLeft, initialRight));
};
}
}
|
