Uses of Interface
org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal

Packages that use GraphTraversal

Package	Description
org.apache.tinkerpop.gremlin
org.apache.tinkerpop.gremlin.neo4j.structure
org.apache.tinkerpop.gremlin.process.traversal
org.apache.tinkerpop.gremlin.process.traversal.dsl.graph

Uses of GraphTraversal in org.apache.tinkerpop.gremlin

Methods in org.apache.tinkerpop.gremlin that return GraphTraversal

Modifier and Type	Method and Description
GraphTraversal<Vertex,VertexProperty<Object>>	AbstractGremlinTest.convertToVertexProperty(Graph graph, String vertexName, String vertexPropertyKey)
GraphTraversal<Vertex,Object>	AbstractGremlinTest.convertToVertexPropertyId(Graph graph, String vertexName, String vertexPropertyKey)
GraphTraversal<Vertex,Object>	AbstractGremlinTest.convertToVertexPropertyId(String vertexName, String vertexPropertyKey)

Uses of GraphTraversal in org.apache.tinkerpop.gremlin.neo4j.structure

Methods in org.apache.tinkerpop.gremlin.neo4j.structure that return GraphTraversal

Modifier and Type	Method and Description
<S,E> GraphTraversal<S,E>	Neo4jGraph.cypher(String query) Execute the Cypher query and get the result set as a GraphTraversal.
<S,E> GraphTraversal<S,E>	Neo4jGraph.cypher(String query, Map<String,Object> parameters) Execute the Cypher query with provided parameters and get the result set as a GraphTraversal.

Uses of GraphTraversal in org.apache.tinkerpop.gremlin.process.traversal

Fields in org.apache.tinkerpop.gremlin.process.traversal with type parameters of type GraphTraversal

Modifier and Type	Field and Description
UnaryOperator<GraphTraversal<?,?>>	TraversalInterruptionTest.traversalAfterPause
Function<GraphTraversalSource,GraphTraversal<?,?>>	TraversalInterruptionTest.traversalBeforePause
Function<GraphTraversalSource,GraphTraversal<?,?>>	TraversalInterruptionComputerTest.traversalMaker

Uses of GraphTraversal in org.apache.tinkerpop.gremlin.process.traversal.dsl.graph

Subinterfaces of GraphTraversal in org.apache.tinkerpop.gremlin.process.traversal.dsl.graph

Modifier and Type	Interface and Description
static interface	GraphTraversal.Admin<S,E>

Classes in org.apache.tinkerpop.gremlin.process.traversal.dsl.graph that implement GraphTraversal

Modifier and Type	Class and Description
class	DefaultGraphTraversal<S,E>

Methods in org.apache.tinkerpop.gremlin.process.traversal.dsl.graph that return GraphTraversal

Modifier and Type	Method and Description
static <A> GraphTraversal<A,A>	__.__(A... starts)
GraphTraversal<Edge,Edge>	GraphTraversalSource.addE(String label)
default GraphTraversal<S,Edge>	GraphTraversal.addE(String edgeLabel) Adds an Edge with the specified edge label.
static <A> GraphTraversal<A,Edge>	__.addE(String edgeLabel)
GraphTraversal<Vertex,Vertex>	GraphTraversalSource.addV()
default GraphTraversal<S,Vertex>	GraphTraversal.addV() Adds a Vertex with a default vertex label.
static <A> GraphTraversal<A,Vertex>	__.addV()
GraphTraversal<Vertex,Vertex>	GraphTraversalSource.addV(String label)
default GraphTraversal<S,Vertex>	GraphTraversal.addV(String vertexLabel) Adds a Vertex.
static <A> GraphTraversal<A,Vertex>	__.addV(String vertexLabel)
default GraphTraversal<S,E>	GraphTraversal.aggregate(String sideEffectKey) Eagerly collects objects up to this step into a side-effect.
static <A> GraphTraversal<A,A>	__.aggregate(String sideEffectKey)
default GraphTraversal<S,E>	GraphTraversal.and(Traversal<?,?>... andTraversals) Ensures that all of the provided traversals yield a result.
static <A> GraphTraversal<A,A>	__.and(Traversal<?,?>... andTraversals)
default GraphTraversal<S,E>	GraphTraversal.as(String stepLabel, String... stepLabels) A step modulator that provides a lable to the step that can be accessed later in the traversal by other steps.
static <A> GraphTraversal<A,A>	__.as(String label, String... labels)
default GraphTraversal<S,E>	GraphTraversal.barrier() Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
static <A> GraphTraversal<A,A>	__.barrier()
default GraphTraversal<S,E>	GraphTraversal.barrier(Consumer<TraverserSet<Object>> barrierConsumer) Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
static <A> GraphTraversal<A,A>	__.barrier(Consumer<TraverserSet<Object>> barrierConsumer)
default GraphTraversal<S,E>	GraphTraversal.barrier(int maxBarrierSize) Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
static <A> GraphTraversal<A,A>	__.barrier(int maxBarrierSize)
static GraphTraversal<Vertex,Vertex>	__.both(String... edgeLabels)
default GraphTraversal<S,Vertex>	GraphTraversal.both(String... edgeLabels) Map the Vertex to its adjacent vertices given the edge labels.
static GraphTraversal<Vertex,Edge>	__.bothE(String... edgeLabels)
default GraphTraversal<S,Edge>	GraphTraversal.bothE(String... edgeLabels) Map the Vertex to its incident edges given the edge labels.
static GraphTraversal<Edge,Vertex>	__.bothV()
default GraphTraversal<S,Vertex>	GraphTraversal.bothV() Map the Edge to its incident vertices.
static <A,M,B> GraphTraversal<A,B>	__.branch(Function<Traverser<A>,M> function)
default <M,E2> GraphTraversal<S,E2>	GraphTraversal.branch(Function<Traverser<E>,M> function) Split the Traverser to all the specified functions.
static <A,M,B> GraphTraversal<A,B>	__.branch(Traversal<?,M> traversalFunction)
default <M,E2> GraphTraversal<S,E2>	GraphTraversal.branch(Traversal<?,M> branchTraversal) Split the Traverser to all the specified traversals.
default GraphTraversal<S,E>	GraphTraversal.by() The by() can be applied to a number of different step to alter their behaviors.
default GraphTraversal<S,E>	GraphTraversal.by(Comparator<E> comparator) The by() can be applied to a number of different step to alter their behaviors.
default <U> GraphTraversal<S,E>	GraphTraversal.by(Function<U,Object> function, Comparator comparator) The by() can be applied to a number of different step to alter their behaviors.
default <V> GraphTraversal<S,E>	GraphTraversal.by(Function<V,Object> function) The by() can be applied to a number of different step to alter their behaviors.
default GraphTraversal<S,E>	GraphTraversal.by(Order order) The by() can be applied to a number of different step to alter their behaviors.
default GraphTraversal<S,E>	GraphTraversal.by(String key) The by() can be applied to a number of different step to alter their behaviors.
default <V> GraphTraversal<S,E>	GraphTraversal.by(String key, Comparator<V> comparator) The by() can be applied to a number of different step to alter their behaviors.
default GraphTraversal<S,E>	GraphTraversal.by(T token) The by() can be applied to a number of different step to alter their behaviors.
default GraphTraversal<S,E>	GraphTraversal.by(Traversal<?,?> traversal) The by() can be applied to a number of different step to alter their behaviors.
default <V> GraphTraversal<S,E>	GraphTraversal.by(Traversal<?,?> traversal, Comparator<V> comparator) The by() can be applied to a number of different step to alter their behaviors.
static <A,B> GraphTraversal<A,B>	__.cap(String sideEffectKey, String... sideEffectKeys)
default <E2> GraphTraversal<S,E2>	GraphTraversal.cap(String sideEffectKey, String... sideEffectKeys) Iterates the traversal up to the itself and emits the side-effect referenced by the key.
static <A,M,B> GraphTraversal<A,B>	__.choose(Function<A,M> choiceFunction)
default <M,E2> GraphTraversal<S,E2>	GraphTraversal.choose(Function<E,M> choiceFunction) Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
static <A,B> GraphTraversal<A,B>	__.choose(Predicate<A> choosePredicate, Traversal<?,B> trueChoice)
static <A,B> GraphTraversal<A,B>	__.choose(Predicate<A> choosePredicate, Traversal<?,B> trueChoice, Traversal<?,B> falseChoice)
default <E2> GraphTraversal<S,E2>	GraphTraversal.choose(Predicate<E> choosePredicate, Traversal<?,E2> trueChoice) Routes the current traverser to a particular traversal branch option which allows the creation of if-then like semantics within a traversal.
default <E2> GraphTraversal<S,E2>	GraphTraversal.choose(Predicate<E> choosePredicate, Traversal<?,E2> trueChoice, Traversal<?,E2> falseChoice) Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
default <E2> GraphTraversal<S,E2>	GraphTraversal.choose(Traversal<?,?> traversalPredicate, Traversal<?,E2> trueChoice) Routes the current traverser to a particular traversal branch option which allows the creation of if-then like semantics within a traversal.
default <E2> GraphTraversal<S,E2>	GraphTraversal.choose(Traversal<?,?> traversalPredicate, Traversal<?,E2> trueChoice, Traversal<?,E2> falseChoice) Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
static <A,M,B> GraphTraversal<A,B>	__.choose(Traversal<?,M> traversalFunction)
default <M,E2> GraphTraversal<S,E2>	GraphTraversal.choose(Traversal<?,M> choiceTraversal) Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
static <A,M,B> GraphTraversal<A,B>	__.choose(Traversal<?,M> traversalPredicate, Traversal<?,B> trueChoice)
static <A,M,B> GraphTraversal<A,B>	__.choose(Traversal<?,M> traversalPredicate, Traversal<?,B> trueChoice, Traversal<?,B> falseChoice)
static <A,B> GraphTraversal<A,B>	__.coalesce(Traversal<?,B>... traversals)
default <E2> GraphTraversal<S,E2>	GraphTraversal.coalesce(Traversal<?,E2>... coalesceTraversals) Evaluates the provided traversals and returns the result of the first traversal to emit at least one object.
default GraphTraversal<S,E>	GraphTraversal.coin(double probability) Filter the E object given a biased coin toss.
static <A> GraphTraversal<A,A>	__.coin(double probability)
static <A> GraphTraversal<A,A>	__.constant(A a)
default <E2> GraphTraversal<S,E2>	GraphTraversal.constant(E2 e) Map any object to a fixed E value.
default GraphTraversal<S,Long>	GraphTraversal.count() Map the traversal stream to its reduction as a sum of the Traverser.bulk() values (i.e.
static <A> GraphTraversal<A,Long>	__.count()
default GraphTraversal<S,Long>	GraphTraversal.count(Scope scope) Map the traversal stream to its reduction as a sum of the Traverser.bulk() values given the specified Scope (i.e.
static <A> GraphTraversal<A,Long>	__.count(Scope scope)
default GraphTraversal<S,E>	GraphTraversal.cyclicPath() Filter the E object if its Traverser.path() is Path.isSimple().
static <A> GraphTraversal<A,A>	__.cyclicPath()
default GraphTraversal<S,E>	GraphTraversal.dedup(Scope scope, String... dedupLabels) Remove all duplicates in the traversal stream up to this point.
static <A> GraphTraversal<A,A>	__.dedup(Scope scope, String... dedupLabels)
default GraphTraversal<S,E>	GraphTraversal.dedup(String... dedupLabels) Remove all duplicates in the traversal stream up to this point.
static <A> GraphTraversal<A,A>	__.dedup(String... dedupLabels)
default GraphTraversal<S,E>	GraphTraversal.drop() Removes elements and properties from the graph.
static <A> GraphTraversal<A,A>	__.drop()
GraphTraversal<Edge,Edge>	GraphTraversalSource.E(Object... edgesIds)
default GraphTraversal<S,E>	GraphTraversal.emit() Emit is used in conjunction with repeat(Traversal) to emit all objects from the loop.
static <A> GraphTraversal<A,A>	__.emit()
static <A> GraphTraversal<A,A>	__.emit(Predicate<Traverser<A>> emitPredicate)
default GraphTraversal<S,E>	GraphTraversal.emit(Predicate<Traverser<E>> emitPredicate) Emit is used in conjunction with repeat(Traversal) to determine what objects get emit from the loop.
default GraphTraversal<S,E>	GraphTraversal.emit(Traversal<?,?> emitTraversal) Emit is used in conjunction with repeat(Traversal) to determine what objects get emit from the loop.
static <A> GraphTraversal<A,A>	__.emit(Traversal<?,?> emitTraversal)
static <A> GraphTraversal<A,A>	__.filter(Predicate<Traverser<A>> predicate)
default GraphTraversal<S,E>	GraphTraversal.filter(Predicate<Traverser<E>> predicate) Map the Traverser to either true or false, where false will not pass the traverser to the next step.
default GraphTraversal<S,E>	GraphTraversal.filter(Traversal<?,?> filterTraversal) Map the Traverser to either true or false, where false will not pass the traverser to the next step.
static <A> GraphTraversal<A,A>	__.filter(Traversal<?,?> filterTraversal)
static <A,B> GraphTraversal<A,B>	__.flatMap(Function<Traverser<A>,Iterator<B>> function)
default <E2> GraphTraversal<S,E2>	GraphTraversal.flatMap(Function<Traverser<E>,Iterator<E2>> function) Map a Traverser referencing an object of type E to an iterator of objects of type E2.
static <A,B> GraphTraversal<A,B>	__.flatMap(Traversal<?,B> flatMapTraversal)
default <E2> GraphTraversal<S,E2>	GraphTraversal.flatMap(Traversal<?,E2> flatMapTraversal) Map a Traverser referencing an object of type E to an iterator of objects of type E2.
default GraphTraversal<S,List<E>>	GraphTraversal.fold() Rolls up objects in the stream into an aggregate list.
static <A> GraphTraversal<A,List<A>>	__.fold()
static <A,B> GraphTraversal<A,B>	__.fold(B seed, BiFunction<B,A,B> foldFunction)
default <E2> GraphTraversal<S,E2>	GraphTraversal.fold(E2 seed, BiFunction<E2,E,E2> foldFunction) Rolls up objects in the stream into an aggregate value as defined by a seed and BiFunction.
default GraphTraversal<S,E>	GraphTraversal.from(String fromStepLabel) Provide from()-modulation to respective steps.
default GraphTraversal<S,E>	GraphTraversal.from(Traversal<E,Vertex> fromVertex) When used as a modifier to addE(String) this method specifies the traversal to use for selecting the outgoing vertex of the newly added Edge.
default GraphTraversal<S,E>	GraphTraversal.from(Vertex fromVertex) When used as a modifier to addE(String) this method specifies the traversal to use for selecting the outgoing vertex of the newly added Edge.
static <A,K,V> GraphTraversal<A,Map<K,V>>	__.group()
default <K,V> GraphTraversal<S,Map<K,V>>	GraphTraversal.group() Organize objects in the stream into a Map.
default GraphTraversal<S,E>	GraphTraversal.group(String sideEffectKey) Organize objects in the stream into a Map.
static <A> GraphTraversal<A,A>	__.group(String sideEffectKey)
static <A,K> GraphTraversal<A,Map<K,Long>>	__.groupCount()
default <K> GraphTraversal<S,Map<K,Long>>	GraphTraversal.groupCount() Counts the number of times a particular objects has been part of a traversal, returning a Map where the object is the key and the value is the count.
default GraphTraversal<S,E>	GraphTraversal.groupCount(String sideEffectKey) Counts the number of times a particular objects has been part of a traversal, returning a Map where the object is the key and the value is the count.
static <A> GraphTraversal<A,A>	__.groupCount(String sideEffectKey)
default GraphTraversal<S,E>	GraphTraversal.has(String propertyKey) Filters vertices, edges and vertex properties based on the existence of properties.
static <A> GraphTraversal<A,A>	__.has(String propertyKey)
default GraphTraversal<S,E>	GraphTraversal.has(String propertyKey, Object value) Filters vertices, edges and vertex properties based on their properties.
static <A> GraphTraversal<A,A>	__.has(String propertyKey, Object value)
default GraphTraversal<S,E>	GraphTraversal.has(String propertyKey, P<?> predicate) Filters vertices, edges and vertex properties based on their properties.
static <A> GraphTraversal<A,A>	__.has(String propertyKey, P<?> predicate)
default GraphTraversal<S,E>	GraphTraversal.has(String label, String propertyKey, Object value) Filters vertices, edges and vertex properties based on their properties.
static <A> GraphTraversal<A,A>	__.has(String label, String propertyKey, Object value)
default GraphTraversal<S,E>	GraphTraversal.has(String label, String propertyKey, P<?> predicate) Filters vertices, edges and vertex properties based on their properties.
static <A> GraphTraversal<A,A>	__.has(String label, String propertyKey, P<?> predicate)
default GraphTraversal<S,E>	GraphTraversal.has(String propertyKey, Traversal<?,?> propertyTraversal) Filters vertices, edges and vertex properties based on their properties.
static <A> GraphTraversal<A,A>	__.has(String propertyKey, Traversal<?,?> propertyTraversal)
default GraphTraversal<S,E>	GraphTraversal.has(T accessor, Object value) Filters vertices, edges and vertex properties based on their properties.
static <A> GraphTraversal<A,A>	__.has(T accessor, Object value)
default GraphTraversal<S,E>	GraphTraversal.has(T accessor, P<?> predicate) Filters vertices, edges and vertex properties based on their properties.
static <A> GraphTraversal<A,A>	__.has(T accessor, P<?> predicate)
default GraphTraversal<S,E>	GraphTraversal.has(T accessor, Traversal<?,?> propertyTraversal) Filters vertices, edges and vertex properties based on their properties.
static <A> GraphTraversal<A,A>	__.has(T accessor, Traversal<?,?> propertyTraversal)
default GraphTraversal<S,E>	GraphTraversal.hasId(Object id, Object... otherIds) Filters vertices, edges and vertex properties based on their identifier.
static <A> GraphTraversal<A,A>	__.hasId(Object id, Object... otherIds)
default GraphTraversal<S,E>	GraphTraversal.hasId(P<Object> predicate) Filters vertices, edges and vertex properties based on their identifier.
static <A> GraphTraversal<A,A>	__.hasId(P<Object> predicate)
default GraphTraversal<S,E>	GraphTraversal.hasKey(P<String> predicate) Filters vertices, edges and vertex properties based on their key.
static <A> GraphTraversal<A,A>	__.hasKey(P<String> predicate)
default GraphTraversal<S,E>	GraphTraversal.hasKey(String label, String... otherLabels) Filters vertices, edges and vertex properties based on their key.
static <A> GraphTraversal<A,A>	__.hasKey(String label, String... otherLabels)
default GraphTraversal<S,E>	GraphTraversal.hasLabel(P<String> predicate) Filters vertices, edges and vertex properties based on their label.
static <A> GraphTraversal<A,A>	__.hasLabel(P<String> predicate)
default GraphTraversal<S,E>	GraphTraversal.hasLabel(String label, String... otherLabels) Filters vertices, edges and vertex properties based on their label.
static <A> GraphTraversal<A,A>	__.hasLabel(String label, String... otherLabels)
default GraphTraversal<S,E>	GraphTraversal.hasNot(String propertyKey) Filters vertices, edges and vertex properties based on the non-existence of properties.
static <A> GraphTraversal<A,A>	__.hasNot(String propertyKey)
default GraphTraversal<S,E>	GraphTraversal.hasValue(Object value, Object... otherValues) Filters vertices, edges and vertex properties based on their value.
static <A> GraphTraversal<A,A>	__.hasValue(Object value, Object... values)
default GraphTraversal<S,E>	GraphTraversal.hasValue(P<Object> predicate) Filters vertices, edges and vertex properties based on their value.
static <A> GraphTraversal<A,A>	__.hasValue(P<Object> predicate)
default GraphTraversal<S,Object>	GraphTraversal.id() Map the Element to its Element.id().
static <A extends Element> GraphTraversal<A,Object>	__.id()
default GraphTraversal<S,E>	GraphTraversal.identity() Map the E object to itself.
static <A> GraphTraversal<A,A>	__.identity()
static GraphTraversal<Vertex,Vertex>	__.in(String... edgeLabels)
default GraphTraversal<S,Vertex>	GraphTraversal.in(String... edgeLabels) Map the Vertex to its incoming adjacent vertices given the edge labels.
static GraphTraversal<Vertex,Edge>	__.inE(String... edgeLabels)
default GraphTraversal<S,Edge>	GraphTraversal.inE(String... edgeLabels) Map the Vertex to its incoming incident edges given the edge labels.
static <A> GraphTraversal<A,A>	__.inject(A... injections)
default GraphTraversal<S,E>	GraphTraversal.inject(E... injections) Provides a way to add arbitrary objects to a traversal stream.
<S> GraphTraversal<S,S>	GraphTraversalSource.inject(S... starts)
static GraphTraversal<Edge,Vertex>	__.inV()
default GraphTraversal<S,Vertex>	GraphTraversal.inV() Map the Edge to its incoming/head incident Vertex.
default GraphTraversal<S,E>	GraphTraversal.is(Object value) Filter the E object if it is not P.eq(V) to the provided value.
static <A> GraphTraversal<A,A>	__.is(Object value)
static <A> GraphTraversal<A,A>	__.is(P<A> predicate)
default GraphTraversal<S,E>	GraphTraversal.is(P<E> predicate) Filters E object values given the provided predicate.
GraphTraversal<S,E>	DefaultGraphTraversal.iterate()
default GraphTraversal<S,E>	GraphTraversal.iterate() Iterates the traversal presumably for the generation of side-effects.
default GraphTraversal<S,E>	GraphTraversal.Admin.iterate()
default GraphTraversal<S,String>	GraphTraversal.key() Map the Property to its Property.key().
static <A extends Property> GraphTraversal<A,String>	__.key()
default GraphTraversal<S,String>	GraphTraversal.label() Map the Element to its Element.label().
static <A extends Element> GraphTraversal<A,String>	__.label()
default GraphTraversal<S,E>	GraphTraversal.limit(long limit) Filter the objects in the traversal by the number of them to pass through the stream, where only the first n objects are allowed as defined by the limit argument.
static <A> GraphTraversal<A,A>	__.limit(long limit)
static <A> GraphTraversal<A,A>	__.limit(Scope scope, long limit)
default <E2> GraphTraversal<S,E2>	GraphTraversal.limit(Scope scope, long limit) Filter the objects in the traversal by the number of them to pass through the stream given the Scope, where only the first n objects are allowed as defined by the limit argument.
static <A,B> GraphTraversal<A,B>	__.local(Traversal<?,B> localTraversal)
default <E2> GraphTraversal<S,E2>	GraphTraversal.local(Traversal<?,E2> localTraversal) Provides a execute a specified traversal on a single element within a stream.
default GraphTraversal<S,Integer>	GraphTraversal.loops() If the Traverser supports looping then calling this method will extract the number of loops for that traverser.
static <A> GraphTraversal<A,Integer>	__.loops()
static <A,B> GraphTraversal<A,B>	__.map(Function<Traverser<A>,B> function)
default <E2> GraphTraversal<S,E2>	GraphTraversal.map(Function<Traverser<E>,E2> function) Map a Traverser referencing an object of type E to an object of type E2.
static <A,B> GraphTraversal<A,B>	__.map(Traversal<?,B> mapTraversal)
default <E2> GraphTraversal<S,E2>	GraphTraversal.map(Traversal<?,E2> mapTraversal) Map a Traverser referencing an object of type E to an object of type E2.
static <A,B> GraphTraversal<A,Map<String,B>>	__.match(Traversal<?,?>... matchTraversals)
default <E2> GraphTraversal<S,Map<String,E2>>	GraphTraversal.match(Traversal<?,?>... matchTraversals) Map the Traverser to a Map of bindings as specified by the provided match traversals.
static <A,B extends Number> GraphTraversal<A,B>	__.max()
default <E2 extends Number> GraphTraversal<S,E2>	GraphTraversal.max() Determines the largest value in the stream.
static <A,B extends Number> GraphTraversal<A,B>	__.max(Scope scope)
default <E2 extends Number> GraphTraversal<S,E2>	GraphTraversal.max(Scope scope) Determines the largest value in the stream given the Scope.
static <A> GraphTraversal<A,Double>	__.mean()
default <E2 extends Number> GraphTraversal<S,E2>	GraphTraversal.mean() Determines the mean value in the stream.
static <A> GraphTraversal<A,Double>	__.mean(Scope scope)
default <E2 extends Number> GraphTraversal<S,E2>	GraphTraversal.mean(Scope scope) Determines the mean value in the stream given the Scope.
static <A,B extends Number> GraphTraversal<A,B>	__.min()
default <E2 extends Number> GraphTraversal<S,E2>	GraphTraversal.min() Determines the smallest value in the stream.
static <A,B extends Number> GraphTraversal<A,B>	__.min(Scope scope)
default <E2 extends Number> GraphTraversal<S,E2>	GraphTraversal.min(Scope scope) Determines the smallest value in the stream given the Scope.
default GraphTraversal<S,E>	GraphTraversal.not(Traversal<?,?> notTraversal) Removes objects from the traversal stream when the traversal provided as an argument does not return any objects.
static <A> GraphTraversal<A,A>	__.not(Traversal<?,?> notTraversal)
default <M,E2> GraphTraversal<S,E>	GraphTraversal.option(M pickToken, Traversal<?,E2> traversalOption) This step modifies choose(Function) to specifies the available choices that might be executed.
default <E2> GraphTraversal<S,E>	GraphTraversal.option(Traversal<?,E2> traversalOption) This step modifies choose(Function) to specifies the available choices that might be executed.
static <A> GraphTraversal<A,A>	__.optional(Traversal<?,A> optionalTraversal)
default <E2> GraphTraversal<S,E2>	GraphTraversal.optional(Traversal<?,E2> optionalTraversal) Returns the result of the specified traversal if it yields a result, otherwise it returns the calling element.
default GraphTraversal<S,E>	GraphTraversal.or(Traversal<?,?>... orTraversals) Ensures that at least one of the provided traversals yield a result.
static <A> GraphTraversal<A,A>	__.or(Traversal<?,?>... orTraversals)
default GraphTraversal<S,E>	GraphTraversal.order() Order all the objects in the traversal up to this point and then emit them one-by-one in their ordered sequence.
static <A> GraphTraversal<A,A>	__.order()
default GraphTraversal<S,E>	GraphTraversal.order(Scope scope) Order either the Scope.local object (e.g.
static <A> GraphTraversal<A,A>	__.order(Scope scope)
static GraphTraversal<Edge,Vertex>	__.otherV()
default GraphTraversal<S,Vertex>	GraphTraversal.otherV() Map the Edge to the incident vertex that was not just traversed from in the path history.
static GraphTraversal<Vertex,Vertex>	__.out(String... edgeLabels)
default GraphTraversal<S,Vertex>	GraphTraversal.out(String... edgeLabels) Map the Vertex to its outgoing adjacent vertices given the edge labels.
static GraphTraversal<Vertex,Edge>	__.outE(String... edgeLabels)
default GraphTraversal<S,Edge>	GraphTraversal.outE(String... edgeLabels) Map the Vertex to its outgoing incident edges given the edge labels.
static GraphTraversal<Edge,Vertex>	__.outV()
default GraphTraversal<S,Vertex>	GraphTraversal.outV() Map the Edge to its outgoing/tail incident Vertex.
default GraphTraversal<S,E>	GraphTraversal.pageRank() Calculates a PageRank over the graph using a 0.85 for the alpha value.
default GraphTraversal<S,E>	GraphTraversal.pageRank(double alpha) Calculates a PageRank over the graph.
default GraphTraversal<S,Path>	GraphTraversal.path() Map the Traverser to its Path history via Traverser.path().
static <A> GraphTraversal<A,Path>	__.path()
default GraphTraversal<S,E>	GraphTraversal.peerPressure() Executes a Peer Pressure community detection algorithm over the graph.
default GraphTraversal<S,TraversalMetrics>	GraphTraversal.profile() Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
default GraphTraversal<S,E>	GraphTraversal.profile(String sideEffectKey) Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
default GraphTraversal<S,E>	GraphTraversal.program(VertexProgram<?> vertexProgram) Executes a Peer Pressure community detection algorithm over the graph.
static <A,B> GraphTraversal<A,Map<String,B>>	__.project(String projectKey, String... projectKeys)
default <E2> GraphTraversal<S,Map<String,E2>>	GraphTraversal.project(String projectKey, String... otherProjectKeys) Projects the current object in the stream into a Map that is keyed by the provided labels.
static <A extends Element,B> GraphTraversal<A,? extends Property<B>>	__.properties(String... propertyKeys)
default <E2> GraphTraversal<S,? extends Property<E2>>	GraphTraversal.properties(String... propertyKeys) Map the Element to its associated properties given the provide property keys.
default GraphTraversal<S,E>	GraphTraversal.property(Object key, Object value, Object... keyValues) Sets the key and value of a Property.
static <A> GraphTraversal<A,A>	__.property(Object key, Object value, Object... keyValues)
default GraphTraversal<S,E>	GraphTraversal.property(VertexProperty.Cardinality cardinality, Object key, Object value, Object... keyValues) Sets a Property value and related meta properties if supplied, if supported by the Graph and if the Element is a VertexProperty.
static <A> GraphTraversal<A,A>	__.property(VertexProperty.Cardinality cardinality, Object key, Object value, Object... keyValues)
static <A extends Element,B> GraphTraversal<A,Map<String,B>>	__.propertyMap(String... propertyKeys)
default <E2> GraphTraversal<S,Map<String,E2>>	GraphTraversal.propertyMap(String... propertyKeys) Map the Element to a Map of the properties key'd according to their Property.key().
default GraphTraversal<S,E>	GraphTraversal.range(long low, long high) Filter the objects in the traversal by the number of them to pass through the stream.
static <A> GraphTraversal<A,A>	__.range(long low, long high)
static <A> GraphTraversal<A,A>	__.range(Scope scope, long low, long high)
default <E2> GraphTraversal<S,E2>	GraphTraversal.range(Scope scope, long low, long high) Filter the objects in the traversal by the number of them to pass through the stream as constrained by the Scope.
static <A> GraphTraversal<A,A>	__.repeat(Traversal<?,A> traversal)
default GraphTraversal<S,E>	GraphTraversal.repeat(Traversal<?,E> repeatTraversal) This step is used for looping over a some traversal given some break predicate.
static <A,B> GraphTraversal<A,B>	__.sack()
default <E2> GraphTraversal<S,E2>	GraphTraversal.sack() Map the Traverser to its Traverser.sack() value.
static <A,V,U> GraphTraversal<A,A>	__.sack(BiFunction<V,U,V> sackOperator)
default <V,U> GraphTraversal<S,E>	GraphTraversal.sack(BiFunction<V,U,V> sackOperator) Map the Traverser to its Traverser.sack() value.
default GraphTraversal<S,E>	GraphTraversal.sample(int amountToSample) Allow some specified number of objects to pass through the stream.
static <A> GraphTraversal<A,A>	__.sample(int amountToSample)
default GraphTraversal<S,E>	GraphTraversal.sample(Scope scope, int amountToSample) Allow some specified number of objects to pass through the stream.
static <A> GraphTraversal<A,A>	__.sample(Scope scope, int amountToSample)
static <A,B> GraphTraversal<A,Collection<B>>	__.select(Column column)
default <E2> GraphTraversal<S,Collection<E2>>	GraphTraversal.select(Column column) A version of select that allows for the extraction of a Column from objects in the traversal.
static <A,B> GraphTraversal<A,B>	__.select(Pop pop, String selectKey)
default <E2> GraphTraversal<S,E2>	GraphTraversal.select(Pop pop, String selectKey) Map the Traverser to the object specified by the selectKey and apply the Pop operation to it.
static <A,B> GraphTraversal<A,Map<String,B>>	__.select(Pop pop, String selectKey1, String selectKey2, String... otherSelectKeys)
default <E2> GraphTraversal<S,Map<String,E2>>	GraphTraversal.select(Pop pop, String selectKey1, String selectKey2, String... otherSelectKeys) Map the Traverser to a Map projection of sideEffect values, map values, and/or path values.
static <A,B> GraphTraversal<A,B>	__.select(String selectKey)
default <E2> GraphTraversal<S,E2>	GraphTraversal.select(String selectKey) Map the Traverser to the object specified by the selectKey.
static <A,B> GraphTraversal<A,Map<String,B>>	__.select(String selectKey1, String selectKey2, String... otherSelectKeys)
default <E2> GraphTraversal<S,Map<String,E2>>	GraphTraversal.select(String selectKey1, String selectKey2, String... otherSelectKeys) Map the Traverser to a Map projection of sideEffect values, map values, and/or path values.
static <A> GraphTraversal<A,A>	__.sideEffect(Consumer<Traverser<A>> consumer)
default GraphTraversal<S,E>	GraphTraversal.sideEffect(Consumer<Traverser<E>> consumer) Perform some operation on the Traverser and pass it to the next step unmodified.
default GraphTraversal<S,E>	GraphTraversal.sideEffect(Traversal<?,?> sideEffectTraversal) Perform some operation on the Traverser and pass it to the next step unmodified.
static <A> GraphTraversal<A,A>	__.sideEffect(Traversal<?,?> sideEffectTraversal)
default GraphTraversal<S,E>	GraphTraversal.simplePath() Filter the E object if its Traverser.path() is not Path.isSimple().
static <A> GraphTraversal<A,A>	__.simplePath()
default GraphTraversal<S,E>	GraphTraversal.skip(long skip) Filters out the first n objects in the traversal.
static <A> GraphTraversal<A,A>	__.skip(long skip)
static <A> GraphTraversal<A,A>	__.skip(Scope scope, long skip)
default <E2> GraphTraversal<S,E2>	GraphTraversal.skip(Scope scope, long skip) Filters out the first n objects in the traversal.
static <A> GraphTraversal<A,A>	__.start()
default GraphTraversal<S,E>	GraphTraversal.store(String sideEffectKey) Lazily aggregates objects in the stream into a side-effect collection.
static <A> GraphTraversal<A,A>	__.store(String sideEffectKey)
default GraphTraversal<S,Edge>	GraphTraversal.subgraph(String sideEffectKey) Extracts a portion of the graph being traversed into a Graph object held in the specified side-effect key.
static <A> GraphTraversal<A,Edge>	__.subgraph(String sideEffectKey)
static <A> GraphTraversal<A,Double>	__.sum()
default <E2 extends Number> GraphTraversal<S,E2>	GraphTraversal.sum() Map the traversal stream to its reduction as a sum of the Traverser.get() values multiplied by their Traverser.bulk() (i.e.
static <A> GraphTraversal<A,Double>	__.sum(Scope scope)
default <E2 extends Number> GraphTraversal<S,E2>	GraphTraversal.sum(Scope scope) Map the traversal stream to its reduction as a sum of the Traverser.get() values multiplied by their Traverser.bulk() given the specified Scope (i.e.
default GraphTraversal<S,E>	GraphTraversal.tail() Filters the objects in the traversal emitted as being last objects in the stream.
static <A> GraphTraversal<A,A>	__.tail()
default GraphTraversal<S,E>	GraphTraversal.tail(long limit) Filters the objects in the traversal emitted as being last objects in the stream.
static <A> GraphTraversal<A,A>	__.tail(long limit)
static <A> GraphTraversal<A,A>	__.tail(Scope scope)
default <E2> GraphTraversal<S,E2>	GraphTraversal.tail(Scope scope) Filters the objects in the traversal emitted as being last objects in the stream given the Scope.
static <A> GraphTraversal<A,A>	__.tail(Scope scope, long limit)
default <E2> GraphTraversal<S,E2>	GraphTraversal.tail(Scope scope, long limit) Filters the objects in the traversal emitted as being last objects in the stream given the Scope.
default GraphTraversal<S,E>	GraphTraversal.timeLimit(long timeLimit) Once the first Traverser hits this step, a count down is started.
static <A> GraphTraversal<A,A>	__.timeLimit(long timeLimit)
default GraphTraversal<S,E>	GraphTraversal.times(int maxLoops) Modifies a repeat(Traversal) to specify how many loops should occur before exiting.
static <A> GraphTraversal<A,A>	__.times(int maxLoops)
static GraphTraversal<Vertex,Vertex>	__.to(Direction direction, String... edgeLabels)
default GraphTraversal<S,Vertex>	GraphTraversal.to(Direction direction, String... edgeLabels) Map the Vertex to its adjacent vertices given a direction and edge labels.
default GraphTraversal<S,E>	GraphTraversal.to(String toStepLabel) Provide to()-modulation to respective steps.
default GraphTraversal<S,E>	GraphTraversal.to(Traversal<E,Vertex> toVertex) When used as a modifier to addE(String) this method specifies the traversal to use for selecting the incoming vertex of the newly added Edge.
default GraphTraversal<S,E>	GraphTraversal.to(Vertex toVertex) When used as a modifier to addE(String) this method specifies the traversal to use for selecting the incoming vertex of the newly added Edge.
static GraphTraversal<Vertex,Edge>	__.toE(Direction direction, String... edgeLabels)
default GraphTraversal<S,Edge>	GraphTraversal.toE(Direction direction, String... edgeLabels) Map the Vertex to its incident edges given the direction and edge labels.
static GraphTraversal<Edge,Vertex>	__.toV(Direction direction)
default GraphTraversal<S,Vertex>	GraphTraversal.toV(Direction direction) Map the Edge to its incident vertices given the direction.
default GraphTraversal<S,Tree>	GraphTraversal.tree() Aggregates the emanating paths into a Tree data structure.
static <A> GraphTraversal<A,Tree>	__.tree()
default GraphTraversal<S,E>	GraphTraversal.tree(String sideEffectKey) Aggregates the emanating paths into a Tree data structure.
static <A> GraphTraversal<A,A>	__.tree(String sideEffectKey)
static <A> GraphTraversal<A,A>	__.unfold()
default <E2> GraphTraversal<S,E2>	GraphTraversal.unfold() Unrolls a Iterator, Iterable or Map into a linear form or simply emits the object if it is not one of those types.
static <A,B> GraphTraversal<A,B>	__.union(Traversal<?,B>... traversals)
default <E2> GraphTraversal<S,E2>	GraphTraversal.union(Traversal<?,E2>... unionTraversals) Merges the results of an arbitrary number of traversals.
static <A> GraphTraversal<A,A>	__.until(Predicate<Traverser<A>> untilPredicate)
default GraphTraversal<S,E>	GraphTraversal.until(Predicate<Traverser<E>> untilPredicate) Modifies a repeat(Traversal) to determine when the loop should exit.
default GraphTraversal<S,E>	GraphTraversal.until(Traversal<?,?> untilTraversal) Modifies a repeat(Traversal) to determine when the loop should exit.
static <A> GraphTraversal<A,A>	__.until(Traversal<?,?> untilTraversal)
GraphTraversal<Vertex,Vertex>	GraphTraversalSource.V(Object... vertexIds)
default GraphTraversal<S,Vertex>	GraphTraversal.V(Object... vertexIdsOrElements) A V step is usually used to start a traversal but it may also be used mid-traversal.
static <A> GraphTraversal<A,Vertex>	__.V(Object... vertexIdsOrElements)
static <A extends Property,B> GraphTraversal<A,B>	__.value()
default <E2> GraphTraversal<S,E2>	GraphTraversal.value() Map the Property to its Property.value().
static <A extends Element,B> GraphTraversal<A,Map<Object,B>>	__.valueMap(boolean includeTokens, String... propertyKeys)
default <E2> GraphTraversal<S,Map<Object,E2>>	GraphTraversal.valueMap(boolean includeTokens, String... propertyKeys) Map the Element to a Map of the property values key'd according to their Property.key().
static <A extends Element,B> GraphTraversal<A,Map<String,B>>	__.valueMap(String... propertyKeys)
default <E2> GraphTraversal<S,Map<String,E2>>	GraphTraversal.valueMap(String... propertyKeys) Map the Element to a Map of the property values key'd according to their Property.key().
static <A extends Element,B> GraphTraversal<A,B>	__.values(String... propertyKeys)
default <E2> GraphTraversal<S,E2>	GraphTraversal.values(String... propertyKeys) Map the Element to the values of the associated properties given the provide property keys.
default GraphTraversal<S,E>	GraphTraversal.where(P<String> predicate) Filters the current object based on the object itself or the path history.
static <A> GraphTraversal<A,A>	__.where(P<String> predicate)
default GraphTraversal<S,E>	GraphTraversal.where(String startKey, P<String> predicate) Filters the current object based on the object itself or the path history.
static <A> GraphTraversal<A,A>	__.where(String startKey, P<String> predicate)
default GraphTraversal<S,E>	GraphTraversal.where(Traversal<?,?> whereTraversal) Filters the current object based on the object itself or the path history.
static <A> GraphTraversal<A,A>	__.where(Traversal<?,?> whereTraversal)