* throwing an IllegalStateException.
         */
        return new Iterator<T>() {
          boolean atStart = true;

          @Override
          public boolean hasNext() {
            return iterator.hasNext();
          }

          @Override
          @ParametricNullness
          public T next() {
            T result = iterator.next();

                    public void remove() {
                      iterator.remove();
                    }

                    @Override
                    public boolean hasNext() {
                      return iterator.hasNext();
                    }

                    @Override
                    public Entry<String, String> next() {
                      return transform(iterator.next());

        tempFile.deleteOnExit();
        markForDeletion(tempFile);

        return tempFile;
    }

    public void cleanUp() throws IOException {
        for (Iterator it = filesToDelete.iterator(); it.hasNext(); ) {
            File file = (File) it.next();

            if (file.exists()) {
                if (file.isDirectory()) {
                    FileUtils.deleteDirectory(file);
                } else {

                return false;
            }
            return ff.accept((SmbFile) resource);
        })) {

            final List<String> list = new ArrayList<>();
            while (it.hasNext()) {
                try (SmbResource n = it.next()) {
                    list.add(n.getName());
                }
            }
            return list.toArray(new String[list.size()]);

                    public void remove() {
                      iterator.remove();
                    }

                    @Override
                    public boolean hasNext() {
                      return iterator.hasNext();
                    }

                    @Override
                    public Entry<String, String> next() {
                      return transform(iterator.next());

   * result of a <i>future</i> call to {@code next()}.
   */
  protected abstract @Nullable T computeNext(T previous);

  @Override
  public final boolean hasNext() {
    return nextOrNull != null;
  }

  @Override
  public final T next() {
    if (nextOrNull == null) {
      throw new NoSuchElementException();
    }
    T oldNext = nextOrNull;

        assertFalse(set.isEmpty(), "No Artifacts");
        Iterator iter = set.iterator();
        assertTrue(set.size() == 4, "Set size should be 4, is " + set.size());

        while (iter.hasNext()) {
            Artifact artifact = (Artifact) iter.next();
            System.out.println("Artifact: " + artifact.getDependencyConflictId() + " " + artifact.getVersion()

                    Iterator<Item> right = ((ListItem) item).iterator();

                    while (left.hasNext() || right.hasNext()) {
                        Item l = left.hasNext() ? left.next() : null;
                        Item r = right.hasNext() ? right.next() : null;

                        // if this is shorter, then invert the compare and mul with -1

    private int nextIndex;

    /**
     * nextItem holds on to item fields because once we claim that an element exists in hasNext(),
     * we must return it in the following next() call even if it was in the process of being removed
     * when hasNext() was called.
     */
    private @Nullable E nextItem;

    /**

   *
   * @param failedConnection an optional connection that was resulted in a failure. If the failure
   *     is recoverable, the connection's route may be recovered for the retry.
   */
  fun hasNext(failedConnection: RealConnection? = null): Boolean

  /**
   * Returns true if the host and port are unchanged from when this was created. This is used to