__ (Apache TinkerPop 3.3.3 API)

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

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)

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

to

out

in

both

toE

outE

inE

bothE

toV

inV

outV

bothV

otherV

order

order

properties

values

propertyMap

valueMap

valueMap

project

select

key

value

path

match

sack

loops

select

select

select

select

select

select

unfold

fold

fold

count

count

sum

sum

min

min

max

max

mean

mean

group

groupCount

tree

addV

addV

addV

addE

addE

math

filter

filter

and

or

inject

dedup