From fff6dc5d43539af05ae2679640240b8545b36947 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Tue, 10 May 2016 21:58:08 -0400 Subject: Added interface to JDK collector API --- .../main/java/bjc/utils/data/BoundLazyPair.java | 23 +++- .../src/main/java/bjc/utils/data/Either.java | 135 +++++++++++++++++++++ .../java/bjc/utils/data/HalfBoundLazyPair.java | 15 +++ BJC-Utils2/src/main/java/bjc/utils/data/IPair.java | 48 +++++++- .../src/main/java/bjc/utils/data/LazyPair.java | 15 +++ BJC-Utils2/src/main/java/bjc/utils/data/Pair.java | 12 ++ .../src/main/java/bjc/utils/funcdata/IList.java | 29 ++++- .../src/main/java/bjc/utils/funcdata/IMap.java | 1 - .../java/bjc/utils/funcutils/CollectorUtils.java | 41 +++++++ .../bjc/utils/funcutils/CompoundCollector.java | 97 +++++++++++++++ .../main/java/bjc/utils/funcutils/FuncUtils.java | 4 +- 11 files changed, 408 insertions(+), 12 deletions(-) create mode 100644 BJC-Utils2/src/main/java/bjc/utils/data/Either.java create mode 100644 BJC-Utils2/src/main/java/bjc/utils/funcutils/CollectorUtils.java create mode 100644 BJC-Utils2/src/main/java/bjc/utils/funcutils/CompoundCollector.java (limited to 'BJC-Utils2/src') diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java index 1635e06..dcf9cca 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java @@ -26,8 +26,8 @@ class BoundLazyPair @Override public IPair bind( BiFunction> bindr) { - IHolder> newPair = new Identity<>( - boundPair); + IHolder> newPair = + new Identity<>(boundPair); IHolder newPairMade = new Identity<>(pairBound); Supplier leftSupp = () -> { @@ -93,8 +93,8 @@ class BoundLazyPair public MergedType merge(BiFunction merger) { if (!pairBound) { - boundPair = binder.apply(leftSupplier.get(), - rightSupplier.get()); + boundPair = + binder.apply(leftSupplier.get(), rightSupplier.get()); pairBound = true; } @@ -166,4 +166,19 @@ class BoundLazyPair return new LazyPair<>(leftSupp, rightSupp); } + + @Override + public + IPair + combine(IPair otherPair, + BiFunction leftCombiner, + BiFunction rightCombiner) { + return otherPair.bind((otherLeft, otherRight) -> { + return bind((leftVal, rightVal) -> { + return new LazyPair<>( + leftCombiner.apply(leftVal, otherLeft), + rightCombiner.apply(rightVal, otherRight)); + }); + }); + } } \ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Either.java b/BJC-Utils2/src/main/java/bjc/utils/data/Either.java new file mode 100644 index 0000000..8787888 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/data/Either.java @@ -0,0 +1,135 @@ +package bjc.utils.data; + +import java.util.function.BiFunction; +import java.util.function.Function; + +/** + * Represents a pair where only one side has a value + * + * @author ben + * @param + * The type that could be on the left + * @param + * The type that could be on the right + * + */ +public class Either + implements IPair { + private LeftType leftVal; + private RightType rightVal; + + private boolean isLeft; + + private Either(LeftType left, RightType right) { + if (left == null) { + rightVal = right; + } else { + leftVal = left; + + isLeft = true; + } + } + + /** + * Create a new either with the left value occupied + * + * @param + * The type of the left value + * @param + * The type of the empty right value + * @param left + * The value to put on the left + * @return An either with the left side occupied + */ + public static Either + fromLeft(LeftType left) { + return new Either<>(left, null); + } + + /** + * Create a new either with the right value occupied + * + * @param + * The type of the empty left value + * @param + * The type of the right value + * @param right + * The value to put on the right + * @return An either with the right side occupied + */ + public static Either + fromRight(RightType right) { + return new Either<>(null, right); + } + + @Override + public IPair bind( + BiFunction> binder) { + return binder.apply(leftVal, rightVal); + } + + @Override + public IPair bindLeft( + Function> leftBinder) { + if (isLeft) { + return leftBinder.apply(leftVal); + } + + return new Either<>(null, rightVal); + } + + @Override + public IPair bindRight( + Function> rightBinder) { + if (isLeft) { + return new Either<>(leftVal, null); + } + + return rightBinder.apply(rightVal); + } + + @Override + public IPair + mapLeft(Function mapper) { + if (isLeft) { + return new Either<>(mapper.apply(leftVal), null); + } + + return new Either<>(null, rightVal); + } + + @Override + public IPair + mapRight(Function mapper) { + if (isLeft) { + return new Either<>(leftVal, null); + } + + return new Either<>(null, mapper.apply(rightVal)); + } + + @Override + public MergedType + merge(BiFunction merger) { + return merger.apply(leftVal, rightVal); + } + + @Override + public + IPair + combine(IPair otherPair, + BiFunction leftCombiner, + BiFunction rightCombiner) { + if (isLeft) { + return otherPair.bind((otherLeft, otherRight) -> { + return new Either<>(leftCombiner.apply(leftVal, otherLeft), + null); + }); + } + + return otherPair.bind((otherLeft, otherRight) -> { + return new Either<>(null, + rightCombiner.apply(rightVal, otherRight)); + }); + } +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/HalfBoundLazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/HalfBoundLazyPair.java index 9e26924..198dd96 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/HalfBoundLazyPair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/HalfBoundLazyPair.java @@ -138,4 +138,19 @@ class HalfBoundLazyPair return new LazyPair<>(leftSupp, rightSupp); } + + @Override + public + IPair + combine(IPair otherPair, + BiFunction leftCombiner, + BiFunction rightCombiner) { + return otherPair.bind((otherLeft, otherRight) -> { + return bind((leftVal, rightVal) -> { + return new LazyPair<>( + leftCombiner.apply(leftVal, otherLeft), + rightCombiner.apply(rightVal, otherRight)); + }); + }); + } } \ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java index 707724b..f94d656 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java @@ -81,7 +81,8 @@ public interface IPair "This function can only be applied to instances of IPair"); } - IPair argPair = (IPair) argumentPair; + IPair argPair = + (IPair) argumentPair; return argPair.mapLeft(func); }; @@ -98,7 +99,8 @@ public interface IPair "This function can only be applied to instances of IPair"); } - IPair argPair = (IPair) argumentPair; + IPair argPair = + (IPair) argumentPair; return argPair.mapRight(func); }; @@ -163,4 +165,46 @@ public interface IPair */ public MergedType merge(BiFunction merger); + + /** + * Combine the contents of two pairs together + * + * @param + * The type of the left value of the other pair + * @param + * The type of the right value of the other pair + * @param + * The type of the left value of the combined pair + * @param + * The type of the right value of the combined pair + * @param otherPair + * The other pair to combine with + * @param leftCombiner + * @param rightCombiner + * @return A pair with its values combined + */ + public + IPair + combine(IPair otherPair, + BiFunction leftCombiner, + BiFunction rightCombiner); + + /** + * Pairwise combine two pairs together + * + * @param + * The left type of the other pair + * @param + * The right type of the other pair + * @param otherPair + * The pair to combine with + * @return The pairs, pairwise combined together + */ + public default + IPair, IPair> + combine(IPair otherPair) { + return combine(otherPair, + (left, otherLeft) -> new Pair<>(left, otherLeft), + (right, otherRight) -> new Pair<>(right, otherRight)); + } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java index 6f1be10..d688e5b 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java @@ -198,4 +198,19 @@ public class LazyPair return new LazyPair<>(leftSupp, rightSupp); } + + @Override + public + IPair + combine(IPair otherPair, + BiFunction leftCombiner, + BiFunction rightCombiner) { + return otherPair.bind((otherLeft, otherRight) -> { + return bind((leftVal, rightVal) -> { + return new LazyPair<>( + leftCombiner.apply(leftVal, otherLeft), + rightCombiner.apply(rightVal, otherRight)); + }); + }); + } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java b/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java index eb421bc..1fc0d19 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java @@ -104,4 +104,16 @@ public class Pair return new Pair<>(leftValue, mapper.apply(rightValue)); } + + @Override + public + IPair + combine(IPair otherPair, + BiFunction leftCombiner, + BiFunction rightCombiner) { + return otherPair.bind((otherLeft, otherRight) -> { + return new Pair<>(leftCombiner.apply(leftValue, otherLeft), + rightCombiner.apply(rightValue, otherRight)); + }); + } } \ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java index b6363e7..00ec653 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java @@ -6,6 +6,7 @@ import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; +import java.util.stream.Collector; import bjc.utils.data.IPair; @@ -18,7 +19,6 @@ import bjc.utils.data.IPair; * The type in this list */ public interface IList { - /** * Add an item to this list * @@ -302,12 +302,35 @@ public interface IList { * The type of array to return * @return The list, as an array */ - ContainedType[] toArray(ContainedType[] arrType); + public ContainedType[] toArray(ContainedType[] arrType); /** * Convert the list into a iterable * * @return An iterable view onto the list */ - Iterable toIterable(); + public Iterable toIterable(); + + /** + * Reduce the contents of this list using a collector + * + * @param + * The intermediate accumulation type + * @param + * The final, reduced type + * @param collector + * The collector to use for reduction + * @return The reduced list + */ + public default ReducedType collect( + Collector collector) { + BiConsumer accumulator = + collector.accumulator(); + + return reduceAux(collector.supplier().get(), (value, state) -> { + accumulator.accept(state, value); + + return state; + }, collector.finisher()); + } } \ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IMap.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IMap.java index f5f7a26..243e58a 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IMap.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IMap.java @@ -16,7 +16,6 @@ import java.util.function.Function; * */ public interface IMap { - /** * Check if this map contains the specified key * 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 + * The type of the collection to collect from + * @param + * The intermediate type of the first collector + * @param + * The intermediate type of the second collector + * @param + * The final type of the first collector + * @param + * 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 + Collector>, IPair> + compoundCollect( + Collector firstCollector, + Collector 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 + implements + Collector>, IPair> { + private Set characteristicSet; + + private Collector firstCollector; + private Collector secondCollector; + + public CompoundCollector( + Collector firstCollector, + Collector secondCollector) { + this.firstCollector = firstCollector; + this.secondCollector = secondCollector; + + characteristicSet = firstCollector.characteristics(); + characteristicSet.addAll(secondCollector.characteristics()); + } + + @Override + public Supplier>> supplier() { + return () -> new Identity<>( + new Pair<>(firstCollector.supplier().get(), + secondCollector.supplier().get())); + } + + @Override + public BiConsumer>, InitialType> + accumulator() { + BiConsumer firstAccumulator = + firstCollector.accumulator(); + BiConsumer secondAccumulator = + secondCollector.accumulator(); + + return (state, value) -> { + state.doWith((statePair) -> { + statePair.doWith((leftState, rightState) -> { + firstAccumulator.accept(leftState, value); + secondAccumulator.accept(rightState, value); + }); + }); + }; + } + + @Override + public BinaryOperator>> + combiner() { + BinaryOperator firstCombiner = + firstCollector.combiner(); + BinaryOperator secondCombiner = + secondCollector.combiner(); + + return (leftState, rightState) -> { + return leftState.unwrap((leftPair) -> { + return rightState.transform((rightPair) -> { + return leftPair.combine(rightPair, firstCombiner, + secondCombiner); + }); + }); + }; + } + + @Override + public Function>, IPair> + 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 + 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 cons) { for (int i = 0; i < nTimes; i++) { cons.accept(i); } -- cgit v1.2.3