org.apache.tinkerpop.gremlin.process.traversal.lambda

## Class AbstractLambdaTraversal<S,E>

- java.lang.Object
- - org.apache.tinkerpop.gremlin.process.traversal.lambda.AbstractLambdaTraversal<S,E>

- All Implemented Interfaces:
    Serializable, AutoCloseable, Cloneable, Iterator<E>, Traversal<S,E>, Traversal.Admin<S,E>
  Direct Known Subclasses:
    ColumnTraversal, ConstantTraversal, HaltedTraversersCountTraversal, IdentityTraversal, LoopTraversal, PredicateTraversal, TokenTraversal, TrueTraversal, ValueTraversal

      public abstract class AbstractLambdaTraversal<S,E>
      extends Object
      implements Traversal.Admin<S,E>

  Author:
    Marko A. Rodriguez (http://markorodriguez.com)
  See Also:
    Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal

      `Traversal.Admin<S,E>, Traversal.Exceptions, Traversal.Symbols`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Traversal.Admin<S,E>` | `bypassTraversal`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractLambdaTraversal()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addStart(Traverser.Admin<S> start)` Add a single `Traverser.Admin` object to the head of the traversal.
    `<S2,E2> Traversal.Admin<S2,E2>` | `addStep(int index, Step<?,?> step)` Add a `Step` to an arbitrary point in the traversal.
    `void` | `applyStrategies()` Apply the registered `TraversalStrategies` to the traversal.
    `Traversal.Admin<S,E>` | `clone()` Cloning is used to duplicate the traversal typically in OLAP environments.
    `boolean` | `equals(Object object)`
    `Traversal.Admin<S,E>` | `getBypassTraversal()`
    `Bytecode` | `getBytecode()` Get the `Bytecode` associated with the construction of this traversal.
    `Optional<Graph>` | `getGraph()` Gets the `Graph` instance associated to this `Traversal`.
    `TraversalParent` | `getParent()` Get the `TraversalParent` `Step` that is the parent of this traversal.
    `TraversalSideEffects` | `getSideEffects()` Get the `TraversalSideEffects` associated with the traversal.
    `List<Step>` | `getSteps()` Get the `Step` instances associated with this traversal.
    `TraversalStrategies` | `getStrategies()` Get the `TraversalStrategies` associated with this traversal.
    `TraverserGenerator` | `getTraverserGenerator()` Get the `TraverserGenerator` associated with this traversal.
    `Set<TraverserRequirement>` | `getTraverserRequirements()` Get the set of all `TraverserRequirement`s for this traversal.
    `int` | `hashCode()`
    `boolean` | `hasNext()`
    `boolean` | `isLocked()` When the traversal has had its `TraversalStrategies` applied to it, it is locked.
    `boolean` | `isRoot()` Implementations of this class can never be a root-level traversal as they are specialized implementations intended to be child traversals by design.
    `E` | `next()`
    `Traverser.Admin<E>` | `nextTraverser()`
    `<S2,E2> Traversal.Admin<S2,E2>` | `removeStep(int index)` Remove a `Step` from the traversal.
    `void` | `reset()` Call the `Step.reset()` method on every step in the traversal.
    `void` | `setBypassTraversal(Traversal.Admin<S,E> bypassTraversal)`
    `void` | `setGraph(Graph graph)`
    `void` | `setParent(TraversalParent step)` Set the `TraversalParent` `Step` that is the parent of this traversal.
    `void` | `setSideEffects(TraversalSideEffects sideEffects)` Set the `TraversalSideEffects` of this traversal.
    `void` | `setStrategies(TraversalStrategies strategies)` Set the `TraversalStrategies` to be used by this traversal at evaluation time.

    - ### Methods inherited from class java.lang.Object

      `finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin

      `addStarts, addStep, equals, getEndStep, getStartStep, getTraversalSource, getTraverserSetSupplier, removeStep`

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal

      `asAdmin, close, explain, fill, forEachRemaining, forEachRemaining, iterate, next, none, notifyClose, profile, promise, toBulkSet, toList, toSet, toStream, tryNext`

    - ### Methods inherited from interface java.util.Iterator

      `remove`

- - ### Field Detail

    - #### bypassTraversal

          protected Traversal.Admin<S,E> bypassTraversal

  - ### Constructor Detail

    - #### AbstractLambdaTraversal

          public AbstractLambdaTraversal()

  - ### Method Detail

    - #### setBypassTraversal

          public void setBypassTraversal(Traversal.Admin<S,E> bypassTraversal)

    - #### getBypassTraversal

          public Traversal.Admin<S,E> getBypassTraversal()

    - #### getSteps

          public List<Step> getSteps()

      Description copied from interface: `Traversal.Admin`
      Get the `Step` instances associated with this traversal. The steps are ordered according to their linked list structure as defined by `Step.getPreviousStep()` and `Step.getNextStep()`.
      Specified by:
        `getSteps` in interface `Traversal.Admin<S,E>`
      Returns:
        the ordered steps of the traversal

    - #### getBytecode

          public Bytecode getBytecode()

      Description copied from interface: `Traversal.Admin`
      Get the `Bytecode` associated with the construction of this traversal.
      Specified by:
        `getBytecode` in interface `Traversal.Admin<S,E>`
      Returns:
        the byte code representation of the traversal

    - #### reset

          public void reset()

      Description copied from interface: `Traversal.Admin`
      Call the `Step.reset()` method on every step in the traversal.
      Specified by:
        `reset` in interface `Traversal.Admin<S,E>`

    - #### addStep

          public <S2,E2> Traversal.Admin<S2,E2> addStep(int index,
                                                        Step<?,?> step)
                                                 throws IllegalStateException

      Description copied from interface: `Traversal.Admin`
      Add a `Step` to an arbitrary point in the traversal.
      Specified by:
        `addStep` in interface `Traversal.Admin<S,E>`
      Type Parameters:
        `S2` - the new start type of the traversal (if the added step was a start step)
        `E2` - the new end type of the traversal (if the added step was an end step)
      Parameters:
        `index` - the location in the traversal to insert the step
        `step` - the step to add
      Returns:
        the newly modulated traversal
      Throws:
        `IllegalStateException` - if the `TraversalStrategies` have already been applied

    - #### removeStep

          public <S2,E2> Traversal.Admin<S2,E2> removeStep(int index)
                                                    throws IllegalStateException

      Description copied from interface: `Traversal.Admin`
      Remove a `Step` from the traversal.
      Specified by:
        `removeStep` in interface `Traversal.Admin<S,E>`
      Type Parameters:
        `S2` - the new start type of the traversal (if the removed step was a start step)
        `E2` - the new end type of the traversal (if the removed step was an end step)
      Parameters:
        `index` - the location in the traversal of the step to be evicted
      Returns:
        the newly modulated traversal
      Throws:
        `IllegalStateException` - if the `TraversalStrategies` have already been applied

    - #### applyStrategies

          public void applyStrategies()
                               throws IllegalStateException

      Description copied from interface: `Traversal.Admin`
      Apply the registered `TraversalStrategies` to the traversal. Once the strategies are applied, the traversal is "locked" and can no longer have steps added to it. The order of operations for strategy applications should be: globally id steps, apply each strategy in turn to root traversal, then recursively to nested traversals.
      Specified by:
        `applyStrategies` in interface `Traversal.Admin<S,E>`
      Throws:
        `IllegalStateException` - if the `TraversalStrategies` have already been applied

    - #### getTraverserGenerator

          public TraverserGenerator getTraverserGenerator()

      Description copied from interface: `Traversal.Admin`
      Get the `TraverserGenerator` associated with this traversal. The traversal generator creates `Traverser` instances that are respective of the traversal's `TraverserRequirement`.
      Specified by:
        `getTraverserGenerator` in interface `Traversal.Admin<S,E>`
      Returns:
        the generator of traversers

    - #### setSideEffects

          public void setSideEffects(TraversalSideEffects sideEffects)

      Description copied from interface: `Traversal.Admin`
      Set the `TraversalSideEffects` of this traversal.
      Specified by:
        `setSideEffects` in interface `Traversal.Admin<S,E>`
      Parameters:
        `sideEffects` - the sideEffects to set for this traversal.

    - #### getSideEffects

          public TraversalSideEffects getSideEffects()

      Description copied from interface: `Traversal.Admin`
      Get the `TraversalSideEffects` associated with the traversal. This method should not be called externally for purposes of retrieving side-effects as traversal results. Traversal results should only be returned by way of the execution of the traversal itself. Should a side-effect of a traversal be needed it should only be obtained by using `GraphTraversal.cap(String, String...)` so that the side-effect can be included as part of the traversal iteration. Relying on this method to get side-effects in these situations may not result in consistent behavior across all types of executions and environments (e.g. remoting).
      Specified by:
        `getSideEffects` in interface `Traversal.Admin<S,E>`
      Returns:
        The traversal sideEffects

    - #### setStrategies

          public void setStrategies(TraversalStrategies strategies)

      Description copied from interface: `Traversal.Admin`
      Set the `TraversalStrategies` to be used by this traversal at evaluation time.
      Specified by:
        `setStrategies` in interface `Traversal.Admin<S,E>`
      Parameters:
        `strategies` - the strategies to use on this traversal

    - #### getStrategies

          public TraversalStrategies getStrategies()

      Description copied from interface: `Traversal.Admin`
      Get the `TraversalStrategies` associated with this traversal.
      Specified by:
        `getStrategies` in interface `Traversal.Admin<S,E>`
      Returns:
        the strategies associated with this traversal

    - #### setParent

          public void setParent(TraversalParent step)

      Description copied from interface: `Traversal.Admin`
      Set the `TraversalParent` `Step` that is the parent of this traversal. Traversals can be nested and this is the means by which the traversal tree is connected. If there is no parent, then it should be a `EmptyStep`.
      Specified by:
        `setParent` in interface `Traversal.Admin<S,E>`
      Parameters:
        `step` - the traversal holder parent step or `EmptyStep` if it has no parent

    - #### getParent

          public TraversalParent getParent()

      Description copied from interface: `Traversal.Admin`
      Get the `TraversalParent` `Step` that is the parent of this traversal. Traversals can be nested and this is the means by which the traversal tree is walked.
      Specified by:
        `getParent` in interface `Traversal.Admin<S,E>`
      Returns:
        the traversal holder parent step or `EmptyStep` if it has no parent.

    - #### clone

          public Traversal.Admin<S,E> clone()

      Description copied from interface: `Traversal.Admin`
      Cloning is used to duplicate the traversal typically in OLAP environments.
      Specified by:
        `clone` in interface `Traversal.Admin<S,E>`
      Overrides:
        `clone` in class `Object`
      Returns:
        The cloned traversal

    - #### next

          public E next()

      Specified by:
        `next` in interface `Iterator<E>`

    - #### nextTraverser

          public Traverser.Admin<E> nextTraverser()

      Specified by:
        `nextTraverser` in interface `Traversal.Admin<S,E>`

    - #### hasNext

          public boolean hasNext()

      Specified by:
        `hasNext` in interface `Iterator<E>`

    - #### addStart

          public void addStart(Traverser.Admin<S> start)

      Description copied from interface: `Traversal.Admin`
      Add a single `Traverser.Admin` object to the head of the traversal. Users should typically not need to call this method. For dynamic inject of data, they should use `InjectStep`.
      Specified by:
        `addStart` in interface `Traversal.Admin<S,E>`
      Parameters:
        `start` - a traverser to add to the traversal

    - #### isLocked

          public boolean isLocked()

      Description copied from interface: `Traversal.Admin`
      When the traversal has had its `TraversalStrategies` applied to it, it is locked.
      Specified by:
        `isLocked` in interface `Traversal.Admin<S,E>`
      Returns:
        whether the traversal is locked

    - #### isRoot

          public boolean isRoot()

      Implementations of this class can never be a root-level traversal as they are specialized implementations intended to be child traversals by design.
      Specified by:
        `isRoot` in interface `Traversal.Admin<S,E>`

    - #### getGraph

          public Optional<Graph> getGraph()

      Description copied from interface: `Traversal.Admin`
      Gets the `Graph` instance associated to this `Traversal`.
      Specified by:
        `getGraph` in interface `Traversal.Admin<S,E>`

    - #### setGraph

          public void setGraph(Graph graph)

      Specified by:
        `setGraph` in interface `Traversal.Admin<S,E>`

    - #### getTraverserRequirements

          public Set<TraverserRequirement> getTraverserRequirements()

      Description copied from interface: `Traversal.Admin`
      Get the set of all `TraverserRequirement`s for this traversal.
      Specified by:
        `getTraverserRequirements` in interface `Traversal.Admin<S,E>`
      Returns:
        the features of a traverser that are required to execute properly in this traversal

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### equals

          public boolean equals(Object object)

      Overrides:
        `equals` in class `Object`

Copyright © 2013–2022 Apache Software Foundation. All rights reserved.