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]

    

    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

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

    

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

    

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

    

59. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

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

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

    

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

    

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

    

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

    

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

    

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

    

    Definition Classes

    AnyRef → Any

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

92. def head(): End

    

93. def headOption(): Option[End]

    

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

    

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

    

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

    

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

    

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

    

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

    

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

     

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

     

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

     

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

     

104. final def isInstanceOf[T0]: Boolean

     

     Definition Classes

     Any

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

     Definition Classes

     AnyRef

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

     

123. def notExists(): Boolean

     

124. final def notify(): Unit

     

     Definition Classes

     AnyRef

125. final def notifyAll(): Unit

     

     Definition Classes

     AnyRef

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

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

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

     Attributes

     protected

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

     

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

     

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

     

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

     

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

     

     Definition Classes

     AnyRef

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

180. def toBuffer(): Buffer[End]

     

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

     

     Attributes

     protected

182. def toList(): List[End]

     

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

     

184. def toSet(): Set[End]

     

185. def toStream(): Stream[End]

     

186. val traversal: GraphTraversal[_, End]

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

199. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

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

     

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

     

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

     

     used in scala for comprehensions