return getChildren(node);
        }
      }.preOrderTraversal(root);
    }

    @AfterTemplate
    Iterable<N> after(N root) {
      return Traverser.forTree((N node) -> getChildren(node)).depthFirstPreOrder(root);
    }
  }

  abstract class TreeTraverserPostOrder<N> {
    @Placeholder
    abstract Iterable<N> getChildren(N node);

    @BeforeTemplate

    public boolean hasHiddenNonBuildable() {
        return showDependentPredicate.hiddenNonBuildable;
    }

    private Set<? extends RenderableDependency> getChildren(RenderableDependency node) {
        return Sets.filter(node.getChildren(), showDependentPredicate);
    }

    private static class DependentBinaryNodeRenderer implements NodeRenderer {

        private boolean seenTestSuite;

        @Override

    }

    protected static List<Node> getChildren(@Nullable Node root, String name) {
        return root == null ? Collections.<Node>emptyList() : Cast.<List<Node>>uncheckedCast(root.get(name));
    }

    @Nullable
    public static Node findFirstChildNamed(@Nullable Node root, String name) {
        return root == null ? null : Iterables.getFirst(getChildren(root, name), null);
    }

    @Nullable

         */
        String getBuildFile();

        /**
         * @see LoadProjectsBuildOperationType.Result.Project#getChildren()
         */
        Set<? extends Project> getChildren();
    }

        XmlNode node1 = (XmlNode) pointer1.getBaseValue();
        XmlNode node2 = (XmlNode) pointer2.getBaseValue();
        if (node1 == node2) {
            return 0;
        }
        for (XmlNode child : node.getChildren()) {
            if (child == node1) {
                return -1;
            }
            if (child == node2) {
                return 1;
            }
        }
        return 0;
    }

        if (visitor.enter(this)) {
            for (Node child : getChildren()) {
                if (!child.accept(visitor)) {
                    break;
                }
            }
        }
        return visitor.leave(this);
    }

    @Override
    public Node filter(Predicate<Node> filter) {
        List<Node> children =

        this.requested = requested;
        this.actual = actual;
        this.resolvable = resolvable;
    }

    public void addChild(DependencyEdge child) {
        children.addAll(child.getChildren());
    }

    @Override
    protected ComponentIdentifier getActual() {
        return actual;
    }

    @Override
    public ComponentSelector getRequested() {
        return requested;
    }

            }
            if (result.isTestSuite()) {
                hasTestSuites = true;
            }
            allChildren.addAll(result.getChildren());
            for (DependentBinariesResolvedResult child : result.getChildren()) {
                index.put(child.getId(), child);
            }
        }
        List<DependentBinariesResolvedResult> children = new ArrayList<>();

        assertTrue(labels.contains("c"));
        assertTrue(labels.contains("d"));

        addEdge(graph, "a", "d");
        assertEquals(2, a.getChildren().size());
        assertTrue(a.getChildren().contains(b));
        assertTrue(a.getChildren().contains(d));
        assertEquals(2, d.getParents().size());
        assertTrue(d.getParents().contains(a));
        assertTrue(d.getParents().contains(c));
    }

     * @return The modules of this IDEA project.
     * @since 1.0-milestone-5
     */
    @Override
    DomainObjectSet<? extends IdeaModule> getChildren();

    /**
     * Returns the modules of this IDEA project. Most projects have at least one module.
     * Alias for {@link #getChildren()}.
     *
     * @return The modules of this IDEA project.
     * @since 1.0-milestone-5
     */