NodeSteps

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def aggregate(into: Buffer[EndDomain]): NodeSteps[EndDomain, Labels]

Aggregate all objects at this point into the given collection, e.g.

def and(andTraversals: (Steps[EndDomain, Vertex, HNil]) ⇒ Steps[_, _, _]*): Steps[EndDomain, Vertex, Labels]

The and step is a filter with multiple and related filter traversals.

def as[NewLabels <: HList](stepLabel: StepLabel[EndDomain])(implicit prependDomain: shapeless.ops.hlist.Prepend.Aux[Labels, ::[EndDomain, HNil], NewLabels]): Steps[EndDomain, Vertex, NewLabels]

def as[NewLabels <: HList](stepLabel: String)(implicit prependDomain: shapeless.ops.hlist.Prepend.Aux[Labels, ::[EndDomain, HNil], NewLabels]): Steps[EndDomain, Vertex, NewLabels]

final def asInstanceOf[T0]: T0

def clone(): Steps[EndDomain, Vertex, Labels]

implicit val converter: Aux[EndDomain, Vertex]

def count(): Long

def dedup(): Steps[EndDomain, Vertex, Labels]

def emit(emitTraversal: (Steps[EndDomain, Vertex, HNil]) ⇒ Steps[_, _, _]): Steps[EndDomain, Vertex, Labels]

Emit is used with the repeat step to emit the elements of the repeatTraversal after each iteration of the repeat loop.

def emit(): Steps[EndDomain, Vertex, Labels]

Emit is used with the repeat step to emit the elements of the repeatTraversal after each iteration of the repeat loop.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exec(): Unit

def filter(predicate: (Steps[EndDomain, Vertex, Labels]) ⇒ Steps[_, _, _]): Steps[EndDomain, Vertex, Labels]

def filterNot(predicate: (Steps[EndDomain, Vertex, Labels]) ⇒ Steps[_, _, _]): Steps[EndDomain, Vertex, Labels]

def filterOnEnd(predicate: (EndDomain) ⇒ Boolean): NodeSteps[EndDomain, Labels]

def flatMap[NewSteps <: StepsRoot](fun: (EndDomain) ⇒ NewSteps)(implicit constr: Aux[Steps.flatMap.NewSteps.EndDomain0, Labels, Steps.flatMap.NewSteps.EndGraph0, NewSteps], newConverter: Converter[Steps.flatMap.NewSteps.EndDomain0]): NewSteps

final def getClass(): Class[_]

def hashCode(): Int

def head(): EndDomain

def headOption(): Option[EndDomain]

def id(ids: AnyRef*): NodeSteps[EndDomain, Labels]

filter by id

def isDefined: Boolean

final def isInstanceOf[T0]: Boolean

def iterate(): Unit

def l: List[EndDomain]

shortcut for toList

def map[NewEndDomain, NewEndGraph, NewSteps <: StepsRoot](fun: (EndDomain) ⇒ NewEndDomain)(implicit newConverter: Aux[NewEndDomain, NewEndGraph], constr: Aux[NewEndDomain, Labels, NewEndGraph, NewSteps]): NewSteps

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onRaw(fun: (GremlinScala[Vertex]) ⇒ GremlinScala[Vertex]): Steps[EndDomain, Vertex, Labels]

def or(orTraversals: (Steps[EndDomain, Vertex, HNil]) ⇒ Steps[_, _, _]*): Steps[EndDomain, Vertex, Labels]

The or step is a filter with multiple or related filter traversals.

def orderBy[A](fun: (EndDomain) ⇒ A): Steps[EndDomain, Vertex, Labels]

Step that orders nodes according to f.

def p(): List[String]

print the results to stdout

val raw: GremlinScala[Vertex]

def repeat[NewEndDomain >: EndDomain](repeatTraversal: (Steps[EndDomain, Vertex, HNil]) ⇒ Steps[NewEndDomain, Vertex, _])(implicit newConverter: Aux[NewEndDomain, Vertex]): Steps[NewEndDomain, Vertex, Labels]

Repeat the given traversal.

def s(): Stream[EndDomain]

Alias for toStream

def select[StepLabelsTuple <: Product, StepLabels <: HList, H0, T0 <: HList, SelectedTypes <: HList, SelectedTypesTuple <: Product, SelectedGraphTypesTuple <: Product, LabelNames <: HList, Z](stepLabelsTuple: StepLabelsTuple)(implicit toHList: Aux[StepLabelsTuple, StepLabels], hasOne: Aux[StepLabels, H0, T0], hasTwo: IsHCons[T0], extractLabelType: Aux[StepLabels, SelectedTypes], tupler: shapeless.ops.hlist.Tupler.Aux[SelectedTypes, SelectedTypesTuple], conv: Aux[SelectedTypesTuple, SelectedGraphTypesTuple], stepLabelToString: Aux[GetLabelName.type, StepLabels, LabelNames], trav: Aux[LabelNames, List, String], folder: Aux[StepLabels, (HNil, Map[String, Any]), combineLabelWithValue.type, (SelectedTypes, Z)]): Steps[SelectedTypesTuple, SelectedGraphTypesTuple, Labels]

def select[Label, LabelGraph](label: StepLabel[Label])(implicit conv1: Aux[Label, LabelGraph]): Steps[Label, LabelGraph, Labels]

def select[LabelsGraph <: HList, LabelsGraphTuple, LabelsTuple]()(implicit conv1: Aux[Labels, LabelsGraph], tupler1: shapeless.ops.hlist.Tupler.Aux[LabelsGraph, LabelsGraphTuple], tupler2: shapeless.ops.hlist.Tupler.Aux[Labels, LabelsTuple], conv2: Aux[LabelsTuple, LabelsGraphTuple]): Steps[LabelsTuple, LabelsGraphTuple, Labels]

def sideEffect(fun: (EndDomain) ⇒ Any): NodeSteps[EndDomain, Labels]

Extend the traversal with a side-effect step, where fun is a function that performs a side effect.

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

def times(maxLoops: Int): Steps[EndDomain, Vertex, Labels]

Modifier for repeat steps.

def toBuffer(): Buffer[EndDomain]

Execute the traversal and convert it to a mutable buffer

def toList(): List[EndDomain]

def toSet(): Set[EndDomain]

def toStream(): Stream[EndDomain]

def toString(): String

def until(untilTraversal: (Steps[EndDomain, Vertex, HNil]) ⇒ Steps[_, _, _]): Steps[EndDomain, Vertex, Labels]

Termination criteria for a repeat step.

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def walkIn(edgeType: String): GremlinScala[Vertex]

def finalize(): Unit