class GremlinScala[End] extends AnyRef
- Alphabetic
- By Inheritance
- GremlinScala
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new GremlinScala(traversal: GraphTraversal[_, End])
Type Members
-
abstract
type
Labels <: HList
labels applied to this traversal using
as
step
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]): Aux[Vertex, Labels]
- def addE(label: StepLabel[Vertex], properties: KeyValue[_]*)(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
-
def
addE(label: String, properties: KeyValue[_]*)(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
may be used together with
from
/to
, see TraversalSpec for examples - def addV(label: String): Aux[Vertex, Labels]
- def addV(): Aux[Vertex, Labels]
- def aggregate(stepLabel: StepLabel[Set[End]]): Aux[End, Labels]
- def and(traversals: (Aux[End, HNil]) ⇒ GremlinScala[_]*): Aux[End, Labels]
-
def
as(stepLabel: StepLabel[End])(implicit p: Prepend[Labels, ::[End, HNil]]): Aux[End, Out]
labels the current step and preserves the type - see
select
step -
def
as(name: String, moreNames: String*)(implicit p: Prepend[Labels, ::[End, HNil]]): Aux[End, Out]
labels the current step and preserves the type - see
select
step -
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def barrier(consumer: Consumer[TraverserSet[AnyRef]]): Aux[End, Labels]
- def barrier(consumer: (TraverserSet[End]) ⇒ Unit): Aux[End, Labels]
- def barrier(maxBarrierSize: Int): Aux[End, Labels]
- def barrier(): Aux[End, Labels]
- def both(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
- def both()(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
- def bothE(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
- def bothE()(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
- def bothV()(implicit ev: <:<[End, Edge]): Aux[Vertex, Labels]
-
def
branch[BranchOn, NewEnd](on: (GremlinScala[End]) ⇒ GremlinScala[BranchOn], options: BranchOption[End, NewEnd]*): Aux[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 bytecode: Bytecode
- def cap[A](stepLabel: StepLabel[A]): Aux[A, Labels]
- def cap(sideEffectKey: String, sideEffectKeys: String*): Aux[End, Labels]
-
def
choose[BranchOn, NewEnd](on: (GremlinScala[End]) ⇒ GremlinScala[BranchOn], options: BranchOption[End, NewEnd]*): Aux[NewEnd, Labels]
traverser will pick first option that has a matching pickToken
-
def
choose[NewEnd](predicate: (GremlinScala[End]) ⇒ GremlinScala[_], onTrue: (Aux[End, HNil]) ⇒ GremlinScala[NewEnd], onFalse: (Aux[End, HNil]) ⇒ GremlinScala[NewEnd]): Aux[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)
returns30
, nottrue
-
def
clone(): Aux[End, Labels]
- Definition Classes
- GremlinScala → AnyRef
-
def
coalesce[A](coalesceTraversals: (Aux[End, HNil]) ⇒ GremlinScala[A]*): Aux[A, Labels]
evaluates the provided traversals in order and returns the first traversal that emits at least one element useful e.g.
evaluates the provided traversals in order and returns the first traversal that emits at least one element useful e.g. for if/elseif/else semantics
-
def
coin(probability: Double): Aux[End, Labels]
keeps element on a probabilistic base - probability range: 0.0 (keep none) - 1.0 - keep all
- def collect[A](pf: PartialFunction[End, A]): Aux[A, Labels]
- def constant[A](value: A): Aux[A, Labels]
- def count(scope: Scope): Aux[Long, HNil]
- def count(): Aux[Long, HNil]
- def cyclicPath(): Aux[End, Labels]
- def dedup(scope: Scope, dedupLabels: String*): Aux[End, Labels]
- def dedup(dedupLabels: String*): Aux[End, Labels]
- def dedup(by: By[_]): Aux[End, Labels]
- def dedup(): Aux[End, Labels]
-
def
drop(): Aux[End, Labels]
removes elements/properties from the graph
-
def
emit(emitTraversal: (Aux[End, HNil]) ⇒ GremlinScala[_]): Aux[End, Labels]
modulator for repeat step - emit if emitTraversal has at least one result
-
def
emit(): Aux[End, Labels]
modulator for repeat step - emit everything on the way
-
def
emitWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): Aux[End, Labels]
modulator for repeat step - emit depending on predicate
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def exists(): Boolean
- def explain(): TraversalExplanation
-
def
filter(predicate: (GremlinScala[End]) ⇒ GremlinScala[_]): Aux[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)
returns30
, nottrue
- def filterNot(predicate: (GremlinScala[End]) ⇒ GremlinScala[_]): Aux[End, Labels]
- def filterOnEnd(predicate: (End) ⇒ Boolean): Aux[End, Labels]
- def filterWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): Aux[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]): Aux[A, Labels]
- def flatMapWithTraverser[A](fun: (Traverser[End]) ⇒ GremlinScala[A]): Aux[A, Labels]
- def fold(): Aux[List[End], HNil]
- def foldLeft[Z](z: Z)(op: (Z, End) ⇒ Z): Aux[Z, HNil]
-
def
from(fromTraversal: (GremlinScala[Vertex]) ⇒ GremlinScala[Vertex]): Aux[End, Labels]
modulator, use in conjunction with simplePath(), cyclicPath(), path(), and addE() TODO: make this a standalone modulator like By that may only be used with the above mentioned steps note: when using with addE, it only selects the first vertex! http://tinkerpop.apache.org/docs/current/reference/#from-step https://groups.google.com/forum/#!topic/gremlin-users/3YgKMKB4iNs
-
def
from(label: StepLabel[Vertex]): Aux[End, Labels]
modulator, use in conjunction with simplePath(), cyclicPath(), path(), and addE() http://tinkerpop.apache.org/docs/current/reference/#from-step
-
def
from(vertex: Vertex): Aux[End, Labels]
modulator, use in conjunction with addE http://tinkerpop.apache.org/docs/current/reference/#from-step
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
group[ModulatedKeys, ModulatedValues](keysBy: By[ModulatedKeys], valuesBy: By[ModulatedValues]): Aux[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]): Aux[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]): Aux[Map[String, A], Labels]
Organize objects in the stream into a Map.
- def groupCount[Modulated](by: By[Modulated]): Aux[Map[Modulated, Long], Labels]
-
def
groupCount(sideEffectKey: String): Aux[End, Labels]
note that groupCount is a side effect step, other than the 'count' step..
note that groupCount is a side effect step, other than the 'count' step.. https://groups.google.com/forum/#!topic/gremlin-users/5wXSizpqRxw
- def groupCount(): Aux[Map[End, Long], Labels]
- def has[A](label: String, key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def has[A](label: String, key: Key[A], value: A)(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def has[A, B](key: Key[A], propertyTraversal: (Aux[A, HNil]) ⇒ GremlinScala[B])(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def has[A](accessor: T, predicate: P[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def has(accessor: T, value: Any)(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def has[A](key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def has[A](p: (Key[A], A))(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def has[A](keyValue: KeyValue[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def has[A](key: Key[A], value: A)(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def has(key: Key[_])(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def hasId(predicate: P[AnyRef])(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def hasId(id: AnyRef, ids: AnyRef*)(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def hasKey(key: Key[_], keys: Key[_]*): Aux[End, Labels]
- def hasLabel[CC <: Product]()(implicit arg0: scala.reflect.api.JavaUniverse.WeakTypeTag[CC], ev: <:<[End, Element]): Aux[End, Labels]
- def hasLabel(label: String, labels: String*)(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def hasNot[A](key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def hasNot[A](key: Key[A], value: A): Aux[End, Labels]
- def hasNot[A](keyValue: KeyValue[A]): Aux[End, Labels]
- def hasNot(key: Key[_]): Aux[End, Labels]
- def hasValue[A](value: A, values: AnyRef*): Aux[End, Labels]
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
head(): End
unsafe! this will throw a runtime exception if there is no element.
unsafe! this will throw a runtime exception if there is no element. better use
headOption
- def headOption(): Option[End]
- def id(): Aux[AnyRef, Labels]
- def identity(): Aux[End, Labels]
- def in(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
- def in()(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
- def inE(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
- def inE()(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
- def inV()(implicit ev: <:<[End, Edge]): Aux[Vertex, Labels]
- def inject(injections: End*): Aux[End, Labels]
- def is(predicate: P[End]): Aux[End, Labels]
- def is(value: AnyRef): Aux[End, Labels]
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
iterate(): Aux[End, Labels]
execute pipeline - applies all side effects
- def key()(implicit ev: <:<[End, Element]): Aux[String, Labels]
-
def
l(): List[End]
alias for
toList
, because typing kills - def label(): Aux[String, Labels]
- def limit(scope: Scope, max: Long): Aux[End, Labels]
- def limit(max: Long): Aux[End, Labels]
- def local[A](localTraversal: (Aux[End, HNil]) ⇒ GremlinScala[A])(implicit ev: <:<[End, Element]): Aux[A, Labels]
- def loops(): Aux[Integer, HNil]
- def map[A](fun: (End) ⇒ A): Aux[A, Labels]
- def mapWithTraverser[A](fun: (Traverser[End]) ⇒ A): Aux[A, Labels]
- def match[A](traversals: Traversal[End, _]*): Aux[Map[String, A], Labels]
-
def
math(expression: String, bys: By[_]*): Aux[Double, Labels]
generic maths based on strings, see http://tinkerpop.apache.org/docs/3.3.1/reference/#math-step
- def max[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
- def max[N <: Number]()(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
- def mean[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): Aux[Double, HNil]
- def mean[N <: Number]()(implicit toNumber: (End) ⇒ N): Aux[Double, HNil]
- def min[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
- def min[N <: Number]()(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def not(notTraversal: (Aux[End, HNil]) ⇒ GremlinScala[_]): Aux[End, Labels]
- def notExists(): Boolean
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
optional[A](optionalTraversal: (Aux[End, HNil]) ⇒ GremlinScala[A], default: A): GremlinScala[A] { type Labels = GremlinScala.this.Labels }
returns the result of the specified traversal if it yields a result else it returns the provided default value
returns the result of the specified traversal if it yields a result else it returns the provided default value
note: uses coalesce internally, which is a flatMap step, which affects
as
andtraverser
behaviour -
def
optional(optionalTraversal: (Aux[End, HNil]) ⇒ GremlinScala[End]): Aux[End, Labels]
returns the result of the specified traversal if it yields a result else it returns the calling element, i.e.
returns the result of the specified traversal if it yields a result else it returns the calling element, i.e. the identity().
- def or(traversals: (Aux[End, HNil]) ⇒ GremlinScala[_]*): Aux[End, Labels]
-
def
order(scope: Scope, orderBys: OrderBy[_]*): Aux[End, Labels]
n.b.
n.b.
By
can be used in place ofOrderBy
-
def
order(orderBys: OrderBy[_]*): Aux[End, Labels]
n.b.
n.b.
By
can be used in place ofOrderBy
- def order(scope: Scope): Aux[End, Labels]
- def order(): Aux[End, Labels]
- def otherV()(implicit ev: <:<[End, Edge]): Aux[Vertex, Labels]
- def out(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
- def out()(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
- def outE(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
- def outE()(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
- def outV()(implicit ev: <:<[End, Edge]): Aux[Vertex, Labels]
-
def
path(bys: By[_]*): Aux[Path, Labels]
track every step in the traversal, modulate elements in round robin fashion
-
def
path(): Aux[Path, Labels]
track every step in the traversal
- def profile(sideEffectKey: String): Aux[End, Labels]
- def project[A](projectKey: String, otherProjectKeys: String*): Aux[Map[String, A], Labels]
-
def
promise(): Future[List[End]]
convenience step for majority use case for
promise
-
def
promise[NewEnd](onComplete: (Aux[End, Labels]) ⇒ NewEnd): Future[NewEnd]
run pipeline asynchronously note: only supported by RemoteGraphs (see
withRemote
) - def properties(keys: String*)(implicit ev: <:<[End, Element]): Aux[Property[Any], Labels]
-
def
property[A](key: Key[A])(value: (GremlinScala[End]) ⇒ GremlinScala[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
set the property to the value determined by the given traversal
-
def
property[A](key: Key[A], value: A)(implicit ev: <:<[End, Element]): Aux[End, Labels]
set the property to the given value
-
def
property[A](keyValue: KeyValue[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
set the property to the given value
- def propertyMap(keys: String*)(implicit ev: <:<[End, Element]): Aux[Map[String, Any], Labels]
- def range(scope: Scope, low: Long, high: Long): Aux[End, Labels]
- def range(low: Long, high: Long): Aux[End, Labels]
-
def
repeat[NewEnd >: End](repeatTraversal: (Aux[End, HNil]) ⇒ GremlinScala[NewEnd]): Aux[NewEnd, Labels]
repeats the provided anonymous traversal which starts at the current End combine with
times
oruntil
step, e.g.repeats the provided anonymous traversal which starts at the current End combine with
times
oruntil
step, e.g.gs.V(1).repeat(_.out).times(2)
Note: has to end on the same type (or a supertype of) the currentEnd
, otherwise we couldn't reapply it multiple times. -
def
sack[SackType, Modulated](func: (SackType, Modulated) ⇒ SackType, by: By[Modulated]): Aux[End, Labels]
sack with by modulator
-
def
sack[SackType](func: (SackType, End) ⇒ SackType): Aux[End, Labels]
Modify the sack with the current End type.
Modify the sack with the current End type. [SideEffect]
-
def
sack[SackType](): Aux[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): Aux[End, Labels]
- def sample(amount: Int): Aux[End, Labels]
- def select(pop: Pop, selectKey1: String, selectKey2: String, otherSelectKeys: String*): Aux[Map[String, Any], Labels]
- def select(selectKey1: String, selectKey2: String, otherSelectKeys: String*): Aux[Map[String, Any], Labels]
- def select[A](pop: Pop, selectKey: String)(implicit arg0: DefaultsToAny[A]): Aux[A, Labels]
- def select[A](selectKey: String)(implicit arg0: DefaultsToAny[A]): Aux[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]): Aux[ValueTuples, Labels]
Select values from the traversal based on some given StepLabels (must be a tuple of
StepLabel
)Select values from the traversal based on some given StepLabels (must be a tuple of
StepLabel
)Lot's of type level magic here to make this work... * takes a tuple (with least two elements) whose elements are all StepLabel[_] * converts it to an HList * get's the actual values from the Tinkerpop3 java select as a Map[String, Any] * uses the types from the StepLabels to get the values from the Map (using a type level fold)
- def select[A](stepLabel: StepLabel[A]): Aux[A, Labels]
-
def
select[LabelsTuple]()(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Labels, LabelsTuple]): Aux[LabelsTuple, Labels]
select all labelled steps - see
as
step andSelectSpec
- def sideEffect(fun: (End) ⇒ Any): Aux[End, Labels]
- def sideEffectWithTraverser(fun: (Traverser[End]) ⇒ Any): Aux[End, Labels]
- def simplePath(): Aux[End, Labels]
-
def
start[A]: Aux[A, HNil]
- Attributes
- protected
- def store(stepLabel: StepLabel[Set[End]]): Aux[End, Labels]
- def subgraph(stepLabel: StepLabel[Graph])(implicit ev: <:<[End, Edge]): Aux[Edge, Labels]
- def sum[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
- def sum[N <: Number]()(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- def tail(scope: Scope, limit: Long): Aux[End, Labels]
- def tail(limit: Long): Aux[End, Labels]
- def tail(): Aux[End, Labels]
- def timeLimit(millis: Long)(implicit ev: <:<[End, Element]): Aux[End, Labels]
- def timeLimit(maxTime: FiniteDuration): Aux[End, Labels]
- def times(maxLoops: Int): Aux[End, Labels]
- def to(direction: Direction, edgeLabels: String*): Aux[Vertex, Labels]
-
def
to(toTraversal: (GremlinScala[Vertex]) ⇒ GremlinScala[Vertex]): Aux[End, Labels]
modulator, use in conjunction with simplePath(), cyclicPath(), path(), and addE() TODO: make this a standalone modulator like By that may only be used with the above mentioned steps note: when using with addE, it only selects the first vertex! http://tinkerpop.apache.org/docs/current/reference/#from-step https://groups.google.com/forum/#!topic/gremlin-users/3YgKMKB4iNs
-
def
to(label: StepLabel[Vertex]): Aux[End, Labels]
modulator, use in conjunction with simplePath(), cyclicPath(), path(), and addE() http://tinkerpop.apache.org/docs/current/reference/#from-step
-
def
to(vertex: Vertex): Aux[End, Labels]
modulator, use in conjunction with addE http://tinkerpop.apache.org/docs/current/reference/#to-step
- def toBuffer(): Buffer[End]
- def toList(): List[End]
- def toMap[A, B](implicit ev: <:<[End, (A, B)]): Map[A, B]
- def toSet(): Set[End]
- def toStream(): Stream[End]
-
def
toString(): String
- Definition Classes
- GremlinScala → AnyRef → Any
- val traversal: GraphTraversal[_, End]
- def tree(sideEffectKey: String): Aux[End, Labels]
- def tree(): GremlinScala[Tree[_]] { type Labels = GremlinScala.this.Labels }
- def unfold[A](): Aux[A, Labels]
-
def
union[EndsHList <: HList, EndsTuple](unionTraversals: (UnionTraversals[End, HNil]) ⇒ UnionTraversals[End, EndsHList])(implicit tupler: shapeless.ops.hlist.Tupler.Aux[EndsHList, EndsTuple]): Aux[EndsTuple, Labels]
merges of the results of an arbitrary number of traversals.
merges of the results of an arbitrary number of traversals. supports heterogeneous queries, e.g. for the following query:
g.V(1).union(_.join(_.outE).join(_.out))
the result type is derived asGremlinScala[(JList[Edge], JList[Vertex])]
-
def
unionFlat[A](unionTraversals: (Aux[End, HNil]) ⇒ GremlinScala[A]*): Aux[A, Labels]
merges of the results of an arbitrary number of traversals into a flat structure (i.e.
merges of the results of an arbitrary number of traversals into a flat structure (i.e. no folds).
- def until(untilTraversal: (Aux[End, HNil]) ⇒ GremlinScala[_]): Aux[End, Labels]
- def untilWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): Aux[End, Labels]
- def value[A](key: String)(implicit ev: <:<[End, Element]): Aux[A, Labels]
- def value[A](key: Key[A])(implicit ev: <:<[End, Element]): Aux[A, Labels]
- def valueMap(keys: String*)(implicit ev: <:<[End, Element]): Aux[Map[String, AnyRef], Labels]
- def valueMap(implicit ev: <:<[End, Element]): Aux[Map[String, AnyRef], Labels]
- def valueOption[A](key: String)(implicit ev: <:<[End, Element]): Aux[Option[A], Labels]
- def valueOption[A](key: Key[A])(implicit ev: <:<[End, Element]): Aux[Option[A], Labels]
- def values[A](key: String*)(implicit ev: <:<[End, Element]): Aux[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
- @native() @throws( ... )
- def where(whereTraversal: (Aux[End, HNil]) ⇒ GremlinScala[_]): Aux[End, Labels]
-
def
where(startKey: String, predicate: P[String], by: By[_]): Aux[End, Labels]
predicate
refers to a step label -
def
where(startKey: String, predicate: P[String]): Aux[End, Labels]
predicate
refers to a step label -
def
where(predicate: P[String], by: By[_]): Aux[End, Labels]
predicate
refers to a step label -
def
where(predicate: P[String]): Aux[End, Labels]
predicate
refers to a step label -
def
withFilter(predicate: (GremlinScala[End]) ⇒ GremlinScala[_]): Aux[End, Labels]
used in scala for comprehensions
Deprecated Value Members
-
def
aggregate(sideEffectKey: String): Aux[End, Labels]
- Annotations
- @deprecated
- Deprecated
(Since version 3.3.3.16) use aggregate(StepLabel) for more type safety
-
def
by[A](byTraversal: Traversal[_, A], comparator: Comparator[A]): Aux[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[_, _]): Aux[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): Aux[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]): Aux[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): Aux[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): Aux[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): Aux[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): Aux[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]): Aux[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(): Aux[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): Aux[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): Aux[Map[A, Iterable[B]], Labels]
- Annotations
- @deprecated
- Deprecated
(Since version 3.0.0.1) use group(by(...))
-
def
groupBy[A <: AnyRef](byFun: (End) ⇒ A): Aux[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): Aux[End, Labels]
- Annotations
- @deprecated
- Deprecated
(Since version 3.0.0.1) use order(by(...))
-
def
order(comparator: Order): Aux[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]): Aux[End, Labels]
- Annotations
- @deprecated
- Deprecated
(Since version 3.0.0.1) use order(by(...))
-
def
orderBy(elementPropertyKey: String)(implicit ev: <:<[End, Element]): Aux[End, Labels]
- Annotations
- @deprecated
- Deprecated
(Since version 3.0.0.1) use order(by(...))
-
def
orderBy[A <: AnyRef](by: (End) ⇒ A, comparator: Comparator[A]): Aux[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]): Aux[End, Labels]
- Annotations
- @deprecated
- Deprecated
(Since version 3.0.0.1) use order(by(...))
-
def
store(sideEffectKey: String): Aux[End, Labels]
- Annotations
- @deprecated
- Deprecated
(Since version 3.3.3.16) use store(StepLabel) for more type safety