import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@Test
@FeatureRequirementSet(FeatureRequirementSet.Package.SIMPLE)
public void shouldThrowExceptionOnEInDifferentPartition() {
    final PartitionStrategy partitionStrategyAA = PartitionStrategy.build()
            .partitionKey(partition).writePartition("A").addReadPartition("A").create();
    final GraphTraversalSource sourceAA = create(partitionStrategyAA);

    final PartitionStrategy partitionStrategyA = PartitionStrategy.build()
            .partitionKey(partition).writePartition("A").create();
    final GraphTraversalSource sourceA = create(partitionStrategyA);

    final Vertex vA = sourceAA.addV().property("any", "a").next();
    final Edge e = sourceAA.withSideEffect("vA", vA).V(vA.id()).addE("knows").to("vA").next();
    assertEquals(e.id(), g.E(e.id()).id().next());

    try {
        sourceA.E(e.id()).next();
        fail("Edge should not be in this partition");
    } catch (Exception ex) {
        final Exception expected = FastNoSuchElementException.instance();
        assertEquals(expected.getClass(), ex.getClass());
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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();
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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);
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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);
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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);
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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();
            }
        }
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@Override
public Map<Object, Traverser.Admin<S>> nextBarrier() throws NoSuchElementException {
    final Map<Object, Traverser.Admin<S>> map = new HashMap<>();
    while (this.starts.hasNext()) {
        final Traverser.Admin<S> traverser = this.starts.next();
        final Object object;
        if (null != this.dedupLabels) {
            object = new ArrayList<>(this.dedupLabels.size());
            for (final String label : this.dedupLabels) {
                ((List) object).add(TraversalUtil.applyNullable((S) this.getScopeValue(Pop.last, label, traverser), this.dedupTraversal));
            }
        } else {
            object = TraversalUtil.applyNullable(traverser, this.dedupTraversal);
        }
        if (!map.containsKey(object)) {
            traverser.setBulk(1l);
            traverser.set(DetachedFactory.detach(traverser.get(), true));
            map.put(object, traverser);
        }
    }
    if (map.isEmpty())
        throw FastNoSuchElementException.instance();
    else
        return map;

}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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.getEndStep().next();
        else if (this.starts.hasNext()) {
            this.localTraversal.reset();
            this.localTraversal.addStart(this.starts.next());
        } else {
            throw FastNoSuchElementException.instance();
        }
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@Override
protected Iterator<Traverser.Admin<E>> standardAlgorithm() {
    while (true) {
        if (!this.first) {
            for (final List<Traversal.Admin<S, E>> options : this.traversalOptions.values()) {
                for (final Traversal.Admin<S, E> option : options) {
                    if (option.hasNext())
                        return option.getEndStep();
                }
            }
        }
        this.first = false;
        ///
        if (this.hasBarrier) {
            if (!this.starts.hasNext())
                throw FastNoSuchElementException.instance();
            while (this.starts.hasNext()) {
                this.handleStart(this.starts.next());
            }
        } else {
            this.handleStart(this.starts.next());
        }
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@Override
protected Traverser.Admin<S> processNextStart() throws NoSuchElementException {
    if (resultsIter instanceof EmptyIterator) {
        while (starts.hasNext()) {
            Traverser.Admin<S> next = starts.next();
            B_O_S_SE_SL_Traverser traverser = (B_O_S_SE_SL_Traverser) next;
            if (traverser.getSideEffects().get("_whereStep") instanceof Traverser) {
                results.add(traverser.getSideEffects().get("_whereStep"));
            }
            ArrayList<Traverser.Admin<S>> whereStep = traverser.getSideEffects().get("_whereStep");
            for (Traverser.Admin<S> stringSMap : whereStep) {
                if (((Map<String, S>) stringSMap.get()).get(selectKey).equals(next.get())) {
                    results.add(stringSMap);
                }
            }
        }
        resultsIter = results.iterator();
    }
    if (resultsIter.hasNext())
        return resultsIter.next();
    throw FastNoSuchElementException.instance();
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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 Event.EdgeAddedEvent vae = new Event.EdgeAddedEvent(DetachedFactory.detach(edge, true));
            callbackRegistry.getCallbacks().forEach(c -> c.accept(vae));
        }
        return generator.generate(edge, this, 1L);
    } else
        throw FastNoSuchElementException.instance();


}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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();
        }
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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());
    }

}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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()) {
        Traverser.Admin<E> traverser = this.resultIterator.next();
        return traverser;
    } else {
        throw FastNoSuchElementException.instance();
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
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;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@Test
public void removeDoesNothingWhenTheEntityIsNotPartOfTheCollection() {
  GraphWrapper graphWrapper =
    newGraph().withVertex("collection", v -> v.withLabel(DATABASE_LABEL)
                                              .withOutgoingRelation(HAS_ENTITY_NODE_RELATION_NAME, "entityNode")
                                              .withProperty(ENTITY_TYPE_NAME_PROPERTY_NAME, ENTITY_NAME)
                                              .withProperty(COLLECTION_NAME_PROPERTY_NAME, COLLECTION_NAME))
              .withVertex("entityNode", v -> {
              })
              .withVertex("entity", v -> v.withLabel("entity"))
              .wrap();
  Vertex collectionVertex = graphWrapper.getGraph().traversal().V().has(T.label, LabelP.of(DATABASE_LABEL)).next();
  Vertex entityVertex = graphWrapper.getGraph().traversal().V().has(T.label, LabelP.of("entity")).next();
  Collection instance = new Collection(VRE_NAME, collectionVertex, graphWrapper);

  try {
    instance.remove(entityVertex);
  } catch (FastNoSuchElementException e) {
    fail("Should not throw an exception.");
  }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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();
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
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);
        }
    };
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
@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;
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.util.FastNoSuchElementException; //导入依赖的package包/类
/**
 * 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;
}