public static <K, V> Map<K, V> doFinalReduction(final Map<K, Object> map, final Traversal.Admin<?, V> valueTraversal) { final Barrier barrierStep = determineBarrierStep(valueTraversal); if (barrierStep != null) { for (final K key : map.keySet()) { valueTraversal.reset(); barrierStep.addBarrier(map.get(key)); if (valueTraversal.hasNext()) map.put(key, valueTraversal.next()); } } return (Map<K, V>) map; } }
@Override public Map<K, V> projectTraverser(final Traverser.Admin<S> traverser) { final Map<K, V> map = new HashMap<>(1); this.valueTraversal.reset(); this.valueTraversal.addStart(traverser); if (null == this.barrierStep) { if (this.valueTraversal.hasNext()) map.put(TraversalUtil.applyNullable(traverser, this.keyTraversal), (V) this.valueTraversal.next()); } else if (this.barrierStep.hasNextBarrier()) map.put(TraversalUtil.applyNullable(traverser, this.keyTraversal), (V) this.barrierStep.nextBarrier()); return map; }
@Override protected void sideEffect(final Traverser.Admin<S> traverser) { final Map<K, V> map = new HashMap<>(1); this.valueTraversal.reset(); this.valueTraversal.addStart(traverser); if (null == this.barrierStep) { if (this.valueTraversal.hasNext()) map.put(TraversalUtil.applyNullable(traverser, this.keyTraversal), (V) this.valueTraversal.next()); } else if (this.barrierStep.hasNextBarrier()) map.put(TraversalUtil.applyNullable(traverser, this.keyTraversal), (V) this.barrierStep.nextBarrier()); if (!map.isEmpty()) this.getTraversal().getSideEffects().add(this.sideEffectKey, map); }
public static <S, E> boolean test(final Traverser.Admin<S> traverser, final Traversal.Admin<S, E> traversal) { final Traverser.Admin<S> split = traverser.split(); split.setSideEffects(traversal.getSideEffects()); split.setBulk(1l); traversal.addStart(split); return traversal.hasNext(); // filter }
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 } }
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(); }
boolean stop = false; for (final Traversal.Admin<?, ?> matchTraversal : this.matchTraversals) { while (matchTraversal.hasNext()) { // TODO: perhaps make MatchStep a LocalBarrierStep ?? this.standardAlgorithmBarrier.add(matchTraversal.nextTraverser()); if (null == this.keepLabels || this.standardAlgorithmBarrier.size() >= PathRetractionStrategy.MAX_BARRIER_SIZE) {
if (option.getStartStep().hasNext() && option.hasNext()) return option.getEndStep();
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 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(); } } }
public static final <S, E> boolean test(final Traverser.Admin<S> traverser, final Traversal.Admin<S, E> traversal, E end) { if (null == end) return TraversalUtil.test(traverser, traversal); final Traverser.Admin<S> split = traverser.split(); split.setSideEffects(traversal.getSideEffects()); split.setBulk(1l); traversal.reset(); traversal.addStart(split); final Step<?, E> endStep = traversal.getEndStep(); while (traversal.hasNext()) { if (endStep.next().get().equals(end)) return true; } return false; }
@Override protected Traverser.Admin<S> processNextStart() throws NoSuchElementException { if (this.optionalTraversal.hasNext()) return this.optionalTraversal.nextTraverser(); else { final Traverser.Admin<S> traverser = this.starts.next(); this.optionalTraversal.addStart(traverser.split()); if (this.optionalTraversal.hasNext()) return this.optionalTraversal.nextTraverser(); else return traverser; } }
@Override public boolean hasNext() { return null == this.bypassTraversal || this.bypassTraversal.hasNext(); }
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(); }
private final void fillBulker() { while (this.traversal.hasNext() && this.bulker.size() < this.barrierSize) { this.bulker.add(this.traversal.nextTraverser()); } } }
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; }
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(); }
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> boolean test(final Traverser.Admin<S> traverser, final Traversal.Admin<S, E> traversal) { final Traverser.Admin<S> split = traverser.split(); split.setSideEffects(traversal.getSideEffects()); split.setBulk(1l); traversal.reset(); traversal.addStart(split); return traversal.hasNext(); // filter }
@Override protected Iterator<E> flatMap(final Traverser.Admin<S> traverser) { final Traverser.Admin<S> innerTraverser = traverser.clone().asAdmin(); innerTraverser.setBulk(1L); for (final Traversal.Admin<S, E> coalesceTraversal : this.coalesceTraversals) { coalesceTraversal.reset(); coalesceTraversal.addStart(innerTraverser.split()); if (coalesceTraversal.hasNext()) return coalesceTraversal; } return EmptyIterator.instance(); }