@SuppressWarnings("deprecation") private void initialize() { assert !initialized; initialized = true; assert getReturnType().forProperties() || (orders.isEmpty() && hasContainers.isEmpty()); if (!starts.hasNext()) throw FastNoSuchElementException.instance(); List<Traverser.Admin<Element>> elements = new ArrayList<>(); starts.forEachRemaining(v -> elements.add(v)); starts.add(elements.iterator()); assert elements.size() > 0; useMultiQuery = useMultiQuery && elements.stream().noneMatch(e -> !(e.get() instanceof Vertex)); if (useMultiQuery) { TitanMultiVertexQuery mquery = TitanTraversalUtil.getTx(traversal).multiQuery(); elements.forEach(e -> mquery.addVertex((Vertex) e.get())); makeQuery(mquery); multiQueryResults = mquery.properties(); } }
@Override protected boolean filter(final Traverser.Admin<S> traverser) { if (this.onGraphComputer && !this.executingAtMaster) return true; traverser.setBulk(1L); if (null == this.dedupLabels) { return this.duplicateSet.add(TraversalUtil.applyNullable(traverser, this.dedupTraversal)); } else { final List<Object> objects = new ArrayList<>(this.dedupLabels.size()); this.dedupLabels.forEach(label -> objects.add(TraversalUtil.applyNullable((S) this.getScopeValue(Pop.last, label, traverser), this.dedupTraversal))); return this.duplicateSet.add(objects); } }
@Override public Map<E, Long> projectTraverser(final Traverser.Admin<S> traverser) { final Map<E, Long> map = new HashMap<>(1); map.put(TraversalUtil.applyNullable(traverser, this.keyTraversal), traverser.bulk()); return map; }
foundSomething = true; Traverser.Admin<S> cachedStart = starts.next(); cachedStart.incrLoops(this.getId()); List<Object> startObjects = cachedStart.path().objects(); StringBuilder recordIdConcatenated = new StringBuilder(); for (Object startObject : startObjects) { if (startObject instanceof Element) { Element e = (Element) startObject; recordIdConcatenated.append(e.id().toString()); } else { recordIdConcatenated.append(startObject.toString()); while (this.untilTraversal.hasNext()) { Traverser.Admin<?> filterTraverser = this.untilTraversal.nextTraverser(); List<Object> filterTraverserObjects = filterTraverser.path().objects(); String startId = ""; for (Object filteredTraverserObject : filterTraverserObjects) { if (filteredTraverserObject instanceof Element) { Element e = (Element) filteredTraverserObject; startId += e.id().toString(); } else { startId += filteredTraverserObject.toString(); Collection<Traverser.Admin<S>> startsToReturn = startRecordIds.get(startId); for (Traverser.Admin<S> start : startsToReturn) { start.resetLoops(); toReturn.add(IteratorUtils.of(start));
@Override protected Map<K, E> map(final Traverser.Admin<Element> traverser) { final Map<Object, Object> map = new LinkedHashMap<>(); final Element element = traverser.get(); final boolean isVertex = element instanceof Vertex; if (this.returnType == PropertyType.VALUE) { if (includeToken(WithOptions.ids)) map.put(T.id, element.id()); if (element instanceof VertexProperty) { if (includeToken(WithOptions.keys)) map.put(T.key, ((VertexProperty<?>) element).key()); if (includeToken(WithOptions.values)) map.put(T.value, ((VertexProperty<?>) element).value()); } else { if (includeToken(WithOptions.labels)) map.put(T.label, element.label()); element.properties(this.propertyKeys) : TraversalUtil.applyAll(traverser, this.propertyTraversal);
@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); } } }
foundSomething = true; Traverser.Admin<S> start = starts.next(); start.incrLoops(this.getId()); repeatStep.addStart(start); if (repeatStep.doEmit(start, false)) { foundSomething = true; Traverser.Admin<S> cachedStart = this.starts.next(); cachedStart.incrLoops(this.getId()); if (repeatStep.doUntil(cachedStart, false)) { cachedStart.resetLoops();
@Override protected Iterator<E> flatMap(final Traverser.Admin<Element> traverser) { if (useMultiQuery) { //it is guaranteed that all elements are vertices assert multiQueryResults != null; return convertIterator(multiQueryResults.get(traverser.get())); } else if (traverser.get() instanceof Vertex) { TitanVertexQuery query = makeQuery((TitanTraversalUtil.getTitanVertex(traverser)).query()); return convertIterator(query.properties()); } else { //It is some other element (edge or vertex property) Iterator<E> iter; if (getReturnType().forValues()) { assert orders.isEmpty() && hasContainers.isEmpty(); iter = traverser.get().values(getPropertyKeys()); } else { //this asks for properties assert orders.isEmpty(); //HasContainers don't apply => empty result set if (!hasContainers.isEmpty()) return Collections.emptyIterator(); iter = (Iterator<E>) traverser.get().properties(getPropertyKeys()); } if (limit!=Query.NO_LIMIT) iter = Iterators.limit(iter,limit); return iter; } }
@Override protected Iterator<E> flatMap(final Traverser.Admin<S> traverser) { final S s = traverser.get(); if (s instanceof Iterator) return (Iterator) s; else if (s instanceof Iterable) return ((Iterable) s).iterator(); else if (s instanceof Map) return ((Map) s).entrySet().iterator(); else if (s.getClass().isArray()) return handleArrays(s); else return IteratorUtils.of((E) s); }
return IteratorUtils.of(traversal.getTraverserGenerator().generate(vertexWritable.get(), (Step) graphStep, 1l)); else if (endStep instanceof SumGlobalStep) { result = nextRDD.isEmpty() ? null : nextRDD .map(traverser -> NumberHelper.mul(traverser.bulk(), (Number) traverser.get())) .fold(0, NumberHelper::add); } else if (endStep instanceof MeanGlobalStep) { result = nextRDD.isEmpty() ? null : nextRDD .map(traverser -> new MeanGlobalStep.MeanNumber((Number) traverser.get(), traverser.bulk())) .fold(MeanNumberSupplier.instance().get(), MeanGlobalStep.MeanNumber::add) .getFinal(); } else if (endStep instanceof MinGlobalStep) { result = nextRDD.isEmpty() ? null : nextRDD .map(traverser -> (Comparable) traverser.get()) .fold(Double.NaN, NumberHelper::min); } else if (endStep instanceof MaxGlobalStep) { result = nextRDD.isEmpty() ? null : nextRDD .map(traverser -> (Comparable) traverser.get()) .fold(Double.NaN, NumberHelper::max); } else if (endStep instanceof FoldStep) { if (endStep.getSeedSupplier() instanceof ArrayListSupplier) { final List list = new ArrayList<>(); for (long i = 0; i < traverser.bulk(); i++) { list.add(traverser.get()); return traverser.get();
while (barrier.hasNextBarrier()) { final TraverserSet<Object> barrierSet = barrier.nextBarrier(); IteratorUtils.removeOnNext(barrierSet.iterator()).forEachRemaining(traverser -> { traverser.addLabels(step.getLabels()); // this might need to be generalized for working with global barriers too if (traverser.isHalted() && (returnHaltedTraversers || (!(traverser.get() instanceof Element) && !(traverser.get() instanceof Property)) || Host.getHostingVertex(traverser.get()).equals(vertex))) { if (returnHaltedTraversers) memory.add(TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(haltedTraverserStrategy.halt(traverser))); else haltedTraversers.add(traverser.detach()); } else localBarrierTraversers.add(traverser.detach()); }); if (traverser.isHalted() && (!(traverser.get() instanceof Element) && !(traverser.get() instanceof Property)) || Host.getHostingVertex(traverser.get()).equals(vertex))) { if (returnHaltedTraversers) memory.add(TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(haltedTraverserStrategy.halt(traverser))); else haltedTraversers.add(traverser.detach()); } else { activeTraversers.add(traverser);
final Object[] vertexPropertyKeyValues = this.parameters.getKeyValues(traverser, T.key, T.value); final Element element = traverser.get(); final EventStrategy eventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class).get(); final Property currentProperty = traverser.get().property(key); final boolean newProperty = element instanceof Vertex ? currentProperty == VertexProperty.empty() : currentProperty == Property.empty(); final Event.ElementPropertyChangedEvent evt; ((Vertex) element).property(key, value, vertexPropertyKeyValues); else element.property(key, value);
@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<E>> computerAlgorithm() { final List<Traverser.Admin<E>> ends = new ArrayList<>(); final Traverser.Admin<S> start = this.starts.next(); 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 (null != branch) { branch.forEach(traversal -> { final Traverser.Admin<E> split = (Traverser.Admin<E>) start.split(); split.setStepId(traversal.getStartStep().getId()); //split.addLabels(this.labels); ends.add(split); }); } if (choice != Pick.any) { final List<Traversal.Admin<S, E>> anyBranch = this.traversalOptions.get(Pick.any); if (null != anyBranch) { anyBranch.forEach(traversal -> { final Traverser.Admin<E> split = (Traverser.Admin<E>) start.split(); split.setStepId(traversal.getStartStep().getId()); //split.addLabels(this.labels); ends.add(split); }); } } return ends.iterator(); }
public Iterator<Traverser.Admin<S>> attach(final Iterator<Traverser.Admin<S>> iterator, final Graph graph) { return IteratorUtils.map(iterator, traverser -> { traverser.setSideEffects(this.getTraversal().getSideEffects()); // necessary to ensure no NPE if (this.attachElements && (traverser.get() instanceof Attachable) && !(traverser.get() instanceof Property)) traverser.set((S) ((Attachable<Element>) traverser.get()).attach(Attachable.Method.get(graph))); return traverser; }); }
final Traverser.Admin<Object> traverser = traversers.next(); traversers.remove(); traverser.set(DetachedFactory.detach(traverser.get(), true)); // why? traverser.setSideEffects(traversal.get().getSideEffects()); if (traverser.isHalted()) haltedTraversers.add(haltedTraverserStrategy.halt(traverser)); else if (isRemoteTraverser(traverser, traversalMatrix)) // this is so that patterns like order().name work as expected. try and stay local as long as possible remoteActiveTraversers.add(traverser.detach()); else { currentStep = traversalMatrix.getStepById(traverser.getStepId()); if (!currentStep.getId().equals(previousStep.getId()) && !(previousStep instanceof EmptyStep)) { GraphComputing.atMaster(previousStep, true); while (previousStep.hasNext()) { final Traverser.Admin<Object> result = previousStep.next(); if (result.isHalted()) haltedTraversers.add(haltedTraverserStrategy.halt(result)); else if (isRemoteTraverser(result, traversalMatrix)) remoteActiveTraversers.add(result.detach()); else localActiveTraversers.add(result); while (currentStep.hasNext()) { final Traverser.Admin<Object> traverser = currentStep.next(); if (traverser.isHalted()) haltedTraversers.add(haltedTraverserStrategy.halt(traverser)); else if (isRemoteTraverser(traverser, traversalMatrix)) remoteActiveTraversers.add(traverser.detach()); else localActiveTraversers.add(traverser);
iterator.remove(); maybeActiveTraversers.remove(traverser); traverser.attach(Attachable.Method.get(vertex)); traverser.setSideEffects(traversalSideEffects); toProcessTraversers.add(traverser); IteratorUtils.removeOnNext(previousActiveTraversers.iterator()).forEachRemaining(traverser -> { traverser.attach(Attachable.Method.get(vertex)); traverser.setSideEffects(traversalSideEffects); toProcessTraversers.add(traverser); }); IteratorUtils.removeOnNext(messages.next().iterator()).forEachRemaining(traverser -> { if (traverser.isHalted()) { if (returnHaltedTraversers) memory.add(TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(haltedTraverserStrategy.halt(traverser))); traverser.attach(Attachable.Method.get(vertex)); traverser.setSideEffects(traversalSideEffects); toProcessTraversers.add(traverser); final Traverser.Admin<Object> traverser = traversers.next(); traversers.remove(); final Step<Object, Object> currentStep = traversalMatrix.getStepById(traverser.getStepId()); if (traverser.get() instanceof Element || traverser.get() instanceof Property) { // GRAPH OBJECT final Vertex hostingVertex = Host.getHostingVertex(traverser.get()); if (!vertex.equals(hostingVertex)) { // if its host is not the current vertex, then send the traverser to the hosting vertex