@Override
public long next() {
  if (iterators.isEmpty()) throw FastNoSuchElementException.instance();

  TLongIterator currentIterator = iterators.get(this.current);
  while (true) {
    if (currentIterator.hasNext()) {
      return currentIterator.next();
    } else {
      this.current++;
      if (this.current >= iterators.size())
        break;
      currentIterator = iterators.get(current);
    }
  }
  throw FastNoSuchElementException.instance();
}
 

@Override
public T next() {
    if (this.iterators.isEmpty()) throw FastNoSuchElementException.instance();

    Iterator<T> currentIterator = iterators.get(this.current);
    while (true) {
        if (currentIterator.hasNext()) {
            return currentIterator.next();
        } else {
            this.current++;
            if (this.current >= iterators.size())
                break;
            currentIterator = iterators.get(current);
        }
    }
    throw FastNoSuchElementException.instance();
}
 

@Override
public Edge next() {
    try {
        while (true) {
            if (this.edgeIterator.hasNext())
                return new HadoopEdge(this.edgeIterator.next(), this.graph);
            if (this.readers.isEmpty())
                throw FastNoSuchElementException.instance();
            if (this.readers.peek().nextKeyValue()) {
                this.edgeIterator = this.readers.peek().getCurrentValue().get().edges(Direction.OUT);
            } else {
                this.readers.remove().close();
            }
        }
    } catch (final Exception e) {
        throw new IllegalStateException(e.getMessage(), e);
    }
}
 

@Override
public Vertex next() {
    try {
        if (this.nextVertex != null) {
            final Vertex temp = this.nextVertex;
            this.nextVertex = null;
            return temp;
        } else {
            while (!this.readers.isEmpty()) {
                if (this.readers.peek().nextKeyValue())
                    return new HadoopVertex(this.readers.peek().getCurrentValue().get(), this.graph);
                else
                    this.readers.remove().close();
            }
        }
        throw FastNoSuchElementException.instance();
    } catch (final Exception e) {
        throw new IllegalStateException(e.getMessage(), e);
    }
}
 

@Override
public String next() {
    try {
        if (this.available) {
            this.available = false;
            return this.line;
        } else {
            while (true) {
                if (this.readers.isEmpty())
                    throw FastNoSuchElementException.instance();
                if ((this.line = this.readers.peek().readLine()) != null) {
                    return this.line;
                } else
                    this.readers.remove().close();
            }
        }
    } catch (final IOException e) {
        throw new IllegalStateException(e.getMessage(), e);
    }
}
 

@Override
protected Traverser.Admin<E> processNextStart() {
    while (true) {
        if (this.iterator.hasNext()) {
            return this.isStart ? this.getTraversal().getTraverserGenerator().generate(this.iterator.next(), (Step) this, 1l) : this.head.split(this.iterator.next(), this);
        } else {
            if (this.isStart) {
                if (this.done)
                    throw FastNoSuchElementException.instance();
                else {
                    this.done = true;
                    this.iterator = null == this.iteratorSupplier ? EmptyIterator.instance() : this.iteratorSupplier.get();
                }
            } else {
                this.head = this.starts.next();
                this.iterator = null == this.iteratorSupplier ? EmptyIterator.instance() : this.iteratorSupplier.get();
            }
        }
    }
}
 

@Override
protected Traverser.Admin<S> processNextStart() {
    if (mode == Mode.UNSET) throw new IllegalStateException("IO mode was not set to read() or write()");
    if (!this.first) throw FastNoSuchElementException.instance();

    this.first = false;
    final File file = new File(this.file);

    if (mode == Mode.READING) {
        if (!file.exists()) throw new IllegalStateException(this.file + " does not exist");
        return read(file);
    } else if (mode == Mode.WRITING) {
        return write(file);
    } else {
        throw new IllegalStateException("Invalid ReadWriting.Mode configured in IoStep: " + mode.name());
    }
}
 

@Override
protected Traverser.Admin<E> processNextStart() throws NoSuchElementException {
    if (this.first) {
        this.first = false;
        this.localTraversal.addStart(this.starts.next());
    }
    while (true) {
        if (this.localTraversal.hasNext())
            return this.localTraversal.nextTraverser();
        else if (this.starts.hasNext()) {
            this.localTraversal.reset();
            this.localTraversal.addStart(this.starts.next());
        } else {
            throw FastNoSuchElementException.instance();
        }
    }
}
 

@Override
public T next() {
    if (this.iterators.isEmpty()) throw FastNoSuchElementException.instance();

    Iterator<T> currentIterator = iterators.get(this.current);
    while (true) {
        if (currentIterator.hasNext()) {
            return currentIterator.next();
        } else {
            this.current++;
            if (this.current >= iterators.size())
                break;
            currentIterator = iterators.get(current);
        }
    }
    throw FastNoSuchElementException.instance();
}
 

@Test
@LoadGraphWith(MODERN)
public void shouldThrowFastNoSuchElementExceptionInNestedTraversals() {
    //The nested traversal should throw a regular FastNoSuchElementException

    final GraphTraversal<Object, Object> nestedTraversal = __.has("name", "foo");
    final GraphTraversal<Vertex, Object> traversal = g.V().has("name", "marko").branch(nestedTraversal);

    final GraphTraversal.Admin<Object, Object> nestedTraversalAdmin = nestedTraversal.asAdmin();
    nestedTraversalAdmin.reset();
    nestedTraversalAdmin.addStart(nestedTraversalAdmin.getTraverserGenerator().generate(g.V().has("name", "marko").next(), (Step) traversal.asAdmin().getStartStep(), 1l));

    try {
        nestedTraversal.next();
    } catch (NoSuchElementException e) {
        assertEquals(FastNoSuchElementException.class, e.getClass());
    }
}
 

@Override
protected Traverser.Admin<E> processNextStart() throws NoSuchElementException {
    if (this.first) {
        this.first = false;
        while (this.starts.hasNext()) {
            this.localTraversal.addStart(this.starts.next());
        }
        while (this.localTraversal.hasNext()) {
            this.results.add(this.localTraversal.nextTraverser());
        }
        this.results.sort((o1, o2) -> {
            SqlgTraverser x = (SqlgTraverser) o1;
            SqlgTraverser y = (SqlgTraverser) o2;
            return Long.compare(x.getStartElementIndex(), y.getStartElementIndex());
        });
        this.resultIterator = this.results.iterator();
    }
    if (this.resultIterator.hasNext()) {
        return this.resultIterator.next();
    } else {
        throw FastNoSuchElementException.instance();
    }
}
 

private boolean applyRange(Emit<E> emit) {
    if (this.lastReplacedStep.hasRange() && this.lastReplacedStep.applyInStep() && this.lastReplacedStep.getDepth() == emit.getReplacedStepDepth()) {
        if (this.lastReplacedStep.getSqlgRangeHolder().hasRange()) {
            if (this.lastReplacedStep.getSqlgRangeHolder().getRange().isBefore(this.rangeCount + 1)) {
                throw FastNoSuchElementException.instance();
            }
            if (this.lastReplacedStep.getSqlgRangeHolder().getRange().isAfter(this.rangeCount)) {
                this.rangeCount++;
                return true;
            }
        } else {
            Preconditions.checkState(this.lastReplacedStep.getSqlgRangeHolder().hasSkip(), "If not a range query then it must be a skip.");
            if (this.rangeCount < this.lastReplacedStep.getSqlgRangeHolder().getSkip()) {
                this.rangeCount++;
                return true;
            }
        }
        this.rangeCount++;
    }
    return false;
}
 

@Override
protected Traverser.Admin<Vertex> processNextStart() {
    if (this.first) {
        this.first = false;
        final SqlgTraverserGenerator generator = SqlgTraverserGenerator.instance();
        final Vertex vertex = this.getTraversal().getGraph().get().addVertex(
                this.parameters.getKeyValues(
                        generator.generate(false, (Step)this, 1L, false, false)
                ));
        if (this.callbackRegistry != null && !this.callbackRegistry.getCallbacks().isEmpty()) {
            final EventStrategy eventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class).get();
            final Event.VertexAddedEvent vae = new Event.VertexAddedEvent(eventStrategy.detach(vertex));
            this.callbackRegistry.getCallbacks().forEach(c -> c.accept(vae));
        }
        return generator.generate(vertex, (Step)this, 1L, false, false);
    } else
        throw FastNoSuchElementException.instance();
}
 

@Override
protected Admin<Long> processNextStart() throws NoSuchElementException {
    if (this.done) {
        throw FastNoSuchElementException.instance();
    }
    this.done = true;
    @SuppressWarnings({ "unchecked", "rawtypes" })
    Step<Long, Long> step = (Step) this;
    return this.getTraversal().getTraverserGenerator()
               .generate(this.originGraphStep.count(), step, 1L);
}
 

@Override
protected Traverser.Admin<Long> processNextStart() throws NoSuchElementException {
    if (!this.done) {
        this.done = true;
        final TinkerGraph graph = (TinkerGraph) this.getTraversal().getGraph().get();
        return this.getTraversal().getTraverserGenerator().generate(Vertex.class.isAssignableFrom(this.elementClass) ?
                        (long) TinkerHelper.getVertices(graph).size() :
                        (long) TinkerHelper.getEdges(graph).size(),
                (Step) this, 1L);
    } else
        throw FastNoSuchElementException.instance();
}
 

private void initialize() {
    initialized = true;
    if (useMultiQuery) {
        setParentMultiQueryStep();

        if (!starts.hasNext()) {
            throw FastNoSuchElementException.instance();
        }
        final List<Admin<Vertex>> vertices = new ArrayList<>();
        starts.forEachRemaining(vertices::add);
        starts.add(vertices.iterator());
        initializeMultiQuery(vertices);
    }
}
 

private void initialize() {
    initialized = true;

    if (!starts.hasNext()) throw FastNoSuchElementException.instance();
    List<Traverser.Admin<Element>> elements = new ArrayList<>();
    starts.forEachRemaining(elements::add);
    starts.add(elements.iterator());

    useMultiQuery = useMultiQuery && elements.stream().allMatch(e -> e.get() instanceof Vertex);

    if (useMultiQuery) {
        initializeMultiQuery(elements);
    }
}
 

private void initialize() {
    initialized = true;

    if (!starts.hasNext()) {
        throw FastNoSuchElementException.instance();
    }
    List<Traverser.Admin<Edge>> edges = new ArrayList<>();
    Set<Vertex> vertices = Sets.newHashSet();
    starts.forEachRemaining(e -> {
        edges.add(e);

        if (vertices.size() < txVertexCacheSize) {
            if (Direction.IN.equals(direction) || Direction.BOTH.equals(direction)) {
                vertices.add(e.get().inVertex());
            }
            if (Direction.OUT.equals(direction) || Direction.BOTH.equals(direction)) {
                vertices.add(e.get().outVertex());
            }
        }
    });

    // If there are multiple vertices then fetch the properties for all of them in a single multiQuery to
    // populate the vertex cache so subsequent queries of properties don't have to go to the storage back end
    if (vertices.size() > 1) {
        JanusGraphMultiVertexQuery multiQuery = JanusGraphTraversalUtil.getTx(traversal).multiQuery();
        ((BasicVertexCentricQueryBuilder) multiQuery).profiler(queryProfiler);
        multiQuery.addAllVertices(vertices).preFetch();
    }

    starts.add(edges.iterator());
}
 

public static <S, E> Iterator<E> flatMap(final Iterator<S> iterator, final Function<S, Iterator<E>> function) {
    return new CloseableIterator<E>() {

        private Iterator<E> currentIterator = Collections.emptyIterator();

        @Override
        public boolean hasNext() {
            if (this.currentIterator.hasNext())
                return true;
            else {
                while (iterator.hasNext()) {
                    this.currentIterator = function.apply(iterator.next());
                    if (this.currentIterator.hasNext())
                        return true;
                }
            }
            return false;
        }

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

        @Override
        public E next() {
            if (this.hasNext())
                return this.currentIterator.next();
            else
                throw FastNoSuchElementException.instance();
        }

        @Override
        public void close() {
            CloseableIterator.closeIterator(iterator);
        }
    };
}
 

@Override
protected E map(final Traverser.Admin<S> traverser) {
    final Iterator<E> iterator = traverser.get().iterator();
    if (iterator.hasNext()) {
        Number result = iterator.next();
        while (iterator.hasNext()) {
            result = NumberHelper.add(result, iterator.next());
        }
        return (E) result;
    }
    throw FastNoSuchElementException.instance();
}
 

@Override
public TraverserSet<S> nextBarrier() throws NoSuchElementException {
    this.processAllStarts();
    if (this.barrier.isEmpty())
        throw FastNoSuchElementException.instance();
    else {
        final TraverserSet<S> temp = this.barrier;
        this.barrier = new TraverserSet<>();
        return temp;
    }
}
 

/**
 * Extracts specified range of elements from a Collection.
 */
private static Object applyRangeIterable(final Iterable<Object> iterable, final long low, final long high) {
    // See if we only want a single item.  It is also possible that we will allow more than one item, but that the
    // incoming container is only capable of producing a single item.  In that case, we will still emit a
    // container.  This allows the result type to be predictable based on the step arguments.  It also allows us to
    // avoid creating the result container for the single case.
    boolean single = high != -1 ? (high - low == 1) : false;

    final Collection resultCollection =
            single ? null : (iterable instanceof Set) ? new LinkedHashSet() : new LinkedList();
    Object result = single ? null : resultCollection;
    long c = 0L;
    for (final Object item : iterable) {
        if (c >= low) {
            if (c < high || high == -1) {
                if (single) {
                    result = item;
                    break;
                } else {
                    resultCollection.add(item);
                }
            } else break;
        }
        c++;
    }
    if (null == result)
        // We have nothing to emit, so stop traversal.
        throw FastNoSuchElementException.instance();
    return result;
}
 

@Override
protected Traverser.Admin<Edge> processNextStart() {
    if (this.first) {
        this.first = false;
        final TraverserGenerator generator = this.getTraversal().getTraverserGenerator();
        final Traverser.Admin traverser = generator.generate(1, (Step) this, 1); // a dead traverser to trigger the traversal
        Vertex toVertex = (Vertex) this.parameters.get(traverser, TO, Collections::emptyList).get(0);
        Vertex fromVertex = (Vertex) this.parameters.get(traverser, FROM, Collections::emptyList).get(0);
        if (toVertex instanceof Attachable)
            toVertex = ((Attachable<Vertex>) toVertex)
                    .attach(Attachable.Method.get(this.getTraversal().getGraph().orElse(EmptyGraph.instance())));
        if (fromVertex instanceof Attachable)
            fromVertex = ((Attachable<Vertex>) fromVertex)
                    .attach(Attachable.Method.get(this.getTraversal().getGraph().orElse(EmptyGraph.instance())));
        final String edgeLabel = (String) this.parameters.get(traverser, T.label, () -> Edge.DEFAULT_LABEL).get(0);
        final Edge edge = fromVertex.addEdge(edgeLabel, toVertex, this.parameters.getKeyValues(traverser, TO, FROM, T.label));
        if (callbackRegistry != null) {
            final EventStrategy eventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class).get();
            final Event.EdgeAddedEvent vae = new Event.EdgeAddedEvent(eventStrategy.detach(edge));
            callbackRegistry.getCallbacks().forEach(c -> c.accept(vae));
        }
        return generator.generate(edge, this, 1L);
    } else
        throw FastNoSuchElementException.instance();


}
 

@Override
protected Number map(final Traverser.Admin<S> traverser) {
    final Iterator<E> iterator = traverser.get().iterator();
    if (iterator.hasNext()) {
        Long counter = 1L;
        E result = iterator.next();
        while (iterator.hasNext()) {
            result = (E) NumberHelper.add(result, iterator.next());
            counter++;
        }
        return NumberHelper.div(result, counter, true);
    }
    throw FastNoSuchElementException.instance();
}
 

@Override
protected E map(final Traverser.Admin<S> traverser) {
    final Iterator<E> iterator = traverser.get().iterator();
    if (iterator.hasNext()) {
        Comparable result = iterator.next();
        while (iterator.hasNext()) {
            result = max(iterator.next(), result);
        }
        return (E) result;
    }
    throw FastNoSuchElementException.instance();
}
 

@Override
protected Traverser.Admin<Vertex> processNextStart() {
    if (this.first) {
        this.first = false;
        final TraverserGenerator generator = this.getTraversal().getTraverserGenerator();
        final Vertex vertex = this.getTraversal().getGraph().get().addVertex(this.parameters.getKeyValues(generator.generate(false, (Step) this, 1L)));
        if (this.callbackRegistry != null) {
            final EventStrategy eventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class).get();
            final Event.VertexAddedEvent vae = new Event.VertexAddedEvent(eventStrategy.detach(vertex));
            this.callbackRegistry.getCallbacks().forEach(c -> c.accept(vae));
        }
        return generator.generate(vertex, this, 1L);
    } else
        throw FastNoSuchElementException.instance();
}
 

@Override
protected E map(final Traverser.Admin<S> traverser) {
    final Iterator<E> iterator = traverser.get().iterator();
    if (iterator.hasNext()) {
        Comparable result = iterator.next();
        while (iterator.hasNext()) {
            result = min(iterator.next(), result);
        }
        return (E) result;
    }
    throw FastNoSuchElementException.instance();
}
 

@Override
public TraverserSet<S> nextBarrier() throws NoSuchElementException {
    if (this.barrier.isEmpty()) {
        this.processAllStarts();
    }
    if (this.barrier.isEmpty())
        throw FastNoSuchElementException.instance();
    else {
        final TraverserSet<S> temp = this.barrier;
        this.barrier = new TraverserSet<>();
        return temp;
    }
}
 

@Override
public TraverserSet<S> nextBarrier() throws NoSuchElementException {
    this.processAllStarts();
    if (this.traverserSet.isEmpty())
        throw FastNoSuchElementException.instance();
    else {
        final TraverserSet<S> temp = new TraverserSet<>();
        IteratorUtils.removeOnNext(this.traverserSet.iterator()).forEachRemaining(t -> {
            DetachedFactory.detach(t, true); // this should be dynamic
            temp.add(t);
        });
        return temp;
    }
}
 

@Override
public Traverser.Admin<E> processNextStart() {
    if (this.done)
        throw FastNoSuchElementException.instance();
    this.processAllStarts();
    this.done = true;
    return this.getTraversal().asAdmin().getTraverserGenerator().generate(this.supply(), (Step<E, E>) this, 1l);
}