All Superinterfaces:

AutoCloseable, Cloneable, Iterator<E>, Serializable, Traversal<S,E>

All Known Subinterfaces:

CredentialTraversal<S,E>, CredentialTraversalDsl<S,E>, GraphTraversal.Admin<S,E>

All Known Implementing Classes:

DefaultCredentialTraversal, DefaultGraphTraversal
```
public interface GraphTraversal<S,E>
extends Traversal<S,E>
```
Author:

Marko A. Rodriguez (http://markorodriguez.com), Stephen Mallette (http://stephen.genoprime.com)

Nested Class Summary

Nested Classes
Modifier and Type Interface Description

static interface GraphTraversal.Admin<S,E>

static class GraphTraversal.Symbols
- Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal
  Traversal.Exceptions

Method Summary

All Methods Instance Methods Default Methods Deprecated Methods
Modifier and Type	Method	Description
`default GraphTraversal<S,Edge>`	`addE(String edgeLabel)`	Adds an `Edge` with the specified edge label.
`default GraphTraversal<S,Edge>`	`addE(Traversal<?,String> edgeLabelTraversal)`	Adds a `Edge` with an edge label determined by a `Traversal`.
`default GraphTraversal<S,Vertex>`	`addV()`	Adds a `Vertex` with a default vertex label.
`default GraphTraversal<S,Vertex>`	`addV(String vertexLabel)`	Adds a `Vertex`.
`default GraphTraversal<S,Vertex>`	`addV(Traversal<?,String> vertexLabelTraversal)`	Adds a `Vertex` with a vertex label determined by a `Traversal`.
`default GraphTraversal<S,E>`	`aggregate(String sideEffectKey)`	Eagerly collects objects up to this step into a side-effect.
`default GraphTraversal<S,E>`	`aggregate(Scope scope, String sideEffectKey)`	Collects objects in a list using the `Scope` argument to determine whether it should be lazy `Scope.local` or eager (`Scope.global` while gathering those objects.
`default GraphTraversal<S,E>`	`and(Traversal<?,?>... andTraversals)`	Ensures that all of the provided traversals yield a result.
`default GraphTraversal<S,E>`	`as(String stepLabel, String... stepLabels)`	A step modulator that provides a label to the step that can be accessed later in the traversal by other steps.
`default GraphTraversal.Admin<S,E>`	`asAdmin()`	Get access to administrative methods of the traversal via its accompanying `Traversal.Admin`.
`default GraphTraversal<S,E>`	`barrier()`	Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
`default GraphTraversal<S,E>`	`barrier(int maxBarrierSize)`	Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
`default GraphTraversal<S,E>`	`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.
`default GraphTraversal<S,Vertex>`	`both(String... edgeLabels)`	Map the `Vertex` to its adjacent vertices given the edge labels.
`default GraphTraversal<S,Edge>`	`bothE(String... edgeLabels)`	Map the `Vertex` to its incident edges given the edge labels.
`default GraphTraversal<S,Vertex>`	`bothV()`	Map the `Edge` to its incident vertices.
`default <M,E2> GraphTraversal<S,E2>`	`branch(Function<Traverser<E>,M> function)`	Split the `Traverser` to all the specified functions.
`default <M,E2> GraphTraversal<S,E2>`	`branch(Traversal<?,M> branchTraversal)`	Split the `Traverser` to all the specified traversals.
`default GraphTraversal<S,E>`	`by()`	The `by()` can be applied to a number of different step to alter their behaviors.
`default GraphTraversal<S,E>`	`by(String key)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default <V> GraphTraversal<S,E>`	`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>`	`by(Comparator<E> comparator)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default <U> GraphTraversal<S,E>`	`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>`	`by(Function<V,Object> function)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default GraphTraversal<S,E>`	`by(Order order)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default GraphTraversal<S,E>`	`by(Traversal<?,?> traversal)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default <V> GraphTraversal<S,E>`	`by(Traversal<?,?> traversal, Comparator<V> comparator)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default GraphTraversal<S,E>`	`by(T token)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default <E2> GraphTraversal<S,E2>`	`cap(String sideEffectKey, String... sideEffectKeys)`	Iterates the traversal up to the itself and emits the side-effect referenced by the key.
`default <M,E2> GraphTraversal<S,E2>`	`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.
`default <E2> GraphTraversal<S,E2>`	`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>`	`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>`	`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>`	`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.
`default <M,E2> GraphTraversal<S,E2>`	`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.
`default <E2> GraphTraversal<S,E2>`	`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>`	`coin(double probability)`	Filter the `E` object given a biased coin toss.
`default GraphTraversal<S,E>`	`connectedComponent()`	Executes a Connected Component algorithm over the graph.
`default <E2> GraphTraversal<S,E2>`	`constant(E2 e)`	Map any object to a fixed `E` value.
`default GraphTraversal<S,Long>`	`count()`	Map the traversal stream to its reduction as a sum of the `Traverser.bulk()` values (i.e.
`default GraphTraversal<S,Long>`	`count(Scope scope)`	Map the traversal stream to its reduction as a sum of the `Traverser.bulk()` values given the specified `Scope` (i.e.
`default GraphTraversal<S,E>`	`cyclicPath()`	Filter the `E` object if its `Traverser.path()` is `Path.isSimple()`.
`default GraphTraversal<S,E>`	`dedup(String... dedupLabels)`	Remove all duplicates in the traversal stream up to this point.
`default GraphTraversal<S,E>`	`dedup(Scope scope, String... dedupLabels)`	Remove all duplicates in the traversal stream up to this point.
`default GraphTraversal<S,E>`	`drop()`	Removes elements and properties from the graph.
`default <E2> GraphTraversal<S,Map<Object,E2>>`	`elementMap(String... propertyKeys)`	Map the `Element` to a `Map` of the property values key'd according to their `Property.key()`.
`default GraphTraversal<S,E>`	`emit()`	Emit is used in conjunction with `repeat(Traversal)` to emit all objects from the loop.
`default GraphTraversal<S,E>`	`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>`	`emit(Traversal<?,?> emitTraversal)`	Emit is used in conjunction with `repeat(Traversal)` to determine what objects get emit from the loop.
`default GraphTraversal<S,E>`	`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>`	`filter(Traversal<?,?> filterTraversal)`	Map the `Traverser` to either `true` or `false`, where `false` will not pass the traverser to the next step.
`default <E2> GraphTraversal<S,E2>`	`flatMap(Function<Traverser<E>,Iterator<E2>> function)`	Map a `Traverser` referencing an object of type `E` to an iterator of objects of type `E2`.
`default <E2> GraphTraversal<S,E2>`	`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>>`	`fold()`	Rolls up objects in the stream into an aggregate list.
`default <E2> GraphTraversal<S,E2>`	`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>`	`from(String fromStepLabel)`	Provide `from()`-modulation to respective steps.
`default GraphTraversal<S,E>`	`from(Traversal<?,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>`	`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`.
`default <K,V> GraphTraversal<S,Map<K,V>>`	`group()`	Organize objects in the stream into a `Map`.
`default GraphTraversal<S,E>`	`group(String sideEffectKey)`	Organize objects in the stream into a `Map`.
`default <K> GraphTraversal<S,Map<K,Long>>`	`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>`	`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.
`default GraphTraversal<S,E>`	`has(String propertyKey)`	Filters vertices, edges and vertex properties based on the existence of properties.
`default GraphTraversal<S,E>`	`has(String propertyKey, Object value)`	Filters vertices, edges and vertex properties based on their properties.
`default GraphTraversal<S,E>`	`has(String label, String propertyKey, Object value)`	Filters vertices, edges and vertex properties based on their properties.
`default GraphTraversal<S,E>`	`has(String label, String propertyKey, P<?> predicate)`	Filters vertices, edges and vertex properties based on their properties.
`default GraphTraversal<S,E>`	`has(String propertyKey, P<?> predicate)`	Filters vertices, edges and vertex properties based on their properties.
`default GraphTraversal<S,E>`	`has(String propertyKey, Traversal<?,?> propertyTraversal)`	Filters vertices, edges and vertex properties based on the value of the specified property key.
`default GraphTraversal<S,E>`	`has(T accessor, Object value)`	Filters vertices, edges and vertex properties based on their properties.
`default GraphTraversal<S,E>`	`has(T accessor, P<?> predicate)`	Filters vertices, edges and vertex properties based on their properties.
`default GraphTraversal<S,E>`	`has(T accessor, Traversal<?,?> propertyTraversal)`	Filters vertices, edges and vertex properties based on their value of `T` where only `T.id` and `T.label` are supported.
`default GraphTraversal<S,E>`	`hasId(Object id, Object... otherIds)`	Filters vertices, edges and vertex properties based on their identifier.
`default GraphTraversal<S,E>`	`hasId(P<Object> predicate)`	Filters vertices, edges and vertex properties based on their identifier.
`default GraphTraversal<S,E>`	`hasKey(String label, String... otherLabels)`	Filters `Property` objects based on their key.
`default GraphTraversal<S,E>`	`hasKey(P<String> predicate)`	Filters `Property` objects based on their key.
`default GraphTraversal<S,E>`	`hasLabel(String label, String... otherLabels)`	Filters vertices, edges and vertex properties based on their label.
`default GraphTraversal<S,E>`	`hasLabel(P<String> predicate)`	Filters vertices, edges and vertex properties based on their label.
`default GraphTraversal<S,E>`	`hasNot(String propertyKey)`	Filters vertices, edges and vertex properties based on the non-existence of properties.
`default GraphTraversal<S,E>`	`hasValue(Object value, Object... otherValues)`	Filters `Property` objects based on their value.
`default GraphTraversal<S,E>`	`hasValue(P<Object> predicate)`	Filters `Property` objects based on their value.Note that calling this step with `null` is the same as calling `hasValue(Object, Object...)` with a single `null`.
`default GraphTraversal<S,Object>`	`id()`	Map the `Element` to its `Element.id()`.
`default GraphTraversal<S,E>`	`identity()`	Map the `E` object to itself.
`default GraphTraversal<S,Vertex>`	`in(String... edgeLabels)`	Map the `Vertex` to its incoming adjacent vertices given the edge labels.
`default <E2> GraphTraversal<S,E2>`	`index()`	Indexes all items of the current collection.
`default GraphTraversal<S,Edge>`	`inE(String... edgeLabels)`	Map the `Vertex` to its incoming incident edges given the edge labels.
`default GraphTraversal<S,E>`	`inject(E... injections)`	Provides a way to add arbitrary objects to a traversal stream.
`default GraphTraversal<S,Vertex>`	`inV()`	Map the `Edge` to its incoming/head incident `Vertex`.
`default GraphTraversal<S,E>`	`is(Object value)`	Filter the `E` object if it is not `P.eq(V)` to the provided value.
`default GraphTraversal<S,E>`	`is(P<E> predicate)`	Filters `E` object values given the provided `predicate`.
`default GraphTraversal<S,E>`	`iterate()`	Iterates the traversal presumably for the generation of side-effects.
`default GraphTraversal<S,String>`	`key()`	Map the `Property` to its `Property.key()`.
`default GraphTraversal<S,String>`	`label()`	Map the `Element` to its `Element.label()`.
`default GraphTraversal<S,E>`	`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.
`default <E2> GraphTraversal<S,E2>`	`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.
`default <E2> GraphTraversal<S,E2>`	`local(Traversal<?,E2> localTraversal)`	Provides a execute a specified traversal on a single element within a stream.
`default GraphTraversal<S,Integer>`	`loops()`	If the `Traverser` supports looping then calling this method will extract the number of loops for that traverser.
`default GraphTraversal<S,Integer>`	`loops(String loopName)`	If the `Traverser` supports looping then calling this method will extract the number of loops for that traverser for the named loop.
`default <E2> GraphTraversal<S,E2>`	`map(Function<Traverser<E>,E2> function)`	Map a `Traverser` referencing an object of type `E` to an object of type `E2`.
`default <E2> GraphTraversal<S,E2>`	`map(Traversal<?,E2> mapTraversal)`	Map a `Traverser` referencing an object of type `E` to an object of type `E2`.
`default <E2> GraphTraversal<S,Map<String,E2>>`	`match(Traversal<?,?>... matchTraversals)`	Map the `Traverser` to a `Map` of bindings as specified by the provided match traversals.
`default GraphTraversal<S,Double>`	`math(String expression)`	Map the `Traverser` to a `Double` according to the mathematical expression provided in the argument.
`default <E2 extends Comparable> GraphTraversal<S,E2>`	`max()`	Determines the largest value in the stream.
`default <E2 extends Comparable> GraphTraversal<S,E2>`	`max(Scope scope)`	Determines the largest value in the stream given the `Scope`.
`default <E2 extends Number> GraphTraversal<S,E2>`	`mean()`	Determines the mean value in the stream.
`default <E2 extends Number> GraphTraversal<S,E2>`	`mean(Scope scope)`	Determines the mean value in the stream given the `Scope`.
`default <E2 extends Comparable> GraphTraversal<S,E2>`	`min()`	Determines the smallest value in the stream.
`default <E2 extends Comparable> GraphTraversal<S,E2>`	`min(Scope scope)`	Determines the smallest value in the stream given the `Scope`.
`default GraphTraversal<S,E>`	`none()`	Filter all traversers in the traversal.
`default GraphTraversal<S,E>`	`not(Traversal<?,?> notTraversal)`	Removes objects from the traversal stream when the traversal provided as an argument does not return any objects.
`default <M,E2> GraphTraversal<S,E>`	`option(M pick, Traversal<?,E2> traversalOption)`	This step modifies `choose(Function)` to specifies the available choices that might be executed.
`default <E2> GraphTraversal<S,E>`	`option(Traversal<?,E2> traversalOption)`	This step modifies `choose(Function)` to specifies the available choices that might be executed.
`default <E2> GraphTraversal<S,E2>`	`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>`	`or(Traversal<?,?>... orTraversals)`	Ensures that at least one of the provided traversals yield a result.
`default GraphTraversal<S,E>`	`order()`	Order all the objects in the traversal up to this point and then emit them one-by-one in their ordered sequence.
`default GraphTraversal<S,E>`	`order(Scope scope)`	Order either the `Scope.local` object (e.g.
`default GraphTraversal<S,Vertex>`	`otherV()`	Map the `Edge` to the incident vertex that was not just traversed from in the path history.
`default GraphTraversal<S,Vertex>`	`out(String... edgeLabels)`	Map the `Vertex` to its outgoing adjacent vertices given the edge labels.
`default GraphTraversal<S,Edge>`	`outE(String... edgeLabels)`	Map the `Vertex` to its outgoing incident edges given the edge labels.
`default GraphTraversal<S,Vertex>`	`outV()`	Map the `Edge` to its outgoing/tail incident `Vertex`.
`default GraphTraversal<S,E>`	`pageRank()`	Calculates a PageRank over the graph using a 0.85 for the `alpha` value.
`default GraphTraversal<S,E>`	`pageRank(double alpha)`	Calculates a PageRank over the graph.
`default GraphTraversal<S,Path>`	`path()`	Map the `Traverser` to its `Path` history via `Traverser.path()`.
`default GraphTraversal<S,E>`	`peerPressure()`	Executes a Peer Pressure community detection algorithm over the graph.
`default GraphTraversal<S,TraversalMetrics>`	`profile()`	Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
`default GraphTraversal<S,E>`	`profile(String sideEffectKey)`	Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
`default GraphTraversal<S,E>`	`program(VertexProgram<?> vertexProgram)`	Executes an arbitrary `VertexProgram` over the graph.
`default <E2> GraphTraversal<S,Map<String,E2>>`	`project(String projectKey, String... otherProjectKeys)`	Projects the current object in the stream into a `Map` that is keyed by the provided labels.
`default <E2> GraphTraversal<S,? extends Property<E2>>`	`properties(String... propertyKeys)`	Map the `Element` to its associated properties given the provide property keys.
`default GraphTraversal<S,E>`	`property(Object key, Object value, Object... keyValues)`	Sets the key and value of a `Property`.
`default GraphTraversal<S,E>`	`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`.
`default <E2> GraphTraversal<S,Map<String,E2>>`	`propertyMap(String... propertyKeys)`	Map the `Element` to a `Map` of the properties key'd according to their `Property.key()`.
`default GraphTraversal<S,E>`	`range(long low, long high)`	Filter the objects in the traversal by the number of them to pass through the stream.
`default <E2> GraphTraversal<S,E2>`	`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`.
`default GraphTraversal<S,E>`	`read()`	This step is technically a step modulator for the the `GraphTraversalSource.io(String)` step which instructs the step to perform a read with its given configuration.
`default GraphTraversal<S,E>`	`repeat(String loopName, Traversal<?,E> repeatTraversal)`	This step is used for looping over a traversal given some break predicate and with a specified loop name.
`default GraphTraversal<S,E>`	`repeat(Traversal<?,E> repeatTraversal)`	This step is used for looping over a traversal given some break predicate.
`default <E2> GraphTraversal<S,E2>`	`sack()`	Map the `Traverser` to its `Traverser.sack()` value.
`default <V,U> GraphTraversal<S,E>`	`sack(BiFunction<V,U,V> sackOperator)`	Map the `Traverser` to its `Traverser.sack()` value.
`default GraphTraversal<S,E>`	`sample(int amountToSample)`	Allow some specified number of objects to pass through the stream.
`default GraphTraversal<S,E>`	`sample(Scope scope, int amountToSample)`	Allow some specified number of objects to pass through the stream.
`default <E2> GraphTraversal<S,E2>`	`select(String selectKey)`	Map the `Traverser` to the object specified by the `selectKey`.
`default <E2> GraphTraversal<S,Map<String,E2>>`	`select(String selectKey1, String selectKey2, String... otherSelectKeys)`	Map the `Traverser` to a `Map` projection of sideEffect values, map values, and/or path values.
`default <E2> GraphTraversal<S,E2>`	`select(Pop pop, String selectKey)`	Map the `Traverser` to the object specified by the `selectKey` and apply the `Pop` operation to it.
`default <E2> GraphTraversal<S,Map<String,E2>>`	`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.
`default <E2> GraphTraversal<S,E2>`	`select(Pop pop, Traversal<S,E2> keyTraversal)`	Map the `Traverser` to the object specified by the key returned by the `keyTraversal` and apply the `Pop` operation to it.
`default <E2> GraphTraversal<S,E2>`	`select(Traversal<S,E2> keyTraversal)`	Map the `Traverser` to the object specified by the key returned by the `keyTraversal`.
`default <E2> GraphTraversal<S,Collection<E2>>`	`select(Column column)`	A version of `select` that allows for the extraction of a `Column` from objects in the traversal.
`default GraphTraversal<S,Path>`	`shortestPath()`	Executes a Shortest Path algorithm over the graph.
`default GraphTraversal<S,E>`	`sideEffect(Consumer<Traverser<E>> consumer)`	Perform some operation on the `Traverser` and pass it to the next step unmodified.
`default GraphTraversal<S,E>`	`sideEffect(Traversal<?,?> sideEffectTraversal)`	Perform some operation on the `Traverser` and pass it to the next step unmodified.
`default GraphTraversal<S,E>`	`simplePath()`	Filter the `E` object if its `Traverser.path()` is not `Path.isSimple()`.
`default GraphTraversal<S,E>`	`skip(long skip)`	Filters out the first `n` objects in the traversal.
`default <E2> GraphTraversal<S,E2>`	`skip(Scope scope, long skip)`	Filters out the first `n` objects in the traversal.
`default GraphTraversal<S,E>`	`store(String sideEffectKey)`	Deprecated. As of release 3.4.3, replaced by `aggregate(Scope, String)` using `Scope.local`.
`default GraphTraversal<S,Edge>`	`subgraph(String sideEffectKey)`	Extracts a portion of the graph being traversed into a `Graph` object held in the specified side-effect key.
`default <E2 extends Number> GraphTraversal<S,E2>`	`sum()`	Map the traversal stream to its reduction as a sum of the `Traverser.get()` values multiplied by their `Traverser.bulk()` (i.e.
`default <E2 extends Number> GraphTraversal<S,E2>`	`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>`	`tail()`	Filters the objects in the traversal emitted as being last objects in the stream.
`default GraphTraversal<S,E>`	`tail(long limit)`	Filters the objects in the traversal emitted as being last objects in the stream.
`default <E2> GraphTraversal<S,E2>`	`tail(Scope scope)`	Filters the objects in the traversal emitted as being last objects in the stream given the `Scope`.
`default <E2> GraphTraversal<S,E2>`	`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>`	`timeLimit(long timeLimit)`	Once the first `Traverser` hits this step, a count down is started.
`default GraphTraversal<S,E>`	`times(int maxLoops)`	Modifies a `repeat(Traversal)` to specify how many loops should occur before exiting.
`default GraphTraversal<S,E>`	`to(String toStepLabel)`	Provide `to()`-modulation to respective steps.
`default GraphTraversal<S,E>`	`to(Traversal<?,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,Vertex>`	`to(Direction direction, String... edgeLabels)`	Map the `Vertex` to its adjacent vertices given a direction and edge labels.
`default GraphTraversal<S,E>`	`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`.
`default GraphTraversal<S,Edge>`	`toE(Direction direction, String... edgeLabels)`	Map the `Vertex` to its incident edges given the direction and edge labels.
`default GraphTraversal<S,Vertex>`	`toV(Direction direction)`	Map the `Edge` to its incident vertices given the direction.
`default GraphTraversal<S,Tree>`	`tree()`	Aggregates the emanating paths into a `Tree` data structure.
`default GraphTraversal<S,E>`	`tree(String sideEffectKey)`	Aggregates the emanating paths into a `Tree` data structure.
`default <E2> GraphTraversal<S,E2>`	`unfold()`	Unrolls a `Iterator`, `Iterable` or `Map` into a linear form or simply emits the object if it is not one of those types.
`default <E2> GraphTraversal<S,E2>`	`union(Traversal<?,E2>... unionTraversals)`	Merges the results of an arbitrary number of traversals.
`default GraphTraversal<S,E>`	`until(Predicate<Traverser<E>> untilPredicate)`	Modifies a `repeat(Traversal)` to determine when the loop should exit.
`default GraphTraversal<S,E>`	`until(Traversal<?,?> untilTraversal)`	Modifies a `repeat(Traversal)` to determine when the loop should exit.
`default GraphTraversal<S,Vertex>`	`V(Object... vertexIdsOrElements)`	A `V` step is usually used to start a traversal but it may also be used mid-traversal.
`default <E2> GraphTraversal<S,E2>`	`value()`	Map the `Property` to its `Property.value()`.
`default <E2> GraphTraversal<S,Map<Object,E2>>`	`valueMap(boolean includeTokens, String... propertyKeys)`	Deprecated. As of release 3.4.0, deprecated in favor of `valueMap(String...)` in conjunction with `with(String, Object)` or simple prefer `elementMap(String...)`.
`default <E2> GraphTraversal<S,Map<Object,E2>>`	`valueMap(String... propertyKeys)`	Map the `Element` to a `Map` of the property values key'd according to their `Property.key()`.
`default <E2> GraphTraversal<S,E2>`	`values(String... propertyKeys)`	Map the `Element` to the values of the associated properties given the provide property keys.
`default GraphTraversal<S,E>`	`where(String startKey, P<String> predicate)`	Filters the current object based on the object itself or the path history.
`default GraphTraversal<S,E>`	`where(P<String> predicate)`	Filters the current object based on the object itself or the path history.
`default GraphTraversal<S,E>`	`where(Traversal<?,?> whereTraversal)`	Filters the current object based on the object itself or the path history.
`default GraphTraversal<S,E>`	`with(String key)`	Provides a configuration to a step in the form of a key which is the same as `with(key, true)`.
`default GraphTraversal<S,E>`	`with(String key, Object value)`	Provides a configuration to a step in the form of a key and value pair.
`default GraphTraversal<S,E>`	`write()`	This step is technically a step modulator for the the `GraphTraversalSource.io(String)` step which instructs the step to perform a write with its given configuration.

Methods inherited from interface java.util.Iterator
hasNext, next, remove

Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal
close, explain, fill, forEachRemaining, forEachRemaining, next, notifyClose, promise, toBulkSet, toList, toSet, toStream, tryNext

- Method Detail
  - asAdmin
```
default GraphTraversal.Admin<S,E> asAdmin()
```
    Description copied from interface: Traversal
    
    Get access to administrative methods of the traversal via its accompanying Traversal.Admin.
    
    Specified by:
    
    asAdmin in interface Traversal<S,E>
    
    Returns:
    
    the admin of this traversal
  - map
```
default <E2> GraphTraversal<S,E2> map(Function<Traverser<E>,E2> function)
```
    Map a Traverser referencing an object of type E to an object of type E2.
    
    Parameters:
    
    function - the lambda expression that does the functional mapping
    
    Returns:
    
    the traversal with an appended LambdaMapStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - General Steps
  - map
```
default <E2> GraphTraversal<S,E2> map(Traversal<?,E2> mapTraversal)
```
    Map a Traverser referencing an object of type E to an object of type E2.
    
    Parameters:
    
    mapTraversal - the traversal expression that does the functional mapping
    
    Returns:
    
    the traversal with an appended LambdaMapStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - General Steps
  - flatMap
```
default <E2> GraphTraversal<S,E2> flatMap(Function<Traverser<E>,Iterator<E2>> function)
```
    Map a Traverser referencing an object of type E to an iterator of objects of type E2. The resultant iterator is drained one-by-one before a new E object is pulled in for processing.
    
    Type Parameters:
    
    E2 - the type of the returned iterator objects
    
    Parameters:
    
    function - the lambda expression that does the functional mapping
    
    Returns:
    
    the traversal with an appended LambdaFlatMapStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - General Steps
  - flatMap
```
default <E2> GraphTraversal<S,E2> flatMap(Traversal<?,E2> flatMapTraversal)
```
    Map a Traverser referencing an object of type E to an iterator of objects of type E2. The internal traversal is drained one-by-one before a new E object is pulled in for processing.
    
    Type Parameters:
    
    E2 - the end type of the internal traversal
    
    Parameters:
    
    flatMapTraversal - the traversal generating objects of type E2
    
    Returns:
    
    the traversal with an appended TraversalFlatMapStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - General Steps
  - id
```
default GraphTraversal<S,Object> id()
```
    Map the Element to its Element.id().
    
    Returns:
    
    the traversal with an appended IdStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Id Step
  - label
```
default GraphTraversal<S,String> label()
```
    Map the Element to its Element.label().
    
    Returns:
    
    the traversal with an appended LabelStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Label Step
  - identity
```
default GraphTraversal<S,E> identity()
```
    Map the E object to itself. In other words, a "no op."
    
    Returns:
    
    the traversal with an appended IdentityStep.
    
    Since:
    
    3.0.0-incubating
  - constant
```
default <E2> GraphTraversal<S,E2> constant(E2 e)
```
    Map any object to a fixed E value.
    
    Returns:
    
    the traversal with an appended ConstantStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Constant Step
  - V
```
default GraphTraversal<S,Vertex> V(Object... vertexIdsOrElements)
```
    A V step is usually used to start a traversal but it may also be used mid-traversal.
    
    Parameters:
    
    vertexIdsOrElements - vertices to inject into the traversal
    
    Returns:
    
    the traversal with an appended GraphStep
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - Graph Step
  - to
```
default GraphTraversal<S,Vertex> to(Direction direction,
                                          String... edgeLabels)
```
    Map the Vertex to its adjacent vertices given a direction and edge labels.
    
    Parameters:
    
    direction - the direction to traverse from the current vertex
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - out
```
default GraphTraversal<S,Vertex> out(String... edgeLabels)
```
    Map the Vertex to its outgoing adjacent vertices given the edge labels.
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - in
```
default GraphTraversal<S,Vertex> in(String... edgeLabels)
```
    Map the Vertex to its incoming adjacent vertices given the edge labels.
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - both
```
default GraphTraversal<S,Vertex> both(String... edgeLabels)
```
    Map the Vertex to its adjacent vertices given the edge labels.
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - toE
```
default GraphTraversal<S,Edge> toE(Direction direction,
                                         String... edgeLabels)
```
    Map the Vertex to its incident edges given the direction and edge labels.
    
    Parameters:
    
    direction - the direction to traverse from the current vertex
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - outE
```
default GraphTraversal<S,Edge> outE(String... edgeLabels)
```
    Map the Vertex to its outgoing incident edges given the edge labels.
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - inE
```
default GraphTraversal<S,Edge> inE(String... edgeLabels)
```
    Map the Vertex to its incoming incident edges given the edge labels.
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - bothE
```
default GraphTraversal<S,Edge> bothE(String... edgeLabels)
```
    Map the Vertex to its incident edges given the edge labels.
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - toV
```
default GraphTraversal<S,Vertex> toV(Direction direction)
```
    Map the Edge to its incident vertices given the direction.
    
    Parameters:
    
    direction - the direction to traverser from the current edge
    
    Returns:
    
    the traversal with an appended EdgeVertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - inV
```
default GraphTraversal<S,Vertex> inV()
```
    Map the Edge to its incoming/head incident Vertex.
    
    Returns:
    
    the traversal with an appended EdgeVertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - outV
```
default GraphTraversal<S,Vertex> outV()
```
    Map the Edge to its outgoing/tail incident Vertex.
    
    Returns:
    
    the traversal with an appended EdgeVertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - bothV
```
default GraphTraversal<S,Vertex> bothV()
```
    Map the Edge to its incident vertices.
    
    Returns:
    
    the traversal with an appended EdgeVertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - otherV
```
default GraphTraversal<S,Vertex> otherV()
```
    Map the Edge to the incident vertex that was not just traversed from in the path history.
    
    Returns:
    
    the traversal with an appended EdgeOtherVertexStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Vertex Step
  - order
```
default GraphTraversal<S,E> order()
```
    Order all the objects in the traversal up to this point and then emit them one-by-one in their ordered sequence.
    
    Returns:
    
    the traversal with an appended OrderGlobalStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Order Step
  - order
```
default GraphTraversal<S,E> order(Scope scope)
```
    Order either the Scope.local object (e.g. a list, map, etc.) or the entire Scope.global traversal stream.
    
    Parameters:
    
    scope - whether the ordering is the current local object or the entire global stream.
    
    Returns:
    
    the traversal with an appended OrderGlobalStep or OrderLocalStep depending on the scope.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Order Step
  - properties
```
default <E2> GraphTraversal<S,? extends Property<E2>> properties(String... propertyKeys)
```
    Map the Element to its associated properties given the provide property keys. If no property keys are provided, then all properties are emitted.
    
    Type Parameters:
    
    E2 - the value type of the returned properties
    
    Parameters:
    
    propertyKeys - the properties to retrieve
    
    Returns:
    
    the traversal with an appended PropertiesStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Properties Step
  - values
```
default <E2> GraphTraversal<S,E2> values(String... propertyKeys)
```
    Map the Element to the values of the associated properties given the provide property keys. If no property keys are provided, then all property values are emitted.
    
    Type Parameters:
    
    E2 - the value type of the properties
    
    Parameters:
    
    propertyKeys - the properties to retrieve their value from
    
    Returns:
    
    the traversal with an appended PropertiesStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Values Step
  - propertyMap
```
default <E2> GraphTraversal<S,Map<String,E2>> propertyMap(String... propertyKeys)
```
    Map the Element to a Map of the properties key'd according to their Property.key(). If no property keys are provided, then all properties are retrieved.
    
    Type Parameters:
    
    E2 - the value type of the returned properties
    
    Parameters:
    
    propertyKeys - the properties to retrieve
    
    Returns:
    
    the traversal with an appended PropertyMapStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - PropertyMap Step
  - elementMap
```
default <E2> GraphTraversal<S,Map<Object,E2>> elementMap(String... propertyKeys)
```
    Map the Element to a Map of the property values key'd according to their Property.key(). If no property keys are provided, then all property values are retrieved. For vertices, the Map will be returned with the assumption of single property values along with T.id and T.label. Prefer valueMap(String...) if multi-property processing is required. For edges, keys will include additional related edge structure of Direction.IN and Direction.OUT which themselves are Map instances of the particular Vertex represented by T.id and T.label.
    
    Type Parameters:
    
    E2 - the value type of the returned properties
    
    Parameters:
    
    propertyKeys - the properties to retrieve
    
    Returns:
    
    the traversal with an appended ElementMapStep.
    
    Since:
    
    3.4.4
    
    See Also:
    
    Reference Documentation - ElementMap Step
  - valueMap
```
default <E2> GraphTraversal<S,Map<Object,E2>> valueMap(String... propertyKeys)
```
    Map the Element to a Map of the property values key'd according to their Property.key(). If no property keys are provided, then all property values are retrieved.
    
    Type Parameters:
    
    E2 - the value type of the returned properties
    
    Parameters:
    
    propertyKeys - the properties to retrieve
    
    Returns:
    
    the traversal with an appended PropertyMapStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - ValueMap Step
  - valueMap
```
@Deprecated
default <E2> GraphTraversal<S,Map<Object,E2>> valueMap(boolean includeTokens,
                                                                   String... propertyKeys)
```
    Deprecated.
    As of release 3.4.0, deprecated in favor of valueMap(String...) in conjunction with with(String, Object) or simple prefer elementMap(String...).
    
    Map the Element to a Map of the property values key'd according to their Property.key(). If no property keys are provided, then all property values are retrieved.
    
    Type Parameters:
    
    E2 - the value type of the returned properties
    
    Parameters:
    
    includeTokens - whether to include T tokens in the emitted map.
    
    propertyKeys - the properties to retrieve
    
    Returns:
    
    the traversal with an appended PropertyMapStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - ValueMap Step
  - key
```
default GraphTraversal<S,String> key()
```
    Map the Property to its Property.key().
    
    Returns:
    
    the traversal with an appended PropertyKeyStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Key Step
  - value
```
default <E2> GraphTraversal<S,E2> value()
```
    Map the Property to its Property.value().
    
    Returns:
    
    the traversal with an appended PropertyValueStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Value Step
  - path
```
default GraphTraversal<S,Path> path()
```
    Map the Traverser to its Path history via Traverser.path().
    
    Returns:
    
    the traversal with an appended PathStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Path Step
  - match
```
default <E2> GraphTraversal<S,Map<String,E2>> match(Traversal<?,?>... matchTraversals)
```
    Map the Traverser to a Map of bindings as specified by the provided match traversals.
    
    Type Parameters:
    
    E2 - the type of the objects bound in the variables
    
    Parameters:
    
    matchTraversals - the traversal that maintain variables which must hold for the life of the traverser
    
    Returns:
    
    the traversal with an appended MatchStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Match Step
  - sack
```
default <E2> GraphTraversal<S,E2> sack()
```
    Map the Traverser to its Traverser.sack() value.
    
    Type Parameters:
    
    E2 - the sack value type
    
    Returns:
    
    the traversal with an appended SackStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Sack Step
  - loops
```
default GraphTraversal<S,Integer> loops()
```
    If the Traverser supports looping then calling this method will extract the number of loops for that traverser.
    
    Returns:
    
    the traversal with an appended LoopsStep
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - Loops Step
  - loops
```
default GraphTraversal<S,Integer> loops(String loopName)
```
    If the Traverser supports looping then calling this method will extract the number of loops for that traverser for the named loop.
    
    Returns:
    
    the traversal with an appended LoopsStep
    
    Since:
    
    3.4.0
    
    See Also:
    
    Reference Documentation - Loops Step
  - project
```
default <E2> GraphTraversal<S,Map<String,E2>> project(String projectKey,
                                                                  String... otherProjectKeys)
```
    Projects the current object in the stream into a Map that is keyed by the provided labels.
    
    Returns:
    
    the traversal with an appended ProjectStep
    
    Since:
    
    3.2.0-incubating
    
    See Also:
    
    Reference Documentation - Project Step
  - select
```
default <E2> GraphTraversal<S,Map<String,E2>> 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.
    
    Type Parameters:
    
    E2 - the type of the objects projected
    
    Parameters:
    
    pop - if there are multiple objects referenced in the path, the Pop to use.
    
    selectKey1 - the first key to project
    
    selectKey2 - the second key to project
    
    otherSelectKeys - the third+ keys to project
    
    Returns:
    
    the traversal with an appended SelectStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> GraphTraversal<S,Map<String,E2>> select(String selectKey1,
                                                                 String selectKey2,
                                                                 String... otherSelectKeys)
```
    Map the Traverser to a Map projection of sideEffect values, map values, and/or path values.
    
    Type Parameters:
    
    E2 - the type of the objects projected
    
    Parameters:
    
    selectKey1 - the first key to project
    
    selectKey2 - the second key to project
    
    otherSelectKeys - the third+ keys to project
    
    Returns:
    
    the traversal with an appended SelectStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> GraphTraversal<S,E2> select(Pop pop,
                                               String selectKey)
```
    Map the Traverser to the object specified by the selectKey and apply the Pop operation to it.
    
    Parameters:
    
    selectKey - the key to project
    
    Returns:
    
    the traversal with an appended SelectStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> GraphTraversal<S,E2> select(String selectKey)
```
    Map the Traverser to the object specified by the selectKey. Note that unlike other uses of select where there are multiple keys, this use of select with a single key does not produce a Map.
    
    Parameters:
    
    selectKey - the key to project
    
    Returns:
    
    the traversal with an appended SelectStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> GraphTraversal<S,E2> select(Pop pop,
                                               Traversal<S,E2> keyTraversal)
```
    Map the Traverser to the object specified by the key returned by the keyTraversal and apply the Pop operation to it.
    
    Parameters:
    
    keyTraversal - the traversal expression that selects the key to project
    
    Returns:
    
    the traversal with an appended SelectStep.
    
    Since:
    
    3.3.3
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> GraphTraversal<S,E2> select(Traversal<S,E2> keyTraversal)
```
    Map the Traverser to the object specified by the key returned by the keyTraversal. Note that unlike other uses of select where there are multiple keys, this use of select with a traversal does not produce a Map.
    
    Parameters:
    
    keyTraversal - the traversal expression that selects the key to project
    
    Returns:
    
    the traversal with an appended TraversalSelectStep.
    
    Since:
    
    3.3.3
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> GraphTraversal<S,Collection<E2>> select(Column column)
```
    A version of select that allows for the extraction of a Column from objects in the traversal.
    
    Parameters:
    
    column - the column to extract
    
    Returns:
    
    the traversal with an appended TraversalMapStep
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - Select Step
  - unfold
```
default <E2> GraphTraversal<S,E2> unfold()
```
    Unrolls a Iterator, Iterable or Map into a linear form or simply emits the object if it is not one of those types.
    
    Returns:
    
    the traversal with an appended UnfoldStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Unfold Step
  - fold
```
default GraphTraversal<S,List<E>> fold()
```
    Rolls up objects in the stream into an aggregate list.
    
    Returns:
    
    the traversal with an appended FoldStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Fold Step
  - fold
```
default <E2> GraphTraversal<S,E2> 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.
    
    Parameters:
    
    seed - the value to provide as the first argument to the foldFunction
    
    foldFunction - the function to fold by where the first argument is the seed or the value returned from subsequent class and the second argument is the value from the stream
    
    Returns:
    
    the traversal with an appended FoldStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Fold Step
  - count
```
default GraphTraversal<S,Long> count()
```
    Map the traversal stream to its reduction as a sum of the Traverser.bulk() values (i.e. count the number of traversers up to this point).
    
    Returns:
    
    the traversal with an appended CountGlobalStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Count Step
  - count
```
default GraphTraversal<S,Long> count(Scope scope)
```
    Map the traversal stream to its reduction as a sum of the Traverser.bulk() values given the specified Scope (i.e. count the number of traversers up to this point).
    
    Returns:
    
    the traversal with an appended CountGlobalStep or CountLocalStep depending on the Scope
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Count Step
  - sum
```
default <E2 extends Number> GraphTraversal<S,E2> sum()
```
    Map the traversal stream to its reduction as a sum of the Traverser.get() values multiplied by their Traverser.bulk() (i.e. sum the traverser values up to this point).
    
    Returns:
    
    the traversal with an appended SumGlobalStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Sum Step
  - sum
```
default <E2 extends Number> GraphTraversal<S,E2> 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. sum the traverser values up to this point).
    
    Returns:
    
    the traversal with an appended SumGlobalStep or SumLocalStep depending on the Scope.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Sum Step
  - max
```
default <E2 extends Comparable> GraphTraversal<S,E2> max()
```
    Determines the largest value in the stream.
    
    Returns:
    
    the traversal with an appended MaxGlobalStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Max Step
  - max
```
default <E2 extends Comparable> GraphTraversal<S,E2> max(Scope scope)
```
    Determines the largest value in the stream given the Scope.
    
    Returns:
    
    the traversal with an appended MaxGlobalStep or MaxLocalStep depending on the Scope
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Max Step
  - min
```
default <E2 extends Comparable> GraphTraversal<S,E2> min()
```
    Determines the smallest value in the stream.
    
    Returns:
    
    the traversal with an appended MinGlobalStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Min Step
  - min
```
default <E2 extends Comparable> GraphTraversal<S,E2> min(Scope scope)
```
    Determines the smallest value in the stream given the Scope.
    
    Returns:
    
    the traversal with an appended MinGlobalStep or MinLocalStep depending on the Scope
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Min Step
  - mean
```
default <E2 extends Number> GraphTraversal<S,E2> mean()
```
    Determines the mean value in the stream.
    
    Returns:
    
    the traversal with an appended MeanGlobalStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Mean Step
  - mean
```
default <E2 extends Number> GraphTraversal<S,E2> mean(Scope scope)
```
    Determines the mean value in the stream given the Scope.
    
    Returns:
    
    the traversal with an appended MeanGlobalStep or MeanLocalStep depending on the Scope
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Mean Step
  - group
```
default <K,V> GraphTraversal<S,Map<K,V>> group()
```
    Organize objects in the stream into a Map. Calls to group() are typically accompanied with by() modulators which help specify how the grouping should occur.
    
    Returns:
    
    the traversal with an appended GroupStep.
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - Group Step
  - groupCount
```
default <K> GraphTraversal<S,Map<K,Long>> 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.
    
    Returns:
    
    the traversal with an appended GroupCountStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - GroupCount Step
  - tree
```
default GraphTraversal<S,Tree> tree()
```
    Aggregates the emanating paths into a Tree data structure.
    
    Returns:
    
    the traversal with an appended TreeStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Tree Step
  - addV
```
default GraphTraversal<S,Vertex> addV(String vertexLabel)
```
    Adds a Vertex.
    
    Parameters:
    
    vertexLabel - the label of the Vertex to add
    
    Returns:
    
    the traversal with the AddVertexStep added
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - AddVertex Step
  - addV
```
default GraphTraversal<S,Vertex> addV(Traversal<?,String> vertexLabelTraversal)
```
    Adds a Vertex with a vertex label determined by a Traversal.
    
    Returns:
    
    the traversal with the AddVertexStep added
    
    Since:
    
    3.3.1
    
    See Also:
    
    Reference Documentation - AddVertex Step
  - addV
```
default GraphTraversal<S,Vertex> addV()
```
    Adds a Vertex with a default vertex label.
    
    Returns:
    
    the traversal with the AddVertexStep added
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - AddVertex Step
  - addE
```
default GraphTraversal<S,Edge> addE(String edgeLabel)
```
    Adds an Edge with the specified edge label.
    
    Parameters:
    
    edgeLabel - the label of the newly added edge
    
    Returns:
    
    the traversal with the AddEdgeStep added
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - AddEdge Step
  - addE
```
default GraphTraversal<S,Edge> addE(Traversal<?,String> edgeLabelTraversal)
```
    Adds a Edge with an edge label determined by a Traversal.
    
    Returns:
    
    the traversal with the AddEdgeStep added
    
    Since:
    
    3.3.1
    
    See Also:
    
    Reference Documentation - AddEdge Step
  - to
```
default GraphTraversal<S,E> to(String toStepLabel)
```
    Provide to()-modulation to respective steps.
    
    Parameters:
    
    toStepLabel - the step label to modulate to.
    
    Returns:
    
    the traversal with the modified FromToModulating step.
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - To Step
  - from
```
default GraphTraversal<S,E> from(String fromStepLabel)
```
    Provide from()-modulation to respective steps.
    
    Parameters:
    
    fromStepLabel - the step label to modulate to.
    
    Returns:
    
    the traversal with the modified FromToModulating step.
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - From Step
  - to
```
default GraphTraversal<S,E> to(Traversal<?,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.
    
    Parameters:
    
    toVertex - the traversal for selecting the incoming vertex
    
    Returns:
    
    the traversal with the modified AddEdgeStep
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - From Step
  - from
```
default GraphTraversal<S,E> from(Traversal<?,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.
    
    Parameters:
    
    fromVertex - the traversal for selecting the outgoing vertex
    
    Returns:
    
    the traversal with the modified AddEdgeStep
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - From Step
  - to
```
default GraphTraversal<S,E> 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.
    
    Parameters:
    
    toVertex - the vertex for selecting the incoming vertex
    
    Returns:
    
    the traversal with the modified AddEdgeStep
    
    Since:
    
    3.3.0
    
    See Also:
    
    Reference Documentation - From Step
  - from
```
default GraphTraversal<S,E> 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.
    
    Parameters:
    
    fromVertex - the vertex for selecting the outgoing vertex
    
    Returns:
    
    the traversal with the modified AddEdgeStep
    
    Since:
    
    3.3.0
    
    See Also:
    
    Reference Documentation - From Step
  - math
```
default GraphTraversal<S,Double> math(String expression)
```
    Map the Traverser to a Double according to the mathematical expression provided in the argument.
    
    Parameters:
    
    expression - the mathematical expression with variables refering to scope variables.
    
    Returns:
    
    the traversal with the MathStep added.
    
    Since:
    
    3.3.1
  - filter
```
default GraphTraversal<S,E> filter(Predicate<Traverser<E>> predicate)
```
    Map the Traverser to either true or false, where false will not pass the traverser to the next step.
    
    Parameters:
    
    predicate - the filter function to apply
    
    Returns:
    
    the traversal with the LambdaFilterStep added
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - General Steps
  - filter
```
default GraphTraversal<S,E> filter(Traversal<?,?> filterTraversal)
```
    Map the Traverser to either true or false, where false will not pass the traverser to the next step.
    
    Parameters:
    
    filterTraversal - the filter traversal to apply
    
    Returns:
    
    the traversal with the TraversalFilterStep added
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - General Steps
  - or
```
default GraphTraversal<S,E> or(Traversal<?,?>... orTraversals)
```
    Ensures that at least one of the provided traversals yield a result.
    
    Parameters:
    
    orTraversals - filter traversals where at least one must be satisfied
    
    Returns:
    
    the traversal with an appended OrStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Or Step
  - and
```
default GraphTraversal<S,E> and(Traversal<?,?>... andTraversals)
```
    Ensures that all of the provided traversals yield a result.
    
    Parameters:
    
    andTraversals - filter traversals that must be satisfied
    
    Returns:
    
    the traversal with an appended AndStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - And Step
  - inject
```
default GraphTraversal<S,E> inject(E... injections)
```
    Provides a way to add arbitrary objects to a traversal stream.
    
    Parameters:
    
    injections - the objects to add to the stream
    
    Returns:
    
    the traversal with an appended InjectStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Inject Step
  - dedup
```
default GraphTraversal<S,E> dedup(Scope scope,
                                        String... dedupLabels)
```
    Remove all duplicates in the traversal stream up to this point.
    
    Parameters:
    
    scope - whether the deduplication is on the stream (global) or the current object (local).
    
    dedupLabels - if labels are provided, then the scope labels determine de-duplication. No labels implies current object.
    
    Returns:
    
    the traversal with an appended DedupGlobalStep or DedupLocalStep depending on scope
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Dedup Step
  - dedup
```
default GraphTraversal<S,E> dedup(String... dedupLabels)
```
    Remove all duplicates in the traversal stream up to this point.
    
    Parameters:
    
    dedupLabels - if labels are provided, then the scoped object's labels determine de-duplication. No labels implies current object.
    
    Returns:
    
    the traversal with an appended DedupGlobalStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Dedup Step
  - where
```
default GraphTraversal<S,E> where(String startKey,
                                        P<String> predicate)
```
    Filters the current object based on the object itself or the path history.
    
    Parameters:
    
    startKey - the key containing the object to filter
    
    predicate - the filter to apply
    
    Returns:
    
    the traversal with an appended WherePredicateStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Where Step, Reference Documentation - Where with Match, Reference Documentation - Where with Select
  - where
```
default GraphTraversal<S,E> where(P<String> predicate)
```
    Filters the current object based on the object itself or the path history.
    
    Parameters:
    
    predicate - the filter to apply
    
    Returns:
    
    the traversal with an appended WherePredicateStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Where Step, Reference Documentation - Where with Match, Reference Documentation - Where with Select
  - where
```
default GraphTraversal<S,E> where(Traversal<?,?> whereTraversal)
```
    Filters the current object based on the object itself or the path history.
    
    Parameters:
    
    whereTraversal - the filter to apply
    
    Returns:
    
    the traversal with an appended WherePredicateStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Where Step, Reference Documentation - Where with Match, Reference Documentation - Where with Select
  - has
```
default GraphTraversal<S,E> has(String propertyKey,
                                      P<?> predicate)
```
    Filters vertices, edges and vertex properties based on their properties.
    
    Parameters:
    
    propertyKey - the key of the property to filter on
    
    predicate - the filter to apply to the key's value
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default GraphTraversal<S,E> has(T accessor,
                                      P<?> predicate)
```
    Filters vertices, edges and vertex properties based on their properties.
    
    Parameters:
    
    accessor - the T accessor of the property to filter on
    
    predicate - the filter to apply to the key's value
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default GraphTraversal<S,E> has(String propertyKey,
                                      Object value)
```
    Filters vertices, edges and vertex properties based on their properties.
    
    Parameters:
    
    propertyKey - the key of the property to filter on
    
    value - the value to compare the property value to for equality
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default GraphTraversal<S,E> has(T accessor,
                                      Object value)
```
    Filters vertices, edges and vertex properties based on their properties.
    
    Parameters:
    
    accessor - the T accessor of the property to filter on
    
    value - the value to compare the accessor value to for equality
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default GraphTraversal<S,E> has(String label,
                                      String propertyKey,
                                      P<?> predicate)
```
    Filters vertices, edges and vertex properties based on their properties.
    
    Parameters:
    
    label - the label of the Element
    
    propertyKey - the key of the property to filter on
    
    predicate - the filter to apply to the key's value
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default GraphTraversal<S,E> has(String label,
                                      String propertyKey,
                                      Object value)
```
    Filters vertices, edges and vertex properties based on their properties.
    
    Parameters:
    
    label - the label of the Element
    
    propertyKey - the key of the property to filter on
    
    value - the value to compare the accessor value to for equality
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default GraphTraversal<S,E> has(T accessor,
                                      Traversal<?,?> propertyTraversal)
```
    Filters vertices, edges and vertex properties based on their value of T where only T.id and T.label are supported.
    
    Parameters:
    
    accessor - the T accessor of the property to filter on
    
    propertyTraversal - the traversal to filter the accessor value by
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.1.0-incubating
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default GraphTraversal<S,E> has(String propertyKey,
                                      Traversal<?,?> propertyTraversal)
```
    Filters vertices, edges and vertex properties based on the value of the specified property key.
    
    Parameters:
    
    propertyKey - the key of the property to filter on
    
    propertyTraversal - the traversal to filter the property value by
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default GraphTraversal<S,E> has(String propertyKey)
```
    Filters vertices, edges and vertex properties based on the existence of properties.
    
    Parameters:
    
    propertyKey - the key of the property to filter on for existence
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Has Step
  - hasNot
```
default GraphTraversal<S,E> hasNot(String propertyKey)
```
    Filters vertices, edges and vertex properties based on the non-existence of properties.
    
    Parameters:
    
    propertyKey - the key of the property to filter on for existence
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Has Step
  - hasLabel
```
default GraphTraversal<S,E> hasLabel(String label,
                                           String... otherLabels)
```
    Filters vertices, edges and vertex properties based on their label.
    
    Parameters:
    
    label - the label of the Element
    
    otherLabels - additional labels of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.2.2
    
    See Also:
    
    Reference Documentation - Has Step
  - hasLabel
```
default GraphTraversal<S,E> hasLabel(P<String> predicate)
```
    Filters vertices, edges and vertex properties based on their label. Note that calling this step with null is the same as calling hasLabel(String, String...) with a single null.
    
    Parameters:
    
    predicate - the filter to apply to the label of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.2.4
    
    See Also:
    
    Reference Documentation - Has Step
  - hasId
```
default GraphTraversal<S,E> hasId(Object id,
                                        Object... otherIds)
```
    Filters vertices, edges and vertex properties based on their identifier.
    
    Parameters:
    
    id - the identifier of the Element
    
    otherIds - additional identifiers of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.2.2
    
    See Also:
    
    Reference Documentation - Has Step
  - hasId
```
default GraphTraversal<S,E> hasId(P<Object> predicate)
```
    Filters vertices, edges and vertex properties based on their identifier.
    
    Parameters:
    
    predicate - the filter to apply to the identifier of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.2.4
    
    See Also:
    
    Reference Documentation - Has Step
  - hasKey
```
default GraphTraversal<S,E> hasKey(String label,
                                         String... otherLabels)
```
    Filters Property objects based on their key. It is not meant to test key existence on an Edge or a Vertex. In that case, prefer has(String).
    
    Parameters:
    
    label - the key of the Property
    
    otherLabels - additional key of the Property
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.2.2
    
    See Also:
    
    Reference Documentation - Has Step
  - hasKey
```
default GraphTraversal<S,E> hasKey(P<String> predicate)
```
    Filters Property objects based on their key. It is not meant to test key existence on an Edge or a Vertex. In that case, prefer has(String). Note that calling this step with null is the same as calling hasKey(String, String...) with a single null.
    
    Parameters:
    
    predicate - the filter to apply to the key of the Property
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.2.4
    
    See Also:
    
    Reference Documentation - Has Step
  - hasValue
```
default GraphTraversal<S,E> hasValue(Object value,
                                           Object... otherValues)
```
    Filters Property objects based on their value.
    
    Parameters:
    
    value - the value of the Element
    
    otherValues - additional values of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    See Also:
    
    Reference Documentation - Has Step
  - hasValue
```
default GraphTraversal<S,E> hasValue(P<Object> predicate)
```
    Filters Property objects based on their value.Note that calling this step with null is the same as calling hasValue(Object, Object...) with a single null.
    
    Parameters:
    
    predicate - the filter to apply to the value of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    Since:
    
    3.2.4
    
    See Also:
    
    Reference Documentation - Has Step
  - is
```
default GraphTraversal<S,E> is(P<E> predicate)
```
    Filters E object values given the provided predicate.
    
    Parameters:
    
    predicate - the filter to apply
    
    Returns:
    
    the traversal with an appended IsStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Is Step
  - is
```
default GraphTraversal<S,E> is(Object value)
```
    Filter the E object if it is not P.eq(V) to the provided value.
    
    Parameters:
    
    value - the value that the object must equal.
    
    Returns:
    
    the traversal with an appended IsStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Is Step
  - not
```
default GraphTraversal<S,E> not(Traversal<?,?> notTraversal)
```
    Removes objects from the traversal stream when the traversal provided as an argument does not return any objects.
    
    Parameters:
    
    notTraversal - the traversal to filter by.
    
    Returns:
    
    the traversal with an appended NotStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Not Step
  - coin
```
default GraphTraversal<S,E> coin(double probability)
```
    Filter the E object given a biased coin toss.
    
    Parameters:
    
    probability - the probability that the object will pass through
    
    Returns:
    
    the traversal with an appended CoinStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Coin Step
  - range
```
default GraphTraversal<S,E> range(long low,
                                        long high)
```
    Filter the objects in the traversal by the number of them to pass through the stream. Those before the value of low do not pass through and those that exceed the value of high will end the iteration.
    
    Parameters:
    
    low - the number at which to start allowing objects through the stream
    
    high - the number at which to end the stream - use -1 to emit all remaining objects
    
    Returns:
    
    the traversal with an appended RangeGlobalStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Range Step
  - range
```
default <E2> GraphTraversal<S,E2> 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. Those before the value of low do not pass through and those that exceed the value of high will end the iteration.
    
    Parameters:
    
    scope - the scope of how to apply the range
    
    low - the number at which to start allowing objects through the stream
    
    high - the number at which to end the stream - use -1 to emit all remaining objects
    
    Returns:
    
    the traversal with an appended RangeGlobalStep or RangeLocalStep depending on scope
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Range Step
  - limit
```
default GraphTraversal<S,E> 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.
    
    Parameters:
    
    limit - the number at which to end the stream
    
    Returns:
    
    the traversal with an appended RangeGlobalStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Limit Step
  - limit
```
default <E2> GraphTraversal<S,E2> 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.
    
    Parameters:
    
    scope - the scope of how to apply the limit
    
    limit - the number at which to end the stream
    
    Returns:
    
    the traversal with an appended RangeGlobalStep or RangeLocalStep depending on scope
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Limit Step
  - tail
```
default GraphTraversal<S,E> tail()
```
    Filters the objects in the traversal emitted as being last objects in the stream. In this case, only the last object will be returned.
    
    Returns:
    
    the traversal with an appended TailGlobalStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Tail Step
  - tail
```
default GraphTraversal<S,E> tail(long limit)
```
    Filters the objects in the traversal emitted as being last objects in the stream. In this case, only the last n objects will be returned as defined by the limit.
    
    Parameters:
    
    limit - the number at which to end the stream
    
    Returns:
    
    the traversal with an appended TailGlobalStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Tail Step
  - tail
```
default <E2> GraphTraversal<S,E2> tail(Scope scope)
```
    Filters the objects in the traversal emitted as being last objects in the stream given the Scope. In this case, only the last object in the stream will be returned.
    
    Parameters:
    
    scope - the scope of how to apply the tail
    
    Returns:
    
    the traversal with an appended TailGlobalStep or TailLocalStep depending on scope
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Tail Step
  - tail
```
default <E2> GraphTraversal<S,E2> tail(Scope scope,
                                             long limit)
```
    Filters the objects in the traversal emitted as being last objects in the stream given the Scope. In this case, only the last n objects will be returned as defined by the limit.
    
    Parameters:
    
    scope - the scope of how to apply the tail
    
    limit - the number at which to end the stream
    
    Returns:
    
    the traversal with an appended TailGlobalStep or TailLocalStep depending on scope
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Tail Step
  - skip
```
default GraphTraversal<S,E> skip(long skip)
```
    Filters out the first n objects in the traversal.
    
    Parameters:
    
    skip - the number of objects to skip
    
    Returns:
    
    the traversal with an appended RangeGlobalStep
    
    Since:
    
    3.3.0
    
    See Also:
    
    Reference Documentation - Skip Step
  - skip
```
default <E2> GraphTraversal<S,E2> skip(Scope scope,
                                             long skip)
```
    Filters out the first n objects in the traversal.
    
    Parameters:
    
    scope - the scope of how to apply the tail
    
    skip - the number of objects to skip
    
    Returns:
    
    the traversal with an appended RangeGlobalStep or RangeLocalStep depending on scope
    
    Since:
    
    3.3.0
    
    See Also:
    
    Reference Documentation - Skip Step
  - timeLimit
```
default GraphTraversal<S,E> timeLimit(long timeLimit)
```
    Once the first Traverser hits this step, a count down is started. Once the time limit is up, all remaining traversers are filtered out.
    
    Parameters:
    
    timeLimit - the count down time
    
    Returns:
    
    the traversal with an appended TimeLimitStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - TimeLimit Step
  - simplePath
```
default GraphTraversal<S,E> simplePath()
```
    Filter the E object if its Traverser.path() is not Path.isSimple().
    
    Returns:
    
    the traversal with an appended PathFilterStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - SimplePath Step
  - cyclicPath
```
default GraphTraversal<S,E> cyclicPath()
```
    Filter the E object if its Traverser.path() is Path.isSimple().
    
    Returns:
    
    the traversal with an appended PathFilterStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - CyclicPath Step
  - sample
```
default GraphTraversal<S,E> sample(int amountToSample)
```
    Allow some specified number of objects to pass through the stream.
    
    Parameters:
    
    amountToSample - the number of objects to allow
    
    Returns:
    
    the traversal with an appended SampleGlobalStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Sample Step
  - sample
```
default GraphTraversal<S,E> sample(Scope scope,
                                         int amountToSample)
```
    Allow some specified number of objects to pass through the stream.
    
    Parameters:
    
    scope - the scope of how to apply the sample
    
    amountToSample - the number of objects to allow
    
    Returns:
    
    the traversal with an appended SampleGlobalStep or SampleLocalStep depending on the scope
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Sample Step
  - drop
```
default GraphTraversal<S,E> drop()
```
    Removes elements and properties from the graph. This step is not a terminating, in the sense that it does not automatically iterate the traversal. It is therefore necessary to do some form of iteration for the removal to actually take place. In most cases, iteration is best accomplished with g.V().drop().iterate().
    
    Returns:
    
    the traversal with the DropStep added
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Drop Step
  - sideEffect
```
default GraphTraversal<S,E> sideEffect(Consumer<Traverser<E>> consumer)
```
    Perform some operation on the Traverser and pass it to the next step unmodified.
    
    Parameters:
    
    consumer - the operation to perform at this step in relation to the Traverser
    
    Returns:
    
    the traversal with an appended LambdaSideEffectStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - General Steps
  - sideEffect
```
default GraphTraversal<S,E> sideEffect(Traversal<?,?> sideEffectTraversal)
```
    Perform some operation on the Traverser and pass it to the next step unmodified.
    
    Parameters:
    
    sideEffectTraversal - the operation to perform at this step in relation to the Traverser
    
    Returns:
    
    the traversal with an appended TraversalSideEffectStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - General Steps
  - cap
```
default <E2> GraphTraversal<S,E2> cap(String sideEffectKey,
                                            String... sideEffectKeys)
```
    Iterates the traversal up to the itself and emits the side-effect referenced by the key. If multiple keys are supplied then the side-effects are emitted as a Map.
    
    Parameters:
    
    sideEffectKey - the side-effect to emit
    
    sideEffectKeys - other side-effects to emit
    
    Returns:
    
    the traversal with an appended SideEffectCapStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Cap Step
  - subgraph
```
default GraphTraversal<S,Edge> subgraph(String sideEffectKey)
```
    Extracts a portion of the graph being traversed into a Graph object held in the specified side-effect key.
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the subgraph
    
    Returns:
    
    the traversal with an appended SubgraphStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Subgraph Step
  - aggregate
```
default GraphTraversal<S,E> aggregate(String sideEffectKey)
```
    Eagerly collects objects up to this step into a side-effect. Same as calling aggregate(Scope, String) with a Scope.global.
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the aggregated objects
    
    Returns:
    
    the traversal with an appended AggregateGlobalStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Aggregate Step
  - aggregate
```
default GraphTraversal<S,E> aggregate(Scope scope,
                                            String sideEffectKey)
```
    Collects objects in a list using the Scope argument to determine whether it should be lazy Scope.local or eager (Scope.global while gathering those objects.
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the aggregated objects
    
    Returns:
    
    the traversal with an appended AggregateGlobalStep
    
    Since:
    
    3.4.3
    
    See Also:
    
    Reference Documentation - Aggregate Step
  - group
```
default GraphTraversal<S,E> group(String sideEffectKey)
```
    Organize objects in the stream into a Map. Calls to group() are typically accompanied with by() modulators which help specify how the grouping should occur.
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the aggregated grouping
    
    Returns:
    
    the traversal with an appended GroupStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Group Step
  - groupCount
```
default GraphTraversal<S,E> 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.
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the aggregated grouping
    
    Returns:
    
    the traversal with an appended GroupCountStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - GroupCount Step
  - tree
```
default GraphTraversal<S,E> tree(String sideEffectKey)
```
    Aggregates the emanating paths into a Tree data structure.
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the tree
    
    Returns:
    
    the traversal with an appended TreeStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Tree Step
  - sack
```
default <V,U> GraphTraversal<S,E> sack(BiFunction<V,U,V> sackOperator)
```
    Map the Traverser to its Traverser.sack() value.
    
    Parameters:
    
    sackOperator - the operator to apply to the sack value
    
    Returns:
    
    the traversal with an appended SackStep.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Sack Step
  - store
```
@Deprecated
default GraphTraversal<S,E> store(String sideEffectKey)
```
    Deprecated.
    As of release 3.4.3, replaced by aggregate(Scope, String) using Scope.local.
    
    Lazily aggregates objects in the stream into a side-effect collection.
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the aggregate
    
    Returns:
    
    the traversal with an appended AggregateLocalStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Store Step
  - profile
```
default GraphTraversal<S,E> profile(String sideEffectKey)
```
    Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key within which to hold the profile object
    
    Returns:
    
    the traversal with an appended ProfileSideEffectStep
    
    Since:
    
    3.2.0-incubating
    
    See Also:
    
    Reference Documentation - Profile Step
  - profile
```
default GraphTraversal<S,TraversalMetrics> profile()
```
    Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
    
    Specified by:
    
    profile in interface Traversal<S,E>
    
    Returns:
    
    the traversal with an appended ProfileSideEffectStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Profile Step
  - none
```
default GraphTraversal<S,E> none()
```
    Filter all traversers in the traversal. This step has narrow use cases and is primarily intended for use as a signal to remote servers that iterate() was called. While it may be directly used, it is often a sign that a traversal should be re-written in another form.
    
    Specified by:
    
    none in interface Traversal<S,E>
    
    Returns:
    
    the updated traversal with respective NoneStep.
  - property
```
default GraphTraversal<S,E> 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. This method is the long-hand version of property(Object, Object, Object...) with the difference that the VertexProperty.Cardinality can be supplied.
    Generally speaking, this method will append an AddPropertyStep to the Traversal but when possible, this method will attempt to fold key/value pairs into an AddVertexStep, AddEdgeStep or AddVertexStartStep. This potential optimization can only happen if cardinality is not supplied and when meta-properties are not included.
    
    Parameters:
    
    cardinality - the specified cardinality of the property where null will allow the Graph to use its default settings
    
    key - the key for the property
    
    value - the value for the property
    
    keyValues - any meta properties to be assigned to this property
    
    Returns:
    
    the traversal with the last step modified to add a property
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    AddProperty Step
  - property
```
default GraphTraversal<S,E> property(Object key,
                                           Object value,
                                           Object... keyValues)
```
    Sets the key and value of a Property. If the Element is a VertexProperty and the Graph supports it, meta properties can be set. Use of this method assumes that the VertexProperty.Cardinality is defaulted to null which means that the default cardinality for the Graph will be used.
    This method is effectively calls property(VertexProperty.Cardinality, Object, Object, Object...) as property(null, key, value, keyValues.
    
    Parameters:
    
    key - the key for the property
    
    value - the value for the property
    
    keyValues - any meta properties to be assigned to this property
    
    Returns:
    
    the traversal with the last step modified to add a property
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    AddProperty Step
  - branch
```
default <M,E2> GraphTraversal<S,E2> branch(Traversal<?,M> branchTraversal)
```
    Split the Traverser to all the specified traversals.
    
    Parameters:
    
    branchTraversal - the traversal to branch the Traverser to
    
    Returns:
    
    the Traversal with the BranchStep added
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - General Steps
  - branch
```
default <M,E2> GraphTraversal<S,E2> branch(Function<Traverser<E>,M> function)
```
    Split the Traverser to all the specified functions.
    
    Parameters:
    
    function - the traversal to branch the Traverser to
    
    Returns:
    
    the Traversal with the BranchStep added
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - General Steps
  - choose
```
default <M,E2> GraphTraversal<S,E2> 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. A choose is modified by option(M, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?, E2>) which provides the various branch choices.
    
    Parameters:
    
    choiceTraversal - the traversal used to determine the value for the branch
    
    Returns:
    
    the traversal with the appended ChooseStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Choose Step
  - choose
```
default <E2> GraphTraversal<S,E2> 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.
    
    Parameters:
    
    traversalPredicate - the traversal used to determine the "if" portion of the if-then-else
    
    trueChoice - the traversal to execute in the event the traversalPredicate returns true
    
    falseChoice - the traversal to execute in the event the traversalPredicate returns false
    
    Returns:
    
    the traversal with the appended ChooseStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Choose Step
  - choose
```
default <E2> GraphTraversal<S,E2> 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.
    
    Parameters:
    
    traversalPredicate - the traversal used to determine the "if" portion of the if-then-else
    
    trueChoice - the traversal to execute in the event the traversalPredicate returns true
    
    Returns:
    
    the traversal with the appended ChooseStep
    
    Since:
    
    3.2.4
    
    See Also:
    
    Reference Documentation - Choose Step
  - choose
```
default <M,E2> GraphTraversal<S,E2> 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. A choose is modified by option(M, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?, E2>) which provides the various branch choices.
    
    Parameters:
    
    choiceFunction - the function used to determine the value for the branch
    
    Returns:
    
    the traversal with the appended ChooseStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Choose Step
  - choose
```
default <E2> GraphTraversal<S,E2> 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.
    
    Parameters:
    
    choosePredicate - the function used to determine the "if" portion of the if-then-else
    
    trueChoice - the traversal to execute in the event the traversalPredicate returns true
    
    falseChoice - the traversal to execute in the event the traversalPredicate returns false
    
    Returns:
    
    the traversal with the appended ChooseStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Choose Step
  - choose
```
default <E2> GraphTraversal<S,E2> 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.
    
    Parameters:
    
    choosePredicate - the function used to determine the "if" portion of the if-then-else
    
    trueChoice - the traversal to execute in the event the traversalPredicate returns true
    
    Returns:
    
    the traversal with the appended ChooseStep
    
    Since:
    
    3.2.4
    
    See Also:
    
    Reference Documentation - Choose Step
  - optional
```
default <E2> GraphTraversal<S,E2> optional(Traversal<?,E2> optionalTraversal)
```
    Returns the result of the specified traversal if it yields a result, otherwise it returns the calling element.
    
    Parameters:
    
    optionalTraversal - the traversal to execute for a potential result
    
    Returns:
    
    the traversal with the appended ChooseStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Optional Step
  - union
```
default <E2> GraphTraversal<S,E2> union(Traversal<?,E2>... unionTraversals)
```
    Merges the results of an arbitrary number of traversals.
    
    Parameters:
    
    unionTraversals - the traversals to merge
    
    Returns:
    
    the traversal with the appended UnionStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Union Step
  - coalesce
```
default <E2> GraphTraversal<S,E2> coalesce(Traversal<?,E2>... coalesceTraversals)
```
    Evaluates the provided traversals and returns the result of the first traversal to emit at least one object.
    
    Parameters:
    
    coalesceTraversals - the traversals to coalesce
    
    Returns:
    
    the traversal with the appended CoalesceStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Coalesce Step
  - repeat
```
default GraphTraversal<S,E> repeat(Traversal<?,E> repeatTraversal)
```
    This step is used for looping over a traversal given some break predicate.
    
    Parameters:
    
    repeatTraversal - the traversal to repeat over
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Repeat Step
  - repeat
```
default GraphTraversal<S,E> repeat(String loopName,
                                         Traversal<?,E> repeatTraversal)
```
    This step is used for looping over a traversal given some break predicate and with a specified loop name.
    
    Parameters:
    
    repeatTraversal - the traversal to repeat over
    
    loopName - The name given to the loop
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    Since:
    
    3.4.0
    
    See Also:
    
    Reference Documentation - Repeat Step
  - emit
```
default GraphTraversal<S,E> emit(Traversal<?,?> emitTraversal)
```
    Emit is used in conjunction with repeat(Traversal) to determine what objects get emit from the loop.
    
    Parameters:
    
    emitTraversal - the emit predicate defined as a traversal
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Repeat Step
  - emit
```
default GraphTraversal<S,E> emit(Predicate<Traverser<E>> emitPredicate)
```
    Emit is used in conjunction with repeat(Traversal) to determine what objects get emit from the loop.
    
    Parameters:
    
    emitPredicate - the emit predicate
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Repeat Step
  - emit
```
default GraphTraversal<S,E> emit()
```
    Emit is used in conjunction with repeat(Traversal) to emit all objects from the loop.
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Repeat Step
  - until
```
default GraphTraversal<S,E> until(Traversal<?,?> untilTraversal)
```
    Modifies a repeat(Traversal) to determine when the loop should exit.
    
    Parameters:
    
    untilTraversal - the traversal that determines when the loop exits
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Repeat Step
  - until
```
default GraphTraversal<S,E> until(Predicate<Traverser<E>> untilPredicate)
```
    Modifies a repeat(Traversal) to determine when the loop should exit.
    
    Parameters:
    
    untilPredicate - the predicate that determines when the loop exits
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Repeat Step
  - times
```
default GraphTraversal<S,E> times(int maxLoops)
```
    Modifies a repeat(Traversal) to specify how many loops should occur before exiting.
    
    Parameters:
    
    maxLoops - the number of loops to execute prior to exiting
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Repeat Step
  - local
```
default <E2> GraphTraversal<S,E2> local(Traversal<?,E2> localTraversal)
```
    Provides a execute a specified traversal on a single element within a stream.
    
    Parameters:
    
    localTraversal - the traversal to execute locally
    
    Returns:
    
    the traversal with the appended LocalStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Local Step
  - pageRank
```
default GraphTraversal<S,E> pageRank()
```
    Calculates a PageRank over the graph using a 0.85 for the alpha value.
    
    Returns:
    
    the traversal with the appended PageRankVertexProgramStep
    
    Since:
    
    3.2.0-incubating
    
    See Also:
    
    Reference Documentation - PageRank Step
  - pageRank
```
default GraphTraversal<S,E> pageRank(double alpha)
```
    Calculates a PageRank over the graph.
    
    Returns:
    
    the traversal with the appended PageRankVertexProgramStep
    
    Since:
    
    3.2.0-incubating
    
    See Also:
    
    Reference Documentation - PageRank Step
  - peerPressure
```
default GraphTraversal<S,E> peerPressure()
```
    Executes a Peer Pressure community detection algorithm over the graph.
    
    Returns:
    
    the traversal with the appended PeerPressureVertexProgramStep
    
    Since:
    
    3.2.0-incubating
    
    See Also:
    
    Reference Documentation - PeerPressure Step
  - connectedComponent
```
default GraphTraversal<S,E> connectedComponent()
```
    Executes a Connected Component algorithm over the graph.
    
    Returns:
    
    the traversal with the appended ConnectedComponentVertexProgram
    
    Since:
    
    3.4.0
    
    See Also:
    
    Reference Documentation - ConnectedComponent Step
  - shortestPath
```
default GraphTraversal<S,Path> shortestPath()
```
    Executes a Shortest Path algorithm over the graph.
    
    Returns:
    
    the traversal with the appended ShortestPathVertexProgramStep
    
    See Also:
    
    Reference Documentation - ShortestPath Step
  - program
```
default GraphTraversal<S,E> program(VertexProgram<?> vertexProgram)
```
    Executes an arbitrary VertexProgram over the graph.
    
    Returns:
    
    the traversal with the appended ProgramVertexProgramStep
    
    Since:
    
    3.2.0-incubating
    
    See Also:
    
    Reference Documentation - Program Step
  - as
```
default GraphTraversal<S,E> as(String stepLabel,
                                     String... stepLabels)
```
    A step modulator that provides a label to the step that can be accessed later in the traversal by other steps.
    
    Parameters:
    
    stepLabel - the name of the step
    
    stepLabels - additional names for the label
    
    Returns:
    
    the traversal with the modified end step
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - As Step
  - barrier
```
default GraphTraversal<S,E> barrier()
```
    Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier. In this case, it iterates the entire thing as the default barrier size is set to Integer.MAX_VALUE.
    
    Returns:
    
    the traversal with an appended NoOpBarrierStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Barrier Step
  - barrier
```
default GraphTraversal<S,E> barrier(int maxBarrierSize)
```
    Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
    
    Parameters:
    
    maxBarrierSize - the size of the barrier
    
    Returns:
    
    the traversal with an appended NoOpBarrierStep
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Barrier Step
  - index
```
default <E2> GraphTraversal<S,E2> index()
```
    Indexes all items of the current collection. The indexing format can be configured using the with(String, Object) and WithOptions.indexer. Indexed as list: ["a","b","c"] => [["a",0],["b",1],["c",2]] Indexed as map: ["a","b","c"] => {0:"a",1:"b",2:"c"} If the current object is not a collection, this step will map the object to a single item collection/map: Indexed as list: "a" => ["a",0] Indexed as map: "a" => {0:"a"}
    
    Returns:
    
    the traversal with an appended IndexStep
    
    Since:
    
    3.4.0
    
    See Also:
    
    Reference Documentation - Index Step
  - barrier
```
default GraphTraversal<S,E> 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. In this case, it iterates the entire thing as the default barrier size is set to Integer.MAX_VALUE.
    
    Parameters:
    
    barrierConsumer - a consumer function that is applied to the objects aggregated to the barrier
    
    Returns:
    
    the traversal with an appended NoOpBarrierStep
    
    Since:
    
    3.2.0-incubating
    
    See Also:
    
    Reference Documentation - Barrier Step
  - with
```
default GraphTraversal<S,E> with(String key)
```
    Provides a configuration to a step in the form of a key which is the same as with(key, true). The key of the configuration must be step specific and therefore a configuration could be supplied that is not known to be valid until execution.
    
    Parameters:
    
    key - the key of the configuration to apply to a step
    
    Returns:
    
    the traversal with a modulated step
    
    Since:
    
    3.4.0
    
    See Also:
    
    Reference Documentation - With Step
  - with
```
default GraphTraversal<S,E> with(String key,
                                       Object value)
```
    Provides a configuration to a step in the form of a key and value pair. The key of the configuration must be step specific and therefore a configuration could be supplied that is not known to be valid until execution.
    
    Parameters:
    
    key - the key of the configuration to apply to a step
    
    value - the value of the configuration to apply to a step
    
    Returns:
    
    the traversal with a modulated step
    
    Since:
    
    3.4.0
    
    See Also:
    
    Reference Documentation - With Step
  - by
```
default GraphTraversal<S,E> by()
```
    The by() can be applied to a number of different step to alter their behaviors. This form is essentially an identity() modulation.
    
    Returns:
    
    the traversal with a modulated step.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default GraphTraversal<S,E> by(Traversal<?,?> traversal)
```
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified traversal.
    
    Parameters:
    
    traversal - the traversal to apply
    
    Returns:
    
    the traversal with a modulated step.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default GraphTraversal<S,E> by(T token)
```
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified token of T.
    
    Parameters:
    
    token - the token to apply
    
    Returns:
    
    the traversal with a modulated step.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default GraphTraversal<S,E> by(String key)
```
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified key.
    
    Parameters:
    
    key - the key to apply
    
    Returns:
    
    the traversal with a modulated step.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default <V> GraphTraversal<S,E> by(Function<V,Object> function)
```
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Parameters:
    
    function - the function to apply
    
    Returns:
    
    the traversal with a modulated step.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default <V> GraphTraversal<S,E> by(Traversal<?,?> traversal,
                                         Comparator<V> comparator)
```
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Parameters:
    
    traversal - the traversal to apply
    
    comparator - the comparator to apply typically for some order()
    
    Returns:
    
    the traversal with a modulated step.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default GraphTraversal<S,E> by(Comparator<E> comparator)
```
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Parameters:
    
    comparator - the comparator to apply typically for some order()
    
    Returns:
    
    the traversal with a modulated step.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default GraphTraversal<S,E> by(Order order)
```
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Parameters:
    
    order - the comparator to apply typically for some order()
    
    Returns:
    
    the traversal with a modulated step.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default <V> GraphTraversal<S,E> by(String key,
                                         Comparator<V> comparator)
```
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Parameters:
    
    key - the key to apply traversal
    
    comparator - the comparator to apply typically for some order()
    
    Returns:
    
    the traversal with a modulated step.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default <U> GraphTraversal<S,E> by(Function<U,Object> function,
                                         Comparator comparator)
```
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Parameters:
    
    function - the function to apply
    
    comparator - the comparator to apply typically for some order()
    
    Returns:
    
    the traversal with a modulated step.
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - By Step
  - option
```
default <M,E2> GraphTraversal<S,E> option(M pick,
                                                      Traversal<?,E2> traversalOption)
```
    This step modifies choose(Function) to specifies the available choices that might be executed.
    
    Parameters:
    
    pick - the token that would trigger this option which may be a TraversalOptionParent.Pick, a Traversal, Predicate, or object depending on the step being modulated.
    
    traversalOption - the option as a traversal
    
    Returns:
    
    the traversal with the modulated step
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Choose Step
  - option
```
default <E2> GraphTraversal<S,E> option(Traversal<?,E2> traversalOption)
```
    This step modifies choose(Function) to specifies the available choices that might be executed.
    
    Parameters:
    
    traversalOption - the option as a traversal
    
    Returns:
    
    the traversal with the modulated step
    
    Since:
    
    3.0.0-incubating
    
    See Also:
    
    Reference Documentation - Choose Step
  - read
```
default GraphTraversal<S,E> read()
```
    This step is technically a step modulator for the the GraphTraversalSource.io(String) step which instructs the step to perform a read with its given configuration.
    
    Returns:
    
    the traversal with the IoStep modulated to read
    
    Since:
    
    3.4.0
    
    See Also:
    
    Reference Documentation - IO Step, Reference Documentation - Read Step
  - write
```
default GraphTraversal<S,E> write()
```
    This step is technically a step modulator for the the GraphTraversalSource.io(String) step which instructs the step to perform a write with its given configuration.
    
    Returns:
    
    the traversal with the IoStep modulated to write
    
    Since:
    
    3.4.0
    
    See Also:
    
    Reference Documentation - IO Step, Reference Documentation - Write Step
  - iterate
```
default GraphTraversal<S,E> iterate()
```
    Iterates the traversal presumably for the generation of side-effects.
    
    Specified by:
    
    iterate in interface Traversal<S,E>
    
    Returns:
    
    the fully drained traversal

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

Interface GraphTraversal<S,​E>

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal

Method Summary

Methods inherited from interface java.util.Iterator

Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal

Method Detail

asAdmin

map

map

flatMap

flatMap

id

label

identity

constant

V

to

out

in

both

toE

outE

inE

bothE

toV

inV

outV

bothV

otherV

order

order

properties

values

propertyMap

elementMap

valueMap

valueMap

key

value

path

match

sack

loops

loops

project

select

select

select

select

select

select

select

unfold

fold

fold

count

count

sum

sum

max

max

min

min

mean

mean

group

groupCount

tree

addV

addV

addV

addE

addE

to

from

to

from

to

from

Interface GraphTraversal<S,E>