From 27bf571d6413c3cc6a5d664b5bddd38d21d7b1cd Mon Sep 17 00:00:00 2001 From: EVE Date: Mon, 13 Mar 2017 16:42:21 -0400 Subject: Formatting --- BJC-Utils2/src/main/java/bjc/utils/data/Tree.java | 170 +++++++++++----------- 1 file changed, 87 insertions(+), 83 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 5fed73f..6a16491 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/Tree.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/Tree.java @@ -17,11 +17,11 @@ import bjc.utils.funcdata.bst.TreeLinearizationMethod; * @param */ public class Tree implements ITree { - private ContainedType data; + private ContainedType data; - private IList> children; - private boolean hasChildren; - private int childCount = 0; + private IList> children; + private boolean hasChildren; + private int childCount = 0; private int ID; private static int nextID = 0; @@ -30,7 +30,7 @@ public class Tree implements ITree { * Create a new leaf node in a tree * * @param leaf - * The data to store as a leaf node + * The data to store as a leaf node */ public Tree(ContainedType leaf) { data = leaf; @@ -44,9 +44,9 @@ public class Tree implements ITree { * Create a new tree node with the specified children * * @param leaf - * The data to hold in this node + * The data to hold in this node * @param childrn - * A list of children for this node + * A list of children for this node */ public Tree(ContainedType leaf, IList> childrn) { this(leaf); @@ -60,9 +60,9 @@ public class Tree implements ITree { * Create a new tree node with the specified children * * @param leaf - * The data to hold in this node + * The data to hold in this node * @param childrn - * A list of children for this node + * A list of children for this node */ @SafeVarargs public Tree(ContainedType leaf, ITree... childrn) { @@ -95,8 +95,7 @@ public class Tree implements ITree { } @Override - public ReturnedType collapse( - Function leafTransform, + public ReturnedType collapse(Function leafTransform, Function, NewType>> nodeCollapser, Function resultTransformer) { @@ -127,14 +126,13 @@ public class Tree implements ITree { return childCount; } - protected NewType internalCollapse( - Function leafTransform, + protected NewType internalCollapse(Function leafTransform, Function, NewType>> nodeCollapser) { if (hasChildren) { Function, NewType> nodeTransformer = nodeCollapser.apply(data); IList collapsedChildren = (IList) children.map((child) -> { - return child.collapse(leafTransform, nodeCollapser, (subTreeVal) -> subTreeVal); + return child.collapse(leafTransform, nodeCollapser, (subTreeVal) -> subTreeVal); }); return nodeTransformer.apply(collapsedChildren); @@ -144,7 +142,7 @@ public class Tree implements ITree { } protected void internalToString(StringBuilder builder, int indentLevel, boolean initial) { - for(int i = 0; i < indentLevel; i++) { + for (int i = 0; i < indentLevel; i++) { builder.append(">\t"); } @@ -156,19 +154,17 @@ public class Tree implements ITree { if (hasChildren) { children.forEach((child) -> { - ((Tree) child).internalToString(builder, indentLevel+1, false); + ((Tree) child).internalToString(builder, indentLevel + 1, false); }); } } @Override - public ITree rebuildTree( - Function leafTransformer, + public ITree rebuildTree(Function leafTransformer, Function operatorTransformer) { if (hasChildren) { IList> mappedChildren = children.map((child) -> { - return child.rebuildTree(leafTransformer, - operatorTransformer); + return child.rebuildTree(leafTransformer, operatorTransformer); }); return new Tree<>(operatorTransformer.apply(data), mappedChildren); @@ -187,50 +183,49 @@ public class Tree implements ITree { } @Override - public ITree topDownTransform( - Function transformPicker, + public ITree topDownTransform(Function transformPicker, UnaryOperator> transformer) { TopDownTransformResult transformResult = transformPicker.apply(data); switch (transformResult) { - case PASSTHROUGH: - ITree result = new Tree<>(data); + case PASSTHROUGH: + ITree result = new Tree<>(data); - if (hasChildren) { - children.forEach((child) -> { - result.addChild(child.topDownTransform(transformPicker, transformer)); - }); - } + if (hasChildren) { + children.forEach((child) -> { + result.addChild(child.topDownTransform(transformPicker, transformer)); + }); + } - return result; - case SKIP: - return this; - case TRANSFORM: - return transformer.apply(this); - case RTRANSFORM: - return transformer.apply(this).topDownTransform(transformPicker, transformer); - case PUSHDOWN: - result = new Tree<>(data); - - if (hasChildren) { - children.forEach((child) -> { - result.addChild(child.topDownTransform(transformPicker, transformer)); - }); - } + return result; + case SKIP: + return this; + case TRANSFORM: + return transformer.apply(this); + case RTRANSFORM: + return transformer.apply(this).topDownTransform(transformPicker, transformer); + case PUSHDOWN: + result = new Tree<>(data); + + if (hasChildren) { + children.forEach((child) -> { + result.addChild(child.topDownTransform(transformPicker, transformer)); + }); + } - return transformer.apply(result); - case PULLUP: - ITree intermediateResult = transformer.apply(this); + return transformer.apply(result); + case PULLUP: + ITree intermediateResult = transformer.apply(this); - result = new Tree<>(intermediateResult.getHead()); + result = new Tree<>(intermediateResult.getHead()); - intermediateResult.doForChildren((child) -> { - result.addChild(child.topDownTransform(transformPicker, transformer)); - }); + intermediateResult.doForChildren((child) -> { + result.addChild(child.topDownTransform(transformPicker, transformer)); + }); - return result; - default: - throw new IllegalArgumentException("Recieved unknown transform result " + transformResult); + return result; + default: + throw new IllegalArgumentException("Recieved unknown transform result " + transformResult); } } @@ -247,8 +242,8 @@ 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"); } @@ -264,7 +259,8 @@ public class Tree implements ITree { @Override 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); } @@ -276,29 +272,30 @@ public class Tree implements ITree { 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."); - } + case INORDER: + if (childCount != 2) { + 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); + action.accept(data); - children.getByIndex(1).traverse(linearizationMethod, action); - break; - case POSTORDER: - children.forEach((child) -> child.traverse(linearizationMethod, action)); + children.getByIndex(1).traverse(linearizationMethod, action); + break; + case POSTORDER: + children.forEach((child) -> child.traverse(linearizationMethod, action)); - action.accept(data); - break; - case PREORDER: - action.accept(data); + action.accept(data); + break; + case PREORDER: + action.accept(data); - children.forEach((child) -> child.traverse(linearizationMethod, action)); - break; - default: - break; + children.forEach((child) -> child.traverse(linearizationMethod, action)); + break; + default: + break; } } else { @@ -307,24 +304,31 @@ public class Tree implements ITree { } public boolean equals(Object other) { - if(!(other instanceof Tree)) return false; + if (!(other instanceof Tree)) + return false; @SuppressWarnings("unchecked") Tree otr = (Tree) other; - if(!otr.data.equals(data)) return false; + if (!otr.data.equals(data)) + return false; - if(children == null && otr.children == null) return true; + if (children == null && otr.children == null) + return true; - if(children == null && otr.children != null) return false; - if(children != null && otr.children == null) return false; + if (children == null && otr.children != null) + return false; + if (children != null && otr.children == null) + return false; - if(children.getSize() != otr.children.getSize()) return false; + if (children.getSize() != otr.children.getSize()) + return false; int childNo = 0; - for(ITree child : children) { - if(!otr.children.getByIndex(childNo).equals(child)) return false; + for (ITree child : children) { + if (!otr.children.getByIndex(childNo).equals(child)) + return false; childNo += 1; } -- cgit v1.2.3