Added interface to JDK collector API

3 files changed, 140 insertions, 2 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/CollectorUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CollectorUtils.java
new file mode 100644
index 0000000..a44059b
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CollectorUtils.java
@@ -0,0 +1,41 @@
+package bjc.utils.funcutils;
+
+import java.util.stream.Collector;
+
+import bjc.utils.data.IHolder;
+import bjc.utils.data.IPair;
+
+/**
+ * Utilities for producing implementations of {@link Collector}
+ * 
+ * @author ben
+ *
+ */
+public class CollectorUtils {
+	/**
+	 * Create a collector that applies two collectors at once
+	 * 
+	 * @param <InitialType>
+	 *            The type of the collection to collect from
+	 * @param <AuxType1>
+	 *            The intermediate type of the first collector
+	 * @param <AuxType2>
+	 *            The intermediate type of the second collector
+	 * @param <FinalType1>
+	 *            The final type of the first collector
+	 * @param <FinalType2>
+	 *            The final type of the second collector
+	 * @param firstCollector
+	 *            The first collector to use
+	 * @param secondCollector
+	 *            The second collector to use
+	 * @return A collector that functions as mentioned above
+	 */
+	public static <InitialType, AuxType1, AuxType2, FinalType1, FinalType2>
+			Collector<InitialType, IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>>
+			compoundCollect(
+					Collector<InitialType, AuxType1, FinalType1> firstCollector,
+					Collector<InitialType, AuxType2, FinalType2> secondCollector) {
+		return new CompoundCollector<>(firstCollector, secondCollector);
+	}
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java
new file mode 100644
index 0000000..715a6e5
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java
@@ -0,0 +1,97 @@
+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 java.util.stream.Collector.Characteristics;
+
+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 Supplier<IHolder<IPair<AuxType1, AuxType2>>> supplier() {
+		return () -> new Identity<>(
+				new Pair<>(firstCollector.supplier().get(),
+						secondCollector.supplier().get()));
+	}
+
+	@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 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 Set<java.util.stream.Collector.Characteristics>
+			characteristics() {
+		return characteristicSet;
+	}
+}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java
index 4209e6d..43603d6 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java
@@ -1,8 +1,8 @@
 package bjc.utils.funcutils;
 
 import java.util.function.BiFunction;
+import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.function.IntConsumer;
 
 /**
  * Utility things for functions
@@ -41,7 +41,7 @@ public class FuncUtils {
 	 * @param cons
 	 *            The action to perform
 	 */
-	public static void doTimes(int nTimes, IntConsumer cons) {
+	public static void doTimes(int nTimes, Consumer<Integer> cons) {
 		for (int i = 0; i < nTimes; i++) {
 			cons.accept(i);
 		}