/** * Creates and returns an iterator that traverses the subtree rooted at this node in depth-first order. The first * node returned by {@link Iterator#next()} is the leftmost leaf. * <P> * * Modifying the tree by inserting, removing, or moving a node invalidates any iterators created before the * modification. * * @see #breadthFirstIterator(DependencyNode) * @see #preorderIterator(DependencyNode) * @return an iterator for traversing the tree in depth-first order */ public static Iterator<DependencyNode> depthFirstIterator(DependencyNode dependencyNode) { return new PostorderIterator(dependencyNode); }
/** * Creates and returns an iterator that traverses the subtree rooted at this node in breadth-first order. The first * node returned by {@link Iterator#next()} is this node. * <P> * * Modifying the tree by inserting, removing, or moving a node invalidates any iterators created before the * modification. * * @see #depthFirstIterator(DependencyNode) * @see #preorderIterator(DependencyNode) * @return an enumeration for traversing the tree in breadth-first order */ public static Iterator<DependencyNode> breadthFirstIterator(DependencyNode dependencyNode) { return new BreadthFirstIterator(dependencyNode); }
/** * Creates and returns an iterator that traverses the subtree rooted at this node in preorder. The first node * returned by {@link Iterator#next()} is this node. * <P> * * Modifying the tree by inserting, removing, or moving a node invalidates any iterators created before the * modification. * * @see #depthFirstIterator(DependencyNode) * @see #breadthFirstIterator(DependencyNode) * * @return an enumeration for traversing the tree in breadth-first order */ public static Iterator<DependencyNode> preorderIterator(DependencyNode dependencyNode) { return new PreorderFirstIterator(dependencyNode); }
@Override public String toString() { return DependencyNodeUtil.prettyPrint(this).toString(); }
/** * Returns the {@link DependencyNode} objects that satisfy the filter. The nodes are traversed using a pre order * iterator * * @param root a {@link DependencyNode} as the starting point * @param filter the {@link DependencyNodeFilter} being used * @return the {@link Collection} with the output * * @see #preorderIterator(DependencyNode) * */ public static List<DependencyNode> select(DependencyNode node, Predicate<DependencyNode> filter) { List<DependencyNode> result = new ArrayList<DependencyNode>(); selectInternal(node, filter, result); return result; }
public static String prettyPrint(DependencyNode root, Predicate<DependencyNode> filter) { StringBuilder sb = new StringBuilder(); prettyPrint(root, filter, sb, 0); return sb.toString(); }
@Override public DependencyNode next() { DependencyNode retval; if (subtree.hasNext()) { retval = subtree.next(); } else if (children.hasNext()) { subtree = new PostorderIterator(children.next()); retval = subtree.next(); } else { retval = root; root = null; } return retval; }
private static void selectInternal(DependencyNode root, Predicate<DependencyNode> filter, List<DependencyNode> collector) { if (filter.accept(root)) { collector.add(root); for (DependencyNode child : root.getChildren()) { selectInternal(child, filter, collector); } } }
/** * Prints a tree-like structure for this object * * @param root * @return */ public static CharSequence prettyPrint(DependencyNode root) { StringBuilder sb = new StringBuilder(); prettyPrint(root, new Predicate<DependencyNode>() { @Override public boolean accept(DependencyNode node) { return true; } }, sb, 0); return sb; }
private static void prettyPrint(DependencyNode node, Predicate<DependencyNode> filter, StringBuilder builder, int depth) { if (filter.accept(node)) { for (int i = 0; i < depth; i++) { builder.append(" "); } if (depth > 0) { builder.append("|-"); } builder.append(node.getDependency()) .append(" (") .append(node.getDependency().getScopeType()) .append(")\n"); for (DependencyNode child : node.getChildren()) { prettyPrint(child, filter, builder, depth + 1); } } }