GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
    return (connectionsU != null) && connectionsU.successors().contains(nodeV);
  }

  private final @Nullable V edgeValueOrDefaultInternal(N nodeU, N nodeV, @Nullable V defaultValue) {
    GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
    V value = (connectionsU == null) ? null : connectionsU.value(nodeV);

    checkArgument(containsNode(nodeV), NODE_NOT_IN_GRAPH, nodeV);
    return nodePairInvalidatableSet(connectionsU.edgesConnecting(nodeV), nodeU, nodeV);
  }

  @Override
  public Set<E> inEdges(N node) {
    return nodeInvalidatableSet(checkedConnections(node).inEdges(), node);
  }

  @Override
  public Set<E> outEdges(N node) {
    return nodeInvalidatableSet(checkedConnections(node).outEdges(), node);
  }

  @Override

    for (E key : keys) {
      LockGraphNode node = new LockGraphNode(getLockName(key));
      nodes.add(node);
      map.put(key, node);
    }
    // Pre-populate all allowedPriorLocks with nodes of smaller ordinal.
    for (int i = 1; i < numKeys; i++) {
      nodes.get(i).checkAcquiredLocks(Policies.THROW, nodes.subList(0, i));
    }
    // Pre-populate all disallowedPriorLocks with nodes of larger ordinal.

                + "{\"_source\":{\"type\":\"heartbeat\",\"instanceId\":\"node1@host1\",\"hostname\":\"host1\",\"name\":\"node1\",\"createdTime\":1000}},"
                + "{\"_source\":{\"type\":\"heartbeat\",\"instanceId\":\"node2@host2\",\"hostname\":\"host2\",\"name\":\"node2\",\"createdTime\":2000}}"
                + "]}}";
        final CoordinatorHelper helper = createCapturingHelper("node1@host1", null, null, createMockResponse(200, searchResponse));

    minimizedReason: LowerStr | None = None


class Replies(BaseModel):
    totalCount: int
    nodes: list[CommentsNode]


class DiscussionsCommentsNode(CommentsNode):
    minimizedReason: LowerStr | None = None
    replies: Replies


class DiscussionsComments(BaseModel):
    totalCount: int
    nodes: list[DiscussionsCommentsNode]


class DiscussionsNode(BaseModel):
    number: int

 * user-defined properties.
 *
 * <p>A {@code Graph} built by this class has the following default properties:
 *
 * <ul>
 *   <li>does not allow self-loops
 *   <li>orders {@link Graph#nodes()} in the order in which the elements were added (insertion
 *       order)
 * </ul>
 *
 * <p>{@code Graph}s built by this class also guarantee that each collection-returning accessor

 *
 * <p>A {@code Network} built by this class has the following default properties:
 *
 * <ul>
 *   <li>does not allow parallel edges
 *   <li>does not allow self-loops
 *   <li>orders {@link Network#nodes()} and {@link Network#edges()} in the order in which the
 *       elements were added (insertion order)
 * </ul>
 *
 * <p>{@code Network}s built by this class also guarantee that each collection-returning accessor

 * with user-defined properties.
 *
 * <p>A {@code ValueGraph} built by this class has the following default properties:
 *
 * <ul>
 *   <li>does not allow self-loops
 *   <li>orders {@link ValueGraph#nodes()} in the order in which the elements were added (insertion
 *       order)
 * </ul>
 *
 * <p>{@code ValueGraph}s built by this class also guarantee that each collection-returning accessor

        public boolean visitEnter(DependencyNode node) {
            ArtifactType currentType = jar;
            if (node.getArtifact() != null) {
                if (node.getArtifact().getProperties().containsKey(ArtifactProperties.TYPE)) {
                    currentType = registry.get(node.getArtifact()
                            .getProperty(
                                    ArtifactProperties.TYPE, node.getArtifact().getExtension()));

     * be read without locking. Next fields of nodes are immutable (final). All list additions are
     * performed at the front of each bin. This makes it easy to check changes, and also fast to
     * traverse. When nodes would otherwise be changed, new nodes are created to replace them. This