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

java.lang.Object
- com.tinkerpop.pipes.util.Pipeline<S,E>
- - com.tinkerpop.gremlin.java.GremlinPipeline<S,E>

All Implemented Interfaces:

GremlinFluentPipeline<S,E>, com.tinkerpop.pipes.Pipe<S,E>, com.tinkerpop.pipes.util.MetaPipe, Iterable<E>, Iterator<E>
```
public class GremlinPipeline<S,E>
extends com.tinkerpop.pipes.util.Pipeline<S,E>
implements GremlinFluentPipeline<S,E>
```
Author:

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

Field Summary

Fields
Modifier and Type Field and Description

protected com.tinkerpop.pipes.util.structures.AsMap asMap
- Fields inherited from class com.tinkerpop.pipes.util.Pipeline
  endPipe, pathEnabled, pipes, startPipe, starts
- Fields inherited from interface com.tinkerpop.pipes.Pipe
  NO_PATH_MESSAGE

Fields
Modifier and Type	Field and Description
`protected com.tinkerpop.pipes.util.structures.AsMap`	`asMap`

Constructor Summary

Constructors
Constructor and Description

GremlinPipeline()

GremlinPipeline(Object starts)

GremlinPipeline(Object starts, boolean doQueryOptimization)

Constructors
Constructor and Description
`GremlinPipeline()`
`GremlinPipeline(Object starts)`
`GremlinPipeline(Object starts, boolean doQueryOptimization)`

Method Summary

Methods
Modifier and Type	Method and Description
`GremlinPipeline<S,E>`	`_()` Add an IdentityPipe to the end of the Pipeline.
`<T> GremlinPipeline<S,T>`	`add(com.tinkerpop.pipes.Pipe<?,T> pipe)` Add an arbitrary pipe to the GremlinPipeline
`GremlinPipeline<S,E>`	`aggregate()` Add an AggregatePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`aggregate(Collection<E> aggregate)` Add an AggregatePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`aggregate(Collection aggregate, com.tinkerpop.pipes.PipeFunction<E,?> aggregateFunction)` Add an AggregatePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`aggregate(com.tinkerpop.pipes.PipeFunction<E,?> aggregateFunction)` Add an AggregatePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`and(com.tinkerpop.pipes.Pipe<E,?>... pipes)` Add an AndFilterPipe to the end the Pipeline.
`GremlinPipeline<S,E>`	`as(String name)` Wrap the previous step in an AsPipe.
`GremlinPipeline<S,?>`	`back(int numberedStep)` Deprecated.
`GremlinPipeline<S,?>`	`back(String namedStep)` Add a BackFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`both(int branchFactor, String... labels)` Add a BothPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`both(String... labels)` Add a BothPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Edge>`	`bothE(int branchFactor, String... labels)` Add a BothEdgesPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Edge>`	`bothE(String... labels)` Add a BothEdgesPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`bothV()` Add a BothVerticesPipe to the end of the Pipeline.
`GremlinPipeline<S,?>`	`cap()` Add a SideEffectCapPipe to the end of the Pipeline.
`<E> GremlinPipeline<S,E>`	`cast(Class<E> end)` Returns the current pipeline with a new end type.
`GremlinPipeline<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.
`GremlinPipeline<S,E>`	`dedup()` Add a DuplicateFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`dedup(com.tinkerpop.pipes.PipeFunction<E,?> dedupFunction)` Add a DuplicateFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Edge>`	`E()` Add a GraphQueryPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Edge>`	`E(String key, Object value)` Add a GraphQueryPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`enablePath()` Enable path calculations within the Pipeline.
`GremlinPipeline<S,E>`	`except(Collection<E> collection)` Add an ExceptFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`except(String... namedSteps)` Add an ExceptFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,?>`	`exhaustMerge()` Add an ExhaustMergePipe to the end of the pipeline.
`GremlinPipeline<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.
`GremlinPipeline<S,E>`	`filter(com.tinkerpop.pipes.PipeFunction<E,Boolean> filterFunction)` Add an FilterFunctionPipe to the end of the Pipeline.
`GremlinPipeline<S,List>`	`gather()` Add a GatherPipe to the end of the Pipeline.
`GremlinPipeline<S,?>`	`gather(com.tinkerpop.pipes.PipeFunction<List,?> function)` Add a GatherPipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<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.
`GremlinPipeline<S,E>`	`groupBy(com.tinkerpop.pipes.PipeFunction keyFunction, com.tinkerpop.pipes.PipeFunction valueFunction)` Add a GroupByPipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<S,E>`	`groupCount()` Add a GroupCountPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`groupCount(Map<?,Number> map)` Add a GroupCountPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`groupCount(Map<?,Number> map, com.tinkerpop.pipes.PipeFunction keyFunction)` Add a GroupCountPipe or GroupCountFunctionPipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<S,E>`	`groupCount(com.tinkerpop.pipes.PipeFunction keyFunction)` Add a GroupCountPipe or GroupCountFunctionPipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`has(String key)` Check if the element has a property with provided key.
`GremlinPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`has(String key, Object value)` Add an IdFilterPipe, LabelFilterPipe, or PropertyFilterPipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<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.
`GremlinPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`hasNot(String key)` Check if the element does not have a property with provided key.
`GremlinPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`hasNot(String key, Object value)` Add an IdFilterPipe, LabelFilterPipe, or PropertyFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,Object>`	`id()` Add an IdPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Edge>`	`idEdge(com.tinkerpop.blueprints.Graph graph)` Add an IdEdgePipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`idVertex(com.tinkerpop.blueprints.Graph graph)` Add an IdVertexPipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`in(int branchFactor, String... labels)` Add a InPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`in(String... labels)` Add a InPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Edge>`	`inE(int branchFactor, String... labels)` Add an InEdgesPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Edge>`	`inE(String... labels)` Add an InEdgesPipe to the end of the Pipeline.
`GremlinPipeline<S,? extends com.tinkerpop.blueprints.Element>`	`interval(String key, Comparable startValue, Comparable endValue)` Add an IntervalFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`inV()` Add an InVertexPipe to the end of the Pipeline.
`void`	`iterate()` Completely drain the pipeline of its objects.
`GremlinPipeline<S,String>`	`label()` Add an LabelPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`linkBoth(String label, String namedStep)` Add a LinkPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`linkBoth(String label, com.tinkerpop.blueprints.Vertex other)` Add a LinkPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`linkIn(String label, String namedStep)` Add a LinkPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`linkIn(String label, com.tinkerpop.blueprints.Vertex other)` Add a LinkPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`linkOut(String label, String namedStep)` Add a LinkPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`linkOut(String label, com.tinkerpop.blueprints.Vertex other)` Add a LinkPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`loop(int numberedStep, com.tinkerpop.pipes.PipeFunction<com.tinkerpop.pipes.branch.LoopPipe.LoopBundle<E>,Boolean> whileFunction)` Deprecated.
`GremlinPipeline<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.
`GremlinPipeline<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.
`GremlinPipeline<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.
`GremlinPipeline<S,Map<String,Object>>`	`map(String... keys)` Add a PropertyMapPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`memoize(int numberedStep)` Deprecated.
`GremlinPipeline<S,E>`	`memoize(int numberedStep, Map map)` Deprecated.
`GremlinPipeline<S,E>`	`memoize(String namedStep)` Add a MemoizePipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<S,E>`	`optimize(boolean optimize)` When possible, Gremlin takes advantage of certain sequences of pipes in order to make a more concise, and generally more efficient expression.
`GremlinPipeline<S,?>`	`optional(int numberedStep)` Deprecated.
`GremlinPipeline<S,?>`	`optional(String namedStep)` Add an OptionalPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`or(com.tinkerpop.pipes.Pipe<E,?>... pipes)` Add an OrFilterPipe to the end the Pipeline.
`GremlinPipeline<S,E>`	`order()` Add an OrderPipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<S,E>`	`order(Tokens.T order)` Add an OrderPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`order(com.tinkerpop.pipes.transform.TransformPipe.Order order)` Add an OrderPipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<S,?>`	`orderMap(Tokens.T 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.
`GremlinPipeline<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.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`out(int branchFactor, String... labels)` Add an OutPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`out(String... labels)` Add an OutPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Edge>`	`outE(int branchFactor, String... labels)` Add an OutEdgesPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Edge>`	`outE(String... labels)` Add an OutEdgesPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`outV()` Add an OutVertexPipe to the end of the Pipeline.
`GremlinPipeline<S,List>`	`path(com.tinkerpop.pipes.PipeFunction... pathFunctions)` Add a PathPipe to the end of the Pipeline.
`GremlinPipeline<S,Object>`	`property(String key)` Add a PropertyPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`random(Double bias)` Add a RandomFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`range(int low, int high)` Add a RageFilterPipe to the end of the Pipeline.
`void`	`remove()` Remove every element at the end of this Pipeline.
`GremlinPipeline<S,E>`	`retain(Collection<E> collection)` Add a RetainFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`retain(String... namedSteps)` Add a RetainFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,?>`	`scatter()` Add a ScatterPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.pipes.util.structures.Row>`	`select()` Add a SelectPipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<S,com.tinkerpop.pipes.util.structures.Row>`	`select(com.tinkerpop.pipes.PipeFunction... columnFunctions)` Add a SelectPipe to the end of the Pipeline.
`GremlinPipeline<S,List>`	`shuffle()` Add a ShufflePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`sideEffect(com.tinkerpop.pipes.PipeFunction<E,?> sideEffectFunction)` Add a SideEffectFunctionPipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`simplePath()` Add a CyclicPathFilterPipe to the end of the Pipeline.
`GremlinPipeline<S,S>`	`start(S object)` Add a StartPipe to the end of the pipeline.
`<T> GremlinPipeline<S,T>`	`step(com.tinkerpop.pipes.Pipe<E,T> pipe)` Add an arbitrary Pipe to the end of the pipeline.
`GremlinPipeline<S,?>`	`step(com.tinkerpop.pipes.PipeFunction function)` Add a FunctionPipe to the end of the pipeline.
`GremlinPipeline<S,E>`	`store()` Add an StorePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`store(Collection<E> storage)` Add a StorePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`store(Collection storage, com.tinkerpop.pipes.PipeFunction<E,?> storageFunction)` Add a StorePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`store(com.tinkerpop.pipes.PipeFunction<E,?> storageFunction)` Add a StorePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`table()` Add a TablePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`table(com.tinkerpop.pipes.PipeFunction... columnFunctions)` Add a TablePipe to the end of the Pipeline.
`GremlinPipeline<S,E>`	`table(com.tinkerpop.pipes.util.structures.Table table)` Add a TablePipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<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> GremlinPipeline<S,T>`	`transform(com.tinkerpop.pipes.PipeFunction<E,T> function)` Add a TransformFunctionPipe to the end of the Pipeline.
`GremlinPipeline<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.
`GremlinPipeline<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.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`V()` Add a GraphQueryPipe to the end of the Pipeline.
`GremlinPipeline<S,com.tinkerpop.blueprints.Vertex>`	`V(String key, Object value)` Add a GraphQueryPipe to the end of the Pipeline.

Methods inherited from class com.tinkerpop.pipes.util.Pipeline
addPipe, addPipe, enablePath, equals, get, getCurrentPath, getPipes, getStarts, hasNext, iterator, next, remove, reset, setPipes, setStarts, setStarts, size, toString

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - asMap
```
protected final com.tinkerpop.pipes.util.structures.AsMap asMap
```
- Constructor Detail
  - GremlinPipeline
```
public GremlinPipeline()
```
  - GremlinPipeline
```
public GremlinPipeline(Object starts,
               boolean doQueryOptimization)
```
  - GremlinPipeline
```
public GremlinPipeline(Object starts)
```
- Method Detail
  - add
```
public <T> GremlinPipeline<S,T> add(com.tinkerpop.pipes.Pipe<?,T> pipe)
```
    Add an arbitrary pipe to the GremlinPipeline
    
    Type Parameters:
    T - the type of the end of the pipe
    Parameters:
    pipe - the pipe to add to the pipeline
    
    Returns:
    the extended Pipeline
  - V
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> V()
```
    Add a GraphQueryPipe to the end of the Pipeline. If optimizations are enabled, then the the next steps can fold into a GraphQueryPipe compilation.
    
    Returns:
    the extended Pipeline
  - E
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Edge> E()
```
    Add a GraphQueryPipe to the end of the Pipeline. If optimizations are enabled, then the the next steps can fold into a GraphQueryPipe compilation.
    
    Returns:
    the extended Pipeline
  - V
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> V(String key,
                                                   Object value)
```
    Add a GraphQueryPipe to the end of the Pipeline. If optimizations are enabled, then the the next steps can fold into a GraphQueryPipe compilation.
    
    Parameters:
    key - they key that all the emitted vertices should be checked on
    value - the value that all the emitted vertices should have for the key
    
    Returns:
    the extended Pipeline
  - E
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Edge> E(String key,
                                                 Object value)
```
    Add a GraphQueryPipe to the end of the Pipeline. If optimizations are enabled, then the the next steps can fold into a GraphQueryPipe compilation.
    
    Parameters:
    key - they key that all the emitted edges should be checked on
    value - the value that all the emitted edges should have for the key
    
    Returns:
    the extended Pipeline
  - has
```
public GremlinPipeline<S,? extends com.tinkerpop.blueprints.Element> has(String key)
```
    Check if the element has a property with provided key.
    
    Specified by:
    
    has in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    key - the property key to check
    
    Returns:
    the extended Pipeline
  - has
```
public GremlinPipeline<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.
    
    Specified by:
    
    has in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    key - the property key to check
    value - the object to filter on (in an OR manner)
    
    Returns:
    the extended Pipeline
  - has
```
public GremlinPipeline<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.
    
    Specified by:
    
    has in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    key - the property key to check
    compareToken - the comparison to use
    value - the object to filter on
    
    Returns:
    the extended Pipeline
  - has
```
public GremlinPipeline<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.
    
    Specified by:
    
    has in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    key - the property key to check
    predicate - the comparison to use
    value - the object to filter on
    
    Returns:
    the extended Pipeline
  - hasNot
```
public GremlinPipeline<S,? extends com.tinkerpop.blueprints.Element> hasNot(String key)
```
    Check if the element does not have a property with provided key.
    
    Specified by:
    
    hasNot in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    key - the property key to check
    
    Returns:
    the extended Pipeline
  - hasNot
```
public GremlinPipeline<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.
    
    Specified by:
    
    hasNot in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    key - the property key to check
    value - the objects to filter on (in an OR manner)
    
    Returns:
    the extended Pipeline
  - interval
```
public GremlinPipeline<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.
    
    Specified by:
    
    interval in interface GremlinFluentPipeline<S,E>
    
    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
  - bothE
```
public GremlinPipeline<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.
    
    Specified by:
    
    bothE in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - bothE
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Edge> bothE(int branchFactor,
                                                     String... labels)
```
    Add a BothEdgesPipe to the end of the Pipeline. Emit both incoming and outgoing edges for the incoming vertex.
    
    Specified by:
    
    bothE in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    branchFactor - the number of max incident edges for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - both
```
public GremlinPipeline<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.
    
    Specified by:
    
    both in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - both
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> both(int branchFactor,
                                                      String... labels)
```
    Add a BothPipe to the end of the Pipeline. Emit both the incoming and outgoing adjacent vertices for the incoming vertex.
    
    Specified by:
    
    both in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    branchFactor - the number of max adjacent vertices for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - bothV
```
public GremlinPipeline<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.
    
    Specified by:
    
    bothV in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - idEdge
```
public GremlinPipeline<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.
    
    Specified by:
    
    idEdge in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    graph - the graph of the pipe
    
    Returns:
    the extended Pipeline
  - id
```
public GremlinPipeline<S,Object> id()
```
    Add an IdPipe to the end of the Pipeline. Emit the id of the incoming element.
    
    Specified by:
    
    id in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - idVertex
```
public GremlinPipeline<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.
    
    Specified by:
    
    idVertex in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    graph - the graph of the pipe
    
    Returns:
    the extended Pipeline
  - inE
```
public GremlinPipeline<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.
    
    Specified by:
    
    inE in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - inE
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Edge> inE(int branchFactor,
                                                   String... labels)
```
    Add an InEdgesPipe to the end of the Pipeline. Emit the incoming edges for the incoming vertex.
    
    Specified by:
    
    inE in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    branchFactor - the number of max incident edges for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - in
```
public GremlinPipeline<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.
    
    Specified by:
    
    in in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - in
```
public GremlinPipeline<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.
    
    Specified by:
    
    in in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    branchFactor - the number of max adjacent vertices for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - inV
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> inV()
```
    Add an InVertexPipe to the end of the Pipeline. Emit the head vertex of the incoming edge.
    
    Specified by:
    
    inV in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - label
```
public GremlinPipeline<S,String> label()
```
    Add an LabelPipe to the end of the Pipeline. Emit the label of the incoming edge.
    
    Specified by:
    
    label in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - outE
```
public GremlinPipeline<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.
    
    Specified by:
    
    outE in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - outE
```
public GremlinPipeline<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.
    
    Specified by:
    
    outE in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    branchFactor - the number of max incident edges for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - out
```
public GremlinPipeline<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.
    
    Specified by:
    
    out in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - out
```
public GremlinPipeline<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.
    
    Specified by:
    
    out in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    branchFactor - the number of max adjacent vertices for each incoming vertex
    labels - the edge labels to traverse
    
    Returns:
    the extended Pipeline
  - outV
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> outV()
```
    Add an OutVertexPipe to the end of the Pipeline. Emit the tail vertex of the incoming edge.
    
    Specified by:
    
    outV in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - map
```
public GremlinPipeline<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.
    
    Specified by:
    
    map in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    keys - the keys to get from the element (if none provided, all keys retrieved)
    
    Returns:
    the extended Pipeline
  - property
```
public GremlinPipeline<S,Object> property(String key)
```
    Add a PropertyPipe to the end of the Pipeline. Emit the respective property of the incoming element.
    
    Specified by:
    
    property in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    key - the property key
    
    Returns:
    the extended Pipeline
  - step
```
public GremlinPipeline<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.
    
    Specified by:
    
    step in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    function - the function of the FunctionPipe
    
    Returns:
    the extended Pipeline
  - step
```
public <T> GremlinPipeline<S,T> step(com.tinkerpop.pipes.Pipe<E,T> pipe)
```
    Add an arbitrary Pipe to the end of the pipeline.
    
    Specified by:
    
    step in interface GremlinFluentPipeline<S,E>
    
    Type Parameters:
    T - the object type emitted by the provided pipe.
    Parameters:
    pipe - The provided pipe.
    
    Returns:
    the extended Pipeline
  - copySplit
```
public GremlinPipeline<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."
    
    Specified by:
    
    copySplit in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    pipes - the internal pipes of the CopySplitPipe
    
    Returns:
    the extended Pipeline
  - exhaustMerge
```
public GremlinPipeline<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.
    
    Specified by:
    
    exhaustMerge in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - fairMerge
```
public GremlinPipeline<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.
    
    Specified by:
    
    fairMerge in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - ifThenElse
```
public GremlinPipeline<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.
    
    Specified by:
    
    ifThenElse in interface GremlinFluentPipeline<S,E>
    
    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
public GremlinPipeline<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.
    
    Specified by:
    
    loop in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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.
    
    Specified by:
    
    loop in interface GremlinFluentPipeline<S,E>
    
    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
public GremlinPipeline<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.
    
    Specified by:
    
    loop in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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.
    
    Specified by:
    
    loop in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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.
    
    Specified by:
    
    and in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    pipes - the internal pipes of the AndFilterPipe
    
    Returns:
    the extended Pipeline
  - back
```
@Deprecated
public GremlinPipeline<S,?> back(int numberedStep)
```
    Deprecated.
    
    Add a BackFilterPipe to the end of the Pipeline. The object that was seen numberedSteps ago is emitted.
    
    Specified by:
    
    back in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    numberedStep - the number of steps previous to back up to
    
    Returns:
    the extended Pipeline
  - back
```
public GremlinPipeline<S,?> back(String namedStep)
```
    Add a BackFilterPipe to the end of the Pipeline. The object that was seen namedSteps ago is emitted.
    
    Specified by:
    
    back in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    namedStep - the name of the step previous to back up to
    
    Returns:
    the extended Pipeline
  - dedup
```
public GremlinPipeline<S,E> dedup()
```
    Add a DuplicateFilterPipe to the end of the Pipeline. Will only emit the object if it has not been seen before.
    
    Specified by:
    
    dedup in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - dedup
```
public GremlinPipeline<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.
    
    Specified by:
    
    dedup in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    dedupFunction - a function to call on the object to yield the object to dedup on
    
    Returns:
    the extended Pipeline
  - except
```
public GremlinPipeline<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.
    
    Specified by:
    
    except in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    collection - the collection except from the stream
    
    Returns:
    the extended Pipeline
  - except
```
public GremlinPipeline<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.
    
    Specified by:
    
    except in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    namedSteps - the named steps in the pipeline
    
    Returns:
    the extended Pipeline
  - filter
```
public GremlinPipeline<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.
    
    Specified by:
    
    filter in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    filterFunction - the filter function of the pipe
    
    Returns:
    the extended Pipeline
  - or
```
public GremlinPipeline<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.
    
    Specified by:
    
    or in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    pipes - the internal pipes of the OrFilterPipe
    
    Returns:
    the extended Pipeline
  - random
```
public GremlinPipeline<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.
    
    Specified by:
    
    random in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    bias - the bias of the random coin
    
    Returns:
    the extended Pipeline
  - range
```
public GremlinPipeline<S,E> range(int low,
                         int high)
```
    Add a RageFilterPipe to the end of the Pipeline. Analogous to a high/low index lookup.
    
    Specified by:
    
    range in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    low - the low end of the range
    high - the high end of the range
    
    Returns:
    the extended Pipeline
  - retain
```
public GremlinPipeline<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.
    
    Specified by:
    
    retain in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    collection - the collection to retain
    
    Returns:
    the extended Pipeline
  - retain
```
public GremlinPipeline<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.
    
    Specified by:
    
    retain in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    namedSteps - the named steps in the pipeline
    
    Returns:
    the extended Pipeline
  - simplePath
```
public GremlinPipeline<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.
    
    Specified by:
    
    simplePath in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - aggregate
```
public GremlinPipeline<S,E> aggregate()
```
    Add an AggregatePipe to the end of the Pipeline. The objects prior to aggregate are greedily collected into an ArrayList.
    
    Specified by:
    
    aggregate in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - aggregate
```
public GremlinPipeline<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.
    
    Specified by:
    
    aggregate in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    aggregate - the collection to aggregate results into
    
    Returns:
    the extended Pipeline
  - aggregate
```
public GremlinPipeline<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.
    
    Specified by:
    
    aggregate in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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.
    
    Specified by:
    
    aggregate in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    aggregateFunction - the function to run over each object prior to insertion into the aggregate
    
    Returns:
    the extended Pipeline
  - optional
```
@Deprecated
public GremlinPipeline<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.
    
    Specified by:
    
    optional in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    numberedStep - the number of steps previous to optional back to
    
    Returns:
    the extended Pipeline
  - optional
```
public GremlinPipeline<S,?> optional(String namedStep)
```
    Add an OptionalPipe to the end of the Pipeline. The section of pipeline back to the partition step is evaluated.
    
    Specified by:
    
    optional in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    namedStep - the name of the step previous to optional back to
    
    Returns:
    the extended Pipeline
  - groupBy
```
public GremlinPipeline<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.
    
    Specified by:
    
    groupBy in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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.
    
    Specified by:
    
    groupBy in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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.
    
    Specified by:
    
    groupBy in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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.
    
    Specified by:
    
    groupBy in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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()).
    
    Specified by:
    
    groupCount in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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()).
    
    Specified by:
    
    groupCount in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    keyFunction - the key function to determine map key
    valueFunction - the value function to determine map value
    
    Returns:
    the extended Pipeline
  - groupCount
```
public GremlinPipeline<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.
    
    Specified by:
    
    groupCount in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    map - a provided count map
    keyFunction - the key function to determine map key
    
    Returns:
    the extended Pipeline
  - groupCount
```
public GremlinPipeline<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.
    
    Specified by:
    
    groupCount in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    keyFunction - the key function to determine map key
    
    Returns:
    the extended Pipeline
  - groupCount
```
public GremlinPipeline<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.
    
    Specified by:
    
    groupCount in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    map - a provided count map
    
    Returns:
    the extended Pipeline
  - groupCount
```
public GremlinPipeline<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.
    
    Specified by:
    
    groupCount in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - linkOut
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> 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.
    
    Specified by:
    
    linkOut in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    label - the edge label
    namedStep - the step name that has the other vertex to link to
    
    Returns:
    the extended Pipeline
  - linkIn
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> 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.
    
    Specified by:
    
    linkIn in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    label - the edge label
    namedStep - the step name that has the other vertex to link to
    
    Returns:
    the extended Pipeline
  - linkBoth
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> 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.
    
    Specified by:
    
    linkBoth in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    label - the edge label
    namedStep - the step name that has the other vertex to link to
    
    Returns:
    the extended Pipeline
  - linkOut
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> 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.
    
    Specified by:
    
    linkOut in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    label - the edge label
    other - the other vertex
    
    Returns:
    the extended Pipeline
  - linkIn
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> 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.
    
    Specified by:
    
    linkIn in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    label - the edge label
    other - the other vertex
    
    Returns:
    the extended Pipeline
  - linkBoth
```
public GremlinPipeline<S,com.tinkerpop.blueprints.Vertex> 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.
    
    Specified by:
    
    linkBoth in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    label - the edge label
    other - the other vertex
    
    Returns:
    the extended Pipeline
  - sideEffect
```
public GremlinPipeline<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.
    
    Specified by:
    
    sideEffect in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    sideEffectFunction - the function of the pipe
    
    Returns:
    the extended Pipeline
  - store
```
public GremlinPipeline<S,E> store(Collection<E> storage)
```
    Add a StorePipe to the end of the Pipeline. Lazily store the incoming objects into the provided collection.
    
    Specified by:
    
    store in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    storage - the collection to store results into
    
    Returns:
    the extended Pipeline
  - store
```
public GremlinPipeline<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.
    
    Specified by:
    
    store in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<S,E> store()
```
    Add an StorePipe to the end of the Pipeline. An ArrayList storage collection is provided and filled lazily with incoming objects.
    
    Specified by:
    
    store in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - store
```
public GremlinPipeline<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.
    
    Specified by:
    
    store in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    storageFunction - the function to run over each object prior to insertion into the storage collection
    
    Returns:
    the extended Pipeline
  - table
```
public GremlinPipeline<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.
    
    Specified by:
    
    table in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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.
    
    Specified by:
    
    table in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    table - the table to fill
    columnFunctions - the post-processing function for each column
    
    Returns:
    the extended Pipeline
  - table
```
public GremlinPipeline<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.
    
    Specified by:
    
    table in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    columnFunctions - the post-processing function for each column
    
    Returns:
    the extended Pipeline
  - table
```
public GremlinPipeline<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.
    
    Specified by:
    
    table in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    table - the table to fill
    
    Returns:
    the extended Pipeline
  - table
```
public GremlinPipeline<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.
    
    Specified by:
    
    table in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - tree
```
public GremlinPipeline<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.
    
    Specified by:
    
    tree in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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.
    
    Specified by:
    
    tree in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    branchFunctions - functions to apply to each path object in a round robin fashion
    
    Returns:
    the extended Pipeline
  - gather
```
public GremlinPipeline<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.
    
    Specified by:
    
    gather in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - gather
```
public GremlinPipeline<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.
    
    Specified by:
    
    gather in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    function - a transformation to apply to the gathered list
    
    Returns:
    the extended Pipeline
  - _
```
public GremlinPipeline<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.
    
    Specified by:
    
    _ in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - memoize
```
public GremlinPipeline<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.
    
    Specified by:
    
    memoize in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    namedStep - the name of the step previous to memoize to
    
    Returns:
    the extended Pipeline
  - memoize
```
@Deprecated
public GremlinPipeline<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.
    
    Specified by:
    
    memoize in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    numberedStep - the number of the step previous to memoize to
    
    Returns:
    the extended Pipeline
  - memoize
```
public GremlinPipeline<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.
    
    Specified by:
    
    memoize in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    namedStep - the name of the step previous to memoize to
    map - the memoization map
    
    Returns:
    the extended Pipeline
  - memoize
```
@Deprecated
public GremlinPipeline<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.
    
    Specified by:
    
    memoize in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    numberedStep - the number of the step previous to memoize to
    map - the memoization map
    
    Returns:
    the extended Pipeline
  - order
```
public GremlinPipeline<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.
    
    Specified by:
    
    order in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - order
```
public GremlinPipeline<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.
    
    Specified by:
    
    order in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    order - if the stream is composed of comparable objects, then increment or decrement can be specified
    
    Returns:
    the extended Pipeline
  - order
```
public GremlinPipeline<S,E> order(Tokens.T 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
```
public GremlinPipeline<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.
    
    Specified by:
    
    order in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    compareFunction - a comparator function of two objects of type E
    
    Returns:
    the extended Pipeline
  - path
```
public GremlinPipeline<S,List> path(com.tinkerpop.pipes.PipeFunction... pathFunctions)
```
    Add a 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.
    
    Specified by:
    
    path in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    pathFunctions - the path function of the PathPipe
    
    Returns:
    the extended Pipeline
  - scatter
```
public GremlinPipeline<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.
    
    Specified by:
    
    scatter in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - select
```
public GremlinPipeline<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.
    
    Specified by:
    
    select in interface GremlinFluentPipeline<S,E>
    
    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
```
public GremlinPipeline<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.
    
    Specified by:
    
    select in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    columnFunctions - the functions to apply to the column objects prior to filling the Row
    
    Returns:
    the extended Pipeline
  - select
```
public GremlinPipeline<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.
    
    Specified by:
    
    select in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - shuffle
```
public GremlinPipeline<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.
    
    Specified by:
    
    shuffle in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - cap
```
public GremlinPipeline<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.
    
    Specified by:
    
    cap in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the extended Pipeline
  - orderMap
```
public GremlinPipeline<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.
    
    Specified by:
    
    orderMap in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    order - if the values implement Comparable, then a increment or decrement sort is usable
    
    Returns:
    the extended Pipeline
  - orderMap
```
public GremlinPipeline<S,?> orderMap(Tokens.T 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
```
public GremlinPipeline<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.
    
    Specified by:
    
    orderMap in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    compareFunction - a function to compare to map entries
    
    Returns:
    the extended Pipeline
  - transform
```
public <T> GremlinPipeline<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.
    
    Specified by:
    
    transform in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    function - the transformation function of the pipe
    
    Returns:
    the extended Pipeline
  - as
```
public GremlinPipeline<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.
    
    Specified by:
    
    as in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    name - the name of the AsPipe
    
    Returns:
    the extended Pipeline
  - start
```
public GremlinPipeline<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.
    
    Specified by:
    
    start in interface GremlinFluentPipeline<S,E>
    
    Parameters:
    object - the object that serves as the start of the pipeline (iterator/iterable are unfolded)
    
    Returns:
    the extended Pipeline
  - count
```
public long count()
```
    Return the number of objects iterated through the pipeline.
    
    Specified by:
    
    count in interface GremlinFluentPipeline<S,E>
    
    Overrides:
    
    count in class com.tinkerpop.pipes.util.Pipeline<S,E>
    
    Returns:
    the number of objects iterated
  - iterate
```
public void iterate()
```
    Completely drain the pipeline of its objects. Useful when a sideEffect of the pipeline is desired.
    
    Specified by:
    
    iterate in interface GremlinFluentPipeline<S,E>
    
    Overrides:
    
    iterate in class com.tinkerpop.pipes.util.Pipeline<S,E>
  - next
```
public List<E> next(int number)
```
    Return the next X objects in the pipeline as a list.
    
    Specified by:
    
    next in interface GremlinFluentPipeline<S,E>
    
    Overrides:
    
    next in class com.tinkerpop.pipes.util.Pipeline<S,E>
    
    Parameters:
    number - the number of objects to return
    
    Returns:
    a list of X objects (if X objects occur)
  - toList
```
public List<E> toList()
```
    Return a list of all the objects in the pipeline.
    
    Specified by:
    
    toList in interface GremlinFluentPipeline<S,E>
    
    Overrides:
    
    toList in class com.tinkerpop.pipes.util.Pipeline<S,E>
    
    Returns:
    a list of all the objects
  - fill
```
public Collection<E> fill(Collection<E> collection)
```
    Fill the provided collection with the objects in the pipeline.
    
    Specified by:
    
    fill in interface GremlinFluentPipeline<S,E>
    
    Overrides:
    
    fill in class com.tinkerpop.pipes.util.Pipeline<S,E>
    
    Parameters:
    collection - the collection to fill
    
    Returns:
    the collection filled
  - enablePath
```
public GremlinPipeline<S,E> enablePath()
```
    Enable path calculations within the Pipeline. This is typically done automatically and in rare occasions needs to be called.
    
    Specified by:
    
    enablePath in interface GremlinFluentPipeline<S,E>
    
    Returns:
    the Pipeline with path calculations enabled
  - optimize
```
public GremlinPipeline<S,E> optimize(boolean optimize)
```
    When possible, Gremlin takes advantage of certain sequences of pipes in order to make a more concise, and generally more efficient expression. This method will turn on and off query optimization from this stage in the pipeline on.
    
    Parameters:
    optimize - whether to optimize the pipeline from here on or not
    
    Returns:
    The GremlinPipeline with the optimization turned off
  - remove
```
public void remove()
```
    Remove every element at the end of this Pipeline.
    
    Specified by:
    
    remove in interface Iterator<E>
    
    Overrides:
    
    remove in class com.tinkerpop.pipes.util.Pipeline<S,E>
  - cast
```
public <E> GremlinPipeline<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.
    
    Specified by:
    
    cast in interface GremlinFluentPipeline<S,E>
    
    Overrides:
    
    cast in class com.tinkerpop.pipes.util.Pipeline<S,E>
    
    Returns:
    returns the current pipeline with the new end type.

Class GremlinPipeline<S,E>

Field Summary

Fields inherited from class com.tinkerpop.pipes.util.Pipeline

Fields inherited from interface com.tinkerpop.pipes.Pipe

Constructor Summary

Method Summary

Methods inherited from class com.tinkerpop.pipes.util.Pipeline

Methods inherited from class java.lang.Object

Field Detail

asMap

Constructor Detail

GremlinPipeline

GremlinPipeline

GremlinPipeline

Method Detail

add

V

E

V

E

has

has

has

has

hasNot

hasNot

interval

bothE

bothE

both

both

bothV

idEdge

id

idVertex

inE

inE

in

in

inV

label

outE

outE

out

out

outV

map

property

step

step

copySplit

exhaustMerge

fairMerge

ifThenElse

loop

loop

loop

loop

and

back

back

dedup

dedup

except

except

filter

or

random

range

retain

retain

simplePath

aggregate

aggregate

aggregate

aggregate

optional

optional

groupBy

groupBy