com.tinkerpop.gremlin.scala

GremlinScalaPipeline

class GremlinScalaPipeline[S, E] extends Pipeline[S, E] with Dynamic

Linear Supertypes
Dynamic, Pipeline[S, E], MetaPipe, Pipe[S, E], Iterable[E], Iterator[E], AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. GremlinScalaPipeline
  2. Dynamic
  3. Pipeline
  4. MetaPipe
  5. Pipe
  6. Iterable
  7. Iterator
  8. AnyRef
  9. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new GremlinScalaPipeline()

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 E: GremlinScalaPipeline[Edge, Edge]

  5. def V: GremlinScalaPipeline[Vertex, Vertex]

  6. def addPipe[T](pipe: Pipe[_, T]): GremlinScalaPipeline[S, T]

  7. def addPipe(arg0: Int, arg1: Pipe[_, _]): Unit

    Definition Classes
    Pipeline
  8. def addPipe(arg0: Pipe[_, _]): Unit

    Definition Classes
    Pipeline
  9. def addVertexPipe[A <: Element](branchFactor: Int, direction: Direction, labels: String*)(implicit arg0: ClassTag[A]): GremlinScalaPipeline[S, A]

  10. def aggregate[F](buffer: Buffer[F])(fun: (E) ⇒ F): GremlinScalaPipeline[S, E]

    Like aggregate, but applies fun to each element prior to adding it to the Buffer

  11. def aggregate(buffer: Buffer[E]): GremlinScalaPipeline[S, E]

    Adds input into buffer greedily - it will exhaust all the items that come to it from previous steps before emitting the next element.

    Adds input into buffer greedily - it will exhaust all the items that come to it from previous steps before emitting the next element. Note that this is a side effect step: the input will just flow through to the next step, but you can use cap to get the buffer into the pipeline.

    See also

    example in SideEffectTest

  12. def and(pipes: Pipe[E, _]*): GremlinScalaPipeline[S, E]

    Takes a collection of pipes and emits incoming objects that are true for all of the pipes.

  13. def as(name: String): GremlinScalaPipeline[S, E]

  14. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  15. def asMap: AsMap

    Attributes
    protected
  16. def back(numberStep: Int): GremlinScalaPipeline[S, Any]

  17. def back(namedStep: String): GremlinScalaPipeline[S, Any]

  18. implicit def boolean2BooleanFn(fn: (E) ⇒ Boolean)(e: E): Boolean

  19. def both(branchFactor: Int, labels: String*): GremlinScalaPipeline[S, Vertex]

  20. def both(labels: String*): GremlinScalaPipeline[S, Vertex]

  21. def bothE(branchFactor: Int, labels: String*): GremlinScalaPipeline[S, Edge]

  22. def bothE(labels: String*): GremlinScalaPipeline[S, Edge]

  23. def bothV: GremlinScalaPipeline[S, Vertex]

  24. def cap: GremlinScalaPipeline[S, _]

    emits the side-effect of the previous pipe (e.

    emits the side-effect of the previous pipe (e.g. groupBy) - and not the values that flow through it. If you use it, this normally is the last step. @see examples in SideEffectTest

  25. def cast[E](arg0: Class[E]): Pipeline[S, E]

    Definition Classes
    Pipeline
  26. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  27. def copySplit(pipes: Pipe[E, _]*): GremlinScalaPipeline[S, _]

    Copies incoming object to internal pipes.

  28. def count(): Long

    Definition Classes
    Pipeline
  29. def dedup(dedupFunction: Function1[E, _]): GremlinScalaPipeline[S, E]

    only emits the object if the object generated by its function hasn't been seen before.

  30. def dedup: GremlinScalaPipeline[S, E]

  31. def enablePath(arg0: Boolean): Unit

    Definition Classes
    Pipeline → Pipe
  32. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  33. def equals(arg0: Any): Boolean

    Definition Classes
    Pipeline → AnyRef → Any
  34. def except(namedSteps: String*): GremlinScalaPipeline[S, E]

    emits everything except what is in the results of a named step.

    emits everything except what is in the results of a named step.

    not currently supported because ExceptFilterPipe uses ElementHelper.areEqual to compare two elements, which compares if the classes are equal. I'll open a pull request to fix that in blueprints shortly...

  35. def except(iterable: Iterable[E]): GremlinScalaPipeline[S, E]

    emits everything except what is in the supplied collection.

  36. def exhaustMerge: GremlinScalaPipeline[S, _]

  37. def fairMerge: GremlinScalaPipeline[S, _]

    Used in combination with a copySplit, merging the parallel traversals in a round-robin fashion.

  38. def fill(arg0: Collection[E]): Collection[E]

    Definition Classes
    Pipeline
  39. def filter(f: (E) ⇒ Boolean): GremlinScalaPipeline[S, E]

  40. def filterNot(f: (E) ⇒ Boolean): GremlinScalaPipeline[S, E]

  41. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  42. def gather: GremlinScalaPipeline[S, List[E]]

    All the objects previous to this step are aggregated in a greedy fashion and emitted as a List.

    All the objects previous to this step are aggregated in a greedy fashion and emitted as a List. Normally they would be traversed over lazily. Gather/Scatter is good for breadth-first traversals where the gather closure filters out unwanted elements at the current radius.

    See also

    https://github.com/tinkerpop/gremlin/wiki/Depth-First-vs.-Breadth-First

    Note: Gremlin-Groovy comes with an overloaded gather pipe that takes a function to transform the last step. You can achieve the same by just appending a map step.

  43. def get(arg0: Int): Pipe

    Definition Classes
    Pipeline
  44. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  45. def getCurrentPath(): List

    Definition Classes
    Pipeline → Pipe
  46. def getPipes(): List[Pipe]

    Definition Classes
    Pipeline → MetaPipe
  47. def getStarts(): Iterator[S]

    Definition Classes
    Pipeline
  48. def groupBy[K, V](map: Map[K, Collection[V]] = new JHashMap[K, JCollection[V]])(keyFunction: (E) ⇒ K, valueFunction: (E) ⇒ V): GremlinScalaPipeline[S, E]

    Groups input by given keyFunction greedily - it will exhaust all the items that come to it from previous steps before emitting the next element.

    Groups input by given keyFunction greedily - it will exhaust all the items that come to it from previous steps before emitting the next element. Note that this is a side effect step: the input will just flow through to the next step, but you can use cap to get the buffer into the pipeline.

    See also

    example in SideEffectTest

  49. def groupCount: GremlinScalaPipeline[S, E]

    counts each traversed object and stores it in a map

  50. def has(key: String, predicate: Predicate, value: Any): GremlinScalaPipeline[S, E]

    Check if the element has a property with provided key/value that matches the given predicate

  51. def has(key: String, comparison: T, value: Any): GremlinScalaPipeline[S, E]

    Check if the element has a property with provided key/value that matches the given comparison token

  52. def has(key: String, value: Any): GremlinScalaPipeline[S, E]

    Check if the element has a property with provided key/value

  53. def has(key: String): GremlinScalaPipeline[S, E]

    Check if the element has a property with provided key

  54. def hasNext(): Boolean

    Definition Classes
    Pipeline → Iterator
  55. def hasNot(key: String, value: Any): GremlinScalaPipeline[S, E]

    Check if the element does not have a property with provided key/value

  56. def hasNot(key: String): GremlinScalaPipeline[S, E]

    Check if the element does not have a property with provided key.

  57. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  58. def id: GremlinScalaPipeline[S, AnyRef]

  59. def ifThenElse(ifFunction: (E) ⇒ Boolean, thenFunction: Function1[E, _], elseFunction: Function1[E, _]): GremlinScalaPipeline[S, _]

  60. def in(branchFactor: Int, labels: String*): GremlinScalaPipeline[S, Vertex]

  61. def in(labels: String*): GremlinScalaPipeline[S, Vertex]

  62. def in: GremlinScalaPipeline[S, Vertex]

  63. def inE(branchFactor: Int, labels: String*): GremlinScalaPipeline[S, Edge]

  64. def inE(labels: String*): GremlinScalaPipeline[S, Edge]

  65. def inE: GremlinScalaPipeline[S, Edge]

  66. def inV: GremlinScalaPipeline[S, Vertex]

  67. def interval(key: String, startValue: Comparable[_], endValue: Comparable[_]): GremlinScalaPipeline[S, Element]

    checks if a given property is in an interval (startValue: inclusive, endValue: exclusive)

  68. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  69. def iterate(): Unit

    Completely drain the pipeline of its objects - useful when a sideEffect of the pipeline is desired

    Completely drain the pipeline of its objects - useful when a sideEffect of the pipeline is desired

    Definition Classes
    GremlinScalaPipeline → Pipeline
  70. def iterator(): Iterator[E]

    Definition Classes
    Pipeline → Iterable
  71. def label: GremlinScalaPipeline[S, String]

  72. def linkBoth(label: String, other: Vertex): GremlinScalaPipeline[S, Vertex]

    Emit the incoming vertex, but have other vertex provide an incoming and outgoing edge to incoming vertex.

  73. def linkIn(label: String, other: Vertex): GremlinScalaPipeline[S, Vertex]

    Emit the incoming vertex, but have other vertex provide an incoming and outgoing edge to incoming vertex.

  74. def linkOut(label: String, other: Vertex): GremlinScalaPipeline[S, Vertex]

    Emit the incoming vertex, but have other vertex provide an incoming and outgoing edge to incoming vertex.

  75. def loop(namedStep: String, whileFun: (LoopBundle[E]) ⇒ Boolean, emit: (LoopBundle[E]) ⇒ Boolean): GremlinScalaPipeline[S, E]

    Add a LoopPipe to the end of the Pipeline.

    Add a LoopPipe to the end of the Pipeline. Looping is useful for repeating a section of a pipeline. The provided whileFunction determines when to drop out of the loop. The provided emitFunction can be used to emit objects that are still going through a loop. The whileFunction and emitFunctions are provided a LoopBundle object which contains the object in loop along with other useful metadata.

    namedStep

    the number of steps to loop back to

    whileFun

    whether or not to continue looping on the current object

    emit

    whether or not to emit the current object (irrespective of looping)

  76. def loop(namedStep: String, whileFunction: (LoopBundle[E]) ⇒ Boolean): GremlinScalaPipeline[S, E]

    Add a LoopPipe to the end of the Pipeline.

    Add a LoopPipe to the end of the Pipeline. Looping is useful for repeating a section of a pipeline. The provided whileFunction determines when to drop out of the loop. The whileFunction is provided a LoopBundle object which contains the object in loop along with other useful metadata.

    namedStep

    the name of the step to loop back to

    whileFunction

    whether or not to continue looping on the current object

  77. def map[F](function: (E) ⇒ F): GremlinScalaPipeline[S, F]

    map objects over a given function aliases: transform (standard gremlin) and ∘ (category theory)

  78. def memoize(namedStep: String): GremlinScalaPipeline[S, E]

    Remembers a particular mapping from input to output.

    Remembers a particular mapping from input to output. Long or expensive expressions with no side effects can use this step to remember a mapping, which helps reduce load when previously processed objects are passed into it. For situations where memoization may consume large amounts of RAM, consider using an embedded key-value store like JDBM or some other persistent Map implementation.

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

    Definition Classes
    AnyRef
  80. def next(arg0: Int): List[E]

    Definition Classes
    Pipeline
  81. def next(): E

    Definition Classes
    Pipeline → Iterator
  82. final def notify(): Unit

    Definition Classes
    AnyRef
  83. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  84. def optional(namedStep: String): GremlinScalaPipeline[S, _]

    Behaves similar to back except that it does not filter.

    Behaves similar to back except that it does not filter. It will go down a particular path and back up to where it left off. As such, its useful for yielding a side-effect down a particular branch.

  85. def or(pipes: Pipe[E, _]*): GremlinScalaPipeline[S, E]

  86. def order(compare: (E, E) ⇒ Int): GremlinScalaPipeline[S, E]

  87. def order(by: Order = Order.INCR): GremlinScalaPipeline[S, E]

  88. def order: GremlinScalaPipeline[S, E]

  89. def out(branchFactor: Int, labels: String*): GremlinScalaPipeline[S, Vertex]

  90. def out(labels: String*): GremlinScalaPipeline[S, Vertex]

  91. def out: GremlinScalaPipeline[S, Vertex]

  92. def outE(branchFactor: Int, labels: String*): GremlinScalaPipeline[S, Edge]

  93. def outE(labels: String*): GremlinScalaPipeline[S, Edge]

  94. def outE: GremlinScalaPipeline[S, Edge]

  95. def outV: GremlinScalaPipeline[S, Vertex]

  96. def path: GremlinScalaPipeline[S, Seq[_]]

    Gets the objects on each step on the path through the pipeline as lists.

    Gets the objects on each step on the path through the pipeline as lists. Example: graph.v(1).out.path

    >[v[1], v[2]]

    >[v[1], v[4]]

    >[v[1], v[3]]

  97. def property[F](key: String): GremlinScalaPipeline[S, F]

  98. def propertyMap: GremlinScalaPipeline[S, Map[String, Any]]

  99. def propertyMap(keys: String*): GremlinScalaPipeline[S, Map[String, Any]]

  100. def random(bias: Double): GremlinScalaPipeline[S, E]

  101. def range(low: Int, high: Int): GremlinScalaPipeline[S, E]

    only emit a given range of elements

  102. def remove(arg0: Int): Pipe

    Definition Classes
    Pipeline
  103. def remove(): Unit

    Definition Classes
    Pipeline → Iterator
  104. def reset(): Unit

    Definition Classes
    Pipeline → Pipe
  105. def retain(namedSteps: String*): GremlinScalaPipeline[S, E]

    retains everything that is in the results of a named step.

    retains everything that is in the results of a named step.

    not currently supported because RetainFilterPipe uses ElementHelper.areEqual to compare two elements, which compares if the classes are equal. I'll open a pull request to fix that in blueprints shortly...

  106. def retain(iterable: Iterable[E]): GremlinScalaPipeline[S, E]

    retains everything that is in the supplied collection.

  107. def scatter: GremlinScalaPipeline[S, _]

    This will unroll any iterator/iterable/map that is provided to it.

    This will unroll any iterator/iterable/map that is provided to it. Gather/Scatter is good for breadth-first traversals where the gather closure filters out unwanted elements at the current radius.

    See also

    https://github.com/tinkerpop/gremlin/wiki/Depth-First-vs.-Breadth-First

    Note: only for one level - it will not unroll an iterator within an iterator.

  108. def select(steps: String*): GremlinScalaPipeline[S, Row[_]]

    Gets the objects for given named steps on the path through the pipeline as rows.

  109. def select: GremlinScalaPipeline[S, Row[_]]

    Gets the objects on each named step on the path through the pipeline as rows.

  110. def selectDynamic[F](field: String): GremlinScalaPipeline[S, F]

  111. def setPipes(arg0: List[Pipe]): Unit

    Attributes
    protected[com.tinkerpop.pipes.util]
    Definition Classes
    Pipeline
  112. def setStarts(arg0: Iterable[S]): Unit

    Definition Classes
    Pipeline → Pipe
  113. def setStarts(arg0: Iterator[S]): Unit

    Definition Classes
    Pipeline → Pipe
  114. def shuffle: GremlinScalaPipeline[S, List[E]]

    Add a ShufflePipe to the end of the Pipeline.

    Add a ShufflePipe to the end of the Pipeline. All the objects previous to this step are aggregated in a greedy fashion, their order randomized and emitted as a List.

  115. def sideEffect[F](sideEffectFunction: (E) ⇒ F): GremlinScalaPipeline[S, E]

    Emits input, but calls a side effect closure on each input.

  116. def simplePath: GremlinScalaPipeline[S, E]

    simplifies the path by removing cycles

  117. def size(): Int

    Definition Classes
    Pipeline
  118. def start(startObject: S): GremlinScalaPipeline[S, S]

  119. def store[F](buffer: Buffer[F], fun: (E) ⇒ F): GremlinScalaPipeline[S, E]

    Like store , but applies fun to each element prior to adding it to the Buffer

  120. def store(buffer: Buffer[E]): GremlinScalaPipeline[S, E]

    Emits input, but adds input to collection.

    Emits input, but adds input to collection. This is a lazy step, i.e. it adds it to the buffer as the elements are being traversed.

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

    Definition Classes
    AnyRef
  122. def toList[_](): List[E]

    run through pipeline and get results as List

  123. def toList(): List[E]

    Definition Classes
    Pipeline
  124. def toSet[_](): Set[E]

    run through pipeline and get results as Set

  125. def toStream(): Stream[E]

    run through pipeline and get results as Stream

  126. def toString(): String

    Definition Classes
    Pipeline → AnyRef → Any
  127. def transform[F](function: (E) ⇒ F): GremlinScalaPipeline[S, F]

  128. def tree: GremlinScalaPipeline[S, E]

    Emit input, but stores the tree formed by the traversal as a map.

  129. final def wait(): Unit

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  132. def [F](function: (E) ⇒ F): GremlinScalaPipeline[S, F]

Inherited from Dynamic

Inherited from Pipeline[S, E]

Inherited from MetaPipe

Inherited from Pipe[S, E]

Inherited from Iterable[E]

Inherited from Iterator[E]

Inherited from AnyRef

Inherited from Any

Ungrouped