diff options
Diffstat (limited to 'BJC-Utils2/src/main/java/bjc')
11 files changed, 408 insertions, 12 deletions
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<OldLeft, OldRight, NewLeft, NewRight> @Override public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind( BiFunction<NewLeft, NewRight, IPair<BoundLeft, BoundRight>> bindr) { - IHolder<IPair<NewLeft, NewRight>> newPair = new Identity<>( - boundPair); + IHolder<IPair<NewLeft, NewRight>> newPair = + new Identity<>(boundPair); IHolder<Boolean> newPairMade = new Identity<>(pairBound); Supplier<NewLeft> leftSupp = () -> { @@ -93,8 +93,8 @@ class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> public <MergedType> MergedType merge(BiFunction<NewLeft, NewRight, MergedType> 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<OldLeft, OldRight, NewLeft, NewRight> return new LazyPair<>(leftSupp, rightSupp); } + + @Override + public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> + IPair<CombinedLeft, CombinedRight> + combine(IPair<OtherLeft, OtherRight> otherPair, + BiFunction<NewLeft, OtherLeft, CombinedLeft> leftCombiner, + BiFunction<NewRight, OtherRight, CombinedRight> 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 <LeftType> + * The type that could be on the left + * @param <RightType> + * The type that could be on the right + * + */ +public class Either<LeftType, RightType> + implements IPair<LeftType, RightType> { + 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 <LeftType> + * The type of the left value + * @param <RightType> + * 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 <LeftType, RightType> Either<LeftType, RightType> + fromLeft(LeftType left) { + return new Either<>(left, null); + } + + /** + * Create a new either with the right value occupied + * + * @param <LeftType> + * The type of the empty left value + * @param <RightType> + * 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 <LeftType, RightType> Either<LeftType, RightType> + fromRight(RightType right) { + return new Either<>(null, right); + } + + @Override + public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind( + BiFunction<LeftType, RightType, IPair<BoundLeft, BoundRight>> binder) { + return binder.apply(leftVal, rightVal); + } + + @Override + public <BoundLeft> IPair<BoundLeft, RightType> bindLeft( + Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) { + if (isLeft) { + return leftBinder.apply(leftVal); + } + + return new Either<>(null, rightVal); + } + + @Override + public <BoundRight> IPair<LeftType, BoundRight> bindRight( + Function<RightType, IPair<LeftType, BoundRight>> rightBinder) { + if (isLeft) { + return new Either<>(leftVal, null); + } + + return rightBinder.apply(rightVal); + } + + @Override + public <NewLeft> IPair<NewLeft, RightType> + mapLeft(Function<LeftType, NewLeft> mapper) { + if (isLeft) { + return new Either<>(mapper.apply(leftVal), null); + } + + return new Either<>(null, rightVal); + } + + @Override + public <NewRight> IPair<LeftType, NewRight> + mapRight(Function<RightType, NewRight> mapper) { + if (isLeft) { + return new Either<>(leftVal, null); + } + + return new Either<>(null, mapper.apply(rightVal)); + } + + @Override + public <MergedType> MergedType + merge(BiFunction<LeftType, RightType, MergedType> merger) { + return merger.apply(leftVal, rightVal); + } + + @Override + public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> + IPair<CombinedLeft, CombinedRight> + combine(IPair<OtherLeft, OtherRight> otherPair, + BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner, + BiFunction<RightType, OtherRight, CombinedRight> 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<OldType, NewLeft, NewRight> return new LazyPair<>(leftSupp, rightSupp); } + + @Override + public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> + IPair<CombinedLeft, CombinedRight> + combine(IPair<OtherLeft, OtherRight> otherPair, + BiFunction<NewLeft, OtherLeft, CombinedLeft> leftCombiner, + BiFunction<NewRight, OtherRight, CombinedRight> 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<LeftType, RightType> "This function can only be applied to instances of IPair"); } - IPair<OldLeft, OldRight> argPair = (IPair<OldLeft, OldRight>) argumentPair; + IPair<OldLeft, OldRight> argPair = + (IPair<OldLeft, OldRight>) argumentPair; return argPair.mapLeft(func); }; @@ -98,7 +99,8 @@ public interface IPair<LeftType, RightType> "This function can only be applied to instances of IPair"); } - IPair<OldLeft, OldRight> argPair = (IPair<OldLeft, OldRight>) argumentPair; + IPair<OldLeft, OldRight> argPair = + (IPair<OldLeft, OldRight>) argumentPair; return argPair.mapRight(func); }; @@ -163,4 +165,46 @@ public interface IPair<LeftType, RightType> */ public <MergedType> MergedType merge(BiFunction<LeftType, RightType, MergedType> merger); + + /** + * Combine the contents of two pairs together + * + * @param <OtherLeft> + * The type of the left value of the other pair + * @param <OtherRight> + * The type of the right value of the other pair + * @param <CombinedLeft> + * The type of the left value of the combined pair + * @param <CombinedRight> + * 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 <OtherLeft, OtherRight, CombinedLeft, CombinedRight> + IPair<CombinedLeft, CombinedRight> + combine(IPair<OtherLeft, OtherRight> otherPair, + BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner, + BiFunction<RightType, OtherRight, CombinedRight> rightCombiner); + + /** + * Pairwise combine two pairs together + * + * @param <OtherLeft> + * The left type of the other pair + * @param <OtherRight> + * The right type of the other pair + * @param otherPair + * The pair to combine with + * @return The pairs, pairwise combined together + */ + public default <OtherLeft, OtherRight> + IPair<IPair<LeftType, OtherLeft>, IPair<RightType, OtherRight>> + combine(IPair<OtherLeft, OtherRight> 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<LeftType, RightType> return new LazyPair<>(leftSupp, rightSupp); } + + @Override + public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> + IPair<CombinedLeft, CombinedRight> + combine(IPair<OtherLeft, OtherRight> otherPair, + BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner, + BiFunction<RightType, OtherRight, CombinedRight> 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<LeftType, RightType> return new Pair<>(leftValue, mapper.apply(rightValue)); } + + @Override + public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> + IPair<CombinedLeft, CombinedRight> + combine(IPair<OtherLeft, OtherRight> otherPair, + BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner, + BiFunction<RightType, OtherRight, CombinedRight> 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<ContainedType> { - /** * Add an item to this list * @@ -302,12 +302,35 @@ public interface IList<ContainedType> { * 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<ContainedType> toIterable(); + public Iterable<ContainedType> toIterable(); + + /** + * Reduce the contents of this list using a collector + * + * @param <StateType> + * The intermediate accumulation type + * @param <ReducedType> + * The final, reduced type + * @param collector + * The collector to use for reduction + * @return The reduced list + */ + public default <StateType, ReducedType> ReducedType collect( + Collector<ContainedType, StateType, ReducedType> collector) { + BiConsumer<StateType, ContainedType> 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<KeyType, ValueType> { - /** * 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 <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); } |