All Superinterfaces:

AutoCloseable, Cloneable, CredentialTraversalDsl<S,E>, GraphTraversal<S,E>, GraphTraversal.Admin<S,E>, Iterator<E>, Serializable, Traversal<S,E>, Traversal.Admin<S,E>

All Known Implementing Classes:

DefaultCredentialTraversal
```
public interface CredentialTraversal<S,E>
extends CredentialTraversalDsl<S,E>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal
  GraphTraversal.Admin<S,E>, GraphTraversal.Symbols
- Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal
  Traversal.Admin<S,E>, Traversal.Exceptions, Traversal.Symbols

Field Summary
- Fields inherited from interface org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential.CredentialTraversalDsl
  BCRYPT_ROUNDS

Method Summary

All Methods Instance Methods Default Methods
Modifier and Type	Method	Description
`default CredentialTraversal<S,Edge>`	`addE(String edgeLabel)`	Adds an `Edge` with the specified edge label.
`default CredentialTraversal<S,Edge>`	`addE(Traversal<?,String> edgeLabelTraversal)`	Adds a `Edge` with an edge label determined by a `Traversal`.
`default CredentialTraversal<S,Vertex>`	`addV()`	Adds a `Vertex` with a default vertex label.
`default CredentialTraversal<S,Vertex>`	`addV(String vertexLabel)`	Adds a `Vertex`.
`default CredentialTraversal<S,Vertex>`	`addV(Traversal<?,String> vertexLabelTraversal)`	Adds a `Vertex` with a vertex label determined by a `Traversal`.
`default CredentialTraversal<S,E>`	`aggregate(String sideEffectKey)`	Eagerly collects objects up to this step into a side-effect.
`default CredentialTraversal<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 CredentialTraversal<S,E>`	`and(Traversal<?,?>... andTraversals)`	Ensures that all of the provided traversals yield a result.
`default CredentialTraversal<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 CredentialTraversal<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 CredentialTraversal<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 CredentialTraversal<S,E>`	`barrier(Consumer<TraverserSet<Object>> barrierConsumer)`	Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
`default CredentialTraversal<S,Vertex>`	`both(String... edgeLabels)`	Map the `Vertex` to its adjacent vertices given the edge labels.
`default CredentialTraversal<S,Edge>`	`bothE(String... edgeLabels)`	Map the `Vertex` to its incident edges given the edge labels.
`default CredentialTraversal<S,Vertex>`	`bothV()`	Map the `Edge` to its incident vertices.
`default <M,E2> CredentialTraversal<S,E2>`	`branch(Function<Traverser<E>,M> function)`	Split the `Traverser` to all the specified functions.
`default <M,E2> CredentialTraversal<S,E2>`	`branch(Traversal<?,M> branchTraversal)`	Split the `Traverser` to all the specified traversals.
`default CredentialTraversal<S,E>`	`by()`	The `by()` can be applied to a number of different step to alter their behaviors.
`default CredentialTraversal<S,E>`	`by(String key)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default <V> CredentialTraversal<S,E>`	`by(String key, Comparator<V> comparator)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default CredentialTraversal<S,E>`	`by(Comparator<E> comparator)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default <U> CredentialTraversal<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> CredentialTraversal<S,E>`	`by(Function<V,Object> function)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default CredentialTraversal<S,E>`	`by(Order order)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default CredentialTraversal<S,E>`	`by(Traversal<?,?> traversal)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default <V> CredentialTraversal<S,E>`	`by(Traversal<?,?> traversal, Comparator<V> comparator)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default CredentialTraversal<S,E>`	`by(T token)`	The `by()` can be applied to a number of different step to alter their behaviors.
`default <E> CredentialTraversal<S,E>`	`call(String service)`	Perform the specified service call with no parameters.
`default <E> CredentialTraversal<S,E>`	`call(String service, Map params)`	Perform the specified service call with the specified static parameters.
`default <E> CredentialTraversal<S,E>`	`call(String service, Map params, Traversal<?,Map<?,?>> childTraversal)`	Perform the specified service call with both static and dynamic parameters produced by the specified child traversal.
`default <E> CredentialTraversal<S,E>`	`call(String service, Traversal<?,Map<?,?>> childTraversal)`	Perform the specified service call with dynamic parameters produced by the specified child traversal.
`default <E2> CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<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 CredentialTraversal<S,E>`	`coin(double probability)`	Filter the `E` object given a biased coin toss.
`default CredentialTraversal<S,E>`	`connectedComponent()`	Executes a Connected Component algorithm over the graph.
`default <E2> CredentialTraversal<S,E2>`	`constant(E2 e)`	Map any object to a fixed `E` value.
`default CredentialTraversal<S,Long>`	`count()`	Map the traversal stream to its reduction as a sum of the `Traverser.bulk()` values (i.e.
`default CredentialTraversal<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 CredentialTraversal<S,E>`	`cyclicPath()`	Filter the `E` object if its `Traverser.path()` is `Path.isSimple()`.
`default CredentialTraversal<S,E>`	`dedup(String... dedupLabels)`	Remove all duplicates in the traversal stream up to this point.
`default CredentialTraversal<S,E>`	`dedup(Scope scope, String... dedupLabels)`	Remove all duplicates in the traversal stream up to this point.
`default CredentialTraversal<S,E>`	`drop()`	Removes elements and properties from the graph.
`default CredentialTraversal<S,Element>`	`element()`	Map a `Property` to its `Element`.
`default <E2> CredentialTraversal<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 CredentialTraversal<S,E>`	`emit()`	Emit is used in conjunction with `GraphTraversal.repeat(Traversal)` to emit all objects from the loop.
`default CredentialTraversal<S,E>`	`emit(Predicate<Traverser<E>> emitPredicate)`	Emit is used in conjunction with `GraphTraversal.repeat(Traversal)` to determine what objects get emit from the loop.
`default CredentialTraversal<S,E>`	`emit(Traversal<?,?> emitTraversal)`	Emit is used in conjunction with `GraphTraversal.repeat(Traversal)` to determine what objects get emit from the loop.
`default CredentialTraversal<S,E>`	`fail()`	When triggered, immediately throws a `RuntimeException` which implements the `Failure` interface.
`default CredentialTraversal<S,E>`	`fail(String message)`	When triggered, immediately throws a `RuntimeException` which implements the `Failure` interface.
`default CredentialTraversal<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 CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<S,E2>`	`flatMap(Traversal<?,E2> flatMapTraversal)`	Map a `Traverser` referencing an object of type `E` to an iterator of objects of type `E2`.
`default CredentialTraversal<S,List<E>>`	`fold()`	Rolls up objects in the stream into an aggregate list.
`default <E2> CredentialTraversal<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 CredentialTraversal<S,E>`	`from(String fromStepLabel)`	Provide `from()`-modulation to respective steps.
`default CredentialTraversal<S,E>`	`from(Traversal<?,Vertex> fromVertex)`	When used as a modifier to `GraphTraversal.addE(String)` this method specifies the traversal to use for selecting the outgoing vertex of the newly added `Edge`.
`default CredentialTraversal<S,E>`	`from(Vertex fromVertex)`	When used as a modifier to `GraphTraversal.addE(String)` this method specifies the traversal to use for selecting the outgoing vertex of the newly added `Edge`.
`default <K,V> CredentialTraversal<S,Map<K,V>>`	`group()`	Organize objects in the stream into a `Map`.
`default CredentialTraversal<S,E>`	`group(String sideEffectKey)`	Organize objects in the stream into a `Map`.
`default <K> CredentialTraversal<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 CredentialTraversal<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 CredentialTraversal<S,E>`	`has(String propertyKey)`	Filters vertices, edges and vertex properties based on the existence of properties.
`default CredentialTraversal<S,E>`	`has(String propertyKey, Object value)`	Filters vertices, edges and vertex properties based on their properties.
`default CredentialTraversal<S,E>`	`has(String label, String propertyKey, Object value)`	Filters vertices, edges and vertex properties based on their properties.
`default CredentialTraversal<S,E>`	`has(String label, String propertyKey, P<?> predicate)`	Filters vertices, edges and vertex properties based on their properties.
`default CredentialTraversal<S,E>`	`has(String propertyKey, P<?> predicate)`	Filters vertices, edges and vertex properties based on their properties.
`default CredentialTraversal<S,E>`	`has(String propertyKey, Traversal<?,?> propertyTraversal)`	Filters vertices, edges and vertex properties based on the value of the specified property key.
`default CredentialTraversal<S,E>`	`has(T accessor, Object value)`	Filters vertices, edges and vertex properties based on their properties.
`default CredentialTraversal<S,E>`	`has(T accessor, P<?> predicate)`	Filters vertices, edges and vertex properties based on their properties.
`default CredentialTraversal<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 CredentialTraversal<S,E>`	`hasId(Object id, Object... otherIds)`	Filters vertices, edges and vertex properties based on their identifier.
`default CredentialTraversal<S,E>`	`hasId(P<Object> predicate)`	Filters vertices, edges and vertex properties based on their identifier.
`default CredentialTraversal<S,E>`	`hasKey(String label, String... otherLabels)`	Filters `Property` objects based on their key.
`default CredentialTraversal<S,E>`	`hasKey(P<String> predicate)`	Filters `Property` objects based on their key.
`default CredentialTraversal<S,E>`	`hasLabel(String label, String... otherLabels)`	Filters vertices, edges and vertex properties based on their label.
`default CredentialTraversal<S,E>`	`hasLabel(P<String> predicate)`	Filters vertices, edges and vertex properties based on their label.
`default CredentialTraversal<S,E>`	`hasNot(String propertyKey)`	Filters vertices, edges and vertex properties based on the non-existence of properties.
`default CredentialTraversal<S,E>`	`hasValue(Object value, Object... otherValues)`	Filters `Property` objects based on their value.
`default CredentialTraversal<S,E>`	`hasValue(P<Object> predicate)`	Filters `Property` objects based on their value.Note that calling this step with `null` is the same as calling `GraphTraversal.hasValue(Object, Object...)` with a single `null`.
`default CredentialTraversal<S,Object>`	`id()`	Map the `Element` to its `Element.id()`.
`default CredentialTraversal<S,E>`	`identity()`	Map the `E` object to itself.
`default CredentialTraversal<S,Vertex>`	`in(String... edgeLabels)`	Map the `Vertex` to its incoming adjacent vertices given the edge labels.
`default <E2> CredentialTraversal<S,E2>`	`index()`	Indexes all items of the current collection.
`default CredentialTraversal<S,Edge>`	`inE(String... edgeLabels)`	Map the `Vertex` to its incoming incident edges given the edge labels.
`default CredentialTraversal<S,E>`	`inject(E... injections)`	Provides a way to add arbitrary objects to a traversal stream.
`default CredentialTraversal<S,Vertex>`	`inV()`	Map the `Edge` to its incoming/head incident `Vertex`.
`default CredentialTraversal<S,E>`	`is(Object value)`	Filter the `E` object if it is not `P.eq(V)` to the provided value.
`default CredentialTraversal<S,E>`	`is(P<E> predicate)`	Filters `E` object values given the provided `predicate`.
`default CredentialTraversal<S,E>`	`iterate()`	Iterate all the `Traverser` instances in the traversal.
`default CredentialTraversal<S,String>`	`key()`	Map the `Property` to its `Property.key()`.
`default CredentialTraversal<S,String>`	`label()`	Map the `Element` to its `Element.label()`.
`default CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<S,E2>`	`local(Traversal<?,E2> localTraversal)`	Provides a execute a specified traversal on a single element within a stream.
`default CredentialTraversal<S,Integer>`	`loops()`	If the `Traverser` supports looping then calling this method will extract the number of loops for that traverser.
`default CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<S,E2>`	`map(Traversal<?,E2> mapTraversal)`	Map a `Traverser` referencing an object of type `E` to an object of type `E2`.
`default <E2> CredentialTraversal<S,Map<String,E2>>`	`match(Traversal<?,?>... matchTraversals)`	Map the `Traverser` to a `Map` of bindings as specified by the provided match traversals.
`default CredentialTraversal<S,Double>`	`math(String expression)`	Map the `Traverser` to a `Double` according to the mathematical expression provided in the argument.
`default <E2 extends Comparable> CredentialTraversal<S,E2>`	`max()`	Determines the largest value in the stream.
`default <E2 extends Comparable> CredentialTraversal<S,E2>`	`max(Scope scope)`	Determines the largest value in the stream given the `Scope`.
`default <E2 extends Number> CredentialTraversal<S,E2>`	`mean()`	Determines the mean value in the stream.
`default <E2 extends Number> CredentialTraversal<S,E2>`	`mean(Scope scope)`	Determines the mean value in the stream given the `Scope`.
`default CredentialTraversal<S,Edge>`	`mergeE()`	Spawns a `GraphTraversal` by doing a merge (i.e.
`default CredentialTraversal<S,Edge>`	`mergeE(Map<Object,Object> searchCreate)`	Spawns a `GraphTraversal` by doing a merge (i.e.
`default CredentialTraversal<S,Edge>`	`mergeE(Traversal<?,Map<Object,Object>> searchCreate)`	Spawns a `GraphTraversal` by doing a merge (i.e.
`default CredentialTraversal<S,Vertex>`	`mergeV()`	Performs a merge (i.e.
`default CredentialTraversal<S,Vertex>`	`mergeV(Map<Object,Object> searchCreate)`	Performs a merge (i.e.
`default CredentialTraversal<S,Vertex>`	`mergeV(Traversal<?,Map<Object,Object>> searchCreate)`	Performs a merge (i.e.
`default <E2 extends Comparable> CredentialTraversal<S,E2>`	`min()`	Determines the smallest value in the stream.
`default <E2 extends Comparable> CredentialTraversal<S,E2>`	`min(Scope scope)`	Determines the smallest value in the stream given the `Scope`.
`default CredentialTraversal<S,E>`	`none()`	Filter all traversers in the traversal.
`default CredentialTraversal<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> CredentialTraversal<S,E>`	`option(M token, Map<Object,Object> m)`	This is a step modulator to a `TraversalOptionParent` like `choose()` or `mergeV()` where the provided argument associated to the `token` is applied according to the semantics of the step.
`default <M,E2> CredentialTraversal<S,E>`	`option(M token, Traversal<?,E2> traversalOption)`	This is a step modulator to a `TraversalOptionParent` like `choose()` or `mergeV()` where the provided argument associated to the `token` is applied according to the semantics of the step.
`default <E2> CredentialTraversal<S,E>`	`option(Traversal<?,E2> traversalOption)`	This step modifies `GraphTraversal.choose(Function)` to specifies the available choices that might be executed.
`default <E2> CredentialTraversal<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 CredentialTraversal<S,E>`	`or(Traversal<?,?>... orTraversals)`	Ensures that at least one of the provided traversals yield a result.
`default CredentialTraversal<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 CredentialTraversal<S,E>`	`order(Scope scope)`	Order either the `Scope.local` object (e.g.
`default CredentialTraversal<S,Vertex>`	`otherV()`	Map the `Edge` to the incident vertex that was not just traversed from in the path history.
`default CredentialTraversal<S,Vertex>`	`out(String... edgeLabels)`	Map the `Vertex` to its outgoing adjacent vertices given the edge labels.
`default CredentialTraversal<S,Edge>`	`outE(String... edgeLabels)`	Map the `Vertex` to its outgoing incident edges given the edge labels.
`default CredentialTraversal<S,Vertex>`	`outV()`	Map the `Edge` to its outgoing/tail incident `Vertex`.
`default CredentialTraversal<S,E>`	`pageRank()`	Calculates a PageRank over the graph using a 0.85 for the `alpha` value.
`default CredentialTraversal<S,E>`	`pageRank(double alpha)`	Calculates a PageRank over the graph.
`default CredentialTraversal<S,Path>`	`path()`	Map the `Traverser` to its `Path` history via `Traverser.path()`.
`default CredentialTraversal<S,E>`	`peerPressure()`	Executes a Peer Pressure community detection algorithm over the graph.
`default CredentialTraversal<S,TraversalMetrics>`	`profile()`	Profile the traversal.
`default CredentialTraversal<S,E>`	`profile(String sideEffectKey)`	Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
`default CredentialTraversal<S,E>`	`program(VertexProgram<?> vertexProgram)`	Executes an arbitrary `VertexProgram` over the graph.
`default <E2> CredentialTraversal<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> CredentialTraversal<S,? extends Property<E2>>`	`properties(String... propertyKeys)`	Map the `Element` to its associated properties given the provide property keys.
`default CredentialTraversal<S,E>`	`property(Object key, Object value, Object... keyValues)`	Sets the key and value of a `Property`.
`default CredentialTraversal<S,E>`	`property(Map<Object,Object> value)`	When a `Map` is supplied then each of the key/value pairs in the map will be added as property.
`default CredentialTraversal<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> CredentialTraversal<S,Map<String,E2>>`	`propertyMap(String... propertyKeys)`	Map the `Element` to a `Map` of the properties key'd according to their `Property.key()`.
`default CredentialTraversal<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> CredentialTraversal<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 CredentialTraversal<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 CredentialTraversal<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 CredentialTraversal<S,E>`	`repeat(Traversal<?,E> repeatTraversal)`	This step is used for looping over a traversal given some break predicate.
`default <E2> CredentialTraversal<S,E2>`	`sack()`	Map the `Traverser` to its `Traverser.sack()` value.
`default <V,U> CredentialTraversal<S,E>`	`sack(BiFunction<V,U,V> sackOperator)`	Map the `Traverser` to its `Traverser.sack()` value.
`default CredentialTraversal<S,E>`	`sample(int amountToSample)`	Allow some specified number of objects to pass through the stream.
`default CredentialTraversal<S,E>`	`sample(Scope scope, int amountToSample)`	Allow some specified number of objects to pass through the stream.
`default <E2> CredentialTraversal<S,E2>`	`select(String selectKey)`	Map the `Traverser` to the object specified by the `selectKey`.
`default <E2> CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<S,E2>`	`select(Traversal<S,E2> keyTraversal)`	Map the `Traverser` to the object specified by the key returned by the `keyTraversal`.
`default <E2> CredentialTraversal<S,Collection<E2>>`	`select(Column column)`	A version of `select` that allows for the extraction of a `Column` from objects in the traversal.
`default CredentialTraversal<S,Path>`	`shortestPath()`	Executes a Shortest Path algorithm over the graph.
`default CredentialTraversal<S,E>`	`sideEffect(Consumer<Traverser<E>> consumer)`	Perform some operation on the `Traverser` and pass it to the next step unmodified.
`default CredentialTraversal<S,E>`	`sideEffect(Traversal<?,?> sideEffectTraversal)`	Perform some operation on the `Traverser` and pass it to the next step unmodified.
`default CredentialTraversal<S,E>`	`simplePath()`	Filter the `E` object if its `Traverser.path()` is not `Path.isSimple()`.
`default CredentialTraversal<S,E>`	`skip(long skip)`	Filters out the first `n` objects in the traversal.
`default <E2> CredentialTraversal<S,E2>`	`skip(Scope scope, long skip)`	Filters out the first `n` objects in the traversal.
`default CredentialTraversal<S,E>`	`store(String sideEffectKey)`	Lazily aggregates objects in the stream into a side-effect collection.
`default CredentialTraversal<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> CredentialTraversal<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> CredentialTraversal<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 CredentialTraversal<S,E>`	`tail()`	Filters the objects in the traversal emitted as being last objects in the stream.
`default CredentialTraversal<S,E>`	`tail(long limit)`	Filters the objects in the traversal emitted as being last objects in the stream.
`default <E2> CredentialTraversal<S,E2>`	`tail(Scope scope)`	Filters the objects in the traversal emitted as being last objects in the stream given the `Scope`.
`default <E2> CredentialTraversal<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 CredentialTraversal<S,E>`	`timeLimit(long timeLimit)`	Once the first `Traverser` hits this step, a count down is started.
`default CredentialTraversal<S,E>`	`times(int maxLoops)`	Modifies a `GraphTraversal.repeat(Traversal)` to specify how many loops should occur before exiting.
`default CredentialTraversal<S,E>`	`to(String toStepLabel)`	Provide `to()`-modulation to respective steps.
`default CredentialTraversal<S,E>`	`to(Traversal<?,Vertex> toVertex)`	When used as a modifier to `GraphTraversal.addE(String)` this method specifies the traversal to use for selecting the incoming vertex of the newly added `Edge`.
`default CredentialTraversal<S,Vertex>`	`to(Direction direction, String... edgeLabels)`	Map the `Vertex` to its adjacent vertices given a direction and edge labels.
`default CredentialTraversal<S,E>`	`to(Vertex toVertex)`	When used as a modifier to `GraphTraversal.addE(String)` this method specifies the traversal to use for selecting the incoming vertex of the newly added `Edge`.
`default CredentialTraversal<S,Edge>`	`toE(Direction direction, String... edgeLabels)`	Map the `Vertex` to its incident edges given the direction and edge labels.
`default CredentialTraversal<S,Vertex>`	`toV(Direction direction)`	Map the `Edge` to its incident vertices given the direction.
`default CredentialTraversal<S,Tree>`	`tree()`	Aggregates the emanating paths into a `Tree` data structure.
`default CredentialTraversal<S,E>`	`tree(String sideEffectKey)`	Aggregates the emanating paths into a `Tree` data structure.
`default <E2> CredentialTraversal<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> CredentialTraversal<S,E2>`	`union(Traversal<?,E2>... unionTraversals)`	Merges the results of an arbitrary number of traversals.
`default CredentialTraversal<S,E>`	`until(Predicate<Traverser<E>> untilPredicate)`	Modifies a `GraphTraversal.repeat(Traversal)` to determine when the loop should exit.
`default CredentialTraversal<S,E>`	`until(Traversal<?,?> untilTraversal)`	Modifies a `GraphTraversal.repeat(Traversal)` to determine when the loop should exit.
`default CredentialTraversal<S,Vertex>`	`user(String username, String password)`	Creates or updates a user.
`default CredentialTraversal<S,Vertex>`	`users()`	Finds all users.
`default CredentialTraversal<S,Vertex>`	`users(String username, String... more)`	Finds users by name.
`default CredentialTraversal<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> CredentialTraversal<S,E2>`	`value()`	Map the `Property` to its `Property.value()`.
`default <E2> CredentialTraversal<S,Map<Object,E2>>`	`valueMap(boolean includeTokens, String... propertyKeys)`	Map the `Element` to a `Map` of the property values key'd according to their `Property.key()`.
`default <E2> CredentialTraversal<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> CredentialTraversal<S,E2>`	`values(String... propertyKeys)`	Map the `Element` to the values of the associated properties given the provide property keys.
`default CredentialTraversal<S,E>`	`where(String startKey, P<String> predicate)`	Filters the current object based on the object itself or the path history.
`default CredentialTraversal<S,E>`	`where(P<String> predicate)`	Filters the current object based on the object itself or the path history.
`default CredentialTraversal<S,E>`	`where(Traversal<?,?> whereTraversal)`	Filters the current object based on the object itself or the path history.
`default CredentialTraversal<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 CredentialTraversal<S,E>`	`with(String key, Object value)`	Provides a configuration to a step in the form of a key and value pair.
`default CredentialTraversal<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.dsl.graph.GraphTraversal
asAdmin

Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin
addStep, clone

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

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

Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin
addStart, addStarts, addStep, applyStrategies, equals, getBytecode, getEndStep, getGraph, getParent, getSideEffects, getStartStep, getSteps, getStrategies, getTraversalSource, getTraverserGenerator, getTraverserRequirements, getTraverserSetSupplier, isLocked, isRoot, lock, nextTraverser, removeStep, removeStep, reset, setGraph, setParent, setSideEffects, setStrategies

- Method Detail
  - users
```
default CredentialTraversal<S,Vertex> users()
```
    Description copied from interface: CredentialTraversalDsl
    
    Finds all users.
    
    Specified by:
    
    users in interface CredentialTraversalDsl<S,E>
  - users
```
default CredentialTraversal<S,Vertex> users(String username,
                                                  String... more)
```
    Description copied from interface: CredentialTraversalDsl
    
    Finds users by name.
    
    Specified by:
    
    users in interface CredentialTraversalDsl<S,E>
  - user
```
default CredentialTraversal<S,Vertex> user(String username,
                                                 String password)
```
    Description copied from interface: CredentialTraversalDsl
    
    Creates or updates a user.
    
    Specified by:
    
    user in interface CredentialTraversalDsl<S,E>
  - map
```
default <E2> CredentialTraversal<S,E2> map(Function<Traverser<E>,E2> function)
```
    Description copied from interface: GraphTraversal
    
    Map a Traverser referencing an object of type E to an object of type E2.
    
    Specified by:
    
    map in interface GraphTraversal<S,E>
    
    Parameters:
    
    function - the lambda expression that does the functional mapping
    
    Returns:
    
    the traversal with an appended LambdaMapStep.
    
    See Also:
    
    Reference Documentation - General Steps
  - map
```
default <E2> CredentialTraversal<S,E2> map(Traversal<?,E2> mapTraversal)
```
    Description copied from interface: GraphTraversal
    
    Map a Traverser referencing an object of type E to an object of type E2.
    
    Specified by:
    
    map in interface GraphTraversal<S,E>
    
    Parameters:
    
    mapTraversal - the traversal expression that does the functional mapping
    
    Returns:
    
    the traversal with an appended LambdaMapStep.
    
    See Also:
    
    Reference Documentation - General Steps
  - flatMap
```
default <E2> CredentialTraversal<S,E2> flatMap(Function<Traverser<E>,Iterator<E2>> function)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    flatMap in interface GraphTraversal<S,E>
    
    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.
    
    See Also:
    
    Reference Documentation - General Steps
  - flatMap
```
default <E2> CredentialTraversal<S,E2> flatMap(Traversal<?,E2> flatMapTraversal)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    flatMap in interface GraphTraversal<S,E>
    
    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.
    
    See Also:
    
    Reference Documentation - General Steps
  - id
```
default CredentialTraversal<S,Object> id()
```
    Description copied from interface: GraphTraversal
    
    Map the Element to its Element.id().
    
    Specified by:
    
    id in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended IdStep.
    
    See Also:
    
    Reference Documentation - Id Step
  - label
```
default CredentialTraversal<S,String> label()
```
    Description copied from interface: GraphTraversal
    
    Map the Element to its Element.label().
    
    Specified by:
    
    label in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended LabelStep.
    
    See Also:
    
    Reference Documentation - Label Step
  - identity
```
default CredentialTraversal<S,E> identity()
```
    Description copied from interface: GraphTraversal
    
    Map the E object to itself. In other words, a "no op."
    
    Specified by:
    
    identity in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended IdentityStep.
  - constant
```
default <E2> CredentialTraversal<S,E2> constant(E2 e)
```
    Description copied from interface: GraphTraversal
    
    Map any object to a fixed E value.
    
    Specified by:
    
    constant in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended ConstantStep.
    
    See Also:
    
    Reference Documentation - Constant Step
  - V
```
default CredentialTraversal<S,Vertex> V(Object... vertexIdsOrElements)
```
    Description copied from interface: GraphTraversal
    
    A V step is usually used to start a traversal but it may also be used mid-traversal.
    
    Specified by:
    
    V in interface GraphTraversal<S,E>
    
    Parameters:
    
    vertexIdsOrElements - vertices to inject into the traversal
    
    Returns:
    
    the traversal with an appended GraphStep
    
    See Also:
    
    Reference Documentation - Graph Step
  - to
```
default CredentialTraversal<S,Vertex> to(Direction direction,
                                               String... edgeLabels)
```
    Description copied from interface: GraphTraversal
    
    Map the Vertex to its adjacent vertices given a direction and edge labels.
    
    Specified by:
    
    to in interface GraphTraversal<S,E>
    
    Parameters:
    
    direction - the direction to traverse from the current vertex
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - out
```
default CredentialTraversal<S,Vertex> out(String... edgeLabels)
```
    Description copied from interface: GraphTraversal
    
    Map the Vertex to its outgoing adjacent vertices given the edge labels.
    
    Specified by:
    
    out in interface GraphTraversal<S,E>
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - in
```
default CredentialTraversal<S,Vertex> in(String... edgeLabels)
```
    Description copied from interface: GraphTraversal
    
    Map the Vertex to its incoming adjacent vertices given the edge labels.
    
    Specified by:
    
    in in interface GraphTraversal<S,E>
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - both
```
default CredentialTraversal<S,Vertex> both(String... edgeLabels)
```
    Description copied from interface: GraphTraversal
    
    Map the Vertex to its adjacent vertices given the edge labels.
    
    Specified by:
    
    both in interface GraphTraversal<S,E>
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - toE
```
default CredentialTraversal<S,Edge> toE(Direction direction,
                                              String... edgeLabels)
```
    Description copied from interface: GraphTraversal
    
    Map the Vertex to its incident edges given the direction and edge labels.
    
    Specified by:
    
    toE in interface GraphTraversal<S,E>
    
    Parameters:
    
    direction - the direction to traverse from the current vertex
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - outE
```
default CredentialTraversal<S,Edge> outE(String... edgeLabels)
```
    Description copied from interface: GraphTraversal
    
    Map the Vertex to its outgoing incident edges given the edge labels.
    
    Specified by:
    
    outE in interface GraphTraversal<S,E>
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - inE
```
default CredentialTraversal<S,Edge> inE(String... edgeLabels)
```
    Description copied from interface: GraphTraversal
    
    Map the Vertex to its incoming incident edges given the edge labels.
    
    Specified by:
    
    inE in interface GraphTraversal<S,E>
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - bothE
```
default CredentialTraversal<S,Edge> bothE(String... edgeLabels)
```
    Description copied from interface: GraphTraversal
    
    Map the Vertex to its incident edges given the edge labels.
    
    Specified by:
    
    bothE in interface GraphTraversal<S,E>
    
    Parameters:
    
    edgeLabels - the edge labels to traverse
    
    Returns:
    
    the traversal with an appended VertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - toV
```
default CredentialTraversal<S,Vertex> toV(Direction direction)
```
    Description copied from interface: GraphTraversal
    
    Map the Edge to its incident vertices given the direction.
    
    Specified by:
    
    toV in interface GraphTraversal<S,E>
    
    Parameters:
    
    direction - the direction to traverser from the current edge
    
    Returns:
    
    the traversal with an appended EdgeVertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - inV
```
default CredentialTraversal<S,Vertex> inV()
```
    Description copied from interface: GraphTraversal
    
    Map the Edge to its incoming/head incident Vertex.
    
    Specified by:
    
    inV in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended EdgeVertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - outV
```
default CredentialTraversal<S,Vertex> outV()
```
    Description copied from interface: GraphTraversal
    
    Map the Edge to its outgoing/tail incident Vertex.
    
    Specified by:
    
    outV in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended EdgeVertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - bothV
```
default CredentialTraversal<S,Vertex> bothV()
```
    Description copied from interface: GraphTraversal
    
    Map the Edge to its incident vertices.
    
    Specified by:
    
    bothV in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended EdgeVertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - otherV
```
default CredentialTraversal<S,Vertex> otherV()
```
    Description copied from interface: GraphTraversal
    
    Map the Edge to the incident vertex that was not just traversed from in the path history.
    
    Specified by:
    
    otherV in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended EdgeOtherVertexStep.
    
    See Also:
    
    Reference Documentation - Vertex Step
  - order
```
default CredentialTraversal<S,E> order()
```
    Description copied from interface: GraphTraversal
    
    Order all the objects in the traversal up to this point and then emit them one-by-one in their ordered sequence.
    
    Specified by:
    
    order in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended OrderGlobalStep.
    
    See Also:
    
    Reference Documentation - Order Step
  - order
```
default CredentialTraversal<S,E> order(Scope scope)
```
    Description copied from interface: GraphTraversal
    
    Order either the Scope.local object (e.g. a list, map, etc.) or the entire Scope.global traversal stream.
    
    Specified by:
    
    order in interface GraphTraversal<S,E>
    
    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.
    
    See Also:
    
    Reference Documentation - Order Step
  - properties
```
default <E2> CredentialTraversal<S,? extends Property<E2>> properties(String... propertyKeys)
```
    Description copied from interface: GraphTraversal
    
    Map the Element to its associated properties given the provide property keys. If no property keys are provided, then all properties are emitted.
    
    Specified by:
    
    properties in interface GraphTraversal<S,E>
    
    Type Parameters:
    
    E2 - the value type of the returned properties
    
    Parameters:
    
    propertyKeys - the properties to retrieve
    
    Returns:
    
    the traversal with an appended PropertiesStep.
    
    See Also:
    
    Reference Documentation - Properties Step
  - values
```
default <E2> CredentialTraversal<S,E2> values(String... propertyKeys)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    values in interface GraphTraversal<S,E>
    
    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.
    
    See Also:
    
    Reference Documentation - Values Step
  - propertyMap
```
default <E2> CredentialTraversal<S,Map<String,E2>> propertyMap(String... propertyKeys)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    propertyMap in interface GraphTraversal<S,E>
    
    Type Parameters:
    
    E2 - the value type of the returned properties
    
    Parameters:
    
    propertyKeys - the properties to retrieve
    
    Returns:
    
    the traversal with an appended PropertyMapStep.
    
    See Also:
    
    Reference Documentation - PropertyMap Step
  - elementMap
```
default <E2> CredentialTraversal<S,Map<Object,E2>> elementMap(String... propertyKeys)
```
    Description copied from interface: GraphTraversal
    
    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 GraphTraversal.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.
    
    Specified by:
    
    elementMap in interface GraphTraversal<S,E>
    
    Type Parameters:
    
    E2 - the value type of the returned properties
    
    Parameters:
    
    propertyKeys - the properties to retrieve
    
    Returns:
    
    the traversal with an appended ElementMapStep.
    
    See Also:
    
    Reference Documentation - ElementMap Step
  - valueMap
```
default <E2> CredentialTraversal<S,Map<Object,E2>> valueMap(String... propertyKeys)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    valueMap in interface GraphTraversal<S,E>
    
    Type Parameters:
    
    E2 - the value type of the returned properties
    
    Parameters:
    
    propertyKeys - the properties to retrieve
    
    Returns:
    
    the traversal with an appended PropertyMapStep.
    
    See Also:
    
    Reference Documentation - ValueMap Step
  - valueMap
```
default <E2> CredentialTraversal<S,Map<Object,E2>> valueMap(boolean includeTokens,
                                                                        String... propertyKeys)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    valueMap in interface GraphTraversal<S,E>
    
    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.
    
    See Also:
    
    Reference Documentation - ValueMap Step
  - key
```
default CredentialTraversal<S,String> key()
```
    Description copied from interface: GraphTraversal
    
    Map the Property to its Property.key().
    
    Specified by:
    
    key in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended PropertyKeyStep.
    
    See Also:
    
    Reference Documentation - Key Step
  - value
```
default <E2> CredentialTraversal<S,E2> value()
```
    Description copied from interface: GraphTraversal
    
    Map the Property to its Property.value().
    
    Specified by:
    
    value in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended PropertyValueStep.
    
    See Also:
    
    Reference Documentation - Value Step
  - path
```
default CredentialTraversal<S,Path> path()
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to its Path history via Traverser.path().
    
    Specified by:
    
    path in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended PathStep.
    
    See Also:
    
    Reference Documentation - Path Step
  - match
```
default <E2> CredentialTraversal<S,Map<String,E2>> match(Traversal<?,?>... matchTraversals)
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to a Map of bindings as specified by the provided match traversals.
    
    Specified by:
    
    match in interface GraphTraversal<S,E>
    
    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.
    
    See Also:
    
    Reference Documentation - Match Step
  - sack
```
default <E2> CredentialTraversal<S,E2> sack()
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to its Traverser.sack() value.
    
    Specified by:
    
    sack in interface GraphTraversal<S,E>
    
    Type Parameters:
    
    E2 - the sack value type
    
    Returns:
    
    the traversal with an appended SackStep.
    
    See Also:
    
    Reference Documentation - Sack Step
  - loops
```
default CredentialTraversal<S,Integer> loops()
```
    Description copied from interface: GraphTraversal
    
    If the Traverser supports looping then calling this method will extract the number of loops for that traverser.
    
    Specified by:
    
    loops in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended LoopsStep
    
    See Also:
    
    Reference Documentation - Loops Step
  - loops
```
default CredentialTraversal<S,Integer> loops(String loopName)
```
    Description copied from interface: GraphTraversal
    
    If the Traverser supports looping then calling this method will extract the number of loops for that traverser for the named loop.
    
    Specified by:
    
    loops in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended LoopsStep
    
    See Also:
    
    Reference Documentation - Loops Step
  - project
```
default <E2> CredentialTraversal<S,Map<String,E2>> project(String projectKey,
                                                                       String... otherProjectKeys)
```
    Description copied from interface: GraphTraversal
    
    Projects the current object in the stream into a Map that is keyed by the provided labels.
    
    Specified by:
    
    project in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended ProjectStep
    
    See Also:
    
    Reference Documentation - Project Step
  - select
```
default <E2> CredentialTraversal<S,Map<String,E2>> select(Pop pop,
                                                                      String selectKey1,
                                                                      String selectKey2,
                                                                      String... otherSelectKeys)
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to a Map projection of sideEffect values, map values, and/or path values.
    
    Specified by:
    
    select in interface GraphTraversal<S,E>
    
    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.
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> CredentialTraversal<S,Map<String,E2>> select(String selectKey1,
                                                                      String selectKey2,
                                                                      String... otherSelectKeys)
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to a Map projection of sideEffect values, map values, and/or path values.
    
    Specified by:
    
    select in interface GraphTraversal<S,E>
    
    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.
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> CredentialTraversal<S,E2> select(Pop pop,
                                                    String selectKey)
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to the object specified by the selectKey and apply the Pop operation to it.
    
    Specified by:
    
    select in interface GraphTraversal<S,E>
    
    selectKey - the key to project
    
    Returns:
    
    the traversal with an appended SelectStep.
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> CredentialTraversal<S,E2> select(String selectKey)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    select in interface GraphTraversal<S,E>
    
    Parameters:
    
    selectKey - the key to project
    
    Returns:
    
    the traversal with an appended SelectStep.
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> CredentialTraversal<S,E2> select(Pop pop,
                                                    Traversal<S,E2> keyTraversal)
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to the object specified by the key returned by the keyTraversal and apply the Pop operation to it.
    
    Specified by:
    
    select in interface GraphTraversal<S,E>
    
    keyTraversal - the traversal expression that selects the key to project
    
    Returns:
    
    the traversal with an appended SelectStep.
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> CredentialTraversal<S,E2> select(Traversal<S,E2> keyTraversal)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    select in interface GraphTraversal<S,E>
    
    Parameters:
    
    keyTraversal - the traversal expression that selects the key to project
    
    Returns:
    
    the traversal with an appended TraversalSelectStep.
    
    See Also:
    
    Reference Documentation - Select Step
  - select
```
default <E2> CredentialTraversal<S,Collection<E2>> select(Column column)
```
    Description copied from interface: GraphTraversal
    
    A version of select that allows for the extraction of a Column from objects in the traversal.
    
    Specified by:
    
    select in interface GraphTraversal<S,E>
    
    Parameters:
    
    column - the column to extract
    
    Returns:
    
    the traversal with an appended TraversalMapStep
    
    See Also:
    
    Reference Documentation - Select Step
  - unfold
```
default <E2> CredentialTraversal<S,E2> unfold()
```
    Description copied from interface: GraphTraversal
    
    Unrolls a Iterator, Iterable or Map into a linear form or simply emits the object if it is not one of those types.
    
    Specified by:
    
    unfold in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended UnfoldStep
    
    See Also:
    
    Reference Documentation - Unfold Step
  - fold
```
default CredentialTraversal<S,List<E>> fold()
```
    Description copied from interface: GraphTraversal
    
    Rolls up objects in the stream into an aggregate list.
    
    Specified by:
    
    fold in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended FoldStep
    
    See Also:
    
    Reference Documentation - Fold Step
  - fold
```
default <E2> CredentialTraversal<S,E2> fold(E2 seed,
                                                  BiFunction<E2,E,E2> foldFunction)
```
    Description copied from interface: GraphTraversal
    
    Rolls up objects in the stream into an aggregate value as defined by a seed and BiFunction.
    
    Specified by:
    
    fold in interface GraphTraversal<S,E>
    
    Parameters:
    
    seed - the value to provide as the first argument to the foldFunction
    
    foldFunction - the function to fold by where the first argument is the seed or the value returned from subsequent class and the second argument is the value from the stream
    
    Returns:
    
    the traversal with an appended FoldStep
    
    See Also:
    
    Reference Documentation - Fold Step
  - count
```
default CredentialTraversal<S,Long> count()
```
    Description copied from interface: GraphTraversal
    
    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).
    
    Specified by:
    
    count in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended CountGlobalStep.
    
    See Also:
    
    Reference Documentation - Count Step
  - count
```
default CredentialTraversal<S,Long> count(Scope scope)
```
    Description copied from interface: GraphTraversal
    
    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).
    
    Specified by:
    
    count in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended CountGlobalStep or CountLocalStep depending on the Scope
    
    See Also:
    
    Reference Documentation - Count Step
  - sum
```
default <E2 extends Number> CredentialTraversal<S,E2> sum()
```
    Description copied from interface: GraphTraversal
    
    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).
    
    Specified by:
    
    sum in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended SumGlobalStep.
    
    See Also:
    
    Reference Documentation - Sum Step
  - sum
```
default <E2 extends Number> CredentialTraversal<S,E2> sum(Scope scope)
```
    Description copied from interface: GraphTraversal
    
    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).
    
    Specified by:
    
    sum in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended SumGlobalStep or SumLocalStep depending on the Scope.
    
    See Also:
    
    Reference Documentation - Sum Step
  - max
```
default <E2 extends Comparable> CredentialTraversal<S,E2> max()
```
    Description copied from interface: GraphTraversal
    
    Determines the largest value in the stream.
    
    Specified by:
    
    max in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended MaxGlobalStep.
    
    See Also:
    
    Reference Documentation - Max Step
  - max
```
default <E2 extends Comparable> CredentialTraversal<S,E2> max(Scope scope)
```
    Description copied from interface: GraphTraversal
    
    Determines the largest value in the stream given the Scope.
    
    Specified by:
    
    max in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended MaxGlobalStep or MaxLocalStep depending on the Scope
    
    See Also:
    
    Reference Documentation - Max Step
  - min
```
default <E2 extends Comparable> CredentialTraversal<S,E2> min()
```
    Description copied from interface: GraphTraversal
    
    Determines the smallest value in the stream.
    
    Specified by:
    
    min in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended MinGlobalStep.
    
    See Also:
    
    Reference Documentation - Min Step
  - min
```
default <E2 extends Comparable> CredentialTraversal<S,E2> min(Scope scope)
```
    Description copied from interface: GraphTraversal
    
    Determines the smallest value in the stream given the Scope.
    
    Specified by:
    
    min in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended MinGlobalStep or MinLocalStep depending on the Scope
    
    See Also:
    
    Reference Documentation - Min Step
  - mean
```
default <E2 extends Number> CredentialTraversal<S,E2> mean()
```
    Description copied from interface: GraphTraversal
    
    Determines the mean value in the stream.
    
    Specified by:
    
    mean in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended MeanGlobalStep.
    
    See Also:
    
    Reference Documentation - Mean Step
  - mean
```
default <E2 extends Number> CredentialTraversal<S,E2> mean(Scope scope)
```
    Description copied from interface: GraphTraversal
    
    Determines the mean value in the stream given the Scope.
    
    Specified by:
    
    mean in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended MeanGlobalStep or MeanLocalStep depending on the Scope
    
    See Also:
    
    Reference Documentation - Mean Step
  - group
```
default <K,V> CredentialTraversal<S,Map<K,V>> group()
```
    Description copied from interface: GraphTraversal
    
    Organize objects in the stream into a Map. Calls to group() are typically accompanied with GraphTraversal.by() modulators which help specify how the grouping should occur.
    
    Specified by:
    
    group in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended GroupStep.
    
    See Also:
    
    Reference Documentation - Group Step
  - groupCount
```
default <K> CredentialTraversal<S,Map<K,Long>> groupCount()
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    groupCount in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended GroupCountStep.
    
    See Also:
    
    Reference Documentation - GroupCount Step
  - tree
```
default CredentialTraversal<S,Tree> tree()
```
    Description copied from interface: GraphTraversal
    
    Aggregates the emanating paths into a Tree data structure.
    
    Specified by:
    
    tree in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended TreeStep
    
    See Also:
    
    Reference Documentation - Tree Step
  - addV
```
default CredentialTraversal<S,Vertex> addV(String vertexLabel)
```
    Description copied from interface: GraphTraversal
    
    Adds a Vertex.
    
    Specified by:
    
    addV in interface GraphTraversal<S,E>
    
    Parameters:
    
    vertexLabel - the label of the Vertex to add
    
    Returns:
    
    the traversal with the AddVertexStep added
    
    See Also:
    
    Reference Documentation - AddVertex Step
  - addV
```
default CredentialTraversal<S,Vertex> addV(Traversal<?,String> vertexLabelTraversal)
```
    Description copied from interface: GraphTraversal
    
    Adds a Vertex with a vertex label determined by a Traversal.
    
    Specified by:
    
    addV in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the AddVertexStep added
    
    See Also:
    
    Reference Documentation - AddVertex Step
  - addV
```
default CredentialTraversal<S,Vertex> addV()
```
    Description copied from interface: GraphTraversal
    
    Adds a Vertex with a default vertex label.
    
    Specified by:
    
    addV in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the AddVertexStep added
    
    See Also:
    
    Reference Documentation - AddVertex Step
  - mergeV
```
default CredentialTraversal<S,Vertex> mergeV()
```
    Description copied from interface: GraphTraversal
    
    Performs a merge (i.e. upsert) style operation for an Vertex using the incoming Map traverser as an argument. The Map represents search criteria and will match each of the supplied key/value pairs where the keys may be String property values or a value of T. If a match is not made it will use that search criteria to create the new Vertex.
    
    Specified by:
    
    mergeV in interface GraphTraversal<S,E>
  - mergeV
```
default CredentialTraversal<S,Vertex> mergeV(Map<Object,Object> searchCreate)
```
    Description copied from interface: GraphTraversal
    
    Performs a merge (i.e. upsert) style operation for an Vertex using a Map as an argument. The Map represents search criteria and will match each of the supplied key/value pairs where the keys may be String property values or a value of T. If a match is not made it will use that search criteria to create the new Vertex.
    
    Specified by:
    
    mergeV in interface GraphTraversal<S,E>
    
    Parameters:
    
    searchCreate - This Map can have a key of T or a String.
  - mergeV
```
default CredentialTraversal<S,Vertex> mergeV(Traversal<?,Map<Object,Object>> searchCreate)
```
    Description copied from interface: GraphTraversal
    
    Performs a merge (i.e. upsert) style operation for an Vertex using a Map as an argument. The Map represents search criteria and will match each of the supplied key/value pairs where the keys may be String property values or a value of T. If a match is not made it will use that search criteria to create the new Vertex.
    
    Specified by:
    
    mergeV in interface GraphTraversal<S,E>
    
    Parameters:
    
    searchCreate - This anonymous Traversal must produce a Map that may have a keys of T or a String.
  - mergeE
```
default CredentialTraversal<S,Edge> mergeE()
```
    Description copied from interface: GraphTraversal
    
    Spawns a GraphTraversal by doing a merge (i.e. upsert) style operation for an Edge using an incoming Map as an argument.
    
    Specified by:
    
    mergeE in interface GraphTraversal<S,E>
  - mergeE
```
default CredentialTraversal<S,Edge> mergeE(Map<Object,Object> searchCreate)
```
    Description copied from interface: GraphTraversal
    
    Spawns a GraphTraversal by doing a merge (i.e. upsert) style operation for an Edge using a Map as an argument.
    
    Specified by:
    
    mergeE in interface GraphTraversal<S,E>
    
    Parameters:
    
    searchCreate - This Map can have a key of T Direction or a String.
  - mergeE
```
default CredentialTraversal<S,Edge> mergeE(Traversal<?,Map<Object,Object>> searchCreate)
```
    Description copied from interface: GraphTraversal
    
    Spawns a GraphTraversal by doing a merge (i.e. upsert) style operation for an Edge using a Map as an argument.
    
    Specified by:
    
    mergeE in interface GraphTraversal<S,E>
    
    Parameters:
    
    searchCreate - This Map can have a key of T Direction or a String.
  - addE
```
default CredentialTraversal<S,Edge> addE(String edgeLabel)
```
    Description copied from interface: GraphTraversal
    
    Adds an Edge with the specified edge label.
    
    Specified by:
    
    addE in interface GraphTraversal<S,E>
    
    Parameters:
    
    edgeLabel - the label of the newly added edge
    
    Returns:
    
    the traversal with the AddEdgeStep added
    
    See Also:
    
    Reference Documentation - AddEdge Step
  - addE
```
default CredentialTraversal<S,Edge> addE(Traversal<?,String> edgeLabelTraversal)
```
    Description copied from interface: GraphTraversal
    
    Adds a Edge with an edge label determined by a Traversal.
    
    Specified by:
    
    addE in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the AddEdgeStep added
    
    See Also:
    
    Reference Documentation - AddEdge Step
  - to
```
default CredentialTraversal<S,E> to(String toStepLabel)
```
    Description copied from interface: GraphTraversal
    
    Provide to()-modulation to respective steps.
    
    Specified by:
    
    to in interface GraphTraversal<S,E>
    
    Parameters:
    
    toStepLabel - the step label to modulate to.
    
    Returns:
    
    the traversal with the modified FromToModulating step.
    
    See Also:
    
    Reference Documentation - To Step
  - from
```
default CredentialTraversal<S,E> from(String fromStepLabel)
```
    Description copied from interface: GraphTraversal
    
    Provide from()-modulation to respective steps.
    
    Specified by:
    
    from in interface GraphTraversal<S,E>
    
    Parameters:
    
    fromStepLabel - the step label to modulate to.
    
    Returns:
    
    the traversal with the modified FromToModulating step.
    
    See Also:
    
    Reference Documentation - From Step
  - to
```
default CredentialTraversal<S,E> to(Traversal<?,Vertex> toVertex)
```
    Description copied from interface: GraphTraversal
    
    When used as a modifier to GraphTraversal.addE(String) this method specifies the traversal to use for selecting the incoming vertex of the newly added Edge.
    
    Specified by:
    
    to in interface GraphTraversal<S,E>
    
    Parameters:
    
    toVertex - the traversal for selecting the incoming vertex
    
    Returns:
    
    the traversal with the modified AddEdgeStep
    
    See Also:
    
    Reference Documentation - From Step
  - from
```
default CredentialTraversal<S,E> from(Traversal<?,Vertex> fromVertex)
```
    Description copied from interface: GraphTraversal
    
    When used as a modifier to GraphTraversal.addE(String) this method specifies the traversal to use for selecting the outgoing vertex of the newly added Edge.
    
    Specified by:
    
    from in interface GraphTraversal<S,E>
    
    Parameters:
    
    fromVertex - the traversal for selecting the outgoing vertex
    
    Returns:
    
    the traversal with the modified AddEdgeStep
    
    See Also:
    
    Reference Documentation - From Step
  - to
```
default CredentialTraversal<S,E> to(Vertex toVertex)
```
    Description copied from interface: GraphTraversal
    
    When used as a modifier to GraphTraversal.addE(String) this method specifies the traversal to use for selecting the incoming vertex of the newly added Edge.
    
    Specified by:
    
    to in interface GraphTraversal<S,E>
    
    Parameters:
    
    toVertex - the vertex for selecting the incoming vertex
    
    Returns:
    
    the traversal with the modified AddEdgeStep
    
    See Also:
    
    Reference Documentation - From Step
  - from
```
default CredentialTraversal<S,E> from(Vertex fromVertex)
```
    Description copied from interface: GraphTraversal
    
    When used as a modifier to GraphTraversal.addE(String) this method specifies the traversal to use for selecting the outgoing vertex of the newly added Edge.
    
    Specified by:
    
    from in interface GraphTraversal<S,E>
    
    Parameters:
    
    fromVertex - the vertex for selecting the outgoing vertex
    
    Returns:
    
    the traversal with the modified AddEdgeStep
    
    See Also:
    
    Reference Documentation - From Step
  - math
```
default CredentialTraversal<S,Double> math(String expression)
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to a Double according to the mathematical expression provided in the argument.
    
    Specified by:
    
    math in interface GraphTraversal<S,E>
    
    Parameters:
    
    expression - the mathematical expression with variables refering to scope variables.
    
    Returns:
    
    the traversal with the MathStep added.
  - element
```
default CredentialTraversal<S,Element> element()
```
    Description copied from interface: GraphTraversal
    
    Map a Property to its Element.
    
    Specified by:
    
    element in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended ElementStep.
    
    See Also:
    
    Reference Documentation - Element Step
  - call
```
default <E> CredentialTraversal<S,E> call(String service)
```
    Description copied from interface: GraphTraversal
    
    Perform the specified service call with no parameters.
    
    Specified by:
    
    call in interface GraphTraversal<S,E>
    
    Parameters:
    
    service - the name of the service call
    
    Returns:
    
    the traversal with an appended CallStep.
    
    See Also:
    
    Reference Documentation - Call Step
  - call
```
default <E> CredentialTraversal<S,E> call(String service,
                                                Map params)
```
    Description copied from interface: GraphTraversal
    
    Perform the specified service call with the specified static parameters.
    
    Specified by:
    
    call in interface GraphTraversal<S,E>
    
    Parameters:
    
    service - the name of the service call
    
    params - static parameter map (no nested traversals)
    
    Returns:
    
    the traversal with an appended CallStep.
    
    See Also:
    
    Reference Documentation - Call Step
  - call
```
default <E> CredentialTraversal<S,E> call(String service,
                                                Traversal<?,Map<?,?>> childTraversal)
```
    Description copied from interface: GraphTraversal
    
    Perform the specified service call with dynamic parameters produced by the specified child traversal.
    
    Specified by:
    
    call in interface GraphTraversal<S,E>
    
    Parameters:
    
    service - the name of the service call
    
    childTraversal - a traversal that will produce a Map of parameters for the service call when invoked.
    
    Returns:
    
    the traversal with an appended CallStep.
    
    See Also:
    
    Reference Documentation - Call Step
  - call
```
default <E> CredentialTraversal<S,E> call(String service,
                                                Map params,
                                                Traversal<?,Map<?,?>> childTraversal)
```
    Description copied from interface: GraphTraversal
    
    Perform the specified service call with both static and dynamic parameters produced by the specified child traversal. These parameters will be merged at execution time per the provider implementation. Reference implementation merges dynamic into static (dynamic will overwrite static).
    
    Specified by:
    
    call in interface GraphTraversal<S,E>
    
    Parameters:
    
    service - the name of the service call
    
    params - static parameter map (no nested traversals)
    
    childTraversal - a traversal that will produce a Map of parameters for the service call when invoked.
    
    Returns:
    
    the traversal with an appended CallStep.
    
    See Also:
    
    Reference Documentation - Call Step
  - filter
```
default CredentialTraversal<S,E> filter(Predicate<Traverser<E>> predicate)
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to either true or false, where false will not pass the traverser to the next step.
    
    Specified by:
    
    filter in interface GraphTraversal<S,E>
    
    Parameters:
    
    predicate - the filter function to apply
    
    Returns:
    
    the traversal with the LambdaFilterStep added
    
    See Also:
    
    Reference Documentation - General Steps
  - filter
```
default CredentialTraversal<S,E> filter(Traversal<?,?> filterTraversal)
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to either true or false, where false will not pass the traverser to the next step.
    
    Specified by:
    
    filter in interface GraphTraversal<S,E>
    
    Parameters:
    
    filterTraversal - the filter traversal to apply
    
    Returns:
    
    the traversal with the TraversalFilterStep added
    
    See Also:
    
    Reference Documentation - General Steps
  - none
```
default CredentialTraversal<S,E> none()
```
    Description copied from interface: Traversal
    
    Filter all traversers in the traversal. This step has narrow use cases and is primarily intended for use as a signal to remote servers that Traversal.iterate() was called. While it may be directly used, it is often a sign that a traversal should be re-written in another form.
    
    Specified by:
    
    none in interface GraphTraversal<S,E>
    
    Specified by:
    
    none in interface Traversal<S,E>
    
    Returns:
    
    the updated traversal with respective NoneStep.
  - or
```
default CredentialTraversal<S,E> or(Traversal<?,?>... orTraversals)
```
    Description copied from interface: GraphTraversal
    
    Ensures that at least one of the provided traversals yield a result.
    
    Specified by:
    
    or in interface GraphTraversal<S,E>
    
    Parameters:
    
    orTraversals - filter traversals where at least one must be satisfied
    
    Returns:
    
    the traversal with an appended OrStep
    
    See Also:
    
    Reference Documentation - Or Step
  - and
```
default CredentialTraversal<S,E> and(Traversal<?,?>... andTraversals)
```
    Description copied from interface: GraphTraversal
    
    Ensures that all of the provided traversals yield a result.
    
    Specified by:
    
    and in interface GraphTraversal<S,E>
    
    Parameters:
    
    andTraversals - filter traversals that must be satisfied
    
    Returns:
    
    the traversal with an appended AndStep
    
    See Also:
    
    Reference Documentation - And Step
  - inject
```
default CredentialTraversal<S,E> inject(E... injections)
```
    Description copied from interface: GraphTraversal
    
    Provides a way to add arbitrary objects to a traversal stream.
    
    Specified by:
    
    inject in interface GraphTraversal<S,E>
    
    Parameters:
    
    injections - the objects to add to the stream
    
    Returns:
    
    the traversal with an appended InjectStep
    
    See Also:
    
    Reference Documentation - Inject Step
  - dedup
```
default CredentialTraversal<S,E> dedup(Scope scope,
                                             String... dedupLabels)
```
    Description copied from interface: GraphTraversal
    
    Remove all duplicates in the traversal stream up to this point.
    
    Specified by:
    
    dedup in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Dedup Step
  - dedup
```
default CredentialTraversal<S,E> dedup(String... dedupLabels)
```
    Description copied from interface: GraphTraversal
    
    Remove all duplicates in the traversal stream up to this point.
    
    Specified by:
    
    dedup in interface GraphTraversal<S,E>
    
    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.
    
    See Also:
    
    Reference Documentation - Dedup Step
  - where
```
default CredentialTraversal<S,E> where(String startKey,
                                             P<String> predicate)
```
    Description copied from interface: GraphTraversal
    
    Filters the current object based on the object itself or the path history.
    
    Specified by:
    
    where in interface GraphTraversal<S,E>
    
    Parameters:
    
    startKey - the key containing the object to filter
    
    predicate - the filter to apply
    
    Returns:
    
    the traversal with an appended WherePredicateStep
    
    See Also:
    
    Reference Documentation - Where Step, Reference Documentation - Where with Match, Reference Documentation - Where with Select
  - where
```
default CredentialTraversal<S,E> where(P<String> predicate)
```
    Description copied from interface: GraphTraversal
    
    Filters the current object based on the object itself or the path history.
    
    Specified by:
    
    where in interface GraphTraversal<S,E>
    
    Parameters:
    
    predicate - the filter to apply
    
    Returns:
    
    the traversal with an appended WherePredicateStep
    
    See Also:
    
    Reference Documentation - Where Step, Reference Documentation - Where with Match, Reference Documentation - Where with Select
  - where
```
default CredentialTraversal<S,E> where(Traversal<?,?> whereTraversal)
```
    Description copied from interface: GraphTraversal
    
    Filters the current object based on the object itself or the path history.
    
    Specified by:
    
    where in interface GraphTraversal<S,E>
    
    Parameters:
    
    whereTraversal - the filter to apply
    
    Returns:
    
    the traversal with an appended WherePredicateStep
    
    See Also:
    
    Reference Documentation - Where Step, Reference Documentation - Where with Match, Reference Documentation - Where with Select
  - has
```
default CredentialTraversal<S,E> has(String propertyKey,
                                           P<?> predicate)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their properties.
    
    Specified by:
    
    has in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default CredentialTraversal<S,E> has(T accessor,
                                           P<?> predicate)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their properties.
    
    Specified by:
    
    has in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default CredentialTraversal<S,E> has(String propertyKey,
                                           Object value)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their properties.
    
    Specified by:
    
    has in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default CredentialTraversal<S,E> has(T accessor,
                                           Object value)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their properties.
    
    Specified by:
    
    has in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default CredentialTraversal<S,E> has(String label,
                                           String propertyKey,
                                           P<?> predicate)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their properties.
    
    Specified by:
    
    has in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default CredentialTraversal<S,E> has(String label,
                                           String propertyKey,
                                           Object value)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their properties.
    
    Specified by:
    
    has in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default CredentialTraversal<S,E> has(T accessor,
                                           Traversal<?,?> propertyTraversal)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their value of T where only T.id and T.label are supported.
    
    Specified by:
    
    has in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default CredentialTraversal<S,E> has(String propertyKey,
                                           Traversal<?,?> propertyTraversal)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on the value of the specified property key.
    
    Specified by:
    
    has in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Has Step
  - has
```
default CredentialTraversal<S,E> has(String propertyKey)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on the existence of properties.
    
    Specified by:
    
    has in interface GraphTraversal<S,E>
    
    Parameters:
    
    propertyKey - the key of the property to filter on for existence
    
    Returns:
    
    the traversal with an appended HasStep
    
    See Also:
    
    Reference Documentation - Has Step
  - hasNot
```
default CredentialTraversal<S,E> hasNot(String propertyKey)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on the non-existence of properties.
    
    Specified by:
    
    hasNot in interface GraphTraversal<S,E>
    
    Parameters:
    
    propertyKey - the key of the property to filter on for existence
    
    Returns:
    
    the traversal with an appended HasStep
    
    See Also:
    
    Reference Documentation - Has Step
  - hasLabel
```
default CredentialTraversal<S,E> hasLabel(String label,
                                                String... otherLabels)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their label.
    
    Specified by:
    
    hasLabel in interface GraphTraversal<S,E>
    
    Parameters:
    
    label - the label of the Element
    
    otherLabels - additional labels of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    See Also:
    
    Reference Documentation - Has Step
  - hasLabel
```
default CredentialTraversal<S,E> hasLabel(P<String> predicate)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their label. Note that calling this step with null is the same as calling GraphTraversal.hasLabel(String, String...) with a single null.
    
    Specified by:
    
    hasLabel in interface GraphTraversal<S,E>
    
    Parameters:
    
    predicate - the filter to apply to the label of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    See Also:
    
    Reference Documentation - Has Step
  - hasId
```
default CredentialTraversal<S,E> hasId(Object id,
                                             Object... otherIds)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their identifier.
    
    Specified by:
    
    hasId in interface GraphTraversal<S,E>
    
    Parameters:
    
    id - the identifier of the Element
    
    otherIds - additional identifiers of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    See Also:
    
    Reference Documentation - Has Step
  - hasId
```
default CredentialTraversal<S,E> hasId(P<Object> predicate)
```
    Description copied from interface: GraphTraversal
    
    Filters vertices, edges and vertex properties based on their identifier. Calling this step with a null value will result in effectively calling GraphTraversal.hasId(Object, Object...) wit a single null identifier and therefore filter all results since a T.id cannot be null.
    
    Specified by:
    
    hasId in interface GraphTraversal<S,E>
    
    Parameters:
    
    predicate - the filter to apply to the identifier of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    See Also:
    
    Reference Documentation - Has Step
  - hasKey
```
default CredentialTraversal<S,E> hasKey(String label,
                                              String... otherLabels)
```
    Description copied from interface: GraphTraversal
    
    Filters Property objects based on their key. It is not meant to test key existence on an Edge or a Vertex. In that case, prefer GraphTraversal.has(String).
    
    Specified by:
    
    hasKey in interface GraphTraversal<S,E>
    
    Parameters:
    
    label - the key of the Property
    
    otherLabels - additional key of the Property
    
    Returns:
    
    the traversal with an appended HasStep
    
    See Also:
    
    Reference Documentation - Has Step
  - hasKey
```
default CredentialTraversal<S,E> hasKey(P<String> predicate)
```
    Description copied from interface: GraphTraversal
    
    Filters Property objects based on their key. It is not meant to test key existence on an Edge or a Vertex. In that case, prefer GraphTraversal.has(String). Note that calling this step with null is the same as calling GraphTraversal.hasKey(String, String...) with a single null.
    
    Specified by:
    
    hasKey in interface GraphTraversal<S,E>
    
    Parameters:
    
    predicate - the filter to apply to the key of the Property
    
    Returns:
    
    the traversal with an appended HasStep
    
    See Also:
    
    Reference Documentation - Has Step
  - hasValue
```
default CredentialTraversal<S,E> hasValue(Object value,
                                                Object... otherValues)
```
    Description copied from interface: GraphTraversal
    
    Filters Property objects based on their value.
    
    Specified by:
    
    hasValue in interface GraphTraversal<S,E>
    
    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 CredentialTraversal<S,E> hasValue(P<Object> predicate)
```
    Description copied from interface: GraphTraversal
    
    Filters Property objects based on their value.Note that calling this step with null is the same as calling GraphTraversal.hasValue(Object, Object...) with a single null.
    
    Specified by:
    
    hasValue in interface GraphTraversal<S,E>
    
    Parameters:
    
    predicate - the filter to apply to the value of the Element
    
    Returns:
    
    the traversal with an appended HasStep
    
    See Also:
    
    Reference Documentation - Has Step
  - is
```
default CredentialTraversal<S,E> is(P<E> predicate)
```
    Description copied from interface: GraphTraversal
    
    Filters E object values given the provided predicate.
    
    Specified by:
    
    is in interface GraphTraversal<S,E>
    
    Parameters:
    
    predicate - the filter to apply
    
    Returns:
    
    the traversal with an appended IsStep
    
    See Also:
    
    Reference Documentation - Is Step
  - is
```
default CredentialTraversal<S,E> is(Object value)
```
    Description copied from interface: GraphTraversal
    
    Filter the E object if it is not P.eq(V) to the provided value.
    
    Specified by:
    
    is in interface GraphTraversal<S,E>
    
    Parameters:
    
    value - the value that the object must equal.
    
    Returns:
    
    the traversal with an appended IsStep.
    
    See Also:
    
    Reference Documentation - Is Step
  - not
```
default CredentialTraversal<S,E> not(Traversal<?,?> notTraversal)
```
    Description copied from interface: GraphTraversal
    
    Removes objects from the traversal stream when the traversal provided as an argument does not return any objects.
    
    Specified by:
    
    not in interface GraphTraversal<S,E>
    
    Parameters:
    
    notTraversal - the traversal to filter by.
    
    Returns:
    
    the traversal with an appended NotStep.
    
    See Also:
    
    Reference Documentation - Not Step
  - coin
```
default CredentialTraversal<S,E> coin(double probability)
```
    Description copied from interface: GraphTraversal
    
    Filter the E object given a biased coin toss.
    
    Specified by:
    
    coin in interface GraphTraversal<S,E>
    
    Parameters:
    
    probability - the probability that the object will pass through
    
    Returns:
    
    the traversal with an appended CoinStep.
    
    See Also:
    
    Reference Documentation - Coin Step
  - range
```
default CredentialTraversal<S,E> range(long low,
                                             long high)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    range in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Range Step
  - range
```
default <E2> CredentialTraversal<S,E2> range(Scope scope,
                                                   long low,
                                                   long high)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    range in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Range Step
  - limit
```
default CredentialTraversal<S,E> limit(long limit)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    limit in interface GraphTraversal<S,E>
    
    Parameters:
    
    limit - the number at which to end the stream
    
    Returns:
    
    the traversal with an appended RangeGlobalStep
    
    See Also:
    
    Reference Documentation - Limit Step
  - limit
```
default <E2> CredentialTraversal<S,E2> limit(Scope scope,
                                                   long limit)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    limit in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Limit Step
  - tail
```
default CredentialTraversal<S,E> tail()
```
    Description copied from interface: GraphTraversal
    
    Filters the objects in the traversal emitted as being last objects in the stream. In this case, only the last object will be returned.
    
    Specified by:
    
    tail in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended TailGlobalStep
    
    See Also:
    
    Reference Documentation - Tail Step
  - tail
```
default CredentialTraversal<S,E> tail(long limit)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    tail in interface GraphTraversal<S,E>
    
    Parameters:
    
    limit - the number at which to end the stream
    
    Returns:
    
    the traversal with an appended TailGlobalStep
    
    See Also:
    
    Reference Documentation - Tail Step
  - tail
```
default <E2> CredentialTraversal<S,E2> tail(Scope scope)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    tail in interface GraphTraversal<S,E>
    
    Parameters:
    
    scope - the scope of how to apply the tail
    
    Returns:
    
    the traversal with an appended TailGlobalStep or TailLocalStep depending on scope
    
    See Also:
    
    Reference Documentation - Tail Step
  - tail
```
default <E2> CredentialTraversal<S,E2> tail(Scope scope,
                                                  long limit)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    tail in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Tail Step
  - skip
```
default CredentialTraversal<S,E> skip(long skip)
```
    Description copied from interface: GraphTraversal
    
    Filters out the first n objects in the traversal.
    
    Specified by:
    
    skip in interface GraphTraversal<S,E>
    
    Parameters:
    
    skip - the number of objects to skip
    
    Returns:
    
    the traversal with an appended RangeGlobalStep
    
    See Also:
    
    Reference Documentation - Skip Step
  - skip
```
default <E2> CredentialTraversal<S,E2> skip(Scope scope,
                                                  long skip)
```
    Description copied from interface: GraphTraversal
    
    Filters out the first n objects in the traversal.
    
    Specified by:
    
    skip in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Skip Step
  - timeLimit
```
default CredentialTraversal<S,E> timeLimit(long timeLimit)
```
    Description copied from interface: GraphTraversal
    
    Once the first Traverser hits this step, a count down is started. Once the time limit is up, all remaining traversers are filtered out.
    
    Specified by:
    
    timeLimit in interface GraphTraversal<S,E>
    
    Parameters:
    
    timeLimit - the count down time
    
    Returns:
    
    the traversal with an appended TimeLimitStep
    
    See Also:
    
    Reference Documentation - TimeLimit Step
  - simplePath
```
default CredentialTraversal<S,E> simplePath()
```
    Description copied from interface: GraphTraversal
    
    Filter the E object if its Traverser.path() is not Path.isSimple().
    
    Specified by:
    
    simplePath in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended PathFilterStep.
    
    See Also:
    
    Reference Documentation - SimplePath Step
  - cyclicPath
```
default CredentialTraversal<S,E> cyclicPath()
```
    Description copied from interface: GraphTraversal
    
    Filter the E object if its Traverser.path() is Path.isSimple().
    
    Specified by:
    
    cyclicPath in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended PathFilterStep.
    
    See Also:
    
    Reference Documentation - CyclicPath Step
  - sample
```
default CredentialTraversal<S,E> sample(int amountToSample)
```
    Description copied from interface: GraphTraversal
    
    Allow some specified number of objects to pass through the stream.
    
    Specified by:
    
    sample in interface GraphTraversal<S,E>
    
    Parameters:
    
    amountToSample - the number of objects to allow
    
    Returns:
    
    the traversal with an appended SampleGlobalStep
    
    See Also:
    
    Reference Documentation - Sample Step
  - sample
```
default CredentialTraversal<S,E> sample(Scope scope,
                                              int amountToSample)
```
    Description copied from interface: GraphTraversal
    
    Allow some specified number of objects to pass through the stream.
    
    Specified by:
    
    sample in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Sample Step
  - drop
```
default CredentialTraversal<S,E> drop()
```
    Description copied from interface: GraphTraversal
    
    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().
    
    Specified by:
    
    drop in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the DropStep added
    
    See Also:
    
    Reference Documentation - Drop Step
  - sideEffect
```
default CredentialTraversal<S,E> sideEffect(Consumer<Traverser<E>> consumer)
```
    Description copied from interface: GraphTraversal
    
    Perform some operation on the Traverser and pass it to the next step unmodified.
    
    Specified by:
    
    sideEffect in interface GraphTraversal<S,E>
    
    Parameters:
    
    consumer - the operation to perform at this step in relation to the Traverser
    
    Returns:
    
    the traversal with an appended LambdaSideEffectStep
    
    See Also:
    
    Reference Documentation - General Steps
  - sideEffect
```
default CredentialTraversal<S,E> sideEffect(Traversal<?,?> sideEffectTraversal)
```
    Description copied from interface: GraphTraversal
    
    Perform some operation on the Traverser and pass it to the next step unmodified.
    
    Specified by:
    
    sideEffect in interface GraphTraversal<S,E>
    
    Parameters:
    
    sideEffectTraversal - the operation to perform at this step in relation to the Traverser
    
    Returns:
    
    the traversal with an appended TraversalSideEffectStep
    
    See Also:
    
    Reference Documentation - General Steps
  - cap
```
default <E2> CredentialTraversal<S,E2> cap(String sideEffectKey,
                                                 String... sideEffectKeys)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    cap in interface GraphTraversal<S,E>
    
    Parameters:
    
    sideEffectKey - the side-effect to emit
    
    sideEffectKeys - other side-effects to emit
    
    Returns:
    
    the traversal with an appended SideEffectCapStep
    
    See Also:
    
    Reference Documentation - Cap Step
  - subgraph
```
default CredentialTraversal<S,Edge> subgraph(String sideEffectKey)
```
    Description copied from interface: GraphTraversal
    
    Extracts a portion of the graph being traversed into a Graph object held in the specified side-effect key.
    
    Specified by:
    
    subgraph in interface GraphTraversal<S,E>
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the subgraph
    
    Returns:
    
    the traversal with an appended SubgraphStep
    
    See Also:
    
    Reference Documentation - Subgraph Step
  - aggregate
```
default CredentialTraversal<S,E> aggregate(String sideEffectKey)
```
    Description copied from interface: GraphTraversal
    
    Eagerly collects objects up to this step into a side-effect. Same as calling GraphTraversal.aggregate(Scope, String) with a Scope.global.
    
    Specified by:
    
    aggregate in interface GraphTraversal<S,E>
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the aggregated objects
    
    Returns:
    
    the traversal with an appended AggregateGlobalStep
    
    See Also:
    
    Reference Documentation - Aggregate Step
  - aggregate
```
default CredentialTraversal<S,E> aggregate(Scope scope,
                                                 String sideEffectKey)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    aggregate in interface GraphTraversal<S,E>
    
    sideEffectKey - the name of the side-effect key that will hold the aggregated objects
    
    Returns:
    
    the traversal with an appended AggregateGlobalStep
    
    See Also:
    
    Reference Documentation - Aggregate Step
  - group
```
default CredentialTraversal<S,E> group(String sideEffectKey)
```
    Description copied from interface: GraphTraversal
    
    Organize objects in the stream into a Map. Calls to group() are typically accompanied with GraphTraversal.by() modulators which help specify how the grouping should occur.
    
    Specified by:
    
    group in interface GraphTraversal<S,E>
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the aggregated grouping
    
    Returns:
    
    the traversal with an appended GroupStep.
    
    See Also:
    
    Reference Documentation - Group Step
  - groupCount
```
default CredentialTraversal<S,E> groupCount(String sideEffectKey)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    groupCount in interface GraphTraversal<S,E>
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the aggregated grouping
    
    Returns:
    
    the traversal with an appended GroupCountStep.
    
    See Also:
    
    Reference Documentation - GroupCount Step
  - fail
```
default CredentialTraversal<S,E> fail()
```
    Description copied from interface: GraphTraversal
    
    When triggered, immediately throws a RuntimeException which implements the Failure interface. The traversal will be terminated as a result.
    
    Specified by:
    
    fail in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended FailStep.
    
    See Also:
    
    Reference Documentation - Fail Step
  - fail
```
default CredentialTraversal<S,E> fail(String message)
```
    Description copied from interface: GraphTraversal
    
    When triggered, immediately throws a RuntimeException which implements the Failure interface. The traversal will be terminated as a result.
    
    Specified by:
    
    fail in interface GraphTraversal<S,E>
    
    Parameters:
    
    message - the error message to include in the exception
    
    Returns:
    
    the traversal with an appended FailStep.
    
    See Also:
    
    Reference Documentation - Fail Step
  - tree
```
default CredentialTraversal<S,E> tree(String sideEffectKey)
```
    Description copied from interface: GraphTraversal
    
    Aggregates the emanating paths into a Tree data structure.
    
    Specified by:
    
    tree in interface GraphTraversal<S,E>
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the tree
    
    Returns:
    
    the traversal with an appended TreeStep
    
    See Also:
    
    Reference Documentation - Tree Step
  - sack
```
default <V,U> CredentialTraversal<S,E> sack(BiFunction<V,U,V> sackOperator)
```
    Description copied from interface: GraphTraversal
    
    Map the Traverser to its Traverser.sack() value.
    
    Specified by:
    
    sack in interface GraphTraversal<S,E>
    
    Parameters:
    
    sackOperator - the operator to apply to the sack value
    
    Returns:
    
    the traversal with an appended SackStep.
    
    See Also:
    
    Reference Documentation - Sack Step
  - store
```
default CredentialTraversal<S,E> store(String sideEffectKey)
```
    Description copied from interface: GraphTraversal
    
    Lazily aggregates objects in the stream into a side-effect collection.
    
    Specified by:
    
    store in interface GraphTraversal<S,E>
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key that will hold the aggregate
    
    Returns:
    
    the traversal with an appended AggregateLocalStep
    
    See Also:
    
    Reference Documentation - Store Step
  - profile
```
default CredentialTraversal<S,E> profile(String sideEffectKey)
```
    Description copied from interface: GraphTraversal
    
    Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
    
    Specified by:
    
    profile in interface GraphTraversal<S,E>
    
    Parameters:
    
    sideEffectKey - the name of the side-effect key within which to hold the profile object
    
    Returns:
    
    the traversal with an appended ProfileSideEffectStep
    
    See Also:
    
    Reference Documentation - Profile Step
  - profile
```
default CredentialTraversal<S,TraversalMetrics> profile()
```
    Description copied from interface: Traversal
    
    Profile the traversal.
    
    Specified by:
    
    profile in interface GraphTraversal<S,E>
    
    Specified by:
    
    profile in interface Traversal<S,E>
    
    Returns:
    
    the updated traversal with respective ProfileSideEffectStep.
    
    See Also:
    
    Reference Documentation - Profile Step
  - property
```
default CredentialTraversal<S,E> property(VertexProperty.Cardinality cardinality,
                                                Object key,
                                                Object value,
                                                Object... keyValues)
```
    Description copied from interface: GraphTraversal
    
    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 GraphTraversal.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.
    
    Specified by:
    
    property in interface GraphTraversal<S,E>
    
    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 which may not be null if the key is of type T
    
    keyValues - any meta properties to be assigned to this property
    
    Returns:
    
    the traversal with the last step modified to add a property
    
    See Also:
    
    AddProperty Step
  - property
```
default CredentialTraversal<S,E> property(Object key,
                                                Object value,
                                                Object... keyValues)
```
    Description copied from interface: GraphTraversal
    
    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.
    If a Map is supplied then each of the key/value pairs in the map will be added as property. This method is the long-hand version of looping through the GraphTraversal.property(Object, Object, Object...) method for each key/value pair supplied.
    This method is effectively calls GraphTraversal.property(VertexProperty.Cardinality, Object, Object, Object...) as property(null, key, value, keyValues.
    
    Specified by:
    
    property in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    AddProperty Step
  - property
```
default CredentialTraversal<S,E> property(Map<Object,Object> value)
```
    Description copied from interface: GraphTraversal
    
    When a Map is supplied then each of the key/value pairs in the map will be added as property. This method is the long-hand version of looping through the GraphTraversal.property(Object, Object, Object...) method for each key/value pair supplied.
    If a Map is not supplied then an exception is thrown.
    This method is effectively calls GraphTraversal.property(VertexProperty.Cardinality, Object, Object, Object...) as property(null, key, value, keyValues.
    
    Specified by:
    
    property in interface GraphTraversal<S,E>
    
    Parameters:
    
    value - the value for the property
    
    Returns:
    
    the traversal with the last step modified to add a property
    
    See Also:
    
    AddProperty Step
  - branch
```
default <M,E2> CredentialTraversal<S,E2> branch(Traversal<?,M> branchTraversal)
```
    Description copied from interface: GraphTraversal
    
    Split the Traverser to all the specified traversals.
    
    Specified by:
    
    branch in interface GraphTraversal<S,E>
    
    Parameters:
    
    branchTraversal - the traversal to branch the Traverser to
    
    Returns:
    
    the Traversal with the BranchStep added
    
    See Also:
    
    Reference Documentation - General Steps
  - branch
```
default <M,E2> CredentialTraversal<S,E2> branch(Function<Traverser<E>,M> function)
```
    Description copied from interface: GraphTraversal
    
    Split the Traverser to all the specified functions.
    
    Specified by:
    
    branch in interface GraphTraversal<S,E>
    
    Parameters:
    
    function - the traversal to branch the Traverser to
    
    Returns:
    
    the Traversal with the BranchStep added
    
    See Also:
    
    Reference Documentation - General Steps
  - choose
```
default <M,E2> CredentialTraversal<S,E2> choose(Traversal<?,M> choiceTraversal)
```
    Description copied from interface: GraphTraversal
    
    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 GraphTraversal.option(M, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?, E2>) which provides the various branch choices.
    
    Specified by:
    
    choose in interface GraphTraversal<S,E>
    
    Parameters:
    
    choiceTraversal - the traversal used to determine the value for the branch
    
    Returns:
    
    the traversal with the appended ChooseStep
    
    See Also:
    
    Reference Documentation - Choose Step
  - choose
```
default <E2> CredentialTraversal<S,E2> choose(Traversal<?,?> traversalPredicate,
                                                    Traversal<?,E2> trueChoice,
                                                    Traversal<?,E2> falseChoice)
```
    Description copied from interface: GraphTraversal
    
    Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
    
    Specified by:
    
    choose in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Choose Step
  - choose
```
default <E2> CredentialTraversal<S,E2> choose(Traversal<?,?> traversalPredicate,
                                                    Traversal<?,E2> trueChoice)
```
    Description copied from interface: GraphTraversal
    
    Routes the current traverser to a particular traversal branch option which allows the creation of if-then like semantics within a traversal.
    
    Specified by:
    
    choose in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Choose Step
  - choose
```
default <M,E2> CredentialTraversal<S,E2> choose(Function<E,M> choiceFunction)
```
    Description copied from interface: GraphTraversal
    
    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 GraphTraversal.option(M, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?, E2>) which provides the various branch choices.
    
    Specified by:
    
    choose in interface GraphTraversal<S,E>
    
    Parameters:
    
    choiceFunction - the function used to determine the value for the branch
    
    Returns:
    
    the traversal with the appended ChooseStep
    
    See Also:
    
    Reference Documentation - Choose Step
  - choose
```
default <E2> CredentialTraversal<S,E2> choose(Predicate<E> choosePredicate,
                                                    Traversal<?,E2> trueChoice,
                                                    Traversal<?,E2> falseChoice)
```
    Description copied from interface: GraphTraversal
    
    Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
    
    Specified by:
    
    choose in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Choose Step
  - choose
```
default <E2> CredentialTraversal<S,E2> choose(Predicate<E> choosePredicate,
                                                    Traversal<?,E2> trueChoice)
```
    Description copied from interface: GraphTraversal
    
    Routes the current traverser to a particular traversal branch option which allows the creation of if-then like semantics within a traversal.
    
    Specified by:
    
    choose in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - Choose Step
  - optional
```
default <E2> CredentialTraversal<S,E2> optional(Traversal<?,E2> optionalTraversal)
```
    Description copied from interface: GraphTraversal
    
    Returns the result of the specified traversal if it yields a result, otherwise it returns the calling element.
    
    Specified by:
    
    optional in interface GraphTraversal<S,E>
    
    Parameters:
    
    optionalTraversal - the traversal to execute for a potential result
    
    Returns:
    
    the traversal with the appended ChooseStep
    
    See Also:
    
    Reference Documentation - Optional Step
  - union
```
default <E2> CredentialTraversal<S,E2> union(Traversal<?,E2>... unionTraversals)
```
    Description copied from interface: GraphTraversal
    
    Merges the results of an arbitrary number of traversals.
    
    Specified by:
    
    union in interface GraphTraversal<S,E>
    
    Parameters:
    
    unionTraversals - the traversals to merge
    
    Returns:
    
    the traversal with the appended UnionStep
    
    See Also:
    
    Reference Documentation - Union Step
  - coalesce
```
default <E2> CredentialTraversal<S,E2> coalesce(Traversal<?,E2>... coalesceTraversals)
```
    Description copied from interface: GraphTraversal
    
    Evaluates the provided traversals and returns the result of the first traversal to emit at least one object.
    
    Specified by:
    
    coalesce in interface GraphTraversal<S,E>
    
    Parameters:
    
    coalesceTraversals - the traversals to coalesce
    
    Returns:
    
    the traversal with the appended CoalesceStep
    
    See Also:
    
    Reference Documentation - Coalesce Step
  - repeat
```
default CredentialTraversal<S,E> repeat(Traversal<?,E> repeatTraversal)
```
    Description copied from interface: GraphTraversal
    
    This step is used for looping over a traversal given some break predicate.
    
    Specified by:
    
    repeat in interface GraphTraversal<S,E>
    
    Parameters:
    
    repeatTraversal - the traversal to repeat over
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    See Also:
    
    Reference Documentation - Repeat Step
  - repeat
```
default CredentialTraversal<S,E> repeat(String loopName,
                                              Traversal<?,E> repeatTraversal)
```
    Description copied from interface: GraphTraversal
    
    This step is used for looping over a traversal given some break predicate and with a specified loop name.
    
    Specified by:
    
    repeat in interface GraphTraversal<S,E>
    
    Parameters:
    
    loopName - The name given to the loop
    
    repeatTraversal - the traversal to repeat over
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    See Also:
    
    Reference Documentation - Repeat Step
  - emit
```
default CredentialTraversal<S,E> emit(Traversal<?,?> emitTraversal)
```
    Description copied from interface: GraphTraversal
    
    Emit is used in conjunction with GraphTraversal.repeat(Traversal) to determine what objects get emit from the loop.
    
    Specified by:
    
    emit in interface GraphTraversal<S,E>
    
    Parameters:
    
    emitTraversal - the emit predicate defined as a traversal
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    See Also:
    
    Reference Documentation - Repeat Step
  - emit
```
default CredentialTraversal<S,E> emit(Predicate<Traverser<E>> emitPredicate)
```
    Description copied from interface: GraphTraversal
    
    Emit is used in conjunction with GraphTraversal.repeat(Traversal) to determine what objects get emit from the loop.
    
    Specified by:
    
    emit in interface GraphTraversal<S,E>
    
    Parameters:
    
    emitPredicate - the emit predicate
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    See Also:
    
    Reference Documentation - Repeat Step
  - emit
```
default CredentialTraversal<S,E> emit()
```
    Description copied from interface: GraphTraversal
    
    Emit is used in conjunction with GraphTraversal.repeat(Traversal) to emit all objects from the loop.
    
    Specified by:
    
    emit in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    See Also:
    
    Reference Documentation - Repeat Step
  - until
```
default CredentialTraversal<S,E> until(Traversal<?,?> untilTraversal)
```
    Description copied from interface: GraphTraversal
    
    Modifies a GraphTraversal.repeat(Traversal) to determine when the loop should exit.
    
    Specified by:
    
    until in interface GraphTraversal<S,E>
    
    Parameters:
    
    untilTraversal - the traversal that determines when the loop exits
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    See Also:
    
    Reference Documentation - Repeat Step
  - until
```
default CredentialTraversal<S,E> until(Predicate<Traverser<E>> untilPredicate)
```
    Description copied from interface: GraphTraversal
    
    Modifies a GraphTraversal.repeat(Traversal) to determine when the loop should exit.
    
    Specified by:
    
    until in interface GraphTraversal<S,E>
    
    Parameters:
    
    untilPredicate - the predicate that determines when the loop exits
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    See Also:
    
    Reference Documentation - Repeat Step
  - times
```
default CredentialTraversal<S,E> times(int maxLoops)
```
    Description copied from interface: GraphTraversal
    
    Modifies a GraphTraversal.repeat(Traversal) to specify how many loops should occur before exiting.
    
    Specified by:
    
    times in interface GraphTraversal<S,E>
    
    Parameters:
    
    maxLoops - the number of loops to execute prior to exiting
    
    Returns:
    
    the traversal with the appended RepeatStep
    
    See Also:
    
    Reference Documentation - Repeat Step
  - local
```
default <E2> CredentialTraversal<S,E2> local(Traversal<?,E2> localTraversal)
```
    Description copied from interface: GraphTraversal
    
    Provides a execute a specified traversal on a single element within a stream.
    
    Specified by:
    
    local in interface GraphTraversal<S,E>
    
    Parameters:
    
    localTraversal - the traversal to execute locally
    
    Returns:
    
    the traversal with the appended LocalStep
    
    See Also:
    
    Reference Documentation - Local Step
  - pageRank
```
default CredentialTraversal<S,E> pageRank()
```
    Description copied from interface: GraphTraversal
    
    Calculates a PageRank over the graph using a 0.85 for the alpha value.
    
    Specified by:
    
    pageRank in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the appended PageRankVertexProgramStep
    
    See Also:
    
    Reference Documentation - PageRank Step
  - pageRank
```
default CredentialTraversal<S,E> pageRank(double alpha)
```
    Description copied from interface: GraphTraversal
    
    Calculates a PageRank over the graph.
    
    Specified by:
    
    pageRank in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the appended PageRankVertexProgramStep
    
    See Also:
    
    Reference Documentation - PageRank Step
  - peerPressure
```
default CredentialTraversal<S,E> peerPressure()
```
    Description copied from interface: GraphTraversal
    
    Executes a Peer Pressure community detection algorithm over the graph.
    
    Specified by:
    
    peerPressure in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the appended PeerPressureVertexProgramStep
    
    See Also:
    
    Reference Documentation - PeerPressure Step
  - connectedComponent
```
default CredentialTraversal<S,E> connectedComponent()
```
    Description copied from interface: GraphTraversal
    
    Executes a Connected Component algorithm over the graph.
    
    Specified by:
    
    connectedComponent in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the appended ConnectedComponentVertexProgram
    
    See Also:
    
    Reference Documentation - ConnectedComponent Step
  - shortestPath
```
default CredentialTraversal<S,Path> shortestPath()
```
    Description copied from interface: GraphTraversal
    
    Executes a Shortest Path algorithm over the graph.
    
    Specified by:
    
    shortestPath in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the appended ShortestPathVertexProgramStep
    
    See Also:
    
    Reference Documentation - ShortestPath Step
  - program
```
default CredentialTraversal<S,E> program(VertexProgram<?> vertexProgram)
```
    Description copied from interface: GraphTraversal
    
    Executes an arbitrary VertexProgram over the graph.
    
    Specified by:
    
    program in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the appended ProgramVertexProgramStep
    
    See Also:
    
    Reference Documentation - Program Step
  - as
```
default CredentialTraversal<S,E> as(String stepLabel,
                                          String... stepLabels)
```
    Description copied from interface: GraphTraversal
    
    A step modulator that provides a label to the step that can be accessed later in the traversal by other steps.
    
    Specified by:
    
    as in interface GraphTraversal<S,E>
    
    Parameters:
    
    stepLabel - the name of the step
    
    stepLabels - additional names for the label
    
    Returns:
    
    the traversal with the modified end step
    
    See Also:
    
    Reference Documentation - As Step
  - barrier
```
default CredentialTraversal<S,E> barrier()
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    barrier in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended NoOpBarrierStep
    
    See Also:
    
    Reference Documentation - Barrier Step
  - barrier
```
default CredentialTraversal<S,E> barrier(int maxBarrierSize)
```
    Description copied from interface: GraphTraversal
    
    Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
    
    Specified by:
    
    barrier in interface GraphTraversal<S,E>
    
    Parameters:
    
    maxBarrierSize - the size of the barrier
    
    Returns:
    
    the traversal with an appended NoOpBarrierStep
    
    See Also:
    
    Reference Documentation - Barrier Step
  - index
```
default <E2> CredentialTraversal<S,E2> index()
```
    Description copied from interface: GraphTraversal
    
    Indexes all items of the current collection. The indexing format can be configured using the GraphTraversal.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"}
    
    Specified by:
    
    index in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with an appended IndexStep
    
    See Also:
    
    Reference Documentation - Index Step
  - barrier
```
default CredentialTraversal<S,E> barrier(Consumer<TraverserSet<Object>> barrierConsumer)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    barrier in interface GraphTraversal<S,E>
    
    Parameters:
    
    barrierConsumer - a consumer function that is applied to the objects aggregated to the barrier
    
    Returns:
    
    the traversal with an appended NoOpBarrierStep
    
    See Also:
    
    Reference Documentation - Barrier Step
  - with
```
default CredentialTraversal<S,E> with(String key)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    with in interface GraphTraversal<S,E>
    
    Parameters:
    
    key - the key of the configuration to apply to a step
    
    Returns:
    
    the traversal with a modulated step
    
    See Also:
    
    Reference Documentation - With Step
  - with
```
default CredentialTraversal<S,E> with(String key,
                                            Object value)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    with in interface GraphTraversal<S,E>
    
    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
    
    See Also:
    
    Reference Documentation - With Step
  - by
```
default CredentialTraversal<S,E> by()
```
    Description copied from interface: GraphTraversal
    
    The by() can be applied to a number of different step to alter their behaviors. This form is essentially an GraphTraversal.identity() modulation.
    
    Specified by:
    
    by in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with a modulated step.
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default CredentialTraversal<S,E> by(Traversal<?,?> traversal)
```
    Description copied from interface: GraphTraversal
    
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified traversal.
    
    Specified by:
    
    by in interface GraphTraversal<S,E>
    
    Parameters:
    
    traversal - the traversal to apply
    
    Returns:
    
    the traversal with a modulated step.
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default CredentialTraversal<S,E> by(T token)
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    by in interface GraphTraversal<S,E>
    
    Parameters:
    
    token - the token to apply
    
    Returns:
    
    the traversal with a modulated step.
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default CredentialTraversal<S,E> by(String key)
```
    Description copied from interface: GraphTraversal
    
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified key.
    
    Specified by:
    
    by in interface GraphTraversal<S,E>
    
    Parameters:
    
    key - the key to apply
    
    Returns:
    
    the traversal with a modulated step.
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default <V> CredentialTraversal<S,E> by(Function<V,Object> function)
```
    Description copied from interface: GraphTraversal
    
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Specified by:
    
    by in interface GraphTraversal<S,E>
    
    Parameters:
    
    function - the function to apply
    
    Returns:
    
    the traversal with a modulated step.
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default <V> CredentialTraversal<S,E> by(Traversal<?,?> traversal,
                                              Comparator<V> comparator)
```
    Description copied from interface: GraphTraversal
    
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Specified by:
    
    by in interface GraphTraversal<S,E>
    
    Parameters:
    
    traversal - the traversal to apply
    
    comparator - the comparator to apply typically for some GraphTraversal.order()
    
    Returns:
    
    the traversal with a modulated step.
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default CredentialTraversal<S,E> by(Comparator<E> comparator)
```
    Description copied from interface: GraphTraversal
    
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Specified by:
    
    by in interface GraphTraversal<S,E>
    
    Parameters:
    
    comparator - the comparator to apply typically for some GraphTraversal.order()
    
    Returns:
    
    the traversal with a modulated step.
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default CredentialTraversal<S,E> by(Order order)
```
    Description copied from interface: GraphTraversal
    
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Specified by:
    
    by in interface GraphTraversal<S,E>
    
    Parameters:
    
    order - the comparator to apply typically for some GraphTraversal.order()
    
    Returns:
    
    the traversal with a modulated step.
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default <V> CredentialTraversal<S,E> by(String key,
                                              Comparator<V> comparator)
```
    Description copied from interface: GraphTraversal
    
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Specified by:
    
    by in interface GraphTraversal<S,E>
    
    Parameters:
    
    key - the key to apply traversal
    
    comparator - the comparator to apply typically for some GraphTraversal.order()
    
    Returns:
    
    the traversal with a modulated step.
    
    See Also:
    
    Reference Documentation - By Step
  - by
```
default <U> CredentialTraversal<S,E> by(Function<U,Object> function,
                                              Comparator comparator)
```
    Description copied from interface: GraphTraversal
    
    The by() can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
    
    Specified by:
    
    by in interface GraphTraversal<S,E>
    
    Parameters:
    
    function - the function to apply
    
    comparator - the comparator to apply typically for some GraphTraversal.order()
    
    Returns:
    
    the traversal with a modulated step.
    
    See Also:
    
    Reference Documentation - By Step
  - option
```
default <M,E2> CredentialTraversal<S,E> option(M token,
                                                           Traversal<?,E2> traversalOption)
```
    Description copied from interface: GraphTraversal
    
    This is a step modulator to a TraversalOptionParent like choose() or mergeV() where the provided argument associated to the token is applied according to the semantics of the step. Please see the documentation of such steps to understand the usage context.
    
    Specified by:
    
    option in interface GraphTraversal<S,E>
    
    Parameters:
    
    token - the token that would trigger this option which may be a Pick, Merge, a Traversal, Predicate, or object depending on the step being modulated.
    
    traversalOption - the option as a traversal
    
    Returns:
    
    the traversal with the modulated step
    
    See Also:
    
    Reference Documentation - Choose Step, Reference Documentation - MergeV Step, Reference Documentation - MergeE Step
  - option
```
default <M,E2> CredentialTraversal<S,E> option(M token,
                                                           Map<Object,Object> m)
```
    Description copied from interface: GraphTraversal
    
    This is a step modulator to a TraversalOptionParent like choose() or mergeV() where the provided argument associated to the token is applied according to the semantics of the step. Please see the documentation of such steps to understand the usage context.
    
    Specified by:
    
    option in interface GraphTraversal<S,E>
    
    m - Provides a Map as the option which is the same as doing constant(m).
    
    Returns:
    
    the traversal with the modulated step
    
    See Also:
    
    Reference Documentation - MergeV Step, Reference Documentation - MergeE Step
  - option
```
default <E2> CredentialTraversal<S,E> option(Traversal<?,E2> traversalOption)
```
    Description copied from interface: GraphTraversal
    
    This step modifies GraphTraversal.choose(Function) to specifies the available choices that might be executed.
    
    Specified by:
    
    option in interface GraphTraversal<S,E>
    
    Parameters:
    
    traversalOption - the option as a traversal
    
    Returns:
    
    the traversal with the modulated step
    
    See Also:
    
    Reference Documentation - Choose Step
  - read
```
default CredentialTraversal<S,E> read()
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    read in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the IoStep modulated to read
    
    See Also:
    
    Reference Documentation - IO Step, Reference Documentation - Read Step
  - write
```
default CredentialTraversal<S,E> write()
```
    Description copied from interface: GraphTraversal
    
    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.
    
    Specified by:
    
    write in interface GraphTraversal<S,E>
    
    Returns:
    
    the traversal with the IoStep modulated to write
    
    See Also:
    
    Reference Documentation - IO Step, Reference Documentation - Write Step
  - iterate
```
default CredentialTraversal<S,E> iterate()
```
    Description copied from interface: Traversal
    
    Iterate all the Traverser instances in the traversal. What is returned is the empty traversal. It is assumed that what is desired from the computation is are the sideEffects yielded by the traversal.
    
    Specified by:
    
    iterate in interface GraphTraversal<S,E>
    
    Specified by:
    
    iterate in interface GraphTraversal.Admin<S,E>
    
    Specified by:
    
    iterate in interface Traversal<S,E>
    
    Returns:
    
    the fully drained traversal

Interface CredentialTraversal<S,​E>

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal

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

Field Summary

Fields inherited from interface org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential.CredentialTraversalDsl

Method Summary

Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal

Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin

Methods inherited from interface java.util.Iterator

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

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

Method Detail

users

users

user

map

map

flatMap

flatMap

id

label

identity

constant

V

to

out

in

both

toE

outE

inE

bothE

toV

inV

outV

bothV

otherV

order

order

properties

values

propertyMap

elementMap

valueMap

valueMap

key

value

path

match

sack

loops

loops

project

select

select

select

select

select

select

select

unfold

fold

fold

count

count

sum

sum

max

max

min

min

mean

mean

group

groupCount

tree

addV

addV

addV

Interface CredentialTraversal<S,E>