GremlinScala

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]): GremlinScala[Vertex, Labels]

   

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

   

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

   

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

   

8. def addV(): GremlinScala[Vertex, Labels]

   

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

   

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

    

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

    

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

    

13. final def asInstanceOf[T0]: T0

    

    Definition Classes

    Any

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

    

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

    

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

    

17. def barrier(): GremlinScala[End, Labels]

    

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

    

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

    

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

    

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

    

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

    

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

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

    

25. def by(byTraversal: Traversal[_, _]): GremlinScala[End, Labels]

    

26. def by(lessThan: (End, End) ⇒ Boolean): GremlinScala[End, Labels]

    

27. def by[A](elementPropertyKey: String, comparator: Comparator[A]): GremlinScala[End, Labels]

    

28. def by(elementPropertyKey: String): GremlinScala[End, Labels]

    

29. def by(tokenProjection: T): GremlinScala[End, Labels]

    

30. def by[A <: AnyRef](funProjection: (End) ⇒ A, comparator: Comparator[A] = Order.incr)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

    

31. def by[A <: AnyRef](funProjection: (End) ⇒ A): GremlinScala[End, Labels]

    

32. def by(comparator: Comparator[End]): GremlinScala[End, Labels]

    

33. def by(): GremlinScala[End, Labels]

    

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

    

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

    

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

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

38. def clone(): GremlinScala[End, Labels]

    

    Definition Classes

    GremlinScala → AnyRef

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

    

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

    

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

    

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

    

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

    

44. def count(): GremlinScala[Long, HNil]

    

45. def cyclicPath(): GremlinScala[End, Labels]

    

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

    

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

    

48. def drop(): GremlinScala[End, Labels]

    

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

    

50. def emit(): GremlinScala[End, Labels]

    

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

    

52. final def eq(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

53. def exists(): Boolean

    

54. def explain(): TraversalExplanation

    

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

    

    Existing users please note: since 3.2.4.8 the filter step changed it's signature and now takes a traversal: filter(predicate: GremlinScala[End, _] ⇒ GremlinScala[_, _]).

    Existing users please note: since 3.2.4.8 the filter step changed it's signature and now takes a traversal: filter(predicate: GremlinScala[End, _] ⇒ GremlinScala[_, _]). The old filter(predicate: End ⇒ Boolean) is now called filterOnEnd, in case you still need it. This change might affect your for comprehensions. The reasoning for the change is that it's discouraged to use lambdas (see http://tinkerpop.apache.org/docs/current/reference/#a-note-on-lambdas). Instead we are now creating anonymous traversals, which can be optimised by the driver, sent over the wire as gremlin binary for remote execution etc.

    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

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

    

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

    

58. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

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

    

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

    

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

    

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

    

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

    

64. final def getClass(): Class[_]

    

    Definition Classes

    AnyRef → Any

65. def group(sideEffectKey: String): GremlinScala[End, Labels]

    

66. def group[A <: AnyRef](byTraversal: (End) ⇒ A): GremlinScala[Map[A, BulkSet[End]], Labels]

    

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

    

68. def groupBy[A <: AnyRef, B](byFun: (End) ⇒ A, valueFun: (End) ⇒ B): GremlinScala[Map[A, Iterable[B]], Labels]

    

69. def groupBy[A <: AnyRef](byFun: (End) ⇒ A): GremlinScala[Map[A, Collection[End]], Labels]

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

82. def hasId(id: AnyRef, ids: AnyRef*)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

    

83. def hasKey(key: Key[_], keys: Key[_]*): GremlinScala[End, Labels]

    

84. def hasLabel[CC <: Product]()(implicit arg0: scala.reflect.api.JavaUniverse.WeakTypeTag[CC], ev: <:<[End, Element]): GremlinScala[End, Labels]

    

85. def hasLabel(label: String, labels: String*)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

    

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

    

87. def hasNot[A](key: Key[A], value: A): GremlinScala[End, Labels]

    

88. def hasNot[A](keyValue: KeyValue[A]): GremlinScala[End, Labels]

    

89. def hasNot(key: Key[_]): GremlinScala[End, Labels]

    

90. def hasValue(value: String, values: String*): GremlinScala[End, Labels]

    

91. def head(): End

    

92. def headOption(): Option[End]

    

93. def id(): GremlinScala[AnyRef, Labels]

    

94. def identity(): GremlinScala[End, Labels]

    

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

    

96. def in()(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]

    

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

    

98. def inE()(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]

    

99. def inV()(implicit ev: <:<[End, Edge]): GremlinScala[Vertex, Labels]

    

100. def inject(injections: End*): GremlinScala[End, Labels]

     

101. def is(predicate: P[End]): GremlinScala[End, Labels]

     

102. def is(value: AnyRef): GremlinScala[End, Labels]

     

103. final def isInstanceOf[T0]: Boolean

     

     Definition Classes

     Any

104. def iterate(): GremlinScala[End, Labels]

     

105. def key()(implicit ev: <:<[End, Element]): GremlinScala[String, Labels]

     

106. def label(): GremlinScala[String, Labels]

     

107. def limit(scope: Scope, limit: Long): GremlinScala[End, Labels]

     

108. def limit(limit: Long): GremlinScala[End, Labels]

     

109. def local[A](localTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[A, _])(implicit ev: <:<[End, Element]): GremlinScala[A, Labels]

     

110. def loops(): GremlinScala[Integer, HNil]

     

111. def map[A](fun: (End) ⇒ A): GremlinScala[A, Labels]

     

112. def mapWithTraverser[A](fun: (Traverser[End]) ⇒ A): GremlinScala[A, Labels]

     

113. def match[A](traversals: Traversal[End, _]*): GremlinScala[Map[String, A], Labels]

     

114. def max[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]

     

115. def max[N <: Number]()(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]

     

116. def mean[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): GremlinScala[Double, HNil]

     

117. def mean[N <: Number]()(implicit toNumber: (End) ⇒ N): GremlinScala[Double, HNil]

     

118. def min[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]

     

119. def min[N <: Number]()(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]

     

120. final def ne(arg0: AnyRef): Boolean

     

     Definition Classes

     AnyRef

121. def not(notTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]

     

122. def notExists(): Boolean

     

123. final def notify(): Unit

     

     Definition Classes

     AnyRef

124. final def notifyAll(): Unit

     

     Definition Classes

     AnyRef

125. def optional(optionalTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[End, _]): GremlinScala[End, Labels]

     

126. def or(traversals: (GremlinScala[End, HNil]) ⇒ GremlinScala[_, _]*): GremlinScala[End, Labels]

     

127. def order(scope: Scope, comparator: Order = Order.incr): GremlinScala[End, Labels]

     

128. def order(scope: Scope): GremlinScala[End, Labels]

     

129. def order(comparator: Order): GremlinScala[End, Labels]

     

130. def order(): GremlinScala[End, Labels]

     

131. def orderBy(elementPropertyKey: String, comparator: Order)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

     

132. def orderBy(elementPropertyKey: String)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

     

133. def orderBy[A <: AnyRef](by: (End) ⇒ A, comparator: Comparator[A]): GremlinScala[End, Labels]

     

134. def orderBy[A <: AnyRef](by: (End) ⇒ A)(implicit arg0: Ordering[A]): GremlinScala[End, Labels]

     

135. def otherV()(implicit ev: <:<[End, Edge]): GremlinScala[Vertex, Labels]

     

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

     

137. def out()(implicit ev: <:<[End, Vertex]): GremlinScala[Vertex, Labels]

     

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

     

139. def outE()(implicit ev: <:<[End, Vertex]): GremlinScala[Edge, Labels]

     

140. def outV()(implicit ev: <:<[End, Edge]): GremlinScala[Vertex, Labels]

     

141. def path(): GremlinScala[Path, Labels]

     

142. def profile(sideEffectKey: String): GremlinScala[End, Labels]

     

143. def project[A](projectKey: String, otherProjectKeys: String*): GremlinScala[Map[String, A], Labels]

     

144. def promise[NewEnd](onComplete: (GremlinScala[End, Labels]) ⇒ NewEnd): Future[NewEnd]

     

145. def properties(keys: String*)(implicit ev: <:<[End, Element]): GremlinScala[Property[Any], Labels]

     

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

     

147. def propertyMap(keys: String*)(implicit ev: <:<[End, Element]): GremlinScala[Map[String, Any], Labels]

     

148. def range(scope: Scope, low: Long, high: Long): GremlinScala[End, Labels]

     

149. def range(low: Long, high: Long): GremlinScala[End, Labels]

     

150. def repeat(repeatTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[End, _]): GremlinScala[End, Labels]

     

151. 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. TODO: carry SackType as class type parameter (both ScalaGraph and GremlinScala) [SideEffect]

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

153. def sample(scope: Scope, amount: Int): GremlinScala[End, Labels]

     

154. def sample(amount: Int): GremlinScala[End, Labels]

     

155. def select(pop: Pop, selectKey1: String, selectKey2: String, otherSelectKeys: String*): GremlinScala[Map[String, Any], Labels]

     

156. def select(selectKey1: String, selectKey2: String, otherSelectKeys: String*): GremlinScala[Map[String, Any], Labels]

     

157. def select[A](pop: Pop, selectKey: String)(implicit arg0: DefaultsToAny[A]): GremlinScala[A, Labels]

     

158. def select[A](selectKey: String)(implicit arg0: DefaultsToAny[A]): GremlinScala[A, Labels]

     

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

     

160. def select[A](stepLabel: StepLabel[A]): GremlinScala[A, Labels]

     

161. def select[LabelsTuple]()(implicit tupler: shapeless.ops.hlist.Tupler.Aux[Labels, LabelsTuple]): GremlinScala[LabelsTuple, Labels]

     

162. def sideEffect(fun: (End) ⇒ Any): GremlinScala[End, Labels]

     

163. def sideEffectWithTraverser(fun: (Traverser[End]) ⇒ Any): GremlinScala[End, Labels]

     

164. def simplePath(): GremlinScala[End, Labels]

     

165. def start[A]: GremlinScala[A, HNil]

     

     Attributes

     protected

166. def store(sideEffectKey: String)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

     

167. def subgraph(stepLabel: StepLabel[Graph])(implicit ev: <:<[End, Edge]): GremlinScala[Edge, Labels]

     

168. def sum[N <: Number](scope: Scope)(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]

     

169. def sum[N <: Number]()(implicit toNumber: (End) ⇒ N): GremlinScala[N, HNil]

     

170. final def synchronized[T0](arg0: ⇒ T0): T0

     

     Definition Classes

     AnyRef

171. def tail(scope: Scope, limit: Long): GremlinScala[End, Labels]

     

172. def tail(limit: Long): GremlinScala[End, Labels]

     

173. def tail(): GremlinScala[End, Labels]

     

174. def timeLimit(millis: Long)(implicit ev: <:<[End, Element]): GremlinScala[End, Labels]

     

175. def timeLimit(limit: FiniteDuration): GremlinScala[End, Labels]

     

176. def times(maxLoops: Int): GremlinScala[End, Labels]

     

177. def to(label: StepLabel[Vertex]): GremlinScala[End, Labels]

     

178. def to(direction: Direction, edgeLabels: String*): GremlinScala[Vertex, Labels]

     

179. def toBuffer(): Buffer[End]

     

180. def toJavaList[A](i: Iterable[A]): List[A]

     

     Attributes

     protected

181. def toList(): List[End]

     

182. def toMap[A, B](implicit ev: <:<[End, (A, B)]): Map[A, B]

     

183. def toSet(): Set[End]

     

184. def toStream(): Stream[End]

     

185. val traversal: GraphTraversal[_, End]

     

186. def tree(sideEffectKey: String): GremlinScala[End, Labels]

     

187. def tree(): GremlinScala[Tree[_], Labels]

     

188. def unfold[A](): GremlinScala[A, Labels]

     

189. def union[A](unionTraversals: (GremlinScala[End, HNil]) ⇒ GremlinScala[A, _]*): GremlinScala[A, Labels]

     

190. def until(untilTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]

     

191. def untilWithTraverser(predicate: (Traverser[End]) ⇒ Boolean): GremlinScala[End, Labels]

     

192. def value[A](key: String)(implicit ev: <:<[End, Element]): GremlinScala[A, Labels]

     

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

     

194. def valueMap(keys: String*)(implicit ev: <:<[End, Element]): GremlinScala[Map[String, AnyRef], Labels]

     

195. def valueOption[A](key: String)(implicit ev: <:<[End, Element]): GremlinScala[Option[A], Labels]

     

196. def valueOption[A](key: Key[A])(implicit ev: <:<[End, Element]): GremlinScala[Option[A], Labels]

     

197. def values[A](key: String*)(implicit ev: <:<[End, Element]): GremlinScala[A, Labels]

     

198. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

199. final def wait(arg0: Long, arg1: Int): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

200. final def wait(arg0: Long): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

201. def where(whereTraversal: (GremlinScala[End, HNil]) ⇒ GremlinScala[_, _]): GremlinScala[End, Labels]

     

202. def where(startKey: String, predicate: P[String]): GremlinScala[End, Labels]

     

203. def where(predicate: P[String]): GremlinScala[End, Labels]

     

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

     

     used in scala for comprehensions