/** Constructor for use by subclasses. */
  public AbstractValueGraph() {}

  @Override
  public Graph<N> asGraph() {
    return new AbstractGraph<N>() {
      @Override
      public Set<N> nodes() {
        return AbstractValueGraph.this.nodes();
      }

      @Override
      public Set<EndpointPair<N>> edges() {
        return AbstractValueGraph.this.edges();
      }

      @Override
      public boolean isDirected() {

Là, vous pouvez définir :

* « Item ID », utilisé dans le chemin.
* « Token » utilisé comme paramètre de requête.

/// tip | Astuce

Notez que le `token` de requête sera géré par une dépendance.

///

Avec cela, vous pouvez connecter le WebSocket puis envoyer et recevoir des messages :

<img src="/img/tutorial/websockets/image05.png">

parts of the API the tests depend upon.

For example:
---------------------------------------------------------------------------
restResources {
  restApi {
    includeCore '_common', 'indices', 'index', 'cluster', 'nodes', 'get', 'ingest'
  }
}
---------------------------------------------------------------------------

YAML REST tests that include x-pack specific APIs need to explicitly declare

    }
  }

  /**
   * Returns an unmodifiable iterable over the nodes in a tree structure, using breadth-first
   * traversal. That is, all the nodes of depth 0 are returned, then depth 1, then 2, and so on.
   *
   * <p>No guarantees are made about the behavior of the traversal when nodes change while iteration
   * is in progress or when the iterators generated by {@link #children} are advanced.
   *

      assertThat(network.nodes()).isEmpty();
      assertThat(network.edges()).isEmpty();
      AbstractNetworkTest.validateNetwork(network);

      while (network.nodes().size() < NUM_NODES) {
        network.addNode(gen.nextInt(NODE_POOL_SIZE));
      }
      ArrayList<Integer> nodeList = new ArrayList<>(network.nodes());
      for (int i = 0; i < NUM_EDGES; ++i) {

      assertThat(graph.nodes()).isEmpty();
      assertThat(graph.edges()).isEmpty();
      AbstractGraphTest.validateGraph(graph);

      while (graph.nodes().size() < NUM_NODES) {
        graph.addNode(gen.nextInt(NODE_POOL_SIZE));
      }
      ArrayList<Integer> nodeList = new ArrayList<>(graph.nodes());
      while (graph.edges().size() < NUM_EDGES) {

      return true;
    }
    if (!(obj instanceof Graph)) {
      return false;
    }
    Graph<?> other = (Graph<?>) obj;

    return isDirected() == other.isDirected()
        && nodes().equals(other.nodes())
        && edges().equals(other.edges());
  }

  @Override
  public final int hashCode() {
    return edges().hashCode();
  }

  /** Returns a string representation of this graph. */

		switch msgp.UnsafeString(field) {
		case "Nodes":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Nodes")
				return
			}
			if cap(z.Nodes) >= int(zb0002) {
				z.Nodes = (z.Nodes)[:zb0002]
			} else {
				z.Nodes = make([]ReplQNodeStats, zb0002)
			}
			for za0001 := range z.Nodes {
				err = z.Nodes[za0001].DecodeMsg(dc)
				if err != nil {

        } else  {
            current.appendChild(document.importNode(node, true))
        }
    }

    def appendChildren(Iterable<? extends Node> nodes) {
        nodes.each { appendChild(it) }
    }

    def appendChildren(NodeList nodes) {
        nodes.each { appendChild(it) }
    }

    def text(String text) {
        current.appendChild(document.createTextNode(text))
    }

        node.nextSibling.previousSibling = node.previousSibling;
      }
    }
    size--;
  }

  /** Removes all nodes for the specified key. */
  private void removeAllNodes(@ParametricNullness K key) {
    Iterators.clear(new ValueForKeyIterator(key));
  }

  /** An {@code Iterator} over all nodes. */
  private final class NodeIterator implements ListIterator<Entry<K, V>> {
    int nextIndex;
    @Nullable Node<K, V> next;