MetadataTreeNode parent; // papa

    /** default # of children. Used for tree creation optimization only */
    int nChildren = 8;

    MetadataTreeNode[] children; // of cause

    public int getNChildren() {
        return nChildren;
    }

    public void setNChildren(int children) {
        nChildren = children;
    }

    // ------------------------------------------------------------------------

    @Nullable
    Dependency getDependency();

    /**
     * Gets the child nodes of this node.
     *
     * @return the child nodes of this node, never {@code null}
     */
    @Nonnull
    List<Node> getChildren();

    /**
     * @return repositories of this node
     */
    @Nonnull
    List<RemoteRepository> getRemoteRepositories();

    /**
     * The repository where this artifact has been downloaded from.

 *
 * <p>If you have your own graph implementation based around a custom node type {@code MyNode},
 * which has a method {@code getChildren()} that retrieves its successors in a graph:
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, MyNode::getChildren);
 * }</pre>
 *
 * <p>If you have some other mechanism for returning the successors of a node, or one that doesn't

        assertEquals("m", node.getPrefix());
        assertEquals("configuration", node.getName());
        assertEquals(1, node.getChildren().size());
        XmlNode myConfig = node.getChildren().get(0);
        assertEquals("http://fabric8.io/fabric8-maven-plugin", myConfig.getNamespaceUri());
        assertEquals("", myConfig.getPrefix());

            throws PlexusConfigurationException {
        List<MojoDescriptor> mojos = new ArrayList<>();

        PlexusConfiguration[] mojoConfigurations = c.getChild("mojos").getChildren("mojo");

        for (PlexusConfiguration component : mojoConfigurations) {
            mojos.add(buildComponentDescriptor(component, pluginDescriptor));
        }
        return mojos;
    }

 *
 * <p>If you have your own graph implementation based around a custom node type {@code MyNode},
 * which has a method {@code getChildren()} that retrieves its successors in a graph:
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, MyNode::getChildren);
 * }</pre>
 *
 * <p>If you have some other mechanism for returning the successors of a node, or one that doesn't

        return exception;
    }

    public String getMessage() {
        return message;
    }

    public String getReference() {
        return reference;
    }

    public List<ExceptionSummary> getChildren() {
        return children;
    }

    /**
     * Gets the children of this result.
     *
     * @return the children of this result, can be empty but never {@code null}
     */
    @Nonnull
    List<? extends ModelBuilderResult> getChildren();

    /**
     * Creates a human-readable representation of these errors.
     */
    String toString();

            addEdge(parentVertex, vertex, e);
        } else {
            entry = vertex;
        }

        MetadataTreeNode[] kids = node.getChildren();
        if (kids == null || kids.length < 1) {
            return;
        }

        for (int i = 0; i < kids.length; i++) {
            MetadataTreeNode n = kids[i];

    @Nullable
    String getValue();

    @Nonnull
    Map<String, String> getAttributes();

    @Nullable
    String getAttribute(@Nonnull String name);

    @Nonnull
    List<XmlNode> getChildren();

    @Nullable
    XmlNode getChild(String name);

    @Nullable
    Object getInputLocation();

    default XmlNode merge(@Nullable XmlNode source) {