public static String traversalStrategiesString(final TraversalStrategies traversalStrategies) { return "strategies" + traversalStrategies.toList(); }
/** * Return the {@link TraversalStrategy} instance associated with the provided class. * * @param traversalStrategyClass the class of the strategy to get * @param <T> the strategy class type * @return an optional containing the strategy instance or not */ public default <T extends TraversalStrategy> Optional<T> getStrategy(final Class<T> traversalStrategyClass) { return (Optional) toList().stream().filter(s -> traversalStrategyClass.isAssignableFrom(s.getClass())).findAny(); }
public static Optional<Computer> getComputer(final TraversalStrategies strategies) { final Optional<TraversalStrategy<?>> optional = strategies.toList().stream().filter(strategy -> strategy instanceof VertexProgramStrategy).findAny(); return optional.isPresent() ? Optional.of(((VertexProgramStrategy) optional.get()).computer) : Optional.empty(); }
public static void addRequirements(final TraversalStrategies traversalStrategies, final TraverserRequirement... requirements) { RequirementsStrategy strategy = (RequirementsStrategy) traversalStrategies.toList().stream().filter(s -> s instanceof RequirementsStrategy).findAny().orElse(null); if (null == strategy) { strategy = new RequirementsStrategy(); traversalStrategies.addStrategies(strategy); } else { final RequirementsStrategy cloneStrategy = new RequirementsStrategy(); cloneStrategy.requirements.addAll(strategy.requirements); strategy = cloneStrategy; traversalStrategies.addStrategies(strategy); } Collections.addAll(strategy.requirements, requirements); }
public static boolean isLegal(final Traversal.Admin<?, ?> traversal) { final Step<?, ?> startStep = traversal.getStartStep(); final Step<?, ?> endStep = traversal.getEndStep(); // right now this is not supported because of how the SparkStarBarrierInterceptor mutates the traversal prior to local evaluation if (traversal.getStrategies().toList().stream().filter(strategy -> strategy instanceof SubgraphStrategy).findAny().isPresent()) return false; if (!startStep.getClass().equals(GraphStep.class) || ((GraphStep) startStep).returnsEdge()) return false; if (!endStep.getClass().equals(CountGlobalStep.class) && !endStep.getClass().equals(SumGlobalStep.class) && !endStep.getClass().equals(MeanGlobalStep.class) && !endStep.getClass().equals(MaxGlobalStep.class) && !endStep.getClass().equals(MinGlobalStep.class) && !endStep.getClass().equals(FoldStep.class) && !endStep.getClass().equals(GroupStep.class) && !endStep.getClass().equals(GroupCountStep.class)) // TODO: tree() return false; if (TraversalHelper.getStepsOfAssignableClassRecursively(Scope.global, Barrier.class, traversal).size() != 1) return false; if (traversal.getTraverserRequirements().contains(TraverserRequirement.SACK)) return false; return TraversalHelper.isLocalStarGraph(traversal); } }
public static <A> void addSideEffect(final TraversalStrategies traversalStrategies, final String key, final A value, final BinaryOperator<A> reducer) { SideEffectStrategy strategy = (SideEffectStrategy) traversalStrategies.toList().stream().filter(s -> s instanceof SideEffectStrategy).findAny().orElse(null); if (null == strategy) { strategy = new SideEffectStrategy(); traversalStrategies.addStrategies(strategy); } else { final SideEffectStrategy cloneStrategy = new SideEffectStrategy(); cloneStrategy.sideEffects.addAll(strategy.sideEffects); strategy = cloneStrategy; traversalStrategies.addStrategies(strategy); } strategy.sideEffects.add(new Triplet<>(key, null == value ? null : value instanceof Supplier ? (Supplier) value : new ConstantSupplier<>(value), reducer)); } }
public void addGraphComputerStrategies(final TraversalSource traversalSource) { Class<? extends GraphComputer> graphComputerClass; if (this.computer.getGraphComputerClass().equals(GraphComputer.class)) { try { graphComputerClass = this.computer.apply(traversalSource.getGraph()).getClass(); } catch (final Exception e) { graphComputerClass = GraphComputer.class; } } else graphComputerClass = this.computer.getGraphComputerClass(); final List<TraversalStrategy<?>> graphComputerStrategies = TraversalStrategies.GlobalCache.getStrategies(graphComputerClass).toList(); traversalSource.getStrategies().addStrategies(graphComputerStrategies.toArray(new TraversalStrategy[graphComputerStrategies.size()])); }
public static void applySingleLevelStrategies(final Traversal.Admin<?, ?> parentTraversal, final Traversal.Admin<?, ?> childTraversal, final Class<? extends TraversalStrategy> stopAfterStrategy) { childTraversal.setStrategies(parentTraversal.getStrategies()); childTraversal.setSideEffects(parentTraversal.getSideEffects()); parentTraversal.getGraph().ifPresent(childTraversal::setGraph); for (final TraversalStrategy<?> strategy : parentTraversal.getStrategies().toList()) { strategy.apply(childTraversal); if (null != stopAfterStrategy && stopAfterStrategy.isInstance(strategy)) break; } }
private void validate_g_V_whereXinXcreatedX_count_isX1XX_name_profile(final Traversal traversal, final TraversalMetrics traversalMetrics) { traversalMetrics.toString(); // ensure no exceptions are thrown assumeThat("The following assertions apply to TinkerGraph only as provider strategies can alter the steps to not comply with expectations", graph.getClass().getSimpleName(), equalTo("TinkerGraph")); assertEquals("There should be 3 top-level metrics.", 3, traversalMetrics.getMetrics().size()); Metrics metrics = traversalMetrics.getMetrics(0); assertEquals(6, metrics.getCount(TraversalMetrics.TRAVERSER_COUNT_ID).longValue()); assertEquals(6, metrics.getCount(TraversalMetrics.ELEMENT_COUNT_ID).longValue()); metrics = traversalMetrics.getMetrics(1); assertEquals(1, metrics.getCount(TraversalMetrics.TRAVERSER_COUNT_ID).longValue()); assertEquals(1, metrics.getCount(TraversalMetrics.ELEMENT_COUNT_ID).longValue()); if (traversal.asAdmin().getStrategies().toList().stream().anyMatch(s -> s instanceof CountStrategy)) { assertEquals("Metrics 1 should have 4 nested metrics.", 4, metrics.getNested().size()); } else { assertEquals("Metrics 1 should have 3 nested metrics.", 3, metrics.getNested().size()); } }
@Override public void applyStrategies() throws IllegalStateException { try { assert 0 == this.getSteps().size(); final ScriptEngine engine = SingleGremlinScriptEngineManager.get(this.scriptEngine); final Bindings engineBindings = engine.createBindings(); final List<TraversalStrategy<?>> strategyList = this.getStrategies().toList(); engineBindings.put(this.alias, this.factory.createTraversalSource(this.graph).withStrategies(strategyList.toArray(new TraversalStrategy[strategyList.size()]))); engineBindings.put("graph", this.graph); // TODO: we don't need this as the traversalSource.getGraph() exists, but its now here and people might be using it (remove in 3.3.0) for (int i = 0; i < this.bindings.length; i = i + 2) { engineBindings.put((String) this.bindings[i], this.bindings[i + 1]); } final Traversal.Admin<S, E> traversal = (Traversal.Admin<S, E>) engine.eval(this.script, engineBindings); traversal.getSideEffects().mergeInto(this.sideEffects); traversal.getSteps().forEach(this::addStep); this.strategies = traversal.getStrategies(); super.applyStrategies(); } catch (final ScriptException e) { throw new IllegalStateException(e.getMessage(), e); } } }
@Test @LoadGraphWith(MODERN) public void g_V_repeat_both_profile() { final Traversal<Vertex, TraversalMetrics> traversal = get_g_V_repeatXbothX_timesX3X_profile(); printTraversalForm(traversal); final TraversalMetrics traversalMetrics = traversal.next(); validate_g_V_repeat_both_modern_profile(traversalMetrics, traversal.asAdmin().getStrategies().toList().contains(RepeatUnrollStrategy.instance()) && !traversal.asAdmin().getStrategies().toList().contains(ComputerVerificationStrategy.instance())); }
TraversalStrategy strategies[] = this.getStrategies().toList() .toArray(new TraversalStrategy[0]); bindings.put("g", this.factory.createTraversalSource(this.graph)
@Test @LoadGraphWith(MODERN) public void g_V_repeat_both_profileXmetricsX() { final Traversal<Vertex, Vertex> traversal = get_g_V_repeatXbothX_timesX3X_profileXmetricsX(); printTraversalForm(traversal); traversal.iterate(); final TraversalMetrics traversalMetrics = traversal.asAdmin().getSideEffects().get(METRICS_KEY); validate_g_V_repeat_both_modern_profile(traversalMetrics, traversal.asAdmin().getStrategies().toList().contains(RepeatUnrollStrategy.instance()) && !traversal.asAdmin().getStrategies().toList().contains(ComputerVerificationStrategy.instance())); }
public TraversalExplanation(final Traversal.Admin<?, ?> traversal) { this.traversal = traversal.clone(); TraversalStrategies mutatingStrategies = new DefaultTraversalStrategies(); for (final TraversalStrategy strategy : this.traversal.getStrategies().toList()) { final Traversal.Admin<?, ?> mutatingTraversal = this.traversal.clone(); mutatingStrategies.addStrategies(strategy); mutatingTraversal.setStrategies(mutatingStrategies); mutatingTraversal.applyStrategies(); this.strategyTraversals.add(Pair.with(strategy, mutatingTraversal)); } }
final Traversal.Admin<?, ?> computerTraversal = step.computerTraversal.get().clone(); final List<TraversalStrategy<?>> strategies = step.getTraversal().getStrategies().toList(); final int indexOfStrategy = strategies.indexOf(MessagePassingReductionStrategy.instance()); if (indexOfStrategy > 0)
@Override public TraversalVertexProgram generateProgram(final Graph graph, final Memory memory) { final Traversal.Admin<?, ?> computerSpecificTraversal = this.computerTraversal.getPure(); final TraversalStrategies computerSpecificStrategies = this.getTraversal().getStrategies().clone(); IteratorUtils.filter(TraversalStrategies.GlobalCache.getStrategies(graph.getClass()).toList(), s -> s instanceof TraversalStrategy.ProviderOptimizationStrategy).forEach(computerSpecificStrategies::addStrategies); computerSpecificTraversal.setStrategies(computerSpecificStrategies); computerSpecificTraversal.setSideEffects(new MemoryTraversalSideEffects(this.getTraversal().getSideEffects())); computerSpecificTraversal.setParent(this); final TraversalVertexProgram.Builder builder = TraversalVertexProgram.build().traversal(computerSpecificTraversal); if (memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)) builder.haltedTraversers(memory.get(TraversalVertexProgram.HALTED_TRAVERSERS)); return builder.create(graph); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { 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 Iterator<?> itty = IteratorUtils.filter(this.traversal.get().getStrategies().toList(), strategy -> strategy instanceof HaltedTraverserStrategy).iterator(); this.haltedTraverserStrategy = itty.hasNext() ? (HaltedTraverserStrategy) itty.next() : HaltedTraverserStrategy.reference();
private boolean isIgnoredKey(String key) { // TODO Filter out constants? Predicate<String> isKey = Predicate.isEqual(Objects.requireNonNull(key)); return isKey.test(options().fileParentKey().orElse(null)) || options().identifierKey().filter(isKey).isPresent() || traversal().getStrategies().toList().stream().flatMap(ofType(PartitionStrategy.class)) .map(PartitionStrategy::getPartitionKey).anyMatch(isKey); }
public TraversalExplanation(final Traversal.Admin<?, ?> traversal) { this.traversal = traversal.clone(); TraversalStrategies mutatingStrategies = new DefaultTraversalStrategies(); for (final TraversalStrategy strategy : this.traversal.getStrategies().toList()) { final Traversal.Admin<?, ?> mutatingTraversal = this.traversal.clone(); mutatingStrategies.addStrategies(strategy); mutatingTraversal.setStrategies(mutatingStrategies); mutatingTraversal.applyStrategies(); this.strategyTraversals.add(Pair.with(strategy, mutatingTraversal)); } }