org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper.applyTraversalRecursively java code examples

private void applyToChildren(final Set<String> keepLabels, final List<Traversal.Admin<Object, Object>> children) {
  for (final Traversal.Admin<Object, Object> child : children) {
    TraversalHelper.applyTraversalRecursively(trav -> addLabels(trav, keepLabels), child);
  }
}

@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
  if ((traversal.getParent() instanceof EmptyStep || traversal.getParent() instanceof VertexProgramStep) &&
      TraversalHelper.hasStepOfAssignableClassRecursively(ProfileSideEffectStep.class, traversal))
    TraversalHelper.applyTraversalRecursively(t -> t.getEndStep().addLabel(MARKER), traversal);
  if (traversal.getEndStep().getLabels().contains(MARKER)) {
    traversal.getEndStep().removeLabel(MARKER);
    // Add .profile() step after every pre-existing step.
    final List<Step> steps = traversal.getSteps();
    final int numSteps = steps.size();
    for (int i = 0; i < numSteps; i++) {
      // Do not inject profiling after ProfileSideEffectStep as this will be the last step on the root traversal.
      if (steps.get(i * 2) instanceof ProfileSideEffectStep)
        break;
      // Create and inject ProfileStep
      traversal.addStep((i * 2) + 1, new ProfileStep(traversal));
    }
  }
}

private SubgraphStrategy(final Traversal<Vertex, ?> vertexCriterion, final Traversal<Edge, ?> edgeCriterion, final Traversal<VertexProperty, ?> vertexPropertyCriterion) {
  this.vertexCriterion = null == vertexCriterion ? null : vertexCriterion.asAdmin().clone();
  // if there is no vertex predicate there is no need to test either side of the edge
  if (null == this.vertexCriterion) {
    this.edgeCriterion = null == edgeCriterion ? null : edgeCriterion.asAdmin().clone();
  } else {
    final Traversal.Admin<Edge, ?> vertexPredicate;
    vertexPredicate = __.<Edge>and(
        __.inV().filter(this.vertexCriterion),
        __.outV().filter(this.vertexCriterion)).asAdmin();
    // if there is a vertex predicate then there is an implied edge filter on vertices even if there is no
    // edge predicate provided by the user.
    this.edgeCriterion = null == edgeCriterion ?
        vertexPredicate :
        edgeCriterion.asAdmin().clone().addStep(new TraversalFilterStep<>(edgeCriterion.asAdmin(), vertexPredicate));
  }
  this.vertexPropertyCriterion = null == vertexPropertyCriterion ? null : vertexPropertyCriterion.asAdmin().clone();
  if (null != this.vertexCriterion)
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), this.vertexCriterion);
  if (null != this.edgeCriterion)
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), this.edgeCriterion);
  if (null != this.vertexPropertyCriterion)
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), this.vertexPropertyCriterion);
}

/**
 * Apply the provider {@link Consumer} function to the provided {@link Traversal} and all of its children.
 *
 * @param consumer  the function to apply to the each traversal in the tree
 * @param traversal the root traversal to start application
 */
public static void applyTraversalRecursively(final Consumer<Traversal.Admin<?, ?>> consumer, final Traversal.Admin<?, ?> traversal) {
  consumer.accept(traversal);
  for (final Step<?, ?> step : traversal.getSteps()) {
    if (step instanceof TraversalParent) {
      for (final Traversal.Admin<?, ?> local : ((TraversalParent) step).getLocalChildren()) {
        applyTraversalRecursively(consumer, local);
      }
      for (final Traversal.Admin<?, ?> global : ((TraversalParent) step).getGlobalChildren()) {
        applyTraversalRecursively(consumer, global);
      }
    }
  }
}

@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
  // using a hidden label marker to denote whether the traversal should not be processed by this strategy
  if ((traversal.getParent() instanceof EmptyStep || traversal.getParent() instanceof VertexProgramStep) &&
      TraversalHelper.hasStepOfAssignableClassRecursively(INVALIDATING_STEP_CLASSES, traversal))
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), traversal);
  if (traversal.getStartStep().getLabels().contains(MARKER)) {
    traversal.getStartStep().removeLabel(MARKER);
    return;
  }
  ////////////////////////////////////////////////////////////////////////////
  final Collection<Pair<VertexStep, Step>> stepsToReplace = new ArrayList<>();
  Step prev = null;
  for (final Step curr : traversal.getSteps()) {
    if (isOptimizable(prev, curr)) {
      stepsToReplace.add(Pair.with((VertexStep) prev, curr));
    }
    prev = curr;
  }
  if (!stepsToReplace.isEmpty()) {
    for (final Pair<VertexStep, Step> pair : stepsToReplace) {
      optimizeSteps(traversal, pair.getValue0(), pair.getValue1());
    }
  }
}

      (step instanceof VertexProgramStep &&
          step.getRequirements().contains(TraverserRequirement.LABELED_PATH)), traversal)) {
TraversalHelper.applyTraversalRecursively(t -> t.getEndStep().addLabel(MARKER), traversal);

private void applyToChildren(final Set<String> keepLabels, final List<Traversal.Admin<Object, Object>> children) {
  for (final Traversal.Admin<Object, Object> child : children) {
    TraversalHelper.applyTraversalRecursively(trav -> addLabels(trav, keepLabels), child);
  }
}

/**
 * Apply the provider {@link Consumer} function to the provided {@link Traversal} and all of its children.
 *
 * @param consumer  the function to apply to the each traversal in the tree
 * @param traversal the root traversal to start application
 */
public static void applyTraversalRecursively(final Consumer<Traversal.Admin<?, ?>> consumer, final Traversal.Admin<?, ?> traversal) {
  consumer.accept(traversal);
  for (final Step<?, ?> step : traversal.getSteps()) {
    if (step instanceof TraversalParent) {
      for (final Traversal.Admin<?, ?> local : ((TraversalParent) step).getLocalChildren()) {
        applyTraversalRecursively(consumer, local);
      }
      for (final Traversal.Admin<?, ?> global : ((TraversalParent) step).getGlobalChildren()) {
        applyTraversalRecursively(consumer, global);
      }
    }
  }
}

@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
  if ((traversal.getParent() instanceof EmptyStep || traversal.getParent() instanceof VertexProgramStep) &&
      TraversalHelper.hasStepOfAssignableClassRecursively(ProfileSideEffectStep.class, traversal))
    TraversalHelper.applyTraversalRecursively(t -> t.getEndStep().addLabel(MARKER), traversal);
  if (traversal.getEndStep().getLabels().contains(MARKER)) {
    traversal.getEndStep().removeLabel(MARKER);
    // Add .profile() step after every pre-existing step.
    final List<Step> steps = traversal.getSteps();
    final int numSteps = steps.size();
    for (int i = 0; i < numSteps; i++) {
      // Do not inject profiling after ProfileSideEffectStep as this will be the last step on the root traversal.
      if (steps.get(i * 2) instanceof ProfileSideEffectStep)
        break;
      // Create and inject ProfileStep
      traversal.addStep((i * 2) + 1, new ProfileStep(traversal));
    }
  }
}

@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
  if ((traversal.getParent() instanceof EmptyStep || traversal.getParent() instanceof VertexProgramStep) &&
      TraversalHelper.hasStepOfAssignableClassRecursively(ProfileSideEffectStep.class, traversal))
    TraversalHelper.applyTraversalRecursively(t -> t.getEndStep().addLabel(MARKER), traversal);
  if (traversal.getEndStep().getLabels().contains(MARKER)) {
    traversal.getEndStep().removeLabel(MARKER);
    // Add .profile() step after every pre-existing step.
    final List<Step> steps = traversal.getSteps();
    final int numSteps = steps.size();
    for (int i = 0; i < numSteps; i++) {
      // Do not inject profiling after ProfileSideEffectStep as this will be the last step on the root traversal.
      if (steps.get(i * 2) instanceof ProfileSideEffectStep)
        break;
      // Create and inject ProfileStep
      traversal.addStep((i * 2) + 1, new ProfileStep(traversal));
    }
  }
}

private SubgraphStrategy(final Traversal<Vertex, ?> vertexCriterion, final Traversal<Edge, ?> edgeCriterion, final Traversal<VertexProperty, ?> vertexPropertyCriterion) {
  this.vertexCriterion = null == vertexCriterion ? null : vertexCriterion.asAdmin().clone();
  // if there is no vertex predicate there is no need to test either side of the edge
  if (null == this.vertexCriterion) {
    this.edgeCriterion = null == edgeCriterion ? null : edgeCriterion.asAdmin().clone();
  } else {
    final Traversal.Admin<Edge, ?> vertexPredicate;
    vertexPredicate = __.<Edge>and(
        __.inV().filter(this.vertexCriterion),
        __.outV().filter(this.vertexCriterion)).asAdmin();
    // if there is a vertex predicate then there is an implied edge filter on vertices even if there is no
    // edge predicate provided by the user.
    this.edgeCriterion = null == edgeCriterion ?
        vertexPredicate :
        edgeCriterion.asAdmin().clone().addStep(new TraversalFilterStep<>(edgeCriterion.asAdmin(), vertexPredicate));
  }
  this.vertexPropertyCriterion = null == vertexPropertyCriterion ? null : vertexPropertyCriterion.asAdmin().clone();
  if (null != this.vertexCriterion)
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), this.vertexCriterion);
  if (null != this.edgeCriterion)
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), this.edgeCriterion);
  if (null != this.vertexPropertyCriterion)
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), this.vertexPropertyCriterion);
}

private SubgraphStrategy(final Traversal<Vertex, ?> vertexCriterion, final Traversal<Edge, ?> edgeCriterion, final Traversal<VertexProperty, ?> vertexPropertyCriterion) {
  this.vertexCriterion = null == vertexCriterion ? null : vertexCriterion.asAdmin().clone();
  // if there is no vertex predicate there is no need to test either side of the edge
  if (null == this.vertexCriterion) {
    this.edgeCriterion = null == edgeCriterion ? null : edgeCriterion.asAdmin().clone();
  } else {
    final Traversal.Admin<Edge, ?> vertexPredicate;
    vertexPredicate = __.<Edge>and(
        __.inV().filter(this.vertexCriterion),
        __.outV().filter(this.vertexCriterion)).asAdmin();
    // if there is a vertex predicate then there is an implied edge filter on vertices even if there is no
    // edge predicate provided by the user.
    this.edgeCriterion = null == edgeCriterion ?
        vertexPredicate :
        edgeCriterion.asAdmin().clone().addStep(new TraversalFilterStep<>(edgeCriterion.asAdmin(), vertexPredicate));
  }
  this.vertexPropertyCriterion = null == vertexPropertyCriterion ? null : vertexPropertyCriterion.asAdmin().clone();
  if (null != this.vertexCriterion)
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), this.vertexCriterion);
  if (null != this.edgeCriterion)
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), this.edgeCriterion);
  if (null != this.vertexPropertyCriterion)
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), this.vertexPropertyCriterion);
}

@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
  // using a hidden label marker to denote whether the traversal should not be processed by this strategy
  if ((traversal.getParent() instanceof EmptyStep || traversal.getParent() instanceof VertexProgramStep) &&
      TraversalHelper.hasStepOfAssignableClassRecursively(INVALIDATING_STEP_CLASSES, traversal))
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), traversal);
  if (traversal.getStartStep().getLabels().contains(MARKER)) {
    traversal.getStartStep().removeLabel(MARKER);
    return;
  }
  ////////////////////////////////////////////////////////////////////////////
  final Collection<Pair<VertexStep, Step>> stepsToReplace = new ArrayList<>();
  Step prev = null;
  for (final Step curr : traversal.getSteps()) {
    if (isOptimizable(prev, curr)) {
      stepsToReplace.add(Pair.with((VertexStep) prev, curr));
    }
    prev = curr;
  }
  if (!stepsToReplace.isEmpty()) {
    for (final Pair<VertexStep, Step> pair : stepsToReplace) {
      optimizeSteps(traversal, pair.getValue0(), pair.getValue1());
    }
  }
}

@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
  // using a hidden label marker to denote whether the traversal should not be processed by this strategy
  if ((traversal.getParent() instanceof EmptyStep || traversal.getParent() instanceof VertexProgramStep) &&
      TraversalHelper.hasStepOfAssignableClassRecursively(INVALIDATING_STEP_CLASSES, traversal))
    TraversalHelper.applyTraversalRecursively(t -> t.getStartStep().addLabel(MARKER), traversal);
  if (traversal.getStartStep().getLabels().contains(MARKER)) {
    traversal.getStartStep().removeLabel(MARKER);
    return;
  }
  ////////////////////////////////////////////////////////////////////////////
  final Collection<Pair<VertexStep, Step>> stepsToReplace = new ArrayList<>();
  Step prev = null;
  for (final Step curr : traversal.getSteps()) {
    if (isOptimizable(prev, curr)) {
      stepsToReplace.add(Pair.with((VertexStep) prev, curr));
    }
    prev = curr;
  }
  if (!stepsToReplace.isEmpty()) {
    for (final Pair<VertexStep, Step> pair : stepsToReplace) {
      optimizeSteps(traversal, pair.getValue0(), pair.getValue1());
    }
  }
}

      (step instanceof VertexProgramStep &&
          step.getRequirements().contains(TraverserRequirement.LABELED_PATH)), traversal)) {
TraversalHelper.applyTraversalRecursively(t -> t.getEndStep().addLabel(MARKER), traversal);

Javadoc

Apply the provider Consumer function to the provided Traversal and all of its children.

Popular methods of TraversalHelper

getStepsOfClass
replaceStep
Replace a step with a new step.
getLastStepOfAssignableClass
onGraphComputer
copyLabels
getRootTraversal
getStepsOfAssignableClassRecursively
anyStepRecursively
Determine if any child step of a TraversalParent match the step given the provided Predicate.
getStepsOfAssignableClass
hasStepOfAssignableClassRecursively
Determine if the traversal has any of the supplied steps of an assignable class in the current Trave
insertAfterStep
Insert a step after a specified step instance.
removeAllSteps

Popular classes and methods

getContentResolver (Context)
getResourceAsStream (ClassLoader)
Returns a stream for the resource with the specified name. See #getResource(String) for a descriptio
Container (java.awt)
Permission (java.security)
Abstract class for representing access to a system resource. All permissions have a name (whose inte
Time (java.sql)
Java representation of an SQL TIME value. Provides utilities to format and parse the time's represen
NumberFormat (java.text)
The abstract base class for all number formats. This class provides the interface for formatting and
ArrayList (java.util)
Resizable-array implementation of the List interface.
TimeZone (java.util)
TimeZone represents a time zone, primarily used for configuring a Calendar or java.text.SimpleDateF
JTable (javax.swing)

Best code snippets using org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper.applyTraversalRecursively(Showing top 15 results out of 315)