Package org.tensorics.core.tree.walking

Class Trees

  • public final class Trees
extends java.lang.Object
    Provides utility methods to walk through a tree of Nodes.

    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      static java.util.Collection<Node> findBottomNodes​(Node startingNode)
      Searches for all bottom nodes of the tree.
      static <T extends Node>
      java.util.Set<T>      		 findClosestAncestorNodeFromNodesToRootOfType​(Node childNode, Node rootNode, com.google.common.reflect.TypeToken<T> nodeToken)
      Searches ancestor nodes which match the given TypeToken (taking into account all generic parameters!), starting from the given child not while using the tree as defined by the given rootNode.
      static <T extends Node>
      java.util.Set<? extends T>      		 findHighestNodeOfClass​(Node rootNode, java.lang.Class<T> nodeClassToFind)
      walks through the tree, starting from the given rootNode and collects the highest node which implement the given class.
      static <T> java.util.Set<T> findNodesOfClass​(Node rootNode, java.lang.Class<T> nodeClassToFind)
      walks through the tree, starting from the given rootNode and collects all the nodes which implement the given class.
      static java.util.List<Path> getPathsFromChildToAncestor​(Node childNode, Node ancestorNode)
      Searches in the tree for paths between the two given nodes.
      static <T extends Node>
      T      		 rebuildTree​(T rootNode, RebuildingContext rebuildingContext)
      Rebuilds the tree by taking elements from given context.
      static java.util.List<Node> subTreeContent​(Node rootNode)
      Retrieves the content of the given subtree.
      static void walkParentAfterChildren​(Node startingNode, NodeCallback callback)
      Traverses the tree, starting from the given node in a way, such that all children are visited before the parent node is visited.

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Method Detail

      • walkParentAfterChildren

        public static void walkParentAfterChildren​(Node startingNode,
                                           NodeCallback callback)
        Traverses the tree, starting from the given node in a way, such that all children are visited before the parent node is visited. It allows to provide a callback which will be called at different points of the traversal, depending on the implemented interfaces of the callback.
        Parameters:
        startingNode - the node which should be considered as the root node for the walk-through
        callback - the callback which will be called at certain points of the traversal, depending on the interfaces which are implemented by the callback.
        See Also:
        TreeWalker, NodeCallback

      • subTreeContent

        public static java.util.List<Node> subTreeContent​(Node rootNode)
        Retrieves the content of the given subtree. All children will be returned in the list, before the parent is returned.
        Parameters:
        rootNode - The node which shall be taken as root of the tree.
        Returns:
        a list containing all nodes of the tree, where all the children are put before their common parent node.

      • getPathsFromChildToAncestor

        public static java.util.List<Path> getPathsFromChildToAncestor​(Node childNode,
                                                               Node ancestorNode)
        Searches in the tree for paths between the two given nodes. The direction of the path will be from the childNode to the ancestor. The childNode will be the first element of each path and the given ancestor node the last element.
        Parameters:
        childNode - the node from which the paths to be found shall start
        ancestorNode - the ancestor node, which will be the end node of each path
        Returns:
        all the paths from childNode to ancestorNode

      • findBottomNodes

        public static java.util.Collection<Node> findBottomNodes​(Node startingNode)
        Searches for all bottom nodes of the tree. Bottom nodes are those, which are furthest away from the startingNode on a given branch. (In other words, those with no more children)
        Parameters:
        startingNode - the node which shall be used as root of the tree.
        Returns:
        a list of all the nodes which are at the bottom of the tree (i.e. which have no children).

      • rebuildTree

        public static <T extends Node> T rebuildTree​(T rootNode,
                                             RebuildingContext rebuildingContext)
        Rebuilds the tree by taking elements from given context.
        Parameters:
        rootNode - the root node of the tree
        rebuildingContext - the context containing the elements needed for rebuilding of the tree
        Returns:
        a new root node of rebuilt tree

      • findNodesOfClass

        public static <T> java.util.Set<T> findNodesOfClass​(Node rootNode,
                                                    java.lang.Class<T> nodeClassToFind)
        walks through the tree, starting from the given rootNode and collects all the nodes which implement the given class. The given class is not restricted to s subclass of a node, because it could potentially be a marker interface. However, the returned set will implement both, Node and the queried type.
        Parameters:
        rootNode - the node from which to start the search
        nodeClassToFind - the class of the nodes to find
        Returns:
        a set of all found nodes, which implement the given class

      • findHighestNodeOfClass

        public static <T extends Node> java.util.Set<? extends T> findHighestNodeOfClass​(Node rootNode,
                                                                                 java.lang.Class<T> nodeClassToFind)
        walks through the tree, starting from the given rootNode and collects the highest node which implement the given class.
        Parameters:
        rootNode - the node from which to start the search
        nodeClassToFind - the class of the nodes to find
        Returns:
        a set of one found Node, which implement the given class

      • findClosestAncestorNodeFromNodesToRootOfType

        public static <T extends Node> java.util.Set<T> findClosestAncestorNodeFromNodesToRootOfType​(Node childNode,
                                                                                             Node rootNode,
                                                                                             com.google.common.reflect.TypeToken<T> nodeToken)
                                                                                      throws NoMatchingNodeFoundException
        Searches ancestor nodes which match the given TypeToken (taking into account all generic parameters!), starting from the given child not while using the tree as defined by the given rootNode. This is eg. used for finding nodes, that can handle Exceptions. If the child node id not part of the tree then an empty set is returned. If there exist paths between the two nodes, then it is enforced, that in this paths a matching node is found. If this is not the case, an exception will be thrown. If the same node is found in different paths, then the corresponding node is only contained once in the set.
        Parameters:
        childNode - the node for which the closest ancestors shall be found.
        rootNode - the node which defines the root of the tree.
        nodeToken - the token, against which the nodes are matched.
        Returns:
        a set of Node containing for each path the closest Node that match the given TypeToken
        Throws:
        NoMatchingNodeFoundException - if there exists a path, that does not contain a matching node.