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

```
public final class __
extends Object
```

Method Summary

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

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

start

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

users

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

users

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

user

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

__

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

map

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

map

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

flatMap

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

flatMap

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

identity

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

constant

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

label

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

id

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

V

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

E

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

to

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

out

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

in

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

both

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

toE

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

outE

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

inE

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

bothE

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

toV

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

inV

public static CredentialTraversal<Edge,Vertex> inV()

outV

public static CredentialTraversal<Edge,Vertex> outV()

bothV

public static CredentialTraversal<Edge,Vertex> bothV()

otherV

public static CredentialTraversal<Edge,Vertex> otherV()

order

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

order

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

properties

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

values

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

propertyMap

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

elementMap

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

valueMap

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

valueMap

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

project

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

select

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

key

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

value

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

path

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

match

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

sack

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

loops

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

loops

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

select

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

select

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

select

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

select

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

select

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

select

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

unfold

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

fold

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

fold

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

count

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

count

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

sum

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

sum

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

min

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

min

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

max

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

max

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

mean

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

mean

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

group

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

groupCount

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

tree

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

addV

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

addV

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

addV

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

mergeV

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

mergeV

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

mergeV

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

addE

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

addE

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

mergeE

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

mergeE

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

mergeE

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

math

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

concat

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

concat

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

asString

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

length

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

toLower

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

toUpper

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

trim

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

lTrim

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

rTrim

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

reverse

public static <A> CredentialTraversal<A,?> reverse()

replace

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

split

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

substring

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

substring

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

asDate

public static <A> CredentialTraversal<A,Date> asDate()

dateAdd

public static <A> CredentialTraversal<A,Date> dateAdd(DT dateToken,
                                                            int value)

dateDiff

public static <A> CredentialTraversal<A,Long> dateDiff(Date value)

dateDiff

public static <A> CredentialTraversal<A,Long> dateDiff(Traversal<?,Date> dateTraversal)

difference

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

disjunct

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

intersect

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

conjoin

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

merge

public static <A> CredentialTraversal<A,?> merge(Object values)

combine

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

product

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

filter

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

filter

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

and

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

or

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

inject

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

dedup

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

dedup

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

has

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

has

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

has

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

has

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

has

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

has

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

has

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

has

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

has

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

hasNot

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

hasLabel

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

hasLabel

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

hasId

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

hasId

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

hasKey

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

hasKey

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

hasValue

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

hasValue

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

where

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

where

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

where

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

is

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

is

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

not

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

coin

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

range

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

range

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

limit

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

limit

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

skip

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

skip

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

tail

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

tail

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

tail

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

tail

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

simplePath

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

cyclicPath

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

sample

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

sample

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

drop

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

all

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

any

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

sideEffect

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

sideEffect

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

cap

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

subgraph

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

aggregate

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

aggregate

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

fail

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

fail

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

group

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

groupCount

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

timeLimit

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

tree

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

sack

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

store

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

property

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

property

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

property

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

branch

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

branch

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

choose

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

choose

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

choose

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

choose

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

choose

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

choose

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

optional

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

union

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

coalesce

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

repeat

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

repeat

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

emit

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

emit

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

until

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

until

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

times

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

emit

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

local

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

as

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

barrier

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

barrier

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

barrier

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

index

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

element

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

call

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

call

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

call

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

call

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

Class __

Method Summary

Methods inherited from class java.lang.Object

Method Detail

start

users

users

user

__

map

map

flatMap

flatMap

identity

constant

label

id

V

E

to

out

in

both

toE

outE

inE

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

max

max

mean

mean

group

groupCount

tree

addV

addV

addV

mergeV

mergeV

mergeV

addE

addE

mergeE