Best Java code snippets using org.apache.tinkerpop.gremlin.process.traversal.Traversal$Admin.removeStep (Showing top 20 results out of 315)

traversal.removeStep(currentStep);

static void localFoldInHasContainer(final HasStepFolder janusgraphStep, final Step<?, ?>  tinkerpopStep, final Traversal.Admin<?, ?> traversal,
    final Traversal<?, ?> rootTraversal){
  Step<?, ?> currentStep = tinkerpopStep;
  while (true) {
    if (currentStep instanceof HasContainerHolder) {
      final Iterable<HasContainer> containers = ((HasContainerHolder) currentStep).getHasContainers().stream().map(c -> JanusGraphPredicate.Converter.convert(c)).collect(Collectors.toList());
      final List<HasContainer> hasContainers = janusgraphStep.addLocalAll(containers);
      currentStep.getLabels().forEach(janusgraphStep::addLabel);
      traversal.removeStep(currentStep);
      currentStep = foldInOrder(janusgraphStep, currentStep, traversal, rootTraversal, janusgraphStep instanceof JanusGraphStep && ((JanusGraphStep)janusgraphStep).returnsVertex(), hasContainers);
      foldInRange(janusgraphStep, currentStep, traversal, hasContainers);
    } else if (!(currentStep instanceof IdentityStep) && !(currentStep instanceof NoOpBarrierStep)) {
      break;
    }
    currentStep = currentStep.getNextStep();
  }
}

static void foldInHasContainer(final HasStepFolder janusgraphStep, final Traversal.Admin<?, ?> traversal,
    final Traversal<?, ?> rootTraversal) {
  Step<?, ?> currentStep = janusgraphStep.getNextStep();
  while (true) {
    if (currentStep instanceof OrStep && janusgraphStep instanceof JanusGraphStep) {
      for (final Traversal.Admin<?, ?> child : ((OrStep<?>) currentStep).getLocalChildren()) {
        if (!validFoldInHasContainer(child.getStartStep(), false)){
          return;
        }
      }
      ((OrStep<?>) currentStep).getLocalChildren().forEach(t ->localFoldInHasContainer(janusgraphStep, t.getStartStep(), t, rootTraversal));
      traversal.removeStep(currentStep);
    } else if (currentStep instanceof HasContainerHolder){
      final Iterable<HasContainer> containers = ((HasContainerHolder) currentStep).getHasContainers().stream().map(c -> JanusGraphPredicate.Converter.convert(c)).collect(Collectors.toList());
      if  (validFoldInHasContainer(currentStep, true)) {
        janusgraphStep.addAll(containers);
        currentStep.getLabels().forEach(janusgraphStep::addLabel);
        traversal.removeStep(currentStep);
      }
    } else if (!(currentStep instanceof IdentityStep) && !(currentStep instanceof NoOpBarrierStep) && !(currentStep instanceof HasContainerHolder)) {
      break;
    }
    currentStep = currentStep.getNextStep();
  }
}

public static <E extends Ranging> void foldInRange(final HasStepFolder titanStep, final Traversal.Admin<?, ?> traversal) {
  Step<?, ?> nextStep = TitanTraversalUtil.getNextNonIdentityStep(titanStep);
  if (nextStep instanceof RangeGlobalStep) {
    RangeGlobalStep range = (RangeGlobalStep) nextStep;
    int limit = QueryUtil.convertLimit(range.getHighRange());
    titanStep.setLimit(QueryUtil.mergeLimits(limit, titanStep.getLimit()));
    if (range.getLowRange() == 0) { //Range can be removed since there is no offset
      nextStep.getLabels().forEach(titanStep::addLabel);
      traversal.removeStep(nextStep);
    }
  }
}

  if (lastOrder != null) { //Previous orders are rendered irrelevant by next order (since re-ordered)
    lastOrder.getLabels().forEach(janusgraphStep::addLabel);
    traversal.removeStep(lastOrder);
traversal.removeStep(lastOrder);

/**
 * Replace a step with a new step.
 *
 * @param removeStep the step to remove
 * @param insertStep the step to insert
 * @param traversal  the traversal on which the action will occur
 */
public static <S, E> void replaceStep(final Step<S, E> removeStep, final Step<S, E> insertStep, final Traversal.Admin<?, ?> traversal) {
  final int i;
  traversal.removeStep(i = stepIndex(removeStep, traversal));
  traversal.addStep(i, insertStep);
}

/**
 * Remove a {@link Step} from the traversal.
 *
 * @param step the step to remove
 * @param <S2> the new start type of the traversal (if the removed step was a start step)
 * @param <E2> the new end type of the traversal (if the removed step was an end step)
 * @return the newly modulated traversal
 * @throws IllegalStateException if the {@link TraversalStrategies} have already been applied
 */
public default <S2, E2> Traversal.Admin<S2, E2> removeStep(final Step<?, ?> step) throws IllegalStateException {
  return this.removeStep(TraversalHelper.stepIndex(step, this));
}

  static void foldInRange(final HasStepFolder janusgraphStep, final Step<?, ?>  tinkerpopStep, final Traversal.Admin<?, ?> traversal, final List<HasContainer> hasContainers) {
    final Step<?, ?> nextStep = tinkerpopStep instanceof IdentityStep ? JanusGraphTraversalUtil.getNextNonIdentityStep(tinkerpopStep): tinkerpopStep;
    if (nextStep instanceof RangeGlobalStep) {
      final RangeGlobalStep range = (RangeGlobalStep) nextStep;
      int low = 0;
      if (janusgraphStep instanceof JanusGraphStep) {
        low = QueryUtil.convertLimit(range.getLowRange());
        low = QueryUtil.mergeLowLimits(low, hasContainers == null ? janusgraphStep.getLowLimit(): janusgraphStep.getLocalLowLimit(hasContainers));
      }
      int high = QueryUtil.convertLimit(range.getHighRange());
      high = QueryUtil.mergeHighLimits(high, hasContainers == null ? janusgraphStep.getHighLimit(): janusgraphStep.getLocalHighLimit(hasContainers));
      if (hasContainers == null) {
        janusgraphStep.setLimit(low, high);
      } else {
        janusgraphStep.setLocalLimit(hasContainers, low, high);
      }
      if (janusgraphStep instanceof JanusGraphStep || range.getLowRange() == 0) { //Range can be removed since there is JanusGraphStep or no offset
        nextStep.getLabels().forEach(janusgraphStep::addLabel);
        traversal.removeStep(nextStep);
      }
    }
  }
}

public static void removeAllSteps(final Traversal.Admin<?, ?> traversal) {
  final int size = traversal.getSteps().size();
  for (int i = 0; i < size; i++) {
    traversal.removeStep(0);
  }
}

public static <S, E> void removeToTraversal(final Step<S, ?> startStep, final Step<?, E> endStep, final Traversal.Admin<S, E> newTraversal) {
  final Traversal.Admin<?, ?> originalTraversal = startStep.getTraversal();
  Step<?, ?> currentStep = startStep;
  while (currentStep != endStep && !(currentStep instanceof EmptyStep)) {
    final Step<?, ?> temp = currentStep.getNextStep();
    originalTraversal.removeStep(currentStep);
    newTraversal.addStep(currentStep);
    currentStep = temp;
  }
}

@Override
public <S2, E2> Traversal.Admin<S2, E2> removeStep(final int index) throws IllegalStateException {
  return null == this.bypassTraversal ? (Traversal.Admin<S2, E2>) this : this.bypassTraversal.removeStep(index);
}

public static void extractHasContainer(HugeVertexStep<?> newStep,
                    Traversal.Admin<?, ?> traversal) {
  Step<?, ?> step = newStep;
  do {
    if (step instanceof HasStep) {
      HasContainerHolder holder = (HasContainerHolder) step;
      for (HasContainer has : holder.getHasContainers()) {
        newStep.addHasContainer(has);
      }
      TraversalHelper.copyLabels(step, step.getPreviousStep(), false);
      traversal.removeStep(step);
    }
    step = step.getNextStep();
  } while (step instanceof HasStep || step instanceof NoOpBarrierStep);
}

/**
 * Optimizes the given edge-emitting step and the vertex-emitting step by replacing them with a single
 * vertex-emitting step.
 *
 * @param traversal the traversal that holds the given steps
 * @param step1     the edge-emitting step to replace
 * @param step2     the vertex-emitting step to replace
 */
private static void optimizeSteps(final Traversal.Admin traversal, final VertexStep step1, final Step step2) {
  final Step newStep = new VertexStep(traversal, Vertex.class, step1.getDirection(), step1.getEdgeLabels());
  for (final String label : (Iterable<String>) step2.getLabels()) {
    newStep.addLabel(label);
  }
  TraversalHelper.replaceStep(step1, newStep, traversal);
  traversal.removeStep(step2);
}

private static final boolean processTraversalFilterStep(final TraversalFilterStep<?> step, final Traversal.Admin<?, ?> traversal) {
  final Traversal.Admin<?, ?> childTraversal = step.getLocalChildren().get(0);
  if (TraversalHelper.hasAllStepsOfClass(childTraversal, FilterStep.class) &&
      !TraversalHelper.hasStepOfClass(childTraversal,
          DropStep.class,
          RangeGlobalStep.class,
          DedupGlobalStep.class,
          LambdaHolder.class)) {
    TraversalHelper.applySingleLevelStrategies(traversal, childTraversal, InlineFilterStrategy.class);
    final Step<?, ?> finalStep = childTraversal.getEndStep();
    TraversalHelper.insertTraversal((Step) step, childTraversal, traversal);
    TraversalHelper.copyLabels(step, finalStep, false);
    traversal.removeStep(step);
    return true;
  }
  return false;
}

if (lastOrder != null) { //Previous orders are rendered irrelevant by next order (since re-ordered)
  lastOrder.getLabels().forEach(titanStep::addLabel);
  traversal.removeStep(lastOrder);
traversal.removeStep(lastOrder);

@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
  for (final GraphStep originalGraphStep : TraversalHelper.getStepsOfClass(GraphStep.class, traversal)) {
    final Neo4jGraphStep<?, ?> neo4jGraphStep = new Neo4jGraphStep<>(originalGraphStep);
    TraversalHelper.replaceStep(originalGraphStep, neo4jGraphStep, traversal);
    Step<?, ?> currentStep = neo4jGraphStep.getNextStep();
    while (currentStep instanceof HasStep || currentStep instanceof NoOpBarrierStep) {
      if (currentStep instanceof HasStep) {
        for (final HasContainer hasContainer : ((HasContainerHolder) currentStep).getHasContainers()) {
          if (!GraphStep.processHasContainerIds(neo4jGraphStep, hasContainer))
            neo4jGraphStep.addHasContainer(hasContainer);
        }
        TraversalHelper.copyLabels(currentStep, currentStep.getPreviousStep(), false);
        traversal.removeStep(currentStep);
      }
      currentStep = currentStep.getNextStep();
    }
  }
}

public static void extractHasContainer(HugeGraphStep<?, ?> newStep,
                    Traversal.Admin<?, ?> traversal) {
  Step<?, ?> step = newStep;
  do {
    step = step.getNextStep();
    if (step instanceof HasStep) {
      HasContainerHolder holder = (HasContainerHolder) step;
      for (HasContainer has : holder.getHasContainers()) {
        if (!GraphStep.processHasContainerIds(newStep, has)) {
          newStep.addHasContainer(has);
        }
      }
      TraversalHelper.copyLabels(step, step.getPreviousStep(), false);
      traversal.removeStep(step);
    }
  } while (step instanceof HasStep || step instanceof NoOpBarrierStep);
}

public static void foldInHasContainer(final HasStepFolder titanStep, final Traversal.Admin<?, ?> traversal) {
  Step<?, ?> currentStep = titanStep.getNextStep();
  while (true) {
    if (currentStep instanceof HasContainerHolder) {
      Iterable<HasContainer> containers = ((HasContainerHolder) currentStep).getHasContainers();
      if (validTitanHas(containers)) {
        titanStep.addAll(containers);
        currentStep.getLabels().forEach(titanStep::addLabel);
        traversal.removeStep(currentStep);
      }
    } else if (currentStep instanceof IdentityStep) {
      // do nothing, has no impact
    } else {
      break;
    }
    currentStep = currentStep.getNextStep();
  }
}

@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
  if (TraversalHelper.onGraphComputer(traversal))
    return;
  for (final GraphStep originalGraphStep : TraversalHelper.getStepsOfClass(GraphStep.class, traversal)) {
    final TinkerGraphStep<?, ?> tinkerGraphStep = new TinkerGraphStep<>(originalGraphStep);
    TraversalHelper.replaceStep(originalGraphStep, tinkerGraphStep, traversal);
    Step<?, ?> currentStep = tinkerGraphStep.getNextStep();
    while (currentStep instanceof HasStep || currentStep instanceof NoOpBarrierStep) {
      if (currentStep instanceof HasStep) {
        for (final HasContainer hasContainer : ((HasContainerHolder) currentStep).getHasContainers()) {
          if (!GraphStep.processHasContainerIds(tinkerGraphStep, hasContainer))
            tinkerGraphStep.addHasContainer(hasContainer);
        }
        TraversalHelper.copyLabels(currentStep, currentStep.getPreviousStep(), false);
        traversal.removeStep(currentStep);
      }
      currentStep = currentStep.getNextStep();
    }
  }
}

@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
  if (traversal.getSteps().size() <= 1)
    return;
  for (final IdentityStep<?> identityStep : TraversalHelper.getStepsOfClass(IdentityStep.class, traversal)) {
    if (identityStep.getLabels().isEmpty() || !(identityStep.getPreviousStep() instanceof EmptyStep)) {
      TraversalHelper.copyLabels(identityStep, identityStep.getPreviousStep(), false);
      traversal.removeStep(identityStep);
    }
  }
}