Added new tree traversal option, and some minor changes

8 files changed, 124 insertions, 20 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java
index 41ab99b..40c502c 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java
@@ -60,8 +60,8 @@ class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight>
 	@Override
 	public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind(
 			BiFunction<NewLeft, NewRight, IPair<BoundLeft, BoundRight>> bindr) {
-		IHolder<IPair<NewLeft, NewRight>> newPair = new Identity<>(
-				boundPair);
+		IHolder<IPair<NewLeft, NewRight>> newPair =
+				new Identity<>(boundPair);
 		IHolder<Boolean> newPairMade = new Identity<>(pairBound);
 
 		Supplier<NewLeft> leftSupp = () -> {
@@ -90,15 +90,24 @@ class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight>
 	}
 
 	@Override
-	public <MergedType> MergedType merge(
-			BiFunction<NewLeft, NewRight, MergedType> merger) {
+	public <MergedType> MergedType
+			merge(BiFunction<NewLeft, NewRight, MergedType> merger) {
 		if (!pairBound) {
-			boundPair = binder.apply(leftSupplier.get(),
-					rightSupplier.get());
+			boundPair =
+					binder.apply(leftSupplier.get(), rightSupplier.get());
 
 			pairBound = true;
 		}
 
 		return boundPair.merge(merger);
 	}
+
+	@Override
+	public String toString() {
+		if (pairBound) {
+			return boundPair.toString();
+		}
+
+		return "(un-materialized)";
+	}
 }
\ No newline at end of file
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 fd432c1..7ae5e96 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java
@@ -93,8 +93,8 @@ public class LazyPair<LeftType, RightType>
 	}
 
 	@Override
-	public <MergedType> MergedType merge(
-			BiFunction<LeftType, RightType, MergedType> merger) {
+	public <MergedType> MergedType
+			merge(BiFunction<LeftType, RightType, MergedType> merger) {
 		if (!leftMaterialized) {
 			leftValue = leftSupplier.get();
 
@@ -131,4 +131,27 @@ public class LazyPair<LeftType, RightType>
 
 		return rightValue;
 	}
+
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder("pair[l=");
+
+		if (leftMaterialized) {
+			sb.append(leftValue.toString());
+		} else {
+			sb.append("(un-materialized)");
+		}
+
+		sb.append(", r=");
+
+		if (rightMaterialized) {
+			sb.append(rightValue.toString());
+		} else {
+			sb.append("(un-materialized)");
+		}
+
+		sb.append("]");
+
+		return sb.toString();
+	}
 }
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 958df40..94affd0 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java
@@ -56,8 +56,14 @@ public class Pair<LeftType, RightType>
 	}
 
 	@Override
-	public <MergedType> MergedType merge(
-			BiFunction<LeftType, RightType, MergedType> merger) {
+	public <MergedType> MergedType
+			merge(BiFunction<LeftType, RightType, MergedType> merger) {
 		return merger.apply(leftValue, rightValue);
 	}
+
+	@Override
+	public String 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/funcdata/ITree.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/ITree.java
index 624c9d6..7f28682 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/ITree.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/ITree.java
@@ -114,8 +114,8 @@ public interface ITree<ContainedType> {
 	 *            The function to use to transform tokens
 	 * @return A tree with the token types transformed
 	 */
-	public <MappedType> ITree<MappedType> transformTree(
-			Function<ContainedType, MappedType> transformer);
+	public <MappedType> ITree<MappedType>
+			transformTree(Function<ContainedType, MappedType> transformer);
 
 	/**
 	 * Perform an action on each part of the tree
@@ -142,4 +142,17 @@ public interface ITree<ContainedType> {
 	public <MappedType> ITree<MappedType> rebuildTree(
 			Function<ContainedType, MappedType> leafTransformer,
 			Function<ContainedType, MappedType> operatorTransformer);
+
+	/**
+	 * Do a top-down transform of the tree
+	 * 
+	 * @param transformPicker
+	 *            The function to use to pick how to progress
+	 * @param transformer
+	 *            The function used to transform picked subtrees
+	 * @return The tree with the transform applied to picked subtrees
+	 */
+	public ITree<ContainedType> topDownTransform(
+			Function<ContainedType, TopDownTransformResult> transformPicker,
+			UnaryOperator<ITree<ContainedType>> transformer);
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/TopDownTransformResult.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/TopDownTransformResult.java
new file mode 100644
index 0000000..9aec2b9
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/TopDownTransformResult.java
@@ -0,0 +1,22 @@
+package bjc.utils.funcdata;
+
+/**
+ * Represents the results for doing a top-down transform of a tree
+ * 
+ * @author ben
+ *
+ */
+public enum TopDownTransformResult {
+	/**
+	 * Do not do anything to this node, and ignore it's children
+	 */
+	SKIP,
+	/**
+	 * Transform this node, and don't touch its children
+	 */
+	TRANSFORM,
+	/**
+	 * Ignore this node, and traverse its children
+	 */
+	PASSTHROUGH;
+}
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 5ee4200..03a1f93 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/Tree.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/Tree.java
@@ -262,4 +262,35 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 			});
 		}
 	}
+
+	@Override
+	public ITree<ContainedType> topDownTransform(
+			Function<ContainedType, TopDownTransformResult> transformPicker,
+			UnaryOperator<ITree<ContainedType>> transformer) {
+		TopDownTransformResult transformResult =
+				transformPicker.apply(data);
+
+		switch (transformResult) {
+			case PASSTHROUGH:
+				ITree<ContainedType> 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);
+			default:
+				throw new IllegalArgumentException(
+						"Recieved unknown transform result "
+								+ transformResult);
+
+		}
+	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
index 95873e9..828f4c3 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
@@ -128,12 +128,15 @@ public class ListUtils {
 		IHolder<IFunctionalList<String>> returnedList =
 				new Identity<>(input);
 
-		operators.forEach((operator) -> returnedList
-				.transform((oldReturn) -> oldReturn.flatMap((token) -> {
+		operators.forEach((operator) -> {
+			returnedList.transform((oldReturn) -> {
+				return oldReturn.flatMap((token) -> {
 					return operator.merge(new TokenSplitter(token));
-				})));
+				});
+			});
+		});
 
-		return returnedList.unwrap((list) -> list);
+		return returnedList.getValue();
 	}
 
 	/**
diff --git a/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java b/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java
index 7b240b8..8386474 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java
@@ -5,8 +5,6 @@ import java.io.OutputStream;
 import java.io.PrintStream;
 import java.util.InputMismatchException;
 import java.util.Scanner;
-import java.util.stream.IntStream;
-
 import bjc.utils.data.IHolder;
 import bjc.utils.data.Identity;
 import bjc.utils.funcdata.FunctionalList;
@@ -109,8 +107,7 @@ public class AdjacencyMap<T> {
 				throw imex;
 			}
 
-			adjacencyMap.setWeight(row.getValue(), column,
-					columnWeight);
+			adjacencyMap.setWeight(row.getValue(), column, columnWeight);
 
 			column++;
 		}