org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential

## Class __

- java.lang.Object
- - org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential.__

-     public final class __
      extends Object

- - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <A> CredentialTraversal<A,A>` | `__(A... starts)`
    `static <A> CredentialTraversal<A,Edge>` | `addE(String edgeLabel)`
    `static <A> CredentialTraversal<A,Edge>` | `addE(Traversal<?,String> edgeLabelTraversal)`
    `static <A> CredentialTraversal<A,Vertex>` | `addV()`
    `static <A> CredentialTraversal<A,Vertex>` | `addV(String vertexLabel)`
    `static <A> CredentialTraversal<A,Vertex>` | `addV(Traversal<?,String> vertexLabelTraversal)`
    `static <A> CredentialTraversal<A,A>` | `aggregate(Scope scope, String sideEffectKey)`
    `static <A> CredentialTraversal<A,A>` | `aggregate(String sideEffectKey)`
    `static <A> CredentialTraversal<A,A>` | `and(Traversal<?,?>... andTraversals)`
    `static <A> CredentialTraversal<A,A>` | `as(String label, String... labels)`
    `static <A> CredentialTraversal<A,A>` | `barrier()`
    `static <A> CredentialTraversal<A,A>` | `barrier(Consumer<TraverserSet<Object>> barrierConsumer)`
    `static <A> CredentialTraversal<A,A>` | `barrier(int maxBarrierSize)`
    `static CredentialTraversal<Vertex,Vertex>` | `both(String... edgeLabels)`
    `static CredentialTraversal<Vertex,Edge>` | `bothE(String... edgeLabels)`
    `static CredentialTraversal<Edge,Vertex>` | `bothV()`
    `static <A,M,B> CredentialTraversal<A,B>` | `branch(Function<Traverser<A>,M> function)`
    `static <A,M,B> CredentialTraversal<A,B>` | `branch(Traversal<?,M> traversalFunction)`
    `static <A,B> CredentialTraversal<A,B>` | `cap(String sideEffectKey, String... sideEffectKeys)`
    `static <A,M,B> CredentialTraversal<A,B>` | `choose(Function<A,M> choiceFunction)`
    `static <A,B> CredentialTraversal<A,B>` | `choose(Predicate<A> choosePredicate, Traversal<?,B> trueChoice)`
    `static <A,B> CredentialTraversal<A,B>` | `choose(Predicate<A> choosePredicate, Traversal<?,B> trueChoice, Traversal<?,B> falseChoice)`
    `static <A,M,B> CredentialTraversal<A,B>` | `choose(Traversal<?,M> traversalFunction)`
    `static <A,M,B> CredentialTraversal<A,B>` | `choose(Traversal<?,M> traversalPredicate, Traversal<?,B> trueChoice)`
    `static <A,M,B> CredentialTraversal<A,B>` | `choose(Traversal<?,M> traversalPredicate, Traversal<?,B> trueChoice, Traversal<?,B> falseChoice)`
    `static <A,B> CredentialTraversal<A,B>` | `coalesce(Traversal<?,B>... traversals)`
    `static <A> CredentialTraversal<A,A>` | `coin(double probability)`
    `static <A> CredentialTraversal<A,A>` | `constant(A a)`
    `static <A> CredentialTraversal<A,Long>` | `count()`
    `static <A> CredentialTraversal<A,Long>` | `count(Scope scope)`
    `static <A> CredentialTraversal<A,A>` | `cyclicPath()`
    `static <A> CredentialTraversal<A,A>` | `dedup(Scope scope, String... dedupLabels)`
    `static <A> CredentialTraversal<A,A>` | `dedup(String... dedupLabels)`
    `static <A> CredentialTraversal<A,A>` | `drop()`
    `static <A extends Element,B> CredentialTraversal<A,Map<Object,B>>` | `elementMap(String... propertyKeys)`
    `static <A> CredentialTraversal<A,A>` | `emit()`
    `static <A> CredentialTraversal<A,A>` | `emit(Predicate<Traverser<A>> emitPredicate)`
    `static <A> CredentialTraversal<A,A>` | `emit(Traversal<?,?> emitTraversal)`
    `static <A> CredentialTraversal<A,A>` | `filter(Predicate<Traverser<A>> predicate)`
    `static <A> CredentialTraversal<A,A>` | `filter(Traversal<?,?> filterTraversal)`
    `static <A,B> CredentialTraversal<A,B>` | `flatMap(Function<Traverser<A>,Iterator<B>> function)`
    `static <A,B> CredentialTraversal<A,B>` | `flatMap(Traversal<?,B> flatMapTraversal)`
    `static <A> CredentialTraversal<A,List<A>>` | `fold()`
    `static <A,B> CredentialTraversal<A,B>` | `fold(B seed, BiFunction<B,A,B> foldFunction)`
    `static <A,K,V> CredentialTraversal<A,Map<K,V>>` | `group()`
    `static <A> CredentialTraversal<A,A>` | `group(String sideEffectKey)`
    `static <A,K> CredentialTraversal<A,Map<K,Long>>` | `groupCount()`
    `static <A> CredentialTraversal<A,A>` | `groupCount(String sideEffectKey)`
    `static <A> CredentialTraversal<A,A>` | `has(String propertyKey)`
    `static <A> CredentialTraversal<A,A>` | `has(String propertyKey, Object value)`
    `static <A> CredentialTraversal<A,A>` | `has(String propertyKey, P<?> predicate)`
    `static <A> CredentialTraversal<A,A>` | `has(String label, String propertyKey, Object value)`
    `static <A> CredentialTraversal<A,A>` | `has(String label, String propertyKey, P<?> predicate)`
    `static <A> CredentialTraversal<A,A>` | `has(String propertyKey, Traversal<?,?> propertyTraversal)`
    `static <A> CredentialTraversal<A,A>` | `has(T accessor, Object value)`
    `static <A> CredentialTraversal<A,A>` | `has(T accessor, P<?> predicate)`
    `static <A> CredentialTraversal<A,A>` | `has(T accessor, Traversal<?,?> propertyTraversal)`
    `static <A> CredentialTraversal<A,A>` | `hasId(Object id, Object... otherIds)`
    `static <A> CredentialTraversal<A,A>` | `hasId(P<Object> predicate)`
    `static <A> CredentialTraversal<A,A>` | `hasKey(P<String> predicate)`
    `static <A> CredentialTraversal<A,A>` | `hasKey(String label, String... otherLabels)`
    `static <A> CredentialTraversal<A,A>` | `hasLabel(P<String> predicate)`
    `static <A> CredentialTraversal<A,A>` | `hasLabel(String label, String... otherLabels)`
    `static <A> CredentialTraversal<A,A>` | `hasNot(String propertyKey)`
    `static <A> CredentialTraversal<A,A>` | `hasValue(Object value, Object... values)`
    `static <A> CredentialTraversal<A,A>` | `hasValue(P<Object> predicate)`
    `static <A extends Element> CredentialTraversal<A,Object>` | `id()`
    `static <A> CredentialTraversal<A,A>` | `identity()`
    `static CredentialTraversal<Vertex,Vertex>` | `in(String... edgeLabels)`
    `static <A,B> CredentialTraversal<A,B>` | `index()`
    `static CredentialTraversal<Vertex,Edge>` | `inE(String... edgeLabels)`
    `static <A> CredentialTraversal<A,A>` | `inject(A... injections)`
    `static CredentialTraversal<Edge,Vertex>` | `inV()`
    `static <A> CredentialTraversal<A,A>` | `is(Object value)`
    `static <A> CredentialTraversal<A,A>` | `is(P<A> predicate)`
    `static <A extends Property> CredentialTraversal<A,String>` | `key()`
    `static <A extends Element> CredentialTraversal<A,String>` | `label()`
    `static <A> CredentialTraversal<A,A>` | `limit(long limit)`
    `static <A> CredentialTraversal<A,A>` | `limit(Scope scope, long limit)`
    `static <A,B> CredentialTraversal<A,B>` | `local(Traversal<?,B> localTraversal)`
    `static <A> CredentialTraversal<A,Integer>` | `loops()`
    `static <A> CredentialTraversal<A,Integer>` | `loops(String loopName)`
    `static <A,B> CredentialTraversal<A,B>` | `map(Function<Traverser<A>,B> function)`
    `static <A,B> CredentialTraversal<A,B>` | `map(Traversal<?,B> mapTraversal)`
    `static <A,B> CredentialTraversal<A,Map<String,B>>` | `match(Traversal<?,?>... matchTraversals)`
    `static <A> CredentialTraversal<A,Double>` | `math(String expression)`
    `static <A,B extends Comparable> CredentialTraversal<A,B>` | `max()`
    `static <A,B extends Comparable> CredentialTraversal<A,B>` | `max(Scope scope)`
    `static <A> CredentialTraversal<A,Double>` | `mean()`
    `static <A> CredentialTraversal<A,Double>` | `mean(Scope scope)`
    `static <A,B extends Comparable> CredentialTraversal<A,B>` | `min()`
    `static <A,B extends Comparable> CredentialTraversal<A,B>` | `min(Scope scope)`
    `static <A> CredentialTraversal<A,A>` | `not(Traversal<?,?> notTraversal)`
    `static <A> CredentialTraversal<A,A>` | `optional(Traversal<?,A> optionalTraversal)`
    `static <A> CredentialTraversal<A,A>` | `or(Traversal<?,?>... orTraversals)`
    `static <A> CredentialTraversal<A,A>` | `order()`
    `static <A> CredentialTraversal<A,A>` | `order(Scope scope)`
    `static CredentialTraversal<Edge,Vertex>` | `otherV()`
    `static CredentialTraversal<Vertex,Vertex>` | `out(String... edgeLabels)`
    `static CredentialTraversal<Vertex,Edge>` | `outE(String... edgeLabels)`
    `static CredentialTraversal<Edge,Vertex>` | `outV()`
    `static <A> CredentialTraversal<A,Path>` | `path()`
    `static <A,B> CredentialTraversal<A,Map<String,B>>` | `project(String projectKey, String... projectKeys)`
    `static <A extends Element,B> CredentialTraversal<A,? extends Property<B>>` | `properties(String... propertyKeys)`
    `static <A> CredentialTraversal<A,A>` | `property(Object key, Object value, Object... keyValues)`
    `static <A> CredentialTraversal<A,A>` | `property(VertexProperty.Cardinality cardinality, Object key, Object value, Object... keyValues)`
    `static <A extends Element,B> CredentialTraversal<A,Map<String,B>>` | `propertyMap(String... propertyKeys)`
    `static <A> CredentialTraversal<A,A>` | `range(long low, long arg1)`
    `static <A> CredentialTraversal<A,A>` | `range(Scope scope, long low, long arg2)`
    `static <A> CredentialTraversal<A,A>` | `repeat(String loopName, Traversal<?,A> traversal)`
    `static <A> CredentialTraversal<A,A>` | `repeat(Traversal<?,A> traversal)`
    `static <A,B> CredentialTraversal<A,B>` | `sack()`
    `static <A,V,U> CredentialTraversal<A,A>` | `sack(BiFunction<V,U,V> sackOperator)`
    `static <A> CredentialTraversal<A,A>` | `sample(int amountToSample)`
    `static <A> CredentialTraversal<A,A>` | `sample(Scope scope, int amountToSample)`
    `static <A,B> CredentialTraversal<A,Collection<B>>` | `select(Column column)`
    `static <A,B> CredentialTraversal<A,B>` | `select(Pop pop, String selectKey)`
    `static <A,B> CredentialTraversal<A,Map<String,B>>` | `select(Pop pop, String selectKey1, String selectKey2, String... otherSelectKeys)`
    `static <A,B> CredentialTraversal<A,B>` | `select(Pop pop, Traversal<A,B> keyTraversal)`
    `static <A,B> CredentialTraversal<A,B>` | `select(String selectKey)`
    `static <A,B> CredentialTraversal<A,Map<String,B>>` | `select(String selectKey1, String selectKey2, String... otherSelectKeys)`
    `static <A,B> CredentialTraversal<A,B>` | `select(Traversal<A,B> keyTraversal)`
    `static <A> CredentialTraversal<A,A>` | `sideEffect(Consumer<Traverser<A>> consumer)`
    `static <A> CredentialTraversal<A,A>` | `sideEffect(Traversal<?,?> sideEffectTraversal)`
    `static <A> CredentialTraversal<A,A>` | `simplePath()`
    `static <A> CredentialTraversal<A,A>` | `skip(long skip)`
    `static <A> CredentialTraversal<A,A>` | `skip(Scope scope, long skip)`
    `static <A> CredentialTraversal<A,A>` | `start()`
    `static <A> CredentialTraversal<A,A>` | `store(String sideEffectKey)`
    `static <A> CredentialTraversal<A,Edge>` | `subgraph(String sideEffectKey)`
    `static <A> CredentialTraversal<A,Double>` | `sum()`
    `static <A> CredentialTraversal<A,Double>` | `sum(Scope scope)`
    `static <A> CredentialTraversal<A,A>` | `tail()`
    `static <A> CredentialTraversal<A,A>` | `tail(long limit)`
    `static <A> CredentialTraversal<A,A>` | `tail(Scope scope)`
    `static <A> CredentialTraversal<A,A>` | `tail(Scope scope, long limit)`
    `static <A> CredentialTraversal<A,A>` | `timeLimit(long timeLimit)`
    `static <A> CredentialTraversal<A,A>` | `times(int maxLoops)`
    `static CredentialTraversal<Vertex,Vertex>` | `to(Direction direction, String... edgeLabels)`
    `static CredentialTraversal<Vertex,Edge>` | `toE(Direction direction, String... edgeLabels)`
    `static CredentialTraversal<Edge,Vertex>` | `toV(Direction direction)`
    `static <A> CredentialTraversal<A,Tree>` | `tree()`
    `static <A> CredentialTraversal<A,A>` | `tree(String sideEffectKey)`
    `static <A> CredentialTraversal<A,A>` | `unfold()`
    `static <A,B> CredentialTraversal<A,B>` | `union(Traversal<?,B>... traversals)`
    `static <A> CredentialTraversal<A,A>` | `until(Predicate<Traverser<A>> untilPredicate)`
    `static <A> CredentialTraversal<A,A>` | `until(Traversal<?,?> untilTraversal)`
    `static <S> CredentialTraversal<S,Vertex>` | `user(String username, String password)`
    `static <S> CredentialTraversal<S,Vertex>` | `users()`
    `static <S> CredentialTraversal<S,Vertex>` | `users(String username, String... more)`
    `static <A> CredentialTraversal<A,Vertex>` | `V(Object... vertexIdsOrElements)`
    `static <A extends Property,B> CredentialTraversal<A,B>` | `value()`
    `static <A extends Element,B> CredentialTraversal<A,Map<Object,B>>` | `valueMap(boolean includeTokens, String... propertyKeys)`
    `static <A extends Element,B> CredentialTraversal<A,Map<Object,B>>` | `valueMap(String... propertyKeys)`
    `static <A extends Element,B> CredentialTraversal<A,B>` | `values(String... propertyKeys)`
    `static <A> CredentialTraversal<A,A>` | `where(P<String> predicate)`
    `static <A> CredentialTraversal<A,A>` | `where(String startKey, P<String> predicate)`
    `static <A> CredentialTraversal<A,A>` | `where(Traversal<?,?> whereTraversal)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### start

          public static <A> CredentialTraversal<A,A> start()

    - #### users

          public static <S> CredentialTraversal<S,Vertex> users()

    - #### users

          public static <S> CredentialTraversal<S,Vertex> users(String username,
                                                                String... more)

    - #### user

          public static <S> CredentialTraversal<S,Vertex> user(String username,
                                                               String password)

    - #### __

          public static <A> CredentialTraversal<A,A> __(A... starts)

    - #### map

          public static <A,B> CredentialTraversal<A,B> map(Function<Traverser<A>,B> function)

    - #### map

          public static <A,B> CredentialTraversal<A,B> map(Traversal<?,B> mapTraversal)

    - #### flatMap

          public static <A,B> CredentialTraversal<A,B> flatMap(Function<Traverser<A>,Iterator<B>> function)

    - #### flatMap

          public static <A,B> CredentialTraversal<A,B> flatMap(Traversal<?,B> flatMapTraversal)

    - #### identity

          public static <A> CredentialTraversal<A,A> identity()

    - #### constant

          public static <A> CredentialTraversal<A,A> constant(A a)

    - #### label

          public static <A extends Element> CredentialTraversal<A,String> label()

    - #### id

          public static <A extends Element> CredentialTraversal<A,Object> id()

    - #### V

          public static <A> CredentialTraversal<A,Vertex> V(Object... vertexIdsOrElements)

    - #### to

          public static CredentialTraversal<Vertex,Vertex> to(Direction direction,
                                                              String... edgeLabels)

    - #### out

          public static CredentialTraversal<Vertex,Vertex> out(String... edgeLabels)

    - #### in

          public static CredentialTraversal<Vertex,Vertex> in(String... edgeLabels)

    - #### both

          public static CredentialTraversal<Vertex,Vertex> both(String... edgeLabels)

    - #### toE

          public static CredentialTraversal<Vertex,Edge> toE(Direction direction,
                                                             String... edgeLabels)

    - #### outE

          public static CredentialTraversal<Vertex,Edge> outE(String... edgeLabels)

    - #### inE

          public static CredentialTraversal<Vertex,Edge> inE(String... edgeLabels)

    - #### bothE

          public static CredentialTraversal<Vertex,Edge> bothE(String... edgeLabels)

    - #### toV

          public static CredentialTraversal<Edge,Vertex> toV(Direction direction)

    - #### inV

          public static CredentialTraversal<Edge,Vertex> inV()

    - #### outV

          public static CredentialTraversal<Edge,Vertex> outV()

    - #### bothV

          public static CredentialTraversal<Edge,Vertex> bothV()

    - #### otherV

          public static CredentialTraversal<Edge,Vertex> otherV()

    - #### order

          public static <A> CredentialTraversal<A,A> order()

    - #### order

          public static <A> CredentialTraversal<A,A> order(Scope scope)

    - #### properties

          public static <A extends Element,B> CredentialTraversal<A,? extends Property<B>> properties(String... propertyKeys)

    - #### values

          public static <A extends Element,B> CredentialTraversal<A,B> values(String... propertyKeys)

    - #### propertyMap

          public static <A extends Element,B> CredentialTraversal<A,Map<String,B>> propertyMap(String... propertyKeys)

    - #### elementMap

          public static <A extends Element,B> CredentialTraversal<A,Map<Object,B>> elementMap(String... propertyKeys)

    - #### valueMap

          public static <A extends Element,B> CredentialTraversal<A,Map<Object,B>> valueMap(String... propertyKeys)

    - #### valueMap

          public static <A extends Element,B> CredentialTraversal<A,Map<Object,B>> valueMap(boolean includeTokens,
                                                                                            String... propertyKeys)

    - #### project

          public static <A,B> CredentialTraversal<A,Map<String,B>> project(String projectKey,
                                                                           String... projectKeys)

    - #### select

          public static <A,B> CredentialTraversal<A,Collection<B>> select(Column column)

    - #### key

          public static <A extends Property> CredentialTraversal<A,String> key()

    - #### value

          public static <A extends Property,B> CredentialTraversal<A,B> value()

    - #### path

          public static <A> CredentialTraversal<A,Path> path()

    - #### match

          public static <A,B> CredentialTraversal<A,Map<String,B>> match(Traversal<?,?>... matchTraversals)

    - #### sack

          public static <A,B> CredentialTraversal<A,B> sack()

    - #### loops

          public static <A> CredentialTraversal<A,Integer> loops()

    - #### loops

          public static <A> CredentialTraversal<A,Integer> loops(String loopName)

    - #### select

          public static <A,B> CredentialTraversal<A,B> select(Pop pop,
                                                              String selectKey)

    - #### select

          public static <A,B> CredentialTraversal<A,B> select(String selectKey)

    - #### select

          public static <A,B> CredentialTraversal<A,Map<String,B>> select(Pop pop,
                                                                          String selectKey1,
                                                                          String selectKey2,
                                                                          String... otherSelectKeys)

    - #### select

          public static <A,B> CredentialTraversal<A,Map<String,B>> select(String selectKey1,
                                                                          String selectKey2,
                                                                          String... otherSelectKeys)

    - #### select

          public static <A,B> CredentialTraversal<A,B> select(Pop pop,
                                                              Traversal<A,B> keyTraversal)

    - #### select

          public static <A,B> CredentialTraversal<A,B> select(Traversal<A,B> keyTraversal)

    - #### unfold

          public static <A> CredentialTraversal<A,A> unfold()

    - #### fold

          public static <A> CredentialTraversal<A,List<A>> fold()

    - #### fold

          public static <A,B> CredentialTraversal<A,B> fold(B seed,
                                                            BiFunction<B,A,B> foldFunction)

    - #### count

          public static <A> CredentialTraversal<A,Long> count()

    - #### count

          public static <A> CredentialTraversal<A,Long> count(Scope scope)

    - #### sum

          public static <A> CredentialTraversal<A,Double> sum()

    - #### sum

          public static <A> CredentialTraversal<A,Double> sum(Scope scope)

    - #### min

          public static <A,B extends Comparable> CredentialTraversal<A,B> min()

    - #### min

          public static <A,B extends Comparable> CredentialTraversal<A,B> min(Scope scope)

    - #### max

          public static <A,B extends Comparable> CredentialTraversal<A,B> max()

    - #### max

          public static <A,B extends Comparable> CredentialTraversal<A,B> max(Scope scope)

    - #### mean

          public static <A> CredentialTraversal<A,Double> mean()

    - #### mean

          public static <A> CredentialTraversal<A,Double> mean(Scope scope)

    - #### group

          public static <A,K,V> CredentialTraversal<A,Map<K,V>> group()

    - #### groupCount

          public static <A,K> CredentialTraversal<A,Map<K,Long>> groupCount()

    - #### tree

          public static <A> CredentialTraversal<A,Tree> tree()

    - #### addV

          public static <A> CredentialTraversal<A,Vertex> addV(String vertexLabel)

    - #### addV

          public static <A> CredentialTraversal<A,Vertex> addV(Traversal<?,String> vertexLabelTraversal)

    - #### addV

          public static <A> CredentialTraversal<A,Vertex> addV()

    - #### addE

          public static <A> CredentialTraversal<A,Edge> addE(String edgeLabel)

    - #### addE

          public static <A> CredentialTraversal<A,Edge> addE(Traversal<?,String> edgeLabelTraversal)

    - #### math

          public static <A> CredentialTraversal<A,Double> math(String expression)

    - #### filter

          public static <A> CredentialTraversal<A,A> filter(Predicate<Traverser<A>> predicate)

    - #### filter

          public static <A> CredentialTraversal<A,A> filter(Traversal<?,?> filterTraversal)

    - #### and

          public static <A> CredentialTraversal<A,A> and(Traversal<?,?>... andTraversals)

    - #### or

          public static <A> CredentialTraversal<A,A> or(Traversal<?,?>... orTraversals)

    - #### inject

          public static <A> CredentialTraversal<A,A> inject(A... injections)

    - #### dedup

          public static <A> CredentialTraversal<A,A> dedup(String... dedupLabels)

    - #### dedup

          public static <A> CredentialTraversal<A,A> dedup(Scope scope,
                                                           String... dedupLabels)

    - #### has

          public static <A> CredentialTraversal<A,A> has(String propertyKey,
                                                         P<?> predicate)

    - #### has

          public static <A> CredentialTraversal<A,A> has(T accessor,
                                                         P<?> predicate)

    - #### has

          public static <A> CredentialTraversal<A,A> has(String propertyKey,
                                                         Object value)

    - #### has

          public static <A> CredentialTraversal<A,A> has(T accessor,
                                                         Object value)

    - #### has

          public static <A> CredentialTraversal<A,A> has(String label,
                                                         String propertyKey,
                                                         Object value)

    - #### has

          public static <A> CredentialTraversal<A,A> has(String label,
                                                         String propertyKey,
                                                         P<?> predicate)

    - #### has

          public static <A> CredentialTraversal<A,A> has(T accessor,
                                                         Traversal<?,?> propertyTraversal)

    - #### has

          public static <A> CredentialTraversal<A,A> has(String propertyKey,
                                                         Traversal<?,?> propertyTraversal)

    - #### has

          public static <A> CredentialTraversal<A,A> has(String propertyKey)

    - #### hasNot

          public static <A> CredentialTraversal<A,A> hasNot(String propertyKey)

    - #### hasLabel

          public static <A> CredentialTraversal<A,A> hasLabel(String label,
                                                              String... otherLabels)

    - #### hasLabel

          public static <A> CredentialTraversal<A,A> hasLabel(P<String> predicate)

    - #### hasId

          public static <A> CredentialTraversal<A,A> hasId(Object id,
                                                           Object... otherIds)

    - #### hasId

          public static <A> CredentialTraversal<A,A> hasId(P<Object> predicate)

    - #### hasKey

          public static <A> CredentialTraversal<A,A> hasKey(String label,
                                                            String... otherLabels)

    - #### hasKey

          public static <A> CredentialTraversal<A,A> hasKey(P<String> predicate)

    - #### hasValue

          public static <A> CredentialTraversal<A,A> hasValue(Object value,
                                                              Object... values)

    - #### hasValue

          public static <A> CredentialTraversal<A,A> hasValue(P<Object> predicate)

    - #### where

          public static <A> CredentialTraversal<A,A> where(String startKey,
                                                           P<String> predicate)

    - #### where

          public static <A> CredentialTraversal<A,A> where(P<String> predicate)

    - #### where

          public static <A> CredentialTraversal<A,A> where(Traversal<?,?> whereTraversal)

    - #### is

          public static <A> CredentialTraversal<A,A> is(P<A> predicate)

    - #### is

          public static <A> CredentialTraversal<A,A> is(Object value)

    - #### not

          public static <A> CredentialTraversal<A,A> not(Traversal<?,?> notTraversal)

    - #### coin

          public static <A> CredentialTraversal<A,A> coin(double probability)

    - #### range

          public static <A> CredentialTraversal<A,A> range(long low,
                                                           long arg1)

    - #### range

          public static <A> CredentialTraversal<A,A> range(Scope scope,
                                                           long low,
                                                           long arg2)

    - #### limit

          public static <A> CredentialTraversal<A,A> limit(long limit)

    - #### limit

          public static <A> CredentialTraversal<A,A> limit(Scope scope,
                                                           long limit)

    - #### skip

          public static <A> CredentialTraversal<A,A> skip(long skip)

    - #### skip

          public static <A> CredentialTraversal<A,A> skip(Scope scope,
                                                          long skip)

    - #### tail

          public static <A> CredentialTraversal<A,A> tail()

    - #### tail

          public static <A> CredentialTraversal<A,A> tail(long limit)

    - #### tail

          public static <A> CredentialTraversal<A,A> tail(Scope scope)

    - #### tail

          public static <A> CredentialTraversal<A,A> tail(Scope scope,
                                                          long limit)

    - #### simplePath

          public static <A> CredentialTraversal<A,A> simplePath()

    - #### cyclicPath

          public static <A> CredentialTraversal<A,A> cyclicPath()

    - #### sample

          public static <A> CredentialTraversal<A,A> sample(int amountToSample)

    - #### sample

          public static <A> CredentialTraversal<A,A> sample(Scope scope,
                                                            int amountToSample)

    - #### drop

          public static <A> CredentialTraversal<A,A> drop()

    - #### sideEffect

          public static <A> CredentialTraversal<A,A> sideEffect(Consumer<Traverser<A>> consumer)

    - #### sideEffect

          public static <A> CredentialTraversal<A,A> sideEffect(Traversal<?,?> sideEffectTraversal)

    - #### cap

          public static <A,B> CredentialTraversal<A,B> cap(String sideEffectKey,
                                                           String... sideEffectKeys)

    - #### subgraph

          public static <A> CredentialTraversal<A,Edge> subgraph(String sideEffectKey)

    - #### aggregate

          public static <A> CredentialTraversal<A,A> aggregate(String sideEffectKey)

    - #### aggregate

          public static <A> CredentialTraversal<A,A> aggregate(Scope scope,
                                                               String sideEffectKey)

    - #### group

          public static <A> CredentialTraversal<A,A> group(String sideEffectKey)

    - #### groupCount

          public static <A> CredentialTraversal<A,A> groupCount(String sideEffectKey)

    - #### timeLimit

          public static <A> CredentialTraversal<A,A> timeLimit(long timeLimit)

    - #### tree

          public static <A> CredentialTraversal<A,A> tree(String sideEffectKey)

    - #### sack

          public static <A,V,U> CredentialTraversal<A,A> sack(BiFunction<V,U,V> sackOperator)

    - #### store

          public static <A> CredentialTraversal<A,A> store(String sideEffectKey)

    - #### property

          public static <A> CredentialTraversal<A,A> property(Object key,
                                                              Object value,
                                                              Object... keyValues)

    - #### property

          public static <A> CredentialTraversal<A,A> property(VertexProperty.Cardinality cardinality,
                                                              Object key,
                                                              Object value,
                                                              Object... keyValues)

    - #### branch

          public static <A,M,B> CredentialTraversal<A,B> branch(Function<Traverser<A>,M> function)

    - #### branch

          public static <A,M,B> CredentialTraversal<A,B> branch(Traversal<?,M> traversalFunction)

    - #### choose

          public static <A,B> CredentialTraversal<A,B> choose(Predicate<A> choosePredicate,
                                                              Traversal<?,B> trueChoice,
                                                              Traversal<?,B> falseChoice)

    - #### choose

          public static <A,B> CredentialTraversal<A,B> choose(Predicate<A> choosePredicate,
                                                              Traversal<?,B> trueChoice)

    - #### choose

          public static <A,M,B> CredentialTraversal<A,B> choose(Function<A,M> choiceFunction)

    - #### choose

          public static <A,M,B> CredentialTraversal<A,B> choose(Traversal<?,M> traversalFunction)

    - #### choose

          public static <A,M,B> CredentialTraversal<A,B> choose(Traversal<?,M> traversalPredicate,
                                                                Traversal<?,B> trueChoice,
                                                                Traversal<?,B> falseChoice)

    - #### choose

          public static <A,M,B> CredentialTraversal<A,B> choose(Traversal<?,M> traversalPredicate,
                                                                Traversal<?,B> trueChoice)

    - #### optional

          public static <A> CredentialTraversal<A,A> optional(Traversal<?,A> optionalTraversal)

    - #### union

          public static <A,B> CredentialTraversal<A,B> union(Traversal<?,B>... traversals)

    - #### coalesce

          public static <A,B> CredentialTraversal<A,B> coalesce(Traversal<?,B>... traversals)

    - #### repeat

          public static <A> CredentialTraversal<A,A> repeat(Traversal<?,A> traversal)

    - #### repeat

          public static <A> CredentialTraversal<A,A> repeat(String loopName,
                                                            Traversal<?,A> traversal)

    - #### emit

          public static <A> CredentialTraversal<A,A> emit(Traversal<?,?> emitTraversal)

    - #### emit

          public static <A> CredentialTraversal<A,A> emit(Predicate<Traverser<A>> emitPredicate)

    - #### until

          public static <A> CredentialTraversal<A,A> until(Traversal<?,?> untilTraversal)

    - #### until

          public static <A> CredentialTraversal<A,A> until(Predicate<Traverser<A>> untilPredicate)

    - #### times

          public static <A> CredentialTraversal<A,A> times(int maxLoops)

    - #### emit

          public static <A> CredentialTraversal<A,A> emit()

    - #### local

          public static <A,B> CredentialTraversal<A,B> local(Traversal<?,B> localTraversal)

    - #### as

          public static <A> CredentialTraversal<A,A> as(String label,
                                                        String... labels)

    - #### barrier

          public static <A> CredentialTraversal<A,A> barrier()

    - #### barrier

          public static <A> CredentialTraversal<A,A> barrier(int maxBarrierSize)

    - #### barrier

          public static <A> CredentialTraversal<A,A> barrier(Consumer<TraverserSet<Object>> barrierConsumer)

    - #### index

          public static <A,B> CredentialTraversal<A,B> index()

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