/** * Choose the right traversal option to apply and seed those options with this traverser. */ private void applyCurrentTraverser(final Traverser.Admin<S> start) { // first get the value of the choice based on the current traverser and use that to select the right traversal // option to which that traverser should be routed final Object choice = PickTokenKey.make(TraversalUtil.apply(start, this.branchTraversal)); final List<Traversal.Admin<S, E>> branch = this.traversalOptions.containsKey(choice) ? this.traversalOptions.get(choice) : this.traversalOptions.get(Pick.none); // if a branch is identified, then split the traverser and add it to the start of the option so that when // that option is iterated (in the calling method) that value can be applied. if (null != branch) branch.forEach(traversal -> traversal.addStart(start.split())); if (choice != Pick.any) { final List<Traversal.Admin<S, E>> anyBranch = this.traversalOptions.get(Pick.any); if (null != anyBranch) anyBranch.forEach(traversal -> traversal.addStart(start.split())); } }
@Override public void setup(final Memory memory) { MemoryTraversalSideEffects.setMemorySideEffects(this.traversal.get(), memory, ProgramPhase.SETUP); final Map<Vertex, Long> map = (Map<Vertex, Long>) this.haltedTraversers.iterator().next().get(); assertEquals(2, map.size()); assertTrue(map.values().contains(3l)); assertTrue(map.values().contains(1l)); final IndexedTraverserSet<Object,Vertex> activeTraversers = new IndexedTraverserSet.VertexIndexedTraverserSet(); map.keySet().forEach(vertex -> activeTraversers.add(this.haltedTraversers.peek().split(vertex, EmptyStep.instance()))); this.haltedTraversers.clear(); this.checkSideEffects(); memory.set(TraversalVertexProgram.ACTIVE_TRAVERSERS, activeTraversers); }
@Override protected Traverser.Admin<E> processNextStart() { while (true) { if (this.iterator.hasNext()) { return this.head.split(this.iterator.next(), this); } else { closeIterator(); this.head = this.starts.next(); this.iterator = this.flatMap(this.head); } } }
@Override protected Iterator<Traverser.Admin<S>> computerAlgorithm() throws NoSuchElementException { final RepeatStep<S> repeatStep = (RepeatStep<S>) this.getTraversal().getParent(); final Traverser.Admin<S> start = this.starts.next(); start.incrLoops(); if (repeatStep.doUntil(start, false)) { start.resetLoops(); start.setStepId(repeatStep.getNextStep().getId()); start.addLabels(repeatStep.labels); return IteratorUtils.of(start); } else { start.setStepId(repeatStep.getId()); if (repeatStep.doEmit(start, false)) { final Traverser.Admin<S> emitSplit = start.split(); emitSplit.resetLoops(); emitSplit.setStepId(repeatStep.getNextStep().getId()); emitSplit.addLabels(repeatStep.labels); return IteratorUtils.of(start, emitSplit); } return IteratorUtils.of(start); } } }
@Override protected Iterator<Traverser.Admin<S>> standardAlgorithm() throws NoSuchElementException { if (null == this.repeatTraversal) throw new IllegalStateException("The repeat()-traversal was not defined: " + this); while (true) { if (this.repeatTraversal.getEndStep().hasNext()) { return this.repeatTraversal.getEndStep(); } else { final Traverser.Admin<S> start = this.starts.next(); start.initialiseLoops(this.getId(), this.loopName); if (doUntil(start, true)) { start.resetLoops(); return IteratorUtils.of(start); } this.repeatTraversal.addStart(start); if (doEmit(start, true)) { final Traverser.Admin<S> emitSplit = start.split(); emitSplit.resetLoops(); return IteratorUtils.of(emitSplit); } } } }
@Override protected Iterator<Traverser.Admin<S>> computerAlgorithm() throws NoSuchElementException { if (null == this.repeatTraversal) throw new IllegalStateException("The repeat()-traversal was not defined: " + this); final Traverser.Admin<S> start = this.starts.next(); if (doUntil(start, true)) { start.setStepId(this.getNextStep().getId()); start.addLabels(this.labels); return IteratorUtils.of(start); } else { start.setStepId(this.repeatTraversal.getStartStep().getId()); start.initialiseLoops(start.getStepId(), this.loopName); if (doEmit(start, true)) { final Traverser.Admin<S> emitSplit = start.split(); emitSplit.resetLoops(); emitSplit.setStepId(this.getNextStep().getId()); return IteratorUtils.of(start, emitSplit); } else { return IteratorUtils.of(start); } } }
@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(); } } } }
private void updateHaltedTraversers(final Vertex vertex, final Memory memory) { if (isStartVertex(vertex)) { final List<Path> paths = memory.get(SHORTEST_PATHS); if (vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS).isPresent()) { // replace the current set of halted traversers with new new traversers that hold the shortest paths // found for this vertex final TraverserSet<Vertex> haltedTraversers = vertex.value(TraversalVertexProgram.HALTED_TRAVERSERS); final TraverserSet<Path> newHaltedTraversers = new TraverserSet<>(); for (final Traverser.Admin<Vertex> traverser : haltedTraversers) { final Vertex v = traverser.get(); for (final Path path : paths) { if (path.get(0).equals(v)) { newHaltedTraversers.add(traverser.split(path, this.programStep)); } } } vertex.property(VertexProperty.Cardinality.single, TraversalVertexProgram.HALTED_TRAVERSERS, newHaltedTraversers); } } }
@Override public void loadState(final Graph graph, final Configuration config) { configuration = new BaseConfiguration(); if (config != null) { ConfigurationUtils.copy(config, configuration); } if (configuration.containsKey(EDGE_TRAVERSAL)) { this.edgeTraversal = PureTraversal.loadState(configuration, EDGE_TRAVERSAL, graph); this.scope = MessageScope.Local.of(() -> this.edgeTraversal.get().clone()); } scopes = new HashSet<>(Collections.singletonList(scope)); this.property = configuration.getString(PROPERTY, COMPONENT); this.haltedTraversers = TraversalVertexProgram.loadHaltedTraversers(configuration); this.haltedTraversersIndex = new IndexedTraverserSet<>(v -> v); for (final Traverser.Admin<Vertex> traverser : this.haltedTraversers) { this.haltedTraversersIndex.add(traverser.split()); } }
@Override public Admin<T> split() { return new ProjectedTraverser<>(this.baseTraverser.split(), this.projections); }
@Override public <R> Admin<R> split(final R r, final Step<T, R> step) { return new ProjectedTraverser<>(this.baseTraverser.split(r, step), this.projections); }
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 protected Traverser.Admin<E> processNextStart() { final Traverser.Admin<S> traverser = this.starts.next(); return traverser.split(this.map(traverser), this); }
@Override protected Traverser.Admin<Object> processNextStart() throws NoSuchElementException { if (null == this.parent) this.parent = (MatchStep<?, ?>) this.getTraversal().getParent(); final Traverser.Admin<Object> traverser = this.starts.next(); this.parent.getMatchAlgorithm().recordStart(traverser, this.getTraversal()); // TODO: sideEffect check? return null == this.selectKey ? traverser : traverser.split(traverser.path().get(Pop.last, this.selectKey), this); }
public static final <S, E> E apply(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); try { return traversal.next(); // map } catch (final NoSuchElementException e) { throw new IllegalArgumentException("The provided traverser does not map to a value: " + split + "->" + traversal); } }
@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); } }
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(); }
public static final <S, E> Iterator<E> applyAll(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; // flatmap }