import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Override
public JSONObject projectTraverser(final Traverser.Admin<Path> traverser) {
    final JSONObject root = new JSONObject();
    JSONObject currentNode = root;
    for (final Object object : traverser.get()) {
        if (object instanceof Map) {
            for(final Map.Entry entry : (Set<Map.Entry>)((Map)object).entrySet()) {
                if(entry.getKey().equals(T.id))
                    currentNode.put(T.id.getAccessor(),entry.getValue());
                else if(entry.getKey().equals(T.label))
                    currentNode.put(T.label.getAccessor(),entry.getValue());
                else
                    currentNode.put(entry.getKey(),entry.getValue());
            }
        }
        else if (object instanceof String)
            currentNode.put(object, currentNode = new JSONObject());
    }
    return root;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
protected DetachedPath(final Path path, final boolean withProperties) {
    path.forEach((object, labels) -> {
        if (object instanceof DetachedElement || object instanceof DetachedProperty || object instanceof DetachedPath) {
            this.objects.add(object);
            this.labels.add(labels);
        } else if (object instanceof Element) {
            this.objects.add(DetachedFactory.detach((Element) object, withProperties));
            this.labels.add(labels);
        } else if (object instanceof Property) {
            this.objects.add(DetachedFactory.detach((Property) object));
            this.labels.add(labels);
        } else if (object instanceof Path) {
            this.objects.add(DetachedFactory.detach((Path) object, withProperties));
            this.labels.add(labels);
        } else {
            this.objects.add(object);
            this.labels.add(labels);
        }
    });
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
protected ReferencePath(final Path path) {
    path.forEach((object, labels) -> {
        if (object instanceof ReferenceElement || object instanceof ReferenceProperty || object instanceof ReferencePath) {
            this.objects.add(object);
            this.labels.add(new HashSet<>(labels));
        } else if (object instanceof Element) {
            this.objects.add(ReferenceFactory.detach((Element) object));
            this.labels.add(new HashSet<>(labels));
        } else if (object instanceof Property) {
            this.objects.add(ReferenceFactory.detach((Property) object));
            this.labels.add(new HashSet<>(labels));
        } else if (object instanceof Path) {
            this.objects.add(ReferenceFactory.detach((Path) object));
            this.labels.add(new HashSet<>(labels));
        } else {
            this.objects.add(object);
            this.labels.add(new HashSet<>(labels));
        }
    });
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
public void g_V_optionalXout_optionalXoutXX_path() {
    final Traversal<Vertex, Path> traversal = get_g_V_optionalXout_optionalXoutXX_path();
    printTraversalForm(traversal);
    List<Path> paths = traversal.toList();
    assertEquals(10, paths.size());
    List<Predicate<Path>> pathsToAssert = Arrays.asList(
            p -> p.size() == 2 && p.get(0).equals(convertToVertex(this.graph, "marko")) && p.get(1).equals(convertToVertex(this.graph, "lop")),
            p -> p.size() == 2 && p.get(0).equals(convertToVertex(this.graph, "marko")) && p.get(1).equals(convertToVertex(this.graph, "vadas")),
            p -> p.size() == 3 && p.get(0).equals(convertToVertex(this.graph, "marko")) && p.get(1).equals(convertToVertex(this.graph, "josh")) && p.get(2).equals(convertToVertex(this.graph, "lop")),
            p -> p.size() == 3 && p.get(0).equals(convertToVertex(this.graph, "marko")) && p.get(1).equals(convertToVertex(this.graph, "josh")) && p.get(2).equals(convertToVertex(this.graph, "ripple")),
            p -> p.size() == 1 && p.get(0).equals(convertToVertex(this.graph, "vadas")),
            p -> p.size() == 1 && p.get(0).equals(convertToVertex(this.graph, "lop")),
            p -> p.size() == 2 && p.get(0).equals(convertToVertex(this.graph, "josh")) && p.get(1).equals(convertToVertex(this.graph, "lop")),
            p -> p.size() == 2 && p.get(0).equals(convertToVertex(this.graph, "josh")) && p.get(1).equals(convertToVertex(this.graph, "ripple")),
            p -> p.size() == 1 && p.get(0).equals(convertToVertex(this.graph, "ripple")),
            p -> p.size() == 2 && p.get(0).equals(convertToVertex(this.graph, "peter")) && p.get(1).equals(convertToVertex(this.graph, "lop"))
    );
    for (Predicate<Path> pathPredicate : pathsToAssert) {
        Optional<Path> path = paths.stream().filter(pathPredicate).findAny();
        assertTrue(path.isPresent());
        assertTrue(paths.remove(path.get()));
    }
    assertTrue(paths.isEmpty());
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Override
public Registration getRegistration(final Class clazz) {
    // force all instances of Vertex, Edge, VertexProperty, etc. to their respective interface
    final Class type;
    if (!ReferenceVertex.class.isAssignableFrom(clazz) && !DetachedVertex.class.isAssignableFrom(clazz) && Vertex.class.isAssignableFrom(clazz))
        type = Vertex.class;
    else if (!ReferenceEdge.class.isAssignableFrom(clazz) && !DetachedEdge.class.isAssignableFrom(clazz) && Edge.class.isAssignableFrom(clazz))
        type = Edge.class;
    else if (!ReferenceVertexProperty.class.isAssignableFrom(clazz) && !DetachedVertexProperty.class.isAssignableFrom(clazz) && VertexProperty.class.isAssignableFrom(clazz))
        type = VertexProperty.class;
    else if (!ReferenceProperty.class.isAssignableFrom(clazz) && !DetachedProperty.class.isAssignableFrom(clazz) && !DetachedVertexProperty.class.isAssignableFrom(clazz) && Property.class.isAssignableFrom(clazz))
        type = Property.class;
    else if (!ReferencePath.class.isAssignableFrom(clazz) && !DetachedPath.class.isAssignableFrom(clazz) && Path.class.isAssignableFrom(clazz))
        type = Path.class;
    else
        type = clazz;

    if (type == memoizedClass) return memoizedClassValue;
    final Registration registration = classToRegistration.get(type);
    if (registration != null) {
        memoizedClass = type;
        memoizedClassValue = registration;
    }

    return registration;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
public void g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path() {
    final Traversal<Vertex, Path> traversal = get_g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path(convertToVertexId("marko"));
    printTraversalForm(traversal);
    int counter = 0;
    while (traversal.hasNext()) {
        counter++;
        final Path path = traversal.next();
        if (path.get("a").equals("daniel")) {
            assertEquals(2, path.size());
            assertEquals(6, (int) path.get(1));
        } else {
            assertEquals(4, path.size());
            assertEquals(path.<String>get("a").length(), (int) path.get(3));
        }
    }
    assertEquals(4, counter);
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
private boolean hasMatched(final ConnectiveStep.Connective connective, final Traverser.Admin<S> traverser) {
    int counter = 0;
    boolean matched = false;
    for (final Traversal.Admin<Object, Object> matchTraversal : this.matchTraversals) {
        if (traverser.getTags().contains(matchTraversal.getStartStep().getId())) {
            if (connective == ConnectiveStep.Connective.OR) {
                matched = true;
                break;
            }
            counter++;
        }
    }
    if (!matched)
        matched = this.matchTraversals.size() == counter;
    if (matched && this.dedupLabels != null) {
        final Path path = traverser.path();
        final List<Object> objects = new ArrayList<>(this.dedupLabels.size());
        for (final String label : this.dedupLabels) {
            objects.add(path.get(Pop.last, label));
        }
        this.dedups.add(objects);
    }
    return matched;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Override
protected Traverser.Admin<Object> processNextStart() throws NoSuchElementException {
    if (null == this.parent)
        this.parent = ((MatchStep) this.getTraversal().getParent().asStep());

    while (true) {
        final Traverser.Admin traverser = this.starts.next();
        // no end label
        if (null == this.matchKey) {
            // if (this.traverserStepIdAndLabelsSetByChild) -- traverser equality is based on stepId, lets ensure they are all at the parent
            traverser.setStepId(this.parent.getId());
            this.parent.getMatchAlgorithm().recordEnd(traverser, this.getTraversal());
            return this.retractUnnecessaryLabels(traverser);
        }
        // TODO: sideEffect check?
        // path check
        final Path path = traverser.path();
        if (!path.hasLabel(this.matchKey) || traverser.get().equals(path.get(Pop.last, this.matchKey))) {
            // if (this.traverserStepIdAndLabelsSetByChild) -- traverser equality is based on stepId and thus, lets ensure they are all at the parent
            traverser.setStepId(this.parent.getId());
            traverser.addLabels(this.matchKeyCollection);
            this.parent.getMatchAlgorithm().recordEnd(traverser, this.getTraversal());
            return this.retractUnnecessaryLabels(traverser);
        }
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Override
protected S map(final Traverser.Admin<S> traverser) {
    // We may consider optimizing the iteration of these containers using subtype-specific interfaces.  For
    // example, we could use descendingIterator if we have a Deque.  But in general, we cannot reliably iterate a
    // collection in reverse, so we use the range algorithm with dynamically computed boundaries.
    final S start = traverser.get();
    final long high =
            start instanceof Map ? ((Map) start).size() :
                    start instanceof Collection ? ((Collection) start).size() :
                            start instanceof Path ? ((Path) start).size() :
                                    start instanceof Iterable ? IteratorUtils.count((Iterable) start) :
                                            this.limit;
    final long low = high - this.limit;
    final S result = RangeLocalStep.applyRange(start, low, high);
    return result;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
public void g_V_asXaX_outXcreatedX_asXbX_inXcreatedX_asXcX_dedupXa_bX_path() {
    final Traversal<Vertex, Path> traversal = get_g_V_asXaX_outXcreatedX_asXbX_inXcreatedX_asXcX_dedupXa_bX_path();
    printTraversalForm(traversal);
    int counter = 0;
    final Set<List<Vertex>> results = new HashSet<>();
    while (traversal.hasNext()) {
        final Path path = traversal.next();
        assertEquals(3, path.size());
        assertTrue(results.add(Arrays.asList(path.get("a"), path.get("b"))));
        counter++;
    }
    assertEquals(4, counter);
    assertEquals(4, results.size());
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
public void g_V_hasLabelXpersonX_optionalXoutXknowsX_optionalXoutXcreatedXXX_path() {
    final Traversal<Vertex, Path> traversal = get_g_V_hasLabelXpersonX_optionalXoutXknowsX_optionalXoutXcreatedXXX_path();
    printTraversalForm(traversal);
    List<Path> paths = traversal.toList();
    assertEquals(6, paths.size());
    List<Predicate<Path>> pathsToAssert = Arrays.asList(
            p -> p.size() == 2 && p.get(0).equals(convertToVertex(this.graph, "marko")) && p.get(1).equals(convertToVertex(this.graph, "vadas")),
            p -> p.size() == 3 && p.get(0).equals(convertToVertex(this.graph, "marko")) && p.get(1).equals(convertToVertex(this.graph, "josh")) && p.get(2).equals(convertToVertex(this.graph, "ripple")),
            p -> p.size() == 3 && p.get(0).equals(convertToVertex(this.graph, "marko")) && p.get(1).equals(convertToVertex(this.graph, "josh")) && p.get(2).equals(convertToVertex(this.graph, "lop")),
            p -> p.size() == 1 && p.get(0).equals(convertToVertex(this.graph, "vadas")),
            p -> p.size() == 1 && p.get(0).equals(convertToVertex(this.graph, "josh")),
            p -> p.size() == 1 && p.get(0).equals(convertToVertex(this.graph, "peter"))
    );
    for (Predicate<Path> pathPredicate : pathsToAssert) {
        Optional<Path> path = paths.stream().filter(pathPredicate).findAny();
        assertTrue(path.isPresent());
        assertTrue(paths.remove(path.get()));
    }
    assertTrue(paths.isEmpty());
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Override
public Path retract(final Set<String> labels) {
    if (labels.isEmpty())
        return this;

    // get all the immutable path sections
    final List<ImmutablePath> immutablePaths = new ArrayList<>();
    ImmutablePath currentPathSection = this;
    while (true) {
        immutablePaths.add(0, currentPathSection);
        if (currentPathSection.previousPath instanceof TailPath)
            break;
        else
            currentPathSection = (ImmutablePath) currentPathSection.previousPath;
    }
    // build a new immutable path using the respective path sections that are not to be retracted
    Path newPath = TailPath.instance();
    for (final ImmutablePath immutablePath : immutablePaths) {
        final Set<String> temp = new LinkedHashSet<>(immutablePath.currentLabels);
        temp.removeAll(labels);
        if (!temp.isEmpty())
            newPath = newPath.extend(immutablePath.currentObject, temp);
    }
    return newPath;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Override
public <A> A get(final Pop pop, final String label) {
    if (Pop.all == pop) {
        // Recursively build the list to avoid building objects/labels collections.
        final List<A> list = this.previousPath.get(Pop.all, label);
        // Add our object, if our step labels match.
        if (this.currentLabels.contains(label))
            list.add((A) currentObject);
        return (A) list;
    } else {
        // Delegate to the non-throwing, optimized head/tail calculations.
        final A single = Pop.first == pop ? this.getSingleTail(label) : this.getSingleHead(label);
        // Throw if we didn't find the label.
        if (null == single)
            throw Path.Exceptions.stepWithProvidedLabelDoesNotExist(label);
        return single;
    }
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Override
public boolean equals(final Object other) {
    if (!(other instanceof Path))
        return false;
    final Path otherPath = (Path) other;
    int size = this.size();
    if (otherPath.size() != size)
        return false;
    if (size > 0) {
        ImmutablePath currentPathSection = this;
        final List<Object> otherObjects = otherPath.objects();
        final List<Set<String>> otherLabels = otherPath.labels();
        for (int i = otherLabels.size() - 1; i >= 0; i--) {
            if (!currentPathSection.currentObject.equals(otherObjects.get(i)))
                return false;
            if (!currentPathSection.currentLabels.equals(otherLabels.get(i)))
                return false;
            if (currentPathSection.previousPath instanceof TailPath)
                break;
            else
                currentPathSection = (ImmutablePath) currentPathSection.previousPath;
        }
    }
    return true;
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
private static void assertPath(final Traversal<Vertex, Path> traversal) {
    int path1 = 0;
    int path2 = 0;
    int path3 = 0;
    while (traversal.hasNext()) {
        final Path path = traversal.next();
        if (path.size() == 1) {
            path1++;
        } else if (path.size() == 2) {
            path2++;
        } else if (path.size() == 3) {
            path3++;
        } else {
            fail("Only path lengths of 1, 2, or 3 should be seen");
        }
    }
    assertEquals(6, path1);
    assertEquals(6, path2);
    assertEquals(2, path3);
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
public void g_VX1X_out_path_byXageX_byXnameX() {
    final Traversal<Vertex, Path> traversal = get_g_VX1X_out_path_byXageX_byXnameX(convertToVertexId("marko"));
    printTraversalForm(traversal);
    int counter = 0;
    final Set<String> names = new HashSet<>();
    while (traversal.hasNext()) {
        counter++;
        final Path path = traversal.next();
        assertEquals(Integer.valueOf(29), path.<Integer>get(0));
        assertTrue(path.get(1).equals("josh") || path.get(1).equals("vadas") || path.get(1).equals("lop"));
        names.add(path.get(1));
    }
    assertEquals(3, counter);
    assertEquals(3, names.size());
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
public void g_V_repeatXoutX_timesX2X_path_byXitX_byXnameX_byXlangX() {
    final Traversal<Vertex, Path> traversal = get_g_V_repeatXoutX_timesX2X_path_by_byXnameX_byXlangX();
    printTraversalForm(traversal);
    int counter = 0;
    while (traversal.hasNext()) {
        counter++;
        final Path path = traversal.next();
        assertEquals(3, path.size());
        assertEquals("marko", ((Vertex) path.get(0)).<String>value("name"));
        assertEquals("josh", path.<String>get(1));
        assertEquals("java", path.<String>get(2));
    }
    assertEquals(2, counter);
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
public void g_V_out_out_path_byXnameX_byXageX() {
    final Traversal<Vertex, Path> traversal = get_g_V_out_out_path_byXnameX_byXageX();
    printTraversalForm(traversal);
    int counter = 0;
    while (traversal.hasNext()) {
        counter++;
        final Path path = traversal.next();
        assertEquals(3, path.size());
        assertEquals("marko", path.<String>get(0));
        assertEquals(Integer.valueOf(32), path.<Integer>get(1));
        assertTrue(path.get(2).equals("lop") || path.get(2).equals("ripple"));
    }
    assertEquals(2, counter);
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
@Test
@LoadGraphWith(MODERN)
public void g_V_repeatXoutX_timesX2X_emit_path() {
    final List<Traversal<Vertex, Path>> traversals = new ArrayList<>();
    traversals.add(get_g_V_repeatXoutX_timesX2X_emit_path());
    traversals.forEach(traversal -> {
        printTraversalForm(traversal);
        final Map<Integer, Long> pathLengths = new HashMap<>();
        int counter = 0;
        while (traversal.hasNext()) {
            counter++;
            MapHelper.incr(pathLengths, traversal.next().size(), 1l);
        }
        assertEquals(2, pathLengths.size());
        assertEquals(8, counter);
        assertEquals(new Long(6), pathLengths.get(2));
        assertEquals(new Long(2), pathLengths.get(3));
    });
}
 

import org.apache.tinkerpop.gremlin.process.traversal.Path; //导入依赖的package包/类
public void displayGraph()
{
  Long c;
  c = g.V().count().next();
  System.out.println("Graph contains " + c + " vertices");
  c = g.E().count().next();
  System.out.println("Graph contains " + c + " edges");

  List<Path> edges = g.V().outE().inV().path().by("name").by().toList();

  for (Path p : edges)
  {
    System.out.println(p);
  }
}