class GremlinScala[End] extends AnyRef

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. GremlinScala
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

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

Type Members

  1. abstract type Labels <: HList

    labels applied to this traversal using as step

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def V(vertexIdsOrElements: Any*)(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
  5. def addE(label: StepLabel[Vertex], properties: KeyValue[_]*)(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
  6. def addE(label: String, properties: KeyValue[_]*)(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]

    may be used together with from / to, see TraversalSpec for examples

  7. def addV(label: String): Aux[Vertex, Labels]
  8. def addV(): Aux[Vertex, Labels]
  9. def aggregate(stepLabel: StepLabel[Set[End]]): Aux[End, Labels]
  10. def and(traversals: (Aux[End, HNil]) ⇒ GremlinScala[_]*): Aux[End, Labels]
  11. 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

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

  13. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  14. def barrier(consumer: Consumer[TraverserSet[AnyRef]]): Aux[End, Labels]
  15. def barrier(consumer: (TraverserSet[End]) ⇒ Unit): Aux[End, Labels]
  16. def barrier(maxBarrierSize: Int): Aux[End, Labels]
  17. def barrier(): Aux[End, Labels]
  18. def both(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
  19. def both()(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
  20. def bothE(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
  21. def bothE()(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
  22. def bothV()(implicit ev: <:<[End, Edge]): Aux[Vertex, Labels]
  23. 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

  24. def bytecode: Bytecode
  25. def cap[A](stepLabel: StepLabel[A]): Aux[A, Labels]
  26. def cap(sideEffectKey: String, sideEffectKeys: String*): Aux[End, Labels]
  27. 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

  28. 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) returns 30, not true

  29. def clone(): Aux[End, Labels]
    Definition Classes
    GremlinScala → AnyRef
  30. 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

  31. def coin(probability: Double): Aux[End, Labels]

    keeps element on a probabilistic base - probability range: 0.0 (keep none) - 1.0 - keep all

  32. def collect[A](pf: PartialFunction[End, A]): Aux[A, Labels]
  33. def constant[A](value: A): Aux[A, Labels]
  34. def count(scope: Scope): Aux[Long, HNil]
  35. def count(): Aux[Long, HNil]
  36. def cyclicPath(): Aux[End, Labels]
  37. def dedup(scope: Scope, dedupLabels: String*): Aux[End, Labels]
  38. def dedup(dedupLabels: String*): Aux[End, Labels]
  39. def dedup(by: By[_]): Aux[End, Labels]
  40. def dedup(): Aux[End, Labels]
  41. def drop(): Aux[End, Labels]

    removes elements/properties from the graph

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

    modulator for repeat step - emit if emitTraversal has at least one result

  43. def emit(): Aux[End, Labels]

    modulator for repeat step - emit everything on the way

  44. def emitWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): Aux[End, Labels]

    modulator for repeat step - emit depending on predicate

  45. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  46. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  47. def exists(): Boolean
  48. def explain(): TraversalExplanation
  49. 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) returns 30, not true

  50. def filterNot(predicate: (GremlinScala[End]) ⇒ GremlinScala[_]): Aux[End, Labels]
  51. def filterOnEnd(predicate: (End) ⇒ Boolean): Aux[End, Labels]
  52. def filterWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): Aux[End, Labels]
  53. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  54. def flatMap[A](fun: (End) ⇒ GremlinScala[A]): Aux[A, Labels]
  55. def flatMapWithTraverser[A](fun: (Traverser[End]) ⇒ GremlinScala[A]): Aux[A, Labels]
  56. def fold(): Aux[List[End], HNil]
  57. def foldLeft[Z](z: Z)(op: (Z, End) ⇒ Z): Aux[Z, HNil]
  58. 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

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

  60. def from(vertex: Vertex): Aux[End, Labels]

    modulator, use in conjunction with addE http://tinkerpop.apache.org/docs/current/reference/#from-step

  61. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  62. 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

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

  64. def group[A]()(implicit arg0: DefaultsToAny[A]): Aux[Map[String, A], Labels]

    Organize objects in the stream into a Map.

  65. def groupCount[Modulated](by: By[Modulated]): Aux[Map[Modulated, Long], Labels]
  66. 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

  67. def groupCount(): Aux[Map[End, Long], Labels]
  68. def has[A](label: String, key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
  69. def has[A](label: String, key: Key[A], value: A)(implicit ev: <:<[End, Element]): Aux[End, Labels]
  70. def has[A, B](key: Key[A], propertyTraversal: (Aux[A, HNil]) ⇒ GremlinScala[B])(implicit ev: <:<[End, Element]): Aux[End, Labels]
  71. def has[A](accessor: T, predicate: P[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
  72. def has(accessor: T, value: Any)(implicit ev: <:<[End, Element]): Aux[End, Labels]
  73. def has[A](key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
  74. def has[A](p: (Key[A], A))(implicit ev: <:<[End, Element]): Aux[End, Labels]
  75. def has[A](keyValue: KeyValue[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
  76. def has[A](key: Key[A], value: A)(implicit ev: <:<[End, Element]): Aux[End, Labels]
  77. def has(key: Key[_])(implicit ev: <:<[End, Element]): Aux[End, Labels]
  78. def hasId(predicate: P[AnyRef])(implicit ev: <:<[End, Element]): Aux[End, Labels]
  79. def hasId(id: AnyRef, ids: AnyRef*)(implicit ev: <:<[End, Element]): Aux[End, Labels]
  80. def hasKey(key: Key[_], keys: Key[_]*): Aux[End, Labels]
  81. def hasLabel[CC <: Product]()(implicit arg0: scala.reflect.api.JavaUniverse.WeakTypeTag[CC], ev: <:<[End, Element]): Aux[End, Labels]
  82. def hasLabel(label: String, labels: String*)(implicit ev: <:<[End, Element]): Aux[End, Labels]
  83. def hasNot[A](key: Key[A], predicate: P[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]
  84. def hasNot[A](key: Key[A], value: A): Aux[End, Labels]
  85. def hasNot[A](keyValue: KeyValue[A]): Aux[End, Labels]
  86. def hasNot(key: Key[_]): Aux[End, Labels]
  87. def hasValue[A](value: A, values: AnyRef*): Aux[End, Labels]
  88. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  89. 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

  90. def headOption(): Option[End]
  91. def id(): Aux[AnyRef, Labels]
  92. def identity(): Aux[End, Labels]
  93. def in(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
  94. def in()(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
  95. def inE(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
  96. def inE()(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
  97. def inV()(implicit ev: <:<[End, Edge]): Aux[Vertex, Labels]
  98. def inject(injections: End*): Aux[End, Labels]
  99. def is(predicate: P[End]): Aux[End, Labels]
  100. def is(value: AnyRef): Aux[End, Labels]
  101. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  102. def iterate(): Aux[End, Labels]

    execute pipeline - applies all side effects

  103. def key()(implicit ev: <:<[End, Element]): Aux[String, Labels]
  104. def l(): List[End]

    alias for toList, because typing kills

  105. def label(): Aux[String, Labels]
  106. def limit(scope: Scope, max: Long): Aux[End, Labels]
  107. def limit(max: Long): Aux[End, Labels]
  108. def local[A](localTraversal: (Aux[End, HNil]) ⇒ GremlinScala[A])(implicit ev: <:<[End, Element]): Aux[A, Labels]
  109. def loops(): Aux[Integer, HNil]
  110. def map[A](fun: (End) ⇒ A): Aux[A, Labels]
  111. def mapWithTraverser[A](fun: (Traverser[End]) ⇒ A): Aux[A, Labels]
  112. def match[A](traversals: Traversal[End, _]*): Aux[Map[String, A], Labels]
  113. 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

  114. def max[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
  115. def max[N <: Number]()(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
  116. def mean[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): Aux[Double, HNil]
  117. def mean[N <: Number]()(implicit toNumber: (End) ⇒ N): Aux[Double, HNil]
  118. def min[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
  119. def min[N <: Number]()(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
  120. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  121. def not(notTraversal: (Aux[End, HNil]) ⇒ GremlinScala[_]): Aux[End, Labels]
  122. def notExists(): Boolean
  123. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  124. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  125. 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 and traverser behaviour

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

  127. def or(traversals: (Aux[End, HNil]) ⇒ GremlinScala[_]*): Aux[End, Labels]
  128. def order(scope: Scope, orderBys: OrderBy[_]*): Aux[End, Labels]

    n.b.

    n.b. By can be used in place of OrderBy

  129. def order(orderBys: OrderBy[_]*): Aux[End, Labels]

    n.b.

    n.b. By can be used in place of OrderBy

  130. def order(scope: Scope): Aux[End, Labels]
  131. def order(): Aux[End, Labels]
  132. def otherV()(implicit ev: <:<[End, Edge]): Aux[Vertex, Labels]
  133. def out(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
  134. def out()(implicit ev: <:<[End, Vertex]): Aux[Vertex, Labels]
  135. def outE(labels: String*)(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
  136. def outE()(implicit ev: <:<[End, Vertex]): Aux[Edge, Labels]
  137. def outV()(implicit ev: <:<[End, Edge]): Aux[Vertex, Labels]
  138. def path(bys: By[_]*): Aux[Path, Labels]

    track every step in the traversal, modulate elements in round robin fashion

  139. def path(): Aux[Path, Labels]

    track every step in the traversal

  140. def profile(sideEffectKey: String): Aux[End, Labels]
  141. def project[A](projectKey: String, otherProjectKeys: String*): Aux[Map[String, A], Labels]
  142. def promise(): Future[List[End]]

    convenience step for majority use case for promise

  143. def promise[NewEnd](onComplete: (Aux[End, Labels]) ⇒ NewEnd): Future[NewEnd]

    run pipeline asynchronously note: only supported by RemoteGraphs (see withRemote)

  144. def properties(keys: String*)(implicit ev: <:<[End, Element]): Aux[Property[Any], Labels]
  145. 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

  146. def property[A](key: Key[A], value: A)(implicit ev: <:<[End, Element]): Aux[End, Labels]

    set the property to the given value

  147. def property[A](keyValue: KeyValue[A])(implicit ev: <:<[End, Element]): Aux[End, Labels]

    set the property to the given value

  148. def propertyMap(keys: String*)(implicit ev: <:<[End, Element]): Aux[Map[String, Any], Labels]
  149. def range(scope: Scope, low: Long, high: Long): Aux[End, Labels]
  150. def range(low: Long, high: Long): Aux[End, Labels]
  151. 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 or until step, e.g.

    repeats the provided anonymous traversal which starts at the current End combine with times or until step, e.g. gs.V(1).repeat(_.out).times(2) Note: has to end on the same type (or a supertype of) the current End, otherwise we couldn't reapply it multiple times.

  152. def sack[SackType, Modulated](func: (SackType, Modulated) ⇒ SackType, by: By[Modulated]): Aux[End, Labels]

    sack with by modulator

  153. 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]

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

  155. def sample(scope: Scope, amount: Int): Aux[End, Labels]
  156. def sample(amount: Int): Aux[End, Labels]
  157. def select(pop: Pop, selectKey1: String, selectKey2: String, otherSelectKeys: String*): Aux[Map[String, Any], Labels]
  158. def select(selectKey1: String, selectKey2: String, otherSelectKeys: String*): Aux[Map[String, Any], Labels]
  159. def select[A](pop: Pop, selectKey: String)(implicit arg0: DefaultsToAny[A]): Aux[A, Labels]
  160. def select[A](selectKey: String)(implicit arg0: DefaultsToAny[A]): Aux[A, Labels]
  161. 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)

  162. def select[A](stepLabel: StepLabel[A]): Aux[A, Labels]
  163. def select[LabelsTuple]()(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Labels, LabelsTuple]): Aux[LabelsTuple, Labels]

    select all labelled steps - see as step and SelectSpec

  164. def sideEffect(fun: (End) ⇒ Any): Aux[End, Labels]
  165. def sideEffectWithTraverser(fun: (Traverser[End]) ⇒ Any): Aux[End, Labels]
  166. def simplePath(): Aux[End, Labels]
  167. def start[A]: Aux[A, HNil]
    Attributes
    protected
  168. def store(stepLabel: StepLabel[Set[End]]): Aux[End, Labels]
  169. def subgraph(stepLabel: StepLabel[Graph])(implicit ev: <:<[End, Edge]): Aux[Edge, Labels]
  170. def sum[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
  171. def sum[N <: Number]()(implicit toNumber: (End) ⇒ N): Aux[N, HNil]
  172. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  173. def tail(scope: Scope, limit: Long): Aux[End, Labels]
  174. def tail(limit: Long): Aux[End, Labels]
  175. def tail(): Aux[End, Labels]
  176. def timeLimit(millis: Long)(implicit ev: <:<[End, Element]): Aux[End, Labels]
  177. def timeLimit(maxTime: FiniteDuration): Aux[End, Labels]
  178. def times(maxLoops: Int): Aux[End, Labels]
  179. def to(direction: Direction, edgeLabels: String*): Aux[Vertex, Labels]
  180. 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

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

  182. def to(vertex: Vertex): Aux[End, Labels]

    modulator, use in conjunction with addE http://tinkerpop.apache.org/docs/current/reference/#to-step

  183. def toBuffer(): Buffer[End]
  184. def toList(): List[End]
  185. def toMap[A, B](implicit ev: <:<[End, (A, B)]): Map[A, B]
  186. def toSet(): Set[End]
  187. def toStream(): Stream[End]
  188. def toString(): String
    Definition Classes
    GremlinScala → AnyRef → Any
  189. val traversal: GraphTraversal[_, End]
  190. def tree(sideEffectKey: String): Aux[End, Labels]
  191. def tree(): GremlinScala[Tree[_]] { type Labels = GremlinScala.this.Labels }
  192. def unfold[A](): Aux[A, Labels]
  193. 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 as GremlinScala[(JList[Edge], JList[Vertex])]

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

  195. def until(untilTraversal: (Aux[End, HNil]) ⇒ GremlinScala[_]): Aux[End, Labels]
  196. def untilWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): Aux[End, Labels]
  197. def value[A](key: String)(implicit ev: <:<[End, Element]): Aux[A, Labels]
  198. def value[A](key: Key[A])(implicit ev: <:<[End, Element]): Aux[A, Labels]
  199. def valueMap(keys: String*)(implicit ev: <:<[End, Element]): Aux[Map[String, AnyRef], Labels]
  200. def valueMap(implicit ev: <:<[End, Element]): Aux[Map[String, AnyRef], Labels]
  201. def valueOption[A](key: String)(implicit ev: <:<[End, Element]): Aux[Option[A], Labels]
  202. def valueOption[A](key: Key[A])(implicit ev: <:<[End, Element]): Aux[Option[A], Labels]
  203. def values[A](key: String*)(implicit ev: <:<[End, Element]): Aux[A, Labels]
  204. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  205. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  206. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  207. def where(whereTraversal: (Aux[End, HNil]) ⇒ GremlinScala[_]): Aux[End, Labels]
  208. def where(startKey: String, predicate: P[String], by: By[_]): Aux[End, Labels]

    predicate refers to a step label

  209. def where(startKey: String, predicate: P[String]): Aux[End, Labels]

    predicate refers to a step label

  210. def where(predicate: P[String], by: By[_]): Aux[End, Labels]

    predicate refers to a step label

  211. def where(predicate: P[String]): Aux[End, Labels]

    predicate refers to a step label

  212. def withFilter(predicate: (GremlinScala[End]) ⇒ GremlinScala[_]): Aux[End, Labels]

    used in scala for comprehensions

Deprecated Value Members

  1. def aggregate(sideEffectKey: String): Aux[End, Labels]
    Annotations
    @deprecated
    Deprecated

    (Since version 3.3.3.16) use aggregate(StepLabel) for more type safety

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

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

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

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

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

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

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

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

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

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

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

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

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

  15. def order(scope: Scope, comparator: Order = Order.incr): Aux[End, Labels]
    Annotations
    @deprecated
    Deprecated

    (Since version 3.0.0.1) use order(by(...))

  16. def order(comparator: Order): Aux[End, Labels]
    Annotations
    @deprecated
    Deprecated

    (Since version 3.0.0.1) use order(by(Order))

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

  18. def orderBy(elementPropertyKey: String)(implicit ev: <:<[End, Element]): Aux[End, Labels]
    Annotations
    @deprecated
    Deprecated

    (Since version 3.0.0.1) use order(by(...))

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

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

  21. def store(sideEffectKey: String): Aux[End, Labels]
    Annotations
    @deprecated
    Deprecated

    (Since version 3.3.3.16) use store(StepLabel) for more type safety

Inherited from AnyRef

Inherited from Any

Ungrouped