HawkularTraversal (Hawkular Inventory Tinkerpop Implementation 0.20.0.Final API)

java.lang.Object
- org.hawkular.inventory.impl.tinkerpop.HawkularTraversal<S,E>

All Implemented Interfaces:

Serializable, Cloneable, Iterator<E>, org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>, org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E>, org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>, org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>
```
public class HawkularTraversal<S,E>
extends Object
implements org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>, org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E>
```
Since:

0.20.0

Author:

Lukas Krejci

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal
  org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E>, org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Symbols
- Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal
  org.apache.tinkerpop.gremlin.process.traversal.Traversal.Exceptions

Constructor Summary

Constructors
Constructor and Description

HawkularTraversal(org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E> delegate)

Constructors
Constructor and Description
`HawkularTraversal(org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E> delegate)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge>`	`addE(org.apache.tinkerpop.gremlin.structure.Direction direction, String firstVertexKeyOrEdgeLabel, String edgeLabelOrSecondVertexKey, Object... propertyKeyValues)` Deprecated.
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge>`	`addE(String edgeLabel)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge>`	`addInE(String firstVertexKeyOrEdgeLabel, String edgeLabelOrSecondVertexKey, Object... propertyKeyValues)` Deprecated.
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge>`	`addOutE(String firstVertexKeyOrEdgeLabel, String edgeLabelOrSecondVertexKey, Object... propertyKeyValues)` Deprecated.
`void`	`addStart(org.apache.tinkerpop.gremlin.process.traversal.Traverser.Admin<S> start)`
`void`	`addStarts(Iterator<org.apache.tinkerpop.gremlin.process.traversal.Traverser.Admin<S>> starts)`
`<S2,E2> org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S2,E2>`	`addStep(int index, org.apache.tinkerpop.gremlin.process.traversal.Step<?,?> step)`
`<E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E2>`	`addStep(org.apache.tinkerpop.gremlin.process.traversal.Step<?,E2> step)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`addV()`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`addV(Object... propertyKeyValues)` Deprecated.
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`addV(String vertexLabel)`
`HawkularTraversal<S,E>`	`aggregate(String sideEffectKey)`
`HawkularTraversal<S,E>`	`and(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?>... andTraversals)`
`void`	`applyStrategies()`
`HawkularTraversal<S,E>`	`as(String stepLabel, String... stepLabels)`
`org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E>`	`asAdmin()`
`HawkularTraversal<S,E>`	`barrier()`
`HawkularTraversal<S,E>`	`barrier(Consumer<org.apache.tinkerpop.gremlin.process.traversal.traverser.util.TraverserSet<Object>> barrierConsumer)`
`HawkularTraversal<S,E>`	`barrier(int maxBarrierSize)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`both(String... edgeLabels)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge>`	`bothE(String... edgeLabels)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`bothV()`
`<M,E2> HawkularTraversal<S,E2>`	`branch(Function<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>,M> function)`
`<M,E2> HawkularTraversal<S,E2>`	`branch(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,M> branchTraversal)`
`HawkularTraversal<S,E>`	`by()`
`HawkularTraversal<S,E>`	`by(Comparator<E> comparator)`
`<U> HawkularTraversal<S,E>`	`by(Function<U,Object> function, Comparator comparator)`
`<V> HawkularTraversal<S,E>`	`by(Function<V,Object> function)`
`HawkularTraversal<S,E>`	`by(org.apache.tinkerpop.gremlin.process.traversal.Order order)`
`HawkularTraversal<S,E>`	`by(String key)`
`<V> HawkularTraversal<S,E>`	`by(String key, Comparator<V> comparator)`
`HawkularTraversal<S,E>`	`by(org.apache.tinkerpop.gremlin.structure.T token)`
`HawkularTraversal<S,E>`	`by(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> traversal)`
`<V> HawkularTraversal<S,E>`	`by(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> traversal, Comparator<V> comparator)`
`<E2> HawkularTraversal<S,E2>`	`cap(String sideEffectKey, String... sideEffectKeys)`
`<M,E2> HawkularTraversal<S,E2>`	`choose(Function<E,M> choiceFunction)`
`<E2> HawkularTraversal<S,E2>`	`choose(Predicate<E> choosePredicate, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> trueChoice, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> falseChoice)`
`<E2> HawkularTraversal<S,E2>`	`choose(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> traversalPredicate, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> trueChoice, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> falseChoice)`
`<M,E2> HawkularTraversal<S,E2>`	`choose(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,M> choiceTraversal)`
`org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E>`	`clone()`
`<E2> HawkularTraversal<S,E2>`	`coalesce(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2>... coalesceTraversals)`
`HawkularTraversal<S,E>`	`coin(double probability)`
`<E2> HawkularTraversal<S,E2>`	`constant(E2 e)`
`HawkularTraversal<S,Long>`	`count()`
`HawkularTraversal<S,Long>`	`count(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)`
`HawkularTraversal<S,E>`	`cyclicPath()`
`HawkularTraversal<S,E>`	`dedup(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, String... dedupLabels)`
`HawkularTraversal<S,E>`	`dedup(String... dedupLabels)`
`HawkularTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Vertex>`	`doesntExistAt(Discriminator discriminator)`
`HawkularTraversal<S,E>`	`drop()`
`HawkularTraversal<S,E>`	`emit()`
`HawkularTraversal<S,E>`	`emit(Predicate<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>> emitPredicate)`
`HawkularTraversal<S,E>`	`emit(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> emitTraversal)`
`boolean`	`equals(Object obj)`
`boolean`	`equals(org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E> other)`
`HawkularTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Vertex>`	`existsAt(Discriminator discriminator)`
`org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation`	`explain()`
`<C extends Collection<E>> C`	`fill(C collection)`
`HawkularTraversal<S,E>`	`filter(Predicate<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>> predicate)`
`HawkularTraversal<S,E>`	`filter(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> filterTraversal)`
`<E2> HawkularTraversal<S,E2>`	`flatMap(Function<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>,Iterator<E2>> function)`
`<E2> HawkularTraversal<S,E2>`	`flatMap(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> flatMapTraversal)`
`HawkularTraversal<S,List<E>>`	`fold()`
`<E2> HawkularTraversal<S,E2>`	`fold(E2 seed, BiFunction<E2,E,E2> foldFunction)`
`<E2> void`	`forEachRemaining(Class<E2> endType, Consumer<E2> consumer)`
`void`	`forEachRemaining(Consumer<? super E> action)`
`HawkularTraversal<S,E>`	`from(String fromStepLabel)`
`HawkularTraversal<S,E>`	`from(org.apache.tinkerpop.gremlin.process.traversal.Traversal<E,org.apache.tinkerpop.gremlin.structure.Vertex> fromVertex)`
`org.apache.tinkerpop.gremlin.process.traversal.Bytecode`	`getBytecode()`
`org.apache.tinkerpop.gremlin.process.traversal.Step<?,E>`	`getEndStep()`
`Optional<org.apache.tinkerpop.gremlin.structure.Graph>`	`getGraph()`
`org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent`	`getParent()`
`org.apache.tinkerpop.gremlin.process.traversal.TraversalSideEffects`	`getSideEffects()`
`org.apache.tinkerpop.gremlin.process.traversal.Step<S,?>`	`getStartStep()`
`List<org.apache.tinkerpop.gremlin.process.traversal.Step>`	`getSteps()`
`org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies`	`getStrategies()`
`org.apache.tinkerpop.gremlin.process.traversal.TraverserGenerator`	`getTraverserGenerator()`
`Set<org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement>`	`getTraverserRequirements()`
`<K,V> HawkularTraversal<S,Map<K,V>>`	`group()`
`HawkularTraversal<S,E>`	`group(String sideEffectKey)`
`<K> HawkularTraversal<S,Map<K,Long>>`	`groupCount()`
`HawkularTraversal<S,E>`	`groupCount(String sideEffectKey)`
`<K,V> HawkularTraversal<S,Map<K,V>>`	`groupV3d0()` Deprecated.
`HawkularTraversal<S,E>`	`groupV3d0(String sideEffectKey)`
`HawkularTraversal<S,E>`	`has(String propertyKey)`
`HawkularTraversal<S,E>`	`has(String propertyKey, Object value)`
`HawkularTraversal<S,E>`	`has(String propertyKey, org.apache.tinkerpop.gremlin.process.traversal.P<?> predicate)`
`HawkularTraversal<S,E>`	`has(String label, String propertyKey, Object value)`
`HawkularTraversal<S,E>`	`has(String label, String propertyKey, org.apache.tinkerpop.gremlin.process.traversal.P<?> predicate)`
`HawkularTraversal<S,E>`	`has(String propertyKey, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> propertyTraversal)`
`HawkularTraversal<S,E>`	`has(org.apache.tinkerpop.gremlin.structure.T accessor, Object value)`
`HawkularTraversal<S,E>`	`has(org.apache.tinkerpop.gremlin.structure.T accessor, Object value, Object... values)`
`HawkularTraversal<S,E>`	`has(org.apache.tinkerpop.gremlin.structure.T accessor, org.apache.tinkerpop.gremlin.process.traversal.P<?> predicate)`
`HawkularTraversal<S,E>`	`has(org.apache.tinkerpop.gremlin.structure.T accessor, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> propertyTraversal)`
`int`	`hashCode()`
`HawkularTraversal<S,E>`	`hasId(Object value, Object... values)`
`HawkularTraversal<S,E>`	`hasKey(Object value, Object... values)`
`HawkularTraversal<S,E>`	`hasLabel(Object value, Object... values)`
`boolean`	`hasNext()`
`HawkularTraversal<S,E>`	`hasNot(String propertyKey)`
`HawkularTraversal<S,E>`	`hasValue(Object value, Object... values)`
`static <A> HawkularTraversal<A,A>`	`hwk__()`
`static <A> HawkularTraversal<A,A>`	`hwk__(A... starts)`
`static <A,B> HawkularTraversal<A,B>`	`hwk(org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<A,B> tr)`
`HawkularTraversal<S,Object>`	`id()`
`HawkularTraversal<S,E>`	`identity()`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`in(String... edgeLabels)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge>`	`inE(String... edgeLabels)`
`HawkularTraversal<S,E>`	`inject(E... injections)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`inV()`
`HawkularTraversal<S,E>`	`is(Object value)`
`HawkularTraversal<S,E>`	`is(org.apache.tinkerpop.gremlin.process.traversal.P<E> predicate)`
`boolean`	`isLocked()`
`HawkularTraversal<S,E>`	`iterate()`
`HawkularTraversal<S,String>`	`key()`
`HawkularTraversal<S,String>`	`label()`
`HawkularTraversal<S,E>`	`limit(long limit)`
`<E2> HawkularTraversal<S,E2>`	`limit(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, long limit)`
`<E2> HawkularTraversal<S,E2>`	`local(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> localTraversal)`
`HawkularTraversal<S,Integer>`	`loops()`
`<E2> HawkularTraversal<S,E2>`	`map(Function<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>,E2> function)`
`<E2> HawkularTraversal<S,E2>`	`map(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> mapTraversal)`
`<E2> HawkularTraversal<S,E2>`	`mapKeys()` Deprecated.
`<E2> HawkularTraversal<S,E2>`	`mapValues()` Deprecated.
`<E2> HawkularTraversal<S,Map<String,E2>>`	`match(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?>... matchTraversals)`
`<E2 extends Number> HawkularTraversal<S,E2>`	`max()`
`<E2 extends Number> HawkularTraversal<S,E2>`	`max(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)`
`<E2 extends Number> HawkularTraversal<S,E2>`	`mean()`
`<E2 extends Number> HawkularTraversal<S,E2>`	`mean(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)`
`<E2 extends Number> HawkularTraversal<S,E2>`	`min()`
`<E2 extends Number> HawkularTraversal<S,E2>`	`min(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)`
`E`	`next()`
`List<E>`	`next(int amount)`
`org.apache.tinkerpop.gremlin.process.traversal.Traverser.Admin<E>`	`nextTraverser()`
`HawkularTraversal<S,E>`	`not(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> notTraversal)`
`<M,E2> HawkularTraversal<S,E>`	`option(M pickToken, org.apache.tinkerpop.gremlin.process.traversal.Traversal<E,E2> traversalOption)`
`<E2> HawkularTraversal<S,E>`	`option(org.apache.tinkerpop.gremlin.process.traversal.Traversal<E,E2> traversalOption)`
`<E2> HawkularTraversal<S,E2>`	`optional(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> optionalTraversal)`
`HawkularTraversal<S,E>`	`or(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?>... orTraversals)`
`HawkularTraversal<S,E>`	`order()`
`HawkularTraversal<S,E>`	`order(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`otherV()`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`out(String... edgeLabels)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge>`	`outE(String... edgeLabels)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`outV()`
`HawkularTraversal<S,E>`	`pageRank()`
`HawkularTraversal<S,E>`	`pageRank(double alpha)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.process.traversal.Path>`	`path()`
`HawkularTraversal<S,E>`	`peerPressure()`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.process.traversal.util.TraversalMetrics>`	`profile()`
`HawkularTraversal<S,E>`	`profile(String sideEffectKey)`
`HawkularTraversal<S,E>`	`program(org.apache.tinkerpop.gremlin.process.computer.VertexProgram<?> vertexProgram)`
`<E2> HawkularTraversal<S,Map<String,E2>>`	`project(String projectKey, String... otherProjectKeys)`
`<E2> HawkularTraversal<S,? extends org.apache.tinkerpop.gremlin.structure.Property<E2>>`	`properties(String... propertyKeys)`
`HawkularTraversal<S,E>`	`property(Object key, Object value, Object... keyValues)`
`HawkularTraversal<S,E>`	`property(org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality cardinality, Object key, Object value, Object... keyValues)`
`<E2> HawkularTraversal<S,Map<String,E2>>`	`propertyMap(String... propertyKeys)`
`HawkularTraversal<S,E>`	`range(long low, long high)`
`<E2> HawkularTraversal<S,E2>`	`range(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, long low, long high)`
`void`	`remove()`
`<S2,E2> org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S2,E2>`	`removeStep(int index)`
`<S2,E2> org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S2,E2>`	`removeStep(org.apache.tinkerpop.gremlin.process.traversal.Step<?,?> step)`
`HawkularTraversal<S,E>`	`repeat(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E> repeatTraversal)`
`void`	`reset()`
`HawkularTraversal<org.apache.tinkerpop.gremlin.structure.Edge,org.apache.tinkerpop.gremlin.structure.Edge>`	`restrictTo(Discriminator discriminator)`
`<E2> HawkularTraversal<S,E2>`	`sack()`
`<V,U> HawkularTraversal<S,E>`	`sack(BiFunction<V,U,V> sackOperator)`
`<V,U> HawkularTraversal<S,E>`	`sack(BiFunction<V,U,V> sackOperator, String elementPropertyKey)` Deprecated.
`HawkularTraversal<S,E>`	`sample(int amountToSample)`
`HawkularTraversal<S,E>`	`sample(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, int amountToSample)`
`<E2> HawkularTraversal<S,Collection<E2>>`	`select(org.apache.tinkerpop.gremlin.structure.Column column)`
`<E2> HawkularTraversal<S,E2>`	`select(org.apache.tinkerpop.gremlin.process.traversal.Pop pop, String selectKey)`
`<E2> HawkularTraversal<S,Map<String,E2>>`	`select(org.apache.tinkerpop.gremlin.process.traversal.Pop pop, String selectKey1, String selectKey2, String... otherSelectKeys)`
`<E2> HawkularTraversal<S,E2>`	`select(String selectKey)`
`<E2> HawkularTraversal<S,Map<String,E2>>`	`select(String selectKey1, String selectKey2, String... otherSelectKeys)`
`void`	`setGraph(org.apache.tinkerpop.gremlin.structure.Graph graph)`
`void`	`setParent(org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent step)`
`void`	`setSideEffects(org.apache.tinkerpop.gremlin.process.traversal.TraversalSideEffects sideEffects)`
`void`	`setStrategies(org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies strategies)`
`HawkularTraversal<S,E>`	`sideEffect(Consumer<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>> consumer)`
`HawkularTraversal<S,E>`	`sideEffect(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> sideEffectTraversal)`
`HawkularTraversal<S,E>`	`simplePath()`
`HawkularTraversal<S,E>`	`store(String sideEffectKey)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge>`	`subgraph(String sideEffectKey)`
`<E2 extends Number> HawkularTraversal<S,E2>`	`sum()`
`<E2 extends Number> HawkularTraversal<S,E2>`	`sum(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)`
`HawkularTraversal<S,E>`	`tail()`
`HawkularTraversal<S,E>`	`tail(long limit)`
`<E2> HawkularTraversal<S,E2>`	`tail(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)`
`<E2> HawkularTraversal<S,E2>`	`tail(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, long limit)`
`HawkularTraversal<S,E>`	`timeLimit(long timeLimit)`
`HawkularTraversal<S,E>`	`times(int maxLoops)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`to(org.apache.tinkerpop.gremlin.structure.Direction direction, String... edgeLabels)`
`HawkularTraversal<S,E>`	`to(String toStepLabel)`
`HawkularTraversal<S,E>`	`to(org.apache.tinkerpop.gremlin.process.traversal.Traversal<E,org.apache.tinkerpop.gremlin.structure.Vertex> toVertex)`
`org.apache.tinkerpop.gremlin.process.traversal.step.util.BulkSet<E>`	`toBulkSet()`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge>`	`toE(org.apache.tinkerpop.gremlin.structure.Direction direction, String... edgeLabels)`
`List<E>`	`toList()`
`Set<E>`	`toSet()`
`Stream<E>`	`toStream()`
`String`	`toString()`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`toV(org.apache.tinkerpop.gremlin.structure.Direction direction)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree>`	`tree()`
`HawkularTraversal<S,E>`	`tree(String sideEffectKey)`
`Optional<E>`	`tryNext()`
`<E2> HawkularTraversal<S,E2>`	`unfold()`
`<E2> HawkularTraversal<S,E2>`	`union(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2>... unionTraversals)`
`HawkularTraversal<S,E>`	`until(Predicate<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>> untilPredicate)`
`HawkularTraversal<S,E>`	`until(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> untilTraversal)`
`HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex>`	`V(Object... vertexIdsOrElements)`
`<E2> HawkularTraversal<S,E2>`	`value()`
`<E2> HawkularTraversal<S,Map<String,E2>>`	`valueMap(boolean includeTokens, String... propertyKeys)`
`<E2> HawkularTraversal<S,Map<String,E2>>`	`valueMap(String... propertyKeys)`
`<E2> HawkularTraversal<S,E2>`	`values(String... propertyKeys)`
`HawkularTraversal<S,E>`	`where(org.apache.tinkerpop.gremlin.process.traversal.P<String> predicate)`
`HawkularTraversal<S,E>`	`where(String startKey, org.apache.tinkerpop.gremlin.process.traversal.P<String> predicate)`
`HawkularTraversal<S,E>`	`where(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> whereTraversal)`

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

Constructor Detail

HawkularTraversal

public HawkularTraversal(org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E> delegate)

Method Detail

hwk

public static <A,B> HawkularTraversal<A,B> hwk(org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<A,B> tr)

hwk__

public static <A> HawkularTraversal<A,A> hwk__()

hwk__

public static <A> HawkularTraversal<A,A> hwk__(A... starts)

restrictTo

public HawkularTraversal<org.apache.tinkerpop.gremlin.structure.Edge,org.apache.tinkerpop.gremlin.structure.Edge> restrictTo(Discriminator discriminator)

existsAt

public HawkularTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Vertex> existsAt(Discriminator discriminator)

doesntExistAt

public HawkularTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Vertex> doesntExistAt(Discriminator discriminator)

asAdmin
```
public org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E> asAdmin()
```
Specified by:

asAdmin in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

Specified by:

asAdmin in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

map

public <E2> HawkularTraversal<S,E2> map(Function<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>,E2> function)

Specified by:: map in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

map

public <E2> HawkularTraversal<S,E2> map(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> mapTraversal)

Specified by:: map in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

flatMap

public <E2> HawkularTraversal<S,E2> flatMap(Function<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>,Iterator<E2>> function)

Specified by:: flatMap in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

flatMap

public <E2> HawkularTraversal<S,E2> flatMap(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> flatMapTraversal)

Specified by:: flatMap in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

id
```
public HawkularTraversal<S,Object> id()
```
Specified by:

id in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

label
```
public HawkularTraversal<S,String> label()
```
Specified by:

label in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

identity
```
public HawkularTraversal<S,E> identity()
```
Specified by:

identity in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

constant
```
public <E2> HawkularTraversal<S,E2> constant(E2 e)
```
Specified by:

constant in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

V

public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> V(Object... vertexIdsOrElements)

Specified by:: V in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

to

public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> to(org.apache.tinkerpop.gremlin.structure.Direction direction,
                                                                             String... edgeLabels)

Specified by:: to in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

out
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> out(String... edgeLabels)
```
Specified by:

out in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

in
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> in(String... edgeLabels)
```
Specified by:

in in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

both
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> both(String... edgeLabels)
```
Specified by:

both in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

toE

public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge> toE(org.apache.tinkerpop.gremlin.structure.Direction direction,
                                                                            String... edgeLabels)

Specified by:: toE in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

outE
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge> outE(String... edgeLabels)
```
Specified by:

outE in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

inE
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge> inE(String... edgeLabels)
```
Specified by:

inE in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

bothE
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge> bothE(String... edgeLabels)
```
Specified by:

bothE in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

toV

public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> toV(org.apache.tinkerpop.gremlin.structure.Direction direction)

Specified by:: toV in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

inV
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> inV()
```
Specified by:

inV in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

outV
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> outV()
```
Specified by:

outV in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

bothV
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> bothV()
```
Specified by:

bothV in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

otherV
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> otherV()
```
Specified by:

otherV in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

order
```
public HawkularTraversal<S,E> order()
```
Specified by:

order in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

order
```
public HawkularTraversal<S,E> order(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)
```
Specified by:

order in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

properties

public <E2> HawkularTraversal<S,? extends org.apache.tinkerpop.gremlin.structure.Property<E2>> properties(String... propertyKeys)

Specified by:: properties in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

values
```
public <E2> HawkularTraversal<S,E2> values(String... propertyKeys)
```
Specified by:

values in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

propertyMap
```
public <E2> HawkularTraversal<S,Map<String,E2>> propertyMap(String... propertyKeys)
```
Specified by:

propertyMap in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

valueMap
```
public <E2> HawkularTraversal<S,Map<String,E2>> valueMap(String... propertyKeys)
```
Specified by:

valueMap in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

valueMap

public <E2> HawkularTraversal<S,Map<String,E2>> valueMap(boolean includeTokens,
                                                         String... propertyKeys)

Specified by:: valueMap in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

select

public <E2> HawkularTraversal<S,Collection<E2>> select(org.apache.tinkerpop.gremlin.structure.Column column)

Specified by:: select in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

mapValues
```
@Deprecated
public <E2> HawkularTraversal<S,E2> mapValues()
```
Deprecated.

Specified by:

mapValues in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

mapKeys
```
@Deprecated
public <E2> HawkularTraversal<S,E2> mapKeys()
```
Deprecated.

Specified by:

mapKeys in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

key
```
public HawkularTraversal<S,String> key()
```
Specified by:

key in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

value
```
public <E2> HawkularTraversal<S,E2> value()
```
Specified by:

value in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

path
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.process.traversal.Path> path()
```
Specified by:

path in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

match

public <E2> HawkularTraversal<S,Map<String,E2>> match(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?>... matchTraversals)

Specified by:: match in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

sack
```
public <E2> HawkularTraversal<S,E2> sack()
```
Specified by:

sack in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

loops
```
public HawkularTraversal<S,Integer> loops()
```
Specified by:

loops in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

project

public <E2> HawkularTraversal<S,Map<String,E2>> project(String projectKey,
                                                        String... otherProjectKeys)

Specified by:: project in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

select

public <E2> HawkularTraversal<S,Map<String,E2>> select(org.apache.tinkerpop.gremlin.process.traversal.Pop pop,
                                                       String selectKey1,
                                                       String selectKey2,
                                                       String... otherSelectKeys)

Specified by:: select in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

select

public <E2> HawkularTraversal<S,Map<String,E2>> select(String selectKey1,
                                                       String selectKey2,
                                                       String... otherSelectKeys)

Specified by:: select in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

select

public <E2> HawkularTraversal<S,E2> select(org.apache.tinkerpop.gremlin.process.traversal.Pop pop,
                                           String selectKey)

Specified by:: select in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

select
```
public <E2> HawkularTraversal<S,E2> select(String selectKey)
```
Specified by:

select in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

unfold
```
public <E2> HawkularTraversal<S,E2> unfold()
```
Specified by:

unfold in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

fold
```
public HawkularTraversal<S,List<E>> fold()
```
Specified by:

fold in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

fold

public <E2> HawkularTraversal<S,E2> fold(E2 seed,
                                         BiFunction<E2,E,E2> foldFunction)

Specified by:: fold in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

count
```
public HawkularTraversal<S,Long> count()
```
Specified by:

count in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

count
```
public HawkularTraversal<S,Long> count(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)
```
Specified by:

count in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

sum
```
public <E2 extends Number> HawkularTraversal<S,E2> sum()
```
Specified by:

sum in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

sum

public <E2 extends Number> HawkularTraversal<S,E2> sum(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

Specified by:: sum in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

max
```
public <E2 extends Number> HawkularTraversal<S,E2> max()
```
Specified by:

max in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

max

public <E2 extends Number> HawkularTraversal<S,E2> max(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

Specified by:: max in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

min
```
public <E2 extends Number> HawkularTraversal<S,E2> min()
```
Specified by:

min in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

min

public <E2 extends Number> HawkularTraversal<S,E2> min(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

Specified by:: min in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

mean
```
public <E2 extends Number> HawkularTraversal<S,E2> mean()
```
Specified by:

mean in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

mean

public <E2 extends Number> HawkularTraversal<S,E2> mean(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

Specified by:: mean in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

group
```
public <K,V> HawkularTraversal<S,Map<K,V>> group()
```
Specified by:

group in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

groupV3d0
```
@Deprecated
public <K,V> HawkularTraversal<S,Map<K,V>> groupV3d0()
```
Deprecated.

Specified by:

groupV3d0 in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

groupCount
```
public <K> HawkularTraversal<S,Map<K,Long>> groupCount()
```
Specified by:

groupCount in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

tree
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree> tree()
```
Specified by:

tree in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

addV
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> addV(String vertexLabel)
```
Specified by:

addV in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

addV
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> addV()
```
Specified by:

addV in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

addV

@Deprecated
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Vertex> addV(Object... propertyKeyValues)

Deprecated.

Specified by:: addV in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

addE
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge> addE(String edgeLabel)
```
Specified by:

addE in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

to
```
public HawkularTraversal<S,E> to(String toStepLabel)
```
Specified by:

to in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

from
```
public HawkularTraversal<S,E> from(String fromStepLabel)
```
Specified by:

from in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

to

public HawkularTraversal<S,E> to(org.apache.tinkerpop.gremlin.process.traversal.Traversal<E,org.apache.tinkerpop.gremlin.structure.Vertex> toVertex)

Specified by:: to in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

from

public HawkularTraversal<S,E> from(org.apache.tinkerpop.gremlin.process.traversal.Traversal<E,org.apache.tinkerpop.gremlin.structure.Vertex> fromVertex)

Specified by:: from in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

addE

@Deprecated
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge> addE(org.apache.tinkerpop.gremlin.structure.Direction direction,
                                                                                         String firstVertexKeyOrEdgeLabel,
                                                                                         String edgeLabelOrSecondVertexKey,
                                                                                         Object... propertyKeyValues)

Deprecated.

Specified by:: addE in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

addOutE

@Deprecated
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge> addOutE(String firstVertexKeyOrEdgeLabel,
                                                                                            String edgeLabelOrSecondVertexKey,
                                                                                            Object... propertyKeyValues)

Deprecated.

Specified by:: addOutE in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

addInE

@Deprecated
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge> addInE(String firstVertexKeyOrEdgeLabel,
                                                                                           String edgeLabelOrSecondVertexKey,
                                                                                           Object... propertyKeyValues)

Deprecated.

Specified by:: addInE in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

filter

public HawkularTraversal<S,E> filter(Predicate<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>> predicate)

Specified by:: filter in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

filter

public HawkularTraversal<S,E> filter(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> filterTraversal)

Specified by:: filter in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

or

public HawkularTraversal<S,E> or(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?>... orTraversals)

Specified by:: or in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

and

public HawkularTraversal<S,E> and(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?>... andTraversals)

Specified by:: and in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

inject
```
public HawkularTraversal<S,E> inject(E... injections)
```
Specified by:

inject in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

dedup

public HawkularTraversal<S,E> dedup(org.apache.tinkerpop.gremlin.process.traversal.Scope scope,
                                    String... dedupLabels)

Specified by:: dedup in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

dedup
```
public HawkularTraversal<S,E> dedup(String... dedupLabels)
```
Specified by:

dedup in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

where

public HawkularTraversal<S,E> where(String startKey,
                                    org.apache.tinkerpop.gremlin.process.traversal.P<String> predicate)

Specified by:: where in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

where
```
public HawkularTraversal<S,E> where(org.apache.tinkerpop.gremlin.process.traversal.P<String> predicate)
```
Specified by:

where in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

where

public HawkularTraversal<S,E> where(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> whereTraversal)

Specified by:: where in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

has

public HawkularTraversal<S,E> has(String propertyKey,
                                  org.apache.tinkerpop.gremlin.process.traversal.P<?> predicate)

Specified by:: has in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

has

public HawkularTraversal<S,E> has(org.apache.tinkerpop.gremlin.structure.T accessor,
                                  org.apache.tinkerpop.gremlin.process.traversal.P<?> predicate)

Specified by:: has in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

has

public HawkularTraversal<S,E> has(String propertyKey,
                                  Object value)

Specified by:: has in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

has

public HawkularTraversal<S,E> has(org.apache.tinkerpop.gremlin.structure.T accessor,
                                  Object value)

Specified by:: has in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

has

public HawkularTraversal<S,E> has(String label,
                                  String propertyKey,
                                  org.apache.tinkerpop.gremlin.process.traversal.P<?> predicate)

Specified by:: has in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

has

public HawkularTraversal<S,E> has(String label,
                                  String propertyKey,
                                  Object value)

Specified by:: has in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

has

public HawkularTraversal<S,E> has(org.apache.tinkerpop.gremlin.structure.T accessor,
                                  org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> propertyTraversal)

Specified by:: has in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

has

public HawkularTraversal<S,E> has(String propertyKey,
                                  org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> propertyTraversal)

Specified by:: has in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

has
```
public HawkularTraversal<S,E> has(String propertyKey)
```
Specified by:

has in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

hasNot
```
public HawkularTraversal<S,E> hasNot(String propertyKey)
```
Specified by:

hasNot in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

has

public HawkularTraversal<S,E> has(org.apache.tinkerpop.gremlin.structure.T accessor,
                                  Object value,
                                  Object... values)

Specified by:: has in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

hasLabel

public HawkularTraversal<S,E> hasLabel(Object value,
                                       Object... values)

Specified by:: hasLabel in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

hasId

public HawkularTraversal<S,E> hasId(Object value,
                                    Object... values)

Specified by:: hasId in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

hasKey

public HawkularTraversal<S,E> hasKey(Object value,
                                     Object... values)

Specified by:: hasKey in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

hasValue

public HawkularTraversal<S,E> hasValue(Object value,
                                       Object... values)

Specified by:: hasValue in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

is
```
public HawkularTraversal<S,E> is(org.apache.tinkerpop.gremlin.process.traversal.P<E> predicate)
```
Specified by:

is in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

is
```
public HawkularTraversal<S,E> is(Object value)
```
Specified by:

is in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

not

public HawkularTraversal<S,E> not(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> notTraversal)

Specified by:: not in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

coin
```
public HawkularTraversal<S,E> coin(double probability)
```
Specified by:

coin in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

range
```
public HawkularTraversal<S,E> range(long low,
                                    long high)
```
Specified by:

range in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

range

public <E2> HawkularTraversal<S,E2> range(org.apache.tinkerpop.gremlin.process.traversal.Scope scope,
                                          long low,
                                          long high)

Specified by:: range in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

limit
```
public HawkularTraversal<S,E> limit(long limit)
```
Specified by:

limit in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

limit

public <E2> HawkularTraversal<S,E2> limit(org.apache.tinkerpop.gremlin.process.traversal.Scope scope,
                                          long limit)

Specified by:: limit in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

tail
```
public HawkularTraversal<S,E> tail()
```
Specified by:

tail in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

tail
```
public HawkularTraversal<S,E> tail(long limit)
```
Specified by:

tail in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

tail
```
public <E2> HawkularTraversal<S,E2> tail(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)
```
Specified by:

tail in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

tail

public <E2> HawkularTraversal<S,E2> tail(org.apache.tinkerpop.gremlin.process.traversal.Scope scope,
                                         long limit)

Specified by:: tail in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

timeLimit
```
public HawkularTraversal<S,E> timeLimit(long timeLimit)
```
Specified by:

timeLimit in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

simplePath
```
public HawkularTraversal<S,E> simplePath()
```
Specified by:

simplePath in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

cyclicPath
```
public HawkularTraversal<S,E> cyclicPath()
```
Specified by:

cyclicPath in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

sample
```
public HawkularTraversal<S,E> sample(int amountToSample)
```
Specified by:

sample in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

sample

public HawkularTraversal<S,E> sample(org.apache.tinkerpop.gremlin.process.traversal.Scope scope,
                                     int amountToSample)

Specified by:: sample in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

drop
```
public HawkularTraversal<S,E> drop()
```
Specified by:

drop in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

sideEffect

public HawkularTraversal<S,E> sideEffect(Consumer<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>> consumer)

Specified by:: sideEffect in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

sideEffect

public HawkularTraversal<S,E> sideEffect(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> sideEffectTraversal)

Specified by:: sideEffect in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

cap

public <E2> HawkularTraversal<S,E2> cap(String sideEffectKey,
                                        String... sideEffectKeys)

Specified by:: cap in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

subgraph
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.structure.Edge> subgraph(String sideEffectKey)
```
Specified by:

subgraph in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

aggregate
```
public HawkularTraversal<S,E> aggregate(String sideEffectKey)
```
Specified by:

aggregate in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

group
```
public HawkularTraversal<S,E> group(String sideEffectKey)
```
Specified by:

group in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

groupV3d0
```
public HawkularTraversal<S,E> groupV3d0(String sideEffectKey)
```
Specified by:

groupV3d0 in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

groupCount
```
public HawkularTraversal<S,E> groupCount(String sideEffectKey)
```
Specified by:

groupCount in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

tree
```
public HawkularTraversal<S,E> tree(String sideEffectKey)
```
Specified by:

tree in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

sack
```
public <V,U> HawkularTraversal<S,E> sack(BiFunction<V,U,V> sackOperator)
```
Specified by:

sack in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

sack

@Deprecated
public <V,U> HawkularTraversal<S,E> sack(BiFunction<V,U,V> sackOperator,
                                                     String elementPropertyKey)

Deprecated.

Specified by:: sack in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

store
```
public HawkularTraversal<S,E> store(String sideEffectKey)
```
Specified by:

store in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

profile
```
public HawkularTraversal<S,E> profile(String sideEffectKey)
```
Specified by:

profile in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

profile
```
public HawkularTraversal<S,org.apache.tinkerpop.gremlin.process.traversal.util.TraversalMetrics> profile()
```
Specified by:

profile in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

Specified by:

profile in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

property

public HawkularTraversal<S,E> property(org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality cardinality,
                                       Object key,
                                       Object value,
                                       Object... keyValues)

Specified by:: property in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

property

public HawkularTraversal<S,E> property(Object key,
                                       Object value,
                                       Object... keyValues)

Specified by:: property in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

branch

public <M,E2> HawkularTraversal<S,E2> branch(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,M> branchTraversal)

Specified by:: branch in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

branch

public <M,E2> HawkularTraversal<S,E2> branch(Function<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>,M> function)

Specified by:: branch in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

choose

public <M,E2> HawkularTraversal<S,E2> choose(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,M> choiceTraversal)

Specified by:: choose in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

choose

public <E2> HawkularTraversal<S,E2> choose(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> traversalPredicate,
                                           org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> trueChoice,
                                           org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> falseChoice)

Specified by:: choose in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

choose
```
public <M,E2> HawkularTraversal<S,E2> choose(Function<E,M> choiceFunction)
```
Specified by:

choose in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

choose

public <E2> HawkularTraversal<S,E2> choose(Predicate<E> choosePredicate,
                                           org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> trueChoice,
                                           org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> falseChoice)

Specified by:: choose in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

optional

public <E2> HawkularTraversal<S,E2> optional(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> optionalTraversal)

Specified by:: optional in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

union

public <E2> HawkularTraversal<S,E2> union(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2>... unionTraversals)

Specified by:: union in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

coalesce

public <E2> HawkularTraversal<S,E2> coalesce(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2>... coalesceTraversals)

Specified by:: coalesce in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

repeat

public HawkularTraversal<S,E> repeat(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E> repeatTraversal)

Specified by:: repeat in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

emit

public HawkularTraversal<S,E> emit(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> emitTraversal)

Specified by:: emit in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

emit

public HawkularTraversal<S,E> emit(Predicate<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>> emitPredicate)

Specified by:: emit in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

emit
```
public HawkularTraversal<S,E> emit()
```
Specified by:

emit in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

until

public HawkularTraversal<S,E> until(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> untilTraversal)

Specified by:: until in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

until

public HawkularTraversal<S,E> until(Predicate<org.apache.tinkerpop.gremlin.process.traversal.Traverser<E>> untilPredicate)

Specified by:: until in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

times
```
public HawkularTraversal<S,E> times(int maxLoops)
```
Specified by:

times in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

local

public <E2> HawkularTraversal<S,E2> local(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,E2> localTraversal)

Specified by:: local in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

pageRank
```
public HawkularTraversal<S,E> pageRank()
```
Specified by:

pageRank in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

pageRank
```
public HawkularTraversal<S,E> pageRank(double alpha)
```
Specified by:

pageRank in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

peerPressure
```
public HawkularTraversal<S,E> peerPressure()
```
Specified by:

peerPressure in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

program

public HawkularTraversal<S,E> program(org.apache.tinkerpop.gremlin.process.computer.VertexProgram<?> vertexProgram)

Specified by:: program in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

as

public HawkularTraversal<S,E> as(String stepLabel,
                                 String... stepLabels)

Specified by:: as in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

barrier
```
public HawkularTraversal<S,E> barrier()
```
Specified by:

barrier in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

barrier
```
public HawkularTraversal<S,E> barrier(int maxBarrierSize)
```
Specified by:

barrier in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

barrier

public HawkularTraversal<S,E> barrier(Consumer<org.apache.tinkerpop.gremlin.process.traversal.traverser.util.TraverserSet<Object>> barrierConsumer)

Specified by:: barrier in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

by
```
public HawkularTraversal<S,E> by()
```
Specified by:

by in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

by

public HawkularTraversal<S,E> by(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> traversal)

Specified by:: by in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

by
```
public HawkularTraversal<S,E> by(org.apache.tinkerpop.gremlin.structure.T token)
```
Specified by:

by in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

by
```
public HawkularTraversal<S,E> by(String key)
```
Specified by:

by in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

by
```
public <V> HawkularTraversal<S,E> by(Function<V,Object> function)
```
Specified by:

by in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

by

public <V> HawkularTraversal<S,E> by(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> traversal,
                                     Comparator<V> comparator)

Specified by:: by in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

by
```
public HawkularTraversal<S,E> by(Comparator<E> comparator)
```
Specified by:

by in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

by
```
public HawkularTraversal<S,E> by(org.apache.tinkerpop.gremlin.process.traversal.Order order)
```
Specified by:

by in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

by

public <V> HawkularTraversal<S,E> by(String key,
                                     Comparator<V> comparator)

Specified by:: by in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

by

public <U> HawkularTraversal<S,E> by(Function<U,Object> function,
                                     Comparator comparator)

Specified by:: by in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

option

public <M,E2> HawkularTraversal<S,E> option(M pickToken,
                                            org.apache.tinkerpop.gremlin.process.traversal.Traversal<E,E2> traversalOption)

Specified by:: option in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

option

public <E2> HawkularTraversal<S,E> option(org.apache.tinkerpop.gremlin.process.traversal.Traversal<E,E2> traversalOption)

Specified by:: option in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

iterate
```
public HawkularTraversal<S,E> iterate()
```
Specified by:

iterate in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<S,E>

Specified by:

iterate in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E>

Specified by:

iterate in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

tryNext
```
public Optional<E> tryNext()
```
Specified by:

tryNext in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

next
```
public List<E> next(int amount)
```
Specified by:

next in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

toList
```
public List<E> toList()
```
Specified by:

toList in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

toSet
```
public Set<E> toSet()
```
Specified by:

toSet in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

toBulkSet
```
public org.apache.tinkerpop.gremlin.process.traversal.step.util.BulkSet<E> toBulkSet()
```
Specified by:

toBulkSet in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

toStream
```
public Stream<E> toStream()
```
Specified by:

toStream in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

fill
```
public <C extends Collection<E>> C fill(C collection)
```
Specified by:

fill in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

explain
```
public org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation explain()
```
Specified by:

explain in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

forEachRemaining

public <E2> void forEachRemaining(Class<E2> endType,
                                  Consumer<E2> consumer)

Specified by:: forEachRemaining in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

forEachRemaining
```
public void forEachRemaining(Consumer<? super E> action)
```
Specified by:

forEachRemaining in interface Iterator<E>

Specified by:

forEachRemaining in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal<S,E>

hasNext
```
public boolean hasNext()
```
Specified by:

hasNext in interface Iterator<E>

next
```
public E next()
```
Specified by:

next in interface Iterator<E>

remove
```
public void remove()
```
Specified by:

remove in interface Iterator<E>

clone
```
public org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E> clone()
```
Specified by:

clone in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E>

Specified by:

clone in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

Overrides:

clone in class Object

getBytecode
```
public org.apache.tinkerpop.gremlin.process.traversal.Bytecode getBytecode()
```
Specified by:

getBytecode in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

getSteps
```
public List<org.apache.tinkerpop.gremlin.process.traversal.Step> getSteps()
```
Specified by:

getSteps in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

addStep

public <S2,E2> org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S2,E2> addStep(int index,
                                                                                             org.apache.tinkerpop.gremlin.process.traversal.Step<?,?> step)
                                                                                      throws IllegalStateException

Specified by:: addStep in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>
Throws:: IllegalStateException

removeStep

public <S2,E2> org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S2,E2> removeStep(int index)
                                                                                         throws IllegalStateException

Specified by:: removeStep in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>
Throws:: IllegalStateException

applyStrategies
```
public void applyStrategies()
                     throws IllegalStateException
```
Specified by:

applyStrategies in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

Throws:

IllegalStateException

getTraverserGenerator
```
public org.apache.tinkerpop.gremlin.process.traversal.TraverserGenerator getTraverserGenerator()
```
Specified by:

getTraverserGenerator in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

getTraverserRequirements
```
public Set<org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement> getTraverserRequirements()
```
Specified by:

getTraverserRequirements in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

setSideEffects
```
public void setSideEffects(org.apache.tinkerpop.gremlin.process.traversal.TraversalSideEffects sideEffects)
```
Specified by:

setSideEffects in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

getSideEffects
```
public org.apache.tinkerpop.gremlin.process.traversal.TraversalSideEffects getSideEffects()
```
Specified by:

getSideEffects in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

setStrategies
```
public void setStrategies(org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies strategies)
```
Specified by:

setStrategies in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

getStrategies
```
public org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategies getStrategies()
```
Specified by:

getStrategies in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

setParent
```
public void setParent(org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent step)
```
Specified by:

setParent in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

getParent
```
public org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent getParent()
```
Specified by:

getParent in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

isLocked
```
public boolean isLocked()
```
Specified by:

isLocked in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

getGraph
```
public Optional<org.apache.tinkerpop.gremlin.structure.Graph> getGraph()
```
Specified by:

getGraph in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

setGraph
```
public void setGraph(org.apache.tinkerpop.gremlin.structure.Graph graph)
```
Specified by:

setGraph in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

addStep
```
public <E2> org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E2> addStep(org.apache.tinkerpop.gremlin.process.traversal.Step<?,E2> step)
```
Specified by:

addStep in interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin<S,E>

Specified by:

addStep in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

addStarts
```
public void addStarts(Iterator<org.apache.tinkerpop.gremlin.process.traversal.Traverser.Admin<S>> starts)
```
Specified by:

addStarts in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

addStart
```
public void addStart(org.apache.tinkerpop.gremlin.process.traversal.Traverser.Admin<S> start)
```
Specified by:

addStart in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

removeStep

public <S2,E2> org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S2,E2> removeStep(org.apache.tinkerpop.gremlin.process.traversal.Step<?,?> step)
                                                                                         throws IllegalStateException

Specified by:: removeStep in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>
Throws:: IllegalStateException

getStartStep
```
public org.apache.tinkerpop.gremlin.process.traversal.Step<S,?> getStartStep()
```
Specified by:

getStartStep in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

getEndStep
```
public org.apache.tinkerpop.gremlin.process.traversal.Step<?,E> getEndStep()
```
Specified by:

getEndStep in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

reset
```
public void reset()
```
Specified by:

reset in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

equals
```
public boolean equals(Object obj)
```
Overrides:

equals in class Object

equals
```
public boolean equals(org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E> other)
```
Specified by:

equals in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

nextTraverser
```
public org.apache.tinkerpop.gremlin.process.traversal.Traverser.Admin<E> nextTraverser()
```
Specified by:

nextTraverser in interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin<S,E>

toString
```
public String toString()
```
Overrides:

toString in class Object

Class HawkularTraversal<S,E>

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

HawkularTraversal

Method Detail

hwk

hwk__

hwk__

restrictTo

existsAt

doesntExistAt

asAdmin

map

map

flatMap

flatMap

id

label

identity

constant

V

to

out

in

both

toE

outE

inE

bothE

toV

inV

outV

bothV

otherV

order

order

properties

values

propertyMap

valueMap

valueMap

select

mapValues

mapKeys

key

value

path

match

sack

loops

project

select

select

select

select

unfold

fold

fold

count

count

sum

sum

max

max

min

min

mean

mean

group

groupV3d0

groupCount

tree

addV

addV

addV