You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by jo...@apache.org on 2021/05/11 18:01:15 UTC
[tinkerpop] branch TINKERPOP-2563-language created (now aaabdfe)
This is an automated email from the ASF dual-hosted git repository.
joshsh pushed a change to branch TINKERPOP-2563-language
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git.
at aaabdfe Add generated API classes. Not yet integrated with the build.
This branch includes the following new commits:
new aa35e70 Add Gremlin traversal specification in YAML
new aaabdfe Add generated API classes. Not yet integrated with the build.
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[tinkerpop] 02/02: Add generated API classes. Not yet integrated
with the build.
Posted by jo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
joshsh pushed a commit to branch TINKERPOP-2563-language
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit aaabdfef7e0801c95e1d5dd82e83fddb98c0a91b
Author: Joshua Shinavier <jo...@uber.com>
AuthorDate: Tue May 11 10:56:40 2021 -0700
Add generated API classes. Not yet integrated with the build.
---
.../model/constants/GremlinStringConstant.java | 170 +
.../model/constants/PageRankStringConstant.java | 9 +
.../constants/PeerPressureStringConstant.java | 9 +
.../constants/ShortestPathStringConstant.java | 23 +
.../model/constants/WithOptionsStringConstant.java | 23 +
.../language/model/literals/DateLiteral.java | 27 +
.../model/literals/EmptyStringLiteral.java | 20 +
.../language/model/literals/GenericLiteral.java | 260 ++
.../model/literals/NonEmptyStringLiteral.java | 27 +
.../language/model/literals/StringLiteral.java | 135 +
.../language/model/methods/ExplainMethod.java | 20 +
.../language/model/methods/HasNextMethod.java | 20 +
.../language/model/methods/IterateMethod.java | 20 +
.../gremlin/language/model/methods/NextMethod.java | 27 +
.../language/model/methods/ToBulkSetMethod.java | 20 +
.../language/model/methods/ToListMethod.java | 20 +
.../language/model/methods/ToSetMethod.java | 20 +
.../model/methods/TraversalSackMethod.java | 20 +
.../model/methods/TraversalSelfMethod.java | 75 +
.../model/methods/TraversalTerminalMethod.java | 318 ++
.../language/model/methods/TryNextMethod.java | 20 +
.../gremlin/language/model/predicates/Between.java | 51 +
.../language/model/predicates/Containing.java | 27 +
.../language/model/predicates/EndingWith.java | 27 +
.../gremlin/language/model/predicates/Eq.java | 29 +
.../gremlin/language/model/predicates/Gt.java | 29 +
.../gremlin/language/model/predicates/Gte.java | 29 +
.../gremlin/language/model/predicates/Inside.java | 51 +
.../gremlin/language/model/predicates/Lt.java | 29 +
.../gremlin/language/model/predicates/Lte.java | 29 +
.../gremlin/language/model/predicates/Neq.java | 29 +
.../gremlin/language/model/predicates/Not.java | 27 +
.../language/model/predicates/NotContaining.java | 27 +
.../language/model/predicates/NotEndingWith.java | 27 +
.../language/model/predicates/NotStartingWith.java | 27 +
.../gremlin/language/model/predicates/Outside.java | 51 +
.../language/model/predicates/StartingWith.java | 27 +
.../model/predicates/TraversalPredicate.java | 741 ++++
.../gremlin/language/model/predicates/Within.java | 29 +
.../gremlin/language/model/predicates/Without.java | 29 +
.../gremlin/language/model/query/Query.java | 268 ++
.../language/model/query/TransactionPart.java | 7 +
.../gremlin/language/model/steps/AddEStep.java | 98 +
.../gremlin/language/model/steps/AddVStep.java | 204 ++
.../language/model/steps/AggregateStep.java | 51 +
.../gremlin/language/model/steps/AndStep.java | 29 +
.../gremlin/language/model/steps/AsStep.java | 49 +
.../gremlin/language/model/steps/BarrierStep.java | 125 +
.../gremlin/language/model/steps/BothEStep.java | 27 +
.../gremlin/language/model/steps/BothStep.java | 27 +
.../gremlin/language/model/steps/BothVStep.java | 20 +
.../gremlin/language/model/steps/BranchStep.java | 29 +
.../gremlin/language/model/steps/ByStep.java | 426 +++
.../gremlin/language/model/steps/CapStep.java | 49 +
.../gremlin/language/model/steps/ChooseStep.java | 238 ++
.../gremlin/language/model/steps/CoalesceStep.java | 29 +
.../gremlin/language/model/steps/CoinStep.java | 27 +
.../model/steps/ConnectedComponentStep.java | 20 +
.../gremlin/language/model/steps/ConstantStep.java | 29 +
.../gremlin/language/model/steps/CountStep.java | 29 +
.../language/model/steps/CyclicPathStep.java | 20 +
.../gremlin/language/model/steps/DedupStep.java | 51 +
.../gremlin/language/model/steps/DropStep.java | 20 +
.../language/model/steps/ElementMapStep.java | 27 +
.../gremlin/language/model/steps/EmitStep.java | 126 +
.../gremlin/language/model/steps/FilterStep.java | 99 +
.../gremlin/language/model/steps/FlatMapStep.java | 29 +
.../gremlin/language/model/steps/FoldStep.java | 79 +
.../gremlin/language/model/steps/FromStep.java | 98 +
.../language/model/steps/GroupCountStep.java | 27 +
.../gremlin/language/model/steps/GroupStep.java | 27 +
.../gremlin/language/model/steps/HasIdStep.java | 138 +
.../gremlin/language/model/steps/HasKeyStep.java | 137 +
.../gremlin/language/model/steps/HasLabelStep.java | 137 +
.../gremlin/language/model/steps/HasNotStep.java | 27 +
.../gremlin/language/model/steps/HasStep.java | 602 ++++
.../gremlin/language/model/steps/HasValueStep.java | 114 +
.../gremlin/language/model/steps/IdStep.java | 20 +
.../gremlin/language/model/steps/IdentityStep.java | 20 +
.../gremlin/language/model/steps/InEStep.java | 27 +
.../gremlin/language/model/steps/InStep.java | 27 +
.../gremlin/language/model/steps/InVStep.java | 20 +
.../gremlin/language/model/steps/IndexStep.java | 20 +
.../gremlin/language/model/steps/InjectStep.java | 29 +
.../gremlin/language/model/steps/IsStep.java | 99 +
.../gremlin/language/model/steps/KeyStep.java | 20 +
.../gremlin/language/model/steps/LabelStep.java | 20 +
.../gremlin/language/model/steps/LimitStep.java | 51 +
.../gremlin/language/model/steps/LocalStep.java | 29 +
.../gremlin/language/model/steps/LoopsStep.java | 27 +
.../gremlin/language/model/steps/MapStep.java | 29 +
.../gremlin/language/model/steps/MatchStep.java | 29 +
.../gremlin/language/model/steps/MathStep.java | 27 +
.../gremlin/language/model/steps/MaxStep.java | 29 +
.../gremlin/language/model/steps/MeanStep.java | 29 +
.../gremlin/language/model/steps/MinStep.java | 29 +
.../gremlin/language/model/steps/NotStep.java | 29 +
.../gremlin/language/model/steps/OptionStep.java | 215 ++
.../gremlin/language/model/steps/OptionalStep.java | 29 +
.../gremlin/language/model/steps/OrStep.java | 29 +
.../gremlin/language/model/steps/OrderStep.java | 29 +
.../gremlin/language/model/steps/OtherVStep.java | 20 +
.../gremlin/language/model/steps/OutEStep.java | 27 +
.../gremlin/language/model/steps/OutStep.java | 27 +
.../gremlin/language/model/steps/OutVStep.java | 20 +
.../gremlin/language/model/steps/PageRankStep.java | 27 +
.../gremlin/language/model/steps/PathStep.java | 20 +
.../language/model/steps/PeerPressureStep.java | 20 +
.../gremlin/language/model/steps/ProfileStep.java | 27 +
.../gremlin/language/model/steps/ProjectStep.java | 49 +
.../language/model/steps/PropertiesStep.java | 27 +
.../language/model/steps/PropertyMapStep.java | 27 +
.../gremlin/language/model/steps/PropertyStep.java | 82 +
.../gremlin/language/model/steps/RangeStep.java | 66 +
.../gremlin/language/model/steps/ReadStep.java | 20 +
.../gremlin/language/model/steps/RepeatStep.java | 51 +
.../gremlin/language/model/steps/SackStep.java | 29 +
.../gremlin/language/model/steps/SampleStep.java | 51 +
.../gremlin/language/model/steps/SelectStep.java | 315 ++
.../language/model/steps/ShortestPathStep.java | 20 +
.../language/model/steps/SideEffectStep.java | 29 +
.../language/model/steps/SimplePathStep.java | 20 +
.../gremlin/language/model/steps/SkipStep.java | 51 +
.../gremlin/language/model/steps/StoreStep.java | 27 +
.../gremlin/language/model/steps/SubgraphStep.java | 27 +
.../gremlin/language/model/steps/SumStep.java | 29 +
.../gremlin/language/model/steps/TailStep.java | 51 +
.../language/model/steps/TimeLimitStep.java | 27 +
.../gremlin/language/model/steps/TimesStep.java | 27 +
.../gremlin/language/model/steps/ToEStep.java | 51 +
.../gremlin/language/model/steps/ToStep.java | 175 +
.../gremlin/language/model/steps/ToVStep.java | 29 +
.../language/model/steps/TraversalMethod.java | 3759 ++++++++++++++++++++
.../gremlin/language/model/steps/TreeStep.java | 27 +
.../gremlin/language/model/steps/UnfoldStep.java | 20 +
.../gremlin/language/model/steps/UnionStep.java | 29 +
.../gremlin/language/model/steps/UntilStep.java | 99 +
.../gremlin/language/model/steps/VStep.java | 29 +
.../gremlin/language/model/steps/ValueMapStep.java | 49 +
.../gremlin/language/model/steps/ValueStep.java | 20 +
.../gremlin/language/model/steps/ValuesStep.java | 27 +
.../gremlin/language/model/steps/WhereStep.java | 138 +
.../gremlin/language/model/steps/WithStep.java | 51 +
.../gremlin/language/model/steps/WriteStep.java | 20 +
.../traversal/ChainedParentOfGraphTraversal.java | 51 +
.../language/model/traversal/ChainedTraversal.java | 147 +
.../traversal/EdgeLabelVerificationStrategy.java | 96 +
.../language/model/traversal/NestedTraversal.java | 135 +
.../model/traversal/PartitionStrategy.java | 170 +
.../ReservedKeysVerificationStrategy.java | 133 +
.../language/model/traversal/RootTraversal.java | 160 +
.../language/model/traversal/SubgraphStrategy.java | 170 +
.../model/traversal/TraversalBiFunction.java | 27 +
.../model/traversal/TraversalCardinality.java | 9 +
.../language/model/traversal/TraversalColumn.java | 7 +
.../model/traversal/TraversalComparator.java | 27 +
.../model/traversal/TraversalDirection.java | 9 +
.../model/traversal/TraversalFunction.java | 96 +
.../model/traversal/TraversalOperator.java | 25 +
.../model/traversal/TraversalOptionParent.java | 7 +
.../language/model/traversal/TraversalOrder.java | 13 +
.../language/model/traversal/TraversalPop.java | 11 +
.../language/model/traversal/TraversalScope.java | 7 +
.../language/model/traversal/TraversalSource.java | 27 +
.../model/traversal/TraversalSourceSelfMethod.java | 244 ++
.../traversal/TraversalSourceSpawnMethod.java | 281 ++
.../model/traversal/TraversalStrategy.java | 223 ++
.../language/model/traversal/TraversalToken.java | 11 +
.../gremlin/language/model/traversal/With.java | 51 +
.../gremlin/language/model/traversal/WithBulk.java | 27 +
.../gremlin/language/model/traversal/WithPath.java | 20 +
.../gremlin/language/model/traversal/WithSack.java | 51 +
.../language/model/traversal/WithSideEffect.java | 52 +
.../language/model/traversal/WithStrategies.java | 27 +
174 files changed, 15099 insertions(+)
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/GremlinStringConstant.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/GremlinStringConstant.java
new file mode 100644
index 0000000..dbde300
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/GremlinStringConstant.java
@@ -0,0 +1,170 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.constants;
+
+public abstract class GremlinStringConstant {
+ private GremlinStringConstant() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a GremlinStringConstant according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(WithOptions instance) ;
+
+ R visit(ShortestPath instance) ;
+
+ R visit(PageRank instance) ;
+
+ R visit(PeerPressure instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a GremlinStringConstant according to its variant (subclass). If a visit()
+ * method for a particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(GremlinStringConstant instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(WithOptions instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(ShortestPath instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(PageRank instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(PeerPressure instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/constants.WithOptionsStringConstant
+ */
+ public static final class WithOptions extends GremlinStringConstant {
+ public final WithOptionsStringConstant withOptions;
+
+ /**
+ * Constructs an immutable WithOptions object
+ */
+ public WithOptions(WithOptionsStringConstant withOptions) {
+ this.withOptions = withOptions;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithOptions)) return false;
+ WithOptions o = (WithOptions) other;
+ return withOptions.equals(o.withOptions);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withOptions.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/constants.ShortestPathStringConstant
+ */
+ public static final class ShortestPath extends GremlinStringConstant {
+ public final ShortestPathStringConstant shortestPath;
+
+ /**
+ * Constructs an immutable ShortestPath object
+ */
+ public ShortestPath(ShortestPathStringConstant shortestPath) {
+ this.shortestPath = shortestPath;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ShortestPath)) return false;
+ ShortestPath o = (ShortestPath) other;
+ return shortestPath.equals(o.shortestPath);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * shortestPath.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/constants.PageRankStringConstant
+ */
+ public static final class PageRank extends GremlinStringConstant {
+ public final PageRankStringConstant pageRank;
+
+ /**
+ * Constructs an immutable PageRank object
+ */
+ public PageRank(PageRankStringConstant pageRank) {
+ this.pageRank = pageRank;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof PageRank)) return false;
+ PageRank o = (PageRank) other;
+ return pageRank.equals(o.pageRank);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * pageRank.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/constants.PeerPressureStringConstant
+ */
+ public static final class PeerPressure extends GremlinStringConstant {
+ public final PeerPressureStringConstant peerPressure;
+
+ /**
+ * Constructs an immutable PeerPressure object
+ */
+ public PeerPressure(PeerPressureStringConstant peerPressure) {
+ this.peerPressure = peerPressure;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof PeerPressure)) return false;
+ PeerPressure o = (PeerPressure) other;
+ return peerPressure.equals(o.peerPressure);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * peerPressure.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/PageRankStringConstant.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/PageRankStringConstant.java
new file mode 100644
index 0000000..75d1049
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/PageRankStringConstant.java
@@ -0,0 +1,9 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.constants;
+
+public enum PageRankStringConstant {
+ EDGES,
+
+ TIMES,
+
+ PROPERTY_NAME;
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/PeerPressureStringConstant.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/PeerPressureStringConstant.java
new file mode 100644
index 0000000..8da2174
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/PeerPressureStringConstant.java
@@ -0,0 +1,9 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.constants;
+
+public enum PeerPressureStringConstant {
+ EDGES,
+
+ TIMES,
+
+ PROPERTY_NAME;
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/ShortestPathStringConstant.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/ShortestPathStringConstant.java
new file mode 100644
index 0000000..88fa00b
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/ShortestPathStringConstant.java
@@ -0,0 +1,23 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.constants;
+
+public enum ShortestPathStringConstant {
+ TOKENS,
+
+ NONE,
+
+ IDS,
+
+ LABELS,
+
+ KEYS,
+
+ VALUES,
+
+ ALL,
+
+ INDEXER,
+
+ LIST,
+
+ MAP;
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/WithOptionsStringConstant.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/WithOptionsStringConstant.java
new file mode 100644
index 0000000..6dc49ab
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/constants/WithOptionsStringConstant.java
@@ -0,0 +1,23 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.constants;
+
+public enum WithOptionsStringConstant {
+ TOKENS,
+
+ NONE,
+
+ IDS,
+
+ LABELS,
+
+ KEYS,
+
+ VALUES,
+
+ ALL,
+
+ INDEXER,
+
+ LIST,
+
+ MAP;
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/DateLiteral.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/DateLiteral.java
new file mode 100644
index 0000000..88673f0
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/DateLiteral.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.literals;
+
+/**
+ * @type string
+ */
+public class DateLiteral {
+ public final String value;
+
+ /**
+ * Constructs an immutable DateLiteral object
+ */
+ public DateLiteral(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof DateLiteral)) return false;
+ DateLiteral o = (DateLiteral) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/EmptyStringLiteral.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/EmptyStringLiteral.java
new file mode 100644
index 0000000..2ea06de
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/EmptyStringLiteral.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.literals;
+
+public class EmptyStringLiteral {
+ /**
+ * Constructs an immutable EmptyStringLiteral object
+ */
+ public EmptyStringLiteral() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof EmptyStringLiteral)) return false;
+ EmptyStringLiteral o = (EmptyStringLiteral) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/GenericLiteral.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/GenericLiteral.java
new file mode 100644
index 0000000..273ff890
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/GenericLiteral.java
@@ -0,0 +1,260 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.literals;
+
+public abstract class GenericLiteral {
+ private GenericLiteral() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class NullValue {
+ /**
+ * Constructs an immutable NullValue object
+ */
+ public NullValue() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NullValue)) return false;
+ NullValue o = (NullValue) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+ }
+
+ /**
+ * An interface for applying a function to a GenericLiteral according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(IntegerEsc instance) ;
+
+ R visit(FloatEsc instance) ;
+
+ R visit(BooleanEsc instance) ;
+
+ R visit(StringEsc instance) ;
+
+ R visit(Date instance) ;
+
+ R visit(Null instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a GenericLiteral according to its variant (subclass). If a visit() method for
+ * a particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(GenericLiteral instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(IntegerEsc instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(FloatEsc instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(BooleanEsc instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(StringEsc instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Date instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Null instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type integer
+ */
+ public static final class IntegerEsc extends GenericLiteral {
+ public final Integer integer;
+
+ /**
+ * Constructs an immutable IntegerEsc object
+ */
+ public IntegerEsc(Integer integer) {
+ this.integer = integer;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof IntegerEsc)) return false;
+ IntegerEsc o = (IntegerEsc) other;
+ return integer.equals(o.integer);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * integer.hashCode();
+ }
+ }
+
+ /**
+ * @type float
+ */
+ public static final class FloatEsc extends GenericLiteral {
+ public final Float floatEsc;
+
+ /**
+ * Constructs an immutable FloatEsc object
+ */
+ public FloatEsc(Float floatEsc) {
+ this.floatEsc = floatEsc;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof FloatEsc)) return false;
+ FloatEsc o = (FloatEsc) other;
+ return floatEsc.equals(o.floatEsc);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * floatEsc.hashCode();
+ }
+ }
+
+ /**
+ * @type boolean
+ */
+ public static final class BooleanEsc extends GenericLiteral {
+ public final Boolean booleanEsc;
+
+ /**
+ * Constructs an immutable BooleanEsc object
+ */
+ public BooleanEsc(Boolean booleanEsc) {
+ this.booleanEsc = booleanEsc;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof BooleanEsc)) return false;
+ BooleanEsc o = (BooleanEsc) other;
+ return booleanEsc.equals(o.booleanEsc);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * booleanEsc.hashCode();
+ }
+ }
+
+ /**
+ * @type string
+ */
+ public static final class StringEsc extends GenericLiteral {
+ public final String string;
+
+ /**
+ * Constructs an immutable StringEsc object
+ */
+ public StringEsc(String string) {
+ this.string = string;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof StringEsc)) return false;
+ StringEsc o = (StringEsc) other;
+ return string.equals(o.string);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * string.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.DateLiteral
+ */
+ public static final class Date extends GenericLiteral {
+ public final DateLiteral date;
+
+ /**
+ * Constructs an immutable Date object
+ */
+ public Date(DateLiteral date) {
+ this.date = date;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Date)) return false;
+ Date o = (Date) other;
+ return date.equals(o.date);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * date.hashCode();
+ }
+ }
+
+ public static final class Null extends GenericLiteral {
+ public final NullValue nullEsc;
+
+ /**
+ * Constructs an immutable Null object
+ */
+ public Null(NullValue nullEsc) {
+ this.nullEsc = nullEsc;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Null)) return false;
+ Null o = (Null) other;
+ return nullEsc.equals(o.nullEsc);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * nullEsc.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/NonEmptyStringLiteral.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/NonEmptyStringLiteral.java
new file mode 100644
index 0000000..f03a53c
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/NonEmptyStringLiteral.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.literals;
+
+/**
+ * @type string
+ */
+public class NonEmptyStringLiteral {
+ public final String value;
+
+ /**
+ * Constructs an immutable NonEmptyStringLiteral object
+ */
+ public NonEmptyStringLiteral(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NonEmptyStringLiteral)) return false;
+ NonEmptyStringLiteral o = (NonEmptyStringLiteral) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/StringLiteral.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/StringLiteral.java
new file mode 100644
index 0000000..596438e
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/literals/StringLiteral.java
@@ -0,0 +1,135 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.literals;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.constants.GremlinStringConstant;
+
+public abstract class StringLiteral {
+ private StringLiteral() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a StringLiteral according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Empty instance) ;
+
+ R visit(NonEmpty instance) ;
+
+ R visit(Constant instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a StringLiteral according to its variant (subclass). If a visit() method for
+ * a particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(StringLiteral instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Empty instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(NonEmpty instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Constant instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.EmptyStringLiteral
+ */
+ public static final class Empty extends StringLiteral {
+ public final EmptyStringLiteral empty;
+
+ /**
+ * Constructs an immutable Empty object
+ */
+ public Empty(EmptyStringLiteral empty) {
+ this.empty = empty;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Empty)) return false;
+ Empty o = (Empty) other;
+ return empty.equals(o.empty);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * empty.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.NonEmptyStringLiteral
+ */
+ public static final class NonEmpty extends StringLiteral {
+ public final NonEmptyStringLiteral nonEmpty;
+
+ /**
+ * Constructs an immutable NonEmpty object
+ */
+ public NonEmpty(NonEmptyStringLiteral nonEmpty) {
+ this.nonEmpty = nonEmpty;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NonEmpty)) return false;
+ NonEmpty o = (NonEmpty) other;
+ return nonEmpty.equals(o.nonEmpty);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * nonEmpty.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/constants.GremlinStringConstant
+ */
+ public static final class Constant extends StringLiteral {
+ public final GremlinStringConstant constant;
+
+ /**
+ * Constructs an immutable Constant object
+ */
+ public Constant(GremlinStringConstant constant) {
+ this.constant = constant;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Constant)) return false;
+ Constant o = (Constant) other;
+ return constant.equals(o.constant);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * constant.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ExplainMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ExplainMethod.java
new file mode 100644
index 0000000..36a7d8c
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ExplainMethod.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+public class ExplainMethod {
+ /**
+ * Constructs an immutable ExplainMethod object
+ */
+ public ExplainMethod() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ExplainMethod)) return false;
+ ExplainMethod o = (ExplainMethod) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/HasNextMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/HasNextMethod.java
new file mode 100644
index 0000000..3cf3e84
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/HasNextMethod.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+public class HasNextMethod {
+ /**
+ * Constructs an immutable HasNextMethod object
+ */
+ public HasNextMethod() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof HasNextMethod)) return false;
+ HasNextMethod o = (HasNextMethod) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/IterateMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/IterateMethod.java
new file mode 100644
index 0000000..e656836
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/IterateMethod.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+public class IterateMethod {
+ /**
+ * Constructs an immutable IterateMethod object
+ */
+ public IterateMethod() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof IterateMethod)) return false;
+ IterateMethod o = (IterateMethod) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/NextMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/NextMethod.java
new file mode 100644
index 0000000..2e1b1f2
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/NextMethod.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+/**
+ * @type optional: integer
+ */
+public class NextMethod {
+ public final java.util.Optional<Integer> value;
+
+ /**
+ * Constructs an immutable NextMethod object
+ */
+ public NextMethod(java.util.Optional<Integer> value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NextMethod)) return false;
+ NextMethod o = (NextMethod) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ToBulkSetMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ToBulkSetMethod.java
new file mode 100644
index 0000000..c63f12f
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ToBulkSetMethod.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+public class ToBulkSetMethod {
+ /**
+ * Constructs an immutable ToBulkSetMethod object
+ */
+ public ToBulkSetMethod() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToBulkSetMethod)) return false;
+ ToBulkSetMethod o = (ToBulkSetMethod) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ToListMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ToListMethod.java
new file mode 100644
index 0000000..1ecc25b
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ToListMethod.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+public class ToListMethod {
+ /**
+ * Constructs an immutable ToListMethod object
+ */
+ public ToListMethod() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToListMethod)) return false;
+ ToListMethod o = (ToListMethod) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ToSetMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ToSetMethod.java
new file mode 100644
index 0000000..a7b8370
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/ToSetMethod.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+public class ToSetMethod {
+ /**
+ * Constructs an immutable ToSetMethod object
+ */
+ public ToSetMethod() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToSetMethod)) return false;
+ ToSetMethod o = (ToSetMethod) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TraversalSackMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TraversalSackMethod.java
new file mode 100644
index 0000000..0f5d4f6
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TraversalSackMethod.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+public class TraversalSackMethod {
+ /**
+ * Constructs an immutable TraversalSackMethod object
+ */
+ public TraversalSackMethod() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof TraversalSackMethod)) return false;
+ TraversalSackMethod o = (TraversalSackMethod) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TraversalSelfMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TraversalSelfMethod.java
new file mode 100644
index 0000000..8e3484f
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TraversalSelfMethod.java
@@ -0,0 +1,75 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+public abstract class TraversalSelfMethod {
+ private TraversalSelfMethod() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class NoneValue {
+ /**
+ * Constructs an immutable NoneValue object
+ */
+ public NoneValue() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NoneValue)) return false;
+ NoneValue o = (NoneValue) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+ }
+
+ /**
+ * An interface for applying a function to a TraversalSelfMethod according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(None instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a TraversalSelfMethod according to its variant (subclass). If a visit()
+ * method for a particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(TraversalSelfMethod instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(None instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class None extends TraversalSelfMethod {
+ public final NoneValue none;
+
+ /**
+ * Constructs an immutable None object
+ */
+ public None(NoneValue none) {
+ this.none = none;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof None)) return false;
+ None o = (None) other;
+ return none.equals(o.none);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * none.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TraversalTerminalMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TraversalTerminalMethod.java
new file mode 100644
index 0000000..3b099dd
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TraversalTerminalMethod.java
@@ -0,0 +1,318 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+public abstract class TraversalTerminalMethod {
+ private TraversalTerminalMethod() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a TraversalTerminalMethod according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Explain instance) ;
+
+ R visit(Iterate instance) ;
+
+ R visit(HasNext instance) ;
+
+ R visit(TryNext instance) ;
+
+ R visit(Next instance) ;
+
+ R visit(ToList instance) ;
+
+ R visit(ToSet instance) ;
+
+ R visit(ToBulkSet instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a TraversalTerminalMethod according to its variant (subclass). If a visit()
+ * method for a particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(TraversalTerminalMethod instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Explain instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Iterate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(HasNext instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(TryNext instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Next instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(ToList instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(ToSet instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(ToBulkSet instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/methods.ExplainMethod
+ */
+ public static final class Explain extends TraversalTerminalMethod {
+ public final ExplainMethod explain;
+
+ /**
+ * Constructs an immutable Explain object
+ */
+ public Explain(ExplainMethod explain) {
+ this.explain = explain;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Explain)) return false;
+ Explain o = (Explain) other;
+ return explain.equals(o.explain);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * explain.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/methods.IterateMethod
+ */
+ public static final class Iterate extends TraversalTerminalMethod {
+ public final IterateMethod iterate;
+
+ /**
+ * Constructs an immutable Iterate object
+ */
+ public Iterate(IterateMethod iterate) {
+ this.iterate = iterate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Iterate)) return false;
+ Iterate o = (Iterate) other;
+ return iterate.equals(o.iterate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * iterate.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/methods.HasNextMethod
+ */
+ public static final class HasNext extends TraversalTerminalMethod {
+ public final HasNextMethod hasNext;
+
+ /**
+ * Constructs an immutable HasNext object
+ */
+ public HasNext(HasNextMethod hasNext) {
+ this.hasNext = hasNext;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof HasNext)) return false;
+ HasNext o = (HasNext) other;
+ return hasNext.equals(o.hasNext);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * hasNext.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/methods.TryNextMethod
+ */
+ public static final class TryNext extends TraversalTerminalMethod {
+ public final TryNextMethod tryNext;
+
+ /**
+ * Constructs an immutable TryNext object
+ */
+ public TryNext(TryNextMethod tryNext) {
+ this.tryNext = tryNext;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof TryNext)) return false;
+ TryNext o = (TryNext) other;
+ return tryNext.equals(o.tryNext);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * tryNext.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/methods.NextMethod
+ */
+ public static final class Next extends TraversalTerminalMethod {
+ public final NextMethod next;
+
+ /**
+ * Constructs an immutable Next object
+ */
+ public Next(NextMethod next) {
+ this.next = next;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Next)) return false;
+ Next o = (Next) other;
+ return next.equals(o.next);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * next.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/methods.ToListMethod
+ */
+ public static final class ToList extends TraversalTerminalMethod {
+ public final ToListMethod toList;
+
+ /**
+ * Constructs an immutable ToList object
+ */
+ public ToList(ToListMethod toList) {
+ this.toList = toList;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToList)) return false;
+ ToList o = (ToList) other;
+ return toList.equals(o.toList);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * toList.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/methods.ToSetMethod
+ */
+ public static final class ToSet extends TraversalTerminalMethod {
+ public final ToSetMethod toSet;
+
+ /**
+ * Constructs an immutable ToSet object
+ */
+ public ToSet(ToSetMethod toSet) {
+ this.toSet = toSet;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToSet)) return false;
+ ToSet o = (ToSet) other;
+ return toSet.equals(o.toSet);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * toSet.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/methods.ToBulkSetMethod
+ */
+ public static final class ToBulkSet extends TraversalTerminalMethod {
+ public final ToBulkSetMethod toBulkSet;
+
+ /**
+ * Constructs an immutable ToBulkSet object
+ */
+ public ToBulkSet(ToBulkSetMethod toBulkSet) {
+ this.toBulkSet = toBulkSet;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToBulkSet)) return false;
+ ToBulkSet o = (ToBulkSet) other;
+ return toBulkSet.equals(o.toBulkSet);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * toBulkSet.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TryNextMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TryNextMethod.java
new file mode 100644
index 0000000..527c949
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/methods/TryNextMethod.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.methods;
+
+public class TryNextMethod {
+ /**
+ * Constructs an immutable TryNextMethod object
+ */
+ public TryNextMethod() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof TryNextMethod)) return false;
+ TryNextMethod o = (TryNextMethod) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Between.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Between.java
new file mode 100644
index 0000000..48659d5
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Between.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+public class Between {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final GenericLiteral min;
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final GenericLiteral max;
+
+ /**
+ * Constructs an immutable Between object
+ */
+ public Between(GenericLiteral min, GenericLiteral max) {
+ this.min = min;
+ this.max = max;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Between)) return false;
+ Between o = (Between) other;
+ return min.equals(o.min)
+ && max.equals(o.max);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * min.hashCode()
+ + 3 * max.hashCode();
+ }
+
+ /**
+ * Construct a new immutable Between object in which min is overridden
+ */
+ public Between withMin(GenericLiteral min) {
+ return new Between(min, max);
+ }
+
+ /**
+ * Construct a new immutable Between object in which max is overridden
+ */
+ public Between withMax(GenericLiteral max) {
+ return new Between(min, max);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Containing.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Containing.java
new file mode 100644
index 0000000..6938108
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Containing.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+/**
+ * @type string
+ */
+public class Containing {
+ public final String value;
+
+ /**
+ * Constructs an immutable Containing object
+ */
+ public Containing(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Containing)) return false;
+ Containing o = (Containing) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/EndingWith.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/EndingWith.java
new file mode 100644
index 0000000..b177596
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/EndingWith.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+/**
+ * @type string
+ */
+public class EndingWith {
+ public final String value;
+
+ /**
+ * Constructs an immutable EndingWith object
+ */
+ public EndingWith(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof EndingWith)) return false;
+ EndingWith o = (EndingWith) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Eq.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Eq.java
new file mode 100644
index 0000000..1baf7f7
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Eq.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+/**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+public class Eq {
+ public final GenericLiteral genericLiteral;
+
+ /**
+ * Constructs an immutable Eq object
+ */
+ public Eq(GenericLiteral genericLiteral) {
+ this.genericLiteral = genericLiteral;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Eq)) return false;
+ Eq o = (Eq) other;
+ return genericLiteral.equals(o.genericLiteral);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * genericLiteral.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Gt.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Gt.java
new file mode 100644
index 0000000..ec783f1
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Gt.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+/**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+public class Gt {
+ public final GenericLiteral genericLiteral;
+
+ /**
+ * Constructs an immutable Gt object
+ */
+ public Gt(GenericLiteral genericLiteral) {
+ this.genericLiteral = genericLiteral;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Gt)) return false;
+ Gt o = (Gt) other;
+ return genericLiteral.equals(o.genericLiteral);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * genericLiteral.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Gte.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Gte.java
new file mode 100644
index 0000000..e360e6b
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Gte.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+/**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+public class Gte {
+ public final GenericLiteral genericLiteral;
+
+ /**
+ * Constructs an immutable Gte object
+ */
+ public Gte(GenericLiteral genericLiteral) {
+ this.genericLiteral = genericLiteral;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Gte)) return false;
+ Gte o = (Gte) other;
+ return genericLiteral.equals(o.genericLiteral);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * genericLiteral.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Inside.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Inside.java
new file mode 100644
index 0000000..037968c
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Inside.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+public class Inside {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final GenericLiteral min;
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final GenericLiteral max;
+
+ /**
+ * Constructs an immutable Inside object
+ */
+ public Inside(GenericLiteral min, GenericLiteral max) {
+ this.min = min;
+ this.max = max;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Inside)) return false;
+ Inside o = (Inside) other;
+ return min.equals(o.min)
+ && max.equals(o.max);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * min.hashCode()
+ + 3 * max.hashCode();
+ }
+
+ /**
+ * Construct a new immutable Inside object in which min is overridden
+ */
+ public Inside withMin(GenericLiteral min) {
+ return new Inside(min, max);
+ }
+
+ /**
+ * Construct a new immutable Inside object in which max is overridden
+ */
+ public Inside withMax(GenericLiteral max) {
+ return new Inside(min, max);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Lt.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Lt.java
new file mode 100644
index 0000000..bfb5d65
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Lt.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+/**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+public class Lt {
+ public final GenericLiteral genericLiteral;
+
+ /**
+ * Constructs an immutable Lt object
+ */
+ public Lt(GenericLiteral genericLiteral) {
+ this.genericLiteral = genericLiteral;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Lt)) return false;
+ Lt o = (Lt) other;
+ return genericLiteral.equals(o.genericLiteral);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * genericLiteral.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Lte.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Lte.java
new file mode 100644
index 0000000..f172f81
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Lte.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+/**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+public class Lte {
+ public final GenericLiteral genericLiteral;
+
+ /**
+ * Constructs an immutable Lte object
+ */
+ public Lte(GenericLiteral genericLiteral) {
+ this.genericLiteral = genericLiteral;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Lte)) return false;
+ Lte o = (Lte) other;
+ return genericLiteral.equals(o.genericLiteral);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * genericLiteral.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Neq.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Neq.java
new file mode 100644
index 0000000..7f0c4b6
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Neq.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+/**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+public class Neq {
+ public final GenericLiteral genericLiteral;
+
+ /**
+ * Constructs an immutable Neq object
+ */
+ public Neq(GenericLiteral genericLiteral) {
+ this.genericLiteral = genericLiteral;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Neq)) return false;
+ Neq o = (Neq) other;
+ return genericLiteral.equals(o.genericLiteral);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * genericLiteral.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Not.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Not.java
new file mode 100644
index 0000000..7beee3a
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Not.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+/**
+ * @type string
+ */
+public class Not {
+ public final String value;
+
+ /**
+ * Constructs an immutable Not object
+ */
+ public Not(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Not)) return false;
+ Not o = (Not) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/NotContaining.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/NotContaining.java
new file mode 100644
index 0000000..919c543
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/NotContaining.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+/**
+ * @type string
+ */
+public class NotContaining {
+ public final String value;
+
+ /**
+ * Constructs an immutable NotContaining object
+ */
+ public NotContaining(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NotContaining)) return false;
+ NotContaining o = (NotContaining) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/NotEndingWith.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/NotEndingWith.java
new file mode 100644
index 0000000..e3e538f
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/NotEndingWith.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+/**
+ * @type string
+ */
+public class NotEndingWith {
+ public final String value;
+
+ /**
+ * Constructs an immutable NotEndingWith object
+ */
+ public NotEndingWith(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NotEndingWith)) return false;
+ NotEndingWith o = (NotEndingWith) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/NotStartingWith.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/NotStartingWith.java
new file mode 100644
index 0000000..3d10d6d
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/NotStartingWith.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+/**
+ * @type string
+ */
+public class NotStartingWith {
+ public final String value;
+
+ /**
+ * Constructs an immutable NotStartingWith object
+ */
+ public NotStartingWith(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NotStartingWith)) return false;
+ NotStartingWith o = (NotStartingWith) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Outside.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Outside.java
new file mode 100644
index 0000000..eb80157
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Outside.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+public class Outside {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final GenericLiteral min;
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final GenericLiteral max;
+
+ /**
+ * Constructs an immutable Outside object
+ */
+ public Outside(GenericLiteral min, GenericLiteral max) {
+ this.min = min;
+ this.max = max;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Outside)) return false;
+ Outside o = (Outside) other;
+ return min.equals(o.min)
+ && max.equals(o.max);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * min.hashCode()
+ + 3 * max.hashCode();
+ }
+
+ /**
+ * Construct a new immutable Outside object in which min is overridden
+ */
+ public Outside withMin(GenericLiteral min) {
+ return new Outside(min, max);
+ }
+
+ /**
+ * Construct a new immutable Outside object in which max is overridden
+ */
+ public Outside withMax(GenericLiteral max) {
+ return new Outside(min, max);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/StartingWith.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/StartingWith.java
new file mode 100644
index 0000000..d05cd51
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/StartingWith.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+/**
+ * @type string
+ */
+public class StartingWith {
+ public final String value;
+
+ /**
+ * Constructs an immutable StartingWith object
+ */
+ public StartingWith(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof StartingWith)) return false;
+ StartingWith o = (StartingWith) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/TraversalPredicate.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/TraversalPredicate.java
new file mode 100644
index 0000000..cd5dbe3
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/TraversalPredicate.java
@@ -0,0 +1,741 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+public abstract class TraversalPredicate {
+ private TraversalPredicate() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class NegateValue {
+ /**
+ * Constructs an immutable NegateValue object
+ */
+ public NegateValue() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NegateValue)) return false;
+ NegateValue o = (NegateValue) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+ }
+
+ /**
+ * An interface for applying a function to a TraversalPredicate according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Eq instance) ;
+
+ R visit(Neq instance) ;
+
+ R visit(Lt instance) ;
+
+ R visit(Lte instance) ;
+
+ R visit(Gt instance) ;
+
+ R visit(Gte instance) ;
+
+ R visit(Inside instance) ;
+
+ R visit(Outside instance) ;
+
+ R visit(Between instance) ;
+
+ R visit(Within instance) ;
+
+ R visit(Without instance) ;
+
+ R visit(Not instance) ;
+
+ R visit(StartingWith instance) ;
+
+ R visit(NotStartingWith instance) ;
+
+ R visit(EndingWith instance) ;
+
+ R visit(Containing instance) ;
+
+ R visit(And instance) ;
+
+ R visit(Or instance) ;
+
+ R visit(Negate instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a TraversalPredicate according to its variant (subclass). If a visit() method
+ * for a particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(TraversalPredicate instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Eq instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Neq instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Lt instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Lte instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Gt instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Gte instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Inside instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Outside instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Between instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Within instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Without instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Not instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(StartingWith instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(NotStartingWith instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(EndingWith instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Containing instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(And instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Or instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Negate instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Eq
+ */
+ public static final class Eq extends TraversalPredicate {
+ public final Eq eq;
+
+ /**
+ * Constructs an immutable Eq object
+ */
+ public Eq(Eq eq) {
+ this.eq = eq;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Eq)) return false;
+ Eq o = (Eq) other;
+ return eq.equals(o.eq);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * eq.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Neq
+ */
+ public static final class Neq extends TraversalPredicate {
+ public final Neq neq;
+
+ /**
+ * Constructs an immutable Neq object
+ */
+ public Neq(Neq neq) {
+ this.neq = neq;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Neq)) return false;
+ Neq o = (Neq) other;
+ return neq.equals(o.neq);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * neq.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Lt
+ */
+ public static final class Lt extends TraversalPredicate {
+ public final Lt lt;
+
+ /**
+ * Constructs an immutable Lt object
+ */
+ public Lt(Lt lt) {
+ this.lt = lt;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Lt)) return false;
+ Lt o = (Lt) other;
+ return lt.equals(o.lt);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * lt.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Lte
+ */
+ public static final class Lte extends TraversalPredicate {
+ public final Lte lte;
+
+ /**
+ * Constructs an immutable Lte object
+ */
+ public Lte(Lte lte) {
+ this.lte = lte;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Lte)) return false;
+ Lte o = (Lte) other;
+ return lte.equals(o.lte);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * lte.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Gt
+ */
+ public static final class Gt extends TraversalPredicate {
+ public final Gt gt;
+
+ /**
+ * Constructs an immutable Gt object
+ */
+ public Gt(Gt gt) {
+ this.gt = gt;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Gt)) return false;
+ Gt o = (Gt) other;
+ return gt.equals(o.gt);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * gt.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Gte
+ */
+ public static final class Gte extends TraversalPredicate {
+ public final Gte gte;
+
+ /**
+ * Constructs an immutable Gte object
+ */
+ public Gte(Gte gte) {
+ this.gte = gte;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Gte)) return false;
+ Gte o = (Gte) other;
+ return gte.equals(o.gte);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * gte.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Inside
+ */
+ public static final class Inside extends TraversalPredicate {
+ public final Inside inside;
+
+ /**
+ * Constructs an immutable Inside object
+ */
+ public Inside(Inside inside) {
+ this.inside = inside;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Inside)) return false;
+ Inside o = (Inside) other;
+ return inside.equals(o.inside);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * inside.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Outside
+ */
+ public static final class Outside extends TraversalPredicate {
+ public final Outside outside;
+
+ /**
+ * Constructs an immutable Outside object
+ */
+ public Outside(Outside outside) {
+ this.outside = outside;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Outside)) return false;
+ Outside o = (Outside) other;
+ return outside.equals(o.outside);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * outside.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Between
+ */
+ public static final class Between extends TraversalPredicate {
+ public final Between between;
+
+ /**
+ * Constructs an immutable Between object
+ */
+ public Between(Between between) {
+ this.between = between;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Between)) return false;
+ Between o = (Between) other;
+ return between.equals(o.between);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * between.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Within
+ */
+ public static final class Within extends TraversalPredicate {
+ public final Within within;
+
+ /**
+ * Constructs an immutable Within object
+ */
+ public Within(Within within) {
+ this.within = within;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Within)) return false;
+ Within o = (Within) other;
+ return within.equals(o.within);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * within.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Without
+ */
+ public static final class Without extends TraversalPredicate {
+ public final Without without;
+
+ /**
+ * Constructs an immutable Without object
+ */
+ public Without(Without without) {
+ this.without = without;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Without)) return false;
+ Without o = (Without) other;
+ return without.equals(o.without);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * without.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.Not
+ */
+ public static final class Not extends TraversalPredicate {
+ public final Not not;
+
+ /**
+ * Constructs an immutable Not object
+ */
+ public Not(Not not) {
+ this.not = not;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Not)) return false;
+ Not o = (Not) other;
+ return not.equals(o.not);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * not.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.StartingWith
+ */
+ public static final class StartingWith extends TraversalPredicate {
+ public final StartingWith startingWith;
+
+ /**
+ * Constructs an immutable StartingWith object
+ */
+ public StartingWith(StartingWith startingWith) {
+ this.startingWith = startingWith;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof StartingWith)) return false;
+ StartingWith o = (StartingWith) other;
+ return startingWith.equals(o.startingWith);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * startingWith.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.NotStartingWith
+ */
+ public static final class NotStartingWith extends TraversalPredicate {
+ public final NotStartingWith notStartingWith;
+
+ /**
+ * Constructs an immutable NotStartingWith object
+ */
+ public NotStartingWith(NotStartingWith notStartingWith) {
+ this.notStartingWith = notStartingWith;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NotStartingWith)) return false;
+ NotStartingWith o = (NotStartingWith) other;
+ return notStartingWith.equals(o.notStartingWith);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * notStartingWith.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.NotEndingWith
+ */
+ public static final class EndingWith extends TraversalPredicate {
+ public final NotEndingWith endingWith;
+
+ /**
+ * Constructs an immutable EndingWith object
+ */
+ public EndingWith(NotEndingWith endingWith) {
+ this.endingWith = endingWith;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof EndingWith)) return false;
+ EndingWith o = (EndingWith) other;
+ return endingWith.equals(o.endingWith);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * endingWith.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.NotContaining
+ */
+ public static final class Containing extends TraversalPredicate {
+ public final NotContaining containing;
+
+ /**
+ * Constructs an immutable Containing object
+ */
+ public Containing(NotContaining containing) {
+ this.containing = containing;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Containing)) return false;
+ Containing o = (Containing) other;
+ return containing.equals(o.containing);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * containing.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.TraversalPredicate
+ */
+ public static final class And extends TraversalPredicate {
+ public final TraversalPredicate and;
+
+ /**
+ * Constructs an immutable And object
+ */
+ public And(TraversalPredicate and) {
+ this.and = and;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof And)) return false;
+ And o = (And) other;
+ return and.equals(o.and);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * and.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.TraversalPredicate
+ */
+ public static final class Or extends TraversalPredicate {
+ public final TraversalPredicate or;
+
+ /**
+ * Constructs an immutable Or object
+ */
+ public Or(TraversalPredicate or) {
+ this.or = or;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Or)) return false;
+ Or o = (Or) other;
+ return or.equals(o.or);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * or.hashCode();
+ }
+ }
+
+ public static final class Negate extends TraversalPredicate {
+ public final NegateValue negate;
+
+ /**
+ * Constructs an immutable Negate object
+ */
+ public Negate(NegateValue negate) {
+ this.negate = negate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Negate)) return false;
+ Negate o = (Negate) other;
+ return negate.equals(o.negate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * negate.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Within.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Within.java
new file mode 100644
index 0000000..cbc1fbf
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Within.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+/**
+ * @type list: org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+public class Within {
+ public final java.util.List<GenericLiteral> value;
+
+ /**
+ * Constructs an immutable Within object
+ */
+ public Within(java.util.List<GenericLiteral> value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Within)) return false;
+ Within o = (Within) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Without.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Without.java
new file mode 100644
index 0000000..f2db1ac
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/predicates/Without.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.predicates;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+/**
+ * @type list: org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+public class Without {
+ public final java.util.List<GenericLiteral> value;
+
+ /**
+ * Constructs an immutable Without object
+ */
+ public Without(java.util.List<GenericLiteral> value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Without)) return false;
+ Without o = (Without) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/query/Query.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/query/Query.java
new file mode 100644
index 0000000..511cd96
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/query/Query.java
@@ -0,0 +1,268 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.query;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.methods.TraversalTerminalMethod;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.RootTraversal;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalSource;
+
+public abstract class Query {
+ private Query() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class EmptyValue {
+ /**
+ * Constructs an immutable EmptyValue object
+ */
+ public EmptyValue() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof EmptyValue)) return false;
+ EmptyValue o = (EmptyValue) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+ }
+
+ public static class WithRootValue {
+ public final RootTraversal root;
+
+ public final java.util.Optional<TraversalTerminalMethod> method;
+
+ /**
+ * Constructs an immutable WithRootValue object
+ */
+ public WithRootValue(RootTraversal root, java.util.Optional<TraversalTerminalMethod> method) {
+ this.root = root;
+ this.method = method;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithRootValue)) return false;
+ WithRootValue o = (WithRootValue) other;
+ return root.equals(o.root)
+ && method.equals(o.method);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * root.hashCode()
+ + 3 * method.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithRootValue object in which root is overridden
+ */
+ public WithRootValue withRoot(RootTraversal root) {
+ return new WithRootValue(root, method);
+ }
+
+ /**
+ * Construct a new immutable WithRootValue object in which method is overridden
+ */
+ public WithRootValue withMethod(java.util.Optional<TraversalTerminalMethod> method) {
+ return new WithRootValue(root, method);
+ }
+ }
+
+ public static class WithSourceValue {
+ public final TraversalSource source;
+
+ public final java.util.Optional<TransactionPart> transactionPart;
+
+ /**
+ * Constructs an immutable WithSourceValue object
+ */
+ public WithSourceValue(TraversalSource source, java.util.Optional<TransactionPart> transactionPart) {
+ this.source = source;
+ this.transactionPart = transactionPart;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithSourceValue)) return false;
+ WithSourceValue o = (WithSourceValue) other;
+ return source.equals(o.source)
+ && transactionPart.equals(o.transactionPart);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * source.hashCode()
+ + 3 * transactionPart.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithSourceValue object in which source is overridden
+ */
+ public WithSourceValue withSource(TraversalSource source) {
+ return new WithSourceValue(source, transactionPart);
+ }
+
+ /**
+ * Construct a new immutable WithSourceValue object in which transactionPart is overridden
+ */
+ public WithSourceValue withTransactionPart(java.util.Optional<TransactionPart> transactionPart) {
+ return new WithSourceValue(source, transactionPart);
+ }
+ }
+
+ /**
+ * An interface for applying a function to a Query according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(WithSource instance) ;
+
+ R visit(WithRoot instance) ;
+
+ R visit(ToString instance) ;
+
+ R visit(Empty instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a Query according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(Query instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(WithSource instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithRoot instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(ToString instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Empty instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class WithSource extends Query {
+ public final WithSourceValue withSource;
+
+ /**
+ * Constructs an immutable WithSource object
+ */
+ public WithSource(WithSourceValue withSource) {
+ this.withSource = withSource;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithSource)) return false;
+ WithSource o = (WithSource) other;
+ return withSource.equals(o.withSource);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withSource.hashCode();
+ }
+ }
+
+ public static final class WithRoot extends Query {
+ public final WithRootValue withRoot;
+
+ /**
+ * Constructs an immutable WithRoot object
+ */
+ public WithRoot(WithRootValue withRoot) {
+ this.withRoot = withRoot;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithRoot)) return false;
+ WithRoot o = (WithRoot) other;
+ return withRoot.equals(o.withRoot);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withRoot.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/query.Query
+ */
+ public static final class ToString extends Query {
+ public final Query toString;
+
+ /**
+ * Constructs an immutable ToString object
+ */
+ public ToString(Query toString) {
+ this.toString = toString;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToString)) return false;
+ ToString o = (ToString) other;
+ return toString.equals(o.toString);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * toString.hashCode();
+ }
+ }
+
+ public static final class Empty extends Query {
+ public final EmptyValue empty;
+
+ /**
+ * Constructs an immutable Empty object
+ */
+ public Empty(EmptyValue empty) {
+ this.empty = empty;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Empty)) return false;
+ Empty o = (Empty) other;
+ return empty.equals(o.empty);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * empty.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/query/TransactionPart.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/query/TransactionPart.java
new file mode 100644
index 0000000..748ea90
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/query/TransactionPart.java
@@ -0,0 +1,7 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.query;
+
+public enum TransactionPart {
+ COMMIT,
+
+ ROLLBACK;
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AddEStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AddEStep.java
new file mode 100644
index 0000000..f1a2aa9
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AddEStep.java
@@ -0,0 +1,98 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public abstract class AddEStep {
+ private AddEStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a AddEStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(EdgeLabel instance) ;
+
+ R visit(EdgeLabelTraversal instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a AddEStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(AddEStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(EdgeLabel instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(EdgeLabelTraversal instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type string
+ */
+ public static final class EdgeLabel extends AddEStep {
+ public final String edgeLabel;
+
+ /**
+ * Constructs an immutable EdgeLabel object
+ */
+ public EdgeLabel(String edgeLabel) {
+ this.edgeLabel = edgeLabel;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof EdgeLabel)) return false;
+ EdgeLabel o = (EdgeLabel) other;
+ return edgeLabel.equals(o.edgeLabel);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * edgeLabel.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public static final class EdgeLabelTraversal extends AddEStep {
+ public final NestedTraversal edgeLabelTraversal;
+
+ /**
+ * Constructs an immutable EdgeLabelTraversal object
+ */
+ public EdgeLabelTraversal(NestedTraversal edgeLabelTraversal) {
+ this.edgeLabelTraversal = edgeLabelTraversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof EdgeLabelTraversal)) return false;
+ EdgeLabelTraversal o = (EdgeLabelTraversal) other;
+ return edgeLabelTraversal.equals(o.edgeLabelTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * edgeLabelTraversal.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AddVStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AddVStep.java
new file mode 100644
index 0000000..59471ce
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AddVStep.java
@@ -0,0 +1,204 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public abstract class AddVStep {
+ private AddVStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class NullValue {
+ /**
+ * Constructs an immutable NullValue object
+ */
+ public NullValue() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NullValue)) return false;
+ NullValue o = (NullValue) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+ }
+
+ public static class EmptyValue {
+ /**
+ * Constructs an immutable EmptyValue object
+ */
+ public EmptyValue() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof EmptyValue)) return false;
+ EmptyValue o = (EmptyValue) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+ }
+
+ /**
+ * An interface for applying a function to a AddVStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Empty instance) ;
+
+ R visit(VertexLabel instance) ;
+
+ R visit(Null instance) ;
+
+ R visit(VertexLabelTraversal instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a AddVStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(AddVStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Empty instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(VertexLabel instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Null instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(VertexLabelTraversal instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class Empty extends AddVStep {
+ public final EmptyValue empty;
+
+ /**
+ * Constructs an immutable Empty object
+ */
+ public Empty(EmptyValue empty) {
+ this.empty = empty;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Empty)) return false;
+ Empty o = (Empty) other;
+ return empty.equals(o.empty);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * empty.hashCode();
+ }
+ }
+
+ /**
+ * @type string
+ */
+ public static final class VertexLabel extends AddVStep {
+ public final String vertexLabel;
+
+ /**
+ * Constructs an immutable VertexLabel object
+ */
+ public VertexLabel(String vertexLabel) {
+ this.vertexLabel = vertexLabel;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof VertexLabel)) return false;
+ VertexLabel o = (VertexLabel) other;
+ return vertexLabel.equals(o.vertexLabel);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * vertexLabel.hashCode();
+ }
+ }
+
+ public static final class Null extends AddVStep {
+ public final NullValue nullEsc;
+
+ /**
+ * Constructs an immutable Null object
+ */
+ public Null(NullValue nullEsc) {
+ this.nullEsc = nullEsc;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Null)) return false;
+ Null o = (Null) other;
+ return nullEsc.equals(o.nullEsc);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * nullEsc.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public static final class VertexLabelTraversal extends AddVStep {
+ public final NestedTraversal vertexLabelTraversal;
+
+ /**
+ * Constructs an immutable VertexLabelTraversal object
+ */
+ public VertexLabelTraversal(NestedTraversal vertexLabelTraversal) {
+ this.vertexLabelTraversal = vertexLabelTraversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof VertexLabelTraversal)) return false;
+ VertexLabelTraversal o = (VertexLabelTraversal) other;
+ return vertexLabelTraversal.equals(o.vertexLabelTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * vertexLabelTraversal.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AggregateStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AggregateStep.java
new file mode 100644
index 0000000..168e931
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AggregateStep.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class AggregateStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * @type string
+ */
+ public final String sideEffectKey;
+
+ /**
+ * Constructs an immutable AggregateStep object
+ */
+ public AggregateStep(java.util.Optional<TraversalScope> scope, String sideEffectKey) {
+ this.scope = scope;
+ this.sideEffectKey = sideEffectKey;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof AggregateStep)) return false;
+ AggregateStep o = (AggregateStep) other;
+ return scope.equals(o.scope)
+ && sideEffectKey.equals(o.sideEffectKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode()
+ + 3 * sideEffectKey.hashCode();
+ }
+
+ /**
+ * Construct a new immutable AggregateStep object in which scope is overridden
+ */
+ public AggregateStep withScope(java.util.Optional<TraversalScope> scope) {
+ return new AggregateStep(scope, sideEffectKey);
+ }
+
+ /**
+ * Construct a new immutable AggregateStep object in which sideEffectKey is overridden
+ */
+ public AggregateStep withSideEffectKey(String sideEffectKey) {
+ return new AggregateStep(scope, sideEffectKey);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AndStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AndStep.java
new file mode 100644
index 0000000..86cdbe1
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AndStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class AndStep {
+ /**
+ * @type list: org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final java.util.List<NestedTraversal> andTraversals;
+
+ /**
+ * Constructs an immutable AndStep object
+ */
+ public AndStep(java.util.List<NestedTraversal> andTraversals) {
+ this.andTraversals = andTraversals;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof AndStep)) return false;
+ AndStep o = (AndStep) other;
+ return andTraversals.equals(o.andTraversals);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * andTraversals.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AsStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AsStep.java
new file mode 100644
index 0000000..1020830
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/AsStep.java
@@ -0,0 +1,49 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class AsStep {
+ /**
+ * @type string
+ */
+ public final String stepLabel;
+
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> stepLabels;
+
+ /**
+ * Constructs an immutable AsStep object
+ */
+ public AsStep(String stepLabel, java.util.List<String> stepLabels) {
+ this.stepLabel = stepLabel;
+ this.stepLabels = stepLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof AsStep)) return false;
+ AsStep o = (AsStep) other;
+ return stepLabel.equals(o.stepLabel)
+ && stepLabels.equals(o.stepLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * stepLabel.hashCode()
+ + 3 * stepLabels.hashCode();
+ }
+
+ /**
+ * Construct a new immutable AsStep object in which stepLabel is overridden
+ */
+ public AsStep withStepLabel(String stepLabel) {
+ return new AsStep(stepLabel, stepLabels);
+ }
+
+ /**
+ * Construct a new immutable AsStep object in which stepLabels is overridden
+ */
+ public AsStep withStepLabels(java.util.List<String> stepLabels) {
+ return new AsStep(stepLabel, stepLabels);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BarrierStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BarrierStep.java
new file mode 100644
index 0000000..d173c6b
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BarrierStep.java
@@ -0,0 +1,125 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.methods.TraversalSackMethod;
+
+/**
+ * @type optional:
+ * union:
+ * - index: 1
+ * name: barrierConsumer
+ * type: org/apache/tinkerpop/gremlin/language/model/methods.TraversalSackMethod
+ * - index: 2
+ * name: maxBarrierSize
+ * type: integer
+ */
+public class BarrierStep {
+ public final java.util.Optional<Value> value;
+
+ /**
+ * Constructs an immutable BarrierStep object
+ */
+ public BarrierStep(java.util.Optional<Value> value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof BarrierStep)) return false;
+ BarrierStep o = (BarrierStep) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+
+ public abstract static class Value {
+ private Value() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a Value according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(BarrierConsumer instance) ;
+
+ R visit(MaxBarrierSize instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a Value according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(Value instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(BarrierConsumer instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(MaxBarrierSize instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class BarrierConsumer extends Value {
+ public final TraversalSackMethod barrierConsumer;
+
+ /**
+ * Constructs an immutable BarrierConsumer object
+ */
+ public BarrierConsumer(TraversalSackMethod barrierConsumer) {
+ this.barrierConsumer = barrierConsumer;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof BarrierConsumer)) return false;
+ BarrierConsumer o = (BarrierConsumer) other;
+ return barrierConsumer.equals(o.barrierConsumer);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * barrierConsumer.hashCode();
+ }
+ }
+
+ public static final class MaxBarrierSize extends Value {
+ public final Integer maxBarrierSize;
+
+ /**
+ * Constructs an immutable MaxBarrierSize object
+ */
+ public MaxBarrierSize(Integer maxBarrierSize) {
+ this.maxBarrierSize = maxBarrierSize;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof MaxBarrierSize)) return false;
+ MaxBarrierSize o = (MaxBarrierSize) other;
+ return maxBarrierSize.equals(o.maxBarrierSize);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * maxBarrierSize.hashCode();
+ }
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BothEStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BothEStep.java
new file mode 100644
index 0000000..f322b63
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BothEStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class BothEStep {
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> edgeLabels;
+
+ /**
+ * Constructs an immutable BothEStep object
+ */
+ public BothEStep(java.util.List<String> edgeLabels) {
+ this.edgeLabels = edgeLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof BothEStep)) return false;
+ BothEStep o = (BothEStep) other;
+ return edgeLabels.equals(o.edgeLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * edgeLabels.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BothStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BothStep.java
new file mode 100644
index 0000000..c6d9e66
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BothStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class BothStep {
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> edgeLabels;
+
+ /**
+ * Constructs an immutable BothStep object
+ */
+ public BothStep(java.util.List<String> edgeLabels) {
+ this.edgeLabels = edgeLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof BothStep)) return false;
+ BothStep o = (BothStep) other;
+ return edgeLabels.equals(o.edgeLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * edgeLabels.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BothVStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BothVStep.java
new file mode 100644
index 0000000..ad998d0
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BothVStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class BothVStep {
+ /**
+ * Constructs an immutable BothVStep object
+ */
+ public BothVStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof BothVStep)) return false;
+ BothVStep o = (BothVStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BranchStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BranchStep.java
new file mode 100644
index 0000000..d1ce5ec
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/BranchStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class BranchStep {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final NestedTraversal branchTraversal;
+
+ /**
+ * Constructs an immutable BranchStep object
+ */
+ public BranchStep(NestedTraversal branchTraversal) {
+ this.branchTraversal = branchTraversal;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof BranchStep)) return false;
+ BranchStep o = (BranchStep) other;
+ return branchTraversal.equals(o.branchTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * branchTraversal.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ByStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ByStep.java
new file mode 100644
index 0000000..92feaa9
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ByStep.java
@@ -0,0 +1,426 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalComparator;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalFunction;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalOrder;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalToken;
+
+/**
+ * @type optional:
+ * union:
+ * - index: 1
+ * name: withTraversal
+ * type:
+ * record:
+ * - index: 1
+ * name: traversal
+ * type: org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ * - index: 2
+ * name: comparator
+ * type: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalComparator
+ * - index: 2
+ * name: withKey
+ * type:
+ * record:
+ * - index: 1
+ * name: key
+ * type: string
+ * - index: 2
+ * name: comparator
+ * type:
+ * optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalComparator
+ * - index: 3
+ * name: withFunction
+ * type:
+ * record:
+ * - index: 1
+ * name: function
+ * type: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalFunction
+ * - index: 2
+ * name: comparator
+ * type:
+ * optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalComparator
+ * - index: 4
+ * name: token
+ * type: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalToken
+ * - index: 5
+ * name: comparator
+ * type: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalComparator
+ * - index: 6
+ * name: order
+ * type: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalOrder
+ */
+public class ByStep {
+ public final java.util.Optional<Value> value;
+
+ /**
+ * Constructs an immutable ByStep object
+ */
+ public ByStep(java.util.Optional<Value> value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ByStep)) return false;
+ ByStep o = (ByStep) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+
+ public abstract static class Value {
+ private Value() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a Value according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(WithTraversal instance) ;
+
+ R visit(WithKey instance) ;
+
+ R visit(WithFunction instance) ;
+
+ R visit(Token instance) ;
+
+ R visit(Comparator instance) ;
+
+ R visit(Order instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a Value according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(Value instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(WithTraversal instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithKey instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithFunction instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Token instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Comparator instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Order instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class WithTraversal extends Value {
+ public final WithTraversalValue withTraversal;
+
+ /**
+ * Constructs an immutable WithTraversal object
+ */
+ public WithTraversal(WithTraversalValue withTraversal) {
+ this.withTraversal = withTraversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithTraversal)) return false;
+ WithTraversal o = (WithTraversal) other;
+ return withTraversal.equals(o.withTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withTraversal.hashCode();
+ }
+ }
+
+ public static final class WithKey extends Value {
+ public final WithKeyValue withKey;
+
+ /**
+ * Constructs an immutable WithKey object
+ */
+ public WithKey(WithKeyValue withKey) {
+ this.withKey = withKey;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithKey)) return false;
+ WithKey o = (WithKey) other;
+ return withKey.equals(o.withKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withKey.hashCode();
+ }
+ }
+
+ public static final class WithFunction extends Value {
+ public final WithFunctionValue withFunction;
+
+ /**
+ * Constructs an immutable WithFunction object
+ */
+ public WithFunction(WithFunctionValue withFunction) {
+ this.withFunction = withFunction;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithFunction)) return false;
+ WithFunction o = (WithFunction) other;
+ return withFunction.equals(o.withFunction);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withFunction.hashCode();
+ }
+ }
+
+ public static final class Token extends Value {
+ public final TraversalToken token;
+
+ /**
+ * Constructs an immutable Token object
+ */
+ public Token(TraversalToken token) {
+ this.token = token;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Token)) return false;
+ Token o = (Token) other;
+ return token.equals(o.token);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * token.hashCode();
+ }
+ }
+
+ public static final class Comparator extends Value {
+ public final TraversalComparator comparator;
+
+ /**
+ * Constructs an immutable Comparator object
+ */
+ public Comparator(TraversalComparator comparator) {
+ this.comparator = comparator;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Comparator)) return false;
+ Comparator o = (Comparator) other;
+ return comparator.equals(o.comparator);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * comparator.hashCode();
+ }
+ }
+
+ public static final class Order extends Value {
+ public final TraversalOrder order;
+
+ /**
+ * Constructs an immutable Order object
+ */
+ public Order(TraversalOrder order) {
+ this.order = order;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Order)) return false;
+ Order o = (Order) other;
+ return order.equals(o.order);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * order.hashCode();
+ }
+ }
+ }
+
+ public static class WithFunctionValue {
+ public final TraversalFunction function;
+
+ public final java.util.Optional<TraversalComparator> comparator;
+
+ /**
+ * Constructs an immutable WithFunctionValue object
+ */
+ public WithFunctionValue(TraversalFunction function, java.util.Optional<TraversalComparator> comparator) {
+ this.function = function;
+ this.comparator = comparator;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithFunctionValue)) return false;
+ WithFunctionValue o = (WithFunctionValue) other;
+ return function.equals(o.function)
+ && comparator.equals(o.comparator);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * function.hashCode()
+ + 3 * comparator.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithFunctionValue object in which function is overridden
+ */
+ public WithFunctionValue withFunction(TraversalFunction function) {
+ return new WithFunctionValue(function, comparator);
+ }
+
+ /**
+ * Construct a new immutable WithFunctionValue object in which comparator is overridden
+ */
+ public WithFunctionValue withComparator(java.util.Optional<TraversalComparator> comparator) {
+ return new WithFunctionValue(function, comparator);
+ }
+ }
+
+ public static class WithKeyValue {
+ public final String key;
+
+ public final java.util.Optional<TraversalComparator> comparator;
+
+ /**
+ * Constructs an immutable WithKeyValue object
+ */
+ public WithKeyValue(String key, java.util.Optional<TraversalComparator> comparator) {
+ this.key = key;
+ this.comparator = comparator;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithKeyValue)) return false;
+ WithKeyValue o = (WithKeyValue) other;
+ return key.equals(o.key)
+ && comparator.equals(o.comparator);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * key.hashCode()
+ + 3 * comparator.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithKeyValue object in which key is overridden
+ */
+ public WithKeyValue withKey(String key) {
+ return new WithKeyValue(key, comparator);
+ }
+
+ /**
+ * Construct a new immutable WithKeyValue object in which comparator is overridden
+ */
+ public WithKeyValue withComparator(java.util.Optional<TraversalComparator> comparator) {
+ return new WithKeyValue(key, comparator);
+ }
+ }
+
+ public static class WithTraversalValue {
+ public final NestedTraversal traversal;
+
+ public final TraversalComparator comparator;
+
+ /**
+ * Constructs an immutable WithTraversalValue object
+ */
+ public WithTraversalValue(NestedTraversal traversal, TraversalComparator comparator) {
+ this.traversal = traversal;
+ this.comparator = comparator;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithTraversalValue)) return false;
+ WithTraversalValue o = (WithTraversalValue) other;
+ return traversal.equals(o.traversal)
+ && comparator.equals(o.comparator);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * traversal.hashCode()
+ + 3 * comparator.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithTraversalValue object in which traversal is overridden
+ */
+ public WithTraversalValue withTraversal(NestedTraversal traversal) {
+ return new WithTraversalValue(traversal, comparator);
+ }
+
+ /**
+ * Construct a new immutable WithTraversalValue object in which comparator is overridden
+ */
+ public WithTraversalValue withComparator(TraversalComparator comparator) {
+ return new WithTraversalValue(traversal, comparator);
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CapStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CapStep.java
new file mode 100644
index 0000000..d71f9a2
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CapStep.java
@@ -0,0 +1,49 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class CapStep {
+ /**
+ * @type string
+ */
+ public final String sideEffectKey;
+
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> sideEffectKeys;
+
+ /**
+ * Constructs an immutable CapStep object
+ */
+ public CapStep(String sideEffectKey, java.util.List<String> sideEffectKeys) {
+ this.sideEffectKey = sideEffectKey;
+ this.sideEffectKeys = sideEffectKeys;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof CapStep)) return false;
+ CapStep o = (CapStep) other;
+ return sideEffectKey.equals(o.sideEffectKey)
+ && sideEffectKeys.equals(o.sideEffectKeys);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * sideEffectKey.hashCode()
+ + 3 * sideEffectKeys.hashCode();
+ }
+
+ /**
+ * Construct a new immutable CapStep object in which sideEffectKey is overridden
+ */
+ public CapStep withSideEffectKey(String sideEffectKey) {
+ return new CapStep(sideEffectKey, sideEffectKeys);
+ }
+
+ /**
+ * Construct a new immutable CapStep object in which sideEffectKeys is overridden
+ */
+ public CapStep withSideEffectKeys(java.util.List<String> sideEffectKeys) {
+ return new CapStep(sideEffectKey, sideEffectKeys);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ChooseStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ChooseStep.java
new file mode 100644
index 0000000..84a0d85
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ChooseStep.java
@@ -0,0 +1,238 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.predicates.TraversalPredicate;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public abstract class ChooseStep {
+ private ChooseStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class WithPredicateValue {
+ public final TraversalPredicate traversalPredicate;
+
+ public final TraversalPredicate trueChoice;
+
+ public final java.util.Optional<TraversalPredicate> falseChoice;
+
+ /**
+ * Constructs an immutable WithPredicateValue object
+ */
+ public WithPredicateValue(TraversalPredicate traversalPredicate, TraversalPredicate trueChoice, java.util.Optional<TraversalPredicate> falseChoice) {
+ this.traversalPredicate = traversalPredicate;
+ this.trueChoice = trueChoice;
+ this.falseChoice = falseChoice;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithPredicateValue)) return false;
+ WithPredicateValue o = (WithPredicateValue) other;
+ return traversalPredicate.equals(o.traversalPredicate)
+ && trueChoice.equals(o.trueChoice)
+ && falseChoice.equals(o.falseChoice);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * traversalPredicate.hashCode()
+ + 3 * trueChoice.hashCode()
+ + 5 * falseChoice.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithPredicateValue object in which traversalPredicate is overridden
+ */
+ public WithPredicateValue withTraversalPredicate(TraversalPredicate traversalPredicate) {
+ return new WithPredicateValue(traversalPredicate, trueChoice, falseChoice);
+ }
+
+ /**
+ * Construct a new immutable WithPredicateValue object in which trueChoice is overridden
+ */
+ public WithPredicateValue withTrueChoice(TraversalPredicate trueChoice) {
+ return new WithPredicateValue(traversalPredicate, trueChoice, falseChoice);
+ }
+
+ /**
+ * Construct a new immutable WithPredicateValue object in which falseChoice is overridden
+ */
+ public WithPredicateValue withFalseChoice(java.util.Optional<TraversalPredicate> falseChoice) {
+ return new WithPredicateValue(traversalPredicate, trueChoice, falseChoice);
+ }
+ }
+
+ public static class WithTraversalValue {
+ public final NestedTraversal traversalPredicate;
+
+ public final TraversalPredicate trueChoice;
+
+ public final java.util.Optional<TraversalPredicate> falseChoice;
+
+ /**
+ * Constructs an immutable WithTraversalValue object
+ */
+ public WithTraversalValue(NestedTraversal traversalPredicate, TraversalPredicate trueChoice, java.util.Optional<TraversalPredicate> falseChoice) {
+ this.traversalPredicate = traversalPredicate;
+ this.trueChoice = trueChoice;
+ this.falseChoice = falseChoice;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithTraversalValue)) return false;
+ WithTraversalValue o = (WithTraversalValue) other;
+ return traversalPredicate.equals(o.traversalPredicate)
+ && trueChoice.equals(o.trueChoice)
+ && falseChoice.equals(o.falseChoice);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * traversalPredicate.hashCode()
+ + 3 * trueChoice.hashCode()
+ + 5 * falseChoice.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithTraversalValue object in which traversalPredicate is overridden
+ */
+ public WithTraversalValue withTraversalPredicate(NestedTraversal traversalPredicate) {
+ return new WithTraversalValue(traversalPredicate, trueChoice, falseChoice);
+ }
+
+ /**
+ * Construct a new immutable WithTraversalValue object in which trueChoice is overridden
+ */
+ public WithTraversalValue withTrueChoice(TraversalPredicate trueChoice) {
+ return new WithTraversalValue(traversalPredicate, trueChoice, falseChoice);
+ }
+
+ /**
+ * Construct a new immutable WithTraversalValue object in which falseChoice is overridden
+ */
+ public WithTraversalValue withFalseChoice(java.util.Optional<TraversalPredicate> falseChoice) {
+ return new WithTraversalValue(traversalPredicate, trueChoice, falseChoice);
+ }
+ }
+
+ /**
+ * An interface for applying a function to a ChooseStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(ChoiceTraversal instance) ;
+
+ R visit(WithTraversal instance) ;
+
+ R visit(WithPredicate instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a ChooseStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(ChooseStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(ChoiceTraversal instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithTraversal instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithPredicate instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public static final class ChoiceTraversal extends ChooseStep {
+ public final NestedTraversal choiceTraversal;
+
+ /**
+ * Constructs an immutable ChoiceTraversal object
+ */
+ public ChoiceTraversal(NestedTraversal choiceTraversal) {
+ this.choiceTraversal = choiceTraversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ChoiceTraversal)) return false;
+ ChoiceTraversal o = (ChoiceTraversal) other;
+ return choiceTraversal.equals(o.choiceTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * choiceTraversal.hashCode();
+ }
+ }
+
+ public static final class WithTraversal extends ChooseStep {
+ public final WithTraversalValue withTraversal;
+
+ /**
+ * Constructs an immutable WithTraversal object
+ */
+ public WithTraversal(WithTraversalValue withTraversal) {
+ this.withTraversal = withTraversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithTraversal)) return false;
+ WithTraversal o = (WithTraversal) other;
+ return withTraversal.equals(o.withTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withTraversal.hashCode();
+ }
+ }
+
+ public static final class WithPredicate extends ChooseStep {
+ public final WithPredicateValue withPredicate;
+
+ /**
+ * Constructs an immutable WithPredicate object
+ */
+ public WithPredicate(WithPredicateValue withPredicate) {
+ this.withPredicate = withPredicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithPredicate)) return false;
+ WithPredicate o = (WithPredicate) other;
+ return withPredicate.equals(o.withPredicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withPredicate.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CoalesceStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CoalesceStep.java
new file mode 100644
index 0000000..bb30117
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CoalesceStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class CoalesceStep {
+ /**
+ * @type list: org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final java.util.List<NestedTraversal> coalesceTraversals;
+
+ /**
+ * Constructs an immutable CoalesceStep object
+ */
+ public CoalesceStep(java.util.List<NestedTraversal> coalesceTraversals) {
+ this.coalesceTraversals = coalesceTraversals;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof CoalesceStep)) return false;
+ CoalesceStep o = (CoalesceStep) other;
+ return coalesceTraversals.equals(o.coalesceTraversals);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * coalesceTraversals.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CoinStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CoinStep.java
new file mode 100644
index 0000000..2940385
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CoinStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class CoinStep {
+ /**
+ * @type float
+ */
+ public final Float probability;
+
+ /**
+ * Constructs an immutable CoinStep object
+ */
+ public CoinStep(Float probability) {
+ this.probability = probability;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof CoinStep)) return false;
+ CoinStep o = (CoinStep) other;
+ return probability.equals(o.probability);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * probability.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ConnectedComponentStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ConnectedComponentStep.java
new file mode 100644
index 0000000..c36f578
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ConnectedComponentStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class ConnectedComponentStep {
+ /**
+ * Constructs an immutable ConnectedComponentStep object
+ */
+ public ConnectedComponentStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ConnectedComponentStep)) return false;
+ ConnectedComponentStep o = (ConnectedComponentStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ConstantStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ConstantStep.java
new file mode 100644
index 0000000..0e4b668
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ConstantStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+public class ConstantStep {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final GenericLiteral e;
+
+ /**
+ * Constructs an immutable ConstantStep object
+ */
+ public ConstantStep(GenericLiteral e) {
+ this.e = e;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ConstantStep)) return false;
+ ConstantStep o = (ConstantStep) other;
+ return e.equals(o.e);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * e.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CountStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CountStep.java
new file mode 100644
index 0000000..e850e29
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CountStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class CountStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * Constructs an immutable CountStep object
+ */
+ public CountStep(java.util.Optional<TraversalScope> scope) {
+ this.scope = scope;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof CountStep)) return false;
+ CountStep o = (CountStep) other;
+ return scope.equals(o.scope);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CyclicPathStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CyclicPathStep.java
new file mode 100644
index 0000000..e7b144f
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/CyclicPathStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class CyclicPathStep {
+ /**
+ * Constructs an immutable CyclicPathStep object
+ */
+ public CyclicPathStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof CyclicPathStep)) return false;
+ CyclicPathStep o = (CyclicPathStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/DedupStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/DedupStep.java
new file mode 100644
index 0000000..7c0bee8
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/DedupStep.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class DedupStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> dedupLabels;
+
+ /**
+ * Constructs an immutable DedupStep object
+ */
+ public DedupStep(java.util.Optional<TraversalScope> scope, java.util.List<String> dedupLabels) {
+ this.scope = scope;
+ this.dedupLabels = dedupLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof DedupStep)) return false;
+ DedupStep o = (DedupStep) other;
+ return scope.equals(o.scope)
+ && dedupLabels.equals(o.dedupLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode()
+ + 3 * dedupLabels.hashCode();
+ }
+
+ /**
+ * Construct a new immutable DedupStep object in which scope is overridden
+ */
+ public DedupStep withScope(java.util.Optional<TraversalScope> scope) {
+ return new DedupStep(scope, dedupLabels);
+ }
+
+ /**
+ * Construct a new immutable DedupStep object in which dedupLabels is overridden
+ */
+ public DedupStep withDedupLabels(java.util.List<String> dedupLabels) {
+ return new DedupStep(scope, dedupLabels);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/DropStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/DropStep.java
new file mode 100644
index 0000000..a0160c8
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/DropStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class DropStep {
+ /**
+ * Constructs an immutable DropStep object
+ */
+ public DropStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof DropStep)) return false;
+ DropStep o = (DropStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ElementMapStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ElementMapStep.java
new file mode 100644
index 0000000..c38d009
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ElementMapStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class ElementMapStep {
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> propertyKeys;
+
+ /**
+ * Constructs an immutable ElementMapStep object
+ */
+ public ElementMapStep(java.util.List<String> propertyKeys) {
+ this.propertyKeys = propertyKeys;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ElementMapStep)) return false;
+ ElementMapStep o = (ElementMapStep) other;
+ return propertyKeys.equals(o.propertyKeys);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * propertyKeys.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/EmitStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/EmitStep.java
new file mode 100644
index 0000000..0d84b17
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/EmitStep.java
@@ -0,0 +1,126 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.predicates.TraversalPredicate;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+/**
+ * @type optional:
+ * union:
+ * - index: 1
+ * name: emitPredicate
+ * type: org/apache/tinkerpop/gremlin/language/model/predicates.TraversalPredicate
+ * - index: 2
+ * name: emitTraversal
+ * type: org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+public class EmitStep {
+ public final java.util.Optional<Value> value;
+
+ /**
+ * Constructs an immutable EmitStep object
+ */
+ public EmitStep(java.util.Optional<Value> value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof EmitStep)) return false;
+ EmitStep o = (EmitStep) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+
+ public abstract static class Value {
+ private Value() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a Value according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(EmitPredicate instance) ;
+
+ R visit(EmitTraversal instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a Value according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(Value instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(EmitPredicate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(EmitTraversal instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class EmitPredicate extends Value {
+ public final TraversalPredicate emitPredicate;
+
+ /**
+ * Constructs an immutable EmitPredicate object
+ */
+ public EmitPredicate(TraversalPredicate emitPredicate) {
+ this.emitPredicate = emitPredicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof EmitPredicate)) return false;
+ EmitPredicate o = (EmitPredicate) other;
+ return emitPredicate.equals(o.emitPredicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * emitPredicate.hashCode();
+ }
+ }
+
+ public static final class EmitTraversal extends Value {
+ public final NestedTraversal emitTraversal;
+
+ /**
+ * Constructs an immutable EmitTraversal object
+ */
+ public EmitTraversal(NestedTraversal emitTraversal) {
+ this.emitTraversal = emitTraversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof EmitTraversal)) return false;
+ EmitTraversal o = (EmitTraversal) other;
+ return emitTraversal.equals(o.emitTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * emitTraversal.hashCode();
+ }
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FilterStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FilterStep.java
new file mode 100644
index 0000000..54c49c8
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FilterStep.java
@@ -0,0 +1,99 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.predicates.TraversalPredicate;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public abstract class FilterStep {
+ private FilterStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a FilterStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Predicate instance) ;
+
+ R visit(FilterTraversal instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a FilterStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(FilterStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Predicate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(FilterTraversal instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.TraversalPredicate
+ */
+ public static final class Predicate extends FilterStep {
+ public final TraversalPredicate predicate;
+
+ /**
+ * Constructs an immutable Predicate object
+ */
+ public Predicate(TraversalPredicate predicate) {
+ this.predicate = predicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Predicate)) return false;
+ Predicate o = (Predicate) other;
+ return predicate.equals(o.predicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicate.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public static final class FilterTraversal extends FilterStep {
+ public final NestedTraversal filterTraversal;
+
+ /**
+ * Constructs an immutable FilterTraversal object
+ */
+ public FilterTraversal(NestedTraversal filterTraversal) {
+ this.filterTraversal = filterTraversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof FilterTraversal)) return false;
+ FilterTraversal o = (FilterTraversal) other;
+ return filterTraversal.equals(o.filterTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * filterTraversal.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FlatMapStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FlatMapStep.java
new file mode 100644
index 0000000..8196286
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FlatMapStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class FlatMapStep {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final NestedTraversal flatMapTraversal;
+
+ /**
+ * Constructs an immutable FlatMapStep object
+ */
+ public FlatMapStep(NestedTraversal flatMapTraversal) {
+ this.flatMapTraversal = flatMapTraversal;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof FlatMapStep)) return false;
+ FlatMapStep o = (FlatMapStep) other;
+ return flatMapTraversal.equals(o.flatMapTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * flatMapTraversal.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FoldStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FoldStep.java
new file mode 100644
index 0000000..79ad466
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FoldStep.java
@@ -0,0 +1,79 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalBiFunction;
+
+/**
+ * @type optional:
+ * record:
+ * - index: 1
+ * name: seed
+ * type: org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ * - index: 2
+ * name: foldFunction
+ * type: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalBiFunction
+ */
+public class FoldStep {
+ public final java.util.Optional<Value> value;
+
+ /**
+ * Constructs an immutable FoldStep object
+ */
+ public FoldStep(java.util.Optional<Value> value) {
+ this.value = value;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof FoldStep)) return false;
+ FoldStep o = (FoldStep) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+
+ public static class Value {
+ public final GenericLiteral seed;
+
+ public final TraversalBiFunction foldFunction;
+
+ /**
+ * Constructs an immutable Value object
+ */
+ public Value(GenericLiteral seed, TraversalBiFunction foldFunction) {
+ this.seed = seed;
+ this.foldFunction = foldFunction;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Value)) return false;
+ Value o = (Value) other;
+ return seed.equals(o.seed)
+ && foldFunction.equals(o.foldFunction);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * seed.hashCode()
+ + 3 * foldFunction.hashCode();
+ }
+
+ /**
+ * Construct a new immutable Value object in which seed is overridden
+ */
+ public Value withSeed(GenericLiteral seed) {
+ return new Value(seed, foldFunction);
+ }
+
+ /**
+ * Construct a new immutable Value object in which foldFunction is overridden
+ */
+ public Value withFoldFunction(TraversalBiFunction foldFunction) {
+ return new Value(seed, foldFunction);
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FromStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FromStep.java
new file mode 100644
index 0000000..bae4f82
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/FromStep.java
@@ -0,0 +1,98 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public abstract class FromStep {
+ private FromStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a FromStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(FromStepLabel instance) ;
+
+ R visit(FromVertex instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a FromStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(FromStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(FromStepLabel instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(FromVertex instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type string
+ */
+ public static final class FromStepLabel extends FromStep {
+ public final String fromStepLabel;
+
+ /**
+ * Constructs an immutable FromStepLabel object
+ */
+ public FromStepLabel(String fromStepLabel) {
+ this.fromStepLabel = fromStepLabel;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof FromStepLabel)) return false;
+ FromStepLabel o = (FromStepLabel) other;
+ return fromStepLabel.equals(o.fromStepLabel);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * fromStepLabel.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public static final class FromVertex extends FromStep {
+ public final NestedTraversal fromVertex;
+
+ /**
+ * Constructs an immutable FromVertex object
+ */
+ public FromVertex(NestedTraversal fromVertex) {
+ this.fromVertex = fromVertex;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof FromVertex)) return false;
+ FromVertex o = (FromVertex) other;
+ return fromVertex.equals(o.fromVertex);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * fromVertex.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/GroupCountStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/GroupCountStep.java
new file mode 100644
index 0000000..a52dd21
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/GroupCountStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class GroupCountStep {
+ /**
+ * @type optional: string
+ */
+ public final java.util.Optional<String> sideEffectKey;
+
+ /**
+ * Constructs an immutable GroupCountStep object
+ */
+ public GroupCountStep(java.util.Optional<String> sideEffectKey) {
+ this.sideEffectKey = sideEffectKey;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof GroupCountStep)) return false;
+ GroupCountStep o = (GroupCountStep) other;
+ return sideEffectKey.equals(o.sideEffectKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * sideEffectKey.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/GroupStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/GroupStep.java
new file mode 100644
index 0000000..ed7e02e
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/GroupStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class GroupStep {
+ /**
+ * @type optional: string
+ */
+ public final java.util.Optional<String> sideEffectKey;
+
+ /**
+ * Constructs an immutable GroupStep object
+ */
+ public GroupStep(java.util.Optional<String> sideEffectKey) {
+ this.sideEffectKey = sideEffectKey;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof GroupStep)) return false;
+ GroupStep o = (GroupStep) other;
+ return sideEffectKey.equals(o.sideEffectKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * sideEffectKey.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasIdStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasIdStep.java
new file mode 100644
index 0000000..9889ed0
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasIdStep.java
@@ -0,0 +1,138 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+import org.example.org.apache.tinkerpop.gremlin.language.model.predicates.TraversalPredicate;
+
+public abstract class HasIdStep {
+ private HasIdStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class WithIdsValue {
+ public final GenericLiteral id;
+
+ public final java.util.List<GenericLiteral> otherIds;
+
+ /**
+ * Constructs an immutable WithIdsValue object
+ */
+ public WithIdsValue(GenericLiteral id, java.util.List<GenericLiteral> otherIds) {
+ this.id = id;
+ this.otherIds = otherIds;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithIdsValue)) return false;
+ WithIdsValue o = (WithIdsValue) other;
+ return id.equals(o.id)
+ && otherIds.equals(o.otherIds);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * id.hashCode()
+ + 3 * otherIds.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithIdsValue object in which id is overridden
+ */
+ public WithIdsValue withId(GenericLiteral id) {
+ return new WithIdsValue(id, otherIds);
+ }
+
+ /**
+ * Construct a new immutable WithIdsValue object in which otherIds is overridden
+ */
+ public WithIdsValue withOtherIds(java.util.List<GenericLiteral> otherIds) {
+ return new WithIdsValue(id, otherIds);
+ }
+ }
+
+ /**
+ * An interface for applying a function to a HasIdStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Predicate instance) ;
+
+ R visit(WithIds instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a HasIdStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(HasIdStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Predicate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithIds instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.TraversalPredicate
+ */
+ public static final class Predicate extends HasIdStep {
+ public final TraversalPredicate predicate;
+
+ /**
+ * Constructs an immutable Predicate object
+ */
+ public Predicate(TraversalPredicate predicate) {
+ this.predicate = predicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Predicate)) return false;
+ Predicate o = (Predicate) other;
+ return predicate.equals(o.predicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicate.hashCode();
+ }
+ }
+
+ public static final class WithIds extends HasIdStep {
+ public final WithIdsValue withIds;
+
+ /**
+ * Constructs an immutable WithIds object
+ */
+ public WithIds(WithIdsValue withIds) {
+ this.withIds = withIds;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithIds)) return false;
+ WithIds o = (WithIds) other;
+ return withIds.equals(o.withIds);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withIds.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasKeyStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasKeyStep.java
new file mode 100644
index 0000000..b0d23c7
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasKeyStep.java
@@ -0,0 +1,137 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.predicates.TraversalPredicate;
+
+public abstract class HasKeyStep {
+ private HasKeyStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class WithLabelsValue {
+ public final String label;
+
+ public final java.util.List<String> otherLabels;
+
+ /**
+ * Constructs an immutable WithLabelsValue object
+ */
+ public WithLabelsValue(String label, java.util.List<String> otherLabels) {
+ this.label = label;
+ this.otherLabels = otherLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithLabelsValue)) return false;
+ WithLabelsValue o = (WithLabelsValue) other;
+ return label.equals(o.label)
+ && otherLabels.equals(o.otherLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * label.hashCode()
+ + 3 * otherLabels.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithLabelsValue object in which label is overridden
+ */
+ public WithLabelsValue withLabel(String label) {
+ return new WithLabelsValue(label, otherLabels);
+ }
+
+ /**
+ * Construct a new immutable WithLabelsValue object in which otherLabels is overridden
+ */
+ public WithLabelsValue withOtherLabels(java.util.List<String> otherLabels) {
+ return new WithLabelsValue(label, otherLabels);
+ }
+ }
+
+ /**
+ * An interface for applying a function to a HasKeyStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Predicate instance) ;
+
+ R visit(WithLabels instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a HasKeyStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(HasKeyStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Predicate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithLabels instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.TraversalPredicate
+ */
+ public static final class Predicate extends HasKeyStep {
+ public final TraversalPredicate predicate;
+
+ /**
+ * Constructs an immutable Predicate object
+ */
+ public Predicate(TraversalPredicate predicate) {
+ this.predicate = predicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Predicate)) return false;
+ Predicate o = (Predicate) other;
+ return predicate.equals(o.predicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicate.hashCode();
+ }
+ }
+
+ public static final class WithLabels extends HasKeyStep {
+ public final WithLabelsValue withLabels;
+
+ /**
+ * Constructs an immutable WithLabels object
+ */
+ public WithLabels(WithLabelsValue withLabels) {
+ this.withLabels = withLabels;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithLabels)) return false;
+ WithLabels o = (WithLabels) other;
+ return withLabels.equals(o.withLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withLabels.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasLabelStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasLabelStep.java
new file mode 100644
index 0000000..f1c8d54
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasLabelStep.java
@@ -0,0 +1,137 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.predicates.TraversalPredicate;
+
+public abstract class HasLabelStep {
+ private HasLabelStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class WithLabelsValue {
+ public final String label;
+
+ public final java.util.List<String> otherLabels;
+
+ /**
+ * Constructs an immutable WithLabelsValue object
+ */
+ public WithLabelsValue(String label, java.util.List<String> otherLabels) {
+ this.label = label;
+ this.otherLabels = otherLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithLabelsValue)) return false;
+ WithLabelsValue o = (WithLabelsValue) other;
+ return label.equals(o.label)
+ && otherLabels.equals(o.otherLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * label.hashCode()
+ + 3 * otherLabels.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithLabelsValue object in which label is overridden
+ */
+ public WithLabelsValue withLabel(String label) {
+ return new WithLabelsValue(label, otherLabels);
+ }
+
+ /**
+ * Construct a new immutable WithLabelsValue object in which otherLabels is overridden
+ */
+ public WithLabelsValue withOtherLabels(java.util.List<String> otherLabels) {
+ return new WithLabelsValue(label, otherLabels);
+ }
+ }
+
+ /**
+ * An interface for applying a function to a HasLabelStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Predicate instance) ;
+
+ R visit(WithLabels instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a HasLabelStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(HasLabelStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Predicate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithLabels instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.TraversalPredicate
+ */
+ public static final class Predicate extends HasLabelStep {
+ public final TraversalPredicate predicate;
+
+ /**
+ * Constructs an immutable Predicate object
+ */
+ public Predicate(TraversalPredicate predicate) {
+ this.predicate = predicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Predicate)) return false;
+ Predicate o = (Predicate) other;
+ return predicate.equals(o.predicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicate.hashCode();
+ }
+ }
+
+ public static final class WithLabels extends HasLabelStep {
+ public final WithLabelsValue withLabels;
+
+ /**
+ * Constructs an immutable WithLabels object
+ */
+ public WithLabels(WithLabelsValue withLabels) {
+ this.withLabels = withLabels;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithLabels)) return false;
+ WithLabels o = (WithLabels) other;
+ return withLabels.equals(o.withLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withLabels.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasNotStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasNotStep.java
new file mode 100644
index 0000000..247cb7c
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasNotStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class HasNotStep {
+ /**
+ * @type string
+ */
+ public final String propertyKey;
+
+ /**
+ * Constructs an immutable HasNotStep object
+ */
+ public HasNotStep(String propertyKey) {
+ this.propertyKey = propertyKey;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof HasNotStep)) return false;
+ HasNotStep o = (HasNotStep) other;
+ return propertyKey.equals(o.propertyKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * propertyKey.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasStep.java
new file mode 100644
index 0000000..8e9b00a
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasStep.java
@@ -0,0 +1,602 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+import org.example.org.apache.tinkerpop.gremlin.language.model.predicates.TraversalPredicate;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalToken;
+
+public abstract class HasStep {
+ private HasStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class WithLabelValue {
+ public final String label;
+
+ public final String propertyKey;
+
+ public final WithLabelOtherValue other;
+
+ /**
+ * Constructs an immutable WithLabelValue object
+ */
+ public WithLabelValue(String label, String propertyKey, WithLabelOtherValue other) {
+ this.label = label;
+ this.propertyKey = propertyKey;
+ this.other = other;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithLabelValue)) return false;
+ WithLabelValue o = (WithLabelValue) other;
+ return label.equals(o.label)
+ && propertyKey.equals(o.propertyKey)
+ && other.equals(o.other);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * label.hashCode()
+ + 3 * propertyKey.hashCode()
+ + 5 * other.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithLabelValue object in which label is overridden
+ */
+ public WithLabelValue withLabel(String label) {
+ return new WithLabelValue(label, propertyKey, other);
+ }
+
+ /**
+ * Construct a new immutable WithLabelValue object in which propertyKey is overridden
+ */
+ public WithLabelValue withPropertyKey(String propertyKey) {
+ return new WithLabelValue(label, propertyKey, other);
+ }
+
+ /**
+ * Construct a new immutable WithLabelValue object in which other is overridden
+ */
+ public WithLabelValue withOther(WithLabelOtherValue other) {
+ return new WithLabelValue(label, propertyKey, other);
+ }
+ }
+
+ public abstract static class WithLabelOtherValue {
+ private WithLabelOtherValue() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a WithLabelOtherValue according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Predicate instance) ;
+
+ R visit(Value instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a WithLabelOtherValue according to its variant (subclass). If a visit()
+ * method for a particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(WithLabelOtherValue instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Predicate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Value instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class Predicate extends WithLabelOtherValue {
+ public final TraversalPredicate predicate;
+
+ /**
+ * Constructs an immutable Predicate object
+ */
+ public Predicate(TraversalPredicate predicate) {
+ this.predicate = predicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Predicate)) return false;
+ Predicate o = (Predicate) other;
+ return predicate.equals(o.predicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicate.hashCode();
+ }
+ }
+
+ public static final class Value extends WithLabelOtherValue {
+ public final GenericLiteral value;
+
+ /**
+ * Constructs an immutable Value object
+ */
+ public Value(GenericLiteral value) {
+ this.value = value;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Value)) return false;
+ Value o = (Value) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+ }
+ }
+
+ public static class WithAccessorValue {
+ public final TraversalToken accessor;
+
+ public final WithAccessorOtherValue other;
+
+ /**
+ * Constructs an immutable WithAccessorValue object
+ */
+ public WithAccessorValue(TraversalToken accessor, WithAccessorOtherValue other) {
+ this.accessor = accessor;
+ this.other = other;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithAccessorValue)) return false;
+ WithAccessorValue o = (WithAccessorValue) other;
+ return accessor.equals(o.accessor)
+ && other.equals(o.other);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * accessor.hashCode()
+ + 3 * other.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithAccessorValue object in which accessor is overridden
+ */
+ public WithAccessorValue withAccessor(TraversalToken accessor) {
+ return new WithAccessorValue(accessor, other);
+ }
+
+ /**
+ * Construct a new immutable WithAccessorValue object in which other is overridden
+ */
+ public WithAccessorValue withOther(WithAccessorOtherValue other) {
+ return new WithAccessorValue(accessor, other);
+ }
+ }
+
+ public abstract static class WithAccessorOtherValue {
+ private WithAccessorOtherValue() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a WithAccessorOtherValue according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Predicate instance) ;
+
+ R visit(Value instance) ;
+
+ R visit(Traversal instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a WithAccessorOtherValue according to its variant (subclass). If a visit()
+ * method for a particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(WithAccessorOtherValue instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Predicate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Value instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Traversal instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class Predicate extends WithAccessorOtherValue {
+ public final TraversalPredicate predicate;
+
+ /**
+ * Constructs an immutable Predicate object
+ */
+ public Predicate(TraversalPredicate predicate) {
+ this.predicate = predicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Predicate)) return false;
+ Predicate o = (Predicate) other;
+ return predicate.equals(o.predicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicate.hashCode();
+ }
+ }
+
+ public static final class Value extends WithAccessorOtherValue {
+ public final GenericLiteral value;
+
+ /**
+ * Constructs an immutable Value object
+ */
+ public Value(GenericLiteral value) {
+ this.value = value;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Value)) return false;
+ Value o = (Value) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+ }
+
+ public static final class Traversal extends WithAccessorOtherValue {
+ public final NestedTraversal traversal;
+
+ /**
+ * Constructs an immutable Traversal object
+ */
+ public Traversal(NestedTraversal traversal) {
+ this.traversal = traversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Traversal)) return false;
+ Traversal o = (Traversal) other;
+ return traversal.equals(o.traversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * traversal.hashCode();
+ }
+ }
+ }
+
+ public static class WithPropertyKeyValue {
+ public final String propertyKey;
+
+ public final java.util.Optional<WithPropertyKeyOtherArgumentsValue> otherArguments;
+
+ /**
+ * Constructs an immutable WithPropertyKeyValue object
+ */
+ public WithPropertyKeyValue(String propertyKey, java.util.Optional<WithPropertyKeyOtherArgumentsValue> otherArguments) {
+ this.propertyKey = propertyKey;
+ this.otherArguments = otherArguments;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithPropertyKeyValue)) return false;
+ WithPropertyKeyValue o = (WithPropertyKeyValue) other;
+ return propertyKey.equals(o.propertyKey)
+ && otherArguments.equals(o.otherArguments);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * propertyKey.hashCode()
+ + 3 * otherArguments.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithPropertyKeyValue object in which propertyKey is overridden
+ */
+ public WithPropertyKeyValue withPropertyKey(String propertyKey) {
+ return new WithPropertyKeyValue(propertyKey, otherArguments);
+ }
+
+ /**
+ * Construct a new immutable WithPropertyKeyValue object in which otherArguments is overridden
+ */
+ public WithPropertyKeyValue withOtherArguments(java.util.Optional<WithPropertyKeyOtherArgumentsValue> otherArguments) {
+ return new WithPropertyKeyValue(propertyKey, otherArguments);
+ }
+ }
+
+ public abstract static class WithPropertyKeyOtherArgumentsValue {
+ private WithPropertyKeyOtherArgumentsValue() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a WithPropertyKeyOtherArgumentsValue according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Predicate instance) ;
+
+ R visit(Value instance) ;
+
+ R visit(Traversal instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a WithPropertyKeyOtherArgumentsValue according to its variant (subclass). If
+ * a visit() method for a particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(WithPropertyKeyOtherArgumentsValue instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Predicate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Value instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Traversal instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class Predicate extends WithPropertyKeyOtherArgumentsValue {
+ public final TraversalPredicate predicate;
+
+ /**
+ * Constructs an immutable Predicate object
+ */
+ public Predicate(TraversalPredicate predicate) {
+ this.predicate = predicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Predicate)) return false;
+ Predicate o = (Predicate) other;
+ return predicate.equals(o.predicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicate.hashCode();
+ }
+ }
+
+ public static final class Value extends WithPropertyKeyOtherArgumentsValue {
+ public final GenericLiteral value;
+
+ /**
+ * Constructs an immutable Value object
+ */
+ public Value(GenericLiteral value) {
+ this.value = value;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Value)) return false;
+ Value o = (Value) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+ }
+
+ public static final class Traversal extends WithPropertyKeyOtherArgumentsValue {
+ public final NestedTraversal traversal;
+
+ /**
+ * Constructs an immutable Traversal object
+ */
+ public Traversal(NestedTraversal traversal) {
+ this.traversal = traversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Traversal)) return false;
+ Traversal o = (Traversal) other;
+ return traversal.equals(o.traversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * traversal.hashCode();
+ }
+ }
+ }
+
+ /**
+ * An interface for applying a function to a HasStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(WithPropertyKey instance) ;
+
+ R visit(WithAccessor instance) ;
+
+ R visit(WithLabel instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a HasStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(HasStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(WithPropertyKey instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithAccessor instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithLabel instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class WithPropertyKey extends HasStep {
+ public final WithPropertyKeyValue withPropertyKey;
+
+ /**
+ * Constructs an immutable WithPropertyKey object
+ */
+ public WithPropertyKey(WithPropertyKeyValue withPropertyKey) {
+ this.withPropertyKey = withPropertyKey;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithPropertyKey)) return false;
+ WithPropertyKey o = (WithPropertyKey) other;
+ return withPropertyKey.equals(o.withPropertyKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withPropertyKey.hashCode();
+ }
+ }
+
+ public static final class WithAccessor extends HasStep {
+ public final WithAccessorValue withAccessor;
+
+ /**
+ * Constructs an immutable WithAccessor object
+ */
+ public WithAccessor(WithAccessorValue withAccessor) {
+ this.withAccessor = withAccessor;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithAccessor)) return false;
+ WithAccessor o = (WithAccessor) other;
+ return withAccessor.equals(o.withAccessor);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withAccessor.hashCode();
+ }
+ }
+
+ public static final class WithLabel extends HasStep {
+ public final WithLabelValue withLabel;
+
+ /**
+ * Constructs an immutable WithLabel object
+ */
+ public WithLabel(WithLabelValue withLabel) {
+ this.withLabel = withLabel;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithLabel)) return false;
+ WithLabel o = (WithLabel) other;
+ return withLabel.equals(o.withLabel);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withLabel.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasValueStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasValueStep.java
new file mode 100644
index 0000000..e20fa28
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/HasValueStep.java
@@ -0,0 +1,114 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.predicates.TraversalPredicate;
+
+public abstract class HasValueStep {
+ private HasValueStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class WithValuesValue {
+ /**
+ * Constructs an immutable WithValuesValue object
+ */
+ public WithValuesValue() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithValuesValue)) return false;
+ WithValuesValue o = (WithValuesValue) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+ }
+
+ /**
+ * An interface for applying a function to a HasValueStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Predicate instance) ;
+
+ R visit(WithValues instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a HasValueStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(HasValueStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Predicate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(WithValues instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.TraversalPredicate
+ */
+ public static final class Predicate extends HasValueStep {
+ public final TraversalPredicate predicate;
+
+ /**
+ * Constructs an immutable Predicate object
+ */
+ public Predicate(TraversalPredicate predicate) {
+ this.predicate = predicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Predicate)) return false;
+ Predicate o = (Predicate) other;
+ return predicate.equals(o.predicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicate.hashCode();
+ }
+ }
+
+ public static final class WithValues extends HasValueStep {
+ public final WithValuesValue withValues;
+
+ /**
+ * Constructs an immutable WithValues object
+ */
+ public WithValues(WithValuesValue withValues) {
+ this.withValues = withValues;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithValues)) return false;
+ WithValues o = (WithValues) other;
+ return withValues.equals(o.withValues);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withValues.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IdStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IdStep.java
new file mode 100644
index 0000000..37af10b
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IdStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class IdStep {
+ /**
+ * Constructs an immutable IdStep object
+ */
+ public IdStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof IdStep)) return false;
+ IdStep o = (IdStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IdentityStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IdentityStep.java
new file mode 100644
index 0000000..e3a01b2
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IdentityStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class IdentityStep {
+ /**
+ * Constructs an immutable IdentityStep object
+ */
+ public IdentityStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof IdentityStep)) return false;
+ IdentityStep o = (IdentityStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InEStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InEStep.java
new file mode 100644
index 0000000..1b730af
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InEStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class InEStep {
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> edgeLabels;
+
+ /**
+ * Constructs an immutable InEStep object
+ */
+ public InEStep(java.util.List<String> edgeLabels) {
+ this.edgeLabels = edgeLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof InEStep)) return false;
+ InEStep o = (InEStep) other;
+ return edgeLabels.equals(o.edgeLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * edgeLabels.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InStep.java
new file mode 100644
index 0000000..ddee660
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class InStep {
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> edgeLabels;
+
+ /**
+ * Constructs an immutable InStep object
+ */
+ public InStep(java.util.List<String> edgeLabels) {
+ this.edgeLabels = edgeLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof InStep)) return false;
+ InStep o = (InStep) other;
+ return edgeLabels.equals(o.edgeLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * edgeLabels.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InVStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InVStep.java
new file mode 100644
index 0000000..47c9867
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InVStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class InVStep {
+ /**
+ * Constructs an immutable InVStep object
+ */
+ public InVStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof InVStep)) return false;
+ InVStep o = (InVStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IndexStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IndexStep.java
new file mode 100644
index 0000000..030e429
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IndexStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class IndexStep {
+ /**
+ * Constructs an immutable IndexStep object
+ */
+ public IndexStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof IndexStep)) return false;
+ IndexStep o = (IndexStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InjectStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InjectStep.java
new file mode 100644
index 0000000..686bd1a
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/InjectStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+
+public class InjectStep {
+ /**
+ * @type list: org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final java.util.List<GenericLiteral> injections;
+
+ /**
+ * Constructs an immutable InjectStep object
+ */
+ public InjectStep(java.util.List<GenericLiteral> injections) {
+ this.injections = injections;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof InjectStep)) return false;
+ InjectStep o = (InjectStep) other;
+ return injections.equals(o.injections);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * injections.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IsStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IsStep.java
new file mode 100644
index 0000000..27f08f6
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/IsStep.java
@@ -0,0 +1,99 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+import org.example.org.apache.tinkerpop.gremlin.language.model.predicates.TraversalPredicate;
+
+public abstract class IsStep {
+ private IsStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a IsStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Predicate instance) ;
+
+ R visit(Value instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a IsStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(IsStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Predicate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Value instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/predicates.TraversalPredicate
+ */
+ public static final class Predicate extends IsStep {
+ public final TraversalPredicate predicate;
+
+ /**
+ * Constructs an immutable Predicate object
+ */
+ public Predicate(TraversalPredicate predicate) {
+ this.predicate = predicate;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Predicate)) return false;
+ Predicate o = (Predicate) other;
+ return predicate.equals(o.predicate);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicate.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public static final class Value extends IsStep {
+ public final GenericLiteral value;
+
+ /**
+ * Constructs an immutable Value object
+ */
+ public Value(GenericLiteral value) {
+ this.value = value;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Value)) return false;
+ Value o = (Value) other;
+ return value.equals(o.value);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * value.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/KeyStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/KeyStep.java
new file mode 100644
index 0000000..6a631e2
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/KeyStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class KeyStep {
+ /**
+ * Constructs an immutable KeyStep object
+ */
+ public KeyStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof KeyStep)) return false;
+ KeyStep o = (KeyStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LabelStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LabelStep.java
new file mode 100644
index 0000000..798ba69
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LabelStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class LabelStep {
+ /**
+ * Constructs an immutable LabelStep object
+ */
+ public LabelStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof LabelStep)) return false;
+ LabelStep o = (LabelStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LimitStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LimitStep.java
new file mode 100644
index 0000000..92e2559
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LimitStep.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class LimitStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * @type integer
+ */
+ public final Integer limit;
+
+ /**
+ * Constructs an immutable LimitStep object
+ */
+ public LimitStep(java.util.Optional<TraversalScope> scope, Integer limit) {
+ this.scope = scope;
+ this.limit = limit;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof LimitStep)) return false;
+ LimitStep o = (LimitStep) other;
+ return scope.equals(o.scope)
+ && limit.equals(o.limit);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode()
+ + 3 * limit.hashCode();
+ }
+
+ /**
+ * Construct a new immutable LimitStep object in which scope is overridden
+ */
+ public LimitStep withScope(java.util.Optional<TraversalScope> scope) {
+ return new LimitStep(scope, limit);
+ }
+
+ /**
+ * Construct a new immutable LimitStep object in which limit is overridden
+ */
+ public LimitStep withLimit(Integer limit) {
+ return new LimitStep(scope, limit);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LocalStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LocalStep.java
new file mode 100644
index 0000000..389d452
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LocalStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class LocalStep {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final NestedTraversal localTraversal;
+
+ /**
+ * Constructs an immutable LocalStep object
+ */
+ public LocalStep(NestedTraversal localTraversal) {
+ this.localTraversal = localTraversal;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof LocalStep)) return false;
+ LocalStep o = (LocalStep) other;
+ return localTraversal.equals(o.localTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * localTraversal.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LoopsStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LoopsStep.java
new file mode 100644
index 0000000..57e2ba8
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/LoopsStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class LoopsStep {
+ /**
+ * @type optional: string
+ */
+ public final java.util.Optional<String> loopName;
+
+ /**
+ * Constructs an immutable LoopsStep object
+ */
+ public LoopsStep(java.util.Optional<String> loopName) {
+ this.loopName = loopName;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof LoopsStep)) return false;
+ LoopsStep o = (LoopsStep) other;
+ return loopName.equals(o.loopName);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * loopName.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MapStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MapStep.java
new file mode 100644
index 0000000..6ee2f26
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MapStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class MapStep {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final NestedTraversal mapTraversal;
+
+ /**
+ * Constructs an immutable MapStep object
+ */
+ public MapStep(NestedTraversal mapTraversal) {
+ this.mapTraversal = mapTraversal;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof MapStep)) return false;
+ MapStep o = (MapStep) other;
+ return mapTraversal.equals(o.mapTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * mapTraversal.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MatchStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MatchStep.java
new file mode 100644
index 0000000..d6dc336
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MatchStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class MatchStep {
+ /**
+ * @type list: org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final java.util.List<NestedTraversal> matchTraversals;
+
+ /**
+ * Constructs an immutable MatchStep object
+ */
+ public MatchStep(java.util.List<NestedTraversal> matchTraversals) {
+ this.matchTraversals = matchTraversals;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof MatchStep)) return false;
+ MatchStep o = (MatchStep) other;
+ return matchTraversals.equals(o.matchTraversals);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * matchTraversals.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MathStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MathStep.java
new file mode 100644
index 0000000..7b79f04
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MathStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class MathStep {
+ /**
+ * @type string
+ */
+ public final String expression;
+
+ /**
+ * Constructs an immutable MathStep object
+ */
+ public MathStep(String expression) {
+ this.expression = expression;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof MathStep)) return false;
+ MathStep o = (MathStep) other;
+ return expression.equals(o.expression);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * expression.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MaxStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MaxStep.java
new file mode 100644
index 0000000..f75ab0d
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MaxStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class MaxStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * Constructs an immutable MaxStep object
+ */
+ public MaxStep(java.util.Optional<TraversalScope> scope) {
+ this.scope = scope;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof MaxStep)) return false;
+ MaxStep o = (MaxStep) other;
+ return scope.equals(o.scope);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MeanStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MeanStep.java
new file mode 100644
index 0000000..d703193
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MeanStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class MeanStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * Constructs an immutable MeanStep object
+ */
+ public MeanStep(java.util.Optional<TraversalScope> scope) {
+ this.scope = scope;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof MeanStep)) return false;
+ MeanStep o = (MeanStep) other;
+ return scope.equals(o.scope);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MinStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MinStep.java
new file mode 100644
index 0000000..7779030
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/MinStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class MinStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * Constructs an immutable MinStep object
+ */
+ public MinStep(java.util.Optional<TraversalScope> scope) {
+ this.scope = scope;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof MinStep)) return false;
+ MinStep o = (MinStep) other;
+ return scope.equals(o.scope);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/NotStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/NotStep.java
new file mode 100644
index 0000000..8d53944
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/NotStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class NotStep {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final NestedTraversal notTraversal;
+
+ /**
+ * Constructs an immutable NotStep object
+ */
+ public NotStep(NestedTraversal notTraversal) {
+ this.notTraversal = notTraversal;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof NotStep)) return false;
+ NotStep o = (NotStep) other;
+ return notTraversal.equals(o.notTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * notTraversal.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OptionStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OptionStep.java
new file mode 100644
index 0000000..e612b8c
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OptionStep.java
@@ -0,0 +1,215 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+import org.example.org.apache.tinkerpop.gremlin.language.model.predicates.TraversalPredicate;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public abstract class OptionStep {
+ private OptionStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class ObjectTraversalValue {
+ public final GenericLiteral object;
+
+ public final NestedTraversal traversal;
+
+ /**
+ * Constructs an immutable ObjectTraversalValue object
+ */
+ public ObjectTraversalValue(GenericLiteral object, NestedTraversal traversal) {
+ this.object = object;
+ this.traversal = traversal;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ObjectTraversalValue)) return false;
+ ObjectTraversalValue o = (ObjectTraversalValue) other;
+ return object.equals(o.object)
+ && traversal.equals(o.traversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * object.hashCode()
+ + 3 * traversal.hashCode();
+ }
+
+ /**
+ * Construct a new immutable ObjectTraversalValue object in which object is overridden
+ */
+ public ObjectTraversalValue withObject(GenericLiteral object) {
+ return new ObjectTraversalValue(object, traversal);
+ }
+
+ /**
+ * Construct a new immutable ObjectTraversalValue object in which traversal is overridden
+ */
+ public ObjectTraversalValue withTraversal(NestedTraversal traversal) {
+ return new ObjectTraversalValue(object, traversal);
+ }
+ }
+
+ public static class PredicateTraversalValue {
+ public final TraversalPredicate predicate;
+
+ public final NestedTraversal traversal;
+
+ /**
+ * Constructs an immutable PredicateTraversalValue object
+ */
+ public PredicateTraversalValue(TraversalPredicate predicate, NestedTraversal traversal) {
+ this.predicate = predicate;
+ this.traversal = traversal;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof PredicateTraversalValue)) return false;
+ PredicateTraversalValue o = (PredicateTraversalValue) other;
+ return predicate.equals(o.predicate)
+ && traversal.equals(o.traversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicate.hashCode()
+ + 3 * traversal.hashCode();
+ }
+
+ /**
+ * Construct a new immutable PredicateTraversalValue object in which predicate is overridden
+ */
+ public PredicateTraversalValue withPredicate(TraversalPredicate predicate) {
+ return new PredicateTraversalValue(predicate, traversal);
+ }
+
+ /**
+ * Construct a new immutable PredicateTraversalValue object in which traversal is overridden
+ */
+ public PredicateTraversalValue withTraversal(NestedTraversal traversal) {
+ return new PredicateTraversalValue(predicate, traversal);
+ }
+ }
+
+ /**
+ * An interface for applying a function to a OptionStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(PredicateTraversal instance) ;
+
+ R visit(ObjectTraversal instance) ;
+
+ R visit(Traversal instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a OptionStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(OptionStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(PredicateTraversal instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(ObjectTraversal instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Traversal instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class PredicateTraversal extends OptionStep {
+ public final PredicateTraversalValue predicateTraversal;
+
+ /**
+ * Constructs an immutable PredicateTraversal object
+ */
+ public PredicateTraversal(PredicateTraversalValue predicateTraversal) {
+ this.predicateTraversal = predicateTraversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof PredicateTraversal)) return false;
+ PredicateTraversal o = (PredicateTraversal) other;
+ return predicateTraversal.equals(o.predicateTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * predicateTraversal.hashCode();
+ }
+ }
+
+ public static final class ObjectTraversal extends OptionStep {
+ public final ObjectTraversalValue objectTraversal;
+
+ /**
+ * Constructs an immutable ObjectTraversal object
+ */
+ public ObjectTraversal(ObjectTraversalValue objectTraversal) {
+ this.objectTraversal = objectTraversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ObjectTraversal)) return false;
+ ObjectTraversal o = (ObjectTraversal) other;
+ return objectTraversal.equals(o.objectTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * objectTraversal.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public static final class Traversal extends OptionStep {
+ public final NestedTraversal traversal;
+
+ /**
+ * Constructs an immutable Traversal object
+ */
+ public Traversal(NestedTraversal traversal) {
+ this.traversal = traversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Traversal)) return false;
+ Traversal o = (Traversal) other;
+ return traversal.equals(o.traversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * traversal.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OptionalStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OptionalStep.java
new file mode 100644
index 0000000..721a5f8
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OptionalStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class OptionalStep {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final NestedTraversal optionalTraversal;
+
+ /**
+ * Constructs an immutable OptionalStep object
+ */
+ public OptionalStep(NestedTraversal optionalTraversal) {
+ this.optionalTraversal = optionalTraversal;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof OptionalStep)) return false;
+ OptionalStep o = (OptionalStep) other;
+ return optionalTraversal.equals(o.optionalTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * optionalTraversal.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OrStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OrStep.java
new file mode 100644
index 0000000..81839ae
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OrStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class OrStep {
+ /**
+ * @type list: org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final java.util.List<NestedTraversal> orTraversals;
+
+ /**
+ * Constructs an immutable OrStep object
+ */
+ public OrStep(java.util.List<NestedTraversal> orTraversals) {
+ this.orTraversals = orTraversals;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof OrStep)) return false;
+ OrStep o = (OrStep) other;
+ return orTraversals.equals(o.orTraversals);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * orTraversals.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OrderStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OrderStep.java
new file mode 100644
index 0000000..5911fb9
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OrderStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class OrderStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * Constructs an immutable OrderStep object
+ */
+ public OrderStep(java.util.Optional<TraversalScope> scope) {
+ this.scope = scope;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof OrderStep)) return false;
+ OrderStep o = (OrderStep) other;
+ return scope.equals(o.scope);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OtherVStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OtherVStep.java
new file mode 100644
index 0000000..97df8fb
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OtherVStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class OtherVStep {
+ /**
+ * Constructs an immutable OtherVStep object
+ */
+ public OtherVStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof OtherVStep)) return false;
+ OtherVStep o = (OtherVStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OutEStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OutEStep.java
new file mode 100644
index 0000000..d322db7
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OutEStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class OutEStep {
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> edgeLabels;
+
+ /**
+ * Constructs an immutable OutEStep object
+ */
+ public OutEStep(java.util.List<String> edgeLabels) {
+ this.edgeLabels = edgeLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof OutEStep)) return false;
+ OutEStep o = (OutEStep) other;
+ return edgeLabels.equals(o.edgeLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * edgeLabels.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OutStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OutStep.java
new file mode 100644
index 0000000..c286c10
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OutStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class OutStep {
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> edgeLabels;
+
+ /**
+ * Constructs an immutable OutStep object
+ */
+ public OutStep(java.util.List<String> edgeLabels) {
+ this.edgeLabels = edgeLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof OutStep)) return false;
+ OutStep o = (OutStep) other;
+ return edgeLabels.equals(o.edgeLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * edgeLabels.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OutVStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OutVStep.java
new file mode 100644
index 0000000..0bf2c98
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/OutVStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class OutVStep {
+ /**
+ * Constructs an immutable OutVStep object
+ */
+ public OutVStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof OutVStep)) return false;
+ OutVStep o = (OutVStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PageRankStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PageRankStep.java
new file mode 100644
index 0000000..5a56999
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PageRankStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class PageRankStep {
+ /**
+ * @type optional: float
+ */
+ public final java.util.Optional<Float> alpha;
+
+ /**
+ * Constructs an immutable PageRankStep object
+ */
+ public PageRankStep(java.util.Optional<Float> alpha) {
+ this.alpha = alpha;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof PageRankStep)) return false;
+ PageRankStep o = (PageRankStep) other;
+ return alpha.equals(o.alpha);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * alpha.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PathStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PathStep.java
new file mode 100644
index 0000000..41376f7
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PathStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class PathStep {
+ /**
+ * Constructs an immutable PathStep object
+ */
+ public PathStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof PathStep)) return false;
+ PathStep o = (PathStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PeerPressureStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PeerPressureStep.java
new file mode 100644
index 0000000..e98c6a1
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PeerPressureStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class PeerPressureStep {
+ /**
+ * Constructs an immutable PeerPressureStep object
+ */
+ public PeerPressureStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof PeerPressureStep)) return false;
+ PeerPressureStep o = (PeerPressureStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ProfileStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ProfileStep.java
new file mode 100644
index 0000000..e9bb2ff
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ProfileStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class ProfileStep {
+ /**
+ * @type optional: string
+ */
+ public final java.util.Optional<String> sideEffectKey;
+
+ /**
+ * Constructs an immutable ProfileStep object
+ */
+ public ProfileStep(java.util.Optional<String> sideEffectKey) {
+ this.sideEffectKey = sideEffectKey;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ProfileStep)) return false;
+ ProfileStep o = (ProfileStep) other;
+ return sideEffectKey.equals(o.sideEffectKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * sideEffectKey.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ProjectStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ProjectStep.java
new file mode 100644
index 0000000..a6280ad
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ProjectStep.java
@@ -0,0 +1,49 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class ProjectStep {
+ /**
+ * @type string
+ */
+ public final String projectKey;
+
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> otherProjectKeys;
+
+ /**
+ * Constructs an immutable ProjectStep object
+ */
+ public ProjectStep(String projectKey, java.util.List<String> otherProjectKeys) {
+ this.projectKey = projectKey;
+ this.otherProjectKeys = otherProjectKeys;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ProjectStep)) return false;
+ ProjectStep o = (ProjectStep) other;
+ return projectKey.equals(o.projectKey)
+ && otherProjectKeys.equals(o.otherProjectKeys);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * projectKey.hashCode()
+ + 3 * otherProjectKeys.hashCode();
+ }
+
+ /**
+ * Construct a new immutable ProjectStep object in which projectKey is overridden
+ */
+ public ProjectStep withProjectKey(String projectKey) {
+ return new ProjectStep(projectKey, otherProjectKeys);
+ }
+
+ /**
+ * Construct a new immutable ProjectStep object in which otherProjectKeys is overridden
+ */
+ public ProjectStep withOtherProjectKeys(java.util.List<String> otherProjectKeys) {
+ return new ProjectStep(projectKey, otherProjectKeys);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PropertiesStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PropertiesStep.java
new file mode 100644
index 0000000..89bd917
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PropertiesStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class PropertiesStep {
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> propertyKeys;
+
+ /**
+ * Constructs an immutable PropertiesStep object
+ */
+ public PropertiesStep(java.util.List<String> propertyKeys) {
+ this.propertyKeys = propertyKeys;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof PropertiesStep)) return false;
+ PropertiesStep o = (PropertiesStep) other;
+ return propertyKeys.equals(o.propertyKeys);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * propertyKeys.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PropertyMapStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PropertyMapStep.java
new file mode 100644
index 0000000..77904ea
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PropertyMapStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class PropertyMapStep {
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> propertyKeys;
+
+ /**
+ * Constructs an immutable PropertyMapStep object
+ */
+ public PropertyMapStep(java.util.List<String> propertyKeys) {
+ this.propertyKeys = propertyKeys;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof PropertyMapStep)) return false;
+ PropertyMapStep o = (PropertyMapStep) other;
+ return propertyKeys.equals(o.propertyKeys);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * propertyKeys.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PropertyStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PropertyStep.java
new file mode 100644
index 0000000..172e56a
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/PropertyStep.java
@@ -0,0 +1,82 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.literals.GenericLiteral;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalCardinality;
+
+public class PropertyStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalCardinality
+ */
+ public final java.util.Optional<TraversalCardinality> cardinality;
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final GenericLiteral key;
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final GenericLiteral value;
+
+ /**
+ * @type list: org/apache/tinkerpop/gremlin/language/model/literals.GenericLiteral
+ */
+ public final java.util.List<GenericLiteral> keyValues;
+
+ /**
+ * Constructs an immutable PropertyStep object
+ */
+ public PropertyStep(java.util.Optional<TraversalCardinality> cardinality, GenericLiteral key, GenericLiteral value, java.util.List<GenericLiteral> keyValues) {
+ this.cardinality = cardinality;
+ this.key = key;
+ this.value = value;
+ this.keyValues = keyValues;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof PropertyStep)) return false;
+ PropertyStep o = (PropertyStep) other;
+ return cardinality.equals(o.cardinality)
+ && key.equals(o.key)
+ && value.equals(o.value)
+ && keyValues.equals(o.keyValues);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * cardinality.hashCode()
+ + 3 * key.hashCode()
+ + 5 * value.hashCode()
+ + 7 * keyValues.hashCode();
+ }
+
+ /**
+ * Construct a new immutable PropertyStep object in which cardinality is overridden
+ */
+ public PropertyStep withCardinality(java.util.Optional<TraversalCardinality> cardinality) {
+ return new PropertyStep(cardinality, key, value, keyValues);
+ }
+
+ /**
+ * Construct a new immutable PropertyStep object in which key is overridden
+ */
+ public PropertyStep withKey(GenericLiteral key) {
+ return new PropertyStep(cardinality, key, value, keyValues);
+ }
+
+ /**
+ * Construct a new immutable PropertyStep object in which value is overridden
+ */
+ public PropertyStep withValue(GenericLiteral value) {
+ return new PropertyStep(cardinality, key, value, keyValues);
+ }
+
+ /**
+ * Construct a new immutable PropertyStep object in which keyValues is overridden
+ */
+ public PropertyStep withKeyValues(java.util.List<GenericLiteral> keyValues) {
+ return new PropertyStep(cardinality, key, value, keyValues);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/RangeStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/RangeStep.java
new file mode 100644
index 0000000..86ab753
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/RangeStep.java
@@ -0,0 +1,66 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class RangeStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * @type integer
+ */
+ public final Integer low;
+
+ /**
+ * @type integer
+ */
+ public final Integer high;
+
+ /**
+ * Constructs an immutable RangeStep object
+ */
+ public RangeStep(java.util.Optional<TraversalScope> scope, Integer low, Integer high) {
+ this.scope = scope;
+ this.low = low;
+ this.high = high;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof RangeStep)) return false;
+ RangeStep o = (RangeStep) other;
+ return scope.equals(o.scope)
+ && low.equals(o.low)
+ && high.equals(o.high);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode()
+ + 3 * low.hashCode()
+ + 5 * high.hashCode();
+ }
+
+ /**
+ * Construct a new immutable RangeStep object in which scope is overridden
+ */
+ public RangeStep withScope(java.util.Optional<TraversalScope> scope) {
+ return new RangeStep(scope, low, high);
+ }
+
+ /**
+ * Construct a new immutable RangeStep object in which low is overridden
+ */
+ public RangeStep withLow(Integer low) {
+ return new RangeStep(scope, low, high);
+ }
+
+ /**
+ * Construct a new immutable RangeStep object in which high is overridden
+ */
+ public RangeStep withHigh(Integer high) {
+ return new RangeStep(scope, low, high);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ReadStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ReadStep.java
new file mode 100644
index 0000000..6f18661
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ReadStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class ReadStep {
+ /**
+ * Constructs an immutable ReadStep object
+ */
+ public ReadStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ReadStep)) return false;
+ ReadStep o = (ReadStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/RepeatStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/RepeatStep.java
new file mode 100644
index 0000000..a43ddb4
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/RepeatStep.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class RepeatStep {
+ /**
+ * @type optional: string
+ */
+ public final java.util.Optional<String> loopName;
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final NestedTraversal repeatTraversals;
+
+ /**
+ * Constructs an immutable RepeatStep object
+ */
+ public RepeatStep(java.util.Optional<String> loopName, NestedTraversal repeatTraversals) {
+ this.loopName = loopName;
+ this.repeatTraversals = repeatTraversals;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof RepeatStep)) return false;
+ RepeatStep o = (RepeatStep) other;
+ return loopName.equals(o.loopName)
+ && repeatTraversals.equals(o.repeatTraversals);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * loopName.hashCode()
+ + 3 * repeatTraversals.hashCode();
+ }
+
+ /**
+ * Construct a new immutable RepeatStep object in which loopName is overridden
+ */
+ public RepeatStep withLoopName(java.util.Optional<String> loopName) {
+ return new RepeatStep(loopName, repeatTraversals);
+ }
+
+ /**
+ * Construct a new immutable RepeatStep object in which repeatTraversals is overridden
+ */
+ public RepeatStep withRepeatTraversals(NestedTraversal repeatTraversals) {
+ return new RepeatStep(loopName, repeatTraversals);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SackStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SackStep.java
new file mode 100644
index 0000000..d534b91
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SackStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalBiFunction;
+
+public class SackStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalBiFunction
+ */
+ public final java.util.Optional<TraversalBiFunction> sackOperator;
+
+ /**
+ * Constructs an immutable SackStep object
+ */
+ public SackStep(java.util.Optional<TraversalBiFunction> sackOperator) {
+ this.sackOperator = sackOperator;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof SackStep)) return false;
+ SackStep o = (SackStep) other;
+ return sackOperator.equals(o.sackOperator);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * sackOperator.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SampleStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SampleStep.java
new file mode 100644
index 0000000..669537b
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SampleStep.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class SampleStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * @type integer
+ */
+ public final Integer amountToSample;
+
+ /**
+ * Constructs an immutable SampleStep object
+ */
+ public SampleStep(java.util.Optional<TraversalScope> scope, Integer amountToSample) {
+ this.scope = scope;
+ this.amountToSample = amountToSample;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof SampleStep)) return false;
+ SampleStep o = (SampleStep) other;
+ return scope.equals(o.scope)
+ && amountToSample.equals(o.amountToSample);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode()
+ + 3 * amountToSample.hashCode();
+ }
+
+ /**
+ * Construct a new immutable SampleStep object in which scope is overridden
+ */
+ public SampleStep withScope(java.util.Optional<TraversalScope> scope) {
+ return new SampleStep(scope, amountToSample);
+ }
+
+ /**
+ * Construct a new immutable SampleStep object in which amountToSample is overridden
+ */
+ public SampleStep withAmountToSample(Integer amountToSample) {
+ return new SampleStep(scope, amountToSample);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SelectStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SelectStep.java
new file mode 100644
index 0000000..25d4ae1
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SelectStep.java
@@ -0,0 +1,315 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalColumn;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalPop;
+
+public abstract class SelectStep {
+ private SelectStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class TraversalValue {
+ public final java.util.Optional<TraversalPop> pop;
+
+ public final NestedTraversal traversal;
+
+ /**
+ * Constructs an immutable TraversalValue object
+ */
+ public TraversalValue(java.util.Optional<TraversalPop> pop, NestedTraversal traversal) {
+ this.pop = pop;
+ this.traversal = traversal;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof TraversalValue)) return false;
+ TraversalValue o = (TraversalValue) other;
+ return pop.equals(o.pop)
+ && traversal.equals(o.traversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * pop.hashCode()
+ + 3 * traversal.hashCode();
+ }
+
+ /**
+ * Construct a new immutable TraversalValue object in which pop is overridden
+ */
+ public TraversalValue withPop(java.util.Optional<TraversalPop> pop) {
+ return new TraversalValue(pop, traversal);
+ }
+
+ /**
+ * Construct a new immutable TraversalValue object in which traversal is overridden
+ */
+ public TraversalValue withTraversal(NestedTraversal traversal) {
+ return new TraversalValue(pop, traversal);
+ }
+ }
+
+ public static class KeysValue {
+ public final java.util.Optional<TraversalPop> pop;
+
+ public final String selectKey1;
+
+ public final String selectKey2;
+
+ public final java.util.List<String> otherSelectKeys;
+
+ /**
+ * Constructs an immutable KeysValue object
+ */
+ public KeysValue(java.util.Optional<TraversalPop> pop, String selectKey1, String selectKey2, java.util.List<String> otherSelectKeys) {
+ this.pop = pop;
+ this.selectKey1 = selectKey1;
+ this.selectKey2 = selectKey2;
+ this.otherSelectKeys = otherSelectKeys;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof KeysValue)) return false;
+ KeysValue o = (KeysValue) other;
+ return pop.equals(o.pop)
+ && selectKey1.equals(o.selectKey1)
+ && selectKey2.equals(o.selectKey2)
+ && otherSelectKeys.equals(o.otherSelectKeys);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * pop.hashCode()
+ + 3 * selectKey1.hashCode()
+ + 5 * selectKey2.hashCode()
+ + 7 * otherSelectKeys.hashCode();
+ }
+
+ /**
+ * Construct a new immutable KeysValue object in which pop is overridden
+ */
+ public KeysValue withPop(java.util.Optional<TraversalPop> pop) {
+ return new KeysValue(pop, selectKey1, selectKey2, otherSelectKeys);
+ }
+
+ /**
+ * Construct a new immutable KeysValue object in which selectKey1 is overridden
+ */
+ public KeysValue withSelectKey1(String selectKey1) {
+ return new KeysValue(pop, selectKey1, selectKey2, otherSelectKeys);
+ }
+
+ /**
+ * Construct a new immutable KeysValue object in which selectKey2 is overridden
+ */
+ public KeysValue withSelectKey2(String selectKey2) {
+ return new KeysValue(pop, selectKey1, selectKey2, otherSelectKeys);
+ }
+
+ /**
+ * Construct a new immutable KeysValue object in which otherSelectKeys is overridden
+ */
+ public KeysValue withOtherSelectKeys(java.util.List<String> otherSelectKeys) {
+ return new KeysValue(pop, selectKey1, selectKey2, otherSelectKeys);
+ }
+ }
+
+ public static class KeyValue {
+ public final java.util.Optional<TraversalPop> pop;
+
+ public final String selectKey;
+
+ /**
+ * Constructs an immutable KeyValue object
+ */
+ public KeyValue(java.util.Optional<TraversalPop> pop, String selectKey) {
+ this.pop = pop;
+ this.selectKey = selectKey;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof KeyValue)) return false;
+ KeyValue o = (KeyValue) other;
+ return pop.equals(o.pop)
+ && selectKey.equals(o.selectKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * pop.hashCode()
+ + 3 * selectKey.hashCode();
+ }
+
+ /**
+ * Construct a new immutable KeyValue object in which pop is overridden
+ */
+ public KeyValue withPop(java.util.Optional<TraversalPop> pop) {
+ return new KeyValue(pop, selectKey);
+ }
+
+ /**
+ * Construct a new immutable KeyValue object in which selectKey is overridden
+ */
+ public KeyValue withSelectKey(String selectKey) {
+ return new KeyValue(pop, selectKey);
+ }
+ }
+
+ /**
+ * An interface for applying a function to a SelectStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(Column instance) ;
+
+ R visit(Key instance) ;
+
+ R visit(Keys instance) ;
+
+ R visit(Traversal instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a SelectStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(SelectStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(Column instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Key instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Keys instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Traversal instance) {
+ return otherwise(instance);
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.TraversalColumn
+ */
+ public static final class Column extends SelectStep {
+ public final TraversalColumn column;
+
+ /**
+ * Constructs an immutable Column object
+ */
+ public Column(TraversalColumn column) {
+ this.column = column;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Column)) return false;
+ Column o = (Column) other;
+ return column.equals(o.column);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * column.hashCode();
+ }
+ }
+
+ public static final class Key extends SelectStep {
+ public final KeyValue key;
+
+ /**
+ * Constructs an immutable Key object
+ */
+ public Key(KeyValue key) {
+ this.key = key;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Key)) return false;
+ Key o = (Key) other;
+ return key.equals(o.key);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * key.hashCode();
+ }
+ }
+
+ public static final class Keys extends SelectStep {
+ public final KeysValue keys;
+
+ /**
+ * Constructs an immutable Keys object
+ */
+ public Keys(KeysValue keys) {
+ this.keys = keys;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Keys)) return false;
+ Keys o = (Keys) other;
+ return keys.equals(o.keys);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * keys.hashCode();
+ }
+ }
+
+ public static final class Traversal extends SelectStep {
+ public final TraversalValue traversal;
+
+ /**
+ * Constructs an immutable Traversal object
+ */
+ public Traversal(TraversalValue traversal) {
+ this.traversal = traversal;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof Traversal)) return false;
+ Traversal o = (Traversal) other;
+ return traversal.equals(o.traversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * traversal.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ShortestPathStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ShortestPathStep.java
new file mode 100644
index 0000000..e5c3a3d
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ShortestPathStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class ShortestPathStep {
+ /**
+ * Constructs an immutable ShortestPathStep object
+ */
+ public ShortestPathStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ShortestPathStep)) return false;
+ ShortestPathStep o = (ShortestPathStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SideEffectStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SideEffectStep.java
new file mode 100644
index 0000000..d7becd0
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SideEffectStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+
+public class SideEffectStep {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public final NestedTraversal sideEffectTraversal;
+
+ /**
+ * Constructs an immutable SideEffectStep object
+ */
+ public SideEffectStep(NestedTraversal sideEffectTraversal) {
+ this.sideEffectTraversal = sideEffectTraversal;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof SideEffectStep)) return false;
+ SideEffectStep o = (SideEffectStep) other;
+ return sideEffectTraversal.equals(o.sideEffectTraversal);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * sideEffectTraversal.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SimplePathStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SimplePathStep.java
new file mode 100644
index 0000000..c4643b6
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SimplePathStep.java
@@ -0,0 +1,20 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class SimplePathStep {
+ /**
+ * Constructs an immutable SimplePathStep object
+ */
+ public SimplePathStep() {}
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof SimplePathStep)) return false;
+ SimplePathStep o = (SimplePathStep) other;
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SkipStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SkipStep.java
new file mode 100644
index 0000000..3bd0f27
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SkipStep.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class SkipStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * @type integer
+ */
+ public final Integer skip;
+
+ /**
+ * Constructs an immutable SkipStep object
+ */
+ public SkipStep(java.util.Optional<TraversalScope> scope, Integer skip) {
+ this.scope = scope;
+ this.skip = skip;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof SkipStep)) return false;
+ SkipStep o = (SkipStep) other;
+ return scope.equals(o.scope)
+ && skip.equals(o.skip);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode()
+ + 3 * skip.hashCode();
+ }
+
+ /**
+ * Construct a new immutable SkipStep object in which scope is overridden
+ */
+ public SkipStep withScope(java.util.Optional<TraversalScope> scope) {
+ return new SkipStep(scope, skip);
+ }
+
+ /**
+ * Construct a new immutable SkipStep object in which skip is overridden
+ */
+ public SkipStep withSkip(Integer skip) {
+ return new SkipStep(scope, skip);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/StoreStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/StoreStep.java
new file mode 100644
index 0000000..e66290a
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/StoreStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class StoreStep {
+ /**
+ * @type string
+ */
+ public final String sideEffectKey;
+
+ /**
+ * Constructs an immutable StoreStep object
+ */
+ public StoreStep(String sideEffectKey) {
+ this.sideEffectKey = sideEffectKey;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof StoreStep)) return false;
+ StoreStep o = (StoreStep) other;
+ return sideEffectKey.equals(o.sideEffectKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * sideEffectKey.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SubgraphStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SubgraphStep.java
new file mode 100644
index 0000000..aa8ee73
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SubgraphStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class SubgraphStep {
+ /**
+ * @type string
+ */
+ public final String sideEffectKey;
+
+ /**
+ * Constructs an immutable SubgraphStep object
+ */
+ public SubgraphStep(String sideEffectKey) {
+ this.sideEffectKey = sideEffectKey;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof SubgraphStep)) return false;
+ SubgraphStep o = (SubgraphStep) other;
+ return sideEffectKey.equals(o.sideEffectKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * sideEffectKey.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SumStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SumStep.java
new file mode 100644
index 0000000..646a971
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/SumStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class SumStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * Constructs an immutable SumStep object
+ */
+ public SumStep(java.util.Optional<TraversalScope> scope) {
+ this.scope = scope;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof SumStep)) return false;
+ SumStep o = (SumStep) other;
+ return scope.equals(o.scope);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TailStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TailStep.java
new file mode 100644
index 0000000..abfe7a3
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TailStep.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalScope;
+
+public class TailStep {
+ /**
+ * @type optional: org/apache/tinkerpop/gremlin/language/model/traversal.TraversalScope
+ */
+ public final java.util.Optional<TraversalScope> scope;
+
+ /**
+ * @type optional: integer
+ */
+ public final java.util.Optional<Integer> limit;
+
+ /**
+ * Constructs an immutable TailStep object
+ */
+ public TailStep(java.util.Optional<TraversalScope> scope, java.util.Optional<Integer> limit) {
+ this.scope = scope;
+ this.limit = limit;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof TailStep)) return false;
+ TailStep o = (TailStep) other;
+ return scope.equals(o.scope)
+ && limit.equals(o.limit);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * scope.hashCode()
+ + 3 * limit.hashCode();
+ }
+
+ /**
+ * Construct a new immutable TailStep object in which scope is overridden
+ */
+ public TailStep withScope(java.util.Optional<TraversalScope> scope) {
+ return new TailStep(scope, limit);
+ }
+
+ /**
+ * Construct a new immutable TailStep object in which limit is overridden
+ */
+ public TailStep withLimit(java.util.Optional<Integer> limit) {
+ return new TailStep(scope, limit);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TimeLimitStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TimeLimitStep.java
new file mode 100644
index 0000000..af9db95
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TimeLimitStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class TimeLimitStep {
+ /**
+ * @type integer
+ */
+ public final Integer timeLimit;
+
+ /**
+ * Constructs an immutable TimeLimitStep object
+ */
+ public TimeLimitStep(Integer timeLimit) {
+ this.timeLimit = timeLimit;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof TimeLimitStep)) return false;
+ TimeLimitStep o = (TimeLimitStep) other;
+ return timeLimit.equals(o.timeLimit);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * timeLimit.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TimesStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TimesStep.java
new file mode 100644
index 0000000..0664bd3
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TimesStep.java
@@ -0,0 +1,27 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public class TimesStep {
+ /**
+ * @type integer
+ */
+ public final Integer maxLoops;
+
+ /**
+ * Constructs an immutable TimesStep object
+ */
+ public TimesStep(Integer maxLoops) {
+ this.maxLoops = maxLoops;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof TimesStep)) return false;
+ TimesStep o = (TimesStep) other;
+ return maxLoops.equals(o.maxLoops);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * maxLoops.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ToEStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ToEStep.java
new file mode 100644
index 0000000..e8e7466
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ToEStep.java
@@ -0,0 +1,51 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalDirection;
+
+public class ToEStep {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.TraversalDirection
+ */
+ public final TraversalDirection direction;
+
+ /**
+ * @type list: string
+ */
+ public final java.util.List<String> edgeLabels;
+
+ /**
+ * Constructs an immutable ToEStep object
+ */
+ public ToEStep(TraversalDirection direction, java.util.List<String> edgeLabels) {
+ this.direction = direction;
+ this.edgeLabels = edgeLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToEStep)) return false;
+ ToEStep o = (ToEStep) other;
+ return direction.equals(o.direction)
+ && edgeLabels.equals(o.edgeLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * direction.hashCode()
+ + 3 * edgeLabels.hashCode();
+ }
+
+ /**
+ * Construct a new immutable ToEStep object in which direction is overridden
+ */
+ public ToEStep withDirection(TraversalDirection direction) {
+ return new ToEStep(direction, edgeLabels);
+ }
+
+ /**
+ * Construct a new immutable ToEStep object in which edgeLabels is overridden
+ */
+ public ToEStep withEdgeLabels(java.util.List<String> edgeLabels) {
+ return new ToEStep(direction, edgeLabels);
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ToStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ToStep.java
new file mode 100644
index 0000000..239977f
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ToStep.java
@@ -0,0 +1,175 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.NestedTraversal;
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalDirection;
+
+public abstract class ToStep {
+ private ToStep() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ public static class WithDirectionValue {
+ public final TraversalDirection direction;
+
+ public final java.util.List<String> edgeLabels;
+
+ /**
+ * Constructs an immutable WithDirectionValue object
+ */
+ public WithDirectionValue(TraversalDirection direction, java.util.List<String> edgeLabels) {
+ this.direction = direction;
+ this.edgeLabels = edgeLabels;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithDirectionValue)) return false;
+ WithDirectionValue o = (WithDirectionValue) other;
+ return direction.equals(o.direction)
+ && edgeLabels.equals(o.edgeLabels);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * direction.hashCode()
+ + 3 * edgeLabels.hashCode();
+ }
+
+ /**
+ * Construct a new immutable WithDirectionValue object in which direction is overridden
+ */
+ public WithDirectionValue withDirection(TraversalDirection direction) {
+ return new WithDirectionValue(direction, edgeLabels);
+ }
+
+ /**
+ * Construct a new immutable WithDirectionValue object in which edgeLabels is overridden
+ */
+ public WithDirectionValue withEdgeLabels(java.util.List<String> edgeLabels) {
+ return new WithDirectionValue(direction, edgeLabels);
+ }
+ }
+
+ /**
+ * An interface for applying a function to a ToStep according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(WithDirection instance) ;
+
+ R visit(ToStepLabel instance) ;
+
+ R visit(ToVertex instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a ToStep according to its variant (subclass). If a visit() method for a
+ * particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(ToStep instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(WithDirection instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(ToStepLabel instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(ToVertex instance) {
+ return otherwise(instance);
+ }
+ }
+
+ public static final class WithDirection extends ToStep {
+ public final WithDirectionValue withDirection;
+
+ /**
+ * Constructs an immutable WithDirection object
+ */
+ public WithDirection(WithDirectionValue withDirection) {
+ this.withDirection = withDirection;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof WithDirection)) return false;
+ WithDirection o = (WithDirection) other;
+ return withDirection.equals(o.withDirection);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * withDirection.hashCode();
+ }
+ }
+
+ /**
+ * @type string
+ */
+ public static final class ToStepLabel extends ToStep {
+ public final String toStepLabel;
+
+ /**
+ * Constructs an immutable ToStepLabel object
+ */
+ public ToStepLabel(String toStepLabel) {
+ this.toStepLabel = toStepLabel;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToStepLabel)) return false;
+ ToStepLabel o = (ToStepLabel) other;
+ return toStepLabel.equals(o.toStepLabel);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * toStepLabel.hashCode();
+ }
+ }
+
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.NestedTraversal
+ */
+ public static final class ToVertex extends ToStep {
+ public final NestedTraversal toVertex;
+
+ /**
+ * Constructs an immutable ToVertex object
+ */
+ public ToVertex(NestedTraversal toVertex) {
+ this.toVertex = toVertex;
+ }
+
+ @Override
+ public <R> R accept(Visitor<R> visitor) {
+ return visitor.visit(this);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToVertex)) return false;
+ ToVertex o = (ToVertex) other;
+ return toVertex.equals(o.toVertex);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * toVertex.hashCode();
+ }
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ToVStep.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ToVStep.java
new file mode 100644
index 0000000..dc8ac43
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/ToVStep.java
@@ -0,0 +1,29 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+import org.example.org.apache.tinkerpop.gremlin.language.model.traversal.TraversalDirection;
+
+public class ToVStep {
+ /**
+ * @type org/apache/tinkerpop/gremlin/language/model/traversal.TraversalDirection
+ */
+ public final TraversalDirection direction;
+
+ /**
+ * Constructs an immutable ToVStep object
+ */
+ public ToVStep(TraversalDirection direction) {
+ this.direction = direction;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof ToVStep)) return false;
+ ToVStep o = (ToVStep) other;
+ return direction.equals(o.direction);
+ }
+
+ @Override
+ public int hashCode() {
+ return 2 * direction.hashCode();
+ }
+}
diff --git a/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TraversalMethod.java b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TraversalMethod.java
new file mode 100644
index 0000000..6e0da01
--- /dev/null
+++ b/gremlin-language/src/gen/java/org/apache/tinkerpop/gremlin/language/model/steps/TraversalMethod.java
@@ -0,0 +1,3759 @@
+package org.example.org.apache.tinkerpop.gremlin.language.model.steps;
+
+public abstract class TraversalMethod {
+ private TraversalMethod() {}
+
+ public abstract <R> R accept(Visitor<R> visitor) ;
+
+ /**
+ * An interface for applying a function to a TraversalMethod according to its variant (subclass)
+ */
+ public interface Visitor<R> {
+ R visit(V instance) ;
+
+ R visit(AddE instance) ;
+
+ R visit(AddV instance) ;
+
+ R visit(Aggregate instance) ;
+
+ R visit(And instance) ;
+
+ R visit(As instance) ;
+
+ R visit(Barrier instance) ;
+
+ R visit(Both instance) ;
+
+ R visit(BothE instance) ;
+
+ R visit(BothV instance) ;
+
+ R visit(Branch instance) ;
+
+ R visit(By instance) ;
+
+ R visit(Cap instance) ;
+
+ R visit(Choose instance) ;
+
+ R visit(Coalesce instance) ;
+
+ R visit(Coin instance) ;
+
+ R visit(ConnectedComponent instance) ;
+
+ R visit(Constant instance) ;
+
+ R visit(Count instance) ;
+
+ R visit(CyclicPath instance) ;
+
+ R visit(Dedup instance) ;
+
+ R visit(Drop instance) ;
+
+ R visit(ElementMap instance) ;
+
+ R visit(Emit instance) ;
+
+ R visit(Filter instance) ;
+
+ R visit(FlatMap instance) ;
+
+ R visit(Fold instance) ;
+
+ R visit(From instance) ;
+
+ R visit(Group instance) ;
+
+ R visit(GroupCount instance) ;
+
+ R visit(Has instance) ;
+
+ R visit(HasId instance) ;
+
+ R visit(HasKey instance) ;
+
+ R visit(HasLabel instance) ;
+
+ R visit(HasNot instance) ;
+
+ R visit(HasValue instance) ;
+
+ R visit(Id instance) ;
+
+ R visit(Identity instance) ;
+
+ R visit(In instance) ;
+
+ R visit(InE instance) ;
+
+ R visit(InV instance) ;
+
+ R visit(Index instance) ;
+
+ R visit(Inject instance) ;
+
+ R visit(Is instance) ;
+
+ R visit(Key instance) ;
+
+ R visit(Label instance) ;
+
+ R visit(Limit instance) ;
+
+ R visit(Local instance) ;
+
+ R visit(Loops instance) ;
+
+ R visit(Map instance) ;
+
+ R visit(Match instance) ;
+
+ R visit(MathEsc instance) ;
+
+ R visit(Max instance) ;
+
+ R visit(Mean instance) ;
+
+ R visit(Min instance) ;
+
+ R visit(Not instance) ;
+
+ R visit(Option instance) ;
+
+ R visit(Optional instance) ;
+
+ R visit(Or instance) ;
+
+ R visit(Order instance) ;
+
+ R visit(OtherV instance) ;
+
+ R visit(Out instance) ;
+
+ R visit(OutE instance) ;
+
+ R visit(OutV instance) ;
+
+ R visit(PageRank instance) ;
+
+ R visit(Path instance) ;
+
+ R visit(PeerPressure instance) ;
+
+ R visit(Profile instance) ;
+
+ R visit(Project instance) ;
+
+ R visit(Properties instance) ;
+
+ R visit(Property instance) ;
+
+ R visit(PropertyMap instance) ;
+
+ R visit(Range instance) ;
+
+ R visit(Read instance) ;
+
+ R visit(Repeat instance) ;
+
+ R visit(Sack instance) ;
+
+ R visit(Sample instance) ;
+
+ R visit(Select instance) ;
+
+ R visit(ShortestPath instance) ;
+
+ R visit(SideEffect instance) ;
+
+ R visit(SimplePath instance) ;
+
+ R visit(Skip instance) ;
+
+ R visit(Store instance) ;
+
+ R visit(Subgraph instance) ;
+
+ R visit(Sum instance) ;
+
+ R visit(Tail instance) ;
+
+ R visit(TimeLimit instance) ;
+
+ R visit(Times instance) ;
+
+ R visit(To instance) ;
+
+ R visit(ToE instance) ;
+
+ R visit(ToV instance) ;
+
+ R visit(Tree instance) ;
+
+ R visit(Unfold instance) ;
+
+ R visit(Union instance) ;
+
+ R visit(Until instance) ;
+
+ R visit(Value instance) ;
+
+ R visit(ValueMap instance) ;
+
+ R visit(Values instance) ;
+
+ R visit(Where instance) ;
+
+ R visit(With instance) ;
+
+ R visit(Write instance) ;
+ }
+
+ /**
+ * An interface for applying a function to a TraversalMethod according to its variant (subclass). If a visit() method
+ * for a particular variant is not implemented, a default method is used instead.
+ */
+ public interface PartialVisitor<R> extends Visitor<R> {
+ default R otherwise(TraversalMethod instance) {
+ throw new IllegalStateException("Non-exhaustive patterns when matching: " + instance);
+ }
+
+ default R visit(V instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(AddE instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(AddV instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Aggregate instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(And instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(As instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Barrier instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Both instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(BothE instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(BothV instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Branch instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(By instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Cap instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Choose instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Coalesce instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Coin instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(ConnectedComponent instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Constant instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Count instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(CyclicPath instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Dedup instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Drop instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(ElementMap instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Emit instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Filter instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(FlatMap instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Fold instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(From instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Group instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(GroupCount instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Has instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(HasId instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(HasKey instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(HasLabel instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(HasNot instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(HasValue instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Id instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Identity instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(In instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(InE instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(InV instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Index instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Inject instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Is instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Key instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Label instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Limit instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Local instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Loops instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Map instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Match instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(MathEsc instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Max instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Mean instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Min instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Not instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Option instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Optional instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Or instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Order instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(OtherV instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Out instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(OutE instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(OutV instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(PageRank instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Path instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(PeerPressure instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Profile instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Project instance) {
+ return otherwise(instance);
+ }
+
+ default R visit(Properties instance) {
+ return otherwise(instance);
+ }
+
... 6325 lines suppressed ...
[tinkerpop] 01/02: Add Gremlin traversal specification in YAML
Posted by jo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
joshsh pushed a commit to branch TINKERPOP-2563-language
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit aa35e7065e77b84b6efd8075f561c1a8fa310c1d
Author: Joshua Shinavier <jo...@uber.com>
AuthorDate: Tue May 11 07:41:21 2021 -0700
Add Gremlin traversal specification in YAML
---
.../gremlin/language/model/constants.yaml | 200 +++
.../tinkerpop/gremlin/language/model/literals.yaml | 404 +++++
.../tinkerpop/gremlin/language/model/methods.yaml | 113 ++
.../gremlin/language/model/predicates.yaml | 234 +++
.../tinkerpop/gremlin/language/model/query.yaml | 60 +
.../tinkerpop/gremlin/language/model/steps.yaml | 1802 ++++++++++++++++++++
.../gremlin/language/model/traversal.yaml | 575 +++++++
7 files changed, 3388 insertions(+)
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/constants.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/constants.yaml
new file mode 100644
index 0000000..af33642
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/constants.yaml
@@ -0,0 +1,200 @@
+# // Gremlin specific lexer rules
+
+definitions:
+
+ # gremlinStringConstants
+ # : withOptionsStringConstants
+ # | shortestPathStringConstants
+ # | pageRankStringConstants
+ # | peerPressureStringConstants
+ # ;
+
+ - name: GremlinStringConstant
+ type:
+ union:
+ - name: withOptions
+ type: WithOptionsStringConstant
+
+ - name: shortestPath
+ type: ShortestPathStringConstant
+
+ - name: pageRank
+ type: PageRankStringConstant
+
+ - name: peerPressure
+ type: PeerPressureStringConstant
+
+ # pageRankStringConstants
+ # : gremlinStringConstants_pageRankStringConstants_edges
+ # | gremlinStringConstants_pageRankStringConstants_times
+ # | gremlinStringConstants_pageRankStringConstants_propertyName
+ # ;
+
+ - name: PageRankStringConstant
+ type:
+ enum:
+ - edges
+ - times
+ - propertyName
+
+ # peerPressureStringConstants
+ # : gremlinStringConstants_peerPressureStringConstants_edges
+ # | gremlinStringConstants_peerPressureStringConstants_times
+ # | gremlinStringConstants_peerPressureStringConstants_propertyName
+ # ;
+
+ - name: PeerPressureStringConstant
+ type:
+ enum:
+ - edges
+ - times
+ - propertyName
+
+ # shortestPathStringConstants
+ # : gremlinStringConstants_shortestPathStringConstants_target
+ # | gremlinStringConstants_shortestPathStringConstants_edges
+ # | gremlinStringConstants_shortestPathStringConstants_distance
+ # | gremlinStringConstants_shortestPathStringConstants_maxDistance
+ # | gremlinStringConstants_shortestPathStringConstants_includeEdges
+ # ;
+
+ - name: ShortestPathStringConstant
+ type:
+ enum:
+ - tokens
+ - none
+ - ids
+ - labels
+ - keys
+ - values
+ - all
+ - indexer
+ - list
+ - map
+
+ # withOptionsStringConstants
+ # : gremlinStringConstants_withOptionsStringConstants_tokens
+ # | gremlinStringConstants_withOptionsStringConstants_none
+ # | gremlinStringConstants_withOptionsStringConstants_ids
+ # | gremlinStringConstants_withOptionsStringConstants_labels
+ # | gremlinStringConstants_withOptionsStringConstants_keys
+ # | gremlinStringConstants_withOptionsStringConstants_values
+ # | gremlinStringConstants_withOptionsStringConstants_all
+ # | gremlinStringConstants_withOptionsStringConstants_indexer
+ # | gremlinStringConstants_withOptionsStringConstants_list
+ # | gremlinStringConstants_withOptionsStringConstants_map
+ # ;
+
+ - name: WithOptionsStringConstant
+ type:
+ enum:
+ - tokens
+ - none
+ - ids
+ - labels
+ - keys
+ - values
+ - all
+ - indexer
+ - list
+ - map
+
+# gremlinStringConstants_pageRankStringConstants_edges
+# : pageRankStringConstant DOT 'edges'
+# ;
+#
+# gremlinStringConstants_pageRankStringConstants_times
+# : pageRankStringConstant DOT 'times'
+# ;
+#
+# gremlinStringConstants_pageRankStringConstants_propertyName
+# : pageRankStringConstant DOT 'propertyName'
+# ;
+#
+# gremlinStringConstants_peerPressureStringConstants_edges
+# : peerPressureStringConstant DOT 'edges'
+# ;
+#
+# gremlinStringConstants_peerPressureStringConstants_times
+# : peerPressureStringConstant DOT 'times'
+# ;
+#
+# gremlinStringConstants_peerPressureStringConstants_propertyName
+# : peerPressureStringConstant DOT 'propertyName'
+# ;
+#
+# gremlinStringConstants_shortestPathStringConstants_target
+# : shortestPathStringConstant DOT 'target'
+# ;
+#
+# gremlinStringConstants_shortestPathStringConstants_edges
+# : shortestPathStringConstant DOT 'edges'
+# ;
+#
+# gremlinStringConstants_shortestPathStringConstants_distance
+# : shortestPathStringConstant DOT 'distance'
+# ;
+#
+# gremlinStringConstants_shortestPathStringConstants_maxDistance
+# : shortestPathStringConstant DOT 'maxDistance'
+# ;
+#
+# gremlinStringConstants_shortestPathStringConstants_includeEdges
+# : shortestPathStringConstant DOT 'includeEdges'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_tokens
+# : withOptionsStringConstant DOT 'tokens'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_none
+# : withOptionsStringConstant DOT 'none'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_ids
+# : withOptionsStringConstant DOT 'ids'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_labels
+# : withOptionsStringConstant DOT 'labels'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_keys
+# : withOptionsStringConstant DOT 'keys'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_values
+# : withOptionsStringConstant DOT 'values'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_all
+# : withOptionsStringConstant DOT 'all'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_indexer
+# : withOptionsStringConstant DOT 'indexer'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_list
+# : withOptionsStringConstant DOT 'list'
+# ;
+#
+# gremlinStringConstants_withOptionsStringConstants_map
+# : withOptionsStringConstant DOT 'map'
+# ;
+#
+# pageRankStringConstant
+# : 'PageRank'
+# ;
+#
+# peerPressureStringConstant
+# : 'PeerPressure'
+# ;
+#
+# shortestPathStringConstant
+# : 'ShortestPath'
+# ;
+#
+# withOptionsStringConstant
+# : 'WithOptions'
+# ;
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/literals.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/literals.yaml
new file mode 100644
index 0000000..89c68bb
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/literals.yaml
@@ -0,0 +1,404 @@
+# /*********************************************
+# LEXER RULES
+# **********************************************/
+#
+# // Lexer rules
+# // These rules are extracted from Java ANTLRv4 Grammar.
+# // Source: https://github.com/antlr/grammars-v4/blob/master/java8/Java8.g4
+
+status: experimental
+comments:
+ - >
+ These definitions greatly simplify the original lexer rules from gremlin-language,
+ because we are not concerned with encoding here.
+
+includes:
+ - constants
+
+definitions:
+
+# // 3.9 Keywords
+#
+# NEW : 'new';
+#
+# // Integer Literals
+#
+# IntegerLiteral
+# : Sign? DecimalIntegerLiteral
+# | Sign? HexIntegerLiteral
+# | Sign? OctalIntegerLiteral
+# ;
+#
+# fragment
+# DecimalIntegerLiteral
+# : DecimalNumeral IntegerTypeSuffix?
+# ;
+#
+# fragment
+# HexIntegerLiteral
+# : HexNumeral IntegerTypeSuffix?
+# ;
+#
+# fragment
+# OctalIntegerLiteral
+# : OctalNumeral IntegerTypeSuffix?
+# ;
+#
+# fragment
+# IntegerTypeSuffix
+# : [lL]
+# ;
+#
+# fragment
+# DecimalNumeral
+# : '0'
+# | NonZeroDigit (Digits? | Underscores Digits)
+# ;
+#
+# fragment
+# Digits
+# : Digit (DigitsAndUnderscores? Digit)?
+# ;
+#
+# fragment
+# Digit
+# : '0'
+# | NonZeroDigit
+# ;
+#
+# fragment
+# NonZeroDigit
+# : [1-9]
+# ;
+#
+# fragment
+# DigitsAndUnderscores
+# : DigitOrUnderscore+
+# ;
+#
+# fragment
+# DigitOrUnderscore
+# : Digit
+# | '_'
+# ;
+#
+# fragment
+# Underscores
+# : '_'+
+# ;
+#
+# fragment
+# HexNumeral
+# : '0' [xX] HexDigits
+# ;
+#
+# fragment
+# HexDigits
+# : HexDigit (HexDigitsAndUnderscores? HexDigit)?
+# ;
+#
+# fragment
+# HexDigit
+# : [0-9a-fA-F]
+# ;
+#
+# fragment
+# HexDigitsAndUnderscores
+# : HexDigitOrUnderscore+
+# ;
+#
+# fragment
+# HexDigitOrUnderscore
+# : HexDigit
+# | '_'
+# ;
+#
+# fragment
+# OctalNumeral
+# : '0' Underscores? OctalDigits
+# ;
+#
+# fragment
+# OctalDigits
+# : OctalDigit (OctalDigitsAndUnderscores? OctalDigit)?
+# ;
+#
+# fragment
+# OctalDigit
+# : [0-7]
+# ;
+#
+# fragment
+# OctalDigitsAndUnderscores
+# : OctalDigitOrUnderscore+
+# ;
+#
+# fragment
+# OctalDigitOrUnderscore
+# : OctalDigit
+# | '_'
+# ;
+#
+# // Floating-Point Literals
+#
+# FloatingPointLiteral
+# : Sign? DecimalFloatingPointLiteral
+# ;
+#
+# fragment
+# DecimalFloatingPointLiteral
+# : Digits ('.' Digits ExponentPart? | ExponentPart) FloatTypeSuffix?
+# | Digits FloatTypeSuffix
+# ;
+#
+# fragment
+# ExponentPart
+# : ExponentIndicator SignedInteger
+# ;
+#
+# fragment
+# ExponentIndicator
+# : [eE]
+# ;
+#
+# fragment
+# SignedInteger
+# : Sign? Digits
+# ;
+#
+# fragment
+# Sign
+# : [+-]
+# ;
+#
+# fragment
+# FloatTypeSuffix
+# : [fFdD]
+# ;
+#
+# // Boolean Literals
+#
+# BooleanLiteral
+# : 'true'
+# | 'false'
+# ;
+#
+# // Null Literal
+#
+# NullLiteral
+# : 'null'
+# ;
+#
+# // String Literals
+#
+# // String literal is customized since Java only allows double quoted strings where Groovy supports single quoted
+# // literals also. A side effect of this is ANTLR will not be able to parse single character string literals with
+# // single quoted so we instead remove char literal altogether and only have string literal in lexer tokens.
+# NonEmptyStringLiteral
+# : '"' DoubleQuotedStringCharacters '"'
+# | '\'' SingleQuotedStringCharacters '\''
+# ;
+
+ - name: NonEmptyStringLiteral
+ type: string
+
+# // We define NonEmptyStringLiteral and EmptyStringLiteral separately so that we can unambiguously handle empty queries
+# EmptyStringLiteral
+# : '""'
+# | '\'\''
+# ;
+
+ - name: EmptyStringLiteral
+
+# fragment
+# DoubleQuotedStringCharacters
+# : DoubleQuotedStringCharacter+
+# ;
+#
+# fragment
+# DoubleQuotedStringCharacter
+# : ~('"' | '\\')
+# | JoinLineEscape
+# | EscapeSequence
+# ;
+#
+# fragment
+# SingleQuotedStringCharacters
+# : SingleQuotedStringCharacter+
+# ;
+#
+# fragment
+# SingleQuotedStringCharacter
+# : ~('\'' | '\\')
+# | JoinLineEscape
+# | EscapeSequence
+# ;
+#
+# // Escape Sequences for Character and String Literals
+# fragment JoinLineEscape
+# : '\\' '\r'? '\n'
+# ;
+#
+# fragment
+# EscapeSequence
+# : '\\' [btnfr"'\\]
+# | OctalEscape
+# | UnicodeEscape // This is not in the spec but prevents having to preprocess the input
+# ;
+#
+# fragment
+# OctalEscape
+# : '\\' OctalDigit
+# | '\\' OctalDigit OctalDigit
+# | '\\' ZeroToThree OctalDigit OctalDigit
+# ;
+#
+# fragment
+# ZeroToThree
+# : [0-3]
+# ;
+#
+# // This is not in the spec but prevents having to preprocess the input
+# fragment
+# UnicodeEscape
+# : '\\' 'u'+ HexDigit HexDigit HexDigit HexDigit
+# ;
+#
+# // Separators
+#
+# LPAREN : '(';
+# RPAREN : ')';
+# LBRACE : '{';
+# RBRACE : '}';
+# LBRACK : '[';
+# RBRACK : ']';
+# SEMI : ';';
+# COMMA : ',';
+# DOT : '.';
+# COLON : ':';
+#
+# TRAVERSAL_ROOT: 'g';
+# ANON_TRAVERSAL_ROOT: '__';
+#
+# // Trim whitespace and comments if present
+#
+# WS : [ \t\r\n\u000C]+ -> skip
+# ;
+#
+# LINE_COMMENT
+# : '//' ~[\r\n]* -> skip
+# ;
+
+
+ # genericLiteralList
+ # : genericLiteralExpr?
+ # ;
+ #
+ # genericLiteralExpr
+ # : genericLiteral (COMMA genericLiteral)*
+ # ;
+ #
+ # genericLiteralRange
+ # : integerLiteral DOT DOT integerLiteral
+ # | stringLiteral DOT DOT stringLiteral
+ # ;
+ #
+ # genericLiteralCollection
+ # : LBRACK (genericLiteral (COMMA genericLiteral)*)? RBRACK
+ # ;
+ #
+ # stringLiteralList
+ # : stringLiteralExpr?
+ # | LBRACK stringLiteralExpr? RBRACK
+ # ;
+ #
+ # stringLiteralExpr
+ # : stringLiteral (COMMA stringLiteral)*
+ # ;
+ #
+ # genericLiteral
+ # : integerLiteral
+ # | floatLiteral
+ # | booleanLiteral
+ # | stringLiteral
+ # | dateLiteral
+ # | nullLiteral
+ # // Allow the generic literal to match specific gremlin tokens also
+ # | traversalToken
+ # | traversalCardinality
+ # | traversalDirection
+ # | traversalOptionParent
+ # | genericLiteralCollection
+ # | genericLiteralRange
+ # | nestedTraversal
+ # | terminatedTraversal
+ # | genericLiteralMap
+ # ;
+
+ - name: GenericLiteral
+ type:
+ union:
+ - name: integer
+ type: integer
+
+ - name: float
+ type: float
+
+ - name: boolean
+ type: boolean
+
+ - name: string
+ type: string
+
+ - name: date
+ type: DateLiteral
+
+ - name: "null"
+
+ # TODO: others
+
+ # genericLiteralMap
+ # : LBRACK (genericLiteral)? COLON (genericLiteral)? (COMMA (genericLiteral)? COLON (genericLiteral)?)* RBRACK
+ # ;
+ #
+ # integerLiteral
+ # : IntegerLiteral
+ # ;
+ #
+ # floatLiteral
+ # : FloatingPointLiteral
+ # ;
+ #
+ # booleanLiteral
+ # : BooleanLiteral
+ # ;
+ #
+ # stringLiteral
+ # : NonEmptyStringLiteral
+ # | EmptyStringLiteral
+ # | gremlinStringConstants
+ # ;
+
+ - name: StringLiteral
+ type:
+ union:
+ - name: empty
+ type: EmptyStringLiteral
+
+ - name: nonEmpty
+ type: NonEmptyStringLiteral
+
+ - name: constant
+ type: constants.GremlinStringConstant
+
+ # dateLiteral
+ # : 'datetime' LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: DateLiteral
+ type: string
+
+# nullLiteral
+# : NullLiteral
+# ;
+#
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/methods.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/methods.yaml
new file mode 100644
index 0000000..ca2369e
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/methods.yaml
@@ -0,0 +1,113 @@
+status: experimental
+
+definitions:
+
+ # traversalSackMethod
+ # : 'normSack' | 'Barrier.normSack'
+ # ;
+
+ - name: TraversalSackMethod
+
+ # traversalSelfMethod
+ # : traversalSelfMethod_none
+ # ;
+
+ - name: TraversalSelfMethod
+ type:
+ union:
+ - name: none
+
+ # traversalSelfMethod_none
+ # : 'none' LPAREN RPAREN
+ # ;
+ #
+ #
+
+ # traversalTerminalMethod
+ # : traversalTerminalMethod_explain
+ # | traversalTerminalMethod_iterate
+ # | traversalTerminalMethod_hasNext
+ # | traversalTerminalMethod_tryNext
+ # | traversalTerminalMethod_next
+ # | traversalTerminalMethod_toList
+ # | traversalTerminalMethod_toSet
+ # | traversalTerminalMethod_toBulkSet
+ # ;
+
+ - name: TraversalTerminalMethod
+ type:
+ union:
+ - name: explain
+ type: ExplainMethod
+
+ - name: iterate
+ type: IterateMethod
+
+ - name: hasNext
+ type: HasNextMethod
+
+ - name: tryNext
+ type: TryNextMethod
+
+ - name: next
+ type: NextMethod
+
+ - name: toList
+ type: ToListMethod
+
+ - name: toSet
+ type: ToSetMethod
+
+ - name: toBulkSet
+ type: ToBulkSetMethod
+
+ # traversalTerminalMethod_explain
+ # : 'explain' LPAREN RPAREN
+ # ;
+
+ - name: ExplainMethod
+
+ # traversalTerminalMethod_hasNext
+ # : 'hasNext' LPAREN RPAREN
+ # ;
+
+ - name: HasNextMethod
+
+ # traversalTerminalMethod_iterate
+ # : 'iterate' LPAREN RPAREN
+ # ;
+
+ - name: IterateMethod
+
+ # traversalTerminalMethod_tryNext
+ # : 'tryNext' LPAREN RPAREN
+ # ;
+
+ - name: TryNextMethod
+
+ # traversalTerminalMethod_next
+ # : 'next' LPAREN RPAREN
+ # | 'next' LPAREN integerLiteral RPAREN
+ # ;
+
+ - name: NextMethod
+ type:
+ optional: integer
+
+ # traversalTerminalMethod_toList
+ # : 'toList' LPAREN RPAREN
+ # ;
+
+ - name: ToListMethod
+
+ # traversalTerminalMethod_toSet
+ # : 'toSet' LPAREN RPAREN
+ # ;
+
+ - name: ToSetMethod
+
+ # traversalTerminalMethod_toBulkSet
+ # : 'toBulkSet' LPAREN RPAREN
+ # ;
+
+ - name: ToBulkSetMethod
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/predicates.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/predicates.yaml
new file mode 100644
index 0000000..17bacb8
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/predicates.yaml
@@ -0,0 +1,234 @@
+status: experimental
+
+includes:
+ - literals
+
+definitions:
+
+ # traversalPredicate
+ # : traversalPredicate_eq
+ # | traversalPredicate_neq
+ # | traversalPredicate_lt
+ # | traversalPredicate_lte
+ # | traversalPredicate_gt
+ # | traversalPredicate_gte
+ # | traversalPredicate_inside
+ # | traversalPredicate_outside
+ # | traversalPredicate_between
+ # | traversalPredicate_within
+ # | traversalPredicate_without
+ # | traversalPredicate_not
+ # | traversalPredicate_startingWith
+ # | traversalPredicate_notStartingWith
+ # | traversalPredicate_endingWith
+ # | traversalPredicate_notEndingWith
+ # | traversalPredicate_containing
+ # | traversalPredicate_notContaining
+ # | traversalPredicate DOT 'and' LPAREN traversalPredicate RPAREN
+ # | traversalPredicate DOT 'or' LPAREN traversalPredicate RPAREN
+ # | traversalPredicate DOT 'negate' LPAREN RPAREN
+ # ;
+
+ - name: TraversalPredicate
+ type:
+ union:
+ - name: eq
+ type: Eq
+
+ - name: neq
+ type: Neq
+
+ - name: lt
+ type: Lt
+
+ - name: lte
+ type: Lte
+
+ - name: gt
+ type: Gt
+
+ - name: gte
+ type: Gte
+
+ - name: inside
+ type: Inside
+
+ - name: outside
+ type: Outside
+
+ - name: between
+ type: Between
+
+ - name: within
+ type: Within
+
+ - name: without
+ type: Without
+
+ - name: not
+ type: Not
+
+ - name: startingWith
+ type: StartingWith
+
+ - name: notStartingWith
+ type: NotStartingWith
+
+ - name: endingWith
+ type: NotEndingWith
+
+ - name: containing
+ type: NotContaining
+
+ - name: and
+ type: TraversalPredicate
+
+ - name: or
+ type: TraversalPredicate
+
+ - name: negate
+
+ # traversalPredicate_eq
+ # : ('P.eq' | 'eq') LPAREN genericLiteral RPAREN
+ # ;
+ - name: Eq
+ type: literals.GenericLiteral
+
+ # traversalPredicate_neq
+ # : ('P.neq' | 'neq') LPAREN genericLiteral RPAREN
+ # ;
+
+ - name: Neq
+ type: literals.GenericLiteral
+
+ # traversalPredicate_lt
+ # : ('P.lt' | 'lt') LPAREN genericLiteral RPAREN
+ # ;
+
+ - name: Lt
+ type: literals.GenericLiteral
+
+ # traversalPredicate_lte
+ # : ('P.lte' | 'lte') LPAREN genericLiteral RPAREN
+ # ;
+
+ - name: Lte
+ type: literals.GenericLiteral
+
+ # traversalPredicate_gt
+ # : ('P.gt' | 'gt') LPAREN genericLiteral RPAREN
+ # ;
+
+ - name: Gt
+ type: literals.GenericLiteral
+
+ # traversalPredicate_gte
+ # : ('P.gte' | 'gte') LPAREN genericLiteral RPAREN
+ # ;
+
+ - name: Gte
+ type: literals.GenericLiteral
+
+ # traversalPredicate_inside
+ # : ('P.inside' | 'inside') LPAREN genericLiteral COMMA genericLiteral RPAREN
+ # ;
+
+ - name: Inside
+ type:
+ record:
+ - name: min
+ type: literals.GenericLiteral
+
+ - name: max
+ type: literals.GenericLiteral
+
+ # traversalPredicate_outside
+ # : ('P.outside' | 'outside') LPAREN genericLiteral COMMA genericLiteral RPAREN
+ # ;
+
+ - name: Outside
+ type:
+ record:
+ - name: min
+ type: literals.GenericLiteral
+
+ - name: max
+ type: literals.GenericLiteral
+
+ # traversalPredicate_between
+ # : ('P.between' | 'between') LPAREN genericLiteral COMMA genericLiteral RPAREN
+ # ;
+
+ - name: Between
+ type:
+ record:
+ - name: min
+ type: literals.GenericLiteral
+
+ - name: max
+ type: literals.GenericLiteral
+
+ # traversalPredicate_within
+ # : ('P.within' | 'within') LPAREN genericLiteralList RPAREN
+ # ;
+
+ - name: Within
+ type:
+ list: literals.GenericLiteral
+
+ # traversalPredicate_without
+ # : ('P.without' | 'without') LPAREN genericLiteralList RPAREN
+ # ;
+
+ - name: Without
+ type:
+ list: literals.GenericLiteral
+
+ # traversalPredicate_not
+ # : ('P.not' | 'not') LPAREN traversalPredicate RPAREN
+ # ;
+
+ - name: Not
+ type: string
+
+ # traversalPredicate_containing
+ # : ('TextP.containing' | 'containing') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: Containing
+ type: string
+
+ # traversalPredicate_notContaining
+ # : ('TextP.notContaining' | 'notContaining') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: NotContaining
+ type: string
+
+ # traversalPredicate_startingWith
+ # : ('TextP.startingWith' | 'startingWith') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: StartingWith
+ type: string
+
+ # traversalPredicate_notStartingWith
+ # : ('TextP.notStartingWith' | 'notStartingWith') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: NotStartingWith
+ type: string
+
+ # traversalPredicate_endingWith
+ # : ('TextP.endingWith' | 'endingWith') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: EndingWith
+ type: string
+
+ # traversalPredicate_notEndingWith
+ # : ('TextP.notEndingWith' | 'notEndingWith') LPAREN stringLiteral RPAREN
+ # ;
+
+ - name: NotEndingWith
+ type: string
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/query.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/query.yaml
new file mode 100644
index 0000000..85ef1d5
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/query.yaml
@@ -0,0 +1,60 @@
+status: experimental
+
+includes:
+ - methods
+ - traversal
+
+definitions:
+
+ # queryList
+ # : query (SEMI? query)* SEMI? EOF
+ # ;
+ #
+ # query
+ # : traversalSource (DOT transactionPart)?
+ # | rootTraversal (DOT traversalTerminalMethod)?
+ # | query DOT 'toString' LPAREN RPAREN
+ # | emptyQuery
+ # ;
+
+ - name: Query
+ type:
+ union:
+ - name: withSource
+ type:
+ record:
+ - name: source
+ type: traversal.TraversalSource
+
+ - name: transactionPart
+ type:
+ optional: TransactionPart
+
+ - name: withRoot
+ type:
+ record:
+ - name: root
+ type: traversal.RootTraversal
+
+ - name: method
+ type:
+ optional: methods.TraversalTerminalMethod
+
+ - name: toString
+ type: Query
+
+ - name: empty
+
+ # emptyQuery
+ # : EmptyStringLiteral
+ # ;
+
+ # transactionPart
+ # : 'tx' LPAREN RPAREN DOT ('commit' | 'rollback')? LPAREN RPAREN
+ # ;
+
+ - name: TransactionPart
+ type:
+ enum:
+ - commit
+ - rollback
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/steps.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/steps.yaml
new file mode 100644
index 0000000..edafef7
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/steps.yaml
@@ -0,0 +1,1802 @@
+# /*********************************************
+# GENERATED GRAMMAR - DO NOT CHANGE
+# **********************************************/
+
+status: experimental
+
+includes:
+ - literals
+ - methods
+ - predicates
+ - traversal
+
+definitions:
+
+# traversalMethod
+# : traversalMethod_V
+# | traversalMethod_addE
+# | traversalMethod_addV
+# | traversalMethod_aggregate
+# | traversalMethod_and
+# | traversalMethod_as
+# | traversalMethod_barrier
+# | traversalMethod_both
+# | traversalMethod_bothE
+# | traversalMethod_bothV
+# | traversalMethod_branch
+# | traversalMethod_by
+# | traversalMethod_cap
+# | traversalMethod_choose
+# | traversalMethod_coalesce
+# | traversalMethod_coin
+# | traversalMethod_connectedComponent
+# | traversalMethod_constant
+# | traversalMethod_count
+# | traversalMethod_cyclicPath
+# | traversalMethod_dedup
+# | traversalMethod_drop
+# | traversalMethod_elementMap
+# | traversalMethod_emit
+# | traversalMethod_filter
+# | traversalMethod_flatMap
+# | traversalMethod_fold
+# | traversalMethod_from
+# | traversalMethod_group
+# | traversalMethod_groupCount
+# | traversalMethod_has
+# | traversalMethod_hasId
+# | traversalMethod_hasKey
+# | traversalMethod_hasLabel
+# | traversalMethod_hasNot
+# | traversalMethod_hasValue
+# | traversalMethod_id
+# | traversalMethod_identity
+# | traversalMethod_in
+# | traversalMethod_inE
+# | traversalMethod_inV
+# | traversalMethod_index
+# | traversalMethod_inject
+# | traversalMethod_is
+# | traversalMethod_key
+# | traversalMethod_label
+# | traversalMethod_limit
+# | traversalMethod_local
+# | traversalMethod_loops
+# | traversalMethod_map
+# | traversalMethod_match
+# | traversalMethod_math
+# | traversalMethod_max
+# | traversalMethod_mean
+# | traversalMethod_min
+# | traversalMethod_not
+# | traversalMethod_option
+# | traversalMethod_optional
+# | traversalMethod_or
+# | traversalMethod_order
+# | traversalMethod_otherV
+# | traversalMethod_out
+# | traversalMethod_outE
+# | traversalMethod_outV
+# | traversalMethod_pageRank
+# | traversalMethod_path
+# | traversalMethod_peerPressure
+# | traversalMethod_profile
+# | traversalMethod_project
+# | traversalMethod_properties
+# | traversalMethod_property
+# | traversalMethod_propertyMap
+# | traversalMethod_range
+# | traversalMethod_read
+# | traversalMethod_repeat
+# | traversalMethod_sack
+# | traversalMethod_sample
+# | traversalMethod_select
+# | traversalMethod_shortestPath
+# | traversalMethod_sideEffect
+# | traversalMethod_simplePath
+# | traversalMethod_skip
+# | traversalMethod_store
+# | traversalMethod_subgraph
+# | traversalMethod_sum
+# | traversalMethod_tail
+# | traversalMethod_timeLimit
+# | traversalMethod_times
+# | traversalMethod_to
+# | traversalMethod_toE
+# | traversalMethod_toV
+# | traversalMethod_tree
+# | traversalMethod_unfold
+# | traversalMethod_union
+# | traversalMethod_until
+# | traversalMethod_value
+# | traversalMethod_valueMap
+# | traversalMethod_values
+# | traversalMethod_where
+# | traversalMethod_with
+# | traversalMethod_write
+# ;
+
+ - name: TraversalMethod
+ type:
+ union:
+ - name: v
+ type: VStep
+
+ - name: addE
+ type: AddEStep
+
+ - name: addV
+ type: AddVStep
+
+ - name: aggregate
+ type: AggregateStep
+
+ - name: and
+ type: AndStep
+
+ - name: as
+ type: AsStep
+
+ - name: barrier
+ type: BarrierStep
+
+ - name: both
+ type: BothStep
+
+ - name: bothE
+ type: BothEStep
+
+ - name: bothV
+ type: BothVStep
+
+ - name: branch
+ type: BranchStep
+
+ - name: by
+ type: ByStep
+
+ - name: cap
+ type: CapStep
+
+ - name: choose
+ type: ChooseStep
+
+ - name: coalesce
+ type: CoalesceStep
+
+ - name: coin
+ type: CoinStep
+
+ - name: connectedComponent
+ type: ConnectedComponentStep
+
+ - name: constant
+ type: ConstantStep
+
+ - name: count
+ type: CountStep
+
+ - name: cyclicPath
+ type: CyclicPathStep
+
+ - name: dedup
+ type: DedupStep
+
+ - name: drop
+ type: DropStep
+
+ - name: elementMap
+ type: ElementMapStep
+
+ - name: emit
+ type: EmitStep
+
+ - name: filter
+ type: FilterStep
+
+ - name: flatMap
+ type: FlatMapStep
+
+ - name: fold
+ type: FoldStep
+
+ - name: from
+ type: FromStep
+
+ - name: group
+ type: GroupStep
+
+ - name: groupCount
+ type: GroupCountStep
+
+ - name: has
+ type: HasStep
+
+ - name: hasId
+ type: HasIdStep
+
+ - name: hasKey
+ type: HasKeyStep
+
+ - name: hasLabel
+ type: HasLabelStep
+
+ - name: hasNot
+ type: HasNotStep
+
+ - name: hasValue
+ type: HasValueStep
+
+ - name: id
+ type: IdStep
+
+ - name: identity
+ type: IdentityStep
+
+ - name: in
+ type: InStep
+
+ - name: inE
+ type: InEStep
+
+ - name: inV
+ type: InVStep
+
+ - name: index
+ type: IndexStep
+
+ - name: inject
+ type: InjectStep
+
+ - name: is
+ type: IsStep
+
+ - name: key
+ type: KeyStep
+
+ - name: label
+ type: LabelStep
+
+ - name: limit
+ type: LimitStep
+
+ - name: local
+ type: LocalStep
+
+ - name: loops
+ type: LoopsStep
+
+ - name: map
+ type: MapStep
+
+ - name: match
+ type: MatchStep
+
+ - name: math
+ type: MathStep
+
+ - name: max
+ type: MaxStep
+
+ - name: mean
+ type: MeanStep
+
+ - name: min
+ type: MinStep
+
+ - name: not
+ type: NotStep
+
+ - name: option
+ type: OptionStep
+
+ - name: optional
+ type: OptionalStep
+
+ - name: or
+ type: OrStep
+
+ - name: order
+ type: OrderStep
+
+ - name: otherV
+ type: OtherVStep
+
+ - name: out
+ type: OutStep
+
+ - name: outE
+ type: OutEStep
+
+ - name: outV
+ type: OutVStep
+
+ - name: pageRank
+ type: PageRankStep
+
+ - name: path
+ type: PathStep
+
+ - name: peerPressure
+ type: PeerPressureStep
+
+ - name: profile
+ type: ProfileStep
+
+ - name: project
+ type: ProjectStep
+
+ - name: properties
+ type: PropertiesStep
+
+ - name: property
+ type: PropertyStep
+
+ - name: propertyMap
+ type: PropertyMapStep
+
+ - name: range
+ type: RangeStep
+
+ - name: read
+ type: ReadStep
+
+ - name: repeat
+ type: RepeatStep
+
+ - name: sack
+ type: SackStep
+
+ - name: sample
+ type: SampleStep
+
+ - name: select
+ type: SelectStep
+
+ - name: shortestPath
+ type: ShortestPathStep
+
+ - name: sideEffect
+ type: SideEffectStep
+
+ - name: simplePath
+ type: SimplePathStep
+
+ - name: skip
+ type: SkipStep
+
+ - name: store
+ type: StoreStep
+
+ - name: subgraph
+ type: SubgraphStep
+
+ - name: sum
+ type: SumStep
+
+ - name: tail
+ type: TailStep
+
+ - name: timeLimit
+ type: TimeLimitStep
+
+ - name: times
+ type: TimesStep
+
+ - name: to
+ type: ToStep
+
+ - name: toE
+ type: ToEStep
+
+ - name: toV
+ type: ToVStep
+
+ - name: tree
+ type: TreeStep
+
+ - name: unfold
+ type: UnfoldStep
+
+ - name: union
+ type: UnionStep
+
+ - name: until
+ type: UntilStep
+
+ - name: value
+ type: ValueStep
+
+ - name: valueMap
+ type: ValueMapStep
+
+ - name: values
+ type: ValuesStep
+
+ - name: where
+ type: WhereStep
+
+ - name: with
+ type: WithStep
+
+ - name: write
+ type: WriteStep
+
+# traversalMethod_V
+# : 'V' LPAREN genericLiteralList RPAREN
+# ;
+
+ - name: VStep
+ properties:
+ - type: annotations.StepName
+ value: "V"
+ type:
+ record:
+ - name: vertexIdsOrElements
+ type:
+ list: literals.GenericLiteral
+
+# traversalMethod_addE
+# : 'addE' LPAREN stringLiteral RPAREN #traversalMethod_addE_String
+# | 'addE' LPAREN nestedTraversal RPAREN #traversalMethod_addE_Traversal
+# ;
+
+ - name: AddEStep
+ type:
+ union:
+ - name: edgeLabel
+ type: string
+
+ - name: edgeLabelTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_addV
+# : 'addV' LPAREN RPAREN #traversalMethod_addV_Empty
+# | 'addV' LPAREN stringLiteral RPAREN #traversalMethod_addV_String
+# | 'addV' LPAREN nullLiteral RPAREN #traversalMethod_addV_String // null means use the default vertex label
+# | 'addV' LPAREN nestedTraversal RPAREN #traversalMethod_addV_Traversal
+# ;
+
+ - name: AddVStep
+ type:
+ union:
+ - name: empty
+
+ - name: vertexLabel
+ type: string
+
+ - name: "null"
+
+ - name: vertexLabelTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_aggregate
+# : 'aggregate' LPAREN traversalScope COMMA stringLiteral RPAREN #traversalMethod_aggregate_Scope_String
+# | 'aggregate' LPAREN stringLiteral RPAREN #traversalMethod_aggregate_String
+# ;
+
+ - name: AggregateStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: sideEffectKey
+ type: string
+
+# traversalMethod_and
+# : 'and' LPAREN nestedTraversalList RPAREN
+# ;
+
+ - name: AndStep
+ type:
+ record:
+ - name: andTraversals
+ type:
+ list: traversal.NestedTraversal
+
+# traversalMethod_as
+# : 'as' LPAREN stringLiteral (COMMA stringLiteralList)? RPAREN
+# ;
+
+ - name: AsStep
+ type:
+ record:
+ - name: stepLabel
+ type: string
+
+ - name: stepLabels
+ type:
+ list: string
+
+# traversalMethod_barrier
+# : 'barrier' LPAREN traversalSackMethod RPAREN #traversalMethod_barrier_Consumer
+# | 'barrier' LPAREN RPAREN #traversalMethod_barrier_Empty
+# | 'barrier' LPAREN integerLiteral RPAREN #traversalMethod_barrier_int
+# ;
+
+ - name: BarrierStep
+ type:
+ optional:
+ union:
+ - name: barrierConsumer
+ type: methods.TraversalSackMethod
+
+ - name: maxBarrierSize
+ type: integer
+
+ # traversalMethod_both
+# : 'both' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: BothStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_bothE
+# : 'bothE' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: BothEStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_bothV
+# : 'bothV' LPAREN RPAREN
+# ;
+
+ - name: BothVStep
+
+# traversalMethod_branch
+# : 'branch' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: BranchStep
+ type:
+ record:
+ - name: branchTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_by
+# : 'by' LPAREN traversalComparator RPAREN #traversalMethod_by_Comparator
+# | 'by' LPAREN RPAREN #traversalMethod_by_Empty
+# | 'by' LPAREN traversalFunction RPAREN #traversalMethod_by_Function
+# | 'by' LPAREN traversalFunction COMMA traversalComparator RPAREN #traversalMethod_by_Function_Comparator
+# | 'by' LPAREN traversalOrder RPAREN #traversalMethod_by_Order
+# | 'by' LPAREN stringLiteral RPAREN #traversalMethod_by_String
+# | 'by' LPAREN stringLiteral COMMA traversalComparator RPAREN #traversalMethod_by_String_Comparator
+# | 'by' LPAREN traversalToken RPAREN #traversalMethod_by_T
+# | 'by' LPAREN nestedTraversal RPAREN #traversalMethod_by_Traversal
+# | 'by' LPAREN nestedTraversal COMMA traversalComparator RPAREN #traversalMethod_by_Traversal_Comparator
+# ;
+
+ - name: ByStep
+ type:
+ optional:
+ union:
+ - name: withTraversal
+ type:
+ record:
+ - name: traversal
+ type: traversal.NestedTraversal
+
+ - name: comparator
+ type: traversal.TraversalComparator
+
+ - name: withKey
+ type:
+ record:
+ - name: key
+ type: string
+
+ - name: comparator
+ type:
+ optional: traversal.TraversalComparator
+
+ - name: withFunction
+ type:
+ record:
+ - name: function
+ type: traversal.TraversalFunction
+
+ - name: comparator
+ type:
+ optional: traversal.TraversalComparator
+
+ - name: token
+ type: traversal.TraversalToken
+
+ - name: comparator
+ type: traversal.TraversalComparator
+
+ - name: order
+ type: traversal.TraversalOrder
+
+# traversalMethod_cap
+# : 'cap' LPAREN stringLiteral (COMMA stringLiteralList)? RPAREN
+# ;
+
+ - name: CapStep
+ type:
+ record:
+ - name: sideEffectKey
+ type: string
+
+ - name: sideEffectKeys
+ type:
+ list: string
+
+# traversalMethod_choose
+# : 'choose' LPAREN traversalFunction RPAREN #traversalMethod_choose_Function
+# | 'choose' LPAREN traversalPredicate COMMA nestedTraversal RPAREN #traversalMethod_choose_Predicate_Traversal
+# | 'choose' LPAREN traversalPredicate COMMA nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Predicate_Traversal_Traversal
+# | 'choose' LPAREN nestedTraversal RPAREN #traversalMethod_choose_Traversal
+# | 'choose' LPAREN nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Traversal_Traversal
+# | 'choose' LPAREN nestedTraversal COMMA nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Traversal_Traversal_Traversal
+# ;
+
+ - name: ChooseStep
+ type:
+ union:
+ - name: choiceTraversal
+ type: traversal.NestedTraversal
+
+ - name: withTraversal
+ type:
+ record:
+ - name: traversalPredicate
+ type: traversal.NestedTraversal
+
+ - name: trueChoice
+ type: predicates.TraversalPredicate
+
+ - name: falseChoice
+ type:
+ optional: predicates.TraversalPredicate
+
+ - name: withPredicate
+ type:
+ record:
+ - name: traversalPredicate
+ type: predicates.TraversalPredicate
+
+ - name: trueChoice
+ type: predicates.TraversalPredicate
+
+ - name: falseChoice
+ type:
+ optional: predicates.TraversalPredicate
+
+# traversalMethod_coalesce
+# : 'coalesce' LPAREN nestedTraversalList RPAREN
+# ;
+
+ - name: CoalesceStep
+ type:
+ record:
+ - name: coalesceTraversals
+ type:
+ list: traversal.NestedTraversal
+
+# traversalMethod_coin
+# : 'coin' LPAREN floatLiteral RPAREN
+# ;
+
+ - name: CoinStep
+ type:
+ record:
+ - name: probability
+ type: float
+
+# traversalMethod_connectedComponent
+# : 'connectedComponent' LPAREN RPAREN
+# ;
+
+ - name: ConnectedComponentStep
+
+# traversalMethod_constant
+# : 'constant' LPAREN genericLiteral RPAREN
+# ;
+
+ - name: ConstantStep
+ type:
+ record:
+ - name: e
+ type: literals.GenericLiteral
+
+# traversalMethod_count
+# : 'count' LPAREN RPAREN #traversalMethod_count_Empty
+# | 'count' LPAREN traversalScope RPAREN #traversalMethod_count_Scope
+# ;
+
+ - name: CountStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_cyclicPath
+# : 'cyclicPath' LPAREN RPAREN
+# ;
+
+ - name: CyclicPathStep
+
+# traversalMethod_dedup
+# : 'dedup' LPAREN traversalScope (COMMA stringLiteralList)? RPAREN #traversalMethod_dedup_Scope_String
+# | 'dedup' LPAREN stringLiteralList RPAREN #traversalMethod_dedup_String
+# ;
+
+ - name: DedupStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: dedupLabels
+ type:
+ list: string
+
+# traversalMethod_drop
+# : 'drop' LPAREN RPAREN
+# ;
+
+ - name: DropStep
+
+# traversalMethod_elementMap
+# : 'elementMap' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: ElementMapStep
+ type:
+ record:
+ - name: propertyKeys
+ type:
+ list: string
+
+# traversalMethod_emit
+# : 'emit' LPAREN RPAREN #traversalMethod_emit_Empty
+# | 'emit' LPAREN traversalPredicate RPAREN #traversalMethod_emit_Predicate
+# | 'emit' LPAREN nestedTraversal RPAREN #traversalMethod_emit_Traversal
+# ;
+
+ - name: EmitStep
+ type:
+ optional:
+ union:
+ - name: emitPredicate
+ type: predicates.TraversalPredicate
+
+ - name: emitTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_filter
+# : 'filter' LPAREN traversalPredicate RPAREN #traversalMethod_filter_Predicate
+# | 'filter' LPAREN nestedTraversal RPAREN #traversalMethod_filter_Traversal
+# ;
+
+ - name: FilterStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: filterTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_flatMap
+# : 'flatMap' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: FlatMapStep
+ type:
+ record:
+ - name: flatMapTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_fold
+# : 'fold' LPAREN RPAREN #traversalMethod_fold_Empty
+# | 'fold' LPAREN genericLiteral COMMA traversalBiFunction RPAREN #traversalMethod_fold_Object_BiFunction
+# ;
+
+ - name: FoldStep
+ type:
+ optional:
+ record:
+ - name: seed
+ type: literals.GenericLiteral
+
+ - name: foldFunction
+ type: traversal.TraversalBiFunction
+
+# traversalMethod_from
+# : 'from' LPAREN stringLiteral RPAREN #traversalMethod_from_String
+# | 'from' LPAREN nestedTraversal RPAREN #traversalMethod_from_Traversal
+# ;
+
+ - name: FromStep
+ type:
+ union:
+ - name: fromStepLabel
+ type: string
+
+ - name: fromVertex
+ type: traversal.NestedTraversal
+
+# traversalMethod_group
+# : 'group' LPAREN RPAREN #traversalMethod_group_Empty
+# | 'group' LPAREN stringLiteral RPAREN #traversalMethod_group_String
+# ;
+
+ - name: GroupStep
+ type:
+ record:
+ - name: sideEffectKey
+ type:
+ optional: string
+
+# traversalMethod_groupCount
+# : 'groupCount' LPAREN RPAREN #traversalMethod_groupCount_Empty
+# | 'groupCount' LPAREN stringLiteral RPAREN #traversalMethod_groupCount_String
+# ;
+
+ - name: GroupCountStep
+ type:
+ record:
+ - name: sideEffectKey
+ type:
+ optional: string
+
+# traversalMethod_has
+# : 'has' LPAREN stringLiteral RPAREN #traversalMethod_has_String
+# | 'has' LPAREN stringLiteral COMMA genericLiteral RPAREN #traversalMethod_has_String_Object
+# | 'has' LPAREN stringLiteral COMMA traversalPredicate RPAREN #traversalMethod_has_String_P
+# | 'has' LPAREN stringLiteral COMMA stringLiteral COMMA genericLiteral RPAREN #traversalMethod_has_String_String_Object
+# | 'has' LPAREN stringLiteral COMMA stringLiteral COMMA traversalPredicate RPAREN #traversalMethod_has_String_String_P
+# | 'has' LPAREN stringLiteral COMMA nestedTraversal RPAREN #traversalMethod_has_String_Traversal
+# | 'has' LPAREN traversalToken COMMA genericLiteral RPAREN #traversalMethod_has_T_Object
+# | 'has' LPAREN traversalToken COMMA traversalPredicate RPAREN #traversalMethod_has_T_P
+# | 'has' LPAREN traversalToken COMMA nestedTraversal RPAREN #traversalMethod_has_T_Traversal
+# ;
+
+ - name: HasStep
+ type:
+ union:
+ - name: withPropertyKey
+ type:
+ record:
+ - name: propertyKey
+ type: string
+
+ - name: otherArguments
+ type:
+ optional:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: value
+ type: literals.GenericLiteral
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+ - name: withAccessor
+ type:
+ record:
+ - name: accessor
+ type: traversal.TraversalToken
+
+ - name: other
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: value
+ type: literals.GenericLiteral
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+ - name: withLabel
+ type:
+ record:
+ - name: label
+ type: string
+
+ - name: propertyKey
+ type: string
+
+ - name: other
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: value
+ type: literals.GenericLiteral
+
+# traversalMethod_hasId
+# : 'hasId' LPAREN genericLiteral (COMMA genericLiteralList)? RPAREN #traversalMethod_hasId_Object_Object
+# | 'hasId' LPAREN traversalPredicate RPAREN #traversalMethod_hasId_P
+# ;
+
+ - name: HasIdStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: withIds
+ type:
+ record:
+ - name: id
+ type: literals.GenericLiteral
+
+ - name: otherIds
+ type:
+ list: literals.GenericLiteral
+
+# traversalMethod_hasKey
+# : 'hasKey' LPAREN traversalPredicate RPAREN #traversalMethod_hasKey_P
+# | 'hasKey' LPAREN stringLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_hasKey_String_String
+# ;
+
+ - name: HasKeyStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: withLabels
+ type:
+ record:
+ - name: label
+ type: string
+
+ - name: otherLabels
+ type:
+ list: string
+
+# traversalMethod_hasLabel
+# : 'hasLabel' LPAREN traversalPredicate RPAREN #traversalMethod_hasLabel_P
+# | 'hasLabel' LPAREN stringLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_hasLabel_String_String
+# ;
+
+ - name: HasLabelStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: withLabels
+ type:
+ record:
+ - name: label
+ type: string
+
+ - name: otherLabels
+ type:
+ list: string
+
+# traversalMethod_hasNot
+# : 'hasNot' LPAREN stringLiteral RPAREN
+# ;
+
+ - name: HasNotStep
+ type:
+ record:
+ - name: propertyKey
+ type: string
+
+# traversalMethod_hasValue
+# : 'hasValue' LPAREN genericLiteral (COMMA genericLiteralList)? RPAREN #traversalMethod_hasValue_Object_Object
+# | 'hasValue' LPAREN traversalPredicate RPAREN #traversalMethod_hasValue_P
+# ;
+
+ - name: HasValueStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: withValues
+ type:
+ - name: value
+ type: literals.GenericLiteral
+
+ - name: otherValues
+ type:
+ list: literals.GenericLiteral
+
+# traversalMethod_id
+# : 'id' LPAREN RPAREN
+# ;
+
+ - name: IdStep
+
+# traversalMethod_identity
+# : 'identity' LPAREN RPAREN
+# ;
+
+ - name: IdentityStep
+
+# traversalMethod_in
+# : 'in' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: InStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_inE
+# : 'inE' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: InEStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_inV
+# : 'inV' LPAREN RPAREN
+# ;
+
+ - name: InVStep
+
+# traversalMethod_index
+# : 'index' LPAREN RPAREN
+# ;
+
+ - name: IndexStep
+
+# traversalMethod_inject
+# : 'inject' LPAREN genericLiteralList RPAREN
+# ;
+
+ - name: InjectStep
+ type:
+ record:
+ - name: injections
+ type:
+ list: literals.GenericLiteral
+
+# traversalMethod_is
+# : 'is' LPAREN genericLiteral RPAREN #traversalMethod_is_Object
+# | 'is' LPAREN traversalPredicate RPAREN #traversalMethod_is_P
+# ;
+
+ - name: IsStep
+ type:
+ union:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: value
+ type: literals.GenericLiteral
+
+# traversalMethod_key
+# : 'key' LPAREN RPAREN
+# ;
+
+ - name: KeyStep
+
+# traversalMethod_label
+# : 'label' LPAREN RPAREN
+# ;
+
+ - name: LabelStep
+
+# traversalMethod_limit
+# : 'limit' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_limit_Scope_long
+# | 'limit' LPAREN integerLiteral RPAREN #traversalMethod_limit_long
+# ;
+
+ - name: LimitStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: limit
+ type: integer
+
+# traversalMethod_local
+# : 'local' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: LocalStep
+ type:
+ record:
+ - name: localTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_loops
+# : 'loops' LPAREN RPAREN #traversalMethod_loops_Empty
+# | 'loops' LPAREN stringLiteral RPAREN #traversalMethod_loops_String
+# ;
+
+ - name: LoopsStep
+ type:
+ record:
+ - name: loopName
+ type:
+ optional: string
+
+# traversalMethod_map
+# : 'map' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: MapStep
+ type:
+ record:
+ - name: mapTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_match
+# : 'match' LPAREN nestedTraversalList RPAREN
+# ;
+
+ - name: MatchStep
+ type:
+ record:
+ - name: matchTraversals
+ type:
+ list: traversal.NestedTraversal
+
+# traversalMethod_math
+# : 'math' LPAREN stringLiteral RPAREN
+# ;
+
+ - name: MathStep
+ type:
+ record:
+ - name: expression
+ type: string
+
+# traversalMethod_max
+# : 'max' LPAREN RPAREN #traversalMethod_max_Empty
+# | 'max' LPAREN traversalScope RPAREN #traversalMethod_max_Scope
+# ;
+
+ - name: MaxStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_mean
+# : 'mean' LPAREN RPAREN #traversalMethod_mean_Empty
+# | 'mean' LPAREN traversalScope RPAREN #traversalMethod_mean_Scope
+# ;
+
+ - name: MeanStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_min
+# : 'min' LPAREN RPAREN #traversalMethod_min_Empty
+# | 'min' LPAREN traversalScope RPAREN #traversalMethod_min_Scope
+# ;
+
+ - name: MinStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_not
+# : 'not' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: NotStep
+ type:
+ record:
+ - name: notTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_option
+# : 'option' LPAREN traversalPredicate COMMA nestedTraversal RPAREN #traversalMethod_option_Predicate_Traversal
+# | 'option' LPAREN genericLiteral COMMA nestedTraversal RPAREN #traversalMethod_option_Object_Traversal
+# | 'option' LPAREN nestedTraversal RPAREN #traversalMethod_option_Traversal
+# ;
+
+ # TODO: the Java API does not agree with the grammar here
+ - name: OptionStep
+ type:
+ union:
+ - name: predicateTraversal
+ type:
+ record:
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+ - name: objectTraversal
+ type:
+ record:
+ - name: object
+ type: literals.GenericLiteral
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_optional
+# : 'optional' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: OptionalStep
+ type:
+ record:
+ - name: optionalTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_or
+# : 'or' LPAREN nestedTraversalList RPAREN
+# ;
+
+ - name: OrStep
+ type:
+ record:
+ - name: orTraversals
+ type:
+ list: traversal.NestedTraversal
+
+# traversalMethod_order
+# : 'order' LPAREN RPAREN #traversalMethod_order_Empty
+# | 'order' LPAREN traversalScope RPAREN #traversalMethod_order_Scope
+# ;
+
+ - name: OrderStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_otherV
+# : 'otherV' LPAREN RPAREN
+# ;
+
+ - name: OtherVStep
+
+# traversalMethod_out
+# : 'out' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: OutStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_outE
+# : 'outE' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: OutEStep
+ type:
+ record:
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_outV
+# : 'outV' LPAREN RPAREN
+# ;
+
+ - name: OutVStep
+
+# traversalMethod_pageRank
+# : 'pageRank' LPAREN RPAREN #traversalMethod_pageRank_Empty
+# | 'pageRank' LPAREN floatLiteral RPAREN #traversalMethod_pageRank_double
+# ;
+
+ - name: PageRankStep
+ type:
+ record:
+ - name: alpha
+ type:
+ optional: float
+
+# traversalMethod_path
+# : 'path' LPAREN RPAREN
+# ;
+
+ - name: PathStep
+
+# traversalMethod_peerPressure
+# : 'peerPressure' LPAREN RPAREN
+# ;
+
+ - name: PeerPressureStep
+
+# traversalMethod_profile
+# : 'profile' LPAREN RPAREN #traversalMethod_profile_Empty
+# | 'profile' LPAREN stringLiteral RPAREN #traversalMethod_profile_String
+# ;
+
+ - name: ProfileStep
+ type:
+ record:
+ - name: sideEffectKey
+ type:
+ optional: string
+
+# traversalMethod_project
+# : 'project' LPAREN stringLiteral (COMMA stringLiteralList)? RPAREN
+# ;
+
+ - name: ProjectStep
+ type:
+ record:
+ - name: projectKey
+ type: string
+
+ - name: otherProjectKeys
+ type:
+ list: string
+
+# traversalMethod_properties
+# : 'properties' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: PropertiesStep
+ type:
+ record:
+ - name: propertyKeys
+ type:
+ list: string
+
+# traversalMethod_property
+# : 'property' LPAREN traversalCardinality COMMA genericLiteral COMMA genericLiteral (COMMA genericLiteralList)? RPAREN #traversalMethod_property_Cardinality_Object_Object_Object
+# | 'property' LPAREN genericLiteral COMMA genericLiteral (COMMA genericLiteralList)? RPAREN #traversalMethod_property_Object_Object_Object
+# ;
+
+ - name: PropertyStep
+ type:
+ record:
+ - name: cardinality
+ type:
+ optional: traversal.TraversalCardinality
+
+ - name: key
+ type: literals.GenericLiteral
+
+ - name: value
+ type: literals.GenericLiteral
+
+ - name: keyValues
+ type:
+ list: literals.GenericLiteral
+
+# traversalMethod_propertyMap
+# : 'propertyMap' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: PropertyMapStep
+ type:
+ record:
+ - name: propertyKeys
+ type:
+ list: string
+
+# traversalMethod_range
+# : 'range' LPAREN traversalScope COMMA integerLiteral COMMA integerLiteral RPAREN #traversalMethod_range_Scope_long_long
+# | 'range' LPAREN integerLiteral COMMA integerLiteral RPAREN #traversalMethod_range_long_long
+# ;
+
+ - name: RangeStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: low
+ type: integer
+
+ - name: high
+ type: integer
+
+# traversalMethod_read
+# : 'read' LPAREN RPAREN
+# ;
+
+ - name: ReadStep
+
+# traversalMethod_repeat
+# : 'repeat' LPAREN stringLiteral COMMA nestedTraversal RPAREN #traversalMethod_repeat_String_Traversal
+# | 'repeat' LPAREN nestedTraversal RPAREN #traversalMethod_repeat_Traversal
+# ;
+
+ - name: RepeatStep
+ type:
+ record:
+ - name: loopName
+ type:
+ optional: string
+
+ - name: repeatTraversals
+ type: traversal.NestedTraversal
+
+# traversalMethod_sack
+# : 'sack' LPAREN traversalBiFunction RPAREN #traversalMethod_sack_BiFunction
+# | 'sack' LPAREN RPAREN #traversalMethod_sack_Empty
+# ;
+
+ - name: SackStep
+ type:
+ record:
+ - name: sackOperator
+ type:
+ optional: traversal.TraversalBiFunction
+
+# traversalMethod_sample
+# : 'sample' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_sample_Scope_int
+# | 'sample' LPAREN integerLiteral RPAREN #traversalMethod_sample_int
+# ;
+
+ - name: SampleStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: amountToSample
+ type: integer
+
+# traversalMethod_select
+# : 'select' LPAREN traversalColumn RPAREN #traversalMethod_select_Column
+# | 'select' LPAREN traversalPop COMMA stringLiteral RPAREN #traversalMethod_select_Pop_String
+# | 'select' LPAREN traversalPop COMMA stringLiteral COMMA stringLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_select_Pop_String_String_String
+# | 'select' LPAREN traversalPop COMMA nestedTraversal RPAREN #traversalMethod_select_Pop_Traversal
+# | 'select' LPAREN stringLiteral RPAREN #traversalMethod_select_String
+# | 'select' LPAREN stringLiteral COMMA stringLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_select_String_String_String
+# | 'select' LPAREN nestedTraversal RPAREN #traversalMethod_select_Traversal
+# ;
+
+ - name: SelectStep
+ type:
+ union:
+ - name: column
+ type: traversal.TraversalColumn
+
+ - name: key
+ type:
+ record:
+ - name: pop
+ type:
+ optional: traversal.TraversalPop
+
+ - name: selectKey
+ type: string
+
+ - name: keys
+ type:
+ record:
+ - name: pop
+ type:
+ optional: traversal.TraversalPop
+
+ - name: selectKey1
+ type: string
+
+ - name: selectKey2
+ type: string
+
+ - name: otherSelectKeys
+ type:
+ list: string
+
+ - name: traversal
+ type:
+ record:
+ - name: pop
+ type:
+ optional: traversal.TraversalPop
+
+ - name: traversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_shortestPath
+# : 'shortestPath' LPAREN RPAREN
+# ;
+
+ - name: ShortestPathStep
+
+# traversalMethod_sideEffect
+# : 'sideEffect' LPAREN nestedTraversal RPAREN
+# ;
+
+ - name: SideEffectStep
+ type:
+ record:
+ - name: sideEffectTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_simplePath
+# : 'simplePath' LPAREN RPAREN
+# ;
+
+ - name: SimplePathStep
+
+# traversalMethod_skip
+# : 'skip' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_skip_Scope_long
+# | 'skip' LPAREN integerLiteral RPAREN #traversalMethod_skip_long
+# ;
+
+ - name: SkipStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: skip
+ type: integer
+
+# traversalMethod_store
+# : 'store' LPAREN stringLiteral RPAREN
+# ;
+
+ - name: StoreStep
+ type:
+ record:
+ - name: sideEffectKey
+ type: string
+
+# traversalMethod_subgraph
+# : 'subgraph' LPAREN stringLiteral RPAREN
+# ;
+
+ - name: SubgraphStep
+ type:
+ record:
+ - name: sideEffectKey
+ type: string
+
+# traversalMethod_sum
+# : 'sum' LPAREN RPAREN #traversalMethod_sum_Empty
+# | 'sum' LPAREN traversalScope RPAREN #traversalMethod_sum_Scope
+# ;
+
+ - name: SumStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+# traversalMethod_tail
+# : 'tail' LPAREN RPAREN #traversalMethod_tail_Empty
+# | 'tail' LPAREN traversalScope RPAREN #traversalMethod_tail_Scope
+# | 'tail' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_tail_Scope_long
+# | 'tail' LPAREN integerLiteral RPAREN #traversalMethod_tail_long
+# ;
+
+ - name: TailStep
+ type:
+ record:
+ - name: scope
+ type:
+ optional: traversal.TraversalScope
+
+ - name: limit
+ type:
+ optional: integer
+
+# traversalMethod_timeLimit
+# : 'timeLimit' LPAREN integerLiteral RPAREN
+# ;
+
+ - name: TimeLimitStep
+ type:
+ record:
+ - name: timeLimit
+ type: integer
+
+# traversalMethod_times
+# : 'times' LPAREN integerLiteral RPAREN
+# ;
+
+ - name: TimesStep
+ type:
+ record:
+ - name: maxLoops
+ type: integer
+
+# traversalMethod_to
+# : 'to' LPAREN traversalDirection (COMMA stringLiteralList)? RPAREN #traversalMethod_to_Direction_String
+# | 'to' LPAREN stringLiteral RPAREN #traversalMethod_to_String
+# | 'to' LPAREN nestedTraversal RPAREN #traversalMethod_to_Traversal
+# ;
+
+ - name: ToStep
+ type:
+ union:
+ - name: withDirection
+ type:
+ record:
+ - name: direction
+ type: traversal.TraversalDirection
+
+ - name: edgeLabels
+ type:
+ list: string
+
+ - name: toStepLabel
+ type: string
+
+ - name: toVertex
+ type: traversal.NestedTraversal
+
+# traversalMethod_toE
+# : 'toE' LPAREN traversalDirection (COMMA stringLiteralList)? RPAREN
+# ;
+
+ - name: ToEStep
+ type:
+ record:
+ - name: direction
+ type: traversal.TraversalDirection
+
+ - name: edgeLabels
+ type:
+ list: string
+
+# traversalMethod_toV
+# : 'toV' LPAREN traversalDirection RPAREN
+# ;
+
+ - name: ToVStep
+ type:
+ record:
+ - name: direction
+ type: traversal.TraversalDirection
+
+# traversalMethod_tree
+# : 'tree' LPAREN RPAREN #traversalMethod_tree_Empty
+# | 'tree' LPAREN stringLiteral RPAREN #traversalMethod_tree_String
+# ;
+
+ - name: TreeStep
+ type:
+ record:
+ - name: sideEffectKey
+ type:
+ optional: string
+
+# traversalMethod_unfold
+# : 'unfold' LPAREN RPAREN
+# ;
+
+ - name: UnfoldStep
+
+# traversalMethod_union
+# : 'union' LPAREN nestedTraversalList RPAREN
+# ;
+
+ - name: UnionStep
+ type:
+ record:
+ - name: unionTraversals
+ type:
+ list: traversal.NestedTraversal
+
+# traversalMethod_until
+# : 'until' LPAREN traversalPredicate RPAREN #traversalMethod_until_Predicate
+# | 'until' LPAREN nestedTraversal RPAREN #traversalMethod_until_Traversal
+# ;
+
+ - name: UntilStep
+ type:
+ union:
+ - name: untilPredicate
+ type: predicates.TraversalPredicate
+
+ - name: untilTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_value
+# : 'value' LPAREN RPAREN
+# ;
+
+ - name: ValueStep
+
+# traversalMethod_valueMap
+# : 'valueMap' LPAREN stringLiteralList RPAREN #traversalMethod_valueMap_String
+# | 'valueMap' LPAREN booleanLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_valueMap_boolean_String
+# ;
+
+ - name: ValueMapStep
+ type:
+ record:
+ - name: includeTokens
+ type:
+ optional: boolean
+
+ - name: propertyKeys
+ type:
+ list: string
+
+# traversalMethod_values
+# : 'values' LPAREN stringLiteralList RPAREN
+# ;
+
+ - name: ValuesStep
+ type:
+ record:
+ - name: propertyKeys
+ type:
+ list: string
+
+# traversalMethod_where
+# : 'where' LPAREN traversalPredicate RPAREN #traversalMethod_where_P
+# | 'where' LPAREN stringLiteral COMMA traversalPredicate RPAREN #traversalMethod_where_String_P
+# | 'where' LPAREN nestedTraversal RPAREN #traversalMethod_where_Traversal
+# ;
+
+ - name: WhereStep
+ type:
+ union:
+ - name: withPredicate
+ type:
+ record:
+ - name: startKey
+ type:
+ optional: string
+
+ - name: predicate
+ type: predicates.TraversalPredicate
+
+ - name: whereTraversal
+ type: traversal.NestedTraversal
+
+# traversalMethod_with
+# : 'with' LPAREN stringLiteral RPAREN #traversalMethod_with_String
+# | 'with' LPAREN stringLiteral COMMA genericLiteral RPAREN #traversalMethod_with_String_Object
+# ;
+
+ - name: WithStep
+ type:
+ record:
+ - name: key
+ type: string
+
+ - name: value
+ type:
+ optional: literals.GenericLiteral
+
+# traversalMethod_write
+# : 'write' LPAREN RPAREN
+# ;
+
+ - name: WriteStep
diff --git a/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/traversal.yaml b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/traversal.yaml
new file mode 100644
index 0000000..94aaa14
--- /dev/null
+++ b/gremlin-language/src/main/yaml/org/apache/tinkerpop/gremlin/language/model/traversal.yaml
@@ -0,0 +1,575 @@
+# /*********************************************
+# PARSER RULES
+# **********************************************/
+
+# /*********************************************
+# ARGUMENT AND TERMINAL RULES
+# **********************************************/
+
+status: experimental
+
+includes:
+ - literals
+ - methods
+ - steps
+
+definitions:
+
+# traversalSource
+# : TRAVERSAL_ROOT (DOT traversalSourceSelfMethod)?
+# | traversalSource DOT traversalSourceSelfMethod
+# ;
+
+ - name: TraversalSource
+ type:
+ list: TraversalSourceSelfMethod
+
+# rootTraversal
+# : traversalSource DOT traversalSourceSpawnMethod (DOT (chainedTraversal | chainedParentOfGraphTraversal))?
+# ;
+
+ - name: RootTraversal
+ type:
+ record:
+ - name: source
+ type: TraversalSource
+
+ - name: spawnMethod
+ type: TraversalSourceSpawnMethod
+
+ - name: rest
+ type:
+ optional:
+ union:
+ - name: chained
+ type: ChainedTraversal
+
+ - name: parent
+ type: ChainedParentOfGraphTraversal
+
+# traversalSourceSelfMethod
+# : traversalSourceSelfMethod_withBulk
+# | traversalSourceSelfMethod_withPath
+# | traversalSourceSelfMethod_withSack
+# | traversalSourceSelfMethod_withSideEffect
+# | traversalSourceSelfMethod_withStrategies
+# | traversalSourceSelfMethod_with
+# ;
+
+ - name: TraversalSourceSelfMethod
+ type:
+ union:
+ - name: withBulk
+ type: WithBulk
+
+ - name: withPath
+ type: WithPath
+
+ - name: withSack
+ type: WithSack
+
+ - name: withSideEffect
+ type: WithSideEffect
+
+ - name: withStrategies
+ type: WithStrategies
+
+ - name: with
+ type: With
+
+# traversalSourceSelfMethod_withBulk
+# : 'withBulk' LPAREN booleanLiteral RPAREN
+# ;
+
+ - name: WithBulk
+ type:
+ record:
+ - name: useBulk
+ type: boolean
+
+# traversalSourceSelfMethod_withPath
+# : 'withPath' LPAREN RPAREN
+# ;
+
+ - name: WithPath
+
+# traversalSourceSelfMethod_withSack
+# : 'withSack' LPAREN genericLiteral (COMMA traversalOperator)? RPAREN
+# ;
+
+ - name: WithSack
+ type:
+ record:
+ - name: initialValue
+ type: literals.StringLiteral
+
+ - name: operator
+ type:
+ optional: TraversalOperator
+
+# traversalSourceSelfMethod_withSideEffect
+# : 'withSideEffect' LPAREN stringLiteral COMMA genericLiteral RPAREN
+# ;
+
+ - name: WithSideEffect
+ type:
+ record:
+ - name: key
+ type: literals.StringLiteral
+
+ - name: initialValue
+ type: literals.GenericLiteral
+
+# traversalSourceSelfMethod_withStrategies
+# : 'withStrategies' LPAREN traversalStrategy (COMMA traversalStrategyList)? RPAREN
+# ;
+
+ - name: WithStrategies
+ type:
+ record:
+ - name: traversalStrategies
+ type:
+ list: TraversalStrategy
+
+# traversalSourceSelfMethod_with
+# : 'with' LPAREN stringLiteral (COMMA genericLiteral)? RPAREN
+# ;
+
+ - name: With
+ type:
+ record:
+ - name: key
+ type: string
+
+ - name: value
+ type:
+ optional: literals.GenericLiteral
+
+# traversalSourceSpawnMethod
+# : traversalSourceSpawnMethod_addE
+# | traversalSourceSpawnMethod_addV
+# | traversalSourceSpawnMethod_E
+# | traversalSourceSpawnMethod_V
+# | traversalSourceSpawnMethod_inject
+# | traversalSourceSpawnMethod_io
+# ;
+
+ - name: TraversalSourceSpawnMethod
+ type:
+ union:
+ - name: addE
+ type: steps.AddEStep
+
+ - name: addV
+ type: steps.AddVStep
+
+ - name: e
+ # TODO: steps.EStep
+
+ - name: v
+ type: steps.VStep
+
+ - name: inject
+ type: steps.InjectStep
+
+ - name: io
+ # TODO: steps.IoStep
+
+# traversalSourceSpawnMethod_addE
+# : 'addE' LPAREN (stringLiteral | nestedTraversal) RPAREN
+# ;
+
+# traversalSourceSpawnMethod_addV
+# // null means use the default vertex label
+# : 'addV' LPAREN (stringLiteral | nullLiteral | nestedTraversal)? RPAREN
+# ;
+#
+# traversalSourceSpawnMethod_E
+# : 'E' LPAREN genericLiteralList RPAREN
+# ;
+#
+# traversalSourceSpawnMethod_V
+# : 'V' LPAREN genericLiteralList RPAREN
+# ;
+#
+# traversalSourceSpawnMethod_inject
+# : 'inject' LPAREN genericLiteralList RPAREN
+# ;
+#
+# traversalSourceSpawnMethod_io
+# : 'io' LPAREN stringLiteral RPAREN
+# ;
+#
+# chainedTraversal
+# : traversalMethod
+# | chainedTraversal DOT (traversalMethod | chainedParentOfGraphTraversal)
+# ;
+
+ - name: ChainedTraversal
+ type:
+ record:
+ - name: first
+ type: steps.TraversalMethod
+
+ - name: rest
+ type:
+ list:
+ union:
+ - name: method
+ type: steps.TraversalMethod
+
+ - name: chainedParent
+ type: ChainedParentOfGraphTraversal
+
+# chainedParentOfGraphTraversal
+# : traversalSelfMethod (DOT chainedParentOfGraphTraversal)?
+# ;
+
+ - name: ChainedParentOfGraphTraversal
+ type:
+ record:
+ - name: first
+ type: methods.TraversalSelfMethod
+
+ - name: rest
+ type:
+ optional: ChainedParentOfGraphTraversal
+
+# nestedTraversal
+# : rootTraversal
+# | (ANON_TRAVERSAL_ROOT DOT)? chainedTraversal
+# ;
+
+ - name: NestedTraversal
+ type:
+ union:
+ - name: root
+ type: RootTraversal
+
+ - name: chained
+ type:
+ record:
+ - name: anonymous
+ type: boolean
+
+ - name: traversal
+ type: ChainedTraversal
+
+# terminatedTraversal
+# : rootTraversal DOT traversalTerminalMethod
+# ;
+
+ # traversalStrategy
+ # // : 'ConnectiveStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'ElementIdStrategy' - not supported as the configuration takes a lambda
+ # // | 'EventStrategy' - not supported as there is no way to send events back to the client
+ # // | 'HaltedTraverserStrategy' - not supported as it is not typically relevant to OLTP
+ # // | 'OptionsStrategy' - not supported as it's internal to with()
+ # : 'new' 'PartitionStrategy' LPAREN traversalStrategyArgs_PartitionStrategy? (COMMA traversalStrategyArgs_PartitionStrategy)* RPAREN
+ # // | 'RequirementStrategy' - not supported as it's internally relevant only
+ # // | 'SackStrategy' - not supported directly as it's internal to withSack()
+ # // | 'SideEffectStrategy' - not supported directly as it's internal to withSideEffect()
+ # | 'new' 'SubgraphStrategy' LPAREN traversalStrategyArgs_SubgraphStrategy? (COMMA traversalStrategyArgs_SubgraphStrategy)* RPAREN
+ # // | 'MatchAlgorithmStrategy' - not supported directly as it's internal to match()
+ # // | 'ProfileStrategy' - not supported directly as it's internal to profile()
+ # // | 'ReferenceElementStrategy' - not supported directly as users really can't/shouldn't change this in our context of a remote Gremlin provider
+ # // | 'AdjacentToIncidentStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'CountStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'EarlyLimitStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'FilterRankingStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'IdentityRemovalStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'IncidentToAdjacentStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'InlineFilterStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'LazyBarrierStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'MatchPredicateStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'OrderLimitStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'PathProcessorStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'PathRetractionStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'RepeatUnrollStrategy' - not supported as it is a default strategy and we don't allow removal at this time
+ # // | 'ComputerVerificationStrategy' - not supported since it's GraphComputer related
+ # | 'new' 'EdgeLabelVerificationStrategy' LPAREN traversalStrategyArgs_EdgeLabelVerificationStrategy? (COMMA traversalStrategyArgs_EdgeLabelVerificationStrategy)* RPAREN
+ # // | 'LambdaRestrictionStrategy' - not supported as we don't support lambdas in any situation
+ # | 'ReadOnlyStrategy'
+ # | 'new' 'ReservedKeysVerificationStrategy' LPAREN traversalStrategyArgs_ReservedKeysVerificationStrategy? (COMMA traversalStrategyArgs_ReservedKeysVerificationStrategy)* RPAREN
+ # // | 'StandardVerificationStrategy' - not supported since this is an interal strategy
+ # ;
+
+ - name: TraversalStrategy
+ type:
+ union:
+ - name: partition
+ type:
+ list: PartitionStrategy
+
+ - name: subgraph
+ type:
+ list: SubgraphStrategy
+
+ - name: edgeLabelVerification
+ type:
+ list: EdgeLabelVerificationStrategy
+
+ - name: readOnly
+
+ - name: reservedKeysVerification
+ type:
+ list: ReservedKeysVerificationStrategy
+
+ # traversalStrategyArgs_PartitionStrategy
+ # : 'includeMetaProperties' COLON booleanLiteral
+ # | 'writePartition' COLON stringLiteral
+ # | 'partitionKey' COLON stringLiteral
+ # | 'readPartitions' COLON stringLiteralList
+ # ;
+
+ - name: PartitionStrategy
+ type:
+ union:
+ - name: includeMetaProperties
+ type: boolean
+
+ - name: writePartition
+ type: string
+
+ - name: partitionKey
+ type: string
+
+ - name: readPartitions
+ type:
+ list: string
+
+ # traversalStrategyArgs_SubgraphStrategy
+ # : 'vertices' COLON nestedTraversal
+ # | 'edges' COLON nestedTraversal
+ # | 'vertexProperties' COLON nestedTraversal
+ # | 'checkAdjacentVertices' COLON booleanLiteral
+ # ;
+
+ - name: SubgraphStrategy
+ type:
+ union:
+ - name: vertices
+ type: NestedTraversal
+
+ - name: edges
+ type: NestedTraversal
+
+ - name: vertexProperties
+ type: NestedTraversal
+
+ - name: checkAdjacentVertixes
+ type: boolean
+
+ # traversalStrategyArgs_EdgeLabelVerificationStrategy
+ # : 'throwException' COLON booleanLiteral
+ # | 'logWarning' COLON booleanLiteral
+ # ;
+
+ - name: EdgeLabelVerificationStrategy
+ type:
+ union:
+ - name: throwException
+ type: boolean
+
+ - name: logWarning
+ type: boolean
+
+ # traversalStrategyArgs_ReservedKeysVerificationStrategy
+ # : 'keys' COLON stringLiteralList
+ # | 'throwException' COLON booleanLiteral
+ # | 'logWarning' COLON booleanLiteral
+ # ;
+
+ - name: ReservedKeysVerificationStrategy
+ type:
+ union:
+ - name: keys
+ type:
+ list: string
+
+ - name: throwException
+ type: boolean
+
+ - name: logWarning
+ type: boolean
+
+ # traversalScope
+ # : 'local' | 'Scope.local'
+ # | 'global' | 'Scope.global'
+ # ;
+
+ - name: TraversalScope
+ type:
+ enum:
+ - local
+ - global
+
+ # traversalToken
+ # : 'id' | 'T.id'
+ # | 'label' | 'T.label'
+ # | 'key' | 'T.key'
+ # | 'value' | 'T.value'
+ # ;
+
+ - name: TraversalToken
+ type:
+ enum:
+ - id
+ - label
+ - key
+ - value
+
+ # traversalOrder
+ # : 'incr' | 'Order.incr'
+ # | 'decr' | 'Order.decr'
+ # | 'asc' | 'Order.asc'
+ # | 'desc' | 'Order.desc'
+ # | 'shuffle' | 'Order.shuffle'
+ # ;
+
+ - name: TraversalOrder
+ type:
+ enum:
+ - incr
+ - decr
+ - asc
+ - desc
+ - shuffle
+
+ # traversalDirection
+ # : 'IN' | 'Direction.IN'
+ # | 'OUT' | 'Direction.OUT'
+ # | 'BOTH' | 'Direction.BOTH'
+ # ;
+
+ - name: TraversalDirection
+ type:
+ enum:
+ - in
+ - out
+ - both
+
+ # traversalCardinality
+ # : 'single' | 'Cardinality.single'
+ # | 'set' | 'Cardinality.set'
+ # | 'list' | 'Cardinality.list'
+ # ;
+
+ - name: TraversalCardinality
+ type:
+ enum:
+ - single
+ - set
+ - list
+
+ # traversalColumn
+ # : 'keys' | 'Column.keys'
+ # | 'values' | 'Column.values'
+ # ;
+
+ - name: TraversalColumn
+ type:
+ enum:
+ - keys
+ - values
+
+ # traversalPop
+ # : 'first' | 'Pop.first'
+ # | 'last' | 'Pop.last'
+ # | 'all' | 'Pop.all'
+ # | 'mixed' | 'Pop.mixed'
+ # ;
+
+ - name: TraversalPop
+ type:
+ enum:
+ - first
+ - last
+ - all
+ - mixed
+
+ # traversalOperator
+ # : 'addAll' | 'Operator.addAll'
+ # | 'and' | 'Operator.and'
+ # | 'assign' | 'Operator.assign'
+ # | 'div' | 'Operator.div'
+ # | 'max' | 'Operator.max'
+ # | 'min' | 'Operator.min'
+ # | 'minus' | 'Operator.minus'
+ # | 'mult' | 'Operator.mult'
+ # | 'or' | 'Operator.or'
+ # | 'sum' | 'Operator.sum'
+ # | 'sumLong' | 'Operator.sumLong'
+ # ;
+
+ - name: TraversalOperator
+ type:
+ enum:
+ - addAll
+ - and
+ - assign
+ - div
+ - max
+ - min
+ - minus
+ - mult
+ - or
+ - sum
+ - sumLong
+
+ # traversalOptionParent
+ # : 'any' | 'Pick.any'
+ # | 'none' | 'Pick.none'
+ # ;
+
+ - name: TraversalOptionParent
+ type:
+ enum:
+ - any
+ - none
+
+ # // Additional special rules that are derived from above
+ # // These are used to restrict broad method signatures that accept lambdas
+ # // to a smaller set.
+ # traversalComparator
+ # : traversalOrder
+ # ;
+
+ - name: TraversalComparator
+ type: TraversalOrder
+
+ # traversalFunction
+ # : traversalToken
+ # | traversalColumn
+ # ;
+
+ - name: TraversalFunction
+ type:
+ union:
+ - name: token
+ type: TraversalToken
+
+ - name: column
+ type: TraversalColumn
+
+ # traversalBiFunction
+ # : traversalOperator
+ # ;
+
+ - name: TraversalBiFunction
+ type: TraversalOperator
+
+# traversalStrategyList
+# : traversalStrategyExpr?
+# ;
+# traversalStrategyExpr
+# : traversalStrategy (COMMA traversalStrategy)*
+# ;
+#
+# nestedTraversalList
+# : nestedTraversalExpr?
+# ;
+#
+# nestedTraversalExpr
+# : nestedTraversal (COMMA nestedTraversal)*
+# ;