GremlinFluentPipeline (Gremlin-Java: Gremlin for the Java Language 2.6.0 API)

All Known Implementing Classes:

GremlinPipeline
```
public interface GremlinFluentPipeline<S,E>
```
Author:

Marko A. Rodriguez (http://markorodriguez.com)

Method Summary

Methods
Modifier and Type	Method and Description
`GremlinFluentPipeline<S,E>`	`_()` Add an IdentityPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`aggregate()` Add an AggregatePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`aggregate(Collection<E> aggregate)` Add an AggregatePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`aggregate(Collection aggregate, com.tinkerpop.pipes.PipeFunction<E,?> aggregateFunction)` Add an AggregatePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`aggregate(com.tinkerpop.pipes.PipeFunction<E,?> aggregateFunction)` Add an AggregatePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`and(com.tinkerpop.pipes.Pipe<E,?>... pipes)` Add an AndFilterPipe to the end the Pipeline.
`GremlinFluentPipeline<S,E>`	`as(String name)` Wrap the previous step in an AsPipe.
`GremlinFluentPipeline<S,?>`	`back(int numberedStep)` Deprecated.
`GremlinFluentPipeline<S,?>`	`back(String namedStep)` Add a BackFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex>`	`both(int branchFactor, String... labels)` Add a BothPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex>`	`both(String... labels)` Add a BothPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge>`	`bothE(int branchFactor, String... labels)` Add a BothEdgesPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge>`	`bothE(String... labels)` Add a BothEdgesPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex>`	`bothV()` Add a BothVerticesPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,?>`	`cap()` Add a SideEffectCapPipe to the end of the Pipeline.
`<E> GremlinFluentPipeline<S,E>`	`cast(Class<E> end)` Returns the current pipeline with a new end type.
`GremlinFluentPipeline<S,?>`	`copySplit(com.tinkerpop.pipes.Pipe<E,?>... pipes)` Add a CopySplitPipe to the end of the pipeline.
`long`	`count()` Return the number of objects iterated through the pipeline.
`GremlinFluentPipeline<S,E>`	`dedup()` Add a DuplicateFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`dedup(com.tinkerpop.pipes.PipeFunction<E,?> dedupFunction)` Add a DuplicateFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`enablePath()` Enable path calculations in the pipeline.
`GremlinFluentPipeline<S,E>`	`except(Collection<E> collection)` Add an ExceptFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`except(String... namedSteps)` Add an ExceptFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,?>`	`exhaustMerge()` Add an ExhaustMergePipe to the end of the pipeline.
`GremlinFluentPipeline<S,?>`	`fairMerge()` Add a FairMergePipe to the end of the Pipeline.
`Collection<E>`	`fill(Collection<E> collection)` Fill the provided collection with the objects in the pipeline.
`GremlinFluentPipeline<S,E>`	`filter(com.tinkerpop.pipes.PipeFunction<E,Boolean> filterFunction)` Add an FilterFunctionPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,List>`	`gather()` Add a GatherPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,?>`	`gather(com.tinkerpop.pipes.PipeFunction<List,?> function)` Add a GatherPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`groupBy(Map<?,List<?>> map, com.tinkerpop.pipes.PipeFunction keyFunction, com.tinkerpop.pipes.PipeFunction valueFunction)` Add a GroupByPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`groupBy(Map reduceMap, com.tinkerpop.pipes.PipeFunction keyFunction, com.tinkerpop.pipes.PipeFunction valueFunction, com.tinkerpop.pipes.PipeFunction reduceFunction)` Add a GroupByReducePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`groupBy(com.tinkerpop.pipes.PipeFunction keyFunction, com.tinkerpop.pipes.PipeFunction valueFunction)` Add a GroupByPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`groupBy(com.tinkerpop.pipes.PipeFunction keyFunction, com.tinkerpop.pipes.PipeFunction valueFunction, com.tinkerpop.pipes.PipeFunction reduceFunction)` Add a GroupByReducePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`groupCount()` Add a GroupCountPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`groupCount(Map<?,Number> map)` Add a GroupCountPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`groupCount(Map<?,Number> map, com.tinkerpop.pipes.PipeFunction keyFunction)` Add a GroupCountPipe or GroupCountFunctionPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`groupCount(Map<?,Number> map, com.tinkerpop.pipes.PipeFunction keyFunction, com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.util.structures.Pair<?,Number>,Number> valueFunction)` Add a GroupCountPipe or GroupCountFunctionPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`groupCount(com.tinkerpop.pipes.PipeFunction keyFunction)` Add a GroupCountPipe or GroupCountFunctionPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`groupCount(com.tinkerpop.pipes.PipeFunction keyFunction, com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.util.structures.Pair<?,Number>,Number> valueFunction)` Add a GroupCountPipe or GroupCountFunctionPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`has(String key)` Check if the element has a property with provided key.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`has(String key, Object value)` Add an IdFilterPipe, LabelFilterPipe, or PropertyFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`has(String key, com.tinkerpop.blueprints.Predicate predicate, Object value)` Add an IdFilterPipe, LabelFilterPipe, or PropertyFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`has(String key, Tokens.T compareToken, Object value)` Add an IdFilterPipe, LabelFilterPipe, or PropertyFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`hasNot(String key)` Check if the element does not have a property with provided key.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`hasNot(String key, Object value)` Add an IdFilterPipe, LabelFilterPipe, or PropertyFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,Object>`	`id()` Add an IdPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge>`	`idEdge(com.tinkerpop.blueprints.Graph graph)` Add an IdEdgePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex>`	`idVertex(com.tinkerpop.blueprints.Graph graph)` Add an IdVertexPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,?>`	`ifThenElse(com.tinkerpop.pipes.PipeFunction<E,Boolean> ifFunction, com.tinkerpop.pipes.PipeFunction<E,?> thenFunction, com.tinkerpop.pipes.PipeFunction<E,?> elseFunction)` Add an IfThenElsePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex>`	`in(int branchFactor, String... labels)` Add a InPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex>`	`in(String... labels)` Add a InPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge>`	`inE(int branchFactor, String... labels)` Add a InPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge>`	`inE(String... labels)` Add an InEdgesPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`interval(String key, Comparable startValue, Comparable endValue)` Add an IntervalFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex>`	`inV()` Add an InVertexPipe to the end of the Pipeline.
`void`	`iterate()` Completely drain the pipeline of its objects.
`GremlinFluentPipeline<S,String>`	`label()` Add an LabelPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`linkBoth(String label, String namedStep)` Add a LinkPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`linkBoth(String label, com.tinkerpop.blueprints.Vertex other)` Add a LinkPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`linkIn(String label, String namedStep)` Add a LinkPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`linkIn(String label, com.tinkerpop.blueprints.Vertex other)` Add a LinkPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`linkOut(String label, String namedStep)` Add a LinkPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`linkOut(String label, com.tinkerpop.blueprints.Vertex other)` Add a LinkPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`loop(int numberedStep, com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> whileFunction)` Deprecated.
`GremlinFluentPipeline<S,E>`	`loop(int numberedStep, com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> whileFunction, com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> emitFunction)` Deprecated.
`GremlinFluentPipeline<S,E>`	`loop(String namedStep, com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> whileFunction)` Add a LoopPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`loop(String namedStep, com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> whileFunction, com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> emitFunction)` Add a LoopPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,Map<String,Object>>`	`map(String... keys)` Add a PropertyMapPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`memoize(int numberedStep)` Deprecated.
`GremlinFluentPipeline<S,E>`	`memoize(int numberedStep, Map map)` Deprecated.
`GremlinFluentPipeline<S,E>`	`memoize(String namedStep)` Add a MemoizePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`memoize(String namedStep, Map map)` Add a MemoizePipe to the end of the Pipeline.
`List<E>`	`next(int number)` Return the next X objects in the pipeline as a list.
`GremlinFluentPipeline<S,?>`	`optional(int numberedStep)` Deprecated.
`GremlinFluentPipeline<S,?>`	`optional(String namedStep)` Add an OptionalPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`or(com.tinkerpop.pipes.Pipe<E,?>... pipes)` Add an OrFilterPipe to the end the Pipeline.
`GremlinFluentPipeline<S,E>`	`order()` Add an OrderPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`order(com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.util.structures.Pair<E,E>,Integer> compareFunction)` Add an OrderPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`order(com.tinkerpop.pipes.transform.TransformPipe.Order order)` Add an OrderPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,?>`	`orderMap(com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.util.structures.Pair<Map.Entry,Map.Entry>,Integer> compareFunction)` Add a OrderMapPipe to the end of the Pipeline Given a Map as an input, the map is first ordered and then the keys are emitted in the order.
`GremlinFluentPipeline<S,?>`	`orderMap(com.tinkerpop.pipes.transform.TransformPipe.Order order)` Add a OrderMapPipe to the end of the Pipeline Given a Map as an input, the map is first ordered and then the keys are emitted in the order.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex>`	`out(int branchFactor, String... labels)` Add an OutPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex>`	`out(String... labels)` Add an OutPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge>`	`outE(int branchFactor, String... labels)` Add an OutEdgesPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge>`	`outE(String... labels)` Add an OutEdgesPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex>`	`outV()` Add an OutVertexPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,List>`	`path(com.tinkerpop.pipes.PipeFunction... pathFunctions)` Add a PathPipe or PathPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,Object>`	`property(String key)` Add a PropertyPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`random(Double bias)` Add a RandomFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`range(int low, int high)` Add a RageFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`retain(Collection<E> collection)` Add a RetainFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`retain(String... namedSteps)` Add a RetainFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,?>`	`scatter()` Add a ScatterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.pipes.util.structures.Row>`	`select()` Add a SelectPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.pipes.util.structures.Row>`	`select(Collection<String> stepNames, com.tinkerpop.pipes.PipeFunction... columnFunctions)` Add a SelectPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,com.tinkerpop.pipes.util.structures.Row>`	`select(com.tinkerpop.pipes.PipeFunction... columnFunctions)` Add a SelectPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,List>`	`shuffle()` Add a ShufflePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`sideEffect(com.tinkerpop.pipes.PipeFunction<E,?> sideEffectFunction)` Add a SideEffectFunctionPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`simplePath()` Add a CyclicPathFilterPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,S>`	`start(S object)` Add a StartPipe to the end of the pipeline.
`<T> GremlinFluentPipeline<S,T>`	`step(com.tinkerpop.pipes.Pipe<E,T> pipe)` Add an arbitrary Pipe to the end of the pipeline.
`GremlinFluentPipeline<S,?>`	`step(com.tinkerpop.pipes.PipeFunction function)` Add a FunctionPipe to the end of the pipeline.
`GremlinFluentPipeline<S,E>`	`store()` Add an StorePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`store(Collection<E> storage)` Add a StorePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`store(Collection storage, com.tinkerpop.pipes.PipeFunction<E,?> storageFunction)` Add a StorePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`store(com.tinkerpop.pipes.PipeFunction<E,?> storageFunction)` Add a StorePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`table()` Add a TablePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`table(com.tinkerpop.pipes.PipeFunction... columnFunctions)` Add a TablePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`table(com.tinkerpop.pipes.util.structures.Table table)` Add a TablePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`table(com.tinkerpop.pipes.util.structures.Table table, Collection<String> stepNames, com.tinkerpop.pipes.PipeFunction... columnFunctions)` Add a TablePipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`table(com.tinkerpop.pipes.util.structures.Table table, com.tinkerpop.pipes.PipeFunction... columnFunctions)` Add a TablePipe to the end of the Pipeline.
`List<E>`	`toList()` Return a list of all the objects in the pipeline.
`<T> GremlinFluentPipeline<S,T>`	`transform(com.tinkerpop.pipes.PipeFunction<E,T> function)` Add a TransformFunctionPipe to the end of the Pipeline.
`GremlinFluentPipeline<S,E>`	`tree(com.tinkerpop.pipes.PipeFunction... branchFunctions)` Add a TreePipe to the end of the Pipeline This step maintains an internal tree representation of the paths that have flowed through the step.
`GremlinFluentPipeline<S,E>`	`tree(com.tinkerpop.pipes.util.structures.Tree tree, com.tinkerpop.pipes.PipeFunction... branchFunctions)` Add a TreePipe to the end of the Pipeline This step maintains an internal tree representation of the paths that have flowed through the step.

- Method Detail
  - step
```
GremlinFluentPipeline<S,?> step(com.tinkerpop.pipes.PipeFunction function)
```
    Add a FunctionPipe to the end of the pipeline. The provide provided PipeFunction emits whatever is defined by the function. This serves as an arbitrary step computation.
    
    Parameters:
    function - the function of the FunctionPipe
    
    Returns:
    the extended Pipeline
  - step
```
<T> GremlinFluentPipeline<S,T> step(com.tinkerpop.pipes.Pipe<E,T> pipe)
```
    Add an arbitrary Pipe to the end of the pipeline.
    
    Type Parameters:
    T - the object type emitted by the provided pipe.
    Parameters:
    pipe - The provided pipe.
    
    Returns:
    the extended Pipeline
  - copySplit
```
GremlinFluentPipeline<S,?> copySplit(com.tinkerpop.pipes.Pipe<E,?>... pipes)
```
    Add a CopySplitPipe to the end of the pipeline. The incoming objects are copied to the provided pipes. This "split-pipe" is used in conjunction with some type of "merge-pipe."
    
    Parameters:
    pipes - the internal pipes of the CopySplitPipe
    
    Returns:
    the extended Pipeline
  - exhaustMerge
```
GremlinFluentPipeline<S,?> exhaustMerge()
```
    Add an ExhaustMergePipe to the end of the pipeline. The one-step previous MetaPipe in the pipeline's pipes are used as the internal pipes. The pipes' emitted objects are merged where the first pipe's objects are exhausted, then the second, etc.
    
    Returns:
    the extended Pipeline
  - fairMerge
```
GremlinFluentPipeline<S,?> fairMerge()
```
    Add a FairMergePipe to the end of the Pipeline. The one-step previous MetaPipe in the pipeline's pipes are used as the internal pipes. The pipes' emitted objects are merged in a round robin fashion.
    
    Returns:
    the extended Pipeline
  - ifThenElse
```
GremlinFluentPipeline<S,?> ifThenElse(com.tinkerpop.pipes.PipeFunction<E,Boolean> ifFunction,
                                    com.tinkerpop.pipes.PipeFunction<E,?> thenFunction,
                                    com.tinkerpop.pipes.PipeFunction<E,?> elseFunction)
```
    Add an IfThenElsePipe to the end of the Pipeline. If the ifFunction is true, then the results of the thenFunction are emitted. If the ifFunction is false, then the results of the elseFunction are emitted.
    
    Parameters:
    ifFunction - the function denoting the "if" part of the pipe
    thenFunction - the function denoting the "then" part of the pipe
    elseFunction - the function denoting the "else" part of the pipe
    
    Returns:
    the extended Pipeline
  - loop
```
@Deprecated
GremlinFluentPipeline<S,E> loop(int numberedStep,
                                         com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> whileFunction)
```
    Deprecated.
    
    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.
    
    Parameters:
    numberedStep - the number of steps to loop back to
    whileFunction - whether or not to continue looping on the current object
    
    Returns:
    the extended Pipeline
  - loop
```
GremlinFluentPipeline<S,E> loop(String namedStep,
                              com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> whileFunction)
```
    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.
    
    Parameters:
    namedStep - the name of the step to loop back to
    whileFunction - whether or not to continue looping on the current object
    
    Returns:
    the extended Pipeline
  - loop
```
@Deprecated
GremlinFluentPipeline<S,E> loop(int numberedStep,
                                         com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> whileFunction,
                                         com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> emitFunction)
```
    Deprecated.
    
    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.
    
    Parameters:
    numberedStep - the number of steps to loop back to
    whileFunction - whether or not to continue looping on the current object
    emitFunction - whether or not to emit the current object (irrespective of looping)
    
    Returns:
    the extended Pipeline
  - loop
```
GremlinFluentPipeline<S,E> loop(String namedStep,
                              com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> whileFunction,
                              com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> emitFunction)
```
    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.
    
    Parameters:
    namedStep - the number of steps to loop back to
    whileFunction - whether or not to continue looping on the current object
    emitFunction - whether or not to emit the current object (irrespective of looping)
    
    Returns:
    the extended Pipeline
  - and
```
GremlinFluentPipeline<S,E> and(com.tinkerpop.pipes.Pipe<E,?>... pipes)
```
    Add an AndFilterPipe to the end the Pipeline. If the internal pipes all yield objects, then the object is not filtered. The provided pipes are provided the object as their starts.
    
    Parameters:
    pipes - the internal pipes of the AndFilterPipe
    
    Returns:
    the extended Pipeline
  - back
```
@Deprecated
GremlinFluentPipeline<S,?> back(int numberedStep)
```
    Deprecated.
    
    Add a BackFilterPipe to the end of the Pipeline. The object that was seen numberedSteps ago is emitted.
    
    Parameters:
    numberedStep - the number of steps previous to back up to
    
    Returns:
    the extended Pipeline
  - back
```
GremlinFluentPipeline<S,?> back(String namedStep)
```
    Add a BackFilterPipe to the end of the Pipeline. The object that was seen namedSteps ago is emitted.
    
    Parameters:
    namedStep - the name of the step previous to back up to
    
    Returns:
    the extended Pipeline
  - dedup
```
GremlinFluentPipeline<S,E> dedup()
```
    Add a DuplicateFilterPipe to the end of the Pipeline. Will only emit the object if it has not been seen before.
    
    Returns:
    the extended Pipeline
  - dedup
```
GremlinFluentPipeline<S,E> dedup(com.tinkerpop.pipes.PipeFunction<E,?> dedupFunction)
```
    Add a DuplicateFilterPipe to the end of the Pipeline. Will only emit the object if the object generated by its function hasn't been seen before.
    
    Parameters:
    dedupFunction - a function to call on the object to yield the object to dedup on
    
    Returns:
    the extended Pipeline
  - except
```
GremlinFluentPipeline<S,E> except(Collection<E> collection)
```
    Add an ExceptFilterPipe to the end of the Pipeline. Will only emit the object if it is not in the provided collection.
    
    Parameters:
    collection - the collection except from the stream
    
    Returns:
    the extended Pipeline
  - except
```
GremlinFluentPipeline<S,E> except(String... namedSteps)
```
    Add an ExceptFilterPipe to the end of the Pipeline. Will only emit the object if it is not equal to any of the objects contained at the named steps.
    
    Parameters:
    namedSteps - the named steps in the pipeline
    
    Returns:
    the extended Pipeline
  - filter
```
GremlinFluentPipeline<S,E> filter(com.tinkerpop.pipes.PipeFunction<E,Boolean> filterFunction)
```
    Add an FilterFunctionPipe to the end of the Pipeline. The serves are an arbitrary filter where the filter criteria is provided by the filterFunction.
    
    Parameters:
    filterFunction - the filter function of the pipe
    
    Returns:
    the extended Pipeline
  - or
```
GremlinFluentPipeline<S,E> or(com.tinkerpop.pipes.Pipe<E,?>... pipes)
```
    Add an OrFilterPipe to the end the Pipeline. Will only emit the object if one or more of the provides pipes yields an object. The provided pipes are provided the object as their starts.
    
    Parameters:
    pipes - the internal pipes of the OrFilterPipe
    
    Returns:
    the extended Pipeline
  - random
```
GremlinFluentPipeline<S,E> random(Double bias)
```
    Add a RandomFilterPipe to the end of the Pipeline. A biased coin toss determines if the object is emitted or not.
    
    Parameters:
    bias - the bias of the random coin
    
    Returns:
    the extended Pipeline
  - range
```
GremlinFluentPipeline<S,E> range(int low,
                               int high)
```
    Add a RageFilterPipe to the end of the Pipeline. Analogous to a high/low index lookup.
    
    Parameters:
    low - the low end of the range
    high - the high end of the range
    
    Returns:
    the extended Pipeline
  - retain
```
GremlinFluentPipeline<S,E> retain(Collection<E> collection)
```
    Add a RetainFilterPipe to the end of the Pipeline. Will emit the object only if it is in the provided collection.
    
    Parameters:
    collection - the collection to retain
    
    Returns:
    the extended Pipeline
  - retain
```
GremlinFluentPipeline<S,E> retain(String... namedSteps)
```
    Add a RetainFilterPipe to the end of the Pipeline. Will only emit the object if it is equal to any of the objects contained at the named steps.
    
    Parameters:
    namedSteps - the named steps in the pipeline
    
    Returns:
    the extended Pipeline
  - simplePath
```
GremlinFluentPipeline<S,E> simplePath()
```
    Add a CyclicPathFilterPipe to the end of the Pipeline. If the object's path is repeating (looping), then the object is filtered. Thus, what is emitted are those objects whose history is composed of unique objects.
    
    Returns:
    the extended Pipeline
  - has
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> has(String key)
```
    Check if the element has a property with provided key.
    
    Parameters:
    key - the property key to check
    
    Returns:
    the extended Pipeline
  - hasNot
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> hasNot(String key)
```
    Check if the element does not have a property with provided key.
    
    Parameters:
    key - the property key to check
    
    Returns:
    the extended Pipeline
  - has
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> has(String key,
                                                                      Object value)
```
    Add an IdFilterPipe, LabelFilterPipe, or PropertyFilterPipe to the end of the Pipeline. If the incoming element has the provided key/value as check with .equals(), then let the element pass. If the key is id or label, then use respect id or label filtering.
    
    Parameters:
    key - the property key to check
    value - the object to filter on (in an OR manner)
    
    Returns:
    the extended Pipeline
  - has
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> has(String key,
                                                                      Tokens.T compareToken,
                                                                      Object value)
```
    Add an IdFilterPipe, LabelFilterPipe, or PropertyFilterPipe to the end of the Pipeline. If the incoming element has the provided key/value as check with .equals(), then let the element pass. If the key is id or label, then use respect id or label filtering.
    
    Parameters:
    key - the property key to check
    compareToken - the comparison to use
    value - the object to filter on
    
    Returns:
    the extended Pipeline
  - has
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> has(String key,
                                                                      com.tinkerpop.blueprints.Predicate predicate,
                                                                      Object value)
```
    Add an IdFilterPipe, LabelFilterPipe, or PropertyFilterPipe to the end of the Pipeline. If the incoming element has the provided key/value as check with .equals(), then let the element pass. If the key is id or label, then use respect id or label filtering.
    
    Parameters:
    key - the property key to check
    predicate - the comparison to use
    value - the object to filter on
    
    Returns:
    the extended Pipeline
  - hasNot
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> hasNot(String key,
                                                                         Object value)
```
    Add an IdFilterPipe, LabelFilterPipe, or PropertyFilterPipe to the end of the Pipeline. If the incoming element has the provided key/value as check with .equals(), then filter the element. If the key is id or label, then use respect id or label filtering.
    
    Parameters:
    key - the property key to check
    value - the objects to filter on (in an OR manner)
    
    Returns:
    the extended Pipeline
  - interval
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> interval(String key,
                                                                           Comparable startValue,
                                                                           Comparable endValue)
```
    Add an IntervalFilterPipe to the end of the Pipeline. If the incoming element has a value that is within the interval value range specified, then the element is allows to pass. If hte incoming element's value for the key is null, the element is filtered.
    
    Parameters:
    key - the property key to check
    startValue - the start of the interval (inclusive)
    endValue - the end of the interval (exclusive)
    
    Returns:
    the extended Pipeline
  - gather
```
GremlinFluentPipeline<S,List> gather()
```
    Add a GatherPipe to the end of the Pipeline. All the objects previous to this step are aggregated in a greedy fashion and emitted as a List.
    
    Returns:
    the extended Pipeline
  - gather
```
GremlinFluentPipeline<S,?> gather(com.tinkerpop.pipes.PipeFunction<List,?> function)
```
    Add a GatherPipe to the end of the Pipeline. All the objects previous to this step are aggregated in a greedy fashion into a List. The provided function is applied to the aggregate and the results of the function are emitted. Typically, the output of the function is a pruned List. This is good for selective breadth-first searching.
    
    Parameters:
    function - a transformation to apply to the gathered list
    
    Returns:
    the extended Pipeline
  - _
```
GremlinFluentPipeline<S,E> _()
```
    Add an IdentityPipe to the end of the Pipeline. Useful in various situations where a step is needed without processing. For example, useful when two as-steps are needed in a row.
    
    Returns:
    the extended Pipeline
  - memoize
```
GremlinFluentPipeline<S,E> memoize(String namedStep)
```
    Add a MemoizePipe to the end of the Pipeline. This step will hold a Map of the objects that have entered into its pipeline section. If an input is seen twice, then the map stored output is emitted instead of recomputing the pipeline section.
    
    Parameters:
    namedStep - the name of the step previous to memoize to
    
    Returns:
    the extended Pipeline
  - memoize
```
@Deprecated
GremlinFluentPipeline<S,E> memoize(int numberedStep)
```
    Deprecated.
    
    Add a MemoizePipe to the end of the Pipeline. This step will hold a Map of the objects that have entered into its pipeline section. If an input is seen twice, then the map stored output is emitted instead of recomputing the pipeline section.
    
    Parameters:
    numberedStep - the number of the step previous to memoize to
    
    Returns:
    the extended Pipeline
  - memoize
```
GremlinFluentPipeline<S,E> memoize(String namedStep,
                                 Map map)
```
    Add a MemoizePipe to the end of the Pipeline. This step will hold a Map of the objects that have entered into its pipeline section. If an input is seen twice, then the map stored output is emitted instead of recomputing the pipeline section.
    
    Parameters:
    namedStep - the name of the step previous to memoize to
    map - the memoization map
    
    Returns:
    the extended Pipeline
  - memoize
```
@Deprecated
GremlinFluentPipeline<S,E> memoize(int numberedStep,
                                            Map map)
```
    Deprecated.
    
    Add a MemoizePipe to the end of the Pipeline. This step will hold a Map of the objects that have entered into its pipeline section. If an input is seen twice, then the map stored output is emitted instead of recomputing the pipeline section.
    
    Parameters:
    numberedStep - the number of the step previous to memoize to
    map - the memoization map
    
    Returns:
    the extended Pipeline
  - order
```
GremlinFluentPipeline<S,E> order()
```
    Add an OrderPipe to the end of the Pipeline. This step will sort the objects in the stream in a default Comparable order.
    
    Returns:
    the extended Pipeline
  - order
```
GremlinFluentPipeline<S,E> order(com.tinkerpop.pipes.transform.TransformPipe.Order order)
```
    Add an OrderPipe to the end of the Pipeline. This step will sort the objects in the stream in a default Comparable order.
    
    Parameters:
    order - if the stream is composed of comparable objects, then increment or decrement can be specified
    
    Returns:
    the extended Pipeline
  - order
```
GremlinFluentPipeline<S,E> order(com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.util.structures.Pair<E,E>,Integer> compareFunction)
```
    Add an OrderPipe to the end of the Pipeline. This step will sort the objects in the stream according to a comparator defined in the provided function.
    
    Parameters:
    compareFunction - a comparator function of two objects of type E
    
    Returns:
    the extended Pipeline
  - path
```
GremlinFluentPipeline<S,List> path(com.tinkerpop.pipes.PipeFunction... pathFunctions)
```
    Add a PathPipe or PathPipe to the end of the Pipeline. This will emit the path that has been seen thus far. If path functions are provided, then they are evaluated in a round robin fashion on the objects of the path.
    
    Parameters:
    pathFunctions - the path function of the PathPipe
    
    Returns:
    the extended Pipeline
  - scatter
```
GremlinFluentPipeline<S,?> scatter()
```
    Add a ScatterPipe to the end of the Pipeline. Any inputted iterator or iterable is unrolled and the iterator/iterable's objects are emitted one at a time.
    
    Returns:
    the extended Pipeline
  - select
```
GremlinFluentPipeline<S,com.tinkerpop.pipes.util.structures.Row> select(Collection<String> stepNames,
                                                                      com.tinkerpop.pipes.PipeFunction... columnFunctions)
```
    Add a SelectPipe to the end of the Pipeline. The objects of the named steps (via as) previous in the pipeline are emitted as a Row object. A Row object extends ArrayList and simply provides named columns and some helper methods. If column functions are provided, then they are evaluated in a round robin fashion on the objects of the Row.
    
    Parameters:
    stepNames - the name of the steps in the expression to retrieve the objects from
    columnFunctions - the functions to apply to the column objects prior to filling the Row
    
    Returns:
    the extended Pipeline
  - select
```
GremlinFluentPipeline<S,com.tinkerpop.pipes.util.structures.Row> select(com.tinkerpop.pipes.PipeFunction... columnFunctions)
```
    Add a SelectPipe to the end of the Pipeline. The objects of the named steps (via as) previous in the pipeline are emitted as a Row object. A Row object extends ArrayList and simply provides named columns and some helper methods. If column functions are provided, then they are evaluated in a round robin fashion on the objects of the Row.
    
    Parameters:
    columnFunctions - the functions to apply to the column objects prior to filling the Row
    
    Returns:
    the extended Pipeline
  - select
```
GremlinFluentPipeline<S,com.tinkerpop.pipes.util.structures.Row> select()
```
    Add a SelectPipe to the end of the Pipeline. The objects of the named steps (via as) previous in the pipeline are emitted as a Row object. A Row object extends ArrayList and simply provides named columns and some helper methods.
    
    Returns:
    the extended Pipeline
  - shuffle
```
GremlinFluentPipeline<S,List> shuffle()
```
    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.
    
    Returns:
    the extended Pipeline
  - cap
```
GremlinFluentPipeline<S,?> cap()
```
    Add a SideEffectCapPipe to the end of the Pipeline. When the previous step in the pipeline is implements SideEffectPipe, then it has a method called getSideEffect(). The cap step will greedily iterate the pipeline and then, when its empty, emit the side effect of the previous pipe.
    
    Returns:
    the extended Pipeline
  - orderMap
```
GremlinFluentPipeline<S,?> orderMap(com.tinkerpop.pipes.transform.TransformPipe.Order order)
```
    Add a OrderMapPipe to the end of the Pipeline Given a Map as an input, the map is first ordered and then the keys are emitted in the order.
    
    Parameters:
    order - if the values implement Comparable, then a increment or decrement sort is usable
    
    Returns:
    the extended Pipeline
  - orderMap
```
GremlinFluentPipeline<S,?> orderMap(com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.util.structures.Pair<Map.Entry,Map.Entry>,Integer> compareFunction)
```
    Add a OrderMapPipe to the end of the Pipeline Given a Map as an input, the map is first ordered and then the keys are emitted in the order.
    
    Parameters:
    compareFunction - a function to compare to map entries
    
    Returns:
    the extended Pipeline
  - transform
```
<T> GremlinFluentPipeline<S,T> transform(com.tinkerpop.pipes.PipeFunction<E,T> function)
```
    Add a TransformFunctionPipe to the end of the Pipeline. Given an input, the provided function is computed on the input and the output of that function is emitted.
    
    Parameters:
    function - the transformation function of the pipe
    
    Returns:
    the extended Pipeline
  - bothE
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge> bothE(String... labels)
```
    Add a BothEdgesPipe to the end of the Pipeline. Emit both incoming and outgoing edges for the incoming vertex.
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - bothE
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge> bothE(int branchFactor,
                                                           String... labels)
```
    Add a BothEdgesPipe to the end of the Pipeline. Emit the adjacent incoming edges for the incoming vertex.
    
    Parameters:
    branchFactor - the number of max incident edges for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - both
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex> both(String... labels)
```
    Add a BothPipe to the end of the Pipeline. Emit both the incoming and outgoing adjacent vertices for the incoming vertex.
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - both
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex> both(int branchFactor,
                                                            String... labels)
```
    Add a BothPipe to the end of the Pipeline. Emit the adjacent incoming vertices for the incoming vertex.
    
    Parameters:
    branchFactor - the number of max adjacent vertices for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - bothV
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex> bothV()
```
    Add a BothVerticesPipe to the end of the Pipeline. Emit both the tail and head vertices of the incoming edge.
    
    Returns:
    the extended Pipeline
  - idEdge
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge> idEdge(com.tinkerpop.blueprints.Graph graph)
```
    Add an IdEdgePipe to the end of the Pipeline. Emit the edges of the graph whose ids are those of the incoming id objects.
    
    Parameters:
    graph - the graph of the pipe
    
    Returns:
    the extended Pipeline
  - id
```
GremlinFluentPipeline<S,Object> id()
```
    Add an IdPipe to the end of the Pipeline. Emit the id of the incoming element.
    
    Returns:
    the extended Pipeline
  - idVertex
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex> idVertex(com.tinkerpop.blueprints.Graph graph)
```
    Add an IdVertexPipe to the end of the Pipeline. Emit the vertices of the graph whose ids are those of the incoming id objects.
    
    Parameters:
    graph - the graph of the pipe
    
    Returns:
    the extended Pipeline
  - inE
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge> inE(String... labels)
```
    Add an InEdgesPipe to the end of the Pipeline. Emit the incoming edges for the incoming vertex.
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - inE
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge> inE(int branchFactor,
                                                         String... labels)
```
    Add a InPipe to the end of the Pipeline. Emit the adjacent incoming vertices for the incoming vertex.
    
    Parameters:
    branchFactor - the number of max incident edges for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - in
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex> in(String... labels)
```
    Add a InPipe to the end of the Pipeline. Emit the adjacent incoming vertices for the incoming vertex.
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - in
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex> in(int branchFactor,
                                                          String... labels)
```
    Add a InPipe to the end of the Pipeline. Emit the adjacent incoming vertices for the incoming vertex.
    
    Parameters:
    branchFactor - the number of max adjacent vertices for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - inV
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex> inV()
```
    Add an InVertexPipe to the end of the Pipeline. Emit the head vertex of the incoming edge.
    
    Returns:
    the extended Pipeline
  - label
```
GremlinFluentPipeline<S,String> label()
```
    Add an LabelPipe to the end of the Pipeline. Emit the label of the incoming edge.
    
    Returns:
    the extended Pipeline
  - outE
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge> outE(String... labels)
```
    Add an OutEdgesPipe to the end of the Pipeline. Emit the outgoing edges for the incoming vertex.
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - outE
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Edge> outE(int branchFactor,
                                                          String... labels)
```
    Add an OutEdgesPipe to the end of the Pipeline. Emit the outgoing edges for the incoming vertex.
    
    Parameters:
    branchFactor - the number of max incident edges for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - out
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex> out(String... labels)
```
    Add an OutPipe to the end of the Pipeline. Emit the adjacent outgoing vertices of the incoming vertex.
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - out
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex> out(int branchFactor,
                                                           String... labels)
```
    Add an OutPipe to the end of the Pipeline. Emit the adjacent outgoing vertices of the incoming vertex.
    
    Parameters:
    branchFactor - the number of max adjacent vertices for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - outV
```
GremlinFluentPipeline<S,com.tinkerpop.blueprints.Vertex> outV()
```
    Add an OutVertexPipe to the end of the Pipeline. Emit the tail vertex of the incoming edge.
    
    Returns:
    the extended Pipeline
  - map
```
GremlinFluentPipeline<S,Map<String,Object>> map(String... keys)
```
    Add a PropertyMapPipe to the end of the Pipeline. Emit the properties of the incoming element as a java.util.Map.
    
    Parameters:
    keys - the keys to get from the element (if none provided, all keys retrieved)
    
    Returns:
    the extended Pipeline
  - property
```
GremlinFluentPipeline<S,Object> property(String key)
```
    Add a PropertyPipe to the end of the Pipeline. Emit the respective property of the incoming element.
    
    Parameters:
    key - the property key
    
    Returns:
    the extended Pipeline
  - aggregate
```
GremlinFluentPipeline<S,E> aggregate()
```
    Add an AggregatePipe to the end of the Pipeline. The objects prior to aggregate are greedily collected into an ArrayList.
    
    Returns:
    the extended Pipeline
  - aggregate
```
GremlinFluentPipeline<S,E> aggregate(Collection<E> aggregate)
```
    Add an AggregatePipe to the end of the Pipeline. The objects prior to aggregate are greedily collected into the provided collection.
    
    Parameters:
    aggregate - the collection to aggregate results into
    
    Returns:
    the extended Pipeline
  - aggregate
```
GremlinFluentPipeline<S,E> aggregate(Collection aggregate,
                                   com.tinkerpop.pipes.PipeFunction<E,?> aggregateFunction)
```
    Add an AggregatePipe to the end of the Pipeline. The results of the function evaluated on the objects prior to the aggregate are greedily collected into the provided collection.
    
    Parameters:
    aggregate - the collection to aggregate results into
    aggregateFunction - the function to run over each object prior to insertion into the aggregate
    
    Returns:
    the extended Pipeline
  - aggregate
```
GremlinFluentPipeline<S,E> aggregate(com.tinkerpop.pipes.PipeFunction<E,?> aggregateFunction)
```
    Add an AggregatePipe to the end of the Pipeline. The results of the function evaluated on the objects prior to the aggregate are greedily collected into an ArrayList.
    
    Parameters:
    aggregateFunction - the function to run over each object prior to insertion into the aggregate
    
    Returns:
    the extended Pipeline
  - optional
```
@Deprecated
GremlinFluentPipeline<S,?> optional(int numberedStep)
```
    Deprecated.
    
    Add an OptionalPipe to the end of the Pipeline. The section of pipeline back to the numbered step is evaluated.
    
    Parameters:
    numberedStep - the number of steps previous to optional back to
    
    Returns:
    the extended Pipeline
  - optional
```
GremlinFluentPipeline<S,?> optional(String namedStep)
```
    Add an OptionalPipe to the end of the Pipeline. The section of pipeline back to the partition step is evaluated.
    
    Parameters:
    namedStep - the name of the step previous to optional back to
    
    Returns:
    the extended Pipeline
  - groupBy
```
GremlinFluentPipeline<S,E> groupBy(Map<?,List<?>> map,
                                 com.tinkerpop.pipes.PipeFunction keyFunction,
                                 com.tinkerpop.pipes.PipeFunction valueFunction)
```
    Add a GroupByPipe to the end of the Pipeline. Group the objects inputted objects according to a key generated from the object and a value generated from the object. The grouping map has values that are Lists.
    
    Parameters:
    map - the map to store the grouping in
    keyFunction - the function that generates the key from the object
    valueFunction - the function that generates the value from the function
    
    Returns:
    the extended Pipeline
  - groupBy
```
GremlinFluentPipeline<S,E> groupBy(com.tinkerpop.pipes.PipeFunction keyFunction,
                                 com.tinkerpop.pipes.PipeFunction valueFunction)
```
    Add a GroupByPipe to the end of the Pipeline. Group the objects inputted objects according to a key generated from the object and a value generated from the object. The grouping map has values that are Lists.
    
    Parameters:
    keyFunction - the function that generates the key from the object
    valueFunction - the function that generates the value from the function
    
    Returns:
    the extended Pipeline
  - groupBy
```
GremlinFluentPipeline<S,E> groupBy(Map reduceMap,
                                 com.tinkerpop.pipes.PipeFunction keyFunction,
                                 com.tinkerpop.pipes.PipeFunction valueFunction,
                                 com.tinkerpop.pipes.PipeFunction reduceFunction)
```
    Add a GroupByReducePipe to the end of the Pipeline. Group the objects inputted objects according to a key generated from the object and a value generated from the object. The grouping map has values that are Lists. When the pipe has no more incoming objects, apply the reduce function to the keyed Lists. The sideEffect is only fully available when the pipe is empty.
    
    Parameters:
    reduceMap - a map to perform the reduce operation on (good for having a later reference)
    keyFunction - the function that generates the key from the object
    valueFunction - the function that generates the value from the function
    reduceFunction - the function that reduces the value lists
    
    Returns:
    the extended Pipeline
  - groupBy
```
GremlinFluentPipeline<S,E> groupBy(com.tinkerpop.pipes.PipeFunction keyFunction,
                                 com.tinkerpop.pipes.PipeFunction valueFunction,
                                 com.tinkerpop.pipes.PipeFunction reduceFunction)
```
    Add a GroupByReducePipe to the end of the Pipeline. Group the objects inputted objects according to a key generated from the object and a value generated from the object. The grouping map has values that are Lists. When the pipe has no more incoming objects, apply the reduce function to the keyed Lists. The sideEffect is only fully available when the pipe is empty.
    
    Parameters:
    keyFunction - the function that generates the key from the object
    valueFunction - the function that generates the value from the function
    reduceFunction - the function that reduces the value lists
    
    Returns:
    the extended Pipeline
  - groupCount
```
GremlinFluentPipeline<S,E> groupCount(Map<?,Number> map,
                                    com.tinkerpop.pipes.PipeFunction keyFunction,
                                    com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.util.structures.Pair<?,Number>,Number> valueFunction)
```
    Add a GroupCountPipe or GroupCountFunctionPipe to the end of the Pipeline. A map is maintained of counts. The map keys are determined by the function on the incoming object. The map values are determined by the function on the incoming object (getA()) and the previous value (getB()).
    
    Parameters:
    map - a provided count map
    keyFunction - the key function to determine map key
    valueFunction - the value function to determine map value
    
    Returns:
    the extended Pipeline
  - groupCount
```
GremlinFluentPipeline<S,E> groupCount(com.tinkerpop.pipes.PipeFunction keyFunction,
                                    com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.util.structures.Pair<?,Number>,Number> valueFunction)
```
    Add a GroupCountPipe or GroupCountFunctionPipe to the end of the Pipeline. map is maintained of counts. The map keys are determined by the function on the incoming object. The map values are determined by the function on the incoming object (getA()) and the previous value (getB()).
    
    Parameters:
    keyFunction - the key function to determine map key
    valueFunction - the value function to determine map value
    
    Returns:
    the extended Pipeline
  - groupCount
```
GremlinFluentPipeline<S,E> groupCount(Map<?,Number> map,
                                    com.tinkerpop.pipes.PipeFunction keyFunction)
```
    Add a GroupCountPipe or GroupCountFunctionPipe to the end of the Pipeline. A map is maintained of counts. The map keys are determined by the function on the incoming object. The map values are 1 plus the previous value for that key.
    
    Parameters:
    map - a provided count map
    keyFunction - the key function to determine map key
    
    Returns:
    the extended Pipeline
  - groupCount
```
GremlinFluentPipeline<S,E> groupCount(com.tinkerpop.pipes.PipeFunction keyFunction)
```
    Add a GroupCountPipe or GroupCountFunctionPipe to the end of the Pipeline. A map is maintained of counts. The map keys are determined by the function on the incoming object. The map values are 1 plus the previous value for that key.
    
    Parameters:
    keyFunction - the key function to determine map key
    
    Returns:
    the extended Pipeline
  - groupCount
```
GremlinFluentPipeline<S,E> groupCount(Map<?,Number> map)
```
    Add a GroupCountPipe to the end of the Pipeline. A map is maintained of counts. The map keys are the incoming objects. The map values are 1 plus the previous value for that key.
    
    Parameters:
    map - a provided count map
    
    Returns:
    the extended Pipeline
  - groupCount
```
GremlinFluentPipeline<S,E> groupCount()
```
    Add a GroupCountPipe to the end of the Pipeline. A map is maintained of counts. The map keys are the incoming objects. The map values are 1 plus the previous value for that key.
    
    Returns:
    the extended Pipeline
  - sideEffect
```
GremlinFluentPipeline<S,E> sideEffect(com.tinkerpop.pipes.PipeFunction<E,?> sideEffectFunction)
```
    Add a SideEffectFunctionPipe to the end of the Pipeline. The provided function is evaluated and the incoming object is the outgoing object.
    
    Parameters:
    sideEffectFunction - the function of the pipe
    
    Returns:
    the extended Pipeline
  - store
```
GremlinFluentPipeline<S,E> store(Collection<E> storage)
```
    Add a StorePipe to the end of the Pipeline. Lazily store the incoming objects into the provided collection.
    
    Parameters:
    storage - the collection to store results into
    
    Returns:
    the extended Pipeline
  - store
```
GremlinFluentPipeline<S,E> store(Collection storage,
                               com.tinkerpop.pipes.PipeFunction<E,?> storageFunction)
```
    Add a StorePipe to the end of the Pipeline. Lazily store the object returned by the function over the incoming object into the provided collection.
    
    Parameters:
    storage - the collection to store results into
    storageFunction - the function to run over each object prior to insertion into the storage collection
    
    Returns:
    the extended Pipeline
  - store
```
GremlinFluentPipeline<S,E> store()
```
    Add an StorePipe to the end of the Pipeline. An ArrayList storage collection is provided and filled lazily with incoming objects.
    
    Returns:
    the extended Pipeline
  - store
```
GremlinFluentPipeline<S,E> store(com.tinkerpop.pipes.PipeFunction<E,?> storageFunction)
```
    Add a StorePipe to the end of the Pipeline. An ArrayList storage collection is provided and filled lazily with the return of the function evaluated over the incoming objects.
    
    Parameters:
    storageFunction - the function to run over each object prior to insertion into the storage collection
    
    Returns:
    the extended Pipeline
  - table
```
GremlinFluentPipeline<S,E> table(com.tinkerpop.pipes.util.structures.Table table,
                               Collection<String> stepNames,
                               com.tinkerpop.pipes.PipeFunction... columnFunctions)
```
    Add a TablePipe to the end of the Pipeline. This step is used for grabbing previously seen objects the pipeline as identified by as-steps.
    
    Parameters:
    table - the table to fill
    stepNames - the partition steps to include in the filling
    columnFunctions - the post-processing function for each column
    
    Returns:
    the extended Pipeline
  - table
```
GremlinFluentPipeline<S,E> table(com.tinkerpop.pipes.util.structures.Table table,
                               com.tinkerpop.pipes.PipeFunction... columnFunctions)
```
    Add a TablePipe to the end of the Pipeline. This step is used for grabbing previously seen objects the pipeline as identified by as-steps.
    
    Parameters:
    table - the table to fill
    columnFunctions - the post-processing function for each column
    
    Returns:
    the extended Pipeline
  - table
```
GremlinFluentPipeline<S,E> table(com.tinkerpop.pipes.PipeFunction... columnFunctions)
```
    Add a TablePipe to the end of the Pipeline. This step is used for grabbing previously seen objects the pipeline as identified by as-steps.
    
    Parameters:
    columnFunctions - the post-processing function for each column
    
    Returns:
    the extended Pipeline
  - table
```
GremlinFluentPipeline<S,E> table(com.tinkerpop.pipes.util.structures.Table table)
```
    Add a TablePipe to the end of the Pipeline. This step is used for grabbing previously seen objects the pipeline as identified by as-steps.
    
    Parameters:
    table - the table to fill
    
    Returns:
    the extended Pipeline
  - table
```
GremlinFluentPipeline<S,E> table()
```
    Add a TablePipe to the end of the Pipeline. This step is used for grabbing previously seen objects the pipeline as identified by as-steps.
    
    Returns:
    the extended Pipeline
  - tree
```
GremlinFluentPipeline<S,E> tree(com.tinkerpop.pipes.util.structures.Tree tree,
                              com.tinkerpop.pipes.PipeFunction... branchFunctions)
```
    Add a TreePipe to the end of the Pipeline This step maintains an internal tree representation of the paths that have flowed through the step.
    
    Parameters:
    tree - an embedded Map data structure to store the tree representation in
    branchFunctions - functions to apply to each path object in a round robin fashion
    
    Returns:
    the extended Pipeline
  - tree
```
GremlinFluentPipeline<S,E> tree(com.tinkerpop.pipes.PipeFunction... branchFunctions)
```
    Add a TreePipe to the end of the Pipeline This step maintains an internal tree representation of the paths that have flowed through the step.
    
    Parameters:
    branchFunctions - functions to apply to each path object in a round robin fashion
    
    Returns:
    the extended Pipeline
  - linkOut
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> linkOut(String label,
                                                                          String namedStep)
```
    Add a LinkPipe to the end of the Pipeline. Emit the incoming vertex, but have other vertex provide an outgoing edge to incoming vertex.
    
    Parameters:
    label - the edge label
    namedStep - the step name that has the other vertex to link to
    
    Returns:
    the extended Pipeline
  - linkIn
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> linkIn(String label,
                                                                         String namedStep)
```
    Add a LinkPipe to the end of the Pipeline. Emit the incoming vertex, but have other vertex provide an incoming edge to incoming vertex.
    
    Parameters:
    label - the edge label
    namedStep - the step name that has the other vertex to link to
    
    Returns:
    the extended Pipeline
  - linkBoth
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> linkBoth(String label,
                                                                           String namedStep)
```
    Add a LinkPipe to the end of the Pipeline. Emit the incoming vertex, but have other vertex provide an incoming and outgoing edge to incoming vertex.
    
    Parameters:
    label - the edge label
    namedStep - the step name that has the other vertex to link to
    
    Returns:
    the extended Pipeline
  - linkOut
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> linkOut(String label,
                                                                          com.tinkerpop.blueprints.Vertex other)
```
    Add a LinkPipe to the end of the Pipeline. Emit the incoming vertex, but have other vertex provide an outgoing edge to incoming vertex.
    
    Parameters:
    label - the edge label
    other - the other vertex
    
    Returns:
    the extended Pipeline
  - linkIn
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> linkIn(String label,
                                                                         com.tinkerpop.blueprints.Vertex other)
```
    Add a LinkPipe to the end of the Pipeline. Emit the incoming vertex, but have other vertex provide an incoming edge to incoming vertex.
    
    Parameters:
    label - the edge label
    other - the other vertex
    
    Returns:
    the extended Pipeline
  - linkBoth
```
GremlinFluentPipeline<S,? extends com.tinkerpop.blueprints.Element> linkBoth(String label,
                                                                           com.tinkerpop.blueprints.Vertex other)
```
    Add a LinkPipe to the end of the Pipeline. Emit the incoming vertex, but have other vertex provide an incoming and outgoing edge to incoming vertex.
    
    Parameters:
    label - the edge label
    other - the other vertex
    
    Returns:
    the extended Pipeline
  - as
```
GremlinFluentPipeline<S,E> as(String name)
```
    Wrap the previous step in an AsPipe. Useful for naming steps and is used in conjunction with various other steps including: loop, select, back, table, etc.
    
    Parameters:
    name - the name of the AsPipe
    
    Returns:
    the extended Pipeline
  - start
```
GremlinFluentPipeline<S,S> start(S object)
```
    Add a StartPipe to the end of the pipeline. Though, in practice, a StartPipe is usually the beginning. Moreover, the constructor of the Pipeline will internally use StartPipe.
    
    Parameters:
    object - the object that serves as the start of the pipeline (iterator/iterable are unfolded)
    
    Returns:
    the extended Pipeline
  - count
```
long count()
```
    Return the number of objects iterated through the pipeline.
    
    Returns:
    the number of objects iterated
  - iterate
```
void iterate()
```
    Completely drain the pipeline of its objects. Useful when a sideEffect of the pipeline is desired.
  - next
```
List<E> next(int number)
```
    Return the next X objects in the pipeline as a list.
    
    Parameters:
    number - the number of objects to return
    
    Returns:
    a list of X objects (if X objects occur)
  - toList
```
List<E> toList()
```
    Return a list of all the objects in the pipeline.
    
    Returns:
    a list of all the objects
  - fill
```
Collection<E> fill(Collection<E> collection)
```
    Fill the provided collection with the objects in the pipeline.
    
    Parameters:
    collection - the collection to fill
    
    Returns:
    the collection filled
  - enablePath
```
GremlinFluentPipeline<S,E> enablePath()
```
    Enable path calculations in the pipeline. This is typically handled automatically and on rare occasions requires an explicit call.
    
    Returns:
    the path-enabled Pipeline
  - cast
```
<E> GremlinFluentPipeline<S,E> cast(Class<E> end)
```
    Returns the current pipeline with a new end type. Useful if the end type of the pipeline cannot be implicitly derived.
    
    Returns:
    returns the current pipeline with the new end type.

Interface GremlinFluentPipeline<S,E>

Method Summary

Method Detail

step

step

copySplit

exhaustMerge

fairMerge

ifThenElse

loop

loop

loop

loop

and

back

back

dedup

dedup

except

except

filter

or

random

range

retain

retain

simplePath

has

hasNot

has

has

has

hasNot

interval

gather

gather

_

memoize

memoize

memoize

memoize

order

order

order

path

scatter

select

select

select

shuffle

cap

orderMap

orderMap

transform

bothE

bothE

both

both

bothV

idEdge

id

idVertex

inE

inE

in

in

inV

label

outE

outE

out

out

outV

map

property

aggregate

aggregate

aggregate

aggregate

optional