org.apache.tinkerpop.gremlin.process.traversal.dsl.graph

## Interface GraphTraversal<S,E>

- All Superinterfaces:
    AutoCloseable, Cloneable, Iterator<E>, Serializable, Traversal<S,E>
  All Known Subinterfaces:
    GraphTraversal.Admin<S,E>

      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 and 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 and 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(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>` | `aggregate(String sideEffectKey)` Eagerly collects objects up to this step into a side-effect.
    `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(Consumer<org.apache.tinkerpop.gremlin.process.traversal.traverser.util.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,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,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(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(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(T token)` 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 <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(Scope scope, String... dedupLabels)` Remove all duplicates in the traversal stream up to this point.
    `default GraphTraversal<S,E>` | `dedup(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 propertyKey, P<?> predicate)` 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, 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(P<String> predicate)` Filters vertices, edges and vertex properties based on their key.
    `default GraphTraversal<S,E>` | `hasKey(String label, String... otherLabels)` Filters vertices, edges and vertex properties based on their key.
    `default GraphTraversal<S,E>` | `hasLabel(P<String> predicate)` Filters vertices, edges and vertex properties based on their label.
    `default GraphTraversal<S,E>` | `hasLabel(String label, String... otherLabels)` 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 vertices, edges and vertex properties based on their value.
    `default GraphTraversal<S,E>` | `hasValue(P<Object> predicate)` Filters vertices, edges and vertex properties based on their value.
    `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>` | `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 pickToken, 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,org.apache.tinkerpop.gremlin.process.traversal.util.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,Collection<E2>>` | `select(Column column)` A version of `select` that allows for the extraction of a `Column` from objects in the traversal.
    `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(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(Traversal<S,E2> keyTraversal)` Map the `Traverser` to the object specified by the key returned by the `keyTraversal`.
    `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,Vertex>` | `to(Direction direction, String... edgeLabels)` Map the `Vertex` to its adjacent vertices given a direction and edge labels.
    `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,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,org.apache.tinkerpop.gremlin.process.traversal.step.util.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(P<String> predicate)` Filters the current object based on the object itself or the path history.
    `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(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 org.apache.tinkerpop.gremlin.process.traversal.Traversal

      `close, explain, fill, forEachRemaining, forEachRemaining, next, none, promise, toBulkSet, toList, toSet, toStream, tryNext`

    - ### Methods inherited from interface java.util.Iterator

      `hasNext, next, remove`

- - ### 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 calss 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,org.apache.tinkerpop.gremlin.process.traversal.step.util.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.
      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 vertices, edges and vertex properties based on their key.
      Parameters:
        `label` - the key of the `Element`
        `otherLabels` - additional key of the `Element`
      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 vertices, edges and vertex properties based on their key.
      Parameters:
        `predicate` - the filter to apply to the key of the `Element`
      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 vertices, edges and vertex properties 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 vertices, edges and vertex properties based on their value.
      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.local`.
      Parameters:
        `sideEffectKey` - the name of the side-effect key that will hold the aggregated objects
      Returns:
        the traversal with an appended `AggregateStep`
      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 `AggregateStep`
      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

          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 `StoreStep`
      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,org.apache.tinkerpop.gremlin.process.traversal.util.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

    - #### 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(org.apache.tinkerpop.gremlin.structure.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<org.apache.tinkerpop.gremlin.process.traversal.traverser.util.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 pickToken,
                                                    Traversal<?,E2> traversalOption)

      This step modifies `choose(Function)` to specifies the available choices that might be executed.
      Parameters:
        `pickToken` - the token that would trigger this option
        `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

Copyright © 2013–2020 Apache Software Foundation. All rights reserved.