From 8a8b457c98e207d809a7616e73eb59bfe197a7a5 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Thu, 31 Mar 2016 11:43:21 -0400 Subject: More code maintenance --- .../src/main/java/bjc/utils/parserutils/AST.java | 152 ++++++++++++--------- 1 file changed, 89 insertions(+), 63 deletions(-) (limited to 'BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java') diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java index 9ced090..4bfb469 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java @@ -6,7 +6,7 @@ import java.util.function.Function; import java.util.function.Predicate; import java.util.function.UnaryOperator; -import bjc.utils.funcdata.ITreePart.TreeLinearizationMethod; +import bjc.utils.funcdata.bst.ITreePart.TreeLinearizationMethod; /** * A simple binary tree meant for use as an AST @@ -55,36 +55,37 @@ public class AST { /** * Traverse an AST * - * @param tlm + * @param linearizationMethod * The way to traverse the tree - * @param con + * @param action * The function to call on each traversed element */ - public void traverse(TreeLinearizationMethod tlm, Consumer con) { + public void traverse(TreeLinearizationMethod linearizationMethod, + Consumer action) { if (left != null && right != null) { - switch (tlm) { + switch (linearizationMethod) { case INORDER: - left.traverse(tlm, con); - con.accept(token); - right.traverse(tlm, con); + left.traverse(linearizationMethod, action); + action.accept(token); + right.traverse(linearizationMethod, action); break; case POSTORDER: - left.traverse(tlm, con); - right.traverse(tlm, con); - con.accept(token); + left.traverse(linearizationMethod, action); + right.traverse(linearizationMethod, action); + action.accept(token); break; case PREORDER: - con.accept(token); - left.traverse(tlm, con); - right.traverse(tlm, con); + action.accept(token); + left.traverse(linearizationMethod, action); + right.traverse(linearizationMethod, action); break; default: throw new IllegalArgumentException( - "Got a invalid tree linearizer " + tlm - + ". WAT"); + "Got a invalid tree linearizer " + + linearizationMethod + ". WAT"); } } else { - con.accept(token); + action.accept(token); } } @@ -95,107 +96,131 @@ public class AST { * The final value of the collapsed tree * @param * - * @param tokenTransform + * @param tokenTransformer * The function to transform nodes into data - * @param nodeTransform + * @param nodeTransformer * A map of functions for operator collapsing - * @param resultTransform + * @param resultTransformer * The function for transforming the result * @return The collapsed value of the tree */ - public E collapse(Function tokenTransform, - Function> nodeTransform, - Function resultTransform) { - return resultTransform - .apply(internalCollapse(tokenTransform, nodeTransform)); + public E collapse(Function tokenTransformer, + Function> nodeTransformer, + Function resultTransformer) { + return resultTransformer.apply( + internalCollapse(tokenTransformer, nodeTransformer)); } /* * Internal recursive collapser */ - protected T2 internalCollapse(Function tokenTransform, - Function> nodeTransform) { + protected T2 internalCollapse(Function tokenTransformer, + Function> nodeTransformer) { if (left == null && right == null) { - return tokenTransform.apply(token); + return tokenTransformer.apply(token); } else { - T2 leftCollapsed = left.internalCollapse(tokenTransform, - nodeTransform); - T2 rightCollapsed = right.internalCollapse(tokenTransform, - nodeTransform); + T2 leftCollapsed; + + if (left == null) { + leftCollapsed = null; + } else { + leftCollapsed = left.internalCollapse(tokenTransformer, + nodeTransformer); + } + + T2 rightCollapsed; + if (right == null) { + rightCollapsed = null; + } else { + rightCollapsed = right.internalCollapse(tokenTransformer, + nodeTransformer); + } - return nodeTransform.apply(token).apply(leftCollapsed, + return nodeTransformer.apply(token).apply(leftCollapsed, rightCollapsed); } } @Override public String toString() { - StringBuilder sb = new StringBuilder(); + StringBuilder builder = new StringBuilder(); - internalToString(sb, -1); + internalToString(builder, -1); - return sb.toString(); + return builder.toString(); } /** * Internal version of toString for proper rendering * - * @param sb + * @param builder * The string rendering being built * @param indentLevel * The current level to indent the tree */ - protected void internalToString(StringBuilder sb, int indentLevel) { - indentNLevels(sb, indentLevel); + protected void internalToString(StringBuilder builder, + int indentLevel) { + indentNLevels(builder, indentLevel); if (left == null && right == null) { - sb.append("Node: "); - sb.append(token.toString()); - sb.append("\n"); + builder.append("Node: "); + builder.append(token.toString()); + builder.append("\n"); } else { - sb.append("Node: "); - sb.append(token.toString()); - sb.append("\n"); - - left.internalToString(sb, indentLevel + 2); - right.internalToString(sb, indentLevel + 2); + builder.append("Node: "); + builder.append(token.toString()); + builder.append("\n"); + + if (left != null) { + left.internalToString(builder, indentLevel + 2); + } else { + indentNLevels(builder, indentLevel + 2); + builder.append("No left node\n"); + } + if (right != null) { + right.internalToString(builder, indentLevel + 2); + } else { + indentNLevels(builder, indentLevel + 2); + builder.append("No right node\n"); + } } } /** * Indent a string n levels * - * @param sb + * @param builder * The string to indent - * @param n + * @param levels * The number of levels to indent */ - protected static void indentNLevels(StringBuilder sb, int n) { - for (int i = 0; i <= n; i++) { - sb.append("\t"); + protected static void indentNLevels(StringBuilder builder, + int levels) { + for (int i = 0; i <= levels; i++) { + builder.append("\t"); } } /** * Execute a transform on selective nodes of the tree * - * @param transformPred + * @param transformerPredicate * The predicate to pick nodes to transform * @param transformer * The thing to use to transform the nodes */ - public void selectiveTransform(Predicate transformPred, + public void selectiveTransform(Predicate transformerPredicate, UnaryOperator transformer) { - if (transformPred.test(token)) { + if (transformerPredicate.test(token)) { token = transformer.apply(token); } if (left != null) { - left.selectiveTransform(transformPred, transformer); + left.selectiveTransform(transformerPredicate, transformer); } if (right != null) { - right.selectiveTransform(transformPred, transformer); + right.selectiveTransform(transformerPredicate, transformer); } } @@ -210,17 +235,18 @@ public class AST { * @return The AST with transformed tokens */ public AST transmuteAST(Function tokenTransformer) { - AST l = null; - AST r = null; + AST leftBranch = null; + AST rightBranch = null; if (left != null) { - l = left.transmuteAST(tokenTransformer); + leftBranch = left.transmuteAST(tokenTransformer); } if (right != null) { - r = right.transmuteAST(tokenTransformer); + rightBranch = right.transmuteAST(tokenTransformer); } - return new AST<>(tokenTransformer.apply(token), l, r); + return new AST<>(tokenTransformer.apply(token), leftBranch, + rightBranch); } } -- cgit v1.2.3