From b0516949d7577b809c75d7267df77bff2cdb078b Mon Sep 17 00:00:00 2001
From: bculkin2442 <bjculkin@mix.wvu.edu>
Date: Mon, 3 Oct 2016 09:11:55 -0400
Subject: Minor reorganization

---
 BJC-Utils2/src/main/java/bjc/utils/data/ITree.java | 189 +++++++++++++++++++++
 1 file changed, 189 insertions(+)
 create mode 100644 BJC-Utils2/src/main/java/bjc/utils/data/ITree.java

(limited to 'BJC-Utils2/src/main/java/bjc/utils/data/ITree.java')

diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/ITree.java b/BJC-Utils2/src/main/java/bjc/utils/data/ITree.java
new file mode 100644
index 0000000..7d5988f
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/ITree.java
@@ -0,0 +1,189 @@
+package bjc.utils.data;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+
+import bjc.utils.funcdata.IList;
+import bjc.utils.funcdata.bst.TreeLinearizationMethod;
+
+/**
+ * A node in a homogenous tree with a unlimited amount of children
+ * 
+ * @author ben
+ * @param <ContainedType>
+ *            The type of data contained in the tree nodes
+ *
+ */
+public interface ITree<ContainedType> {
+	/**
+	 * Add a child to this node
+	 * 
+	 * @param child
+	 *            The child to add to this node
+	 */
+	public void addChild(ITree<ContainedType> child);
+
+	/**
+	 * Collapse a tree into a single version
+	 * 
+	 * @param <NewType>
+	 *            The intermediate type being folded
+	 * @param <ReturnedType>
+	 *            The type that is the end result
+	 * @param leafTransform
+	 *            The function to use to convert leaf values
+	 * @param nodeCollapser
+	 *            The function to use to convert internal nodes and their
+	 *            children
+	 * @param resultTransformer
+	 *            The function to use to convert a state to the returned
+	 *            version
+	 * @return The final transformed state
+	 */
+	public <NewType, ReturnedType> ReturnedType collapse(
+			Function<ContainedType, NewType> leafTransform,
+			Function<ContainedType,
+					Function<IList<NewType>, NewType>> nodeCollapser,
+			Function<NewType, ReturnedType> resultTransformer);
+
+	/**
+	 * Execute a given action for each of this tree's children
+	 * 
+	 * @param action
+	 *            The action to execute for each child
+	 */
+	void doForChildren(Consumer<ITree<ContainedType>> action);
+
+	/**
+	 * Expand the nodes of a tree into trees, and then merge the contents
+	 * of those trees into a single tree
+	 * 
+	 * @param mapper
+	 *            The function to use to map values into trees
+	 * @return A tree, with some nodes expanded into trees
+	 */
+	public ITree<ContainedType> flatMapTree(
+			Function<ContainedType, ITree<ContainedType>> mapper);
+
+	/**
+	 * Get the specified child of this tree
+	 * 
+	 * @param childNo
+	 *            The number of the child to get
+	 * @return The specified child of this tree
+	 */
+	default ITree<ContainedType> getChild(int childNo) {
+		return transformChild(childNo, (child) -> child);
+	}
+
+	/**
+	 * Get a count of the number of direct children this node has
+	 * 
+	 * @return The number of direct children this node has
+	 */
+	public int getChildrenCount();
+
+	/**
+	 * Get the data stored in this node
+	 * 
+	 * @return The data stored in this node
+	 */
+	default ContainedType getHead() {
+		return transformHead((head) -> head);
+	}
+
+	/**
+	 * Rebuild the tree with the same structure, but different nodes
+	 * 
+	 * @param <MappedType>
+	 *            The type of the new tree
+	 * @param leafTransformer
+	 *            The function to use to transform leaf tokens
+	 * @param operatorTransformer
+	 *            The function to use to transform internal tokens
+	 * @return The tree, with the nodes changed
+	 */
+	public <MappedType> ITree<MappedType> rebuildTree(
+			Function<ContainedType, MappedType> leafTransformer,
+			Function<ContainedType, MappedType> operatorTransformer);
+
+	/**
+	 * Transform some of the nodes in this tree
+	 * 
+	 * @param nodePicker
+	 *            The predicate to use to pick nodes to transform
+	 * @param transformer
+	 *            The function to use to transform picked nodes
+	 */
+	public void selectiveTransform(Predicate<ContainedType> nodePicker,
+			UnaryOperator<ContainedType> transformer);
+
+	/**
+	 * 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);
+
+	/**
+	 * Transform one of this nodes children
+	 * 
+	 * @param <TransformedType>
+	 *            The type of the transformed value
+	 * @param childNo
+	 *            The number of the child to transform
+	 * @param transformer
+	 *            The function to use to transform the value
+	 * @return The transformed value
+	 * 
+	 * @throws IllegalArgumentException
+	 *             if the childNo is out of bounds (0 <= childNo <=
+	 *             childCount())
+	 */
+	public <TransformedType> TransformedType transformChild(int childNo,
+			Function<ITree<ContainedType>, TransformedType> transformer);
+
+	/**
+	 * Transform the value that is the head of this node
+	 * 
+	 * @param <TransformedType>
+	 *            The type of the transformed value
+	 * @param transformer
+	 *            The function to use to transform the value
+	 * @return The transformed value
+	 */
+	public <TransformedType> TransformedType transformHead(
+			Function<ContainedType, TransformedType> transformer);
+
+	/**
+	 * Transform the tree into a tree with a different type of token
+	 * 
+	 * @param <MappedType>
+	 *            The type of the new tree
+	 * @param transformer
+	 *            The function to use to transform tokens
+	 * @return A tree with the token types transformed
+	 */
+	public <MappedType> ITree<MappedType> transformTree(
+			Function<ContainedType, MappedType> transformer);
+
+	/**
+	 * Perform an action on each part of the tree
+	 * 
+	 * @param linearizationMethod
+	 *            The way to traverse the tree
+	 * @param action
+	 *            The action to perform on each tree node
+	 */
+	public void traverse(TreeLinearizationMethod linearizationMethod,
+			Consumer<ContainedType> action);
+}
-- 
cgit v1.2.3