import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
    if (!(traversal.getParent() instanceof EmptyStep) || TraversalHelper.onGraphComputer(traversal))
        return;
    final List<Step> steps = traversal.getSteps();
    if (steps.size() < 2 ||
            !(steps.get(0) instanceof GraphStep) ||
            0 != ((GraphStep) steps.get(0)).getIds().length ||
            !(steps.get(steps.size() - 1) instanceof CountGlobalStep))
        return;
    for (int i = 1; i < steps.size() - 1; i++) {
        final Step current = steps.get(i);
        if (!(current instanceof MapStep ||
                current instanceof IdentityStep ||
                current instanceof NoOpBarrierStep ||
                current instanceof CollectingBarrierStep) ||
                (current instanceof TraversalParent &&
                        TraversalHelper.anyStepRecursively(s -> (s instanceof SideEffectStep || s instanceof AggregateStep), (TraversalParent) current)))
            return;
    }
    final Class<? extends Element> elementClass = ((GraphStep<?, ?>) steps.get(0)).getReturnClass();
    TraversalHelper.removeAllSteps(traversal);
    traversal.addStep(new TinkerCountGlobalStep<>(traversal, elementClass));
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
private String determineStartLabelForHasPullOut(final MatchStep<?, ?> matchStep) {
    if (!(matchStep.getTraversal().getParent() instanceof EmptyStep))
        return null;
    else {
        final String startLabel = MatchStep.Helper.computeStartLabel(matchStep.getGlobalChildren());
        Step<?, ?> previousStep = matchStep.getPreviousStep();
        if (previousStep.getLabels().contains(startLabel))
            return startLabel;
        while (!(previousStep instanceof EmptyStep)) {
            if (!previousStep.getLabels().isEmpty())
                return null;
            previousStep = previousStep.getPreviousStep();
        }
        return startLabel;
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
private List<PropertyFetcher> getAllPropertyFetchersOf(Step step, Traversal.Admin<?, ?> traversal) {
    List<PropertyFetcher> propertyFetchers = new ArrayList<>();
    Step previous = step.getPreviousStep();
    while (!(previous instanceof EmptyStep)) {
        if (previous instanceof PropertyFetcher)
            propertyFetchers.add((PropertyFetcher) previous);
        if (previous instanceof TraversalParent) {
            ((TraversalParent) previous).getLocalChildren()
                    .forEach(t -> t.getSteps().stream()
                            .filter(s -> s instanceof PropertyFetcher)
                            .map(p -> ((PropertyFetcher) p)).forEach(propertyFetchers::add));
            ((TraversalParent) previous).getGlobalChildren()
                    .forEach(t -> t.getSteps().stream()
                            .filter(s -> s instanceof PropertyFetcher)
                            .map(p -> ((PropertyFetcher) p)).forEach(propertyFetchers::add));
        }
        previous = previous.getPreviousStep();
    }
    return propertyFetchers;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
public static Set<String> getReferencedLabels(final Step step) {
    final Set<String> referencedLabels = new HashSet<>();

    if (step instanceof Scoping) {
        final Set<String> labels = new HashSet<>(((Scoping) step).getScopeKeys());
        if (step instanceof MatchStep) {
            // if this is the last step, keep everything, else just add founds
            if (step.getNextStep() instanceof EmptyStep) {
                labels.addAll(((MatchStep) step).getMatchEndLabels());
                labels.addAll(((MatchStep) step).getMatchStartLabels());
            }
        }
        referencedLabels.addAll(labels);

    }

    return referencedLabels;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
@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));
        }
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
@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());
        }
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
@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;
            }
        }
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
private static final char processesPropertyType(Step step) {
    while (!(step instanceof EmptyStep)) {
        if (step instanceof FilterStep || step instanceof SideEffectStep)
            step = step.getPreviousStep();
        else if (step instanceof GraphStep && ((GraphStep) step).returnsVertex())
            return 'v';
        else if (step instanceof EdgeVertexStep)
            return 'v';
        else if (step instanceof VertexStep)
            return ((VertexStep) step).returnsVertex() ? 'v' : 'p';
        else if (step instanceof PropertyMapStep || step instanceof PropertiesStep)
            return 'p';
        else
            return 'x';
    }
    return 'x';
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
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;
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
public static boolean isGlobalChild(Traversal.Admin<?, ?> traversal) {
    while (!(traversal.getParent() instanceof EmptyStep)) {
        if (traversal.getParent().getLocalChildren().contains(traversal))
            return false;
        traversal = traversal.getParent().asStep().getTraversal();
    }
    return true;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
public static void reIdSteps(final StepPosition stepPosition, final Traversal.Admin<?, ?> traversal) {
    stepPosition.x = 0;
    stepPosition.y = -1;
    stepPosition.z = -1;
    stepPosition.parentId = null;
    Traversal.Admin<?, ?> current = traversal;
    while (!(current instanceof EmptyTraversal)) {
        stepPosition.y++;
        final TraversalParent parent = current.getParent();
        if (null == stepPosition.parentId && !(parent instanceof EmptyStep))
            stepPosition.parentId = parent.asStep().getId();
        if (-1 == stepPosition.z) {
            final int globalChildrenSize = parent.getGlobalChildren().size();
            for (int i = 0; i < globalChildrenSize; i++) {
                if (parent.getGlobalChildren().get(i) == current) {
                    stepPosition.z = i;
                }
            }
            for (int i = 0; i < parent.getLocalChildren().size(); i++) {
                if (parent.getLocalChildren().get(i) == current) {
                    stepPosition.z = i + globalChildrenSize;
                }
            }
        }
        current = parent.asStep().getTraversal();
    }
    if (-1 == stepPosition.z) stepPosition.z = 0;
    if (null == stepPosition.parentId) stepPosition.parentId = "";
    for (final Step<?, ?> step : traversal.getSteps()) {
        step.setId(stepPosition.nextXId());
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
public static boolean onGraphComputer(Traversal.Admin<?, ?> traversal) {
    while (!(traversal.getParent() instanceof EmptyStep)) {
        if (traversal.getParent().asStep() instanceof TraversalVertexProgramStep)
            return true;
        traversal = traversal.getParent().asStep().getTraversal();
    }
    return false;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
@Override
public TraverserGenerator getTraverserGenerator() {
    if (null == this.generator)
        this.generator = (this.parent instanceof EmptyStep) ?
                DefaultTraverserGeneratorFactory.instance().getTraverserGenerator(this.getTraverserRequirements()) :
                TraversalHelper.getRootTraversal(this).getTraverserGenerator();
    return this.generator;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
@Override
public void applyStrategies() throws IllegalStateException {
    if (this.locked) throw Traversal.Exceptions.traversalIsLocked();
    TraversalHelper.reIdSteps(this.stepPosition, this);
    this.strategies.applyStrategies(this);
    boolean hasGraph = null != this.graph;
    for (final Step<?, ?> step : this.getSteps()) {
        if (step instanceof TraversalParent) {
            for (final Traversal.Admin<?, ?> globalChild : ((TraversalParent) step).getGlobalChildren()) {
                globalChild.setStrategies(this.strategies);
                globalChild.setSideEffects(this.sideEffects);
                if (hasGraph) globalChild.setGraph(this.graph);
                globalChild.applyStrategies();
            }
            for (final Traversal.Admin<?, ?> localChild : ((TraversalParent) step).getLocalChildren()) {
                localChild.setStrategies(this.strategies);
                localChild.setSideEffects(this.sideEffects);
                if (hasGraph) localChild.setGraph(this.graph);
                localChild.applyStrategies();
            }
        }
    }
    this.finalEndStep = this.getEndStep();
    // finalize requirements
    if (this.getParent() instanceof EmptyStep) {
        this.requirements = null;
        this.getTraverserRequirements();
    }
    this.locked = true;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
@Override
public <S2, E2> Traversal.Admin<S2, E2> addStep(final int index, final Step<?, ?> step) throws IllegalStateException {
    if (this.locked) throw Exceptions.traversalIsLocked();
    step.setId(this.stepPosition.nextXId());
    this.steps.add(index, step);
    final Step previousStep = this.steps.size() > 0 && index != 0 ? steps.get(index - 1) : null;
    final Step nextStep = this.steps.size() > index + 1 ? steps.get(index + 1) : null;
    step.setPreviousStep(null != previousStep ? previousStep : EmptyStep.instance());
    step.setNextStep(null != nextStep ? nextStep : EmptyStep.instance());
    if (null != previousStep) previousStep.setNextStep(step);
    if (null != nextStep) nextStep.setPreviousStep(step);
    step.setTraversal(this);
    return (Traversal.Admin<S2, E2>) this;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
@Override
public <S2, E2> Traversal.Admin<S2, E2> removeStep(final int index) throws IllegalStateException {
    if (this.locked) throw Exceptions.traversalIsLocked();
    final Step previousStep = this.steps.size() > 0 && index != 0 ? steps.get(index - 1) : null;
    final Step nextStep = this.steps.size() > index + 1 ? steps.get(index + 1) : null;
    //this.steps.get(index).setTraversal(EmptyTraversal.instance());
    this.steps.remove(index);
    if (null != previousStep) previousStep.setNextStep(null == nextStep ? EmptyStep.instance() : nextStep);
    if (null != nextStep) nextStep.setPreviousStep(null == previousStep ? EmptyStep.instance() : previousStep);
    return (Traversal.Admin<S2, E2>) this;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
public static Set<String> getReferencedLabelsAfterStep(Step<?, ?> step) {
    final Set<String> labels = new HashSet<>();
    while (!(step instanceof EmptyStep)) {
        labels.addAll(PathUtil.getReferencedLabels(step));
        step = step.getNextStep();
    }
    return labels;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
public static Set<String> getReferencedLabels(final Step step) {
    final Set<String> referencedLabels = new HashSet<>();

    if (step instanceof Parameterizing) { // TODO: we should really make the mutation steps Scoping :|
        final Parameters parameters = ((Parameterizing) step).getParameters();
        for (final Traversal.Admin trav : parameters.getTraversals()) {
            for (final Object ss : trav.getSteps()) {
                if (ss instanceof Scoping) {
                    for (String label : ((Scoping) ss).getScopeKeys()) {
                        referencedLabels.add(label);
                    }
                }
            }
        }
    }

    if (step instanceof Scoping) {
        final Set<String> labels = new HashSet<>(((Scoping) step).getScopeKeys());
        if (step instanceof MatchStep) {
            // if this is the last step, keep everything, else just add founds
            if (step.getNextStep() instanceof EmptyStep) {
                labels.addAll(((MatchStep) step).getMatchEndLabels());
                labels.addAll(((MatchStep) step).getMatchStartLabels());
            }
        }
        referencedLabels.addAll(labels);

    }

    return referencedLabels;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
    if (traversal.getSteps().size() <= 1 || !TraversalHelper.hasStepOfClass(IdentityStep.class, traversal))
        return;

    TraversalHelper.getStepsOfClass(IdentityStep.class, traversal).stream().forEach(identityStep -> {
        final Step<?, ?> previousStep = identityStep.getPreviousStep();
        if (!(previousStep instanceof EmptyStep) || identityStep.getLabels().isEmpty()) {
            ((IdentityStep<?>) identityStep).getLabels().forEach(previousStep::addLabel);
            traversal.removeStep(identityStep);
        }
    });
}
 

import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; //导入依赖的package包/类
protected boolean previousTraversalVertexProgram() {
    Step<?, ?> currentStep = this;
    while (!(currentStep instanceof EmptyStep)) {
        if (currentStep instanceof TraversalVertexProgramStep)
            return true;
        currentStep = currentStep.getPreviousStep();
    }
    return false;
}