}

  @Override
  @CheckForNull
  public V value(N node) {
    return adjacentNodeValues.get(node);
  }

  @Override
  public void removePredecessor(N node) {
    @SuppressWarnings("unused")
    V unused = removeSuccessor(node);
  }

  @Override
  @CheckForNull
  public V removeSuccessor(N node) {
    return adjacentNodeValues.remove(node);
  }

  @Override

    }

    public static def leftShift(Node parent, Closure cl) {
        DomBuilder builder = new DomBuilder(parent)
        cl.delegate = builder
        cl.call()
        return builder.elements[0]
    }

    public static void leftShift(Node parent, Node node) {
        parent.appendChild(parent.ownerDocument.importNode(node, true))
    }

    public static void addFirst(Node parent, Closure cl) {

  public N removeOutEdge(E edge) {
    N node = super.removeOutEdge(edge);
    Multiset<N> adjacentNodes = getReference(adjacentNodesReference);
    if (adjacentNodes != null) {
      checkState(adjacentNodes.remove(node));
    }
    return node;
  }

  @Override
  public void addInEdge(E edge, N node, boolean isSelfLoop) {
    if (!isSelfLoop) {
      addOutEdge(edge, node);
    }
  }

  @Override

  }

  @Override
  @CheckForNull
  public V value(N node) {
    return adjacentNodeValues.get(node);
  }

  @Override
  public void removePredecessor(N node) {
    @SuppressWarnings("unused")
    V unused = removeSuccessor(node);
  }

  @Override
  @CheckForNull
  public V removeSuccessor(N node) {
    return adjacentNodeValues.remove(node);
  }

  @Override

 *
 * @author James Sexton
 * @param <N> Node parameter type
 * @param <E> Edge parameter type
 */
@ElementTypesAreNonnullByDefault
abstract class AbstractDirectedNetworkConnections<N, E> implements NetworkConnections<N, E> {
  /** Keys are edges incoming to the origin node, values are the source node. */
  final Map<E, N> inEdgeMap;

  /** Keys are edges outgoing from the origin node, values are the target node. */

## Privileges required

	memTotalMD     = NewGaugeMD(memTotal, "Total memory on the node")
	memUsedMD      = NewGaugeMD(memUsed, "Used memory on the node")
	memUsedPercMD  = NewGaugeMD(memUsedPerc, "Used memory percentage on the node")
	memFreeMD      = NewGaugeMD(memFree, "Free memory on the node")
	memBuffersMD   = NewGaugeMD(memBuffers, "Buffers memory on the node")
	memCacheMD     = NewGaugeMD(memCache, "Cache memory on the node")

import org.w3c.dom.Node;

public class PrunedTag {
    private final String tag;
    private String id;
    private String css;
    private String attrName;
    private String attrValue;

    public PrunedTag(final String tag) {
        this.tag = tag;
    }

    public boolean matches(final Node node) {
        if (tag.equalsIgnoreCase(node.getNodeName())) {
            if (attrName != null) {

	configDumpFile string

	node string
}

func (c *commonFlags) attach(cmd *cobra.Command) {
	cmd.PersistentFlags().IntVar(&c.proxyAdminPort, "proxy-admin-port", defaultProxyAdminPort, "Ztunnel proxy admin port")
	cmd.PersistentFlags().StringVarP(&c.outputFormat, "output", "o", summaryOutput, "Output format: one of json|yaml|short")
	cmd.PersistentFlags().StringVar(&c.node, "node", "", "Filter workloads by node field")

        @Override
        public Iterable<Tree> children(Tree node) {
          return node.children;
        }
      };

  private static final TreeTraverser<Tree> ADAPTER_USING_USING =
      TreeTraverser.using(
          new Function<Tree, Iterable<Tree>>() {
            @Override
            public Iterable<Tree> apply(Tree node) {
              return node.children;
            }
          });

  //        h