From d2af58b0f68ebfbba2be7e7679efec6c8c0af12f Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Thu, 9 Feb 2017 11:50:31 -0500 Subject: Update --- BJC-Utils2/src/main/java/bjc/utils/data/Tree.java | 129 ++++++++-------------- 1 file changed, 48 insertions(+), 81 deletions(-) (limited to 'BJC-Utils2/src/main/java/bjc/utils/data/Tree.java') 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; -- cgit v1.2.3