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

## Class __

- java.lang.Object
- - org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__

-     public class __
      extends Object

  An anonymous `GraphTraversal`.
  Author:
    Marko A. Rodriguez (http://markorodriguez.com)

- - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `__()`

  - ### Method Summary

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

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

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

- - ### Constructor Detail

    - #### __

          protected __()

  - ### Method Detail

    - #### start

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

    - #### __

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

    - #### map

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

      See Also:
        `GraphTraversal.map(Function)`

    - #### map

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

      See Also:
        `GraphTraversal.map(Traversal)`

    - #### flatMap

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

      See Also:
        `GraphTraversal.flatMap(Function)`

    - #### flatMap

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

      See Also:
        `GraphTraversal.flatMap(Traversal)`

    - #### identity

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

      See Also:
        `GraphTraversal.identity()`

    - #### constant

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

      See Also:
        `GraphTraversal.constant(Object)`

    - #### label

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

      See Also:
        `GraphTraversal.label()`

    - #### id

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

      See Also:
        `GraphTraversal.id()`

    - #### V

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

      See Also:
        `GraphTraversal.V(Object...)`

    - #### to

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

      See Also:
        `GraphTraversal.to(Direction, String...)`

    - #### out

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

      See Also:
        `GraphTraversal.out(String...)`

    - #### in

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

      See Also:
        `GraphTraversal.in(String...)`

    - #### both

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

      See Also:
        `GraphTraversal.both(String...)`

    - #### toE

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

      See Also:
        `GraphTraversal.toE(Direction, String...)`

    - #### outE

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

      See Also:
        `GraphTraversal.outE(String...)`

    - #### inE

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

      See Also:
        `GraphTraversal.inE(String...)`

    - #### bothE

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

      See Also:
        `GraphTraversal.bothE(String...)`

    - #### toV

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

      See Also:
        `GraphTraversal.toV(Direction)`

    - #### inV

          public static GraphTraversal<Edge,Vertex> inV()

      See Also:
        `GraphTraversal.inV()`

    - #### outV

          public static GraphTraversal<Edge,Vertex> outV()

      See Also:
        `GraphTraversal.outV()`

    - #### bothV

          public static GraphTraversal<Edge,Vertex> bothV()

      See Also:
        `GraphTraversal.bothV()`

    - #### otherV

          public static GraphTraversal<Edge,Vertex> otherV()

      See Also:
        `GraphTraversal.otherV()`

    - #### order

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

      See Also:
        `GraphTraversal.order()`

    - #### order

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

      See Also:
        `GraphTraversal.order(Scope)`

    - #### properties

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

      See Also:
        `GraphTraversal.properties(String...)`

    - #### values

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

      See Also:
        `GraphTraversal.values(String...)`

    - #### propertyMap

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

      See Also:
        `GraphTraversal.propertyMap(String...)`

    - #### valueMap

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

      See Also:
        `GraphTraversal.valueMap(String...)`

    - #### valueMap

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

      See Also:
        `GraphTraversal.valueMap(boolean, String...)`

    - #### project

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

      See Also:
        `GraphTraversal.project(String, String...)`

    - #### select

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

      See Also:
        `GraphTraversal.select(Column)`

    - #### key

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

      See Also:
        `GraphTraversal.key()`

    - #### value

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

      See Also:
        `GraphTraversal.value()`

    - #### path

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

      See Also:
        `GraphTraversal.path()`

    - #### match

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

      See Also:
        `GraphTraversal.match(Traversal[])`

    - #### sack

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

      See Also:
        `GraphTraversal.sack()`

    - #### loops

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

      See Also:
        `GraphTraversal.loops()`

    - #### select

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

      See Also:
        `GraphTraversal.select(Pop, String)`

    - #### select

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

      See Also:
        `GraphTraversal.select(String)`

    - #### select

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

      See Also:
        `GraphTraversal.select(Pop, String, String, String...)`

    - #### select

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

      See Also:
        `GraphTraversal.select(String, String, String...)`

    - #### select

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

      See Also:
        `GraphTraversal.select(Pop, Traversal)`

    - #### select

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

      See Also:
        `GraphTraversal.select(Traversal)`

    - #### unfold

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

      See Also:
        `GraphTraversal.unfold()`

    - #### fold

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

      See Also:
        `GraphTraversal.fold()`

    - #### fold

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

      See Also:
        `GraphTraversal.fold(Object, BiFunction)`

    - #### count

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

      See Also:
        `GraphTraversal.count()`

    - #### count

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

      See Also:
        `GraphTraversal.count(Scope)`

    - #### sum

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

      See Also:
        `GraphTraversal.sum()`

    - #### sum

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

      See Also:
        `GraphTraversal.sum(Scope)`

    - #### min

          public static <A,B extends Number> GraphTraversal<A,B> min()

      See Also:
        `GraphTraversal.min()`

    - #### min

          public static <A,B extends Number> GraphTraversal<A,B> min(Scope scope)

      See Also:
        `GraphTraversal.min(Scope)`

    - #### max

          public static <A,B extends Number> GraphTraversal<A,B> max()

      See Also:
        `GraphTraversal.max()`

    - #### max

          public static <A,B extends Number> GraphTraversal<A,B> max(Scope scope)

      See Also:
        `GraphTraversal.max(Scope)`

    - #### mean

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

      See Also:
        `GraphTraversal.mean()`

    - #### mean

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

      See Also:
        `GraphTraversal.mean(Scope)`

    - #### group

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

      See Also:
        `GraphTraversal.group()`

    - #### groupCount

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

      See Also:
        `GraphTraversal.groupCount()`

    - #### tree

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

      See Also:
        `GraphTraversal.tree()`

    - #### addV

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

      See Also:
        `GraphTraversal.addV(String)`

    - #### addV

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

      See Also:
        `GraphTraversal.addV(org.apache.tinkerpop.gremlin.process.traversal.Traversal)`

    - #### addV

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

      See Also:
        `GraphTraversal.addV()`

    - #### addE

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

      See Also:
        `GraphTraversal.addE(String)`

    - #### addE

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

      See Also:
        `GraphTraversal.addE(org.apache.tinkerpop.gremlin.process.traversal.Traversal)`

    - #### math

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

      See Also:
        `GraphTraversal.math(String)`

    - #### filter

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

      See Also:
        `GraphTraversal.filter(Predicate)`

    - #### filter

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

      See Also:
        `GraphTraversal.filter(Traversal)`

    - #### and

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

      See Also:
        `GraphTraversal.and(Traversal[])`

    - #### or

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

      See Also:
        `GraphTraversal.or(Traversal[])`

    - #### inject

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

      See Also:
        `GraphTraversal.inject(Object[])`

    - #### dedup

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

      See Also:
        `GraphTraversal.dedup(String...)`

    - #### dedup

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

      See Also:
        `GraphTraversal.dedup(Scope, String...)`

    - #### has

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

      See Also:
        `GraphTraversal.has(String, P)`

    - #### has

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

      See Also:
        `GraphTraversal.has(T, P)`

    - #### has

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

      See Also:
        `GraphTraversal.has(String, Object)`

    - #### has

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

      See Also:
        `GraphTraversal.has(T, Object)`

    - #### has

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

      See Also:
        `GraphTraversal.has(String, String, Object)`

    - #### has

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

      See Also:
        `GraphTraversal.has(String, String, P)`

    - #### has

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

      See Also:
        `GraphTraversal.has(T, Traversal)`

    - #### has

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

      See Also:
        `GraphTraversal.has(String, Traversal)`

    - #### has

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

      See Also:
        `GraphTraversal.has(String)`

    - #### hasNot

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

      See Also:
        `GraphTraversal.hasNot(String)`

    - #### hasLabel

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

      See Also:
        `GraphTraversal.hasLabel(String, String...)`

    - #### hasLabel

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

      See Also:
        `GraphTraversal.hasLabel(P)`

    - #### hasId

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

      See Also:
        `GraphTraversal.hasId(Object, Object...)`

    - #### hasId

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

      See Also:
        `GraphTraversal.hasId(P)`

    - #### hasKey

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

      See Also:
        `GraphTraversal.hasKey(String, String...)`

    - #### hasKey

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

      See Also:
        `GraphTraversal.hasKey(P)`

    - #### hasValue

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

      See Also:
        `GraphTraversal.hasValue(Object, Object...)`

    - #### hasValue

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

      See Also:
        `GraphTraversal.hasValue(P)`

    - #### where

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

      See Also:
        `GraphTraversal.where(String, P)`

    - #### where

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

      See Also:
        `GraphTraversal.where(P)`

    - #### where

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

      See Also:
        `GraphTraversal.where(Traversal)`

    - #### is

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

      See Also:
        `GraphTraversal.is(P)`

    - #### is

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

      See Also:
        `GraphTraversal.is(Object)`

    - #### not

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

      See Also:
        `GraphTraversal.not(Traversal)`

    - #### coin

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

      See Also:
        `GraphTraversal.coin(double)`

    - #### range

          public static <A> GraphTraversal<A,A> range(long low,
                                                      long high)

      See Also:
        `GraphTraversal.range(long, long)`

    - #### range

          public static <A> GraphTraversal<A,A> range(Scope scope,
                                                      long low,
                                                      long high)

      See Also:
        `GraphTraversal.range(Scope, long, long)`

    - #### limit

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

      See Also:
        `GraphTraversal.limit(long)`

    - #### limit

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

      See Also:
        `GraphTraversal.limit(Scope, long)`

    - #### skip

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

      See Also:
        `GraphTraversal.skip(long)`

    - #### skip

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

      See Also:
        `GraphTraversal.skip(Scope, long)`

    - #### tail

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

      See Also:
        `GraphTraversal.tail()`

    - #### tail

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

      See Also:
        `GraphTraversal.tail(long)`

    - #### tail

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

      See Also:
        `GraphTraversal.tail(Scope)`

    - #### tail

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

      See Also:
        `GraphTraversal.tail(Scope, long)`

    - #### simplePath

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

      See Also:
        `GraphTraversal.simplePath()`

    - #### cyclicPath

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

      See Also:
        `GraphTraversal.cyclicPath()`

    - #### sample

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

      See Also:
        `GraphTraversal.sample(int)`

    - #### sample

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

      See Also:
        `GraphTraversal.sample(Scope, int)`

    - #### drop

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

      See Also:
        `GraphTraversal.drop()`

    - #### sideEffect

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

      See Also:
        `GraphTraversal.sideEffect(Consumer)`

    - #### sideEffect

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

      See Also:
        `GraphTraversal.sideEffect(Traversal)`

    - #### cap

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

      See Also:
        `GraphTraversal.cap(String, String...)`

    - #### subgraph

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

      See Also:
        `GraphTraversal.subgraph(String)`

    - #### aggregate

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

      See Also:
        `GraphTraversal.aggregate(String)`

    - #### group

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

      See Also:
        `GraphTraversal.group(String)`

    - #### groupCount

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

      See Also:
        `GraphTraversal.groupCount(String)`

    - #### timeLimit

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

      See Also:
        `GraphTraversal.timeLimit(long)`

    - #### tree

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

      See Also:
        `GraphTraversal.tree(String)`

    - #### sack

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

      See Also:
        `GraphTraversal.sack(BiFunction)`

    - #### store

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

      See Also:
        `GraphTraversal.store(String)`

    - #### property

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

      See Also:
        `GraphTraversal.property(Object, Object, Object...)`

    - #### property

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

      See Also:
        `GraphTraversal.property(VertexProperty.Cardinality, Object, Object, Object...)`

    - #### branch

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

      See Also:
        `GraphTraversal.branch(Function)`

    - #### branch

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

      See Also:
        `GraphTraversal.branch(Traversal)`

    - #### choose

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

      See Also:
        `GraphTraversal.choose(Predicate, Traversal, Traversal)`

    - #### choose

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

      See Also:
        `GraphTraversal.choose(Predicate, Traversal)`

    - #### choose

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

      See Also:
        `GraphTraversal.choose(Function)`

    - #### choose

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

      See Also:
        `GraphTraversal.choose(Traversal)`

    - #### choose

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

      See Also:
        `GraphTraversal.choose(Traversal, Traversal, Traversal)`

    - #### choose

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

      See Also:
        `GraphTraversal.choose(Traversal, Traversal)`

    - #### optional

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

      See Also:
        `GraphTraversal.optional(Traversal)`

    - #### union

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

      See Also:
        `GraphTraversal.union(Traversal[])`

    - #### coalesce

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

      See Also:
        `GraphTraversal.coalesce(Traversal[])`

    - #### repeat

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

      See Also:
        `GraphTraversal.repeat(Traversal)`

    - #### emit

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

      See Also:
        `GraphTraversal.emit(Traversal)`

    - #### emit

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

      See Also:
        `GraphTraversal.emit(Predicate)`

    - #### until

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

      See Also:
        `GraphTraversal.until(Traversal)`

    - #### until

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

      See Also:
        `GraphTraversal.until(Predicate)`

    - #### times

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

      See Also:
        `GraphTraversal.times(int)`

    - #### emit

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

      See Also:
        `GraphTraversal.emit()`

    - #### local

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

      See Also:
        `GraphTraversal.local(Traversal)`

    - #### as

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

      See Also:
        `GraphTraversal.as(String, String...)`

    - #### barrier

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

      See Also:
        `GraphTraversal.barrier()`

    - #### barrier

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

      See Also:
        `GraphTraversal.barrier(int)`

    - #### barrier

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

      See Also:
        `GraphTraversal.barrier(Consumer)`

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