Java Scope类代码示例

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
public static <S> List<S> getStepsOfAssignableClassRecursively(final Scope scope, final Class<S> stepClass, final Traversal.Admin<?, ?> traversal) {
    final List<S> list = new ArrayList<>();
    for (final Step<?, ?> step : traversal.getSteps()) {
        if (stepClass.isAssignableFrom(step.getClass()))
            list.add((S) step);
        if (step instanceof TraversalParent) {
            if (null == scope || Scope.local.equals(scope)) {
                for (final Traversal.Admin<?, ?> localChild : ((TraversalParent) step).getLocalChildren()) {
                    list.addAll(TraversalHelper.getStepsOfAssignableClassRecursively(stepClass, localChild));
                }
            }
            if (null == scope || Scope.global.equals(scope)) {
                for (final Traversal.Admin<?, ?> globalChild : ((TraversalParent) step).getGlobalChildren()) {
                    list.addAll(TraversalHelper.getStepsOfAssignableClassRecursively(stepClass, globalChild));
                }
            }
        }
    }
    return list;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
/**
 * Determine if the traversal has a step of an assignable class in the current {@link Traversal} and its
 * {@link Scope} child traversals.
 *
 * @param scope     the child traversal scope to check
 * @param stepClass the step class to look for
 * @param traversal the traversal in which to look for the given step class
 * @return <code>true</code> if any step in the given traversal (and its child traversals) is an instance of the
 * given <code>stepClass</code>, otherwise <code>false</code>.
 */
public static boolean hasStepOfAssignableClassRecursively(final Scope scope, final Class stepClass, final Traversal.Admin<?, ?> traversal) {
    for (final Step<?, ?> step : traversal.getSteps()) {
        if (stepClass.isAssignableFrom(step.getClass())) {
            return true;
        }
        if (step instanceof TraversalParent) {
            if (null == scope || Scope.local.equals(scope)) {
                for (final Traversal.Admin<?, ?> localChild : ((TraversalParent) step).getLocalChildren()) {
                    if (hasStepOfAssignableClassRecursively(stepClass, localChild)) return true;
                }
            }
            if (null == scope || Scope.global.equals(scope)) {
                for (final Traversal.Admin<?, ?> globalChild : ((TraversalParent) step).getGlobalChildren()) {
                    if (hasStepOfAssignableClassRecursively(stepClass, globalChild)) return true;
                }
            }
        }
    }
    return false;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> data() {
    return Arrays.asList(new Object[][]{
            {"filter(x->true)", __.filter(x -> true), false},
            {"map(Traverser::get)", __.map(Traverser::get), false},
            {"sideEffect(x -> {int i = 1+1;})", __.sideEffect(x -> {
                int i = 1 + 1;
            }), false},
            {"select('a','b').by(Object::toString)", __.select("a", "b").by(Object::toString), false},
            {"order().by((a,b)->a.compareTo(b))", __.order().by((a, b) -> ((Integer) a).compareTo((Integer) b)), false},
            {"order(local).by((a,b)->a.compareTo(b))", __.order(Scope.local).by((a, b) -> ((Integer) a).compareTo((Integer) b)), false},
            {"__.choose(v->v.toString().equals(\"marko\"),__.out(),__.in())", __.choose(v -> v.toString().equals("marko"), __.out(), __.in()), false},
            {"order(local).by(values,decr)", __.order(Scope.local).by(Column.values, (a, b) -> ((Double) a).compareTo((Double) b)), false},
            //
            {"order(local).by(values,decr)", __.order(Scope.local).by(Column.values, Order.decr), true},
            {"order().by(label,decr)", __.order().by(T.label, Order.decr), true},
            {"groupCount().by(label)", __.groupCount().by(T.label), true},
    });
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
public static boolean isLegal(final Traversal.Admin<?, ?> traversal) {
    final Step<?, ?> startStep = traversal.getStartStep();
    final Step<?, ?> endStep = traversal.getEndStep();
    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);
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
@Override
public void apply(final Traversal.Admin<?, ?> traversal) {
    final Graph graph = traversal.getGraph().orElse(EmptyGraph.instance()); // best guess at what the graph will be as its dynamically determined
    for (final TraversalVertexProgramStep step : TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, traversal)) {
        final Traversal.Admin<?, ?> computerTraversal = step.generateProgram(graph, EmptyMemory.instance()).getTraversal().get().clone();
        if (!computerTraversal.isLocked())
            computerTraversal.applyStrategies();
        boolean doesMessagePass = TraversalHelper.hasStepOfAssignableClassRecursively(Scope.global, MULTI_ITERATION_CLASSES, computerTraversal);
        if (!doesMessagePass) {
            for (final VertexStep vertexStep : TraversalHelper.getStepsOfAssignableClassRecursively(Scope.global, VertexStep.class, computerTraversal)) {
                if (vertexStep.returnsVertex() || !vertexStep.getDirection().equals(Direction.OUT)) { // in-edges require message pass in OLAP
                    doesMessagePass = true;
                    break;
                }
            }
        }
        if (!doesMessagePass) {
            step.setComputer(step.getComputer()
                    // if no message passing, don't partition the loaded graph
                    .configure(Constants.GREMLIN_SPARK_SKIP_PARTITIONER, true)
                            // if no message passing, don't cache the loaded graph
                    .configure(Constants.GREMLIN_SPARK_SKIP_GRAPH_CACHE, true));
        }
    }
}
 

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

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
@Test
public void g_V_asXaX_out_asXaX_out_asXaX_selectXaX_byXunfold_valuesXnameX_foldX_rangeXlocal_1_2X() throws IOException {
    loadModern();
    Graph g = this.sqlgGraph;
    assertModernGraph(g, true, false);
    DefaultGraphTraversal<Vertex, String> traversal = (DefaultGraphTraversal) g.traversal()
            .V().as("a")
            .out().as("a")
            .out().as("a")
            .<List<String>>select(Pop.all, "a")
            .by(__.unfold().values("name").fold())
            .range(Scope.local, 1, 2);
    Assert.assertEquals(5, traversal.getSteps().size());
    int counter = 0;
    while (traversal.hasNext()) {
        final String s = traversal.next();
        Assert.assertEquals("josh", s);
        counter++;
    }
    Assert.assertEquals(2, counter);
    Assert.assertEquals(3, traversal.getSteps().size());
}
 

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

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
@Override
protected List<Traversal> getTraversals() {
    return Arrays.asList(
            __.sample(Scope.local, 5),
            __.sample(Scope.local, 10)
    );
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
@Test
public void shouldSelectSubsetsCorrectly() {
    final List<Integer> list = new ArrayList<>();
    for (int i = 0; i < 100; i++) {
        list.add(i);
    }
    for(int i=0; i<100; i++) {
        List<Integer> result;
        result = __.inject(list).sample(Scope.local, i).next();
        assertEquals(i, result.size());
        assertEquals(i, new HashSet<>(result).size());
        assertTrue(list.containsAll(result));
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
@Test
public void testReturnTypes() {
    assertEquals(3d, __.__(2, 4).fold().mean(Scope.local).next());
    assertEquals(3d, __.__((short) 2, (short) 4).fold().mean(Scope.local).next()); // why? because the internal counter is a Long value
    assertEquals(BigDecimal.ONE, __.__(BigInteger.ONE, BigInteger.ONE).fold().mean(Scope.local).next());
    assertEquals(BigDecimal.ONE, __.__((short) 1, BigInteger.ONE).fold().mean(Scope.local).next());
    assertEquals(BigDecimal.ONE, __.__(BigInteger.ONE, (short) 1).fold().mean(Scope.local).next());
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
@Override
protected List<Traversal> getTraversals() {
    return Arrays.asList(
            __.limit(Scope.local, 10L),
            __.range(Scope.local, 1L, 10L)
    );
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
@Override
protected List<Traversal> getTraversals() {
    return Arrays.asList(
            __.order(Scope.local),
            __.order(Scope.local).by(Order.decr),
            __.order(Scope.local).by("age", Order.incr),
            __.order(Scope.local).by("age", Order.decr),
            __.order(Scope.local).by(outE().count(), Order.incr),
            __.order(Scope.local).by("age", Order.incr).by(outE().count(), Order.incr),
            __.order(Scope.local).by(outE().count(), Order.incr).by("age", Order.incr)
    );
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
@Test
public void shouldNotThrowContractException() {
    for (int x = 0; x < 1000; x++) {
        final List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            list.add(i);
        }
        __.inject(list).order(Scope.local).by(Order.shuffle).iterate();
        __.inject(list).order(Scope.local).by().by(Order.shuffle).iterate();
        __.inject(list).order(Scope.local).by(Order.shuffle).by().iterate();
        __.inject(list).order(Scope.local).by(__.identity(), Order.shuffle).iterate();
        __.inject(list).order(Scope.local).by().by(__.identity(), Order.shuffle).iterate();
        __.inject(list).order(Scope.local).by(__.identity(), Order.shuffle).by().iterate();
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Scope; //导入依赖的package包/类
@Override
protected List<Traversal> getTraversals() {
    return Arrays.asList(
            __.tail(Scope.local, 5L),
            __.tail(Scope.local, 10L)
    );
}