diff options
Diffstat (limited to 'BJC-Utils2/src/main/java/bjc/utils/data/ITree.java')
| -rw-r--r-- | BJC-Utils2/src/main/java/bjc/utils/data/ITree.java | 189 |
1 files changed, 189 insertions, 0 deletions
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); +} |