public static <S> Optional<S> getLastStepOfAssignableClass(final Class<S> stepClass, final Traversal.Admin<?, ?> traversal) { final List<S> steps = TraversalHelper.getStepsOfAssignableClass(stepClass, traversal); return steps.size() == 0 ? Optional.empty() : Optional.of(steps.get(steps.size() - 1)); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!TraversalHelper.onGraphComputer(traversal)) return; if (traversal.getParent() instanceof TraversalVertexProgramStep) { if (TraversalHelper.getStepsOfAssignableClassRecursively(GraphStep.class, traversal).size() > 1) throw new VerificationException("Mid-traversal V()/E() is currently not supported on GraphComputer", traversal); if (TraversalHelper.hasStepOfAssignableClassRecursively(ProfileStep.class, traversal) && TraversalHelper.getStepsOfAssignableClass(VertexProgramStep.class, TraversalHelper.getRootTraversal(traversal)).size() > 1) throw new VerificationException("Profiling a multi-VertexProgramStep traversal is currently not supported on GraphComputer", traversal); } // this is a problem because sideEffect.merge() is transient on the OLAP reduction if (TraversalHelper.getRootTraversal(traversal).getTraverserRequirements().contains(TraverserRequirement.ONE_BULK)) throw new VerificationException("One bulk is currently not supported on GraphComputer: " + traversal, traversal); // you can not traverse past the local star graph with localChildren (e.g. by()-modulators). if (!TraversalHelper.isGlobalChild(traversal) && !TraversalHelper.isLocalStarGraph(traversal)) throw new VerificationException("Local traversals may not traverse past the local star-graph on GraphComputer: " + traversal, traversal); for (final Step<?, ?> step : traversal.getSteps()) { if (step instanceof PathProcessor && ((PathProcessor) step).getMaxRequirement() != PathProcessor.ElementRequirement.ID) throw new VerificationException("It is not possible to access more than a path element's id on GraphComputer: " + step + " requires " + ((PathProcessor) step).getMaxRequirement(), traversal); if (UNSUPPORTED_STEPS.stream().filter(c -> c.isAssignableFrom(step.getClass())).findFirst().isPresent()) throw new VerificationException("The following step is currently not supported on GraphComputer: " + step, traversal); } Step<?, ?> nextParentStep = traversal.getParent().asStep(); while (!(nextParentStep instanceof EmptyStep)) { if (nextParentStep instanceof PathProcessor && ((PathProcessor) nextParentStep).getMaxRequirement() != PathProcessor.ElementRequirement.ID) throw new VerificationException("The following path processor step requires more than the element id on GraphComputer: " + nextParentStep + " requires " + ((PathProcessor) nextParentStep).getMaxRequirement(), traversal); nextParentStep = nextParentStep.getNextStep(); } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { final EventStrategyCallback callback = new EventStrategyCallback(eventQueue); TraversalHelper.getStepsOfAssignableClass(Mutating.class, traversal).forEach(s -> s.getMutatingCallbackRegistry().addCallback(callback)); }
SqlgWhereStartStep(final Traversal.Admin traversal, final String selectKey) { super(traversal); this.selectKey = selectKey; }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { boolean changed = true; // recursively walk child traversals trying to inline them into the current traversal line. while (changed) { changed = false; final Iterator<FilterStep> filterStepIterator = TraversalHelper.getStepsOfAssignableClass(FilterStep.class, traversal).iterator(); while (!changed && filterStepIterator.hasNext()) { final FilterStep<?> step = filterStepIterator.next(); changed = step instanceof HasStep && InlineFilterStrategy.processHasStep((HasStep) step, traversal) || step instanceof TraversalFilterStep && InlineFilterStrategy.processTraversalFilterStep((TraversalFilterStep) step, traversal) || step instanceof OrStep && InlineFilterStrategy.processOrStep((OrStep) step, traversal) || step instanceof AndStep && InlineFilterStrategy.processAndStep((AndStep) step, traversal); } if (!changed && traversal.getParent() instanceof EmptyStep) { final Iterator<MatchStep> matchStepIterator = TraversalHelper.getStepsOfClass(MatchStep.class, traversal).iterator(); while (!changed && matchStepIterator.hasNext()) { if (InlineFilterStrategy.processMatchStep(matchStepIterator.next(), traversal)) changed = true; } } } }
SqlgWhereStartStep(final Traversal.Admin traversal, final String selectKey) { super(traversal); this.selectKey = selectKey; }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { TraversalHelper.getStepsOfAssignableClass(HasStep.class, traversal).stream() .filter(hasStep -> ((HasStep<?>) hasStep).getHasContainers().get(0).getKey().equals(T.id.getAccessor())) .forEach(hasStep -> ((HasStep<?>) hasStep).getHasContainers().get(0).setKey(this.idPropertyKey)); TraversalHelper.getStepsOfAssignableClass(IdStep.class, traversal).stream().forEach(step -> { TraversalHelper.replaceStep(step, new PropertiesStep(traversal, PropertyType.VALUE, idPropertyKey), traversal); });
stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(GraphStep.class, traversal)); stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(VertexStep.class, traversal)); stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeOtherVertexStep.class, traversal)); stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeVertexStep.class, traversal)); final List<PropertiesStep> propertiesSteps = TraversalHelper.getStepsOfAssignableClass(PropertiesStep.class, traversal); propertiesSteps.forEach(step -> { final List<PropertyMapStep> propertyMapSteps = TraversalHelper.getStepsOfAssignableClass(PropertyMapStep.class, traversal); propertyMapSteps.forEach(step -> {
if (TraversalHelper.getStepsOfAssignableClass(Barrier.class, matchTraversal).stream(). filter(s -> !(s instanceof NoOpBarrierStep)).findAny().isPresent()) { // exclude NoOpBarrierSteps from the determination as they are optimization barriers final Traversal.Admin newTraversal = new DefaultTraversal<>();
!(TraversalHelper.getStepsOfAssignableClass(TraversalParent.class, compiledComputerTraversal). // this is a strict precaution that could be loosed with deeper logic on barriers in global children stream(). filter(parent -> !parent.getGlobalChildren().isEmpty()).findAny().isPresent())) {
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (TraversalHelper.getStepsOfAssignableClass(VertexProgramStep.class, traversal).size() > 1) // do not do if there is an OLAP chain return; final Graph graph = traversal.getGraph().orElse(EmptyGraph.instance()); // given that this strategy only works for single OLAP jobs, the graph is the traversal graph for (final TraversalVertexProgramStep step : TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, traversal)) { // will be zero or one step final Traversal.Admin<?, ?> computerTraversal = step.generateProgram(graph, EmptyMemory.instance()).getTraversal().get().clone(); if (!computerTraversal.isLocked()) computerTraversal.applyStrategies(); final Computer computer = step.getComputer(); if (null == computer.getEdges() && !GraphComputer.Persist.EDGES.equals(computer.getPersist())) { // if edges() already set, use it final Traversal.Admin<Vertex, Edge> edgeFilter = getEdgeFilter(computerTraversal); if (null != edgeFilter) // if no edges can be filtered, then don't set edges() step.setComputer(computer.edges(edgeFilter)); } } }
if (!traversal.getStrategies().toList().contains(ComputerFinalizationStrategy.instance()) && !traversal.getStrategies().toList().contains(ComputerVerificationStrategy.instance())) { if (!TraversalHelper.getStepsOfAssignableClass(VertexComputing.class, traversal).isEmpty()) throw new VerificationException("VertexComputing steps must be executed with a GraphComputer: " + TraversalHelper.getStepsOfAssignableClass(VertexComputing.class, traversal), traversal);
final List<GraphStep> graphSteps = TraversalHelper.getStepsOfAssignableClass(GraphStep.class, traversal); final List<VertexStep> vertexSteps = TraversalHelper.getStepsOfAssignableClass(VertexStep.class, traversal); if (null != this.vertexCriterion) { final List<Step> vertexStepsToInsertFilterAfter = new ArrayList<>(); vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeOtherVertexStep.class, traversal)); vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeVertexStep.class, traversal)); vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddVertexStep.class, traversal)); vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddVertexStartStep.class, traversal)); vertexStepsToInsertFilterAfter.addAll(graphSteps.stream().filter(GraphStep::returnsVertex).collect(Collectors.toList())); applyCriterion(vertexStepsToInsertFilterAfter, traversal, this.vertexCriterion); edgeStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddEdgeStep.class, traversal)); edgeStepsToInsertFilterAfter.addAll(graphSteps.stream().filter(GraphStep::returnsEdge).collect(Collectors.toList())); edgeStepsToInsertFilterAfter.addAll(vertexSteps.stream().filter(VertexStep::returnsEdge).collect(Collectors.toList())); for (final PropertiesStep<?> step : TraversalHelper.getStepsOfAssignableClass(PropertiesStep.class, traversal)) { final char propertyType = processesPropertyType(step.getPreviousStep()); if ('p' != propertyType) {
public static <S> Optional<S> getLastStepOfAssignableClass(final Class<S> stepClass, final Traversal.Admin<?, ?> traversal) { final List<S> steps = TraversalHelper.getStepsOfAssignableClass(stepClass, traversal); return steps.size() == 0 ? Optional.empty() : Optional.of(steps.get(steps.size() - 1)); }
public static <S> S stepAfter(final Traversal.Admin<?, ?> traversal, final Class<S> stepClass, Step<?,?> step) { int index = TraversalHelper.stepIndex(step, traversal); List<S> steps = TraversalHelper.getStepsOfAssignableClass(stepClass, traversal); Collections.reverse(steps); for (S s : steps) { int stepIndex = TraversalHelper.stepIndex((Step)s, traversal); if (stepIndex > index) { return s; } } return null; }
public static <S> S stepAfter(final Traversal.Admin<?, ?> traversal, final Class<S> stepClass, Step<?,?> step) { int index = TraversalHelper.stepIndex(step, traversal); List<S> steps = TraversalHelper.getStepsOfAssignableClass(stepClass, traversal); Collections.reverse(steps); for (S s : steps) { int stepIndex = TraversalHelper.stepIndex((Step)s, traversal); if (stepIndex > index) { return s; } } return null; }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { final EventStrategyCallback callback = new EventStrategyCallback(eventQueue); TraversalHelper.getStepsOfAssignableClass(Mutating.class, traversal).forEach(s -> s.getMutatingCallbackRegistry().addCallback(callback)); }
SqlgRepeatEndStepBarrier(final Traversal.Admin traversal) { super(traversal); this.toReturn = new ArrayList<>(); }
SqlgRepeatEndStepBarrier(final Traversal.Admin traversal) { super(traversal); this.toReturn = new ArrayList<>(); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (TraversalHelper.getStepsOfAssignableClass(VertexProgramStep.class, traversal).size() > 1) // do not do if there is an OLAP chain return; final Graph graph = traversal.getGraph().orElse(EmptyGraph.instance()); // given that this strategy only works for single OLAP jobs, the graph is the traversal graph for (final TraversalVertexProgramStep step : TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, traversal)) { // will be zero or one step final Traversal.Admin<?, ?> computerTraversal = step.generateProgram(graph, EmptyMemory.instance()).getTraversal().get().clone(); if (!computerTraversal.isLocked()) computerTraversal.applyStrategies(); final Computer computer = step.getComputer(); if (null == computer.getEdges() && !GraphComputer.Persist.EDGES.equals(computer.getPersist())) { // if edges() already set, use it final Traversal.Admin<Vertex, Edge> edgeFilter = getEdgeFilter(computerTraversal); if (null != edgeFilter) // if no edges can be filtered, then don't set edges() step.setComputer(computer.edges(edgeFilter)); } } }