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;
    }

    }

    private static List<String> visitAll(
            Collection<Vertex> children, Map<Vertex, DfsState> stateMap, List<String> list) {
        for (Vertex v : children) {
            DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
            if (state == null) {
                visitAll(v.children, stateMap, list);
                stateMap.put(v, DfsState.VISITED);
                list.add(v.label);

     *
     * @param name the name for the new node
     * @param children the list of child nodes
     * @return a new XmlNode instance
     * @throws NullPointerException if name is null
     */
    static XmlNode newInstance(String name, List<XmlNode> children) {
        return newBuilder().name(name).children(children).build();
    }

    /**

      val children = node.children!!
      var child = children[childIndex]
      if (child == null) {
        child = Node()
        children[childIndex] = child
      }
      node = child
    }

    val shift = 8 - accumulatorBitCount
    val start = (code shl shift) and 0xff
    val end = 1 shl shift
    node.children!!.fill(terminal, start, start + end)
  }

    }

    private static List<String> visitAll(
            Collection<Vertex> children, Map<Vertex, DfsState> stateMap, List<String> list) {
        for (Vertex v : children) {
            DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
            if (state == null) {
                visitAll(v.children, stateMap, list);
                stateMap.put(v, DfsState.VISITED);
                list.add(v.label);

        this.reference = (reference != null) ? reference : "";
        this.children = (children != null) ? Collections.unmodifiableList(children) : Collections.emptyList();
    }

    public Throwable getException() {
        return exception;
    }

    public String getMessage() {
        return message;
    }

    public String getReference() {
        return reference;
    }

    final List<Tree> children;

    Tree(char value, Tree... children) {
      super(value);
      this.children = asList(children);
    }
  }

  private static final TreeTraverser<Tree> ADAPTER =
      new TreeTraverser<Tree>() {
        @Override
        public Iterable<Tree> children(Tree node) {
          return node.children;
        }
      };

        if (node.value() != null) {
            return node.value();
        } else {
            List<Object> children = new ArrayList<>();
            for (XmlNode child : node.children()) {
                children.add(getValue(child));
            }
            return children;
        }
    }

    @Override
    public Object getBaseValue() {
        return node;
    }

    @Override

                if (child != null) {
                    children.add(child);
                }
            }

            message = "The build could not read " + children.size() + " project" + (children.size() == 1 ? "" : "s");
        } else {
            message = getMessage(message, exception);
        }

        return new ExceptionSummary(exception, message, reference, children);
    }

func (e *dataUsageEntry) addChild(hash dataUsageHash) {
	if _, ok := e.Children[hash.Key()]; ok {
		return
	}
	if e.Children == nil {
		e.Children = make(dataUsageHashMap, 1)
	}
	e.Children[hash.Key()] = struct{}{}
}

// Create a clone of the entry.
func (e dataUsageEntry) clone() dataUsageEntry {
	// We operate on a copy from the receiver.
	if e.Children != nil {
		ch := make(dataUsageHashMap, len(e.Children))