@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(); }
@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 public Object submit(final List<String> args) throws RemoteException { try { String script = getScript(String.join(SPACE, args), this.shellEnvironment); if (this.useSugar) script = SugarLoader.class.getCanonicalName() + ".load()\n" + script; final TraversalVertexProgram program = TraversalVertexProgram.build().traversal(this.traversalSource, "gremlin-groovy", script).create(this.hadoopGraph); final ComputerResult computerResult = VertexProgramStrategy.getComputer(this.traversalSource.getStrategies()).get().apply(this.hadoopGraph).program(program).submit().get(); this.shellEnvironment.setVariable(RESULT, computerResult); /// final Traversal.Admin<ComputerResult, ?> traversal = new DefaultTraversal<>(computerResult.graph()); traversal.addStep(new ComputerResultStep<>(traversal)); traversal.addStart(traversal.getTraverserGenerator().generate(computerResult, EmptyStep.instance(), 1l)); return traversal; } catch (final Exception e) { throw new RemoteException(e); } }
private void processEdges(final Vertex vertex, final Path currentPath, final Number currentDistance, final Messenger<Triplet<Path, Edge, Number>> messenger) { final Traversal.Admin<Vertex, Edge> edgeTraversal = this.edgeTraversal.getPure(); edgeTraversal.addStart(edgeTraversal.getTraverserGenerator().generate(vertex, edgeTraversal.getStartStep(), 1)); while (edgeTraversal.hasNext()) { final Edge edge = edgeTraversal.next(); final Number distance = getDistance(edge); Vertex otherV = edge.inVertex(); if (otherV.equals(vertex)) otherV = edge.outVertex(); // only send message if the adjacent vertex is not yet part of the current path if (!currentPath.objects().contains(otherV)) { messenger.sendMessage(MessageScope.Global.of(otherV), Triplet.with(currentPath, this.includeEdges ? edge : null, NumberHelper.add(currentDistance, distance))); } } }
@Override public boolean terminate(final Memory memory) { final TraverserGenerator generator = this.traversal.get().getTraverserGenerator(); MemoryTraversalSideEffects.setMemorySideEffects(this.traversal.get(), memory, ProgramPhase.TERMINATE); checkSideEffects(); if (memory.isInitialIteration()) { assertFalse(memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); return false; } else { /// assertTrue(memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); final TraverserSet<String> haltedTraversers = memory.get(TraversalVertexProgram.HALTED_TRAVERSERS); haltedTraversers.add(generator.generate("hello", this.programStep, 1l)); haltedTraversers.add(generator.generate("gremlin", this.programStep, 1l)); memory.set(TraversalVertexProgram.HALTED_TRAVERSERS, haltedTraversers); return true; } }
@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(); }
private static <T extends Traversal.Admin<Vertex, Edge>> T setVertexStart(final Traversal.Admin<Vertex, Edge> incidentTraversal, final Vertex vertex) { incidentTraversal.asAdmin().addStart(incidentTraversal.getTraverserGenerator().generate(vertex, incidentTraversal.asAdmin().getStartStep(), 1l)); return (T) incidentTraversal; }
@Override public TraverserGenerator getTraverserGenerator() { return null == this.bypassTraversal ? B_O_TraverserGenerator.instance() : this.bypassTraversal.getTraverserGenerator(); }
private static <T extends Traversal.Admin<Vertex, Edge>> T setVertexStart(final Traversal.Admin<Vertex, Edge> incidentTraversal, final Vertex vertex) { incidentTraversal.addStart(incidentTraversal.getTraverserGenerator().generate(vertex,incidentTraversal.getStartStep(),1l)); return (T) incidentTraversal; }
@Override public TraverserGenerator getTraverserGenerator() { if (null == this.generator) this.generator = (this.parent instanceof EmptyStep) ? DefaultTraverserGeneratorFactory.instance().getTraverserGenerator(this.getTraverserRequirements()) : TraversalHelper.getRootTraversal(this).getTraverserGenerator(); return this.generator; }
private Number getDistance(final Edge edge) { if (this.distanceEqualsNumberOfHops) return 1; final Traversal.Admin<Edge, Number> traversal = this.distanceTraversal.getPure(); traversal.addStart(traversal.getTraverserGenerator().generate(edge, traversal.getStartStep(), 1)); return traversal.tryNext().orElse(0); }
private boolean isEndVertex(final Vertex vertex) { final Traversal.Admin<Vertex, ?> filterTraversal = this.targetVertexFilterTraversal.getPure(); //noinspection unchecked final Step<Vertex, Vertex> startStep = (Step<Vertex, Vertex>) filterTraversal.getStartStep(); filterTraversal.addStart(filterTraversal.getTraverserGenerator().generate(vertex, startStep, 1)); return filterTraversal.hasNext(); }
public static final <S, E> Iterator<E> applyAll(final S start, final Traversal.Admin<S, E> traversal) { traversal.reset(); traversal.addStart(traversal.getTraverserGenerator().generate(start, traversal.getStartStep(), 1l)); return traversal; // flatMap }
public static final <S, E> boolean test(final S start, final Traversal.Admin<S, E> traversal) { traversal.reset(); traversal.addStart(traversal.getTraverserGenerator().generate(start, traversal.getStartStep(), 1l)); return traversal.hasNext(); // filter } }
public static final <S, E> E apply(final S start, final Traversal.Admin<S, E> traversal) { traversal.reset(); traversal.addStart(traversal.getTraverserGenerator().generate(start, traversal.getStartStep(), 1l)); try { return traversal.next(); // map } catch (final NoSuchElementException e) { throw new IllegalArgumentException("The provided start does not map to a value: " + start + "->" + traversal); } }
@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); }
@Override public Traverser.Admin<E> processNextStart() { this.processAllStarts(); if (this.seed == null) throw FastNoSuchElementException.instance(); final Traverser.Admin<E> traverser = this.getTraversal().getTraverserGenerator().generate(this.generateFinalResult(this.seed), (Step<E, E>) this, 1l); this.seed = null; return traverser; }
public static final <S, E> boolean test(final S start, final Traversal.Admin<S, E> traversal, final E end) { if (null == end) return TraversalUtil.test(start, traversal); traversal.reset(); traversal.addStart(traversal.getTraverserGenerator().generate(start, traversal.getStartStep(), 1l)); final Step<?, E> endStep = traversal.getEndStep(); while (traversal.hasNext()) { if (endStep.next().get().equals(end)) return true; } return false; }
@Override protected Traverser.Admin<Boolean> processNextStart() throws NoSuchElementException { return this.starts.hasNext() ? this.starts.next().split(Boolean.TRUE, this) : this.getTraversal().getTraverserGenerator().generate(Boolean.FALSE, (Step) this, 1L); } }
private boolean isStartVertex(final Vertex vertex) { // use the sourceVertexFilterTraversal if the VP is running in standalone mode (not part of a traversal) if (this.standalone) { final Traversal.Admin<Vertex, ?> filterTraversal = this.sourceVertexFilterTraversal.getPure(); filterTraversal.addStart(filterTraversal.getTraverserGenerator().generate(vertex, filterTraversal.getStartStep(), 1)); return filterTraversal.hasNext(); } // ...otherwise use halted traversers to determine whether this is a start vertex return vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS).isPresent(); }