From d2af58b0f68ebfbba2be7e7679efec6c8c0af12f Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Thu, 9 Feb 2017 11:50:31 -0500 Subject: Update --- .../src/main/java/bjc/utils/data/LazyPair.java | 9 +- .../src/main/java/bjc/utils/data/ListHolder.java | 15 +-- .../src/main/java/bjc/utils/data/Option.java | 21 ++-- BJC-Utils2/src/main/java/bjc/utils/data/Pair.java | 46 +++----- .../main/java/bjc/utils/data/SingleSupplier.java | 3 +- .../bjc/utils/data/TopDownTransformResult.java | 4 +- BJC-Utils2/src/main/java/bjc/utils/data/Tree.java | 129 ++++++++------------- .../src/main/java/bjc/utils/data/WrappedLazy.java | 34 ++---- .../main/java/bjc/utils/data/WrappedOption.java | 57 ++++----- 9 files changed, 121 insertions(+), 197 deletions(-) (limited to 'BJC-Utils2/src/main/java/bjc/utils/data') 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 53428d9..f20139e 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java @@ -14,8 +14,6 @@ import java.util.function.Supplier; * @param * The type on the right side of the pair * - * @TODO ensure we don't have any issues with values being materialized - * more than once */ public class LazyPair implements IPair { @@ -54,6 +52,7 @@ public class LazyPair */ public LazyPair(Supplier leftSupp, Supplier rightSupp) { + // Use single suppliers to catch double-instantiation bugs leftSupplier = new SingleSupplier<>(leftSupp); rightSupplier = new SingleSupplier<>(rightSupp); @@ -63,14 +62,12 @@ public class LazyPair @Override public IPair bind( - BiFunction> binder) { + BiFunction> binder) { return new BoundLazyPair<>(leftSupplier, rightSupplier, binder); } @Override - public IPair bindLeft( - Function> leftBinder) { + public IPair bindLeft(Function> leftBinder) { Supplier leftSupp = () -> { if (leftMaterialized) { return leftValue; diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java b/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java index fc6180b..e7ae1fc 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java @@ -39,40 +39,35 @@ public class ListHolder implements IHolder { } @Override - public IHolder bind( - Function> binder) { + public IHolder bind(Function> binder) { IList> boundValues = heldValues.map(binder); return new BoundListHolder<>(boundValues); } @Override - public Function> lift( - Function func) { + public Function> lift(Function func) { return (val) -> { return new ListHolder<>(new FunctionalList<>(func.apply(val))); }; } @Override - public IHolder map( - Function mapper) { + public IHolder map(Function mapper) { IList mappedValues = heldValues.map(mapper); return new ListHolder<>(mappedValues); } @Override - public IHolder transform( - UnaryOperator transformer) { + public IHolder transform(UnaryOperator transformer) { heldValues = heldValues.map(transformer); return this; } @Override - public UnwrappedType unwrap( - Function unwrapper) { + public UnwrappedType unwrap(Function unwrapper) { return unwrapper.apply(heldValues.randItem()); } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Option.java b/BJC-Utils2/src/main/java/bjc/utils/data/Option.java index 16d90e3..33b6327 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/Option.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/Option.java @@ -17,16 +17,15 @@ public class Option implements IHolder { /** * Create a new optional, using the given initial value * - * @param seedValue + * @param seed * The initial value for the optional */ - public Option(ContainedType seedValue) { - held = seedValue; + public Option(ContainedType seed) { + held = seed; } @Override - public IHolder bind( - Function> binder) { + public IHolder bind(Function> binder) { if (held == null) { return new Option<>(null); } @@ -35,16 +34,14 @@ public class Option implements IHolder { } @Override - public Function> lift( - Function func) { + public Function> lift(Function func) { return (val) -> { return new Option<>(func.apply(val)); }; } @Override - public IHolder map( - Function mapper) { + public IHolder map(Function mapper) { if (held == null) { return new Option<>(null); } @@ -53,8 +50,7 @@ public class Option implements IHolder { } @Override - public IHolder transform( - UnaryOperator transformer) { + public IHolder transform(UnaryOperator transformer) { if (held != null) { held = transformer.apply(held); } @@ -63,8 +59,7 @@ public class Option implements IHolder { } @Override - public UnwrappedType unwrap( - Function unwrapper) { + public UnwrappedType unwrap(Function unwrapper) { if (held == null) { return null; } 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 3480b2a..74040e8 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java @@ -13,10 +13,10 @@ import java.util.function.Function; * @param * The type of the right value */ -public class Pair - implements IPair { +public class Pair implements IPair { // The left value private LeftType leftValue; + // The right value private RightType rightValue; @@ -24,6 +24,7 @@ public class Pair * Create a new pair with both sides set to null */ public Pair() { + } /** @@ -41,8 +42,7 @@ public class Pair @Override public IPair bind( - BiFunction> binder) { + BiFunction> binder) { if (binder == null) { throw new NullPointerException("Binder must not be null."); } @@ -51,8 +51,7 @@ public class Pair } @Override - public IPair bindLeft( - Function> leftBinder) { + public IPair bindLeft(Function> leftBinder) { if (leftBinder == null) { throw new NullPointerException("Binder must not be null"); } @@ -61,8 +60,7 @@ public class Pair } @Override - public IPair bindRight( - Function> rightBinder) { + public IPair bindRight(Function> rightBinder) { if (rightBinder == null) { throw new NullPointerException("Binder must not be null"); } @@ -71,22 +69,17 @@ public class Pair } @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)); - }); + 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)); + }); } @Override - public IPair mapLeft( - Function mapper) { + public IPair mapLeft(Function mapper) { if (mapper == null) { throw new NullPointerException("Mapper must not be null"); } @@ -95,8 +88,7 @@ public class Pair } @Override - public IPair mapRight( - Function mapper) { + public IPair mapRight(Function mapper) { if (mapper == null) { throw new NullPointerException("Mapper must not be null"); } @@ -105,8 +97,7 @@ public class Pair } @Override - public MergedType merge( - BiFunction merger) { + public MergedType merge(BiFunction merger) { if (merger == null) { throw new NullPointerException("Merger must not be null"); } @@ -116,7 +107,6 @@ public class Pair @Override public String toString() { - return "pair[l=" + leftValue.toString() + ", r=" - + rightValue.toString() + "]"; + return "pair[l=" + leftValue.toString() + ", r=" + rightValue.toString() + "]"; } -} \ No newline at end of file +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/SingleSupplier.java b/BJC-Utils2/src/main/java/bjc/utils/data/SingleSupplier.java index ad00496..b5ff1e3 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/SingleSupplier.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/SingleSupplier.java @@ -55,8 +55,7 @@ public class SingleSupplier implements Supplier { gotten = true; try { - throw new IllegalStateException( - "Previous instantiation here."); + throw new IllegalStateException("Previous instantiation here."); } catch (IllegalStateException isex) { instSite = isex; } diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/TopDownTransformResult.java b/BJC-Utils2/src/main/java/bjc/utils/data/TopDownTransformResult.java index a2448d2..e72cdf6 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/TopDownTransformResult.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/TopDownTransformResult.java @@ -8,7 +8,7 @@ package bjc.utils.data; */ public enum TopDownTransformResult { /** - * Do not do anything to this node, and ignore it's children + * Do not do anything to this node, and ignore its children */ SKIP, /** @@ -20,7 +20,7 @@ public enum TopDownTransformResult { */ PASSTHROUGH, /** - * Traverse this nodes children, then transform it + * Traverse the nodes of this children, then transform it */ PUSHDOWN, /** diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Tree.java b/BJC-Utils2/src/main/java/bjc/utils/data/Tree.java index 46fb1a6..b812650 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/Tree.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/Tree.java @@ -19,20 +19,19 @@ import bjc.utils.funcutils.StringUtils; */ public class Tree implements ITree { private ContainedType data; - private IList> children; + private IList> children; private boolean hasChildren; - private int childCount = 0; /** * Create a new leaf node in a tree * - * @param leafToken + * @param leaf * The data to store as a leaf node */ - public Tree(ContainedType leafToken) { - data = leafToken; + public Tree(ContainedType leaf) { + data = leaf; hasChildren = false; } @@ -40,14 +39,13 @@ public class Tree implements ITree { /** * Create a new tree node with the specified children * - * @param leafToken + * @param leaf * The data to hold in this node * @param childrn * A list of children for this node */ - public Tree(ContainedType leafToken, - IList> childrn) { - data = leafToken; + public Tree(ContainedType leaf, IList> childrn) { + data = leaf; hasChildren = true; @@ -59,14 +57,14 @@ public class Tree implements ITree { /** * Create a new tree node with the specified children * - * @param leafToken + * @param leaf * The data to hold in this node * @param childrn * A list of children for this node */ @SafeVarargs - public Tree(ContainedType leafToken, ITree... childrn) { - data = leafToken; + public Tree(ContainedType leaf, ITree... childrn) { + data = leaf; hasChildren = true; @@ -97,12 +95,10 @@ public class Tree implements ITree { @Override public ReturnedType collapse( Function leafTransform, - Function, NewType>> nodeCollapser, + Function, NewType>> nodeCollapser, Function resultTransformer) { - return resultTransformer - .apply(internalCollapse(leafTransform, nodeCollapser)); + return resultTransformer.apply(internalCollapse(leafTransform, nodeCollapser)); } @Override @@ -111,8 +107,7 @@ public class Tree implements ITree { } @Override - public ITree flatMapTree( - Function> mapper) { + public ITree flatMapTree(Function> mapper) { if (hasChildren) { ITree flatMappedData = mapper.apply(data); @@ -132,17 +127,14 @@ public class Tree implements ITree { protected NewType internalCollapse( Function leafTransform, - Function, NewType>> nodeCollapser) { + Function, NewType>> nodeCollapser) { if (hasChildren) { - Function, - NewType> nodeTransformer = nodeCollapser.apply(data); + Function, NewType> nodeTransformer = nodeCollapser.apply(data); - IList collapsedChildren = (IList) children - .map((child) -> { - return child.collapse(leafTransform, nodeCollapser, - (subTreeVal) -> subTreeVal); - }); + IList collapsedChildren = (IList) children.map((child) -> { + return child.collapse(leafTransform, nodeCollapser, + (subTreeVal) -> subTreeVal); + }); return nodeTransformer.apply(collapsedChildren); } @@ -150,8 +142,7 @@ public class Tree implements ITree { return leafTransform.apply(data); } - protected void internalToString(StringBuilder builder, int indentLevel, - boolean initial) { + protected void internalToString(StringBuilder builder, int indentLevel, boolean initial) { if (!initial) { StringUtils.indentNLevels(builder, indentLevel); } @@ -162,8 +153,7 @@ public class Tree implements ITree { if (hasChildren) { children.forEach((child) -> { - ((Tree) child).internalToString(builder, - indentLevel + 2, false); + ((Tree) child).internalToString(builder, indentLevel + 2, false); }); } } @@ -173,25 +163,21 @@ public class Tree implements ITree { Function leafTransformer, Function operatorTransformer) { if (hasChildren) { - IList> mappedChildren = children - .map((child) -> { - return child.rebuildTree(leafTransformer, - operatorTransformer); - }); + IList> mappedChildren = children.map((child) -> { + return child.rebuildTree(leafTransformer, + operatorTransformer); + }); - return new Tree<>(operatorTransformer.apply(data), - mappedChildren); + return new Tree<>(operatorTransformer.apply(data), mappedChildren); } return new Tree<>(leafTransformer.apply(data)); } @Override - public void selectiveTransform(Predicate nodePicker, - UnaryOperator transformer) { + public void selectiveTransform(Predicate nodePicker, UnaryOperator transformer) { if (hasChildren) { - children.forEach((child) -> child - .selectiveTransform(nodePicker, transformer)); + children.forEach((child) -> child.selectiveTransform(nodePicker, transformer)); } else { data = transformer.apply(data); } @@ -199,11 +185,9 @@ public class Tree implements ITree { @Override public ITree topDownTransform( - Function transformPicker, + Function transformPicker, UnaryOperator> transformer) { - TopDownTransformResult transformResult = transformPicker - .apply(data); + TopDownTransformResult transformResult = transformPicker.apply(data); switch (transformResult) { case PASSTHROUGH: @@ -211,8 +195,7 @@ public class Tree implements ITree { if (hasChildren) { children.forEach((child) -> { - result.addChild(child.topDownTransform( - transformPicker, transformer)); + result.addChild(child.topDownTransform(transformPicker, transformer)); }); } @@ -226,28 +209,23 @@ public class Tree implements ITree { if (hasChildren) { children.forEach((child) -> { - result.addChild(child.topDownTransform( - transformPicker, transformer)); + result.addChild(child.topDownTransform(transformPicker, transformer)); }); } return transformer.apply(result); case PULLUP: - ITree intermediateResult = transformer - .apply(this); + ITree intermediateResult = transformer.apply(this); result = new Tree<>(intermediateResult.getHead()); intermediateResult.doForChildren((child) -> { - result.addChild(child.topDownTransform(transformPicker, - transformer)); + result.addChild(child.topDownTransform(transformPicker, transformer)); }); return result; default: - throw new IllegalArgumentException( - "Recieved unknown transform result " - + transformResult); + throw new IllegalArgumentException("Recieved unknown transform result " + transformResult); } } @@ -264,66 +242,55 @@ public class Tree implements ITree { } @Override - public TransformedType transformChild(int childNo, - Function, TransformedType> transformer) { + public TransformedType transformChild( + int childNo, Function, TransformedType> transformer) { if (childNo < 0 || childNo > (childCount - 1)) { - throw new IllegalArgumentException( - "Child index #" + childNo + " is invalid"); + throw new IllegalArgumentException("Child index #" + childNo + " is invalid"); } return transformer.apply(children.getByIndex(childNo)); } @Override - public TransformedType transformHead( - Function transformer) { + public TransformedType transformHead(Function transformer) { return transformer.apply(data); } @Override - public ITree transformTree( - Function transformer) { + public ITree transformTree(Function transformer) { if (hasChildren) { - IList> transformedChildren = children - .map((child) -> child.transformTree(transformer)); + IList> transformedChildren = children.map((child) -> child.transformTree(transformer)); - return new Tree<>(transformer.apply(data), - transformedChildren); + return new Tree<>(transformer.apply(data), transformedChildren); } return new Tree<>(transformer.apply(data)); } @Override - public void traverse(TreeLinearizationMethod linearizationMethod, - Consumer action) { + public void traverse(TreeLinearizationMethod linearizationMethod, Consumer action) { if (hasChildren) { switch (linearizationMethod) { case INORDER: if (childCount != 2) { - throw new IllegalArgumentException( - "Can only do in-order traversal for binary trees."); + throw new IllegalArgumentException("Can only do in-order traversal for binary trees."); } - children.getByIndex(0).traverse(linearizationMethod, - action); + children.getByIndex(0).traverse(linearizationMethod, action); action.accept(data); - children.getByIndex(1).traverse(linearizationMethod, - action); + children.getByIndex(1).traverse(linearizationMethod, action); break; case POSTORDER: - children.forEach((child) -> child - .traverse(linearizationMethod, action)); + children.forEach((child) -> child.traverse(linearizationMethod, action)); action.accept(data); break; case PREORDER: action.accept(data); - children.forEach((child) -> child - .traverse(linearizationMethod, action)); + children.forEach((child) -> child.traverse(linearizationMethod, action)); break; default: break; diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java index b894ac7..d278358 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java @@ -12,46 +12,37 @@ class WrappedLazy implements IHolder { // This has an extra parameter, because otherwise it erases to the same // as the public one - private WrappedLazy(IHolder> wrappedHolder, - boolean dummy) { + private WrappedLazy(IHolder> wrappedHolder, boolean dummy) { held = wrappedHolder; } @Override - public IHolder bind( - Function> binder) { - IHolder> newHolder = held - .map((containedHolder) -> { - return containedHolder.bind(binder); - }); + public IHolder bind(Function> binder) { + IHolder> newHolder = held.map((containedHolder) -> { + return containedHolder.bind(binder); + }); return new WrappedLazy<>(newHolder, false); } @Override - public Function> lift( - Function func) { + public Function> lift(Function func) { return (val) -> { return new Lazy<>(func.apply(val)); }; } @Override - public IHolder map( - Function mapper) { - IHolder> newHolder = held - .map((containedHolder) -> { - return containedHolder.map(mapper); - }); + public IHolder map(Function mapper) { + IHolder> newHolder = held.map((containedHolder) -> { + return containedHolder.map(mapper); + }); return new WrappedLazy<>(newHolder, false); } @Override - public IHolder transform( - UnaryOperator transformer) { - // FIXME this smells bad to me, but I can't figure out how else to - // do it + public IHolder transform(UnaryOperator transformer) { held.transform((containedHolder) -> { return containedHolder.transform(transformer); }); @@ -60,8 +51,7 @@ class WrappedLazy implements IHolder { } @Override - public UnwrappedType unwrap( - Function unwrapper) { + public UnwrappedType unwrap(Function unwrapper) { return held.unwrap((containedHolder) -> { return containedHolder.unwrap(unwrapper); }); diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java index fea4cb9..554eb54 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java @@ -10,56 +10,48 @@ class WrappedOption implements IHolder { held = new Option<>(seedValue); } - private WrappedOption(IHolder> toHold, - boolean dummy) { + private WrappedOption(IHolder> toHold, boolean dummy) { held = toHold; } - @Override - public IHolder bind( - Function> binder) { - IHolder> newHolder = held - .map((containedHolder) -> { - return containedHolder.bind((containedValue) -> { - if (containedValue == null) { - return new Option<>(null); - } - - return binder.apply(containedValue); - }); - }); + @Override public IHolder bind(Function> binder) { + IHolder> newHolder = held.map((containedHolder) -> { + return containedHolder.bind((containedValue) -> { + if (containedValue == null) { + return new Option<>(null); + } + + return binder.apply(containedValue); + }); + }); return new WrappedOption<>(newHolder, false); } @Override - public Function> lift( - Function func) { + public Function> lift(Function func) { return (val) -> { return new Option<>(func.apply(val)); }; } @Override - public IHolder map( - Function mapper) { - IHolder> newHolder = held - .map((containedHolder) -> { - return containedHolder.map((containedValue) -> { - if (containedValue == null) { - return null; - } - - return mapper.apply(containedValue); - }); - }); + public IHolder map(Function mapper) { + IHolder> newHolder = held.map((containedHolder) -> { + return containedHolder.map((containedValue) -> { + if (containedValue == null) { + return null; + } + + return mapper.apply(containedValue); + }); + }); return new WrappedOption<>(newHolder, false); } @Override - public IHolder transform( - UnaryOperator transformer) { + public IHolder transform(UnaryOperator transformer) { held.transform((containedHolder) -> { return containedHolder.transform((containedValue) -> { if (containedValue == null) { @@ -74,8 +66,7 @@ class WrappedOption implements IHolder { } @Override - public UnwrappedType unwrap( - Function unwrapper) { + public UnwrappedType unwrap(Function unwrapper) { return held.unwrap((containedHolder) -> { return containedHolder.unwrap((containedValue) -> { if (containedValue == null) { -- cgit v1.2.3