From 77fcc58d1facffbc3af50be8c05985350e9f1355 Mon Sep 17 00:00:00 2001
From: bculkin2442 <bjculkin@mix.wvu.edu>
Date: Sun, 17 Apr 2016 15:01:44 -0400
Subject: Code maintenace and changes

---
 .../src/main/java/bjc/utils/funcdata/Tree.java     | 46 ++++++++++++++++++----
 1 file changed, 38 insertions(+), 8 deletions(-)

(limited to 'BJC-Utils2/src/main/java/bjc/utils/funcdata/Tree.java')

diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/Tree.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/Tree.java
index d9938d4..5ee4200 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/Tree.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/Tree.java
@@ -6,6 +6,7 @@ import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 
 import bjc.utils.funcdata.bst.TreeLinearizationMethod;
+import bjc.utils.funcutils.StringUtils;
 
 /**
  * A node in a homogenous tree.
@@ -119,11 +120,11 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 			Function<ContainedType, NewType> leafTransform,
 			Function<ContainedType, Function<IFunctionalList<NewType>, NewType>> nodeCollapser) {
 		if (hasChildren) {
-			Function<IFunctionalList<NewType>, NewType> nodeTransformer = nodeCollapser
-					.apply(data);
+			Function<IFunctionalList<NewType>, NewType> nodeTransformer =
+					nodeCollapser.apply(data);
 
-			IFunctionalList<NewType> collapsedChildren = children
-					.map((child) -> {
+			IFunctionalList<NewType> collapsedChildren =
+					children.map((child) -> {
 						return child.collapse(leafTransform, nodeCollapser,
 								(subTreeVal) -> subTreeVal);
 					});
@@ -164,8 +165,9 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	public <MappedType> ITree<MappedType> transformTree(
 			Function<ContainedType, MappedType> transformer) {
 		if (hasChildren) {
-			IFunctionalList<ITree<MappedType>> transformedChildren = children
-					.map((child) -> child.transformTree(transformer));
+			IFunctionalList<ITree<MappedType>> transformedChildren =
+					children.map(
+							(child) -> child.transformTree(transformer));
 
 			return new Tree<>(transformer.apply(data),
 					transformedChildren);
@@ -219,8 +221,8 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 			Function<ContainedType, MappedType> leafTransformer,
 			Function<ContainedType, MappedType> operatorTransformer) {
 		if (hasChildren) {
-			IFunctionalList<ITree<MappedType>> mappedChildren = children
-					.map((child) -> {
+			IFunctionalList<ITree<MappedType>> mappedChildren =
+					children.map((child) -> {
 						return child.rebuildTree(leafTransformer,
 								operatorTransformer);
 					});
@@ -232,4 +234,32 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 		return new Tree<>(leafTransformer.apply(data));
 	}
 
+	@Override
+	public String toString() {
+		StringBuilder builder = new StringBuilder();
+
+		internalToString(builder, 1, true);
+
+		builder.deleteCharAt(builder.length() - 1);
+
+		return builder.toString();
+	}
+
+	protected void internalToString(StringBuilder builder, int indentLevel,
+			boolean initial) {
+		if (!initial) {
+			StringUtils.indentNLevels(builder, indentLevel);
+		}
+
+		builder.append("Node: ");
+		builder.append(data == null ? "(null)" : data.toString());
+		builder.append("\n");
+
+		if (hasChildren) {
+			children.forEach((child) -> {
+				((Tree<ContainedType>) child).internalToString(builder,
+						indentLevel + 2, false);
+			});
+		}
+	}
 }
-- 
cgit v1.2.3