From 42f7d379a430aaf2fad169f0170de04072b08b10 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Fri, 22 Apr 2016 14:48:04 -0400 Subject: Formatting changes --- .../src/main/java/bjc/utils/data/BoundLazy.java | 18 +++--- .../main/java/bjc/utils/data/BoundLazyPair.java | 64 +++++++++++----------- .../java/bjc/utils/data/HalfBoundLazyPair.java | 56 +++++++++---------- .../src/main/java/bjc/utils/data/IHolder.java | 26 ++++----- BJC-Utils2/src/main/java/bjc/utils/data/IPair.java | 64 +++++++++++----------- BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java | 26 ++++----- .../src/main/java/bjc/utils/data/LazyPair.java | 32 +++++------ BJC-Utils2/src/main/java/bjc/utils/data/Pair.java | 12 ++-- 8 files changed, 149 insertions(+), 149 deletions(-) (limited to 'BJC-Utils2/src/main/java/bjc/utils/data') diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazy.java index dda65a7..ce47eb9 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazy.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazy.java @@ -70,6 +70,15 @@ class BoundLazy return new Lazy<>(typeSupplier); } + @Override + public String toString() { + if (holderBound) { + return boundHolder.toString(); + } + + return "(unmaterialized)"; + } + @Override public IHolder transform( UnaryOperator transformer) { @@ -87,13 +96,4 @@ class BoundLazy return boundHolder.unwrap(unwrapper); } - - @Override - public String toString() { - if (holderBound) { - return boundHolder.toString(); - } - - return "(unmaterialized)"; - } } \ No newline at end of file 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 634f2bd..a49bb9a 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java @@ -23,6 +23,38 @@ class BoundLazyPair binder = bindr; } + @Override + public IPair bind( + BiFunction> bindr) { + IHolder> newPair = new Identity<>( + boundPair); + IHolder newPairMade = new Identity<>(pairBound); + + Supplier leftSupp = () -> { + if (!newPairMade.getValue()) { + newPair.replace(binder.apply(leftSupplier.get(), + rightSupplier.get())); + + newPairMade.replace(false); + } + + return newPair.unwrap((pair) -> pair.getLeft()); + }; + + Supplier rightSupp = () -> { + if (!newPairMade.getValue()) { + newPair.replace(binder.apply(leftSupplier.get(), + rightSupplier.get())); + + newPairMade.replace(false); + } + + return newPair.unwrap((pair) -> pair.getRight()); + }; + + return new BoundLazyPair<>(leftSupp, rightSupp, bindr); + } + @Override public IPair bindLeft( Function> leftBinder) { @@ -57,38 +89,6 @@ class BoundLazyPair return new HalfBoundLazyPair<>(rightSupp, rightBinder); } - @Override - public IPair bind( - BiFunction> bindr) { - IHolder> newPair = new Identity<>( - boundPair); - IHolder newPairMade = new Identity<>(pairBound); - - Supplier leftSupp = () -> { - if (!newPairMade.getValue()) { - newPair.replace(binder.apply(leftSupplier.get(), - rightSupplier.get())); - - newPairMade.replace(false); - } - - return newPair.unwrap((pair) -> pair.getLeft()); - }; - - Supplier rightSupp = () -> { - if (!newPairMade.getValue()) { - newPair.replace(binder.apply(leftSupplier.get(), - rightSupplier.get())); - - newPairMade.replace(false); - } - - return newPair.unwrap((pair) -> pair.getRight()); - }; - - return new BoundLazyPair<>(leftSupp, rightSupp, bindr); - } - @Override public MergedType merge( BiFunction merger) { 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 f32f58f..037dddf 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/HalfBoundLazyPair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/HalfBoundLazyPair.java @@ -19,6 +19,34 @@ class HalfBoundLazyPair binder = bindr; } + @Override + public IPair bind( + BiFunction> bindr) { + IHolder> newPair = new Identity<>( + boundPair); + IHolder newPairMade = new Identity<>(pairBound); + + Supplier leftSupp = () -> { + if (!newPairMade.getValue()) { + newPair.replace(binder.apply(oldSupplier.get())); + newPairMade.replace(true); + } + + return newPair.unwrap((pair) -> pair.getLeft()); + }; + + Supplier rightSupp = () -> { + if (!newPairMade.getValue()) { + newPair.replace(binder.apply(oldSupplier.get())); + newPairMade.replace(true); + } + + return newPair.unwrap((pair) -> pair.getRight()); + }; + + return new BoundLazyPair<>(leftSupp, rightSupp, bindr); + } + @Override public IPair bindLeft( Function> leftBinder) { @@ -51,34 +79,6 @@ class HalfBoundLazyPair return new HalfBoundLazyPair<>(rightSupp, rightBinder); } - @Override - public IPair bind( - BiFunction> bindr) { - IHolder> newPair = new Identity<>( - boundPair); - IHolder newPairMade = new Identity<>(pairBound); - - Supplier leftSupp = () -> { - if (!newPairMade.getValue()) { - newPair.replace(binder.apply(oldSupplier.get())); - newPairMade.replace(true); - } - - return newPair.unwrap((pair) -> pair.getLeft()); - }; - - Supplier rightSupp = () -> { - if (!newPairMade.getValue()) { - newPair.replace(binder.apply(oldSupplier.get())); - newPairMade.replace(true); - } - - return newPair.unwrap((pair) -> pair.getRight()); - }; - - return new BoundLazyPair<>(leftSupp, rightSupp, bindr); - } - @Override public MergedType merge( BiFunction merger) { diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java b/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java index 77eb899..ecf3f14 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java @@ -63,6 +63,19 @@ public interface IHolder { public IHolder map( Function mapper); + /** + * Replace the held value with a new one + * + * @param newValue + * The value to hold instead + * @return The holder itself + */ + public default IHolder replace(ContainedType newValue) { + return transform((oldValue) -> { + return newValue; + }); + } + /** * Transform the value held in this holder * @@ -85,17 +98,4 @@ public interface IHolder { */ public UnwrappedType unwrap( Function unwrapper); - - /** - * Replace the held value with a new one - * - * @param newValue - * The value to hold instead - * @return The holder itself - */ - public default IHolder replace(ContainedType newValue) { - return transform((oldValue) -> { - return newValue; - }); - } } 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 ce38d60..316074e 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java @@ -15,6 +15,20 @@ import java.util.function.Function; * */ public interface IPair { + /** + * Bind a function across the values in this pair + * + * @param + * The type of the bound left + * @param + * The type of the bound right + * @param binder + * The function to bind with + * @return The bound pair + */ + public IPair bind( + BiFunction> binder); + /** * Bind a function to the left value in this pair * @@ -40,30 +54,19 @@ public interface IPair { Function> rightBinder); /** - * Bind a function across the values in this pair + * Immediately perfom the specified action with the contents of this + * pair * - * @param - * The type of the bound left - * @param - * The type of the bound right - * @param binder - * The function to bind with - * @return The bound pair + * @param consumer + * The action to perform on the pair */ - public IPair bind( - BiFunction> binder); + public default void doWith(BiConsumer consumer) { + merge((leftValue, rightValue) -> { + consumer.accept(leftValue, rightValue); - /** - * Merge the two values in this pair into a single value - * - * @param - * The type of the single value - * @param merger - * The function to use for merging - * @return The pair, merged into a single value - */ - public MergedType merge( - BiFunction merger); + return null; + }); + } /** * Get the value on the left side of the pair @@ -84,17 +87,14 @@ public interface IPair { } /** - * Immediately perfom the specified action with the contents of this - * pair + * Merge the two values in this pair into a single value * - * @param consumer - * The action to perform on the pair + * @param + * The type of the single value + * @param merger + * The function to use for merging + * @return The pair, merged into a single value */ - public default void doWith(BiConsumer consumer) { - merge((leftValue, rightValue) -> { - consumer.accept(leftValue, rightValue); - - return null; - }); - } + public MergedType merge( + BiFunction merger); } diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java index f4bc24a..061486e 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java @@ -95,6 +95,19 @@ public class Lazy implements IHolder { }); } + @Override + public String toString() { + if (valueMaterialized) { + if (actions.isEmpty()) { + return "value[v='" + heldValue + "']"; + } + + return "value[v='" + heldValue + "'] (has pending transforms)"; + } + + return "(unmaterialized)"; + } + @Override public IHolder transform( UnaryOperator transformer) { @@ -120,17 +133,4 @@ public class Lazy implements IHolder { return unwrapper.apply(heldValue); } - - @Override - public String toString() { - if (valueMaterialized) { - if (actions.isEmpty()) { - return "value[v='" + heldValue + "']"; - } - - return "value[v='" + heldValue + "'] (has pending transforms)"; - } - - return "(unmaterialized)"; - } } 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 d69a7bb..b02d9cb 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java @@ -58,6 +58,12 @@ public class LazyPair rightMaterialized = false; } + @Override + public IPair bind( + BiFunction> binder) { + return new BoundLazyPair<>(leftSupplier, rightSupplier, binder); + } + @Override public IPair bindLeft( Function> leftBinder) { @@ -87,49 +93,43 @@ public class LazyPair } @Override - public IPair bind( - BiFunction> binder) { - return new BoundLazyPair<>(leftSupplier, rightSupplier, binder); - } - - @Override - public MergedType merge( - BiFunction merger) { + public LeftType getLeft() { if (!leftMaterialized) { leftValue = leftSupplier.get(); leftMaterialized = true; } + return leftValue; + } + + @Override + public RightType getRight() { if (!rightMaterialized) { rightValue = rightSupplier.get(); rightMaterialized = true; } - return merger.apply(leftValue, rightValue); + return rightValue; } @Override - public LeftType getLeft() { + public MergedType merge( + BiFunction merger) { if (!leftMaterialized) { leftValue = leftSupplier.get(); leftMaterialized = true; } - return leftValue; - } - - @Override - public RightType getRight() { if (!rightMaterialized) { rightValue = rightSupplier.get(); rightMaterialized = true; } - return rightValue; + return merger.apply(leftValue, rightValue); } @Override 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 66c50de..05955b6 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java @@ -37,6 +37,12 @@ public class Pair rightValue = right; } + @Override + public IPair bind( + BiFunction> binder) { + return binder.apply(leftValue, rightValue); + } + @Override public IPair bindLeft( Function> leftBinder) { @@ -49,12 +55,6 @@ public class Pair return rightBinder.apply(rightValue); } - @Override - public IPair bind( - BiFunction> binder) { - return binder.apply(leftValue, rightValue); - } - @Override public MergedType merge( BiFunction merger) { -- cgit v1.2.3