assertArgumentNotNull("classLoader", classLoader);
        this.classLoader = classLoader;
    }

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

    @Override
    public ClassLoader next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        final ClassLoader result = classLoader;
        classLoader = classLoader.getParent();

    return new UnmodifiableIterator<V>() {
      final UnmodifiableIterator<Entry<K, V>> entryItr = map.entrySet().iterator();

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

      @Override
      public V next() {
        return entryItr.next().getValue();
      }
    };
  }

  @Override
  public Spliterator<V> spliterator() {

CommandLineArgumentE(String); } org/gradle/cli/CommandLineOption.class package org.gradle.cli; public final class CommandLineOption { public final java.util.HashSet options; public Class argumentType; public String description; public final java.util.HashSet groupWith; public void CommandLineOption(java.util.List); public final java.util.HashSet getOptions(); } org/gradle/cli/CommandLineParser$AfterOptions.class package org.gradle.cli; public final class CommandLineParser$AfterOptions extends Comm...

  /** Constructor for use by subclasses. */
  protected ForwardingIterator() {}

  @Override
  protected abstract Iterator<T> delegate();

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

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public T next() {
    return delegate().next();
  }

  @Override
  public void remove() {

      Runnable task, @ParametricNullness T result);

  /**
   * {@inheritDoc}
   *
   * <p>All elements in the returned list must be {@link ListenableFuture} instances. The easiest
   * way to obtain a {@code List<ListenableFuture<T>>} from this method is an unchecked (but safe)
   * cast:
   *
   * <pre>
   *   {@code @SuppressWarnings("unchecked") // guaranteed by invokeAll contract}

package org.codelibs.fess.ds;

import java.io.File;
import java.io.InputStream;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import javax.xml.parsers.DocumentBuilder;

    for (i in 0 until frameCount) {
      if (nextOutFrame == null && outFramesIterator.hasNext()) {
        nextOutFrame = outFramesIterator.next()
      }

      if (nextOutFrame != null && nextOutFrame.sequence == i) {
        val start = nextOutFrame.start
        var truncated: Boolean
        var end: Long
        if (outFramesIterator.hasNext()) {
          nextOutFrame = outFramesIterator.next()

    int i = 0;
    while (expectedIterator.hasNext()) {
      Object expected = expectedIterator.next();

      assertTrue(
          "index " + i + " expected <" + expected + "., actual is exhausted",
          actualIterator.hasNext());

      Object actual = actualIterator.next();
      assertEquals("index " + i, expected, actual);
      i++;
    }
    if (actualIterator.hasNext()) {

         * 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();

        assertTrue(iterator.hasNext());
        assertEquals(doc1, iterator.next());
        assertTrue(iterator.hasNext());
        assertEquals(doc2, iterator.next());
        assertFalse(iterator.hasNext());

        // Test listIterator
        ListIterator<Map<String, Object>> listIterator = qrList.listIterator();
        assertTrue(listIterator.hasNext());
        assertEquals(doc1, listIterator.next());