GremlinScala

Instance Constructors

new GremlinScala(traversal: GraphTraversal[_, End])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def V(vertexIdsOrElements: Any*)(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]
def addE(label: StepLabel[Vertex])(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]
def addE(label: String)(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]
def addV(label: String): GremlinScala[Vertex, Labels]
def addV(): GremlinScala[Vertex, Labels]
def aggregate(sideEffectKey: String): GremlinScala[End, Labels]
def and(traversals: (GremlinScala[End, HNil]) ⇒ GremlinScala[_, _]*): GremlinScala[End, Labels]
def as(stepLabel: StepLabel[End])(implicit p: Prepend[Labels, ::[End, HNil]]): GremlinScala[End, Out]
def as(name: String, moreNames: String*)(implicit p: Prepend[Labels, ::[End, HNil]]): GremlinScala[End, Out]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def barrier(consumer: Consumer[TraverserSet[AnyRef]]): GremlinScala[End, Labels]
def barrier(consumer: (TraverserSet[End]) ⇒ Unit): GremlinScala[End, Labels]
def barrier(maxBarrierSize: Int): GremlinScala[End, Labels]
def barrier(): GremlinScala[End, Labels]
def both(labels: String*)(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]
def both()(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]
def bothE(labels: String*)(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]
def bothE()(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]
def bothV()(implicit ev: <:<[End, Edge]): GremlinScala[Vertex, Labels]
def branch[BranchOn, NewEnd](on: (GremlinScala[End, _]) ⇒ GremlinScala[BranchOn, _], options: BranchOption[End, NewEnd]*): GremlinScala[NewEnd, Labels]

note that the traverser will go down all traversals in options if the pickToken matches if you need if/then/else semantic, use choose instead
def cap[A](stepLabel: StepLabel[A]): GremlinScala[A, Labels]
def cap(sideEffectKey: String, sideEffectKeys: String*): GremlinScala[End, Labels]
def choose[BranchOn, NewEnd](on: (GremlinScala[End, _]) ⇒ GremlinScala[BranchOn, _], options: BranchOption[End, NewEnd]*): GremlinScala[NewEnd, Labels]

traverser will pick first option that has a matching pickToken
def choose[NewEnd](predicate: (GremlinScala[End, _]) ⇒ GremlinScala[_, _], onTrue: (GremlinScala[End, HNil]) ⇒ GremlinScala[NewEnd, _], onFalse: (GremlinScala[End, HNil]) ⇒ GremlinScala[NewEnd, _]): GremlinScala[NewEnd, Labels]

special case of choose step if there's only two options - basically an if/else condition for traversals
special case of choose step if there's only two options - basically an if/else condition for traversals
you might think that predicate should be GremlinScala[End, _] => GremlinScala[Boolean, _], but that's not how tp3 works: e.g. .value(Age).is(30) returns 30, not true
def clone(): GremlinScala[End, Labels]

Definition Classes
GremlinScala → AnyRef
def coalesce[A](coalesceTraversals: (GremlinScala[End, HNil]) ⇒ GremlinScala[A, _]*): GremlinScala[A, Labels]
def coin(probability: Double): GremlinScala[End, Labels]
def collect[A](pf: PartialFunction[End, A]): GremlinScala[A, Labels]
def constant[A](value: A): GremlinScala[A, Labels]
def count(scope: Scope): GremlinScala[Long, HNil]
def count(): GremlinScala[Long, HNil]
def cyclicPath(): GremlinScala[End, Labels]
def dedup(scope: Scope, dedupLabels: String*): GremlinScala[End, Labels]
def dedup(dedupLabels: String*): GremlinScala[End, Labels]
def dedup(by: By[_]): GremlinScala[End, Labels]
def dedup(): GremlinScala[End, Labels]
def drop(): GremlinScala[End, Labels]
def emit(emitTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[End, _]): GremlinScala[End, Labels]
def emit(): GremlinScala[End, Labels]
def emitWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): GremlinScala[End, Labels]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def exists(): Boolean
def explain(): TraversalExplanation
def filter(predicate: (GremlinScala[End, _]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]

You might think that predicate should be GremlinScala[End, _] => GremlinScala[Boolean, _], but that's not how tp3 works: e.g.
You might think that predicate should be GremlinScala[End, _] => GremlinScala[Boolean, _], but that's not how tp3 works: e.g. .value(Age).is(30) returns 30, not true
def filterNot(predicate: (GremlinScala[End, _]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]
def filterOnEnd(predicate: (End) ⇒ Boolean): GremlinScala[End, Labels]
def filterWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): GremlinScala[End, Labels]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap[A](fun: (End) ⇒ GremlinScala[A, _]): GremlinScala[A, Labels]
def flatMapWithTraverser[A](fun: (Traverser[End]) ⇒ GremlinScala[A, _]): GremlinScala[A, Labels]
def fold(): GremlinScala[List[End], HNil]
def foldLeft[Z](z: Z)(op: (Z, End) ⇒ Z): GremlinScala[Z, HNil]
def from(fromTraversal: (GremlinScala[Vertex, _]) ⇒ GremlinScala[Vertex, _]): GremlinScala[End, Labels]
def from(label: StepLabel[Vertex]): GremlinScala[End, Labels]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def group[ModulatedKeys, ModulatedValues](keysBy: By[ModulatedKeys], valuesBy: By[ModulatedValues]): GremlinScala[Map[ModulatedKeys, Collection[ModulatedValues]], Labels]

Organize objects in the stream into a Map, group keys and values with a modulator
def group[Modulated](keysBy: By[Modulated]): GremlinScala[Map[Modulated, Collection[End]], Labels]

Organize objects in the stream into a Map, group keys with a modulator
def group[A]()(implicit arg0: DefaultsToAny[A]): GremlinScala[Map[String, A], Labels]

Organize objects in the stream into a Map.
def groupCount[Modulated](by: By[Modulated]): GremlinScala[Map[Modulated, Long], Labels]
def groupCount(sideEffectKey: String): GremlinScala[End, Labels]
def groupCount(): GremlinScala[Map[End, Long], Labels]
def has[A](label: String, key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def has[A](label: String, key: Key[A], value: A)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def has[A, B](key: Key[A], propertyTraversal: (GremlinScala[A, HNil]) ⇒ GremlinScala[B, _])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def has[A](accessor: T, predicate: P[A])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def has(accessor: T, value: Any)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def has[A](key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def has[A](p: (Key[A], A))(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def has[A](keyValue: KeyValue[A])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def has[A](key: Key[A], value: A)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def has(key: Key[_])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def hasId(predicate: P[AnyRef])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def hasId(id: AnyRef, ids: AnyRef*)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def hasKey(key: Key[_], keys: Key[_]*): GremlinScala[End, Labels]
def hasLabel[CC <: Product]()(implicit arg0: scala.reflect.api.JavaUniverse.WeakTypeTag[CC], ev: <:<[End, Element]): GremlinScala[End, Labels]
def hasLabel(label: String, labels: String*)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def hasNot[A](key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def hasNot[A](key: Key[A], value: A): GremlinScala[End, Labels]
def hasNot[A](keyValue: KeyValue[A]): GremlinScala[End, Labels]
def hasNot(key: Key[_]): GremlinScala[End, Labels]
def hasValue(value: String, values: String*): GremlinScala[End, Labels]
def head(): End
def headOption(): Option[End]
def id(): GremlinScala[AnyRef, Labels]
def identity(): GremlinScala[End, Labels]
def in(labels: String*)(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]
def in()(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]
def inE(labels: String*)(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]
def inE()(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]
def inV()(implicit ev: <:<[End, Edge]): GremlinScala[Vertex, Labels]
def inject(injections: End*): GremlinScala[End, Labels]
def is(predicate: P[End]): GremlinScala[End, Labels]
def is(value: AnyRef): GremlinScala[End, Labels]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterate(): GremlinScala[End, Labels]
def key()(implicit ev: <:<[End, Element]): GremlinScala[String, Labels]
def l(): List[End]

alias for toList, because typing kills
def label(): GremlinScala[String, Labels]
def limit(scope: Scope, limit: Long): GremlinScala[End, Labels]
def limit(limit: Long): GremlinScala[End, Labels]
def local[A](localTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[A, _])(implicit ev: <:<[End, Element]): GremlinScala[A, Labels]
def loops(): GremlinScala[Integer, HNil]
def map[A](fun: (End) ⇒ A): GremlinScala[A, Labels]
def mapWithTraverser[A](fun: (Traverser[End]) ⇒ A): GremlinScala[A, Labels]
def match[A](traversals: Traversal[End, _]*): GremlinScala[Map[String, A], Labels]
def math(expression: String, bys: By[_]*): GremlinScala[Double, Labels]
def max[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]
def max[N <: Number]()(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]
def mean[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): GremlinScala[Double, HNil]
def mean[N <: Number]()(implicit toNumber: (End) ⇒ N): GremlinScala[Double, HNil]
def min[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]
def min[N <: Number]()(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def not(notTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]
def notExists(): Boolean
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def optional[A](optionalTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[A, _], default: A): GremlinScala[A, Labels]
def optional(optionalTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[End, _]): GremlinScala[End, Labels]
def or(traversals: (GremlinScala[End, HNil]) ⇒ GremlinScala[_, _]*): GremlinScala[End, Labels]
def order(scope: Scope, orderBys: OrderBy[_]*): GremlinScala[End, Labels]
def order(orderBys: OrderBy[_]*): GremlinScala[End, Labels]
def order(scope: Scope): GremlinScala[End, Labels]
def order(): GremlinScala[End, Labels]
def otherV()(implicit ev: <:<[End, Edge]): GremlinScala[Vertex, Labels]
def out(labels: String*)(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]
def out()(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]
def outE(labels: String*)(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]
def outE()(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]
def outV()(implicit ev: <:<[End, Edge]): GremlinScala[Vertex, Labels]
def path(bys: By[_]*): GremlinScala[Path, Labels]
def path(): GremlinScala[Path, Labels]
def profile(sideEffectKey: String): GremlinScala[End, Labels]
def project[A](projectKey: String, otherProjectKeys: String*): GremlinScala[Map[String, A], Labels]
def promise[NewEnd](onComplete: (GremlinScala[End, Labels]) ⇒ NewEnd): Future[NewEnd]
def properties(keys: String*)(implicit ev: <:<[End, Element]): GremlinScala[Property[Any], Labels]
def property[A](key: Key[A])(value: (GremlinScala[End, _]) ⇒ GremlinScala[A, _])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def property[A](key: Key[A], value: A)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def propertyMap(keys: String*)(implicit ev: <:<[End, Element]): GremlinScala[Map[String, Any], Labels]
def range(scope: Scope, low: Long, high: Long): GremlinScala[End, Labels]
def range(low: Long, high: Long): GremlinScala[End, Labels]
def repeat(repeatTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[End, _]): GremlinScala[End, Labels]
def sack[SackType, Modulated](func: (SackType, Modulated) ⇒ SackType, by: By[Modulated]): GremlinScala[End, Labels]

sack with by modulator
def sack[SackType](func: (SackType, End) ⇒ SackType): GremlinScala[End, Labels]

Modify the sack with the current End type.
Modify the sack with the current End type. [SideEffect]
def sack[SackType](): GremlinScala[SackType, Labels]

Take value out of the sack.
Take value out of the sack. TODO: carry SackType as class type parameter (both ScalaGraph and GremlinScala)
def sample(scope: Scope, amount: Int): GremlinScala[End, Labels]
def sample(amount: Int): GremlinScala[End, Labels]
def select(pop: Pop, selectKey1: String, selectKey2: String, otherSelectKeys: String*): GremlinScala[Map[String, Any], Labels]
def select(selectKey1: String, selectKey2: String, otherSelectKeys: String*): GremlinScala[Map[String, Any], Labels]
def select[A](pop: Pop, selectKey: String)(implicit arg0: DefaultsToAny[A]): GremlinScala[A, Labels]
def select[A](selectKey: String)(implicit arg0: DefaultsToAny[A]): GremlinScala[A, Labels]
def select[StepLabelsAsTuple <: Product, StepLabels <: HList, H0, T0 <: HList, LabelNames <: HList, TupleWithValue, Values <: HList, Z, ValueTuples](stepLabelsTuple: StepLabelsAsTuple)(implicit toHList: Aux[StepLabelsAsTuple, StepLabels], hasOne: Aux[StepLabels, H0, T0], hasTwo: IsHCons[T0], stepLabelToString: Aux[GetLabelName.type, StepLabels, LabelNames], trav: Aux[LabelNames, List, String], folder: Aux[StepLabels, (HNil, Map[String, Any]), combineLabelWithValue.type, (Values, Z)], tupler: shapeless.ops.hlist.Tupler.Aux[Values, ValueTuples]): GremlinScala[ValueTuples, Labels]
def select[A](stepLabel: StepLabel[A]): GremlinScala[A, Labels]
def select[LabelsTuple]()(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Labels, LabelsTuple]): GremlinScala[LabelsTuple, Labels]
def sideEffect(fun: (End) ⇒ Any): GremlinScala[End, Labels]
def sideEffectWithTraverser(fun: (Traverser[End]) ⇒ Any): GremlinScala[End, Labels]
def simplePath(): GremlinScala[End, Labels]
def start[A]: GremlinScala[A, HNil]

Attributes
protected
def store(sideEffectKey: String)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def subgraph(stepLabel: StepLabel[Graph])(implicit ev: <:<[End, Edge]): GremlinScala[Edge, Labels]
def sum[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]
def sum[N <: Number]()(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail(scope: Scope, limit: Long): GremlinScala[End, Labels]
def tail(limit: Long): GremlinScala[End, Labels]
def tail(): GremlinScala[End, Labels]
def timeLimit(millis: Long)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]
def timeLimit(limit: FiniteDuration): GremlinScala[End, Labels]
def times(maxLoops: Int): GremlinScala[End, Labels]
def to(direction: Direction, edgeLabels: String*): GremlinScala[Vertex, Labels]
def to(toTraversal: (GremlinScala[Vertex, _]) ⇒ GremlinScala[Vertex, _]): GremlinScala[End, Labels]
def to(label: StepLabel[Vertex]): GremlinScala[End, Labels]
def toBuffer(): Buffer[End]
def toJavaList[A](i: Iterable[A]): List[A]

Attributes
protected
def toList(): List[End]
def toMap[A, B](implicit ev: <:<[End, (A, B)]): Map[A, B]
def toSet(): Set[End]
def toStream(): Stream[End]
val traversal: GraphTraversal[_, End]
def tree(sideEffectKey: String): GremlinScala[End, Labels]
def tree(): GremlinScala[Tree[_], Labels]
def unfold[A](): GremlinScala[A, Labels]
def union[A](unionTraversals: (GremlinScala[End, HNil]) ⇒ GremlinScala[A, _]*): GremlinScala[A, Labels]
def until(untilTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]
def untilWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): GremlinScala[End, Labels]
def value[A](key: String)(implicit ev: <:<[End, Element]): GremlinScala[A, Labels]
def value[A](key: Key[A])(implicit ev: <:<[End, Element]): GremlinScala[A, Labels]
def valueMap(keys: String*)(implicit ev: <:<[End, Element]): GremlinScala[Map[String, AnyRef], Labels]
def valueMap(implicit ev: <:<[End, Element]): GremlinScala[Map[String, AnyRef], Labels]
def valueOption[A](key: String)(implicit ev: <:<[End, Element]): GremlinScala[Option[A], Labels]
def valueOption[A](key: Key[A])(implicit ev: <:<[End, Element]): GremlinScala[Option[A], Labels]
def values[A](key: String*)(implicit ev: <:<[End, Element]): GremlinScala[A, Labels]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def where(whereTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]
def where(startKey: String, predicate: P[String], by: By[_]): GremlinScala[End, Labels]
def where(startKey: String, predicate: P[String]): GremlinScala[End, Labels]
def where(predicate: P[String], by: By[_]): GremlinScala[End, Labels]
def where(predicate: P[String]): GremlinScala[End, Labels]
def withFilter(predicate: (GremlinScala[End, _]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]

used in scala for comprehensions

Deprecated Value Members

def by[A](byTraversal: Traversal[_, A], comparator: Comparator[A]): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) don't use step by itself, most steps now accept a By instance as an argument
def by(byTraversal: Traversal[_, _]): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) don't use step by itself, most steps now accept a By instance as an argument
def by(lessThan: (End, End) ⇒ Boolean): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) don't use step by itself, most steps now accept a By instance as an argument
def by[A](elementPropertyKey: String, comparator: Comparator[A]): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) don't use step by itself, most steps now accept a By instance as an argument
def by(elementPropertyKey: String): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) don't use step by itself, most steps now accept a By instance as an argument
def by(tokenProjection: T): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) don't use step by itself, most steps now accept a By instance as an argument
def by[A <: AnyRef](funProjection: (End) ⇒ A, comparator: Comparator[A] = Order.incr): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) don't use step by itself, most steps now accept a By instance as an argument
def by[A <: AnyRef](funProjection: (End) ⇒ A): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) don't use step by itself, most steps now accept a By instance as an argument
def by(comparator: Comparator[End]): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) don't use step by itself, most steps now accept a By instance as an argument
def by(): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) don't use step by itself, most steps now accept a By instance as an argument
def group[A <: AnyRef](byTraversal: (End) ⇒ A): GremlinScala[Map[A, BulkSet[End]], Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) use group(by(...))
def groupBy[A <: AnyRef, B](byFun: (End) ⇒ A, valueFun: (End) ⇒ B): GremlinScala[Map[A, Iterable[B]], Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) use group(by(...))
def groupBy[A <: AnyRef](byFun: (End) ⇒ A): GremlinScala[Map[A, Collection[End]], Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) use group(by(...))
def order(scope: Scope, comparator: Order = Order.incr): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) use order(by(...))
def order(comparator: Order): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) use order(by(Order))
def orderBy(elementPropertyKey: String, comparator: Order)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) use order(by(...))
def orderBy(elementPropertyKey: String)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) use order(by(...))
def orderBy[A <: AnyRef](by: (End) ⇒ A, comparator: Comparator[A]): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) use order(by(...))
def orderBy[A <: AnyRef](by: (End) ⇒ A)(implicit arg0: Ordering[A]): GremlinScala[End, Labels]

Annotations
@deprecated
Deprecated
(Since version 3.0.0.1) use order(by(...))

Related Doc: package scala

case class GremlinScala[End, Labels <: HList](traversal: GraphTraversal[_, End]) extends Product with Serializable

Instance Constructors

new GremlinScala(traversal: GraphTraversal[_, End])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def V(vertexIdsOrElements: Any*)(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]

def addE(label: StepLabel[Vertex])(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]

def addE(label: String)(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]

def addV(label: String): GremlinScala[Vertex, Labels]

def addV(): GremlinScala[Vertex, Labels]

def aggregate(sideEffectKey: String): GremlinScala[End, Labels]

def and(traversals: (GremlinScala[End, HNil]) ⇒ GremlinScala[_, _]*): GremlinScala[End, Labels]

def as(stepLabel: StepLabel[End])(implicit p: Prepend[Labels, ::[End, HNil]]): GremlinScala[End, Out]

def as(name: String, moreNames: String*)(implicit p: Prepend[Labels, ::[End, HNil]]): GremlinScala[End, Out]

final def asInstanceOf[T0]: T0

def barrier(consumer: Consumer[TraverserSet[AnyRef]]): GremlinScala[End, Labels]

def barrier(consumer: (TraverserSet[End]) ⇒ Unit): GremlinScala[End, Labels]

def barrier(maxBarrierSize: Int): GremlinScala[End, Labels]

def barrier(): GremlinScala[End, Labels]

def both(labels: String*)(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]

def both()(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]

def bothE(labels: String*)(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]

def bothE()(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]

def bothV()(implicit ev: <:<[End, Edge]): GremlinScala[Vertex, Labels]

def branch[BranchOn, NewEnd](on: (GremlinScala[End, _]) ⇒ GremlinScala[BranchOn, _], options: BranchOption[End, NewEnd]*): GremlinScala[NewEnd, Labels]

def cap[A](stepLabel: StepLabel[A]): GremlinScala[A, Labels]

def cap(sideEffectKey: String, sideEffectKeys: String*): GremlinScala[End, Labels]

def choose[BranchOn, NewEnd](on: (GremlinScala[End, _]) ⇒ GremlinScala[BranchOn, _], options: BranchOption[End, NewEnd]*): GremlinScala[NewEnd, Labels]

def choose[NewEnd](predicate: (GremlinScala[End, _]) ⇒ GremlinScala[_, _], onTrue: (GremlinScala[End, HNil]) ⇒ GremlinScala[NewEnd, _], onFalse: (GremlinScala[End, HNil]) ⇒ GremlinScala[NewEnd, _]): GremlinScala[NewEnd, Labels]

def clone(): GremlinScala[End, Labels]

def coalesce[A](coalesceTraversals: (GremlinScala[End, HNil]) ⇒ GremlinScala[A, _]*): GremlinScala[A, Labels]

def coin(probability: Double): GremlinScala[End, Labels]

def collect[A](pf: PartialFunction[End, A]): GremlinScala[A, Labels]

def constant[A](value: A): GremlinScala[A, Labels]

def count(scope: Scope): GremlinScala[Long, HNil]

def count(): GremlinScala[Long, HNil]

def cyclicPath(): GremlinScala[End, Labels]

def dedup(scope: Scope, dedupLabels: String*): GremlinScala[End, Labels]

def dedup(dedupLabels: String*): GremlinScala[End, Labels]

def dedup(by: By[_]): GremlinScala[End, Labels]

def dedup(): GremlinScala[End, Labels]

def drop(): GremlinScala[End, Labels]

def emit(emitTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[End, _]): GremlinScala[End, Labels]

def emit(): GremlinScala[End, Labels]

def emitWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): GremlinScala[End, Labels]

final def eq(arg0: AnyRef): Boolean

def exists(): Boolean

def explain(): TraversalExplanation

def filter(predicate: (GremlinScala[End, _]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]

def filterNot(predicate: (GremlinScala[End, _]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]

def filterOnEnd(predicate: (End) ⇒ Boolean): GremlinScala[End, Labels]

def filterWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): GremlinScala[End, Labels]

def finalize(): Unit

def flatMap[A](fun: (End) ⇒ GremlinScala[A, _]): GremlinScala[A, Labels]

def flatMapWithTraverser[A](fun: (Traverser[End]) ⇒ GremlinScala[A, _]): GremlinScala[A, Labels]

def fold(): GremlinScala[List[End], HNil]

def foldLeft[Z](z: Z)(op: (Z, End) ⇒ Z): GremlinScala[Z, HNil]

def from(fromTraversal: (GremlinScala[Vertex, _]) ⇒ GremlinScala[Vertex, _]): GremlinScala[End, Labels]

def from(label: StepLabel[Vertex]): GremlinScala[End, Labels]

final def getClass(): Class[_]

def group[ModulatedKeys, ModulatedValues](keysBy: By[ModulatedKeys], valuesBy: By[ModulatedValues]): GremlinScala[Map[ModulatedKeys, Collection[ModulatedValues]], Labels]

def group[Modulated](keysBy: By[Modulated]): GremlinScala[Map[Modulated, Collection[End]], Labels]

def group[A]()(implicit arg0: DefaultsToAny[A]): GremlinScala[Map[String, A], Labels]

def groupCount[Modulated](by: By[Modulated]): GremlinScala[Map[Modulated, Long], Labels]

def groupCount(sideEffectKey: String): GremlinScala[End, Labels]

def groupCount(): GremlinScala[Map[End, Long], Labels]

def has[A](label: String, key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

def has[A](label: String, key: Key[A], value: A)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

def has[A, B](key: Key[A], propertyTraversal: (GremlinScala[A, HNil]) ⇒ GremlinScala[B, _])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

def has[A](accessor: T, predicate: P[A])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

def has(accessor: T, value: Any)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

def has[A](key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

def has[A](p: (Key[A], A))(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

def has[A](keyValue: KeyValue[A])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

def has[A](key: Key[A], value: A)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

def has(key: Key[_])(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]