interface GraphConnections<N, V> {

  Set<N> adjacentNodes();

  Set<N> predecessors();

  Set<N> successors();

  /**
   * Returns an iterator over the incident edges.
   *
   * @param thisNode The node that this all of the connections in this class are connected to.
   */
  Iterator<EndpointPair<N>> incidentEdgeIterator(N thisNode);

  /**

    offerAll(elements.iterator());
  }

  /**
   * Adds each member of {@code elements} as a candidate for the top {@code k} elements. This
   * operation takes amortized linear time in the length of {@code elements}. The iterator is
   * consumed after this operation completes.
   *
   * <p>If all input data to this {@code TopKSelector} is in a single {@code Iterator}, prefer

  }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(SUPPORTS_ITERATOR_REMOVE)
  public void testKeySetIteratorRemove() {
    int key0Count = multimap().get(k0()).size();
    Iterator<K> keyItr = multimap().keySet().iterator();
    while (keyItr.hasNext()) {
      if (keyItr.next().equals(k0())) {
        keyItr.remove();
      }
    }
    assertEquals(getNumElements() - key0Count, multimap().size());

    IncidentEdgeSet<N> incident =
        new IncidentEdgeSet<N>(this, node, IncidentEdgeSet.EdgeType.BOTH) {
          @Override
          public Iterator<EndpointPair<N>> iterator() {
            return connections.incidentEdgeIterator(node);
          }
        };
    return nodeInvalidatableSet(incident, node);
  }

  @Override

        }
    }

    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#hasNext()
     */
    @Override
    public boolean hasNext() {
        return this.next != null;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#next()
     */
    @Override
    public FileEntry next() {
        final FileEntry n = this.next;

        if ((coreExtensions.getExtensions() != null)
                && (coreExtensions.getExtensions().size() > 0)) {
            for (Iterator iter = coreExtensions.getExtensions().iterator(); iter.hasNext(); ) {
                CoreExtension o = (CoreExtension) iter.next();
                writeCoreExtension(o, "extension", serializer);
            }
        }

     */
    public boolean isChildOfRootNode() {
        return parent != null && parent.parent == null;
    }

    public Iterator<ResolutionNode> getChildrenIterator() {
        return children.iterator();
    }

    public int getDepth() {
        return depth;
    }

    public List<ArtifactRepository> getRemoteRepositories() {
        return remoteRepositories;

        () -> {
          Iterator<String> iterator = values.iterator();
          iterator.next();
          iterator.remove();
        });

    Set<Entry<Integer, String>> entries = unmod.entrySet();
    assertThrows(
        UnsupportedOperationException.class,
        () -> {
          Iterator<Entry<Integer, String>> iterator = entries.iterator();
          iterator.next();

  final transient Collection<E> delegate;

  ForwardingImmutableCollection(Collection<E> delegate) {
    this.delegate = delegate;
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return Iterators.unmodifiableIterator(delegate.iterator());
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return object != null && delegate.contains(object);
  }

  @Override

  }

  @Override
  Iterator<Entry<E>> entryIterator() {
    // AbstractIterator makes this fairly clean, but it doesn't support remove(). To support
    // remove(), we create an AbstractIterator, and then use ForwardingIterator to delegate to it.
    Iterator<Entry<E>> readOnlyIterator =
        new AbstractIterator<Entry<E>>() {
          private final Iterator<Map.Entry<E, AtomicInteger>> mapEntries =