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 Description

protected __()

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`static <A> GraphTraversal<A,A>`	`__(A... starts)`
`static <A> GraphTraversal<A,Edge>`	`addE(String edgeLabel)`
`static <A> GraphTraversal<A,Edge>`	`addE(GValue<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(GValue<String> vertexLabel)`
`static <A> GraphTraversal<A,Vertex>`	`addV(Traversal<?,String> vertexLabelTraversal)`
`static <A> GraphTraversal<A,A>`	`aggregate(String sideEffectKey)`
`static <A> GraphTraversal<A,A>`	`aggregate(Scope scope, String sideEffectKey)`
`static <A> GraphTraversal<A,A>`	`all(P<A> predicate)`
`static <A> GraphTraversal<A,A>`	`and(Traversal<?,?>... andTraversals)`
`static <A> GraphTraversal<A,A>`	`any(P<A> predicate)`
`static <A> GraphTraversal<A,A>`	`as(String label, String... labels)`
`static <A> GraphTraversal<A,Boolean>`	`asBool()`
`static <A> GraphTraversal<A,OffsetDateTime>`	`asDate()`
`static <A> GraphTraversal<A,Number>`	`asNumber()`
`static <A> GraphTraversal<A,Number>`	`asNumber(GType typeToken)`
`static <A> GraphTraversal<A,String>`	`asString()`
`static <A,B> GraphTraversal<A,B>`	`asString(Scope scope)`
`static <A> GraphTraversal<A,A>`	`barrier()`
`static <A> GraphTraversal<A,A>`	`barrier(int maxBarrierSize)`
`static <A> GraphTraversal<A,A>`	`barrier(Consumer<TraverserSet<Object>> barrierConsumer)`
`static GraphTraversal<Vertex,Vertex>`	`both()`
`static GraphTraversal<Vertex,Vertex>`	`both(String... edgeLabels)`
`static GraphTraversal<Vertex,Vertex>`	`both(GValue<String>... edgeLabels)`
`static GraphTraversal<Vertex,Edge>`	`bothE()`
`static GraphTraversal<Vertex,Edge>`	`bothE(String... edgeLabels)`
`static GraphTraversal<Vertex,Edge>`	`bothE(GValue<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>`	`call(String service)`
`static <A,B> GraphTraversal<A,B>`	`call(String service, Map params)`
`static <A,B> GraphTraversal<A,B>`	`call(String service, Map params, Traversal<?,Map<?,?>> childTraversal)`
`static <A,B> GraphTraversal<A,B>`	`call(String service, GValue<Map<?,?>> params)`
`static <A,B> GraphTraversal<A,B>`	`call(String service, GValue<Map<?,?>> params, Traversal<A,Map<?,?>> childTraversal)`
`static <A,B> GraphTraversal<A,B>`	`call(String service, Traversal<?,Map<?,?>> childTraversal)`
`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,B> GraphTraversal<A,B>`	`choose(P<A> choosePredicate, Traversal<?,B> trueChoice)`
`static <A,B> GraphTraversal<A,B>`	`choose(P<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>`	`choose(T t)`
`static <A,B> GraphTraversal<A,B>`	`coalesce(Traversal<?,B>... traversals)`
`static <A> GraphTraversal<A,A>`	`coin(double probability)`
`static <A> GraphTraversal<A,List<?>>`	`combine(Object values)`
`static <A> GraphTraversal<A,String>`	`concat(String... concatString)`
`static <A> GraphTraversal<A,String>`	`concat(Traversal<A,String> concatTraversal, Traversal<A,String>... otherConcatTraversals)`
`static <A> GraphTraversal<A,String>`	`conjoin(String values)`
`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,OffsetDateTime>`	`dateAdd(DT dateToken, int value)`
`static <A> GraphTraversal<A,Long>`	`dateDiff(OffsetDateTime value)`
`static <A> GraphTraversal<A,Long>`	`dateDiff(Date value)`	Deprecated. As of release 3.8.0, deprecated in favor of `GraphTraversal.dateDiff(OffsetDateTime)`.
`static <A> GraphTraversal<A,Long>`	`dateDiff(Traversal<?,OffsetDateTime> dateTraversal)`
`static <A> GraphTraversal<A,A>`	`dedup(String... dedupLabels)`
`static <A> GraphTraversal<A,A>`	`dedup(Scope scope, String... dedupLabels)`
`static <A> GraphTraversal<A,Set<?>>`	`difference(Object values)`
`static <A> GraphTraversal<A,A>`	`discard()`
`static <A> GraphTraversal<A,Set<?>>`	`disjunct(Object values)`
`static <A> GraphTraversal<A,A>`	`drop()`
`static <A> GraphTraversal<A,Edge>`	`E(Object... edgeIdsOrElements)`
`static <A,B> GraphTraversal<A,Element>`	`element()`
`static <A extends Element,B> GraphTraversal<A,Map<Object,B>>`	`elementMap(String... propertyKeys)`
`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>`	`fail()`
`static <A> GraphTraversal<A,A>`	`fail(String message)`
`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> GraphTraversal<A,String>`	`format(String format)`
`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 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, P<?> predicate)`
`static <A> GraphTraversal<A,A>`	`has(GValue<String> label, String propertyKey, Object value)`
`static <A> GraphTraversal<A,A>`	`has(GValue<String> label, String propertyKey, P<?> predicate)`
`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>`	`hasId(Object id, Object... otherIds)`
`static <A> GraphTraversal<A,A>`	`hasId(P<?> predicate)`
`static <A> GraphTraversal<A,A>`	`hasKey(String label, String... otherLabels)`
`static <A> GraphTraversal<A,A>`	`hasKey(P<String> predicate)`
`static <A> GraphTraversal<A,A>`	`hasLabel(String label, String... otherLabels)`
`static <A> GraphTraversal<A,A>`	`hasLabel(P<String> predicate)`
`static <A> GraphTraversal<A,A>`	`hasLabel(GValue<String> label, GValue<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<?> predicate)`
`static <A extends Element> GraphTraversal<A,Object>`	`id()`
`static <A> GraphTraversal<A,A>`	`identity()`
`static GraphTraversal<Vertex,Vertex>`	`in()`
`static GraphTraversal<Vertex,Vertex>`	`in(String... edgeLabels)`
`static GraphTraversal<Vertex,Vertex>`	`in(GValue<String>... edgeLabels)`
`static <A,B> GraphTraversal<A,B>`	`index()`
`static GraphTraversal<Vertex,Edge>`	`inE()`
`static GraphTraversal<Vertex,Edge>`	`inE(String... edgeLabels)`
`static GraphTraversal<Vertex,Edge>`	`inE(GValue<String>... edgeLabels)`
`static <A> GraphTraversal<A,A>`	`inject(A... injections)`
`static <A> GraphTraversal<A,Set<?>>`	`intersect(Object values)`
`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,Integer>`	`length()`
`static <A,B> GraphTraversal<A,B>`	`length(Scope scope)`
`static <A> GraphTraversal<A,A>`	`limit(long limit)`
`static <A> GraphTraversal<A,A>`	`limit(Scope scope, long limit)`
`static <A> GraphTraversal<A,A>`	`limit(Scope scope, GValue<Long> limit)`
`static <A> GraphTraversal<A,A>`	`limit(GValue<Long> limit)`
`static <A,B> GraphTraversal<A,B>`	`local(Traversal<?,B> localTraversal)`
`static <A> GraphTraversal<A,Integer>`	`loops()`
`static <A> GraphTraversal<A,Integer>`	`loops(String loopName)`
`static <A> GraphTraversal<A,String>`	`lTrim()`
`static <A,B> GraphTraversal<A,B>`	`lTrim(Scope scope)`
`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 Comparable> GraphTraversal<A,B>`	`max()`
`static <A,B extends Comparable> GraphTraversal<A,B>`	`max(Scope scope)`
`static <A> GraphTraversal<A,Double>`	`mean()`
`static <A> GraphTraversal<A,Double>`	`mean(Scope scope)`
`static <A,B> GraphTraversal<A,B>`	`merge(Object values)`
`static <A> GraphTraversal<A,Edge>`	`mergeE()`
`static <A> GraphTraversal<A,Edge>`	`mergeE(Map<Object,Object> searchCreate)`
`static <A> GraphTraversal<A,Edge>`	`mergeE(GValue<Map<Object,Object>> searchCreate)`
`static <A> GraphTraversal<A,Edge>`	`mergeE(Traversal<?,Map<Object,Object>> searchCreate)`
`static <A> GraphTraversal<A,Vertex>`	`mergeV()`
`static <A> GraphTraversal<A,Vertex>`	`mergeV(Map<Object,Object> searchCreate)`
`static <A> GraphTraversal<A,Vertex>`	`mergeV(GValue<Map<Object,Object>> searchCreate)`
`static <A> GraphTraversal<A,Vertex>`	`mergeV(Traversal<?,Map<Object,Object>> searchCreate)`
`static <A,B extends Comparable> GraphTraversal<A,B>`	`min()`
`static <A,B extends Comparable> GraphTraversal<A,B>`	`min(Scope scope)`
`static <A> GraphTraversal<A,A>`	`none(P<A> predicate)`
`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()`
`static GraphTraversal<Vertex,Vertex>`	`out(String... edgeLabels)`
`static GraphTraversal<Vertex,Vertex>`	`out(GValue<String>... edgeLabels)`
`static GraphTraversal<Vertex,Edge>`	`outE()`
`static GraphTraversal<Vertex,Edge>`	`outE(String... edgeLabels)`
`static GraphTraversal<Vertex,Edge>`	`outE(GValue<String>... edgeLabels)`
`static GraphTraversal<Edge,Vertex>`	`outV()`
`static <A> GraphTraversal<A,Path>`	`path()`
`static <A> GraphTraversal<A,List<List<?>>>`	`product(Object values)`
`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(Map<Object,Object> value)`
`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>`	`range(Scope scope, GValue<Long> low, GValue<Long> high)`
`static <A> GraphTraversal<A,A>`	`range(GValue<Long> low, GValue<Long> high)`
`static <A> GraphTraversal<A,A>`	`repeat(String loopName, Traversal<?,A> traversal)`
`static <A> GraphTraversal<A,A>`	`repeat(Traversal<?,A> traversal)`
`static <A> GraphTraversal<A,String>`	`replace(String oldChar, String newChar)`
`static <A,B> GraphTraversal<A,B>`	`replace(Scope scope, String oldChar, String newChar)`
`static <A,B> GraphTraversal<A,B>`	`reverse()`
`static <A> GraphTraversal<A,String>`	`rTrim()`
`static <A,B> GraphTraversal<A,B>`	`rTrim(Scope scope)`
`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,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(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(Traversal<A,B> keyTraversal)`
`static <A,B> GraphTraversal<A,Collection<B>>`	`select(Column column)`
`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>`	`skip(Scope scope, GValue<Long> skip)`
`static <A> GraphTraversal<A,A>`	`skip(GValue<Long> skip)`
`static <A> GraphTraversal<A,List<String>>`	`split(String separator)`
`static <A,B> GraphTraversal<A,List<B>>`	`split(Scope scope, String separator)`
`static <A> GraphTraversal<A,A>`	`start()`
`static <A> GraphTraversal<A,A>`	`store(String sideEffectKey)`	Deprecated. As of release 3.4.3, replaced by `aggregate(Scope, String)` using `Scope.local`.
`static <A> GraphTraversal<A,Edge>`	`subgraph(String sideEffectKey)`
`static <A> GraphTraversal<A,String>`	`substring(int startIndex)`
`static <A> GraphTraversal<A,String>`	`substring(int startIndex, int endIndex)`
`static <A,B> GraphTraversal<A,B>`	`substring(Scope scope, int startIndex)`
`static <A,B> GraphTraversal<A,B>`	`substring(Scope scope, int startIndex, int endIndex)`
`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>`	`tail(Scope scope, GValue<Long> limit)`
`static <A> GraphTraversal<A,A>`	`tail(GValue<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)`
`static GraphTraversal<Vertex,Vertex>`	`to(Direction direction, String... edgeLabels)`
`static GraphTraversal<Vertex,Vertex>`	`to(Direction direction, GValue<String>... edgeLabels)`
`static GraphTraversal<Vertex,Edge>`	`toE(Direction direction)`
`static GraphTraversal<Vertex,Edge>`	`toE(Direction direction, String... edgeLabels)`
`static GraphTraversal<Vertex,Edge>`	`toE(Direction direction, GValue<String>... edgeLabels)`
`static <A> GraphTraversal<A,String>`	`toLower()`
`static <A,B> GraphTraversal<A,B>`	`toLower(Scope scope)`
`static <A> GraphTraversal<A,String>`	`toUpper()`
`static <A,B> GraphTraversal<A,B>`	`toUpper(Scope scope)`
`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,String>`	`trim()`
`static <A,B> GraphTraversal<A,B>`	`trim(Scope scope)`
`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)`	Deprecated. As of release 3.4.0, deprecated in favor of `valueMap(String...)` in conjunction with `GraphTraversal.with(String, Object)`.
`static <A extends Element,B> GraphTraversal<A,Map<Object,B>>`	`valueMap(String... propertyKeys)`
`static <A extends Element,B> GraphTraversal<A,B>`	`values(String... propertyKeys)`
`static <A> GraphTraversal<A,A>`	`where(String startKey, P<String> predicate)`
`static <A> GraphTraversal<A,A>`	`where(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...)

E

public static <A> GraphTraversal<A,Edge> E(Object... edgeIdsOrElements)

See Also:: GraphTraversal.E(Object...)

to

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

See Also:: GraphTraversal.to(Direction)

to

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

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

to

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

See Also:: GraphTraversal.to(Direction, GValue...)

out

public static GraphTraversal<Vertex,Vertex> out()

See Also:: GraphTraversal.out()

out

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

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

out

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

See Also:: GraphTraversal.out(GValue...)

in

public static GraphTraversal<Vertex,Vertex> in()

See Also:: GraphTraversal.in()

in

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

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

in

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

See Also:: GraphTraversal.in(GValue...)

both

public static GraphTraversal<Vertex,Vertex> both()

See Also:: GraphTraversal.both()

both

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

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

both

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

See Also:: GraphTraversal.both(GValue...)

toE

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

See Also:: GraphTraversal.toE(Direction)

toE

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

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

toE

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

See Also:: GraphTraversal.toE(Direction, GValue...)

outE

public static GraphTraversal<Vertex,Edge> outE()

See Also:: GraphTraversal.outE()

outE

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

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

outE

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

See Also:: GraphTraversal.outE(GValue...)

inE

public static GraphTraversal<Vertex,Edge> inE()

See Also:: GraphTraversal.inE()

inE

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

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

inE

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

See Also:: GraphTraversal.inE(GValue...)

bothE

public static GraphTraversal<Vertex,Edge> bothE()

See Also:: GraphTraversal.bothE()

bothE

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

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

bothE

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

See Also:: GraphTraversal.bothE(GValue...)

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...)

elementMap

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

See Also:: GraphTraversal.elementMap(String...)

valueMap

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

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

valueMap

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

Deprecated.

As of release 3.4.0, deprecated in favor of valueMap(String...) in conjunction with GraphTraversal.with(String, Object).

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()

loops

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

See Also:: GraphTraversal.loops(String)

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 Comparable> GraphTraversal<A,B> min()

See Also:: GraphTraversal.min()

min

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

See Also:: GraphTraversal.min(Scope)

max

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

See Also:: GraphTraversal.max()

max

public static <A,B extends Comparable> 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(GValue<String> vertexLabel)

See Also:: GraphTraversal.addV(GValue)

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()

mergeV

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

See Also:: GraphTraversal.mergeV()

mergeV

public static <A> GraphTraversal<A,Vertex> mergeV(Map<Object,Object> searchCreate)

See Also:: GraphTraversal.mergeV(Map)

mergeV

public static <A> GraphTraversal<A,Vertex> mergeV(GValue<Map<Object,Object>> searchCreate)

See Also:: GraphTraversal.mergeV(GValue)

mergeV

public static <A> GraphTraversal<A,Vertex> mergeV(Traversal<?,Map<Object,Object>> searchCreate)

See Also:: GraphTraversal.mergeV(Traversal)

addE

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

See Also:: GraphTraversal.addE(String)

addE

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

See Also:: GraphTraversal.addE(GValue)

addE

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

See Also:: GraphTraversal.addE(Traversal)

mergeE

public static <A> GraphTraversal<A,Edge> mergeE()

See Also:: GraphTraversal.mergeE()

mergeE

public static <A> GraphTraversal<A,Edge> mergeE(Map<Object,Object> searchCreate)

See Also:: GraphTraversal.mergeE(Map)

mergeE

public static <A> GraphTraversal<A,Edge> mergeE(GValue<Map<Object,Object>> searchCreate)

See Also:: GraphTraversal.mergeE(GValue)

mergeE

public static <A> GraphTraversal<A,Edge> mergeE(Traversal<?,Map<Object,Object>> searchCreate)

See Also:: GraphTraversal.mergeE(Traversal)

math

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

See Also:: GraphTraversal.math(String)

concat

public static <A> GraphTraversal<A,String> concat(Traversal<A,String> concatTraversal,
                                                        Traversal<A,String>... otherConcatTraversals)

See Also:: GraphTraversal.concat(Traversal, Traversal...)

concat

public static <A> GraphTraversal<A,String> concat(String... concatString)

See Also:: GraphTraversal.concat(String...)

asString

public static <A> GraphTraversal<A,String> asString()

See Also:: GraphTraversal.asString()

asString

public static <A,B> GraphTraversal<A,B> asString(Scope scope)

See Also:: GraphTraversal.asString()

length

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

See Also:: GraphTraversal.length()

length

public static <A,B> GraphTraversal<A,B> length(Scope scope)

See Also:: GraphTraversal.length()

toLower

public static <A> GraphTraversal<A,String> toLower()

See Also:: GraphTraversal.toLower()

toLower

public static <A,B> GraphTraversal<A,B> toLower(Scope scope)

See Also:: GraphTraversal.toLower()

toUpper

public static <A> GraphTraversal<A,String> toUpper()

See Also:: GraphTraversal.toUpper()

toUpper

public static <A,B> GraphTraversal<A,B> toUpper(Scope scope)

See Also:: GraphTraversal.toUpper(Scope)

trim

public static <A> GraphTraversal<A,String> trim()

See Also:: GraphTraversal.trim()

trim

public static <A,B> GraphTraversal<A,B> trim(Scope scope)

See Also:: GraphTraversal.trim(Scope)

lTrim

public static <A> GraphTraversal<A,String> lTrim()

See Also:: GraphTraversal.lTrim()

lTrim

public static <A,B> GraphTraversal<A,B> lTrim(Scope scope)

See Also:: GraphTraversal.lTrim(Scope)

rTrim

public static <A> GraphTraversal<A,String> rTrim()

See Also:: GraphTraversal.rTrim()

rTrim

public static <A,B> GraphTraversal<A,B> rTrim(Scope scope)

See Also:: GraphTraversal.rTrim(Scope)

reverse

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

See Also:: GraphTraversal.reverse()

replace

public static <A> GraphTraversal<A,String> replace(String oldChar,
                                                         String newChar)

See Also:: GraphTraversal.replace(String, String)

replace

public static <A,B> GraphTraversal<A,B> replace(Scope scope,
                                                            String oldChar,
                                                            String newChar)

See Also:: GraphTraversal.replace(Scope, String, String)

split

public static <A> GraphTraversal<A,List<String>> split(String separator)

See Also:: GraphTraversal.split(String)

split

public static <A,B> GraphTraversal<A,List<B>> split(Scope scope,
                                                                String separator)

See Also:: GraphTraversal.split(Scope, String)

substring

public static <A> GraphTraversal<A,String> substring(int startIndex)

See Also:: GraphTraversal.substring(int)

substring

public static <A,B> GraphTraversal<A,B> substring(Scope scope,
                                                              int startIndex)

See Also:: GraphTraversal.substring(Scope, int)

substring

public static <A> GraphTraversal<A,String> substring(int startIndex,
                                                           int endIndex)

See Also:: GraphTraversal.substring(int, int)

substring

public static <A,B> GraphTraversal<A,B> substring(Scope scope,
                                                              int startIndex,
                                                              int endIndex)

See Also:: GraphTraversal.substring(Scope, int, int)

format

public static <A> GraphTraversal<A,String> format(String format)

See Also:: GraphTraversal.format(String)

asBool

public static <A> GraphTraversal<A,Boolean> asBool()

See Also:: GraphTraversal.asBool()

asDate

public static <A> GraphTraversal<A,OffsetDateTime> asDate()

See Also:: GraphTraversal.asDate()

asNumber

public static <A> GraphTraversal<A,Number> asNumber()

See Also:: GraphTraversal.asNumber()

asNumber

public static <A> GraphTraversal<A,Number> asNumber(GType typeToken)

See Also:: GraphTraversal.asNumber(GType)

dateAdd

public static <A> GraphTraversal<A,OffsetDateTime> dateAdd(DT dateToken,
                                                                 int value)

See Also:: GraphTraversal.dateAdd(DT, int)

dateDiff
```
@Deprecated
public static <A> GraphTraversal<A,Long> dateDiff(Date value)
```
Deprecated.
As of release 3.8.0, deprecated in favor of GraphTraversal.dateDiff(OffsetDateTime).

See Also:

GraphTraversal.dateDiff(OffsetDateTime)

dateDiff

public static <A> GraphTraversal<A,Long> dateDiff(OffsetDateTime value)

See Also:: GraphTraversal.dateDiff(OffsetDateTime)

dateDiff

public static <A> GraphTraversal<A,Long> dateDiff(Traversal<?,OffsetDateTime> dateTraversal)

See Also:: GraphTraversal.dateDiff(Traversal)

difference

public static <A> GraphTraversal<A,Set<?>> difference(Object values)

See Also:: GraphTraversal.difference(Object)

disjunct

public static <A> GraphTraversal<A,Set<?>> disjunct(Object values)

See Also:: GraphTraversal.disjunct(Object)

intersect

public static <A> GraphTraversal<A,Set<?>> intersect(Object values)

See Also:: GraphTraversal.intersect(Object)

conjoin

public static <A> GraphTraversal<A,String> conjoin(String values)

See Also:: GraphTraversal.conjoin(String)

merge

public static <A,B> GraphTraversal<A,B> merge(Object values)

See Also:: GraphTraversal.merge(Object)

combine

public static <A> GraphTraversal<A,List<?>> combine(Object values)

See Also:: GraphTraversal.combine(Object)

product

public static <A> GraphTraversal<A,List<List<?>>> product(Object values)

See Also:: GraphTraversal.product(Object)

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(GValue<String> label,
                                                String propertyKey,
                                                P<?> predicate)

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

has

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

See Also:: GraphTraversal.has(GValue, 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(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(GValue<String> label,
                                                     GValue<String>... otherLabels)

See Also:: GraphTraversal.hasLabel(GValue, GValue...)

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<?> 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<?> 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)

discard

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

See Also:: GraphTraversal.discard()

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(GValue<Long> low,
                                                  GValue<Long> high)

See Also:: GraphTraversal.range(GValue, GValue)

range

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

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

range

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

See Also:: GraphTraversal.range(Scope, GValue, GValue)

limit

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

See Also:: GraphTraversal.limit(long)

limit

public static <A> GraphTraversal<A,A> limit(GValue<Long> limit)

See Also:: GraphTraversal.limit(GValue)

limit

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

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

limit

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

See Also:: GraphTraversal.limit(Scope, GValue)

skip

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

See Also:: GraphTraversal.skip(long)

skip

public static <A> GraphTraversal<A,A> skip(GValue<Long> skip)

See Also:: GraphTraversal.skip(GValue)

skip

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

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

skip

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

See Also:: GraphTraversal.skip(Scope, GValue)

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(GValue<Long> limit)

See Also:: GraphTraversal.tail(GValue)

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)

tail

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

See Also:: GraphTraversal.tail(Scope, GValue)

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()

all

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

See Also:: GraphTraversal.all(P)

any

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

See Also:: GraphTraversal.any(P)

none

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

See Also:: GraphTraversal.none(P)

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)

aggregate

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

See Also:: GraphTraversal.aggregate(Scope, String)

fail

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

See Also:: GraphTraversal.fail()

fail

public static <A> GraphTraversal<A,A> fail(String message)

See Also:: GraphTraversal.fail(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
```
@Deprecated
public static <A> GraphTraversal<A,A> store(String sideEffectKey)
```
Deprecated.
As of release 3.4.3, replaced by aggregate(Scope, String) using Scope.local.

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...)

property

public static <A> GraphTraversal<A,A> property(Map<Object,Object> value)

See Also:: GraphTraversal.property(Map)

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(P<A> choosePredicate,
                                                           Traversal<?,B> trueChoice,
                                                           Traversal<?,B> falseChoice)

See Also:: GraphTraversal.choose(P, 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,B> GraphTraversal<A,B> choose(P<A> choosePredicate,
                                                           Traversal<?,B> trueChoice)

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

choose

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

See Also:: GraphTraversal.choose(Function)

choose

public static <A,B> GraphTraversal<A,B> choose(T t)

See Also:: GraphTraversal.choose(T)

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)

repeat

public static <A> GraphTraversal<A,A> repeat(String loopName,
                                                   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)

index

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

See Also:: GraphTraversal.index()

element

public static <A,B> GraphTraversal<A,Element> element()

See Also:: GraphTraversal.element()

call

public static <A,B> GraphTraversal<A,B> call(String service)

See Also:: GraphTraversal.call(String)

call

public static <A,B> GraphTraversal<A,B> call(String service,
                                                         Map params)

See Also:: GraphTraversal.call(String, Map)

call

public static <A,B> GraphTraversal<A,B> call(String service,
                                                         GValue<Map<?,?>> params)

See Also:: GraphTraversal.call(String, GValue)

call

public static <A,B> GraphTraversal<A,B> call(String service,
                                                         Traversal<?,Map<?,?>> childTraversal)

See Also:: GraphTraversal.call(String, Traversal)

call

public static <A,B> GraphTraversal<A,B> call(String service,
                                                         Map params,
                                                         Traversal<?,Map<?,?>> childTraversal)

See Also:: GraphTraversal.call(String, Map, Traversal)

call

public static <A,B> GraphTraversal<A,B> call(String service,
                                                         GValue<Map<?,?>> params,
                                                         Traversal<A,Map<?,?>> childTraversal)

See Also:: GraphTraversal.call(String, GValue, Traversal)

Class __

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

__

Method Detail

start

__

map

map

flatMap

flatMap

identity

constant

label

id

V

E

to

to

to

out

out

out

in

in

in

both

both

both

toE

toE

toE

outE

outE

outE

inE

inE

inE

bothE

bothE

bothE

toV

inV

outV

bothV

otherV

order

order

properties

values

propertyMap

elementMap

valueMap

valueMap

project

select

key

value

path

match

sack

loops

loops

select

select

select

select

select

select

unfold

fold

fold

count

count

sum

sum

min

min