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
99
100
101
102
103
104
105
106
|
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.data.IHolder;
import bjc.data.IPair;
import bjc.data.Identity;
import bjc.data.Pair;
/**
* Implementation of a collecter that uses two collectors.
*
* @author Ben Culkin
*/
final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1, FinalType2>
implements Collector<InitialType, IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>> {
/* Our characteristics. */
private final Set<java.util.stream.Collector.Characteristics> characteristicSet;
/* The first collector. */
private final Collector<InitialType, AuxType1, FinalType1> first;
/* The second collector. */
private final Collector<InitialType, AuxType2, FinalType2> second;
/**
* Create a collector that uses two collectors.
*
* @param first
* The first collector.
*
* @param second
* The second collector.
*/
public CompoundCollector(final Collector<InitialType, AuxType1, FinalType1> first,
final Collector<InitialType, AuxType2, FinalType2> second) {
this.first = first;
this.second = second;
/* Accumulate characteristics. */
characteristicSet = first.characteristics();
characteristicSet.addAll(second.characteristics());
}
@Override
public BiConsumer<IHolder<IPair<AuxType1, AuxType2>>, InitialType> accumulator() {
final BiConsumer<AuxType1, InitialType> firstAccumulator = first.accumulator();
final 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() {
final BinaryOperator<AuxType1> firstCombiner = first.combiner();
final 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) -> {
final FinalType1 finalLeft = first.finisher().apply(left);
final FinalType2 finalRight = second.finisher().apply(right);
return new Pair<>(finalLeft, finalRight);
});
});
};
}
@Override
public Supplier<IHolder<IPair<AuxType1, AuxType2>>> supplier() {
return () -> {
final AuxType1 initialLeft = first.supplier().get();
final AuxType2 initialRight = second.supplier().get();
return new Identity<>(new Pair<>(initialLeft, initialRight));
};
}
}
|
