You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by sp...@apache.org on 2023/06/13 18:38:24 UTC
[tinkerpop] branch TINKERPOP-2959 created (now f08fac16c0)
This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a change to branch TINKERPOP-2959
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
at f08fac16c0 TINKERPOP-2959 Allowed parsing of parameters with the grammar
This branch includes the following new commits:
new f08fac16c0 TINKERPOP-2959 Allowed parsing of parameters with the grammar
The 1 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] 01/01: TINKERPOP-2959 Allowed parsing of parameters with the grammar
Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a commit to branch TINKERPOP-2959
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit f08fac16c06f74c03cad689c80af0482e84eee89
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Thu Jun 8 14:42:17 2023 -0400
TINKERPOP-2959 Allowed parsing of parameters with the grammar
This adds functionality similar to GremlinGroovyScriptEngine where bindings can be applied to a script as in g.V(x) where x is a variable that can be bound to a value external to the script. This functionality doesn't offer any particular performance enhancement for the grammar the way that it does for groovy but it does better allow one engine to be swapped for the other which is crucial for a migration away from the groovy engine. This change also opens up better opportunities for t [...]
---
CHANGELOG.asciidoc | 4 +-
.../gremlin/jsr223/GremlinLangScriptEngine.java | 6 +-
.../gremlin/language/grammar/ArgumentVisitor.java | 420 ++++++++++++++
.../grammar/DefaultGremlinBaseVisitor.java | 239 +++++---
.../language/grammar/GenericLiteralVisitor.java | 161 +++---
.../language/grammar/GremlinAntlrToJava.java | 52 +-
.../language/grammar/GremlinParserException.java | 4 +-
.../language/grammar/GremlinQueryParser.java | 12 +
.../grammar/GremlinStringConstantsVisitor.java | 224 --------
.../grammar/ParseTreeContextCastHelper.java | 14 +-
.../language/grammar/StructureElementVisitor.java | 15 +-
.../language/grammar/TraversalFunctionVisitor.java | 65 ---
.../language/grammar/TraversalMethodVisitor.java | 391 +++++++------
.../grammar/TraversalPredicateVisitor.java | 140 +++--
.../grammar/TraversalSourceSelfMethodVisitor.java | 65 +--
.../grammar/TraversalSourceSpawnMethodVisitor.java | 46 +-
.../language/grammar/TraversalStrategyVisitor.java | 45 +-
.../gremlin/language/grammar/VariableResolver.java | 72 +++
.../grammar/VariableResolverException.java} | 18 +-
.../language/grammar/WithOptionsVisitor.java | 228 ++++++++
.../gremlin/util/function/ThrowingBiFunction.java} | 19 +-
.../jsr223/GremlinLangScriptEngineTest.java | 17 +
.../language/grammar/ArgumentVisitorTest.java | 260 +++++++++
.../grammar/ComplexTraversalMethodVisitorTest.java | 6 +-
.../grammar/GeneralLiteralVisitorTest.java | 53 +-
.../language/grammar/GremlinQueryParserTest.java | 62 +++
.../language/grammar/TraversalEnumParserTest.java | 4 +-
.../grammar/TraversalMethodVisitorTest.java | 386 +++++++------
.../grammar/TraversalPredicateVisitorTest.java | 4 +-
.../language/grammar/TraversalRootVisitorTest.java | 2 +-
.../TraversalSourceSelfMethodVisitorTest.java | 2 +-
.../grammar/TraversalSourceSpawnVisitorTest.java | 22 +-
.../grammar/TraversalStrategyVisitorTest.java | 4 +-
gremlin-language/src/main/antlr4/Gremlin.g4 | 605 +++++++++++++--------
.../gremlin/server/GremlinDriverIntegrateTest.java | 19 +
35 files changed, 2359 insertions(+), 1327 deletions(-)
diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index 3298cd92a3..cfa5ad5da6 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -26,7 +26,7 @@ image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
This release also includes changes from <<release-3-6-XXX, 3.6.XXX>>.
* Removed `connectOnStartup` configuration option from gremlin-javascript.
-* Changed `Gremlin.version()` to read from the more specificly named `tinkerpop-version` attribute.
+* Changed `Gremlin.version()` to read from the more specifically named `tinkerpop-version` attribute.
* Added warning on vertex property cardinality mismatch when reading GraphML.
* Added a `union()` start step.
* Bumped to `ws` 8.x for `gremlin-javascript`.
@@ -46,6 +46,8 @@ This release also includes changes from <<release-3-6-XXX, 3.6.XXX>>.
* Added functional properties to the graph structure components for .NET, GO and Python.
* Modified the 1GremlinScriptChecker1 to extract the `materializeProperties` request option.
* `Neo4jVertexProperty` no longer throw Exception for `properties()`, but return empty `Iterable`.
+* Modified the grammar to allow for parameters to be specified in Gremlin.
+* Modified `GremlinLangScriptEngine` to take bindings.
* Removed deprecated `getInstance()` method for grammar `Visitor` implementations.
* Bumped Groovy to 4.0.9.
* Bumped GMavenPlus to 2.1.0.
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/jsr223/GremlinLangScriptEngine.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/jsr223/GremlinLangScriptEngine.java
index 6c771bd07f..842d4daa32 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/jsr223/GremlinLangScriptEngine.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/jsr223/GremlinLangScriptEngine.java
@@ -20,6 +20,7 @@ package org.apache.tinkerpop.gremlin.jsr223;
import org.apache.tinkerpop.gremlin.language.grammar.GremlinAntlrToJava;
import org.apache.tinkerpop.gremlin.language.grammar.GremlinQueryParser;
+import org.apache.tinkerpop.gremlin.language.grammar.VariableResolver;
import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalSource;
@@ -32,6 +33,7 @@ import javax.script.ScriptException;
import javax.script.SimpleBindings;
import java.io.IOException;
import java.io.Reader;
+import java.util.Map;
/**
* A {@link GremlinScriptEngine} implementation that evaluates Gremlin scripts using {@code gremlin-language}. As it
@@ -104,7 +106,9 @@ public class GremlinLangScriptEngine extends AbstractScriptEngine implements Gre
if (!(o instanceof GraphTraversalSource))
throw new IllegalArgumentException("g is of type " + o.getClass().getSimpleName() + " and is not an instance of TraversalSource");
- final GremlinAntlrToJava antlr = new GremlinAntlrToJava((GraphTraversalSource) o);
+ final Map<String, Object> m = context.getBindings(ScriptContext.ENGINE_SCOPE);
+ final GremlinAntlrToJava antlr = new GremlinAntlrToJava((GraphTraversalSource) o,
+ new VariableResolver.DefaultVariableResolver(m));
try {
return GremlinQueryParser.parse(script, antlr);
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitor.java
new file mode 100644
index 0000000000..32f11fa74d
--- /dev/null
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitor.java
@@ -0,0 +1,420 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.language.grammar;
+
+import org.apache.tinkerpop.gremlin.process.traversal.Merge;
+import org.apache.tinkerpop.gremlin.process.traversal.Operator;
+import org.apache.tinkerpop.gremlin.process.traversal.Order;
+import org.apache.tinkerpop.gremlin.process.traversal.Pop;
+import org.apache.tinkerpop.gremlin.process.traversal.SackFunctions;
+import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+import org.apache.tinkerpop.gremlin.structure.Column;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.function.Function;
+
+public class ArgumentVisitor extends DefaultGremlinBaseVisitor<Object> {
+
+ private final VariableResolver resolver;
+
+ private final GremlinAntlrToJava antlr;
+
+ public ArgumentVisitor(final VariableResolver resolver, final GremlinAntlrToJava antlr) {
+ this.resolver = resolver;
+ this.antlr = antlr;
+ }
+
+ /**
+ * Wrapper to visit function for boolean.
+ */
+ public boolean parseBoolean(final GremlinParser.BooleanArgumentContext ctx) {
+ return (boolean) visitBooleanArgument(ctx);
+ }
+
+ /**
+ * Wrapper to visit function for integer types.
+ */
+ public Number parseNumber(final GremlinParser.IntegerArgumentContext ctx) {
+ return (Number) visitIntegerArgument(ctx);
+ }
+
+ /**
+ * Wrapper to visit function for float types.
+ */
+ public Number parseNumber(final GremlinParser.FloatArgumentContext ctx) {
+ return (Number) visitFloatArgument(ctx);
+ }
+
+ /**
+ * Wrapper to visit function for string types.
+ */
+ public String parseString(final GremlinParser.StringArgumentContext ctx) {
+ return (String) visitStringArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for object types.
+ */
+ public Object parseObject(final GremlinParser.GenericLiteralArgumentContext ctx) {
+ return visitGenericLiteralArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@link Direction} types.
+ */
+ public Direction parseDirection(final GremlinParser.TraversalDirectionArgumentContext ctx) {
+ return (Direction) visitTraversalDirectionArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@link Vertex} types.
+ */
+ public Vertex parseVertex(final GremlinParser.StructureVertexArgumentContext ctx) {
+ return (Vertex) visitStructureVertexArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@link Order} types.
+ */
+ public Order parseOrder(final GremlinParser.TraversalOrderArgumentContext ctx) {
+ return (Order) visitTraversalOrderArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@link Scope} types.
+ */
+ public Scope parseScope(final GremlinParser.TraversalScopeArgumentContext ctx) {
+ return (Scope) visitTraversalScopeArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@link T} types.
+ */
+ public T parseT(final GremlinParser.TraversalTokenArgumentContext ctx) {
+ return (T) visitTraversalTokenArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@link VertexProperty.Cardinality} types.
+ */
+ public VertexProperty.Cardinality parseCardinality(final GremlinParser.TraversalCardinalityArgumentContext ctx) {
+ return (VertexProperty.Cardinality) visitTraversalCardinalityArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@link Merge} types.
+ */
+ public Merge parseMerge(final GremlinParser.TraversalMergeArgumentContext ctx) {
+ return (Merge) visitTraversalMergeArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@link Pop} types.
+ */
+ public Pop parsePop(final GremlinParser.TraversalPopArgumentContext ctx) {
+ return (Pop) visitTraversalPopArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@link Pop} types.
+ */
+ public Column parseColumn(final GremlinParser.TraversalColumnArgumentContext ctx) {
+ return (Column) visitTraversalColumnArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@code Function} types like {@link T} and {@link Column}.
+ */
+ public Function parseFunction(final GremlinParser.TraversalFunctionArgumentContext ctx) {
+ return (Function) visitTraversalFunctionArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@code Comparator} types like {@link Order}.
+ */
+ public Comparator parseComparator(final GremlinParser.TraversalComparatorArgumentContext ctx) {
+ return (Comparator) visitTraversalComparatorArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@code Map} types.
+ */
+ public Map parseMap(final GremlinParser.GenericLiteralMapArgumentContext ctx) {
+ return (Map) visitGenericLiteralMapArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for {@code Map} types.
+ */
+ public Map parseMap(final GremlinParser.GenericLiteralMapNullableArgumentContext ctx) {
+ return (Map) visitGenericLiteralMapNullableArgument(ctx);
+ }
+
+ /**
+ * Wrapper for visit function for list types.
+ */
+ public Object[] parseObjectVarargs(final GremlinParser.GenericLiteralListArgumentContext ctx) {
+ if (ctx.genericLiteralList() != null) {
+ return antlr.genericVisitor.parseObjectList(ctx.genericLiteralList());
+ } else {
+ final Object l = visitVariable(ctx.variable());
+ if (null == l) {
+ return null;
+ } else if (l.getClass().isArray()) {
+ int length = Array.getLength(l);
+ Object[] result = new Object[length];
+ for (int i = 0; i < length; i++) {
+ result[i] = Array.get(l, i);
+ }
+ return result;
+ } else if (l instanceof Collection) {
+ Collection<?> collection = (Collection<?>) l;
+ return collection.toArray();
+ } else {
+ return new Object[] { l };
+ }
+ }
+ }
+
+ /**
+ * Wrapper to visit function for string types.
+ */
+ public String parseString(final GremlinParser.StringNullableArgumentContext ctx) {
+ return (String) visitStringNullableArgument(ctx);
+ }
+
+ @Override
+ public Object visitBooleanArgument(final GremlinParser.BooleanArgumentContext ctx) {
+ if (ctx.booleanLiteral() != null) {
+ return antlr.genericVisitor.parseBoolean(ctx.booleanLiteral());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitIntegerArgument(final GremlinParser.IntegerArgumentContext ctx) {
+ if (ctx.integerLiteral() != null) {
+ return antlr.genericVisitor.parseIntegral(ctx.integerLiteral());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitFloatArgument(final GremlinParser.FloatArgumentContext ctx) {
+ if (ctx.floatLiteral() != null) {
+ return antlr.genericVisitor.parseFloating(ctx.floatLiteral());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitStringArgument(final GremlinParser.StringArgumentContext ctx) {
+ if (ctx.stringLiteral() != null) {
+ return antlr.genericVisitor.parseString(ctx.stringLiteral());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitStringNullableArgument(final GremlinParser.StringNullableArgumentContext ctx) {
+ if (ctx.stringNullableLiteral() != null) {
+ return antlr.genericVisitor.parseString(ctx.stringNullableLiteral());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitGenericLiteralArgument(final GremlinParser.GenericLiteralArgumentContext ctx) {
+ if (ctx.genericLiteral() != null) {
+ return antlr.genericVisitor.visitGenericLiteral(ctx.genericLiteral());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitGenericLiteralListArgument(final GremlinParser.GenericLiteralListArgumentContext ctx) {
+ if (ctx.genericLiteralList() != null) {
+ return antlr.genericVisitor.visitChildren(ctx.genericLiteralList());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalDirectionArgument(final GremlinParser.TraversalDirectionArgumentContext ctx) {
+ if (ctx.traversalDirection() != null) {
+ return TraversalEnumParser.parseTraversalDirectionFromContext(ctx.traversalDirection());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitStructureVertexArgument(final GremlinParser.StructureVertexArgumentContext ctx) {
+ if (ctx.structureVertex() != null) {
+ return antlr.structureVisitor.visitStructureVertex(ctx.structureVertex());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalOrderArgument(final GremlinParser.TraversalOrderArgumentContext ctx) {
+ if (ctx.traversalOrder() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(Order.class, ctx.traversalOrder());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalScopeArgument(final GremlinParser.TraversalScopeArgumentContext ctx) {
+ if (ctx.traversalScope() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.traversalScope());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalTokenArgument(final GremlinParser.TraversalTokenArgumentContext ctx) {
+ if (ctx.traversalToken() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(T.class, ctx.traversalToken());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalCardinalityArgument(final GremlinParser.TraversalCardinalityArgumentContext ctx) {
+ if (ctx.traversalCardinality() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(VertexProperty.Cardinality.class, ctx.traversalCardinality());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalMergeArgument(final GremlinParser.TraversalMergeArgumentContext ctx) {
+ if (ctx.traversalMerge() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(Merge.class, ctx.traversalMerge());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalPopArgument(final GremlinParser.TraversalPopArgumentContext ctx) {
+ if (ctx.traversalPop() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(Pop.class, ctx.traversalPop());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalColumnArgument(final GremlinParser.TraversalColumnArgumentContext ctx) {
+ if (ctx.traversalColumn() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(Column.class, ctx.traversalColumn());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalComparatorArgument(final GremlinParser.TraversalComparatorArgumentContext ctx) {
+ if (ctx.traversalComparator() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(Order.class, ctx.traversalComparator().traversalOrder());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalFunctionArgument(final GremlinParser.TraversalFunctionArgumentContext ctx) {
+ if (ctx.traversalFunction() != null) {
+ final GremlinParser.TraversalFunctionContext tfc = ctx.traversalFunction();
+ if (tfc.traversalToken() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(T.class, tfc.traversalToken());
+ } else if (tfc.traversalColumn() != null)
+ return TraversalEnumParser.parseTraversalEnumFromContext(Column.class, tfc.traversalColumn());
+ else {
+ throw new GremlinParserException("Unrecognized enum for traversal function");
+ }
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalBiFunctionArgument(final GremlinParser.TraversalBiFunctionArgumentContext ctx) {
+ if (ctx.traversalBiFunction() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(Operator.class, ctx.traversalBiFunction().traversalOperator());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitGenericLiteralMapArgument(final GremlinParser.GenericLiteralMapArgumentContext ctx) {
+ if (ctx.genericLiteralMap() != null) {
+ return antlr.genericVisitor.visitGenericLiteralMap(ctx.genericLiteralMap());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitGenericLiteralMapNullableArgument(final GremlinParser.GenericLiteralMapNullableArgumentContext ctx) {
+ if (ctx.nullLiteral() != null) {
+ return null;
+ } else if (ctx.genericLiteralMap() != null) {
+ return antlr.genericVisitor.visitGenericLiteralMap(ctx.genericLiteralMap());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitTraversalSackMethodArgument(final GremlinParser.TraversalSackMethodArgumentContext ctx) {
+ if (ctx.traversalSackMethod() != null) {
+ return TraversalEnumParser.parseTraversalEnumFromContext(SackFunctions.Barrier.class, ctx.traversalSackMethod());
+ } else {
+ return visitVariable(ctx.variable());
+ }
+ }
+
+ @Override
+ public Object visitVariable(final GremlinParser.VariableContext ctx) {
+ return resolver.apply(ctx.getText(), ctx);
+ }
+}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java
index 798578dfac..f8884165de 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java
@@ -34,7 +34,6 @@ public class DefaultGremlinBaseVisitor<T> extends AbstractParseTreeVisitor<T> im
final String className = (ctx != null)? ctx.getClass().getName() : "";
throw new UnsupportedOperationException("Method not implemented for context class " + className);
}
-
/**
* {@inheritDoc}
*/
@@ -1188,10 +1187,6 @@ public class DefaultGremlinBaseVisitor<T> extends AbstractParseTreeVisitor<T> im
* {@inheritDoc}
*/
@Override public T visitStringLiteral(final GremlinParser.StringLiteralContext ctx) { notImplemented(ctx); return null; }
- /**
- * {@inheritDoc}
- */
- @Override public T visitStringBasedLiteral(final GremlinParser.StringBasedLiteralContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
@@ -1211,232 +1206,346 @@ public class DefaultGremlinBaseVisitor<T> extends AbstractParseTreeVisitor<T> im
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants(final GremlinParser.GremlinStringConstantsContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitPageRankStringConstant(final GremlinParser.PageRankStringConstantContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitPageRankStringConstants(final GremlinParser.PageRankStringConstantsContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitPeerPressureStringConstant(final GremlinParser.PeerPressureStringConstantContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitPeerPressureStringConstants(final GremlinParser.PeerPressureStringConstantsContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitShortestPathStringConstant(final GremlinParser.ShortestPathStringConstantContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitShortestPathStringConstants(final GremlinParser.ShortestPathStringConstantsContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitWithOptionsStringConstant(final GremlinParser.WithOptionsStringConstantContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitWithOptionsStringConstants(final GremlinParser.WithOptionsStringConstantsContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalMethod_option_Predicate_Traversal(final GremlinParser.TraversalMethod_option_Predicate_TraversalContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_pageRankStringConstants_edges(final GremlinParser.GremlinStringConstants_pageRankStringConstants_edgesContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitConnectedComponentConstants(final GremlinParser.ConnectedComponentConstantsContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_pageRankStringConstants_times(final GremlinParser.GremlinStringConstants_pageRankStringConstants_timesContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitConnectedComponentStringConstant(final GremlinParser.ConnectedComponentStringConstantContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_pageRankStringConstants_propertyName(final GremlinParser.GremlinStringConstants_pageRankStringConstants_propertyNameContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitIoOptionsStringConstant(final GremlinParser.IoOptionsStringConstantContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_peerPressureStringConstants_edges(final GremlinParser.GremlinStringConstants_peerPressureStringConstants_edgesContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitStructureVertex(final GremlinParser.StructureVertexContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_peerPressureStringConstants_times(final GremlinParser.GremlinStringConstants_peerPressureStringConstants_timesContext ctx) { notImplemented(ctx);return null; }
+ @Override public T visitTraversalSourceSpawnMethod_mergeV_Map(final GremlinParser.TraversalSourceSpawnMethod_mergeV_MapContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_peerPressureStringConstants_propertyName(final GremlinParser.GremlinStringConstants_peerPressureStringConstants_propertyNameContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalSourceSpawnMethod_mergeV_Traversal(final GremlinParser.TraversalSourceSpawnMethod_mergeV_TraversalContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_shortestPathStringConstants_target(final GremlinParser.GremlinStringConstants_shortestPathStringConstants_targetContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalMethod_option_Merge_Map(final GremlinParser.TraversalMethod_option_Merge_MapContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_shortestPathStringConstants_edges(final GremlinParser.GremlinStringConstants_shortestPathStringConstants_edgesContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalMethod_option_Merge_Traversal(final GremlinParser.TraversalMethod_option_Merge_TraversalContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_shortestPathStringConstants_distance(final GremlinParser.GremlinStringConstants_shortestPathStringConstants_distanceContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalMerge(final GremlinParser.TraversalMergeContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_shortestPathStringConstants_maxDistance(final GremlinParser.GremlinStringConstants_shortestPathStringConstants_maxDistanceContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalMethod_mergeV_Map(final GremlinParser.TraversalMethod_mergeV_MapContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_shortestPathStringConstants_includeEdges(final GremlinParser.GremlinStringConstants_shortestPathStringConstants_includeEdgesContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalMethod_mergeV_Traversal(final GremlinParser.TraversalMethod_mergeV_TraversalContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_withOptionsStringConstants_tokens(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_tokensContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalMethod_mergeE_Map(final GremlinParser.TraversalMethod_mergeE_MapContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_withOptionsStringConstants_none(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_noneContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalMethod_mergeE_Traversal(final GremlinParser.TraversalMethod_mergeE_TraversalContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_withOptionsStringConstants_ids(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_idsContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalSourceSpawnMethod_mergeE_Map(final GremlinParser.TraversalSourceSpawnMethod_mergeE_MapContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_withOptionsStringConstants_labels(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_labelsContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalSourceSpawnMethod_mergeE_Traversal(final GremlinParser.TraversalSourceSpawnMethod_mergeE_TraversalContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_withOptionsStringConstants_keys(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_keysContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalMethod_mergeV_empty(final GremlinParser.TraversalMethod_mergeV_emptyContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_withOptionsStringConstants_values(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_valuesContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalMethod_mergeE_empty(final GremlinParser.TraversalMethod_mergeE_emptyContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_withOptionsStringConstants_all(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_allContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitTraversalSourceSpawnMethod_union(final GremlinParser.TraversalSourceSpawnMethod_unionContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_withOptionsStringConstants_indexer(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_indexerContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitBooleanArgument(final GremlinParser.BooleanArgumentContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_withOptionsStringConstants_list(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_listContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitVariable(final GremlinParser.VariableContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_withOptionsStringConstants_map(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_mapContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitIntegerArgument(final GremlinParser.IntegerArgumentContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitPageRankStringConstant(final GremlinParser.PageRankStringConstantContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitFloatArgument(final GremlinParser.FloatArgumentContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitPeerPressureStringConstant(final GremlinParser.PeerPressureStringConstantContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitStringArgument(final GremlinParser.StringArgumentContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitShortestPathStringConstant(final GremlinParser.ShortestPathStringConstantContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitStringNullableArgument(final GremlinParser.StringNullableArgumentContext ctx) { notImplemented(ctx); return null;}
/**
* {@inheritDoc}
*/
- @Override public T visitWithOptionsStringConstant(final GremlinParser.WithOptionsStringConstantContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitStringNullableLiteral(final GremlinParser.StringNullableLiteralContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalMethod_option_Predicate_Traversal(final GremlinParser.TraversalMethod_option_Predicate_TraversalContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitWithOptionKeys(final GremlinParser. WithOptionKeysContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitIoOptionsStringConstants(final GremlinParser.IoOptionsStringConstantsContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitPageRankConstants(final GremlinParser. PageRankConstantsContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_ioOptionsStringConstants_reader(final GremlinParser.GremlinStringConstants_ioOptionsStringConstants_readerContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitPeerPressureConstants(final GremlinParser. PeerPressureConstantsContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_ioOptionsStringConstants_writer(final GremlinParser.GremlinStringConstants_ioOptionsStringConstants_writerContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitShortestPathConstants(final GremlinParser. ShortestPathConstantsContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_ioOptionsStringConstants_gryo(final GremlinParser.GremlinStringConstants_ioOptionsStringConstants_gryoContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitWithOptionsValues(final GremlinParser. WithOptionsValuesContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_ioOptionsStringConstants_graphson(final GremlinParser.GremlinStringConstants_ioOptionsStringConstants_graphsonContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitIoOptionsKeys(final GremlinParser. IoOptionsKeysContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_ioOptionsStringConstants_graphml(final GremlinParser.GremlinStringConstants_ioOptionsStringConstants_graphmlContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitIoOptionsValues(final GremlinParser. IoOptionsValuesContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitConnectedComponentConstants(final GremlinParser.ConnectedComponentConstantsContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitConnectedComponentConstants_component(final GremlinParser. ConnectedComponentConstants_componentContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_connectedComponentStringConstants_component(final GremlinParser.GremlinStringConstants_connectedComponentStringConstants_componentContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitConnectedComponentConstants_edges(final GremlinParser. ConnectedComponentConstants_edgesContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_connectedComponentStringConstants_edges(final GremlinParser.GremlinStringConstants_connectedComponentStringConstants_edgesContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitConnectedComponentConstants_propertyName(final GremlinParser. ConnectedComponentConstants_propertyNameContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitGremlinStringConstants_connectedComponentStringConstants_propertyName(final GremlinParser.GremlinStringConstants_connectedComponentStringConstants_propertyNameContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitPageRankConstants_edges(final GremlinParser. PageRankConstants_edgesContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitConnectedComponentStringConstant(final GremlinParser.ConnectedComponentStringConstantContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitPageRankConstants_times(final GremlinParser. PageRankConstants_timesContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitIoOptionsStringConstant(final GremlinParser.IoOptionsStringConstantContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitPageRankConstants_propertyName(final GremlinParser. PageRankConstants_propertyNameContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitStructureVertex(final GremlinParser.StructureVertexContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitPeerPressureConstants_edges(final GremlinParser. PeerPressureConstants_edgesContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalSourceSpawnMethod_mergeV_Map(final GremlinParser.TraversalSourceSpawnMethod_mergeV_MapContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitPeerPressureConstants_times(final GremlinParser. PeerPressureConstants_timesContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalSourceSpawnMethod_mergeV_Traversal(final GremlinParser.TraversalSourceSpawnMethod_mergeV_TraversalContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitPeerPressureConstants_propertyName(final GremlinParser. PeerPressureConstants_propertyNameContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalMethod_option_Merge_Map(final GremlinParser.TraversalMethod_option_Merge_MapContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitShortestPathConstants_target(final GremlinParser. ShortestPathConstants_targetContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalMethod_option_Merge_Traversal(final GremlinParser.TraversalMethod_option_Merge_TraversalContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitShortestPathConstants_edges(final GremlinParser. ShortestPathConstants_edgesContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalMerge(final GremlinParser.TraversalMergeContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitShortestPathConstants_distance(final GremlinParser. ShortestPathConstants_distanceContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalMethod_mergeV_Map(final GremlinParser.TraversalMethod_mergeV_MapContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitShortestPathConstants_maxDistance(final GremlinParser. ShortestPathConstants_maxDistanceContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalMethod_mergeV_Traversal(final GremlinParser.TraversalMethod_mergeV_TraversalContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitShortestPathConstants_includeEdges(final GremlinParser. ShortestPathConstants_includeEdgesContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalMethod_mergeE_Map(final GremlinParser.TraversalMethod_mergeE_MapContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitWithOptionsConstants_tokens(final GremlinParser. WithOptionsConstants_tokensContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalMethod_mergeE_Traversal(final GremlinParser.TraversalMethod_mergeE_TraversalContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitWithOptionsConstants_none(final GremlinParser. WithOptionsConstants_noneContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalSourceSpawnMethod_mergeE_Map(final GremlinParser.TraversalSourceSpawnMethod_mergeE_MapContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitWithOptionsConstants_ids(final GremlinParser. WithOptionsConstants_idsContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalSourceSpawnMethod_mergeE_Traversal(final GremlinParser.TraversalSourceSpawnMethod_mergeE_TraversalContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitWithOptionsConstants_labels(final GremlinParser. WithOptionsConstants_labelsContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
- @Override public T visitTraversalMethod_mergeV_empty(final GremlinParser.TraversalMethod_mergeV_emptyContext ctx) { notImplemented(ctx); return null; }
-
- @Override public T visitTraversalMethod_mergeE_empty(final GremlinParser.TraversalMethod_mergeE_emptyContext ctx) { notImplemented(ctx); return null; }
+ @Override public T visitWithOptionsConstants_keys(final GremlinParser. WithOptionsConstants_keysContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitWithOptionsConstants_values(final GremlinParser. WithOptionsConstants_valuesContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitWithOptionsConstants_all(final GremlinParser. WithOptionsConstants_allContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitWithOptionsConstants_indexer(final GremlinParser. WithOptionsConstants_indexerContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitWithOptionsConstants_list(final GremlinParser. WithOptionsConstants_listContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitWithOptionsConstants_map(final GremlinParser. WithOptionsConstants_mapContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitIoOptionsConstants_reader(final GremlinParser. IoOptionsConstants_readerContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitIoOptionsConstants_writer(final GremlinParser. IoOptionsConstants_writerContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitIoOptionsConstants_gryo(final GremlinParser. IoOptionsConstants_gryoContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitIoOptionsConstants_graphson(final GremlinParser. IoOptionsConstants_graphsonContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitIoOptionsConstants_graphml(final GremlinParser. IoOptionsConstants_graphmlContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitGenericLiteralArgument(final GremlinParser.GenericLiteralArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitGenericLiteralListArgument(GremlinParser.GenericLiteralListArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitStructureVertexArgument(GremlinParser.StructureVertexArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalDirectionArgument(GremlinParser.TraversalDirectionArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalOrderArgument(final GremlinParser.TraversalOrderArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalScopeArgument(final GremlinParser.TraversalScopeArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalTokenArgument(final GremlinParser.TraversalTokenArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalCardinalityArgument(final GremlinParser.TraversalCardinalityArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalMergeArgument(final GremlinParser.TraversalMergeArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalPopArgument(final GremlinParser.TraversalPopArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalColumnArgument(final GremlinParser.TraversalColumnArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalComparatorArgument(final GremlinParser.TraversalComparatorArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalFunctionArgument(final GremlinParser.TraversalFunctionArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override public T visitTraversalBiFunctionArgument(final GremlinParser.TraversalBiFunctionArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public T visitTraversalSackMethodArgument(final GremlinParser.TraversalSackMethodArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public T visitGenericLiteralVarargs(final GremlinParser.GenericLiteralVarargsContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public T visitGenericLiteralMapArgument(final GremlinParser.GenericLiteralMapArgumentContext ctx) { notImplemented(ctx); return null; }
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public T visitGenericLiteralMapNullableArgument(final GremlinParser.GenericLiteralMapNullableArgumentContext ctx) { notImplemented(ctx); return null; }
/**
* {@inheritDoc}
*/
@Override
- public T visitTraversalSourceSpawnMethod_union(final GremlinParser.TraversalSourceSpawnMethod_unionContext ctx) { notImplemented(ctx); return null; }
-}
+ public T visitStringLiteralVarargs(final GremlinParser.StringLiteralVarargsContext ctx) { notImplemented(ctx); return null; }
+}
\ No newline at end of file
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GenericLiteralVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GenericLiteralVisitor.java
index 1bade7d626..bf8000bccd 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GenericLiteralVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GenericLiteralVisitor.java
@@ -47,80 +47,107 @@ public class GenericLiteralVisitor extends DefaultGremlinBaseVisitor<Object> {
*/
public static final int TOTAL_INTEGER_RANGE_RESULT_COUNT_LIMIT = 1_000_000;
protected final GremlinAntlrToJava antlr;
- protected DefaultGremlinBaseVisitor<TraversalStrategy> traversalStrategyVisitor;
-
- private static GenericLiteralVisitor instance;
-
- private GenericLiteralVisitor() {
- this.antlr = null;
- }
public GenericLiteralVisitor(final GremlinAntlrToJava antlr) {
this.antlr = antlr;
}
- public static GenericLiteralVisitor instance() {
- if (instance == null) {
- instance = new GenericLiteralVisitor();
- }
+ /**
+ * Parse integral literal context and return an integral type number.
+ */
+ public Number parseIntegral(final GremlinParser.IntegerLiteralContext integerLiteral) {
+ return (Number) visitIntegerLiteral(integerLiteral);
+ }
+
+ /**
+ * Parse floating literal context and return a floating type number.
+ */
+ public Number parseFloating(final GremlinParser.FloatLiteralContext floatLiteral) {
+ return (Number) visitFloatLiteral(floatLiteral);
+ }
- return instance;
+ /**
+ * Parse a string based literal context and return the string.
+ */
+ public String parseString(final GremlinParser.StringLiteralContext stringLiteral) {
+ return (String) visitStringLiteral(stringLiteral);
}
/**
- * Parse a string literal context and return the string literal
+ * Parse a string based literal context and return the string.
*/
- public static String getStringLiteral(final GremlinParser.StringBasedLiteralContext stringLiteral) {
- return (String) (instance().visitStringBasedLiteral(stringLiteral));
+ public String parseString(final GremlinParser.StringNullableLiteralContext stringLiteral) {
+ return (String) visitStringNullableLiteral(stringLiteral);
}
/**
* Parse a map literal context and return the map literal
*/
- public static Map getMapLiteral(final GremlinParser.GenericLiteralMapContext mapLiteral) {
- return (Map) (instance().visitGenericLiteralMap(mapLiteral));
+ public Map parseMap(final GremlinParser.GenericLiteralMapContext mapLiteral) {
+ return (Map) visitGenericLiteralMap(mapLiteral);
}
/**
* Parse a boolean literal context and return the boolean literal
*/
- public static boolean getBooleanLiteral(final GremlinParser.BooleanLiteralContext booleanLiteral) {
- return (boolean) (instance().visitBooleanLiteral(booleanLiteral));
+ public boolean parseBoolean(final GremlinParser.BooleanLiteralContext booleanLiteral) {
+ return (boolean) visitBooleanLiteral(booleanLiteral);
}
/**
* Parse a String literal list context and return a string array
*/
- public static String[] getStringLiteralList(final GremlinParser.StringLiteralListContext stringLiteralList) {
- if (stringLiteralList == null || stringLiteralList.stringLiteralExpr() == null) {
- return new String[0];
- }
- return stringLiteralList.stringLiteralExpr().stringBasedLiteral()
- .stream()
- .filter(Objects::nonNull)
- .map(stringLiteral -> instance().visitStringBasedLiteral(stringLiteral))
- .toArray(String[]::new);
+ public String[] parseStringList(final GremlinParser.StringLiteralListContext stringLiteralList) {
+ return (String[]) visitStringLiteralList(stringLiteralList);
}
/**
* Parse a generic literal list, and return an object array
*/
- public static Object[] getGenericLiteralList(final GremlinParser.GenericLiteralListContext objectLiteralList) {
+ public Object[] parseObjectList(final GremlinParser.GenericLiteralListContext objectLiteralList) {
if (objectLiteralList == null || objectLiteralList.genericLiteralExpr() == null) {
return new Object[0];
}
return objectLiteralList.genericLiteralExpr().genericLiteral()
.stream()
.filter(Objects::nonNull)
- .map(genericLiteral -> instance().visitGenericLiteral(genericLiteral))
+ .map(antlr.genericVisitor::visitGenericLiteral)
.toArray(Object[]::new);
}
+ /**
+ * Parse a generic literal varargs, and return an object array
+ */
+ public Object[] parseObjectVarargs(final GremlinParser.GenericLiteralVarargsContext varargsContext) {
+ if (varargsContext == null || varargsContext.genericLiteralArgument() == null) {
+ return new Object[0];
+ }
+ return varargsContext.genericLiteralArgument()
+ .stream()
+ .filter(Objects::nonNull)
+ .map(antlr.argumentVisitor::visitGenericLiteralArgument)
+ .toArray(Object[]::new);
+ }
+
+ /**
+ * Parse a string literal varargs, and return an string array
+ */
+ public String[] parseStringVarargs(final GremlinParser.StringLiteralVarargsContext varargsContext) {
+ if (varargsContext == null || varargsContext.stringNullableArgument() == null) {
+ return new String[0];
+ }
+ return varargsContext.stringNullableArgument()
+ .stream()
+ .filter(Objects::nonNull)
+ .map(antlr.argumentVisitor::parseString)
+ .toArray(String[]::new);
+ }
+
/**
* Parse a TraversalStrategy literal list context and return a string array
*/
- public static TraversalStrategy[] getTraversalStrategyList(final GremlinParser.TraversalStrategyListContext traversalStrategyListContext,
- final DefaultGremlinBaseVisitor<TraversalStrategy> traversalStrategyVisitor) {
+ public static TraversalStrategy[] parseTraversalStrategyList(final GremlinParser.TraversalStrategyListContext traversalStrategyListContext,
+ final DefaultGremlinBaseVisitor<TraversalStrategy> traversalStrategyVisitor) {
if (traversalStrategyListContext == null || traversalStrategyListContext.traversalStrategyExpr() == null) {
return new TraversalStrategy[0];
}
@@ -250,16 +277,12 @@ public class GenericLiteralVisitor extends DefaultGremlinBaseVisitor<Object> {
return new Object[0];
case 1:
// handle single generic literal
- return visitGenericLiteral((GremlinParser.GenericLiteralContext) ctx.getChild(0));
+ return antlr.genericVisitor.visitGenericLiteral(ctx.genericLiteral(0));
default:
// handle multiple generic literal separated by comma
final List<Object> genericLiterals = new ArrayList<>();
- int childIndex = 0;
- while (childIndex < ctx.getChildCount()) {
- genericLiterals.add(visitGenericLiteral(
- (GremlinParser.GenericLiteralContext) ctx.getChild(childIndex)));
- // skip comma
- childIndex += 2;
+ for (GremlinParser.GenericLiteralContext ic : ctx.genericLiteral()) {
+ genericLiterals.add(antlr.genericVisitor.visitGenericLiteral(ic));
}
return genericLiterals.toArray();
}
@@ -307,7 +330,7 @@ public class GenericLiteralVisitor extends DefaultGremlinBaseVisitor<Object> {
} else if (kctx instanceof TerminalNode) {
key = ((TerminalNode) kctx).getText();
} else {
- throw new GremlinParserException("Invalid key for map" + ((ParseTree) kctx).getText());
+ throw new GremlinParserException("Invalid key for map " + ((ParseTree) kctx).getText());
}
final int valueIndex = isKeyExpression ? 4 : 2;
@@ -330,7 +353,7 @@ public class GenericLiteralVisitor extends DefaultGremlinBaseVisitor<Object> {
@Override
public Object visitStructureVertex(final GremlinParser.StructureVertexContext ctx) {
- return StructureElementVisitor.instance().visitStructureVertex(ctx);
+ return antlr.structureVisitor.visitStructureVertex(ctx);
}
/**
@@ -447,7 +470,7 @@ public class GenericLiteralVisitor extends DefaultGremlinBaseVisitor<Object> {
*/
@Override
public Object visitDateLiteral(final GremlinParser.DateLiteralContext ctx) {
- return DatetimeHelper.parse((String) visitStringLiteral(ctx.stringLiteral()));
+ return DatetimeHelper.parse((String) antlr.argumentVisitor.visitStringArgument(ctx.stringArgument()));
}
/**
@@ -460,25 +483,6 @@ public class GenericLiteralVisitor extends DefaultGremlinBaseVisitor<Object> {
throw new GremlinParserException("Invalid numeric");
}
- /**
- * {@inheritDoc}
- */
- @Override
- public Object visitStringBasedLiteral(final GremlinParser.StringBasedLiteralContext ctx) {
- // Using Java string unescaping because it coincides with the Groovy rules:
- // https://docs.oracle.com/javase/tutorial/java/data/characters.html
- // http://groovy-lang.org/syntax.html#_escaping_special_characters
- if (ctx.gremlinStringConstants() != null) {
- return GremlinStringConstantsVisitor.instance().visitChildren(ctx);
- }
-
- if (ctx.NullLiteral() != null) {
- return GremlinStringConstantsVisitor.instance().visitChildren(ctx);
- }
-
- return StringEscapeUtils.unescapeJava(stripQuotes(ctx.getText()));
- }
-
/**
* {@inheritDoc}
*/
@@ -529,10 +533,7 @@ public class GenericLiteralVisitor extends DefaultGremlinBaseVisitor<Object> {
@Override
public Object visitTraversalStrategy(final GremlinParser.TraversalStrategyContext ctx) {
- if (null == traversalStrategyVisitor)
- traversalStrategyVisitor = new TraversalStrategyVisitor((DefaultGremlinBaseVisitor) antlr.tvisitor);
-
- return traversalStrategyVisitor.visitTraversalStrategy(ctx);
+ return antlr.traversalStrategyVisitor.visitTraversalStrategy(ctx);
}
/**
@@ -591,17 +592,29 @@ public class GenericLiteralVisitor extends DefaultGremlinBaseVisitor<Object> {
@Override
public Object visitGenericLiteralCollection(final GremlinParser.GenericLiteralCollectionContext ctx) {
final List<Object> result = new ArrayList<>(ctx.getChildCount() / 2);
- // first child is "[", so start from 2nd child
- int childIndex = 1;
- final int childCount = ctx.getChildCount();
- if (childCount > 2) {
- while (childIndex < childCount) {
- result.add(visitGenericLiteral((GremlinParser.GenericLiteralContext) ctx.getChild(childIndex)));
- // comma is also child, so we need skip it.
- childIndex += 2;
- }
+ for (GremlinParser.GenericLiteralContext ic : ctx.genericLiteral()) {
+ result.add(antlr.genericVisitor.visitGenericLiteral(ic));
}
return result;
}
+ @Override
+ public Object visitStringLiteralList(final GremlinParser.StringLiteralListContext ctx) {
+ if (ctx == null || ctx.stringLiteralExpr() == null) {
+ return new String[0];
+ }
+ return ctx.stringLiteralExpr().stringNullableLiteral()
+ .stream()
+ .filter(Objects::nonNull)
+ .map(this::visitStringNullableLiteral)
+ .toArray(String[]::new);
+ }
+
+ @Override
+ public Object visitStringNullableLiteral(final GremlinParser.StringNullableLiteralContext ctx) {
+ if (ctx.NullLiteral() != null)
+ return null;
+ else
+ return StringEscapeUtils.unescapeJava(stripQuotes(ctx.getText()));
+ }
}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinAntlrToJava.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinAntlrToJava.java
index cdf72746d8..bea85349f0 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinAntlrToJava.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinAntlrToJava.java
@@ -20,13 +20,16 @@ package org.apache.tinkerpop.gremlin.language.grammar;
import org.antlr.v4.runtime.tree.ParseTree;
import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
+import org.apache.tinkerpop.gremlin.process.traversal.P;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalSource;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
import java.util.function.Supplier;
@@ -76,6 +79,31 @@ public class GremlinAntlrToJava extends DefaultGremlinBaseVisitor<Object> {
*/
final Supplier<GraphTraversal<?,?>> createAnonymous;
+ /**
+ * Parses arguments, which may or may not be variables.
+ */
+ final ArgumentVisitor argumentVisitor;
+
+ /**
+ * Parses literals.
+ */
+ final GenericLiteralVisitor genericVisitor;
+
+ /**
+ * Parses {@link TraversalStrategy} instances.
+ */
+ final TraversalStrategyVisitor traversalStrategyVisitor;
+
+ /**
+ * Parses {@link P} instances.
+ */
+ final TraversalPredicateVisitor traversalPredicateVisitor;
+
+ /**
+ * Parses structure instances like {@link Vertex}.
+ */
+ final StructureElementVisitor structureVisitor;
+
/**
* Constructs a new instance and is bound to an {@link EmptyGraph}. This form of construction is helpful for
* generating {@link Bytecode} or for various forms of testing. {@link Traversal} instances constructed from this
@@ -101,6 +129,15 @@ public class GremlinAntlrToJava extends DefaultGremlinBaseVisitor<Object> {
this(g, __::start);
}
+ /**
+ * Constructs a new instance that is bound to the specified {@link GraphTraversalSource} and thus spawns the
+ * {@link Traversal} from this "g" rather than from a fresh one constructed from the {@link Graph} instance.
+ * Allows for specification of a {@link VariableResolver} to allow parameters to be resolved.
+ */
+ public GremlinAntlrToJava(final GraphTraversalSource g, final VariableResolver variableResolver) {
+ this(GraphTraversalSourceVisitor.TRAVERSAL_ROOT, g.getGraph(), __::start, g, variableResolver);
+ }
+
/**
* Constructs a new instance that is bound to the specified {@link Graph} instance with an override to using
* {@link __} for constructing anonymous {@link Traversal} instances. Assumes that "g" is the name of the
@@ -115,7 +152,7 @@ public class GremlinAntlrToJava extends DefaultGremlinBaseVisitor<Object> {
* {@link Traversal} from this "g" rather than from a fresh one constructed from the {@link Graph} instance.
*/
protected GremlinAntlrToJava(final GraphTraversalSource g, final Supplier<GraphTraversal<?,?>> createAnonymous) {
- this(GraphTraversalSourceVisitor.TRAVERSAL_ROOT, g.getGraph(), createAnonymous, g);
+ this(GraphTraversalSourceVisitor.TRAVERSAL_ROOT, g.getGraph(), createAnonymous, g, VariableResolver.NoVariableResolver.instance());
}
/**
@@ -126,19 +163,21 @@ public class GremlinAntlrToJava extends DefaultGremlinBaseVisitor<Object> {
*/
protected GremlinAntlrToJava(final String traversalSourceName, final Graph graph,
final Supplier<GraphTraversal<?,?>> createAnonymous) {
- this(traversalSourceName, graph, createAnonymous, null);
+ this(traversalSourceName, graph, createAnonymous, null, VariableResolver.NoVariableResolver.instance());
}
/**
* Constructs a new instance that is bound to the specified {@link Graph} instance with an override to using
* {@link __} for constructing anonymous {@link Traversal} instances. If the {@link GraphTraversalSource} is
- * provided then the {@link Traversal} will spawn from it as opposed to a fresh one from the {@link Graph} instance.
+ * provided then the {@link Traversal} will spawn from it as opposed to a fresh one from the {@link Graph}
+ * instance. When a {@link VariableResolver} is supplied it will attempt to resolve parameters in the Gremlin to
+ * objects.
*
* @param traversalSourceName The name of the traversal source which will be "g" if not specified.
*/
protected GremlinAntlrToJava(final String traversalSourceName, final Graph graph,
final Supplier<GraphTraversal<?,?>> createAnonymous,
- final GraphTraversalSource g) {
+ final GraphTraversalSource g, final VariableResolver variableResolver) {
this.g = g;
this.graph = graph;
this.gvisitor = new GraphTraversalSourceVisitor(
@@ -147,6 +186,11 @@ public class GremlinAntlrToJava extends DefaultGremlinBaseVisitor<Object> {
this.tListVisitor = new NestedTraversalSourceListVisitor(this);
this.createAnonymous = createAnonymous;
this.txVisitor = new TraversalSourceTxVisitor(g, this);
+ this.traversalPredicateVisitor = new TraversalPredicateVisitor(this);
+ this.traversalStrategyVisitor = new TraversalStrategyVisitor(this);
+ this.structureVisitor = new StructureElementVisitor(this);
+ this.genericVisitor = new GenericLiteralVisitor(this);
+ this.argumentVisitor = new ArgumentVisitor(variableResolver, this);
}
/**
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinParserException.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinParserException.java
index 946e7153bc..07530bc5aa 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinParserException.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinParserException.java
@@ -33,10 +33,10 @@ public class GremlinParserException extends RuntimeException {
super(message);
}
- public GremlinParserException(final int line_number, final int charPositionInLine, final String message) {
+ public GremlinParserException(final int lineNumber, final int charPositionInLine, final String message) {
super(new StringBuilder()
.append("Query parsing failed at line ")
- .append(line_number)
+ .append(lineNumber)
.append(", character position at ")
.append(charPositionInLine)
.append(", error message : ")
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParser.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParser.java
index a02d19f8da..7ab7392af2 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParser.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParser.java
@@ -22,17 +22,29 @@ import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.atn.PredictionMode;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.util.Map;
+
+/**
+ * Parses Gremlin strings to an {@code Object}, typically to a {@link Traversal}.
+ */
public class GremlinQueryParser {
private static final Logger log = LoggerFactory.getLogger(GremlinQueryParser.class);
private static final GremlinErrorListener errorListener = new GremlinErrorListener();
+ /**
+ * Parse Gremlin string using a default {@link GremlinAntlrToJava} object.
+ */
public static Object parse(final String query) {
return parse(query, new GremlinAntlrToJava());
}
+ /**
+ * Parse Gremlin string using a specified {@link GremlinAntlrToJava} object.
+ */
public static Object parse(final String query, final GremlinVisitor<Object> visitor) {
final CharStream in = CharStreams.fromString(query);
final GremlinLexer lexer = new GremlinLexer(in);
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinStringConstantsVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinStringConstantsVisitor.java
deleted file mode 100644
index 8c181ca6d6..0000000000
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinStringConstantsVisitor.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.tinkerpop.gremlin.language.grammar;
-
-import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.ConnectedComponent;
-import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.PageRank;
-import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.PeerPressure;
-import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.ShortestPath;
-import org.apache.tinkerpop.gremlin.process.traversal.IO;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
-import org.apache.tinkerpop.gremlin.process.traversal.step.util.WithOptions;
-
-/**
- * Covers {@code String} oriented constants used as arguments to {@link GraphTraversal#with(String)} steps.
- */
-public class GremlinStringConstantsVisitor extends DefaultGremlinBaseVisitor<Object> {
-
- private GremlinStringConstantsVisitor() {}
-
- private static GremlinStringConstantsVisitor instance;
-
- public static GremlinStringConstantsVisitor instance() {
- if (instance == null) {
- instance = new GremlinStringConstantsVisitor();
- }
- return instance;
- }
-
- @Override
- public Object visitGremlinStringConstants(final GremlinParser.GremlinStringConstantsContext ctx) {
- return visitChildren(ctx);
- }
-
- @Override
- public Object visitConnectedComponentStringConstant(final GremlinParser.ConnectedComponentStringConstantContext ctx) {
- return visitChildren(ctx);
- }
-
- @Override
- public Object visitPageRankStringConstants(final GremlinParser.PageRankStringConstantsContext ctx) {
- return visitChildren(ctx);
- }
-
- @Override
- public Object visitPeerPressureStringConstants(final GremlinParser.PeerPressureStringConstantsContext ctx) {
- return visitChildren(ctx);
- }
-
- @Override
- public Object visitShortestPathStringConstants(final GremlinParser.ShortestPathStringConstantsContext ctx) {
- return visitChildren(ctx);
- }
-
- @Override
- public Object visitWithOptionsStringConstants(final GremlinParser.WithOptionsStringConstantsContext ctx) {
- return visitChildren(ctx);
- }
-
- @Override
- public Object visitIoOptionsStringConstants(final GremlinParser.IoOptionsStringConstantsContext ctx) {
- return visitChildren(ctx);
- }
-
- @Override
- public Object visitGremlinStringConstants_connectedComponentStringConstants_edges(final GremlinParser.GremlinStringConstants_connectedComponentStringConstants_edgesContext ctx) {
- return ConnectedComponent.edges;
- }
-
- @Override
- public Object visitGremlinStringConstants_connectedComponentStringConstants_component(final GremlinParser.GremlinStringConstants_connectedComponentStringConstants_componentContext ctx) {
- return ConnectedComponent.component;
- }
-
- @Override
- public Object visitGremlinStringConstants_connectedComponentStringConstants_propertyName(final GremlinParser.GremlinStringConstants_connectedComponentStringConstants_propertyNameContext ctx) {
- return ConnectedComponent.propertyName;
- }
-
- @Override
- public Object visitGremlinStringConstants_pageRankStringConstants_edges(final GremlinParser.GremlinStringConstants_pageRankStringConstants_edgesContext ctx) {
- return PageRank.edges;
- }
-
- @Override
- public Object visitGremlinStringConstants_pageRankStringConstants_times(final GremlinParser.GremlinStringConstants_pageRankStringConstants_timesContext ctx) {
- return PageRank.times;
- }
-
- @Override
- public Object visitGremlinStringConstants_pageRankStringConstants_propertyName(final GremlinParser.GremlinStringConstants_pageRankStringConstants_propertyNameContext ctx) {
- return PageRank.propertyName;
- }
-
- @Override
- public Object visitGremlinStringConstants_peerPressureStringConstants_edges(final GremlinParser.GremlinStringConstants_peerPressureStringConstants_edgesContext ctx) {
- return PeerPressure.edges;
- }
-
- @Override
- public Object visitGremlinStringConstants_peerPressureStringConstants_times(final GremlinParser.GremlinStringConstants_peerPressureStringConstants_timesContext ctx) {
- return PeerPressure.times;
- }
-
- @Override
- public Object visitGremlinStringConstants_peerPressureStringConstants_propertyName(final GremlinParser.GremlinStringConstants_peerPressureStringConstants_propertyNameContext ctx) {
- return PeerPressure.propertyName;
- }
-
- @Override
- public Object visitGremlinStringConstants_shortestPathStringConstants_target(final GremlinParser.GremlinStringConstants_shortestPathStringConstants_targetContext ctx) {
- return ShortestPath.target;
- }
-
- @Override
- public Object visitGremlinStringConstants_shortestPathStringConstants_edges(final GremlinParser.GremlinStringConstants_shortestPathStringConstants_edgesContext ctx) {
- return ShortestPath.edges;
- }
-
- @Override
- public Object visitGremlinStringConstants_shortestPathStringConstants_distance(final GremlinParser.GremlinStringConstants_shortestPathStringConstants_distanceContext ctx) {
- return ShortestPath.distance;
- }
-
- @Override
- public Object visitGremlinStringConstants_shortestPathStringConstants_maxDistance(final GremlinParser.GremlinStringConstants_shortestPathStringConstants_maxDistanceContext ctx) {
- return ShortestPath.maxDistance;
- }
-
- @Override
- public Object visitGremlinStringConstants_shortestPathStringConstants_includeEdges(final GremlinParser.GremlinStringConstants_shortestPathStringConstants_includeEdgesContext ctx) {
- return ShortestPath.includeEdges;
- }
-
- @Override
- public Object visitGremlinStringConstants_withOptionsStringConstants_tokens(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_tokensContext ctx) {
- return WithOptions.tokens;
- }
-
- @Override
- public Object visitGremlinStringConstants_withOptionsStringConstants_none(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_noneContext ctx) {
- return WithOptions.none;
- }
-
- @Override
- public Object visitGremlinStringConstants_withOptionsStringConstants_ids(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_idsContext ctx) {
- return WithOptions.ids;
- }
-
- @Override
- public Object visitGremlinStringConstants_withOptionsStringConstants_labels(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_labelsContext ctx) {
- return WithOptions.labels;
- }
-
- @Override
- public Object visitGremlinStringConstants_withOptionsStringConstants_keys(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_keysContext ctx) {
- return WithOptions.keys;
- }
-
- @Override
- public Object visitGremlinStringConstants_withOptionsStringConstants_values(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_valuesContext ctx) {
- return WithOptions.values;
- }
-
- @Override
- public Object visitGremlinStringConstants_withOptionsStringConstants_all(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_allContext ctx) {
- return WithOptions.all;
- }
-
- @Override
- public Object visitGremlinStringConstants_withOptionsStringConstants_indexer(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_indexerContext ctx) {
- return WithOptions.indexer;
- }
-
- @Override
- public Object visitGremlinStringConstants_withOptionsStringConstants_list(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_listContext ctx) {
- return WithOptions.list;
- }
-
- @Override
- public Object visitGremlinStringConstants_withOptionsStringConstants_map(final GremlinParser.GremlinStringConstants_withOptionsStringConstants_mapContext ctx) {
- return WithOptions.map;
- }
-
- @Override
- public Object visitGremlinStringConstants_ioOptionsStringConstants_reader(final GremlinParser.GremlinStringConstants_ioOptionsStringConstants_readerContext ctx) {
- return IO.reader;
- }
-
- @Override
- public Object visitGremlinStringConstants_ioOptionsStringConstants_writer(final GremlinParser.GremlinStringConstants_ioOptionsStringConstants_writerContext ctx) {
- return IO.writer;
- }
-
- @Override
- public Object visitGremlinStringConstants_ioOptionsStringConstants_gryo(final GremlinParser.GremlinStringConstants_ioOptionsStringConstants_gryoContext ctx) {
- return IO.gryo;
- }
-
- @Override
- public Object visitGremlinStringConstants_ioOptionsStringConstants_graphson(final GremlinParser.GremlinStringConstants_ioOptionsStringConstants_graphsonContext ctx) {
- return IO.graphson;
- }
-
- @Override
- public Object visitGremlinStringConstants_ioOptionsStringConstants_graphml(final GremlinParser.GremlinStringConstants_ioOptionsStringConstants_graphmlContext ctx) {
- return IO.graphml;
- }
-}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/ParseTreeContextCastHelper.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/ParseTreeContextCastHelper.java
index 18bbe0fa6d..5d665ae45e 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/ParseTreeContextCastHelper.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/ParseTreeContextCastHelper.java
@@ -31,17 +31,7 @@ public class ParseTreeContextCastHelper {
* @param childIndex : child index
* @return casted GenericLiteralContext
*/
- public static GremlinParser.GenericLiteralContext castChildToGenericLiteral(final ParseTree ctx, final int childIndex) {
- return (GremlinParser.GenericLiteralContext)(ctx.getChild(childIndex));
- }
-
- /**
- * Cast ParseTree node child into GenericLiteralListContext
- * @param ctx : ParseTree node
- * @param childIndex : child index
- * @return casted GenericLiteralListContext
- */
- public static GremlinParser.GenericLiteralListContext castChildToGenericLiteralList(final ParseTree ctx, final int childIndex) {
- return (GremlinParser.GenericLiteralListContext)(ctx.getChild(childIndex));
+ public static GremlinParser.GenericLiteralArgumentContext castChildToGenericLiteral(final ParseTree ctx, final int childIndex) {
+ return (GremlinParser.GenericLiteralArgumentContext)(ctx.getChild(childIndex));
}
}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/StructureElementVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/StructureElementVisitor.java
index 0e9c68b08c..007985842a 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/StructureElementVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/StructureElementVisitor.java
@@ -24,20 +24,15 @@ import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex;
public class StructureElementVisitor extends GremlinBaseVisitor<Element> {
- private StructureElementVisitor() {}
+ protected final GremlinAntlrToJava antlr;
- private static StructureElementVisitor instance;
-
- public static StructureElementVisitor instance() {
- if (instance == null) {
- instance = new StructureElementVisitor();
- }
- return instance;
+ public StructureElementVisitor(final GremlinAntlrToJava antlr) {
+ this.antlr = antlr;
}
@Override
public Vertex visitStructureVertex(final GremlinParser.StructureVertexContext ctx) {
- return new ReferenceVertex(GenericLiteralVisitor.instance().visitGenericLiteral(ctx.genericLiteral()),
- GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return new ReferenceVertex(antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()),
+ (String) antlr.argumentVisitor.visitStringArgument(ctx.stringArgument()));
}
}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalFunctionVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalFunctionVisitor.java
deleted file mode 100644
index 4dce5e645d..0000000000
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalFunctionVisitor.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.tinkerpop.gremlin.language.grammar;
-
-import org.apache.tinkerpop.gremlin.structure.Column;
-import org.apache.tinkerpop.gremlin.structure.T;
-
-import java.util.function.Function;
-
-/**
- * Traversal Function parser parses Function enums.
- */
-public class TraversalFunctionVisitor extends DefaultGremlinBaseVisitor<Function> {
-
- private TraversalFunctionVisitor() {}
-
- private static TraversalFunctionVisitor instance;
-
- public static TraversalFunctionVisitor instance() {
- if (instance == null) {
- instance = new TraversalFunctionVisitor();
- }
- return instance;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Function visitTraversalFunction(final GremlinParser.TraversalFunctionContext ctx) {
- return this.visitChildren(ctx);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Function visitTraversalToken(final GremlinParser.TraversalTokenContext ctx) {
- return TraversalEnumParser.parseTraversalEnumFromContext(T.class, ctx);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public Function visitTraversalColumn(final GremlinParser.TraversalColumnContext ctx) {
- return TraversalEnumParser.parseTraversalEnumFromContext(Column.class, ctx);
- }
-}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
index 6c2a0ca21e..bb02fface8 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
@@ -18,17 +18,10 @@
*/
package org.apache.tinkerpop.gremlin.language.grammar;
-import org.apache.tinkerpop.gremlin.process.traversal.Merge;
import org.apache.tinkerpop.gremlin.process.traversal.Operator;
import org.apache.tinkerpop.gremlin.process.traversal.Order;
-import org.apache.tinkerpop.gremlin.process.traversal.Pop;
-import org.apache.tinkerpop.gremlin.process.traversal.Scope;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
-import org.apache.tinkerpop.gremlin.structure.Column;
-import org.apache.tinkerpop.gremlin.structure.Direction;
-import org.apache.tinkerpop.gremlin.structure.T;
-import org.apache.tinkerpop.gremlin.structure.VertexProperty;
import org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality;
import java.util.LinkedHashMap;
@@ -66,11 +59,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_V(final GremlinParser.TraversalMethod_VContext ctx) {
- if (ctx.genericLiteralList().getChildCount() != 0) {
- return this.graphTraversal.V(GenericLiteralVisitor.getGenericLiteralList(ctx.genericLiteralList()));
- } else {
- return this.graphTraversal.V();
- }
+ return this.graphTraversal.V(antlr.genericVisitor.parseObjectVarargs(ctx.genericLiteralVarargs()));
}
/**
@@ -78,11 +67,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_E(final GremlinParser.TraversalMethod_EContext ctx) {
- if (ctx.genericLiteralList().getChildCount() != 0) {
- return this.graphTraversal.E(GenericLiteralVisitor.getGenericLiteralList(ctx.genericLiteralList()));
- } else {
- return this.graphTraversal.E();
- }
+ return this.graphTraversal.E(antlr.genericVisitor.parseObjectVarargs(ctx.genericLiteralVarargs()));
}
/**
@@ -98,7 +83,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_addV_String(final GremlinParser.TraversalMethod_addV_StringContext ctx) {
- return this.graphTraversal.addV(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return this.graphTraversal.addV(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -106,10 +91,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_mergeV_Map(final GremlinParser.TraversalMethod_mergeV_MapContext ctx) {
- if (ctx.nullLiteral() != null) {
- return this.graphTraversal.mergeV((Map) null);
- }
- return this.graphTraversal.mergeV(GenericLiteralVisitor.getMapLiteral(ctx.genericLiteralMap()));
+ return this.graphTraversal.mergeV(antlr.argumentVisitor.parseMap(ctx.genericLiteralMapNullableArgument()));
}
/**
@@ -141,10 +123,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_mergeE_Map(final GremlinParser.TraversalMethod_mergeE_MapContext ctx) {
- if (ctx.nullLiteral() != null) {
- return this.graphTraversal.mergeE((Map) null);
- }
- return this.graphTraversal.mergeE(GenericLiteralVisitor.getMapLiteral(ctx.genericLiteralMap()));
+ return this.graphTraversal.mergeE(antlr.argumentVisitor.parseMap(ctx.genericLiteralMapNullableArgument()));
}
/**
@@ -176,10 +155,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_addE_String(final GremlinParser.TraversalMethod_addE_StringContext ctx) {
- final int childIndexOfParameterEdgeLabel = 2;
- final GremlinParser.StringBasedLiteralContext stringLiteralContext =
- (GremlinParser.StringBasedLiteralContext) (ctx.getChild(childIndexOfParameterEdgeLabel));
- return this.graphTraversal.addE(GenericLiteralVisitor.getStringLiteral(stringLiteralContext));
+ return this.graphTraversal.addE(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -187,7 +163,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_aggregate_String(final GremlinParser.TraversalMethod_aggregate_StringContext ctx) {
- return graphTraversal.aggregate(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.aggregate(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -196,8 +172,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_aggregate_Scope_String(final GremlinParser.TraversalMethod_aggregate_Scope_StringContext ctx) {
return graphTraversal.aggregate(
- TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)),
- GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()),
+ antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -215,10 +191,10 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_as(final GremlinParser.TraversalMethod_asContext ctx) {
if (ctx.getChildCount() == 4) {
- return graphTraversal.as(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.as(antlr.argumentVisitor.parseString(ctx.stringArgument()));
} else {
- return graphTraversal.as(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.as(antlr.argumentVisitor.parseString(ctx.stringArgument()),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
}
@@ -245,7 +221,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_barrier_int(final GremlinParser.TraversalMethod_barrier_intContext ctx) {
- return graphTraversal.barrier(Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.barrier(antlr.argumentVisitor.parseNumber(ctx.integerArgument()).intValue());
}
/**
@@ -253,7 +229,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_both(final GremlinParser.TraversalMethod_bothContext ctx) {
- return graphTraversal.both(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.both(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -261,7 +237,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_bothE(final GremlinParser.TraversalMethod_bothEContext ctx) {
- return graphTraversal.bothE(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.bothE(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -301,7 +277,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_by_Function(final GremlinParser.TraversalMethod_by_FunctionContext ctx) {
- return graphTraversal.by(TraversalFunctionVisitor.instance().visitTraversalFunction(ctx.traversalFunction()));
+ return graphTraversal.by(antlr.argumentVisitor.parseFunction(ctx.traversalFunctionArgument()));
}
/**
@@ -309,8 +285,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_by_Function_Comparator(final GremlinParser.TraversalMethod_by_Function_ComparatorContext ctx) {
- return graphTraversal.by(TraversalFunctionVisitor.instance().visitTraversalFunction(ctx.traversalFunction()),
- TraversalEnumParser.parseTraversalEnumFromContext(Order.class, ctx.getChild(4)));
+ return graphTraversal.by(antlr.argumentVisitor.parseFunction(ctx.traversalFunctionArgument()),
+ antlr.argumentVisitor.parseComparator(ctx.traversalComparatorArgument()));
}
/**
@@ -326,7 +302,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_by_String(final GremlinParser.TraversalMethod_by_StringContext ctx) {
- return graphTraversal.by(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.by(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -334,7 +310,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_by_String_Comparator(final GremlinParser.TraversalMethod_by_String_ComparatorContext ctx) {
- return graphTraversal.by(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
+ return graphTraversal.by(antlr.argumentVisitor.parseString(ctx.stringArgument()),
TraversalEnumParser.parseTraversalEnumFromContext(Order.class, ctx.getChild(4)));
}
@@ -343,7 +319,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_by_T(final GremlinParser.TraversalMethod_by_TContext ctx) {
- return graphTraversal.by(TraversalEnumParser.parseTraversalEnumFromContext(T.class, ctx.getChild(2)));
+ return graphTraversal.by(antlr.argumentVisitor.parseT(ctx.traversalTokenArgument()));
}
/**
@@ -369,10 +345,10 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_cap(final GremlinParser.TraversalMethod_capContext ctx) {
if (ctx.getChildCount() == 4) {
- return graphTraversal.cap(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.cap(antlr.argumentVisitor.parseString(ctx.stringArgument()));
} else {
- return graphTraversal.cap(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.cap(antlr.argumentVisitor.parseString(ctx.stringArgument()),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
}
@@ -381,7 +357,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_choose_Function(final GremlinParser.TraversalMethod_choose_FunctionContext ctx) {
- return graphTraversal.choose(TraversalFunctionVisitor.instance().visitTraversalFunction(ctx.traversalFunction()));
+ return graphTraversal.choose(antlr.argumentVisitor.parseFunction(ctx.traversalFunctionArgument()));
}
/**
@@ -389,7 +365,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_choose_Predicate_Traversal(final GremlinParser.TraversalMethod_choose_Predicate_TraversalContext ctx) {
- return graphTraversal.choose(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()),
+ return graphTraversal.choose(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
@@ -398,7 +374,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_choose_Predicate_Traversal_Traversal(final GremlinParser.TraversalMethod_choose_Predicate_Traversal_TraversalContext ctx) {
- return graphTraversal.choose(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()),
+ return graphTraversal.choose(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal(0)),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal(1)));
}
@@ -444,7 +420,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_coin(final GremlinParser.TraversalMethod_coinContext ctx) {
- return graphTraversal.coin(Double.valueOf(ctx.floatLiteral().getText()));
+ return graphTraversal.coin(((Number) antlr.argumentVisitor.visitFloatArgument(ctx.floatArgument())).doubleValue());
}
/**
@@ -453,7 +429,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_constant(final GremlinParser.TraversalMethod_constantContext ctx) {
return graphTraversal
- .constant(GenericLiteralVisitor.instance().visitGenericLiteral(ctx.genericLiteral()));
+ .constant(antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()));
}
/**
@@ -469,7 +445,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_count_Scope(final GremlinParser.TraversalMethod_count_ScopeContext ctx) {
- return graphTraversal.count(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)));
+ return graphTraversal.count(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()));
}
/**
@@ -485,8 +461,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_dedup_Scope_String(final GremlinParser.TraversalMethod_dedup_Scope_StringContext ctx) {
- return graphTraversal.dedup(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.dedup(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -494,7 +470,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_dedup_String(final GremlinParser.TraversalMethod_dedup_StringContext ctx) {
- return graphTraversal.dedup(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.dedup(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -518,7 +494,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_emit_Predicate(final GremlinParser.TraversalMethod_emit_PredicateContext ctx) {
- return graphTraversal.emit(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.emit(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -542,7 +518,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public Traversal visitTraversalMethod_fail_String(final GremlinParser.TraversalMethod_fail_StringContext ctx) {
- return this.graphTraversal.fail(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return this.graphTraversal.fail(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -550,7 +526,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_filter_Predicate(final GremlinParser.TraversalMethod_filter_PredicateContext ctx) {
- return graphTraversal.filter(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.filter(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -583,7 +559,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_fold_Object_BiFunction(final GremlinParser.TraversalMethod_fold_Object_BiFunctionContext ctx) {
return graphTraversal.fold(
- GenericLiteralVisitor.instance().visitGenericLiteral(ctx.genericLiteral()),
+ antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()),
(BiFunction) TraversalEnumParser.parseTraversalEnumFromContext(Operator.class, ctx.getChild(4)));
}
@@ -592,7 +568,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_from_String(final GremlinParser.TraversalMethod_from_StringContext ctx) {
- return graphTraversal.from(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.from(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -616,7 +592,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_groupCount_String(final GremlinParser.TraversalMethod_groupCount_StringContext ctx) {
- return graphTraversal.groupCount(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.groupCount(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -632,7 +608,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_group_String(final GremlinParser.TraversalMethod_group_StringContext ctx) {
- return graphTraversal.group(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.group(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -640,8 +616,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_hasId_Object_Object(final GremlinParser.TraversalMethod_hasId_Object_ObjectContext ctx) {
- return graphTraversal.hasId(GenericLiteralVisitor.instance().visitGenericLiteral(ctx.genericLiteral()),
- GenericLiteralVisitor.getGenericLiteralList(ctx.genericLiteralList()));
+ return graphTraversal.hasId(antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()),
+ antlr.genericVisitor.parseObjectVarargs(ctx.genericLiteralVarargs()));
}
/**
@@ -649,7 +625,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_hasId_P(final GremlinParser.TraversalMethod_hasId_PContext ctx) {
- return graphTraversal.hasId(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.hasId(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -657,7 +633,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_hasKey_P(final GremlinParser.TraversalMethod_hasKey_PContext ctx) {
- return graphTraversal.hasKey(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.hasKey(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -666,10 +642,10 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_hasKey_String_String(final GremlinParser.TraversalMethod_hasKey_String_StringContext ctx) {
if (ctx.getChildCount() == 4) {
- return graphTraversal.hasKey(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.hasKey(antlr.argumentVisitor.parseString(ctx.stringNullableArgument()));
} else {
- return graphTraversal.hasKey(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.hasKey(antlr.argumentVisitor.parseString(ctx.stringNullableArgument()),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
}
@@ -678,7 +654,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_hasLabel_P(final GremlinParser.TraversalMethod_hasLabel_PContext ctx) {
- return graphTraversal.hasLabel(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.hasLabel(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -687,10 +663,10 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_hasLabel_String_String(final GremlinParser.TraversalMethod_hasLabel_String_StringContext ctx) {
if (ctx.getChildCount() == 4) {
- return graphTraversal.hasLabel(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.hasLabel(antlr.argumentVisitor.parseString(ctx.stringNullableArgument()));
} else {
- return graphTraversal.hasLabel(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.hasLabel(antlr.argumentVisitor.parseString(ctx.stringNullableArgument()),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
}
@@ -699,7 +675,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_hasNot(final GremlinParser.TraversalMethod_hasNotContext ctx) {
- return graphTraversal.hasNot(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.hasNot(antlr.argumentVisitor.parseString(ctx.stringNullableArgument()));
}
/**
@@ -707,8 +683,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_hasValue_Object_Object(final GremlinParser.TraversalMethod_hasValue_Object_ObjectContext ctx) {
- return graphTraversal.hasValue(GenericLiteralVisitor.instance().visitGenericLiteral(ctx.genericLiteral()),
- GenericLiteralVisitor.getGenericLiteralList(ctx.genericLiteralList()));
+ return graphTraversal.hasValue(antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()),
+ antlr.genericVisitor.parseObjectVarargs(ctx.genericLiteralVarargs()));
}
/**
@@ -716,7 +692,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_hasValue_P(final GremlinParser.TraversalMethod_hasValue_PContext ctx) {
- return graphTraversal.hasValue(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.hasValue(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -724,7 +700,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_has_String(final GremlinParser.TraversalMethod_has_StringContext ctx) {
- return graphTraversal.has(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.has(antlr.argumentVisitor.parseString(ctx.stringNullableArgument()));
}
/**
@@ -732,8 +708,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_has_String_Object(final GremlinParser.TraversalMethod_has_String_ObjectContext ctx) {
- return graphTraversal.has(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- new GenericLiteralVisitor(antlr).visitGenericLiteral(ctx.genericLiteral()));
+ return graphTraversal.has(antlr.argumentVisitor.parseString(ctx.stringNullableArgument()),
+ antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()));
}
/**
@@ -741,8 +717,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_has_String_P(final GremlinParser.TraversalMethod_has_String_PContext ctx) {
- return graphTraversal.has(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.has(antlr.argumentVisitor.parseString(ctx.stringNullableArgument()),
+ antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -750,9 +726,9 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_has_String_String_Object(final GremlinParser.TraversalMethod_has_String_String_ObjectContext ctx) {
- return graphTraversal.has(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral(0)),
- GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral(1)),
- GenericLiteralVisitor.instance().visitGenericLiteral(ctx.genericLiteral()));
+ return graphTraversal.has(antlr.argumentVisitor.parseString(ctx.stringNullableArgument(0)),
+ antlr.argumentVisitor.parseString(ctx.stringNullableArgument(1)),
+ antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()));
}
/**
@@ -760,9 +736,9 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_has_String_String_P(final GremlinParser.TraversalMethod_has_String_String_PContext ctx) {
- return graphTraversal.has(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral(0)),
- GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral(1)),
- TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.has(antlr.argumentVisitor.parseString(ctx.stringNullableArgument(0)),
+ antlr.argumentVisitor.parseString(ctx.stringNullableArgument(1)),
+ antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -770,7 +746,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_has_String_Traversal(final GremlinParser.TraversalMethod_has_String_TraversalContext ctx) {
- return graphTraversal.has(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
+ return graphTraversal.has(antlr.argumentVisitor.parseString(ctx.stringNullableArgument()),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
@@ -779,8 +755,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_has_T_Object(final GremlinParser.TraversalMethod_has_T_ObjectContext ctx) {
- return graphTraversal.has(TraversalEnumParser.parseTraversalEnumFromContext(T.class, ctx.getChild(2)),
- new GenericLiteralVisitor(antlr).visitGenericLiteral(ctx.genericLiteral()));
+ return graphTraversal.has(antlr.argumentVisitor.parseT(ctx.traversalTokenArgument()),
+ antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()));
}
/**
@@ -788,8 +764,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_has_T_P(final GremlinParser.TraversalMethod_has_T_PContext ctx) {
- return graphTraversal.has(TraversalEnumParser.parseTraversalEnumFromContext(T.class, ctx.getChild(2)),
- TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.has(antlr.argumentVisitor.parseT(ctx.traversalTokenArgument()),
+ antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -797,7 +773,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_has_T_Traversal(final GremlinParser.TraversalMethod_has_T_TraversalContext ctx) {
- return graphTraversal.has(TraversalEnumParser.parseTraversalEnumFromContext(T.class, ctx.getChild(2)),
+ return graphTraversal.has(antlr.argumentVisitor.parseT(ctx.traversalTokenArgument()),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
@@ -822,7 +798,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_in(final GremlinParser.TraversalMethod_inContext ctx) {
- return graphTraversal.in(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.in(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -830,7 +806,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_inE(final GremlinParser.TraversalMethod_inEContext ctx) {
- return graphTraversal.inE(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.inE(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -846,7 +822,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_inject(final GremlinParser.TraversalMethod_injectContext ctx) {
- return graphTraversal.inject(GenericLiteralVisitor.getGenericLiteralList(ctx.genericLiteralList()));
+ return graphTraversal.inject(antlr.genericVisitor.parseObjectVarargs(ctx.genericLiteralVarargs()));
}
@Override
@@ -859,7 +835,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_is_Object(final GremlinParser.TraversalMethod_is_ObjectContext ctx) {
- return graphTraversal.is(GenericLiteralVisitor.instance().visitGenericLiteral(ctx.genericLiteral()));
+ return graphTraversal.is(antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()));
}
/**
@@ -867,7 +843,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_is_P(final GremlinParser.TraversalMethod_is_PContext ctx) {
- return graphTraversal.is(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.is(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -891,8 +867,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_limit_Scope_long(final GremlinParser.TraversalMethod_limit_Scope_longContext ctx) {
- return graphTraversal.limit(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)),
- Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.limit(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()),
+ antlr.argumentVisitor.parseNumber(ctx.integerArgument()).longValue());
}
/**
@@ -900,7 +876,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_limit_long(final GremlinParser.TraversalMethod_limit_longContext ctx) {
- return graphTraversal.limit(Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.limit(antlr.argumentVisitor.parseNumber(ctx.integerArgument()).longValue());
}
/**
@@ -918,12 +894,12 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_loops_String(final GremlinParser.TraversalMethod_loops_StringContext ctx) {
- return graphTraversal.loops(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.loops(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
@Override
public GraphTraversal visitTraversalMethod_repeat_String_Traversal(final GremlinParser.TraversalMethod_repeat_String_TraversalContext ctx) {
- return graphTraversal.repeat((GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral())),
+ return graphTraversal.repeat((antlr.argumentVisitor.parseString(ctx.stringArgument())),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
@@ -944,13 +920,31 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_with_String(final GremlinParser.TraversalMethod_with_StringContext ctx) {
- return graphTraversal.with(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ if (ctx.withOptionKeys() != null) {
+ return graphTraversal.with((String) WithOptionsVisitor.instance().visitWithOptionKeys(ctx.withOptionKeys()));
+ } else {
+ return graphTraversal.with(antlr.argumentVisitor.parseString(ctx.stringArgument()));
+ }
}
@Override
public GraphTraversal visitTraversalMethod_with_String_Object(final GremlinParser.TraversalMethod_with_String_ObjectContext ctx) {
- return graphTraversal.with(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- new GenericLiteralVisitor(antlr).visitGenericLiteral(ctx.genericLiteral()));
+ final String k;
+ if (ctx.withOptionKeys() != null) {
+ k = (String) WithOptionsVisitor.instance().visitWithOptionKeys(ctx.withOptionKeys());
+ } else {
+ k = antlr.argumentVisitor.parseString(ctx.stringArgument());
+ }
+
+ final Object o;
+ if (ctx.withOptionsValues() != null) {
+ o = WithOptionsVisitor.instance().visitWithOptionsValues(ctx.withOptionsValues());
+ } else if (ctx.ioOptionsValues() != null) {
+ o = WithOptionsVisitor.instance().visitIoOptionsValues(ctx.ioOptionsValues());
+ } else {
+ o = antlr.argumentVisitor.parseObject(ctx.genericLiteralArgument());
+ }
+ return graphTraversal.with(k, o);
}
@Override
@@ -988,7 +982,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_max_Scope(final GremlinParser.TraversalMethod_max_ScopeContext ctx) {
- return graphTraversal.max(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)));
+ return graphTraversal.max(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()));
}
/**
@@ -1004,7 +998,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_mean_Scope(final GremlinParser.TraversalMethod_mean_ScopeContext ctx) {
- return graphTraversal.mean(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)));
+ return graphTraversal.mean(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()));
}
/**
@@ -1020,7 +1014,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_min_Scope(final GremlinParser.TraversalMethod_min_ScopeContext ctx) {
- return graphTraversal.min(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)));
+ return graphTraversal.min(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()));
}
/**
@@ -1036,7 +1030,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_option_Object_Traversal(final GremlinParser.TraversalMethod_option_Object_TraversalContext ctx) {
- return graphTraversal.option(new GenericLiteralVisitor(antlr).visitGenericLiteral(ctx.genericLiteral()),
+ return graphTraversal.option(antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
@@ -1053,12 +1047,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_option_Merge_Map(final GremlinParser.TraversalMethod_option_Merge_MapContext ctx) {
- if (ctx.nullLiteral() != null) {
- return this.graphTraversal.option(TraversalEnumParser.parseTraversalEnumFromContext(Merge.class, ctx.traversalMerge()), (Map) null);
- }
-
- return graphTraversal.option(TraversalEnumParser.parseTraversalEnumFromContext(Merge.class, ctx.traversalMerge()),
- (Map) new GenericLiteralVisitor(antlr).visitGenericLiteralMap(ctx.genericLiteralMap()));
+ return graphTraversal.option(antlr.argumentVisitor.parseMerge(ctx.traversalMergeArgument()),
+ (Map) antlr.argumentVisitor.visitGenericLiteralMapNullableArgument(ctx.genericLiteralMapNullableArgument()));
}
/**
@@ -1066,7 +1056,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_option_Merge_Traversal(final GremlinParser.TraversalMethod_option_Merge_TraversalContext ctx) {
- return this.graphTraversal.option(TraversalEnumParser.parseTraversalEnumFromContext(Merge.class, ctx.traversalMerge()),
+ return this.graphTraversal.option(antlr.argumentVisitor.parseMerge(ctx.traversalMergeArgument()),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
@@ -1100,7 +1090,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_order_Scope(final GremlinParser.TraversalMethod_order_ScopeContext ctx) {
- return graphTraversal.order(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)));
+ return graphTraversal.order(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()));
}
/**
@@ -1116,7 +1106,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_out(final GremlinParser.TraversalMethod_outContext ctx) {
- return graphTraversal.out(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.out(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -1124,7 +1114,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_outE(final GremlinParser.TraversalMethod_outEContext ctx) {
- return graphTraversal.outE(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.outE(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -1153,7 +1143,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_pageRank_double(final GremlinParser.TraversalMethod_pageRank_doubleContext ctx) {
- return graphTraversal.pageRank(Double.valueOf(ctx.floatLiteral().getText()));
+ return graphTraversal.pageRank(((Number) antlr.argumentVisitor.visitFloatArgument(ctx.floatArgument())).doubleValue());
}
/**
@@ -1185,7 +1175,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_profile_String(final GremlinParser.TraversalMethod_profile_StringContext ctx) {
- return graphTraversal.profile(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.profile(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -1194,10 +1184,10 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_project(final GremlinParser.TraversalMethod_projectContext ctx) {
if (ctx.getChildCount() == 4) {
- return graphTraversal.project(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.project(antlr.argumentVisitor.parseString(ctx.stringArgument()));
} else {
- return graphTraversal.project(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.project(antlr.argumentVisitor.parseString(ctx.stringArgument()),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
}
@@ -1206,7 +1196,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_properties(final GremlinParser.TraversalMethod_propertiesContext ctx) {
- return graphTraversal.properties(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.properties(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -1214,7 +1204,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_elementMap(final GremlinParser.TraversalMethod_elementMapContext ctx) {
- return graphTraversal.elementMap(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.elementMap(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -1222,7 +1212,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_propertyMap(final GremlinParser.TraversalMethod_propertyMapContext ctx) {
- return graphTraversal.propertyMap(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.propertyMap(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -1230,10 +1220,10 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_property_Cardinality_Object_Object_Object(final GremlinParser.TraversalMethod_property_Cardinality_Object_Object_ObjectContext ctx) {
- return graphTraversal.property(TraversalEnumParser.parseTraversalEnumFromContext(VertexProperty.Cardinality.class, ctx.getChild(2)),
- GenericLiteralVisitor.instance().visitGenericLiteral(ctx.genericLiteral(0)),
- GenericLiteralVisitor.instance().visitGenericLiteral(ctx.genericLiteral(1)),
- GenericLiteralVisitor.getGenericLiteralList(ctx.genericLiteralList()));
+ return graphTraversal.property(antlr.argumentVisitor.parseCardinality(ctx.traversalCardinalityArgument()),
+ antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument(0)),
+ antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument(1)),
+ antlr.genericVisitor.parseObjectVarargs(ctx.genericLiteralVarargs()));
}
/**
@@ -1241,9 +1231,14 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_property_Object_Object_Object(final GremlinParser.TraversalMethod_property_Object_Object_ObjectContext ctx) {
- return graphTraversal.property(new GenericLiteralVisitor(antlr).visitGenericLiteral(ctx.genericLiteral(0)),
- new GenericLiteralVisitor(antlr).visitGenericLiteral(ctx.genericLiteral(1)),
- GenericLiteralVisitor.getGenericLiteralList(ctx.genericLiteralList()));
+ if (ctx.getChildCount() == 6) {
+ return graphTraversal.property(antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument(0)),
+ antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument(1)));
+ } else {
+ return graphTraversal.property(antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument(0)),
+ antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument(1)),
+ antlr.genericVisitor.parseObjectVarargs(ctx.genericLiteralVarargs()));
+ }
}
/**
@@ -1251,7 +1246,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public Traversal visitTraversalMethod_property_Cardinality_Object(final GremlinParser.TraversalMethod_property_Cardinality_ObjectContext ctx) {
- return graphTraversal.property(Cardinality.list, new GenericLiteralVisitor(antlr).visitGenericLiteralMap(ctx.genericLiteralMap()));
+ return graphTraversal.property(Cardinality.list, antlr.argumentVisitor.parseMap(ctx.genericLiteralMapNullableArgument()));
}
/**
@@ -1259,7 +1254,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public Traversal visitTraversalMethod_property_Object(final GremlinParser.TraversalMethod_property_ObjectContext ctx) {
- return graphTraversal.property((LinkedHashMap<Object, Object>) new GenericLiteralVisitor(antlr).visitGenericLiteralMap(ctx.genericLiteralMap()));
+ return graphTraversal.property(antlr.argumentVisitor.parseMap(ctx.genericLiteralMapNullableArgument()));
}
/**
@@ -1267,9 +1262,9 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_range_Scope_long_long(final GremlinParser.TraversalMethod_range_Scope_long_longContext ctx) {
- return graphTraversal.range(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)),
- Integer.valueOf(ctx.integerLiteral(0).getText()),
- Integer.valueOf(ctx.integerLiteral(1).getText()));
+ return graphTraversal.range(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()),
+ antlr.argumentVisitor.parseNumber(ctx.integerArgument(0)).longValue(),
+ antlr.argumentVisitor.parseNumber(ctx.integerArgument(1)).longValue());
}
/**
@@ -1277,8 +1272,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_range_long_long(final GremlinParser.TraversalMethod_range_long_longContext ctx) {
- return graphTraversal.range(Integer.valueOf(ctx.integerLiteral(0).getText()),
- Integer.valueOf(ctx.integerLiteral(1).getText()));
+ return graphTraversal.range(antlr.argumentVisitor.parseNumber(ctx.integerArgument(0)).longValue(),
+ antlr.argumentVisitor.parseNumber(ctx.integerArgument(1)).longValue());
}
/**
@@ -1302,8 +1297,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_sample_Scope_int(final GremlinParser.TraversalMethod_sample_Scope_intContext ctx) {
- return graphTraversal.sample(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)),
- Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.sample(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()),
+ antlr.argumentVisitor.parseNumber(ctx.integerArgument()).intValue());
}
/**
@@ -1311,7 +1306,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_sample_int(final GremlinParser.TraversalMethod_sample_intContext ctx) {
- return graphTraversal.sample(Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.sample(antlr.argumentVisitor.parseNumber(ctx.integerArgument()).intValue());
}
/**
@@ -1319,7 +1314,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_select_Column(final GremlinParser.TraversalMethod_select_ColumnContext ctx) {
- return graphTraversal.select(TraversalEnumParser.parseTraversalEnumFromContext(Column.class, ctx.getChild(2)));
+ return graphTraversal.select(antlr.argumentVisitor.parseColumn(ctx.traversalColumnArgument()));
}
/**
@@ -1327,8 +1322,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_select_Pop_String(final GremlinParser.TraversalMethod_select_Pop_StringContext ctx) {
- return graphTraversal.select(TraversalEnumParser.parseTraversalEnumFromContext(Pop.class, ctx.getChild(2)),
- GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.select(antlr.argumentVisitor.parsePop(ctx.traversalPopArgument()),
+ antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -1336,15 +1331,15 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_select_Pop_String_String_String(final GremlinParser.TraversalMethod_select_Pop_String_String_StringContext ctx) {
- return graphTraversal.select(TraversalEnumParser.parseTraversalEnumFromContext(Pop.class, ctx.getChild(2)),
- GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral(0)),
- GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral(1)),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.select(antlr.argumentVisitor.parsePop(ctx.traversalPopArgument()),
+ antlr.argumentVisitor.parseString(ctx.stringArgument(0)),
+ antlr.argumentVisitor.parseString(ctx.stringArgument(1)),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
@Override
public GraphTraversal visitTraversalMethod_select_Pop_Traversal(final GremlinParser.TraversalMethod_select_Pop_TraversalContext ctx) {
- return graphTraversal.select(TraversalEnumParser.parseTraversalEnumFromContext(Pop.class, ctx.getChild(2)),
+ return graphTraversal.select(antlr.argumentVisitor.parsePop(ctx.traversalPopArgument()),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
@@ -1353,7 +1348,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_select_String(final GremlinParser.TraversalMethod_select_StringContext ctx) {
- return graphTraversal.select(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.select(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -1361,9 +1356,9 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_select_String_String_String(final GremlinParser.TraversalMethod_select_String_String_StringContext ctx) {
- return graphTraversal.select(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral(0)),
- GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral(1)),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.select(antlr.argumentVisitor.parseString(ctx.stringArgument(0)),
+ antlr.argumentVisitor.parseString(ctx.stringArgument(1)),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
@Override
@@ -1392,8 +1387,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_skip_Scope_long(final GremlinParser.TraversalMethod_skip_Scope_longContext ctx) {
- return graphTraversal.skip(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)),
- Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.skip(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()),
+ antlr.argumentVisitor.parseNumber(ctx.integerArgument()).longValue());
}
/**
@@ -1401,7 +1396,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_skip_long(final GremlinParser.TraversalMethod_skip_longContext ctx) {
- return graphTraversal.skip(Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.skip(antlr.argumentVisitor.parseNumber(ctx.integerArgument()).longValue());
}
/**
@@ -1409,7 +1404,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_store(final GremlinParser.TraversalMethod_storeContext ctx) {
- return graphTraversal.store(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.store(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -1417,7 +1412,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_subgraph(final GremlinParser.TraversalMethod_subgraphContext ctx) {
- return graphTraversal.subgraph(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.subgraph(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -1433,7 +1428,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_sum_Scope(final GremlinParser.TraversalMethod_sum_ScopeContext ctx) {
- return graphTraversal.sum(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)));
+ return graphTraversal.sum(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()));
}
/**
@@ -1449,7 +1444,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_tail_Scope(final GremlinParser.TraversalMethod_tail_ScopeContext ctx) {
- return graphTraversal.tail(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)));
+ return graphTraversal.tail(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()));
}
/**
@@ -1457,8 +1452,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_tail_Scope_long(final GremlinParser.TraversalMethod_tail_Scope_longContext ctx) {
- return graphTraversal.tail(TraversalEnumParser.parseTraversalEnumFromContext(Scope.class, ctx.getChild(2)),
- Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.tail(antlr.argumentVisitor.parseScope(ctx.traversalScopeArgument()),
+ antlr.argumentVisitor.parseNumber(ctx.integerArgument()).longValue());
}
/**
@@ -1466,7 +1461,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_tail_long(final GremlinParser.TraversalMethod_tail_longContext ctx) {
- return graphTraversal.tail(Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.tail(antlr.argumentVisitor.parseNumber(ctx.integerArgument()).longValue());
}
/**
@@ -1474,7 +1469,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_timeLimit(final GremlinParser.TraversalMethod_timeLimitContext ctx) {
- return graphTraversal.timeLimit(Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.timeLimit(antlr.argumentVisitor.parseNumber(ctx.integerArgument()).longValue());
}
/**
@@ -1482,7 +1477,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_times(final GremlinParser.TraversalMethod_timesContext ctx) {
- return graphTraversal.times(Integer.valueOf(ctx.integerLiteral().getText()));
+ return graphTraversal.times(antlr.argumentVisitor.parseNumber(ctx.integerArgument()).intValue());
}
/**
@@ -1490,8 +1485,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_toE(final GremlinParser.TraversalMethod_toEContext ctx) {
- return graphTraversal.toE(TraversalEnumParser.parseTraversalEnumFromContext(Direction.class, ctx.getChild(2)),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.toE(antlr.argumentVisitor.parseDirection(ctx.traversalDirectionArgument()),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -1499,7 +1494,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_toV(final GremlinParser.TraversalMethod_toVContext ctx) {
- return graphTraversal.toV(TraversalEnumParser.parseTraversalEnumFromContext(Direction.class, ctx.getChild(2)));
+ return graphTraversal.toV(antlr.argumentVisitor.parseDirection(ctx.traversalDirectionArgument()));
}
/**
@@ -1507,8 +1502,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_to_Direction_String(final GremlinParser.TraversalMethod_to_Direction_StringContext ctx) {
- return graphTraversal.to(TraversalEnumParser.parseTraversalEnumFromContext(Direction.class, ctx.getChild(2)),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.to(antlr.argumentVisitor.parseDirection(ctx.traversalDirectionArgument()),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -1516,7 +1511,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_to_String(final GremlinParser.TraversalMethod_to_StringContext ctx) {
- return graphTraversal.to(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.to(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -1540,7 +1535,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_tree_String(final GremlinParser.TraversalMethod_tree_StringContext ctx) {
- return graphTraversal.tree(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.tree(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -1565,7 +1560,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_until_Predicate(final GremlinParser.TraversalMethod_until_PredicateContext ctx) {
- return graphTraversal.until(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.until(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -1589,7 +1584,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_valueMap_String(final GremlinParser.TraversalMethod_valueMap_StringContext ctx) {
- return graphTraversal.valueMap(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.valueMap(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -1598,10 +1593,10 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_valueMap_boolean_String(final GremlinParser.TraversalMethod_valueMap_boolean_StringContext ctx) {
if (ctx.getChildCount() == 4) {
- return graphTraversal.valueMap(Boolean.valueOf(ctx.booleanLiteral().getText()));
+ return graphTraversal.valueMap((boolean) antlr.argumentVisitor.visitBooleanArgument(ctx.booleanArgument()));
} else {
- return graphTraversal.valueMap(Boolean.valueOf(ctx.booleanLiteral().getText()),
- GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.valueMap((boolean) antlr.argumentVisitor.visitBooleanArgument(ctx.booleanArgument()),
+ antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
}
@@ -1610,7 +1605,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_values(final GremlinParser.TraversalMethod_valuesContext ctx) {
- return graphTraversal.values(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()));
+ return graphTraversal.values(antlr.genericVisitor.parseStringVarargs(ctx.stringLiteralVarargs()));
}
/**
@@ -1618,7 +1613,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_where_P(final GremlinParser.TraversalMethod_where_PContext ctx) {
- return graphTraversal.where(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.where(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -1626,8 +1621,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_where_String_P(final GremlinParser.TraversalMethod_where_String_PContext ctx) {
- return graphTraversal.where(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()));
+ return graphTraversal.where(antlr.argumentVisitor.parseString(ctx.stringArgument()),
+ antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()));
}
/**
@@ -1643,7 +1638,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_math(final GremlinParser.TraversalMethod_mathContext ctx) {
- return graphTraversal.math(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.math(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -1651,7 +1646,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public Traversal visitTraversalMethod_option_Predicate_Traversal(final GremlinParser.TraversalMethod_option_Predicate_TraversalContext ctx) {
- return graphTraversal.option(TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx.traversalPredicate()),
+ return graphTraversal.option(antlr.traversalPredicateVisitor.visitTraversalPredicate(ctx.traversalPredicate()),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
@@ -1660,7 +1655,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public Traversal visitTraversalMethod_from_Vertex(final GremlinParser.TraversalMethod_from_VertexContext ctx) {
- return graphTraversal.from(StructureElementVisitor.instance().visitStructureVertex(ctx.structureVertex()));
+ return graphTraversal.from(antlr.argumentVisitor.parseVertex(ctx.structureVertexArgument()));
}
/**
@@ -1668,7 +1663,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public Traversal visitTraversalMethod_to_Vertex(final GremlinParser.TraversalMethod_to_VertexContext ctx) {
- return graphTraversal.to(StructureElementVisitor.instance().visitStructureVertex(ctx.structureVertex()));
+ return graphTraversal.to(antlr.argumentVisitor.parseVertex(ctx.structureVertexArgument()));
}
/**
@@ -1684,7 +1679,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public Traversal visitTraversalMethod_call_string(final GremlinParser.TraversalMethod_call_stringContext ctx) {
- return graphTraversal.call(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return graphTraversal.call(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -1692,8 +1687,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public Traversal visitTraversalMethod_call_string_map(final GremlinParser.TraversalMethod_call_string_mapContext ctx) {
- return graphTraversal.call(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- GenericLiteralVisitor.getMapLiteral(ctx.genericLiteralMap()));
+ return graphTraversal.call(antlr.argumentVisitor.parseString(ctx.stringArgument()),
+ antlr.argumentVisitor.parseMap(ctx.genericLiteralMapArgument()));
}
/**
@@ -1701,7 +1696,7 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public Traversal visitTraversalMethod_call_string_traversal(final GremlinParser.TraversalMethod_call_string_traversalContext ctx) {
- return graphTraversal.call(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
+ return graphTraversal.call(antlr.argumentVisitor.parseString(ctx.stringArgument()),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
@@ -1710,8 +1705,8 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public Traversal visitTraversalMethod_call_string_map_traversal(final GremlinParser.TraversalMethod_call_string_map_traversalContext ctx) {
- return graphTraversal.call(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- GenericLiteralVisitor.getMapLiteral(ctx.genericLiteralMap()),
+ return graphTraversal.call(antlr.argumentVisitor.parseString(ctx.stringArgument()),
+ antlr.argumentVisitor.parseMap(ctx.genericLiteralMapArgument()),
antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalPredicateVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalPredicateVisitor.java
index 9095421ebc..e2cad13811 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalPredicateVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalPredicateVisitor.java
@@ -27,25 +27,11 @@ import java.util.List;
import java.util.Set;
public class TraversalPredicateVisitor extends DefaultGremlinBaseVisitor<P> {
- private static TraversalPredicateVisitor instance;
- public static TraversalPredicateVisitor instance() {
- if (instance == null) {
- instance = new TraversalPredicateVisitor();
- }
- return instance;
- }
+ protected final GremlinAntlrToJava antlr;
- private TraversalPredicateVisitor() {}
-
- /**
- * Cast ParseTree node child into TraversalPredicateContext
- * @param ctx : ParseTree node
- * @param childIndex : child index
- * @return casted TraversalPredicateContext
- */
- private GremlinParser.TraversalPredicateContext castChildToTraversalPredicate(final ParseTree ctx, final int childIndex) {
- return (GremlinParser.TraversalPredicateContext)(ctx.getChild(childIndex));
+ public TraversalPredicateVisitor(final GremlinAntlrToJava antlr) {
+ this.antlr = antlr;
}
/**
@@ -77,79 +63,59 @@ public class TraversalPredicateVisitor extends DefaultGremlinBaseVisitor<P> {
}
}
- /**
- * get 1 generic literal argument from the antlr parse tree context,
- * where the arguments has the child index of 2
- */
- private Object getSingleGenericLiteralArgument(final ParseTree ctx) {
- final int childIndexOfParameterValue = 2;
-
- return GenericLiteralVisitor.instance().visitGenericLiteral(
- ParseTreeContextCastHelper.castChildToGenericLiteral(ctx, childIndexOfParameterValue));
- }
-
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_eq(final GremlinParser.TraversalPredicate_eqContext ctx) {
+ @Override
+ public P visitTraversalPredicate_eq(final GremlinParser.TraversalPredicate_eqContext ctx) {
return P.eq(getSingleGenericLiteralArgument(ctx));
}
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_neq(final GremlinParser.TraversalPredicate_neqContext ctx) {
+ @Override
+ public P visitTraversalPredicate_neq(final GremlinParser.TraversalPredicate_neqContext ctx) {
return P.neq(getSingleGenericLiteralArgument(ctx));
}
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_lt(final GremlinParser.TraversalPredicate_ltContext ctx) {
+ @Override
+ public P visitTraversalPredicate_lt(final GremlinParser.TraversalPredicate_ltContext ctx) {
return P.lt(getSingleGenericLiteralArgument(ctx));
}
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_lte(final GremlinParser.TraversalPredicate_lteContext ctx) {
+ @Override
+ public P visitTraversalPredicate_lte(final GremlinParser.TraversalPredicate_lteContext ctx) {
return P.lte(getSingleGenericLiteralArgument(ctx));
}
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_gt(final GremlinParser.TraversalPredicate_gtContext ctx) {
+ @Override
+ public P visitTraversalPredicate_gt(final GremlinParser.TraversalPredicate_gtContext ctx) {
return P.gt(getSingleGenericLiteralArgument(ctx));
}
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_gte(final GremlinParser.TraversalPredicate_gteContext ctx) {
+ @Override
+ public P visitTraversalPredicate_gte(final GremlinParser.TraversalPredicate_gteContext ctx) {
return P.gte(getSingleGenericLiteralArgument(ctx));
}
- /**
- * get 2 generic literal arguments from the antlr parse tree context,
- * where the arguments has the child index of 2 and 4
- */
- private Object[] getDoubleGenericLiteralArgument(ParseTree ctx) {
- final int childIndexOfParameterFirst = 2;
- final int childIndexOfParameterSecond = 4;
-
- final Object first = GenericLiteralVisitor.instance().visitGenericLiteral(
- ParseTreeContextCastHelper.castChildToGenericLiteral(ctx, childIndexOfParameterFirst));
- final Object second = GenericLiteralVisitor.instance().visitGenericLiteral(
- ParseTreeContextCastHelper.castChildToGenericLiteral(ctx, childIndexOfParameterSecond));
-
- return new Object[]{first, second};
- }
-
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_inside(final GremlinParser.TraversalPredicate_insideContext ctx) {
+ @Override
+ public P visitTraversalPredicate_inside(final GremlinParser.TraversalPredicate_insideContext ctx) {
final Object[] arguments = getDoubleGenericLiteralArgument(ctx);
return P.inside(arguments[0], arguments[1]);
}
@@ -157,7 +123,8 @@ public class TraversalPredicateVisitor extends DefaultGremlinBaseVisitor<P> {
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_outside(final GremlinParser.TraversalPredicate_outsideContext ctx) {
+ @Override
+ public P visitTraversalPredicate_outside(final GremlinParser.TraversalPredicate_outsideContext ctx) {
final Object[] arguments = getDoubleGenericLiteralArgument(ctx);
return P.outside(arguments[0], arguments[1]);
}
@@ -165,7 +132,8 @@ public class TraversalPredicateVisitor extends DefaultGremlinBaseVisitor<P> {
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_between(final GremlinParser.TraversalPredicate_betweenContext ctx) {
+ @Override
+ public P visitTraversalPredicate_between(final GremlinParser.TraversalPredicate_betweenContext ctx) {
final Object[] arguments = getDoubleGenericLiteralArgument(ctx);
return P.between(arguments[0], arguments[1]);
}
@@ -173,14 +141,12 @@ public class TraversalPredicateVisitor extends DefaultGremlinBaseVisitor<P> {
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_within(final GremlinParser.TraversalPredicate_withinContext ctx) {
- final int childIndexOfParameterValues = 2;
-
+ @Override
+ public P visitTraversalPredicate_within(final GremlinParser.TraversalPredicate_withinContext ctx) {
// called with no args which is valid for java/groovy
if (ctx.getChildCount() == 3) return P.within();
- final Object arguments = GenericLiteralVisitor.instance().visitGenericLiteralList(
- ParseTreeContextCastHelper.castChildToGenericLiteralList(ctx, childIndexOfParameterValues));
+ final Object arguments = antlr.argumentVisitor.visitGenericLiteralListArgument(ctx.genericLiteralListArgument());
if (arguments instanceof Object[]) {
// when generic literal list is consist of a comma separated generic literals
@@ -197,14 +163,12 @@ public class TraversalPredicateVisitor extends DefaultGremlinBaseVisitor<P> {
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_without(final GremlinParser.TraversalPredicate_withoutContext ctx) {
- final int childIndexOfParameterValues = 2;
-
+ @Override
+ public P visitTraversalPredicate_without(final GremlinParser.TraversalPredicate_withoutContext ctx) {
// called with no args which is valid for java/groovy
if (ctx.getChildCount() == 3) return P.without();
- final Object arguments = GenericLiteralVisitor.instance().visitGenericLiteralList(
- ParseTreeContextCastHelper.castChildToGenericLiteralList(ctx, childIndexOfParameterValues));
+ final Object arguments = antlr.argumentVisitor.visitGenericLiteralListArgument(ctx.genericLiteralListArgument());
if (arguments instanceof Object[]) {
// when generic literal list is consist of a comma separated generic literals
@@ -221,49 +185,75 @@ public class TraversalPredicateVisitor extends DefaultGremlinBaseVisitor<P> {
/**
* {@inheritDoc}
*/
- @Override public P visitTraversalPredicate_not(final GremlinParser.TraversalPredicate_notContext ctx) {
- final int childIndexOfParameterPredicate = 2;
-
- return P.not(visitTraversalPredicate(castChildToTraversalPredicate(ctx, childIndexOfParameterPredicate)));
+ @Override
+ public P visitTraversalPredicate_not(final GremlinParser.TraversalPredicate_notContext ctx) {
+ return P.not(visitTraversalPredicate(ctx.traversalPredicate()));
}
@Override
public P visitTraversalPredicate_containing(final GremlinParser.TraversalPredicate_containingContext ctx) {
- return TextP.containing(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return TextP.containing((String) antlr.argumentVisitor.visitStringArgument(ctx.stringArgument()));
}
@Override
public P visitTraversalPredicate_notContaining(final GremlinParser.TraversalPredicate_notContainingContext ctx) {
- return TextP.notContaining(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return TextP.notContaining((String) antlr.argumentVisitor.visitStringArgument(ctx.stringArgument()));
}
@Override
public P visitTraversalPredicate_notEndingWith(final GremlinParser.TraversalPredicate_notEndingWithContext ctx) {
- return TextP.notEndingWith(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return TextP.notEndingWith((String) antlr.argumentVisitor.visitStringArgument(ctx.stringArgument()));
}
@Override
public P visitTraversalPredicate_endingWith(final GremlinParser.TraversalPredicate_endingWithContext ctx) {
- return TextP.endingWith(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return TextP.endingWith((String) antlr.argumentVisitor.visitStringArgument(ctx.stringArgument()));
}
@Override
public P visitTraversalPredicate_startingWith(final GremlinParser.TraversalPredicate_startingWithContext ctx) {
- return TextP.startingWith(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return TextP.startingWith((String) antlr.argumentVisitor.visitStringArgument(ctx.stringArgument()));
}
@Override
public P visitTraversalPredicate_notStartingWith(final GremlinParser.TraversalPredicate_notStartingWithContext ctx) {
- return TextP.notStartingWith(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return TextP.notStartingWith((String) antlr.argumentVisitor.visitStringArgument(ctx.stringArgument()));
}
@Override
public P visitTraversalPredicate_regex(final GremlinParser.TraversalPredicate_regexContext ctx) {
- return TextP.regex(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return TextP.regex((String) antlr.argumentVisitor.visitStringArgument(ctx.stringArgument()));
}
@Override
public P visitTraversalPredicate_notRegex(final GremlinParser.TraversalPredicate_notRegexContext ctx) {
- return TextP.notRegex(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return TextP.notRegex((String) antlr.argumentVisitor.visitStringArgument(ctx.stringArgument()));
+ }
+
+ /**
+ * Get 2 generic literal arguments from the antlr parse tree context, where the arguments have the child index
+ * of 2 and 4
+ */
+ private Object[] getDoubleGenericLiteralArgument(final ParseTree ctx) {
+ final int childIndexOfParameterFirst = 2;
+ final int childIndexOfParameterSecond = 4;
+
+ final Object first = antlr.argumentVisitor.visitGenericLiteralArgument(
+ ParseTreeContextCastHelper.castChildToGenericLiteral(ctx, childIndexOfParameterFirst));
+ final Object second = antlr.argumentVisitor.visitGenericLiteralArgument(
+ ParseTreeContextCastHelper.castChildToGenericLiteral(ctx, childIndexOfParameterSecond));
+
+ return new Object[]{first, second};
+ }
+
+ /**
+ * Get 1 generic literal argument from the antlr parse tree context, where the arguments have the child index
+ * of 2
+ */
+ private Object getSingleGenericLiteralArgument(final ParseTree ctx) {
+ final int childIndexOfParameterValue = 2;
+
+ return antlr.argumentVisitor.visitGenericLiteralArgument(
+ ParseTreeContextCastHelper.castChildToGenericLiteral(ctx, childIndexOfParameterValue));
}
}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSelfMethodVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSelfMethodVisitor.java
index 6e765bba1f..1df2b54afb 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSelfMethodVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSelfMethodVisitor.java
@@ -25,6 +25,8 @@ import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSo
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
/**
* A {@link GraphTraversalSource} self method visitor.
@@ -52,13 +54,8 @@ public class TraversalSourceSelfMethodVisitor extends DefaultGremlinBaseVisitor<
* {@inheritDoc}
*/
@Override
- public GraphTraversalSource visitTraversalSourceSelfMethod_withBulk(final GremlinParser.TraversalSourceSelfMethod_withBulkContext ctx)
- {
- final int childIndexOfParameterUseBulk = 2;
-
- final Boolean useBulk = (Boolean)(GenericLiteralVisitor.instance().visitBooleanLiteral(
- (GremlinParser.BooleanLiteralContext)(ctx.getChild(childIndexOfParameterUseBulk))));
-
+ public GraphTraversalSource visitTraversalSourceSelfMethod_withBulk(final GremlinParser.TraversalSourceSelfMethod_withBulkContext ctx) {
+ final boolean useBulk = (boolean) antlr.argumentVisitor.visitBooleanArgument(ctx.booleanArgument());
return source.withBulk(useBulk);
}
@@ -66,8 +63,7 @@ public class TraversalSourceSelfMethodVisitor extends DefaultGremlinBaseVisitor<
* {@inheritDoc}
*/
@Override
- public GraphTraversalSource visitTraversalSourceSelfMethod_withPath(final GremlinParser.TraversalSourceSelfMethod_withPathContext ctx)
- {
+ public GraphTraversalSource visitTraversalSourceSelfMethod_withPath(final GremlinParser.TraversalSourceSelfMethod_withPathContext ctx) {
return source.withPath();
}
@@ -75,19 +71,12 @@ public class TraversalSourceSelfMethodVisitor extends DefaultGremlinBaseVisitor<
* {@inheritDoc}
*/
@Override
- public GraphTraversalSource visitTraversalSourceSelfMethod_withSack(final GremlinParser.TraversalSourceSelfMethod_withSackContext ctx)
- {
- final int childIndexOfParameterInitialValue = 2;
-
+ public GraphTraversalSource visitTraversalSourceSelfMethod_withSack(final GremlinParser.TraversalSourceSelfMethod_withSackContext ctx) {
if (ctx.getChildCount() == 4) {
- return source.withSack(GenericLiteralVisitor.instance().visitGenericLiteral(
- ParseTreeContextCastHelper.castChildToGenericLiteral(ctx, childIndexOfParameterInitialValue)));
+ return source.withSack(antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()));
} else {
- final int childIndexOfParameterMergeOperator = 4;
-
- return source.withSack(GenericLiteralVisitor.instance().visitGenericLiteral(
- ParseTreeContextCastHelper.castChildToGenericLiteral(ctx, childIndexOfParameterInitialValue)),
- TraversalEnumParser.parseTraversalEnumFromContext(Operator.class, ctx.getChild(childIndexOfParameterMergeOperator)));
+ return source.withSack(antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()),
+ (BinaryOperator) antlr.argumentVisitor.visitTraversalBiFunctionArgument(ctx.traversalBiFunctionArgument()));
}
}
@@ -95,31 +84,23 @@ public class TraversalSourceSelfMethodVisitor extends DefaultGremlinBaseVisitor<
* {@inheritDoc}
*/
@Override
- public GraphTraversalSource visitTraversalSourceSelfMethod_withSideEffect(final GremlinParser.TraversalSourceSelfMethod_withSideEffectContext ctx)
- {
- final int childIndexOfParameterKey = 2;
- final int childIndexOfParameterInitialValue = 4;
-
- final String argument1 = (String)(GenericLiteralVisitor.instance().visitStringBasedLiteral(
- (GremlinParser.StringBasedLiteralContext)(ctx.getChild(childIndexOfParameterKey))));
- final Object argument2 = GenericLiteralVisitor.instance().visitGenericLiteral(
- (GremlinParser.GenericLiteralContext)(ctx.getChild(childIndexOfParameterInitialValue)));
-
- return source.withSideEffect(argument1, argument2);
+ public GraphTraversalSource visitTraversalSourceSelfMethod_withSideEffect(final GremlinParser.TraversalSourceSelfMethod_withSideEffectContext ctx) {
+ return source.withSideEffect(antlr.argumentVisitor.parseString(ctx.stringArgument()),
+ antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()));
}
@Override
public GraphTraversalSource visitTraversalSourceSelfMethod_withStrategies(final GremlinParser.TraversalSourceSelfMethod_withStrategiesContext ctx) {
if (null == traversalStrategyVisitor)
- traversalStrategyVisitor = new TraversalStrategyVisitor((DefaultGremlinBaseVisitor) antlr.tvisitor);
+ traversalStrategyVisitor = new TraversalStrategyVisitor(antlr);
// with 4 children withStrategies() was called with a single TraversalStrategy, otherwise multiple were
// specified.
if (ctx.getChildCount() < 5) {
return source.withStrategies(traversalStrategyVisitor.visitTraversalStrategy((GremlinParser.TraversalStrategyContext) ctx.getChild(2)));
} else {
- final Object[] vargs = GenericLiteralVisitor.getTraversalStrategyList(
+ final Object[] vargs = GenericLiteralVisitor.parseTraversalStrategyList(
(GremlinParser.TraversalStrategyListContext) ctx.getChild(4), traversalStrategyVisitor);
final List<TraversalStrategy> strats = new ArrayList<>(Arrays.asList(Arrays.copyOf(vargs, vargs.length, TraversalStrategy[].class)));
strats.add(0, traversalStrategyVisitor.visitTraversalStrategy((GremlinParser.TraversalStrategyContext) ctx.getChild(2)));
@@ -131,22 +112,12 @@ public class TraversalSourceSelfMethodVisitor extends DefaultGremlinBaseVisitor<
* {@inheritDoc}
*/
@Override
- public GraphTraversalSource visitTraversalSourceSelfMethod_with(final GremlinParser.TraversalSourceSelfMethod_withContext ctx)
- {
- final int childIndexOfParameterKey = 2;
-
+ public GraphTraversalSource visitTraversalSourceSelfMethod_with(final GremlinParser.TraversalSourceSelfMethod_withContext ctx) {
if (ctx.getChildCount() == 4) {
- final String argument1 = (String)(GenericLiteralVisitor.instance().visitStringBasedLiteral(
- (GremlinParser.StringBasedLiteralContext)(ctx.getChild(childIndexOfParameterKey))));
- return source.with(argument1);
+ return source.with(antlr.argumentVisitor.parseString(ctx.stringArgument()));
} else {
- final int childIndexOfParameterInitialValue = 4;
-
- final String argument1 = (String)(GenericLiteralVisitor.instance().visitStringBasedLiteral(
- (GremlinParser.StringBasedLiteralContext)(ctx.getChild(childIndexOfParameterKey))));
- final Object argument2 = GenericLiteralVisitor.instance().visitGenericLiteral(
- (GremlinParser.GenericLiteralContext)(ctx.getChild(childIndexOfParameterInitialValue)));
- return source.with(argument1, argument2);
+ return source.with(antlr.argumentVisitor.parseString(ctx.stringArgument()),
+ antlr.argumentVisitor.visitGenericLiteralArgument(ctx.genericLiteralArgument()));
}
}
}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java
index de890a0c5f..2227635f80 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java
@@ -56,8 +56,8 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_addE(final GremlinParser.TraversalSourceSpawnMethod_addEContext ctx) {
- if (ctx.stringBasedLiteral() != null) {
- return this.traversalSource.addE(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ if (ctx.stringArgument() != null) {
+ return this.traversalSource.addE(antlr.argumentVisitor.parseString(ctx.stringArgument()));
} else if (ctx.nestedTraversal() != null) {
return this.traversalSource.addE(anonymousVisitor.visitNestedTraversal(ctx.nestedTraversal()));
} else {
@@ -70,8 +70,8 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_addV(final GremlinParser.TraversalSourceSpawnMethod_addVContext ctx) {
- if (ctx.stringBasedLiteral() != null) {
- return this.traversalSource.addV(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ if (ctx.stringArgument() != null) {
+ return this.traversalSource.addV(antlr.argumentVisitor.parseString(ctx.stringArgument()));
} else if (ctx.nestedTraversal() != null) {
return this.traversalSource.addV(anonymousVisitor.visitNestedTraversal(ctx.nestedTraversal()));
} else {
@@ -84,11 +84,7 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_E(final GremlinParser.TraversalSourceSpawnMethod_EContext ctx) {
- if (ctx.genericLiteralList().getChildCount() > 0) {
- return this.traversalSource.E(GenericLiteralVisitor.getGenericLiteralList(ctx.genericLiteralList()));
- } else {
- return this.traversalSource.E();
- }
+ return this.traversalSource.E(antlr.genericVisitor.parseObjectVarargs(ctx.genericLiteralVarargs()));
}
/**
@@ -96,11 +92,7 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_V(final GremlinParser.TraversalSourceSpawnMethod_VContext ctx) {
- if (ctx.genericLiteralList().getChildCount() > 0) {
- return this.traversalSource.V(GenericLiteralVisitor.getGenericLiteralList(ctx.genericLiteralList()));
- } else {
- return this.traversalSource.V();
- }
+ return this.traversalSource.V(antlr.genericVisitor.parseObjectVarargs(ctx.genericLiteralVarargs()));
}
/**
@@ -108,7 +100,7 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_inject(final GremlinParser.TraversalSourceSpawnMethod_injectContext ctx) {
- return this.traversalSource.inject(GenericLiteralVisitor.getGenericLiteralList(ctx.genericLiteralList()));
+ return this.traversalSource.inject(antlr.genericVisitor.parseObjectVarargs(ctx.genericLiteralVarargs()));
}
/**
@@ -117,7 +109,7 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_io(final GremlinParser.TraversalSourceSpawnMethod_ioContext ctx) {
if (ctx.getChildCount() > 2) {
- this.graphTraversal = this.traversalSource.io(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ this.graphTraversal = this.traversalSource.io(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
return graphTraversal;
}
@@ -127,10 +119,7 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_mergeV_Map(final GremlinParser.TraversalSourceSpawnMethod_mergeV_MapContext ctx) {
- if (ctx.nullLiteral() != null) {
- return this.traversalSource.mergeV((Map) null);
- }
- return this.traversalSource.mergeV(GenericLiteralVisitor.getMapLiteral(ctx.genericLiteralMap()));
+ return this.traversalSource.mergeV(antlr.argumentVisitor.parseMap(ctx.genericLiteralMapNullableArgument()));
}
/**
@@ -154,10 +143,7 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_mergeE_Map(final GremlinParser.TraversalSourceSpawnMethod_mergeE_MapContext ctx) {
- if (ctx.nullLiteral() != null) {
- return this.traversalSource.mergeE((Map) null);
- }
- return this.traversalSource.mergeE(GenericLiteralVisitor.getMapLiteral(ctx.genericLiteralMap()));
+ return this.traversalSource.mergeE(antlr.argumentVisitor.parseMap(ctx.genericLiteralMapNullableArgument()));
}
/**
@@ -173,7 +159,7 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_call_string(final GremlinParser.TraversalSourceSpawnMethod_call_stringContext ctx) {
- return this.traversalSource.call(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ return this.traversalSource.call(antlr.argumentVisitor.parseString(ctx.stringArgument()));
}
/**
@@ -181,8 +167,8 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_call_string_map(final GremlinParser.TraversalSourceSpawnMethod_call_string_mapContext ctx) {
- return this.traversalSource.call(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- GenericLiteralVisitor.getMapLiteral(ctx.genericLiteralMap()));
+ return this.traversalSource.call(antlr.argumentVisitor.parseString(ctx.stringArgument()),
+ antlr.argumentVisitor.parseMap(ctx.genericLiteralMapArgument()));
}
/**
@@ -190,7 +176,7 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_call_string_traversal(final GremlinParser.TraversalSourceSpawnMethod_call_string_traversalContext ctx) {
- return this.traversalSource.call(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
+ return this.traversalSource.call(antlr.argumentVisitor.parseString(ctx.stringArgument()),
anonymousVisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
@@ -199,8 +185,8 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
*/
@Override
public GraphTraversal visitTraversalSourceSpawnMethod_call_string_map_traversal(final GremlinParser.TraversalSourceSpawnMethod_call_string_map_traversalContext ctx) {
- return this.traversalSource.call(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()),
- GenericLiteralVisitor.getMapLiteral(ctx.genericLiteralMap()),
+ return this.traversalSource.call(antlr.argumentVisitor.parseString(ctx.stringArgument()),
+ antlr.argumentVisitor.parseMap(ctx.genericLiteralMapArgument()),
anonymousVisitor.visitNestedTraversal(ctx.nestedTraversal()));
}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalStrategyVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalStrategyVisitor.java
index 4d498b8ced..7fd04974f5 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalStrategyVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalStrategyVisitor.java
@@ -18,7 +18,6 @@
*/
package org.apache.tinkerpop.gremlin.language.grammar;
-import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.PartitionStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategy;
@@ -34,10 +33,10 @@ import java.util.HashSet;
import java.util.List;
public class TraversalStrategyVisitor extends DefaultGremlinBaseVisitor<TraversalStrategy> {
- protected final DefaultGremlinBaseVisitor<Traversal> tvisitor;
+ protected final GremlinAntlrToJava antlr;
- public TraversalStrategyVisitor(final DefaultGremlinBaseVisitor<Traversal> tvisitor) {
- this.tvisitor = tvisitor;
+ public TraversalStrategyVisitor(final GremlinAntlrToJava antlrToJava) {
+ this.antlr = antlrToJava;
}
@Override
@@ -61,14 +60,14 @@ public class TraversalStrategyVisitor extends DefaultGremlinBaseVisitor<Traversa
else if (strategyName.equals(SubgraphStrategy.class.getSimpleName()))
return getSubgraphStrategy(ctx.traversalStrategyArgs_SubgraphStrategy());
else if (strategyName.equals(SeedStrategy.class.getSimpleName()))
- return new SeedStrategy(Long.parseLong(ctx.integerLiteral().getText()));
+ return new SeedStrategy(antlr.argumentVisitor.parseNumber(ctx.integerArgument()).longValue());
else if (strategyName.equals(ProductiveByStrategy.class.getSimpleName()))
return getProductiveByStrategy(ctx.traversalStrategyArgs_ProductiveByStrategy());
}
throw new IllegalStateException("Unexpected TraversalStrategy specification - " + ctx.getText());
}
- private static EdgeLabelVerificationStrategy getEdgeLabelVerificationStrategy(final List<GremlinParser.TraversalStrategyArgs_EdgeLabelVerificationStrategyContext> ctxs) {
+ private EdgeLabelVerificationStrategy getEdgeLabelVerificationStrategy(final List<GremlinParser.TraversalStrategyArgs_EdgeLabelVerificationStrategyContext> ctxs) {
if (null == ctxs || ctxs.isEmpty())
return EdgeLabelVerificationStrategy.build().create();
@@ -76,10 +75,10 @@ public class TraversalStrategyVisitor extends DefaultGremlinBaseVisitor<Traversa
ctxs.forEach(ctx -> {
switch (ctx.getChild(0).getText()) {
case AbstractWarningVerificationStrategy.LOG_WARNING:
- builder.logWarning(GenericLiteralVisitor.getBooleanLiteral(ctx.booleanLiteral()));
+ builder.logWarning(antlr.argumentVisitor.parseBoolean(ctx.booleanArgument()));
break;
case AbstractWarningVerificationStrategy.THROW_EXCEPTION:
- builder.throwException(GenericLiteralVisitor.getBooleanLiteral(ctx.booleanLiteral()));
+ builder.throwException(antlr.argumentVisitor.parseBoolean(ctx.booleanArgument()));
break;
}
});
@@ -87,7 +86,7 @@ public class TraversalStrategyVisitor extends DefaultGremlinBaseVisitor<Traversa
return builder.create();
}
- private static ReservedKeysVerificationStrategy getReservedKeysVerificationStrategy(final List<GremlinParser.TraversalStrategyArgs_ReservedKeysVerificationStrategyContext> ctxs) {
+ private ReservedKeysVerificationStrategy getReservedKeysVerificationStrategy(final List<GremlinParser.TraversalStrategyArgs_ReservedKeysVerificationStrategyContext> ctxs) {
if (null == ctxs || ctxs.isEmpty())
return ReservedKeysVerificationStrategy.build().create();
@@ -95,13 +94,13 @@ public class TraversalStrategyVisitor extends DefaultGremlinBaseVisitor<Traversa
ctxs.forEach(ctx -> {
switch (ctx.getChild(0).getText()) {
case AbstractWarningVerificationStrategy.LOG_WARNING:
- builder.logWarning(GenericLiteralVisitor.getBooleanLiteral(ctx.booleanLiteral()));
+ builder.logWarning(antlr.argumentVisitor.parseBoolean(ctx.booleanArgument()));
break;
case AbstractWarningVerificationStrategy.THROW_EXCEPTION:
- builder.throwException(GenericLiteralVisitor.getBooleanLiteral(ctx.booleanLiteral()));
+ builder.throwException(antlr.argumentVisitor.parseBoolean(ctx.booleanArgument()));
break;
case ReservedKeysVerificationStrategy.KEYS:
- builder.reservedKeys(new HashSet<>(Arrays.asList(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList()))));
+ builder.reservedKeys(new HashSet<>(Arrays.asList(antlr.genericVisitor.parseStringList(ctx.stringLiteralList()))));
break;
}
});
@@ -109,21 +108,21 @@ public class TraversalStrategyVisitor extends DefaultGremlinBaseVisitor<Traversa
return builder.create();
}
- private static PartitionStrategy getPartitionStrategy(final List<GremlinParser.TraversalStrategyArgs_PartitionStrategyContext> ctxs) {
+ private PartitionStrategy getPartitionStrategy(final List<GremlinParser.TraversalStrategyArgs_PartitionStrategyContext> ctxs) {
final PartitionStrategy.Builder builder = PartitionStrategy.build();
ctxs.forEach(ctx -> {
switch (ctx.getChild(0).getText()) {
case PartitionStrategy.INCLUDE_META_PROPERTIES:
- builder.includeMetaProperties(GenericLiteralVisitor.getBooleanLiteral(ctx.booleanLiteral()));
+ builder.includeMetaProperties(antlr.argumentVisitor.parseBoolean(ctx.booleanArgument()));
break;
case PartitionStrategy.READ_PARTITIONS:
- builder.readPartitions(Arrays.asList(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList())));
+ builder.readPartitions(Arrays.asList(antlr.genericVisitor.parseStringList(ctx.stringLiteralList())));
break;
case PartitionStrategy.WRITE_PARTITION:
- builder.writePartition(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ builder.writePartition(antlr.argumentVisitor.parseString(ctx.stringArgument()));
break;
case PartitionStrategy.PARTITION_KEY:
- builder.partitionKey(GenericLiteralVisitor.getStringLiteral(ctx.stringBasedLiteral()));
+ builder.partitionKey(antlr.argumentVisitor.parseString(ctx.stringArgument()));
break;
}
});
@@ -136,16 +135,16 @@ public class TraversalStrategyVisitor extends DefaultGremlinBaseVisitor<Traversa
ctxs.forEach(ctx -> {
switch (ctx.getChild(0).getText()) {
case SubgraphStrategy.VERTICES:
- builder.vertices(tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
+ builder.vertices(antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
break;
case SubgraphStrategy.EDGES:
- builder.edges(tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
+ builder.edges(antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
break;
case SubgraphStrategy.VERTEX_PROPERTIES:
- builder.vertexProperties(tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
+ builder.vertexProperties(antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
break;
case SubgraphStrategy.CHECK_ADJACENT_VERTICES:
- builder.checkAdjacentVertices(GenericLiteralVisitor.getBooleanLiteral(ctx.booleanLiteral()));
+ builder.checkAdjacentVertices(antlr.argumentVisitor.parseBoolean(ctx.booleanArgument()));
break;
}
});
@@ -153,9 +152,9 @@ public class TraversalStrategyVisitor extends DefaultGremlinBaseVisitor<Traversa
return builder.create();
}
- private static ProductiveByStrategy getProductiveByStrategy(final GremlinParser.TraversalStrategyArgs_ProductiveByStrategyContext ctx) {
+ private ProductiveByStrategy getProductiveByStrategy(final GremlinParser.TraversalStrategyArgs_ProductiveByStrategyContext ctx) {
final ProductiveByStrategy.Builder builder = ProductiveByStrategy.build();
- builder.productiveKeys(Arrays.asList(GenericLiteralVisitor.getStringLiteralList(ctx.stringLiteralList())));
+ builder.productiveKeys(Arrays.asList(antlr.genericVisitor.parseStringList(ctx.stringLiteralList())));
return builder.create();
}
}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/VariableResolver.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/VariableResolver.java
new file mode 100644
index 0000000000..45da3fae09
--- /dev/null
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/VariableResolver.java
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.language.grammar;
+
+import java.util.Map;
+import java.util.function.BiFunction;
+
+/**
+ * Resolves parameters in Gremlin to objects.
+ */
+public interface VariableResolver extends BiFunction<String, GremlinParser.VariableContext, Object> {
+
+ /**
+ * This function resolves a variable name and the given parsers context to an object.
+ */
+ @Override
+ Object apply(final String varName, final GremlinParser.VariableContext variableContext);
+
+ /**
+ * This {@link VariableResolver} implementation throws exceptions for all variable names.
+ */
+ class NoVariableResolver implements VariableResolver {
+ private static NoVariableResolver instance = new NoVariableResolver();
+
+ public static VariableResolver instance() {
+ return instance;
+ }
+
+ @Override
+ public Object apply(final String s, final GremlinParser.VariableContext variableContext) {
+ throw new VariableResolverException(String.format("No variable found for %s", s));
+ }
+ }
+
+ /**
+ * Allows for a provided variable set in the form of a {@code Map}, where the keys are variable names and the
+ * values are the parameter values to be injected into the traversal in their place.
+ */
+ class DefaultVariableResolver implements VariableResolver {
+
+ private final Map<String, Object> variables;
+
+ public DefaultVariableResolver(final Map<String, Object> variables) {
+ this.variables = variables;
+ }
+
+ @Override
+ public Object apply(final String s, final GremlinParser.VariableContext variableContext) {
+ if (!variables.containsKey(s)) {
+ throw new VariableResolverException(String.format("No variable found for %s", s));
+ }
+
+ return variables.get(s);
+ }
+ }
+}
\ No newline at end of file
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/VariableResolverException.java
similarity index 70%
copy from gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java
copy to gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/VariableResolverException.java
index b9d600dda8..dc78d03efa 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/VariableResolverException.java
@@ -18,15 +18,15 @@
*/
package org.apache.tinkerpop.gremlin.language.grammar;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-public class GremlinQueryParserTest {
+/**
+ * The exception thrown when a variable cannot be resolved for a particular parameter name.
+ */
+public class VariableResolverException extends RuntimeException {
+ public VariableResolverException(final String message) {
+ super(message);
+ }
- @Test
- public void shouldParseEmpty() {
- assertEquals("", GremlinQueryParser.parse("\"\""));
- assertEquals("", GremlinQueryParser.parse("''"));
+ public VariableResolverException(final String message, final Throwable cause) {
+ super(message, cause);
}
}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/WithOptionsVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/WithOptionsVisitor.java
new file mode 100644
index 0000000000..623dc06817
--- /dev/null
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/WithOptionsVisitor.java
@@ -0,0 +1,228 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.language.grammar;
+
+import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.PageRank;
+import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.PeerPressure;
+import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.ShortestPath;
+import org.apache.tinkerpop.gremlin.process.traversal.IO;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.WithOptions;
+
+/**
+ * Covers {@code String} oriented constants used as arguments to {@link GraphTraversal#with(String)} steps.
+ */
+public class WithOptionsVisitor extends DefaultGremlinBaseVisitor<Object> {
+
+ private WithOptionsVisitor() {}
+
+ private static WithOptionsVisitor instance;
+
+ public static WithOptionsVisitor instance() {
+ if (instance == null) {
+ instance = new WithOptionsVisitor();
+ }
+ return instance;
+ }
+
+ @Override
+ public Object visitConnectedComponentConstants(GremlinParser.ConnectedComponentConstantsContext ctx) {
+ return visitChildren(ctx);
+ }
+
+ @Override
+ public Object visitWithOptionKeys(GremlinParser.WithOptionKeysContext ctx) {
+ return visitChildren(ctx);
+ }
+
+ @Override
+ public Object visitPageRankConstants(GremlinParser.PageRankConstantsContext ctx) {
+ return visitChildren(ctx);
+ }
+
+ @Override
+ public Object visitPeerPressureConstants(GremlinParser.PeerPressureConstantsContext ctx) {
+ return visitChildren(ctx);
+ }
+
+ @Override
+ public Object visitShortestPathConstants(GremlinParser.ShortestPathConstantsContext ctx) {
+ return visitChildren(ctx);
+ }
+
+ @Override
+ public Object visitWithOptionsValues(GremlinParser.WithOptionsValuesContext ctx) {
+ return visitChildren(ctx);
+ }
+
+ @Override
+ public Object visitIoOptionsKeys(GremlinParser.IoOptionsKeysContext ctx) {
+ return visitChildren(ctx);
+ }
+
+ @Override
+ public Object visitIoOptionsValues(GremlinParser.IoOptionsValuesContext ctx) {
+ return visitChildren(ctx);
+ }
+
+ @Override
+ public Object visitConnectedComponentConstants_component(GremlinParser.ConnectedComponentConstants_componentContext ctx) {
+ return super.visitConnectedComponentConstants_component(ctx);
+ }
+
+ @Override
+ public Object visitConnectedComponentConstants_edges(GremlinParser.ConnectedComponentConstants_edgesContext ctx) {
+ return super.visitConnectedComponentConstants_edges(ctx);
+ }
+
+ @Override
+ public Object visitConnectedComponentConstants_propertyName(GremlinParser.ConnectedComponentConstants_propertyNameContext ctx) {
+ return super.visitConnectedComponentConstants_propertyName(ctx);
+ }
+
+ @Override
+ public Object visitPageRankConstants_edges(final GremlinParser.PageRankConstants_edgesContext ctx) {
+ return PageRank.edges;
+ }
+
+ @Override
+ public Object visitPageRankConstants_times(final GremlinParser.PageRankConstants_timesContext ctx) {
+ return PageRank.times;
+ }
+
+ @Override
+ public Object visitPageRankConstants_propertyName(final GremlinParser.PageRankConstants_propertyNameContext ctx) {
+ return PageRank.propertyName;
+ }
+
+ @Override
+ public Object visitPeerPressureConstants_edges(final GremlinParser.PeerPressureConstants_edgesContext ctx) {
+ return PeerPressure.edges;
+ }
+
+ @Override
+ public Object visitPeerPressureConstants_times(final GremlinParser.PeerPressureConstants_timesContext ctx) {
+ return PeerPressure.times;
+ }
+
+ @Override
+ public Object visitPeerPressureConstants_propertyName(final GremlinParser.PeerPressureConstants_propertyNameContext ctx) {
+ return PeerPressure.propertyName;
+ }
+
+ @Override
+ public Object visitShortestPathConstants_target(final GremlinParser.ShortestPathConstants_targetContext ctx) {
+ return ShortestPath.target;
+ }
+
+ @Override
+ public Object visitShortestPathConstants_edges(final GremlinParser.ShortestPathConstants_edgesContext ctx) {
+ return ShortestPath.edges;
+ }
+
+ @Override
+ public Object visitShortestPathConstants_distance(final GremlinParser.ShortestPathConstants_distanceContext ctx) {
+ return ShortestPath.distance;
+ }
+
+ @Override
+ public Object visitShortestPathConstants_maxDistance(final GremlinParser.ShortestPathConstants_maxDistanceContext ctx) {
+ return ShortestPath.maxDistance;
+ }
+
+ @Override
+ public Object visitShortestPathConstants_includeEdges(final GremlinParser.ShortestPathConstants_includeEdgesContext ctx) {
+ return ShortestPath.includeEdges;
+ }
+
+ @Override
+ public Object visitWithOptionsConstants_tokens(final GremlinParser.WithOptionsConstants_tokensContext ctx) {
+ return WithOptions.tokens;
+ }
+
+ @Override
+ public Object visitWithOptionsConstants_none(final GremlinParser.WithOptionsConstants_noneContext ctx) {
+ return WithOptions.none;
+ }
+
+ @Override
+ public Object visitWithOptionsConstants_ids(final GremlinParser.WithOptionsConstants_idsContext ctx) {
+ return WithOptions.ids;
+ }
+
+ @Override
+ public Object visitWithOptionsConstants_labels(final GremlinParser.WithOptionsConstants_labelsContext ctx) {
+ return WithOptions.labels;
+ }
+
+ @Override
+ public Object visitWithOptionsConstants_keys(final GremlinParser.WithOptionsConstants_keysContext ctx) {
+ return WithOptions.keys;
+ }
+
+ @Override
+ public Object visitWithOptionsConstants_values(final GremlinParser.WithOptionsConstants_valuesContext ctx) {
+ return WithOptions.values;
+ }
+
+ @Override
+ public Object visitWithOptionsConstants_all(final GremlinParser.WithOptionsConstants_allContext ctx) {
+ return WithOptions.all;
+ }
+
+ @Override
+ public Object visitWithOptionsConstants_indexer(final GremlinParser.WithOptionsConstants_indexerContext ctx) {
+ return WithOptions.indexer;
+ }
+
+ @Override
+ public Object visitWithOptionsConstants_list(final GremlinParser.WithOptionsConstants_listContext ctx) {
+ return WithOptions.list;
+ }
+
+ @Override
+ public Object visitWithOptionsConstants_map(final GremlinParser.WithOptionsConstants_mapContext ctx) {
+ return WithOptions.map;
+ }
+
+ @Override
+ public Object visitIoOptionsConstants_reader(final GremlinParser.IoOptionsConstants_readerContext ctx) {
+ return IO.reader;
+ }
+
+ @Override
+ public Object visitIoOptionsConstants_writer(final GremlinParser.IoOptionsConstants_writerContext ctx) {
+ return IO.writer;
+ }
+
+ @Override
+ public Object visitIoOptionsConstants_gryo(final GremlinParser.IoOptionsConstants_gryoContext ctx) {
+ return IO.gryo;
+ }
+
+ @Override
+ public Object visitIoOptionsConstants_graphson(final GremlinParser.IoOptionsConstants_graphsonContext ctx) {
+ return IO.graphson;
+ }
+
+ @Override
+ public Object visitIoOptionsConstants_graphml(final GremlinParser.IoOptionsConstants_graphmlContext ctx) {
+ return IO.graphml;
+ }
+}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/util/function/ThrowingBiFunction.java
similarity index 70%
copy from gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java
copy to gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/util/function/ThrowingBiFunction.java
index b9d600dda8..30bcf02e7e 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/util/function/ThrowingBiFunction.java
@@ -16,17 +16,12 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.apache.tinkerpop.gremlin.language.grammar;
+package org.apache.tinkerpop.gremlin.util.function;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-public class GremlinQueryParserTest {
-
- @Test
- public void shouldParseEmpty() {
- assertEquals("", GremlinQueryParser.parse("\"\""));
- assertEquals("", GremlinQueryParser.parse("''"));
- }
+/**
+ * @author Stephen Mallette (http://stephen.genoprime.com)
+ */
+@FunctionalInterface
+public interface ThrowingBiFunction<T, U, R> {
+ R apply(final T t, final U u) throws Exception;
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/jsr223/GremlinLangScriptEngineTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/jsr223/GremlinLangScriptEngineTest.java
index aa4d714850..d442f527e6 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/jsr223/GremlinLangScriptEngineTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/jsr223/GremlinLangScriptEngineTest.java
@@ -25,6 +25,10 @@ import org.junit.Test;
import javax.script.Bindings;
import javax.script.ScriptException;
+import javax.script.SimpleBindings;
+
+import java.util.HashMap;
+import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsInstanceOf.instanceOf;
@@ -46,6 +50,19 @@ public class GremlinLangScriptEngineTest {
assertEquals(g.V().asAdmin().getBytecode(), ((Traversal.Admin) result).getBytecode());
}
+ @Test
+ public void shouldEvalGremlinScriptWithParameters() throws ScriptException {
+ final Bindings b = new SimpleBindings();
+ b.put("g", g);
+ b.put("x", 100);
+ b.put("y", 1000);
+ b.put("z", 10000);
+
+ final Object result = scriptEngine.eval("g.V(x, y, z)", b);
+ assertThat(result, instanceOf(Traversal.Admin.class));
+ assertEquals(g.V(100, 1000, 10000).asAdmin().getBytecode(), ((Traversal.Admin) result).getBytecode());
+ }
+
@Test
public void shouldEvalGremlinBytecode() throws ScriptException {
final Object result = scriptEngine.eval(g.V().asAdmin().getBytecode(), "g");
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitorTest.java
new file mode 100644
index 0000000000..1f99b75fe0
--- /dev/null
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitorTest.java
@@ -0,0 +1,260 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.language.grammar;
+
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.apache.tinkerpop.gremlin.process.traversal.IO;
+import org.apache.tinkerpop.gremlin.process.traversal.Merge;
+import org.apache.tinkerpop.gremlin.process.traversal.Operator;
+import org.apache.tinkerpop.gremlin.process.traversal.Order;
+import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Pop;
+import org.apache.tinkerpop.gremlin.process.traversal.SackFunctions;
+import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.structure.Column;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
+import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
+import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.function.Supplier;
+
+import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.hasLabel;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+@RunWith(Parameterized.class)
+public class ArgumentVisitorTest {
+ @Parameterized.Parameter(value = 0)
+ public Class<?> clazz;
+
+ @Parameterized.Parameter(value = 1)
+ public String script;
+
+ @Parameterized.Parameter(value = 2)
+ public Object expected;
+
+ @Parameterized.Parameter(value = 3)
+ public GremlinAntlrToJava antlrToLanguage;
+
+ private static final GraphTraversalSource g = EmptyGraph.instance().traversal();
+
+ private static final Date now = new Date();
+
+ @Parameterized.Parameters(name = "{0}")
+ public static Iterable<Object[]> generateTestParameters() {
+ return Arrays.asList(new Object[][]{
+ {Boolean.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Boolean.class, "true", true, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", true)))},
+ {Boolean.class, "false", false, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", true)))},
+ {Boolean.class, "x", true, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", true)))},
+ {Integer.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Integer.class, "0", 0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100)))},
+ {Integer.class, "0i", 0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100)))},
+ {Integer.class, "0L", 0L, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100)))},
+ {Integer.class, "x", 0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 0)))},
+ {Integer.class, "x", 0L, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 0L)))},
+ {Float.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Float.class, "0.0d", 0.0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 1000.0)))},
+ {Float.class, "0d", 0.0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 1000.0)))},
+ {Float.class, "0F", 0.0F, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 1000.0F)))},
+ {Float.class, "x", 0.0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 0.0)))},
+ {Float.class, "x", 0.0F, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 0.0F)))},
+ {String.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {String.class, "'test'", "test", createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {String.class, "x", "test", createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "test")))},
+ {String.class, "x", "graphson", createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", IO.graphson)))},
+ {Object.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Object.class, "'test'", "test", createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Object.class, "x", "test", createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "test")))},
+ {Object.class, "x", now, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", now)))},
+ {Object.class, "[1,2,3]", Arrays.asList(1, 2, 3), createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", now)))},
+ {Object.class, "x", P.eq(100), createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", P.eq(100))))},
+ {Direction.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Direction.class, "Direction.OUT", Direction.OUT, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Direction.class, "OUT", Direction.OUT, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Direction.class, "x", Direction.OUT, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Direction.OUT)))},
+ {Direction.class, "x", Direction.from, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Direction.from)))},
+ {Vertex.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Vertex.class, "new Vertex(1i,'person')", new ReferenceVertex(1, "person"), createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Direction.from)))},
+ {Vertex.class, "x", new ReferenceVertex(1, "person"), createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", new ReferenceVertex(1, "person"))))},
+ {Order.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Order.class, "Order.desc", Order.desc, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Order.class, "x", Order.desc, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Order.desc)))},
+ {Scope.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Scope.class, "Scope.local", Scope.local, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Scope.class, "local", Scope.local, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Scope.class, "x", Scope.local, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Scope.local)))},
+ {T.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {T.class, "T.label", T.label, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {T.class, "label", T.label, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {T.class, "x", T.label, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", T.label)))},
+ {VertexProperty.Cardinality.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {VertexProperty.Cardinality.class, "Cardinality.list", VertexProperty.Cardinality.list, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {VertexProperty.Cardinality.class, "list", VertexProperty.Cardinality.list, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {VertexProperty.Cardinality.class, "x", VertexProperty.Cardinality.list, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", VertexProperty.Cardinality.list)))},
+ {Merge.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Merge.class, "Merge.onMatch", Merge.onMatch, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Merge.class, "onMatch", Merge.onMatch, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Merge.class, "x", Merge.onMatch, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Merge.onMatch)))},
+ {Pop.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Pop.class, "Pop.last", Pop.last, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Pop.class, "last", Pop.last, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Pop.class, "x", Pop.last, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Pop.last)))},
+ {Operator.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Operator.class, "Operator.sum", Operator.sum, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Operator.class, "sum", Operator.sum, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Operator.class, "x", Operator.sum, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Operator.sum)))},
+ {Column.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {Column.class, "Column.keys", Column.keys, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Column.class, "keys", Column.keys, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Column.class, "x", Column.keys, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Column.keys)))},
+ {SackFunctions.Barrier.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
+ {SackFunctions.Barrier.class, "Barrier.normSack", SackFunctions.Barrier.normSack, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {SackFunctions.Barrier.class, "Barrier.normSack", SackFunctions.Barrier.normSack, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {SackFunctions.Barrier.class, "x", SackFunctions.Barrier.normSack, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", SackFunctions.Barrier.normSack)))},
+ });
+ }
+
+ @Test
+ public void shouldParse() {
+ final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
+ final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
+ if (clazz.equals(Boolean.class)) {
+ assertParsing(() -> {
+ final GremlinParser.BooleanArgumentContext ctx = parser.booleanArgument();
+ return antlrToLanguage.argumentVisitor.parseBoolean(ctx);
+ });
+ } else if (clazz.equals(Integer.class)) {
+ assertParsing(() -> {
+ final GremlinParser.IntegerArgumentContext ctx = parser.integerArgument();
+ return antlrToLanguage.argumentVisitor.parseNumber(ctx);
+ });
+ } else if (clazz.equals(Float.class)) {
+ assertParsing(() -> {
+ final GremlinParser.FloatArgumentContext ctx = parser.floatArgument();
+ return antlrToLanguage.argumentVisitor.parseNumber(ctx);
+ });
+ } else if (clazz.equals(String.class)) {
+ assertParsing(() -> {
+ final GremlinParser.StringArgumentContext ctx = parser.stringArgument();
+ return antlrToLanguage.argumentVisitor.parseString(ctx);
+ });
+ } else if (clazz.equals(Object.class)) {
+ assertParsing(() -> {
+ final GremlinParser.GenericLiteralArgumentContext ctx = parser.genericLiteralArgument();
+ return antlrToLanguage.argumentVisitor.parseObject(ctx);
+ });
+ } else if (clazz.equals(List.class)) {
+ assertParsing(() -> {
+ final GremlinParser.GenericLiteralListArgumentContext ctx = parser.genericLiteralListArgument();
+ return antlrToLanguage.argumentVisitor.parseObjectVarargs(ctx);
+ });
+ } else if (clazz.equals(Direction.class)) {
+ assertParsing(() -> {
+ final GremlinParser.TraversalDirectionArgumentContext ctx = parser.traversalDirectionArgument();
+ return antlrToLanguage.argumentVisitor.parseDirection(ctx);
+ });
+ } else if (clazz.equals(Vertex.class)) {
+ assertParsing(() -> {
+ final GremlinParser.StructureVertexArgumentContext ctx = parser.structureVertexArgument();
+ return antlrToLanguage.argumentVisitor.parseVertex(ctx);
+ });
+ } else if (clazz.equals(Order.class)) {
+ assertParsing(() -> {
+ final GremlinParser.TraversalOrderArgumentContext ctx = parser.traversalOrderArgument();
+ return antlrToLanguage.argumentVisitor.parseOrder(ctx);
+ });
+ } else if (clazz.equals(Scope.class)) {
+ assertParsing(() -> {
+ final GremlinParser.TraversalScopeArgumentContext ctx = parser.traversalScopeArgument();
+ return antlrToLanguage.argumentVisitor.parseScope(ctx);
+ });
+ } else if (clazz.equals(T.class)) {
+ assertParsing(() -> {
+ final GremlinParser.TraversalTokenArgumentContext ctx = parser.traversalTokenArgument();
+ return antlrToLanguage.argumentVisitor.parseT(ctx);
+ });
+ } else if (clazz.equals(VertexProperty.Cardinality.class)) {
+ assertParsing(() -> {
+ final GremlinParser.TraversalCardinalityArgumentContext ctx = parser.traversalCardinalityArgument();
+ return antlrToLanguage.argumentVisitor.parseCardinality(ctx);
+ });
+ } else if (clazz.equals(Merge.class)) {
+ assertParsing(() -> {
+ final GremlinParser.TraversalMergeArgumentContext ctx = parser.traversalMergeArgument();
+ return antlrToLanguage.argumentVisitor.parseMerge(ctx);
+ });
+ } else if (clazz.equals(Pop.class)) {
+ assertParsing(() -> {
+ final GremlinParser.TraversalPopArgumentContext ctx = parser.traversalPopArgument();
+ return antlrToLanguage.argumentVisitor.parsePop(ctx);
+ });
+ } else if (clazz.equals(Operator.class)) {
+ assertParsing(() -> {
+ final GremlinParser.TraversalBiFunctionArgumentContext ctx = parser.traversalBiFunctionArgument();
+ return antlrToLanguage.argumentVisitor.visitTraversalBiFunctionArgument(ctx);
+ });
+ } else if (clazz.equals(Column.class)) {
+ assertParsing(() -> {
+ final GremlinParser.TraversalColumnArgumentContext ctx = parser.traversalColumnArgument();
+ return antlrToLanguage.argumentVisitor.parseColumn(ctx);
+ });
+ } else if (clazz.equals(SackFunctions.Barrier.class)) {
+ assertParsing(() -> {
+ final GremlinParser.TraversalSackMethodArgumentContext ctx = parser.traversalSackMethodArgument();
+ return antlrToLanguage.argumentVisitor.visitTraversalSackMethodArgument(ctx);
+ });
+ } else {
+ fail("Missing an assertion type");
+ }
+ }
+
+ private void assertParsing(final Supplier<Object> visit) {
+ try {
+ final Object o = visit.get();
+ if (expected instanceof VariableResolverException)
+ fail(String.format("Should have failed with %s", VariableResolverException.class.getSimpleName()));
+ else
+ assertEquals(expected, o);
+ } catch (Exception ex) {
+ assertThat(ex, instanceOf(VariableResolverException.class));
+ }
+ }
+
+ private static GremlinAntlrToJava createAntlr(final VariableResolver resolver) {
+ return new GremlinAntlrToJava("g", EmptyGraph.instance(), __::start, g, resolver);
+ }
+}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ComplexTraversalMethodVisitorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ComplexTraversalMethodVisitorTest.java
index 32ba811cd1..9bf9a68156 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ComplexTraversalMethodVisitorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ComplexTraversalMethodVisitorTest.java
@@ -71,7 +71,7 @@ public class ComplexTraversalMethodVisitorTest {
}
@Test
- public void testNestedGraphTraversal() {
+ public void shouldParseNestedGraphTraversal() {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.QueryContext ctx = parser.query();
@@ -104,7 +104,7 @@ public class ComplexTraversalMethodVisitorTest {
}
@Test
- public void testChainedGraphTraversal() {
+ public void shouldParseChainedGraphTraversal() {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.QueryContext ctx = parser.query();
@@ -137,7 +137,7 @@ public class ComplexTraversalMethodVisitorTest {
}
@Test
- public void testTerminatedGraphTraversal() {
+ public void shouldParseTerminatedGraphTraversal() {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.QueryContext ctx = parser.query();
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GeneralLiteralVisitorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GeneralLiteralVisitorTest.java
index 1350b03202..b4da7f146f 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GeneralLiteralVisitorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GeneralLiteralVisitorTest.java
@@ -43,6 +43,7 @@ import static org.hamcrest.number.OrderingComparison.greaterThanOrEqualTo;
import static org.hamcrest.number.OrderingComparison.lessThan;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
/**
* Generic Literal visitor test
@@ -54,7 +55,7 @@ public class GeneralLiteralVisitorTest {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(query));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.GenericLiteralRangeContext ctx = parser.genericLiteralRange();
- return GenericLiteralVisitor.instance().visitGenericLiteralRange(ctx);
+ return new GenericLiteralVisitor(new GremlinAntlrToJava()).visitGenericLiteralRange(ctx);
}
@RunWith(Parameterized.class)
@@ -237,12 +238,12 @@ public class GeneralLiteralVisitorTest {
public void shouldParse() {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
- final GremlinParser.StringBasedLiteralContext ctx = parser.stringBasedLiteral();
+ final GremlinParser.StringLiteralContext ctx = parser.stringLiteral();
if (expected.equals("Empty")) {
// handle special case for Empty string
- assertEquals("", GenericLiteralVisitor.instance().visitStringBasedLiteral(ctx));
+ assertEquals("", new GenericLiteralVisitor(new GremlinAntlrToJava()).visitStringLiteral(ctx));
} else {
- assertEquals(expected, GenericLiteralVisitor.instance().visitStringBasedLiteral(ctx));
+ assertEquals(expected, new GenericLiteralVisitor(new GremlinAntlrToJava()).visitStringLiteral(ctx));
}
}
}
@@ -281,8 +282,8 @@ public class GeneralLiteralVisitorTest {
final String stringLiteral = quoteCharacter + inputChars + quoteCharacter;
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(stringLiteral));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
- final GremlinParser.StringBasedLiteralContext ctx = parser.stringBasedLiteral();
- assertEquals(expectedOutputChars, GenericLiteralVisitor.instance().visitStringBasedLiteral(ctx));
+ final GremlinParser.StringLiteralContext ctx = parser.stringLiteral();
+ assertEquals(expectedOutputChars, new GenericLiteralVisitor(new GremlinAntlrToJava()).visitStringLiteral(ctx));
}
}
@@ -349,7 +350,7 @@ public class GeneralLiteralVisitorTest {
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.IntegerLiteralContext ctx = parser.integerLiteral();
- final Object actualValue = GenericLiteralVisitor.instance().visitIntegerLiteral(ctx);
+ final Object actualValue = new GenericLiteralVisitor(new GremlinAntlrToJava()).visitIntegerLiteral(ctx);
assertEquals(expected, actualValue);
}
}
@@ -386,7 +387,7 @@ public class GeneralLiteralVisitorTest {
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.IntegerLiteralContext ctx = parser.integerLiteral();
- assertEquals(new BigInteger(expected, radix), GenericLiteralVisitor.instance().visitIntegerLiteral(ctx));
+ assertEquals(new BigInteger(expected, radix), new GenericLiteralVisitor(new GremlinAntlrToJava()).visitIntegerLiteral(ctx));
}
}
@@ -437,7 +438,7 @@ public class GeneralLiteralVisitorTest {
final Constructor<?> ctor = clazz.getConstructor(String.class);
final Object expectedValue = ctor.newInstance(expected);
- assertEquals(expectedValue, GenericLiteralVisitor.instance().visitFloatLiteral(ctx));
+ assertEquals(expectedValue, new GenericLiteralVisitor(new GremlinAntlrToJava()).visitFloatLiteral(ctx));
}
}
@@ -475,7 +476,7 @@ public class GeneralLiteralVisitorTest {
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.DateLiteralContext ctx = parser.dateLiteral();
- final Date dt = (Date) GenericLiteralVisitor.instance().visitDateLiteral(ctx);
+ final Date dt = (Date) new GenericLiteralVisitor(new GremlinAntlrToJava()).visitDateLiteral(ctx);
assertEquals(expected, dt);
}
}
@@ -502,7 +503,7 @@ public class GeneralLiteralVisitorTest {
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.BooleanLiteralContext ctx = parser.booleanLiteral();
- assertEquals(expected, GenericLiteralVisitor.instance().visitBooleanLiteral(ctx));
+ assertEquals(expected, new GenericLiteralVisitor(new GremlinAntlrToJava()).visitBooleanLiteral(ctx));
}
}
@@ -543,7 +544,7 @@ public class GeneralLiteralVisitorTest {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.GenericLiteralContext ctx = parser.genericLiteral();
- final Object genericLiteral = GenericLiteralVisitor.instance().visitGenericLiteral(ctx);
+ final Object genericLiteral = new GenericLiteralVisitor(new GremlinAntlrToJava()).visitGenericLiteral(ctx);
// verify type is Map
assertThat(genericLiteral, instanceOf(Map.class));
@@ -557,11 +558,11 @@ public class GeneralLiteralVisitorTest {
public static class ValidListLiteralTest {
@Test
- public void testGenericLiteralCollection() {
+ public void shouldParseGenericLiteralCollection() {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString("['world', 165, [12L, 0xA, 14.5, \"hello\"]]"));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.GenericLiteralContext ctx = parser.genericLiteral();
- final Object genericLiteral = GenericLiteralVisitor.instance().visitGenericLiteral(ctx);
+ final Object genericLiteral = new GenericLiteralVisitor(new GremlinAntlrToJava()).visitGenericLiteral(ctx);
// verify type is Object[]
assertThat(genericLiteral, instanceOf(List.class));
@@ -600,11 +601,11 @@ public class GeneralLiteralVisitorTest {
* Generic literal collection test
*/
@Test
- public void testEmptyGenericLiteralCollection() {
+ public void shouldParseEmptyGenericLiteralCollection() {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString("[]"));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.GenericLiteralContext ctx = parser.genericLiteral();
- final Object genericLiteral = GenericLiteralVisitor.instance().visitGenericLiteral(ctx);
+ final Object genericLiteral = new GenericLiteralVisitor(new GremlinAntlrToJava()).visitGenericLiteral(ctx);
// verify type is Object[]
assertThat(genericLiteral, instanceOf(List.class));
@@ -618,59 +619,59 @@ public class GeneralLiteralVisitorTest {
public static class NullNaNInfTest {
@Test
- public void testNull() {
+ public void shouldParseNull() {
final String script = "null";
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.NullLiteralContext ctx = parser.nullLiteral();
- assertEquals(null, GenericLiteralVisitor.instance().visitNullLiteral(ctx));
+ assertEquals(null, new GenericLiteralVisitor(new GremlinAntlrToJava()).visitNullLiteral(ctx));
}
@Test
- public void testNaN() {
+ public void shouldParseNaN() {
final String script = "NaN";
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.NanLiteralContext ctx = parser.nanLiteral();
- final Object o = GenericLiteralVisitor.instance().visitNanLiteral(ctx);
+ final Object o = new GenericLiteralVisitor(new GremlinAntlrToJava()).visitNanLiteral(ctx);
assertTrue(o instanceof Double);
assertTrue(Double.isNaN((double) o));
}
@Test
- public void testInf() {
+ public void shouldParseInf() {
final String script = "Infinity";
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.InfLiteralContext ctx = parser.infLiteral();
- assertEquals(Double.POSITIVE_INFINITY, GenericLiteralVisitor.instance().visitInfLiteral(ctx));
+ assertEquals(Double.POSITIVE_INFINITY, new GenericLiteralVisitor(new GremlinAntlrToJava()).visitInfLiteral(ctx));
}
@Test
- public void testPosInf() {
+ public void shouldParsePosInf() {
final String script = "+Infinity";
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.InfLiteralContext ctx = parser.infLiteral();
- assertEquals(Double.POSITIVE_INFINITY, GenericLiteralVisitor.instance().visitInfLiteral(ctx));
+ assertEquals(Double.POSITIVE_INFINITY, new GenericLiteralVisitor(new GremlinAntlrToJava()).visitInfLiteral(ctx));
}
@Test
- public void testNegInf() {
+ public void shouldParseNegInf() {
final String script = "-Infinity";
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.InfLiteralContext ctx = parser.infLiteral();
- assertEquals(Double.NEGATIVE_INFINITY, GenericLiteralVisitor.instance().visitInfLiteral(ctx));
+ assertEquals(Double.NEGATIVE_INFINITY, new GenericLiteralVisitor(new GremlinAntlrToJava()).visitInfLiteral(ctx));
}
}
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java
index b9d600dda8..b4efa59796 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java
@@ -18,15 +18,77 @@
*/
package org.apache.tinkerpop.gremlin.language.grammar;
+import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
+import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
+import org.junit.Ignore;
import org.junit.Test;
+import java.util.Arrays;
+
import static org.junit.Assert.assertEquals;
public class GremlinQueryParserTest {
+ private static final GraphTraversalSource g = EmptyGraph.instance().traversal();
@Test
public void shouldParseEmpty() {
assertEquals("", GremlinQueryParser.parse("\"\""));
assertEquals("", GremlinQueryParser.parse("''"));
}
+
+ @Test
+ public void shouldParseVariables() {
+ final GremlinAntlrToJava gremlinAntlrToJava = new GremlinAntlrToJava("g",
+ EmptyGraph.instance(), __::start, g,
+ new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("z", 50)));
+ final GraphTraversal<?, ?> t = (GraphTraversal<?, ?>) GremlinQueryParser.parse("g.V().has('name',gt(z))", gremlinAntlrToJava);
+
+ assertEquals(g.V().has("name", P.gt(50)).asAdmin().getBytecode(),
+ t.asAdmin().getBytecode());
+ }
+
+ @Test
+ public void shouldParseVariablesInVarargs() {
+ final GremlinAntlrToJava gremlinAntlrToJava = new GremlinAntlrToJava("g",
+ EmptyGraph.instance(), __::start, g,
+ new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100,
+ "y", 200,
+ "z", 50)));
+
+ GraphTraversal<?, ?> t = (GraphTraversal<?, ?>) GremlinQueryParser.parse("g.V().has('name',gt(z))", gremlinAntlrToJava);
+ assertEquals(g.V().has("name", P.gt(50)).asAdmin().getBytecode(),
+ t.asAdmin().getBytecode());
+
+ t = (GraphTraversal<?, ?>) GremlinQueryParser.parse("g.V(x).has('name',gt(z))", gremlinAntlrToJava);
+ assertEquals(g.V(100).has("name", P.gt(50)).asAdmin().getBytecode(),
+ t.asAdmin().getBytecode());
+
+ t = (GraphTraversal<?, ?>) GremlinQueryParser.parse("g.V(x, y, 300).has('name',gt(z))", gremlinAntlrToJava);
+ assertEquals(g.V(100, 200, 300).has("name", P.gt(50)).asAdmin().getBytecode(),
+ t.asAdmin().getBytecode());
+ }
+
+ @Test(expected = GremlinParserException.class)
+ public void shouldNotParseVariablesInList() {
+ final GremlinAntlrToJava gremlinAntlrToJava = new GremlinAntlrToJava("g",
+ EmptyGraph.instance(), __::start, g,
+ new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100,
+ "y", 200,
+ "z", 50)));
+ GremlinQueryParser.parse("g.V([x, y, 300]).has('name',gt(z))", gremlinAntlrToJava);
+ }
+
+ @Test(expected = GremlinParserException.class)
+ public void shouldNotParseVariablesWhichAreTraversalBased() {
+ final GremlinAntlrToJava gremlinAntlrToJava = new GremlinAntlrToJava("g",
+ EmptyGraph.instance(), __::start, g,
+ new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100,
+ "y", 200,
+ "z", __.out())));
+ GremlinQueryParser.parse("g.V([x, y, 300]).where(z)", gremlinAntlrToJava);
+ }
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParserTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParserTest.java
index 52f0a25ddd..0f181d6793 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParserTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParserTest.java
@@ -65,7 +65,7 @@ public class TraversalEnumParserTest {
}
@Test
- public void testAllEnumTypes() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
+ public void shouldParseAllEnumTypes() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
final Class<? extends Enum> enumType = (Class<? extends Enum>) (Class.forName(className));
for (Enum enumConstant : enumType.getEnumConstants()) {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(enumConstant.name()));
@@ -98,7 +98,7 @@ public class TraversalEnumParserTest {
}
@Test
- public void testAllQualifiedEnumTypes() throws
+ public void shouldParseAllQualifiedEnumTypes() throws
ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
Class<? extends Enum> enumType = (Class<? extends Enum>) (Class.forName(className));
for (Enum enumConstant : enumType.getEnumConstants()) {
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitorTest.java
index d9a4fce879..da2833ae91 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitorTest.java
@@ -39,9 +39,7 @@ import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
import org.junit.Before;
import org.junit.Test;
-import java.util.HashMap;
import java.util.LinkedHashMap;
-import java.util.Map;
import java.util.function.Function;
import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
@@ -75,633 +73,633 @@ public class TraversalMethodVisitorTest {
}
@Test
- public void testChainedTraversal() throws Exception {
+ public void shouldParseChainedTraversal() throws Exception {
// a random chain traversal.
compare(g.V().addE("person"), eval("g.V().addE('person')"));
}
@Test
- public void testTraversalMethod_addE_String() throws Exception {
+ public void shouldParseTraversalMethod_addE_String() throws Exception {
// same with chained traversal but uses double quotes
compare(g.V().addE("person"), eval("g.V().addE(\"person\")"));
}
@Test
- public void testTraversalMethod_addE_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_addE_Traversal() throws Exception {
// same with chained traversal but uses double quotes
compare(g.V().addE(V().hasLabel("person").label()), eval("g.V().addE(V().hasLabel(\"person\").label())"));
}
@Test
- public void testTraversalMethod_addV_Empty() throws Exception {
+ public void shouldParseTraversalMethod_addV_Empty() throws Exception {
compare(g.V().addV(), eval("g.V().addV()"));
}
@Test
- public void testTraversalMethod_addV_String() throws Exception {
+ public void shouldParseTraversalMethod_addV_String() throws Exception {
compare(g.V().addV("test"), eval("g.V().addV(\"test\")"));
}
@Test
- public void testTraversalMethod_addV_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_addV_Traversal() throws Exception {
compare(g.addV(V().hasLabel("person").label()), eval("g.addV(V().hasLabel(\"person\").label())"));
}
@Test
- public void testTraversalMethod_aggregate() throws Exception {
+ public void shouldParseTraversalMethod_aggregate() throws Exception {
compare(g.V().aggregate("test"), eval("g.V().aggregate('test')"));
}
@Test
- public void testTraversalMethod_aggregate_Scope() throws Exception {
+ public void shouldParseTraversalMethod_aggregate_Scope() throws Exception {
compare(g.V().aggregate(global, "test"), eval("g.V().aggregate(global, 'test')"));
compare(g.V().aggregate(Scope.local, "test"), eval("g.V().aggregate(Scope.local, 'test')"));
}
@Test
- public void testTraversalMethod_and() throws Exception {
+ public void shouldParseTraversalMethod_and() throws Exception {
compare(g.V().and(outE("knows")), eval("g.V().and(outE('knows'))"));
}
@Test
- public void testTraversalMethod_as() throws Exception {
+ public void shouldParseTraversalMethod_as() throws Exception {
compare(g.V().as("test"), eval("g.V().as('test')"));
}
@Test
- public void testTraversalMethod_barrier_Consumer() throws Exception {
+ public void shouldParseTraversalMethod_barrier_Consumer() throws Exception {
compare(g.V().barrier(normSack), eval("g.V().barrier(normSack)"));
}
@Test
- public void testTraversalMethod_barrier_Empty() throws Exception {
+ public void shouldParseTraversalMethod_barrier_Empty() throws Exception {
compare(g.V().barrier(), eval("g.V().barrier()"));
}
@Test
- public void testTraversalMethod_barrier_int() throws Exception {
+ public void shouldParseTraversalMethod_barrier_int() throws Exception {
compare(g.V().barrier(4), eval("g.V().barrier(4)"));
}
@Test
- public void testTraversalMethod_both_Empty() throws Exception {
+ public void shouldParseTraversalMethod_both_Empty() throws Exception {
compare(g.V().both(), eval("g.V().both()"));
}
@Test
- public void testTraversalMethod_both_SingleString() throws Exception {
+ public void shouldParseTraversalMethod_both_SingleString() throws Exception {
compare(g.V().both("test"), eval("g.V().both('test')"));
}
@Test
- public void testTraversalMethod_both_MultiString() throws Exception {
+ public void shouldParseTraversalMethod_both_MultiString() throws Exception {
compare(g.V().both(new String[]{"a", "b"}), eval("g.V().both('a', 'b')"));
}
@Test
- public void testTraversalMethod_bothE() throws Exception {
+ public void shouldParseTraversalMethod_bothE() throws Exception {
compare(g.V().bothE("test"), eval("g.V().bothE('test')"));
}
@Test
- public void testTraversalMethod_bothV() throws Exception {
+ public void shouldParseTraversalMethod_bothV() throws Exception {
compare(g.V().bothV(), eval("g.V().bothV()"));
}
@Test
- public void testTraversalMethod_branch_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_branch_Traversal() throws Exception {
compare(g.V().branch(values("name")), eval("g.V().branch(values('name'))"));
}
@Test
- public void testTraversalMethod_by_Comparator() throws Exception {
+ public void shouldParseTraversalMethod_by_Comparator() throws Exception {
compare(g.V().order().by(Order.asc), eval("g.V().order().by(asc)"));
}
@Test
- public void testTraversalMethod_by_Empty() throws Exception {
+ public void shouldParseTraversalMethod_by_Empty() throws Exception {
compare(g.V().cyclicPath().by(), eval("g.V().cyclicPath().by()"));
}
@Test
- public void testTraversalMethod_by_Function() throws Exception {
+ public void shouldParseTraversalMethod_by_Function() throws Exception {
compare(g.V().order().by(T.id), eval("g.V().order().by(id)"));
}
@Test
- public void testTraversalMethod_by_Function_Comparator() throws Exception {
+ public void shouldParseTraversalMethod_by_Function_Comparator() throws Exception {
compare(g.V().order().by(Column.keys, Order.asc), eval("g.V().order().by(keys, asc)"));
}
@Test
- public void testTraversalMethod_by_Order() throws Exception {
+ public void shouldParseTraversalMethod_by_Order() throws Exception {
compare(g.V().order().by(Order.shuffle), eval("g.V().order().by(shuffle)"));
}
@Test
- public void testTraversalMethod_by_String() throws Exception {
+ public void shouldParseTraversalMethod_by_String() throws Exception {
compare(g.V().order().by("name"), eval("g.V().order().by('name')"));
}
@Test
- public void testTraversalMethod_by_String_Comparator() throws Exception {
+ public void shouldParseTraversalMethod_by_String_Comparator() throws Exception {
compare(g.V().order().by("name", Order.asc), eval("g.V().order().by('name', asc)"));
}
@Test
- public void testTraversalMethod_by_T() throws Exception {
+ public void shouldParseTraversalMethod_by_T() throws Exception {
compare(g.V().order().by(T.id), eval("g.V().order().by(id)"));
}
@Test
- public void testTraversalMethod_by_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_by_Traversal() throws Exception {
compare(g.V().group().by(bothE().count()), eval("g.V().group().by(bothE().count())"));
}
@Test
- public void testTraversalMethod_by_Traversal_Comparator() throws Exception {
+ public void shouldParseTraversalMethod_by_Traversal_Comparator() throws Exception {
compare(g.V().order().by(bothE().count(), Order.asc), eval("g.V().order().by(bothE().count(), asc)"));
}
@Test
- public void testTraversalMethod_cap() throws Exception {
+ public void shouldParseTraversalMethod_cap() throws Exception {
compare(g.V().cap("test"), eval("g.V().cap('test')"));
}
@Test
- public void testTraversalMethod_choose_Function() throws Exception {
+ public void shouldParseTraversalMethod_choose_Function() throws Exception {
compare(g.V().choose((Function) label), eval("g.V().choose(label)"));
}
@Test
- public void testTraversalMethod_choose_Predicate_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_choose_Predicate_Traversal() throws Exception {
compare(g.V().choose(is(12), values("age")), eval("g.V().choose(is(12), values(\"age\"))"));
}
@Test
- public void testTraversalMethod_choose_Predicate_Traversal_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_choose_Predicate_Traversal_Traversal() throws Exception {
compare(g.V().choose(is(12), values("age"), values("count")),
eval("g.V().choose(is(12), values(\"age\"), values(\"count\"))"));
}
@Test
- public void testTraversalMethod_choose_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_choose_Traversal() throws Exception {
compare(g.V().choose(values("age")), eval("g.V().choose(values('age'))"));
}
@Test
- public void testTraversalMethod_choose_Traversal_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_choose_Traversal_Traversal() throws Exception {
compare(g.V().choose(values("age"), bothE()), eval("g.V().choose(values('age'), bothE())"));
}
@Test
- public void testTraversalMethod_choose_Traversal_Traversal_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_choose_Traversal_Traversal_Traversal() throws Exception {
compare(g.V().choose(values("age"), bothE(), bothE()), eval("g.V().choose(values('age'), bothE(), bothE())"));
}
@Test
- public void testTraversalMethod_coalesce() throws Exception {
+ public void shouldParseTraversalMethod_coalesce() throws Exception {
compare(g.V().coalesce(outE("knows")), eval("g.V().coalesce(outE('knows'))"));
}
@Test
- public void testTraversalMethod_coin() throws Exception {
+ public void shouldParseTraversalMethod_coin() throws Exception {
compare(g.V().coin(2.5), eval("g.V().coin(2.5)"));
}
@Test
- public void testTraversalMethod_constant() throws Exception {
+ public void shouldParseTraversalMethod_constant() throws Exception {
compare(g.V().constant("yigit"), eval("g.V().constant('yigit')"));
}
@Test
- public void testTraversalMethod_count_Empty() throws Exception {
+ public void shouldParseTraversalMethod_count_Empty() throws Exception {
compare(g.V().count(), eval("g.V().count()"));
}
@Test
- public void testTraversalMethod_count_Scope() throws Exception {
+ public void shouldParseTraversalMethod_count_Scope() throws Exception {
compare(g.V().count(global), eval("g.V().count(global)"));
}
@Test
- public void testTraversalMethod_cyclicPath() throws Exception {
+ public void shouldParseTraversalMethod_cyclicPath() throws Exception {
compare(g.V().cyclicPath(), eval("g.V().cyclicPath()"));
}
@Test
- public void testTraversalMethod_dedup_Scope_String() throws Exception {
+ public void shouldParseTraversalMethod_dedup_Scope_String() throws Exception {
compare(g.V().dedup(Scope.local, "age"), eval("g.V().dedup(local, 'age')"));
}
@Test
- public void testTraversalMethod_dedup_String() throws Exception {
+ public void shouldParseTraversalMethod_dedup_String() throws Exception {
compare(g.V().dedup(), eval("g.V().dedup()"));
}
@Test
- public void testTraversalMethod_drop() throws Exception {
+ public void shouldParseTraversalMethod_drop() throws Exception {
compare(g.V().drop(), eval("g.V().drop()"));
}
@Test
- public void testTraversalMethod_emit_Empty() throws Exception {
+ public void shouldParseTraversalMethod_emit_Empty() throws Exception {
compare(g.V().emit(), eval("g.V().emit()"));
}
@Test
- public void testTraversalMethod_emit_Predicate() throws Exception {
+ public void shouldParseTraversalMethod_emit_Predicate() throws Exception {
compare(g.V().repeat(out()).emit(is("asd")), eval("g.V().repeat(out()).emit(is(\"asd\"))"));
}
@Test
- public void testTraversalMethod_emit_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_emit_Traversal() throws Exception {
compare(g.V().emit(has("name")), eval("g.V().emit(has('name'))"));
}
@Test
- public void testTraversalMethod_filter_Predicate() throws Exception {
+ public void shouldParseTraversalMethod_filter_Predicate() throws Exception {
compare(g.V().repeat(out()).filter(is("2")), eval("g.V().repeat(out()).filter(is(\"2\"))"));
}
@Test
- public void testTraversalMethod_filter_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_filter_Traversal() throws Exception {
compare(g.V().filter(has("name")), eval("g.V().filter(has('name'))"));
}
@Test
- public void testTraversalMethod_flatMap_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_flatMap_Traversal() throws Exception {
compare(g.V().flatMap(has("name")), eval("g.V().flatMap(has('name'))"));
}
@Test
- public void testTraversalMethod_fold_Empty() throws Exception {
+ public void shouldParseTraversalMethod_fold_Empty() throws Exception {
compare(g.V().fold(), eval("g.V().fold()"));
}
@Test
- public void testTraversalMethod_fold_Object_BiFunction() throws Exception {
+ public void shouldParseTraversalMethod_fold_Object_BiFunction() throws Exception {
compare(g.V().values("age").fold(0, Operator.max), eval("g.V().values('age').fold(0, max)"));
}
@Test
- public void testTraversalMethod_from_String() throws Exception {
+ public void shouldParseTraversalMethod_from_String() throws Exception {
compare(g.V().cyclicPath().from("name"), eval("g.V().cyclicPath().from('name')"));
}
@Test
- public void testTraversalMethod_from_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_from_Traversal() throws Exception {
compare(g.V().addE("as").from(V()), eval("g.V().addE('as').from(V())"));
}
@Test
- public void testTraversalMethod_group_Empty() throws Exception {
+ public void shouldParseTraversalMethod_group_Empty() throws Exception {
compare(g.V().group(), eval("g.V().group()"));
}
@Test
- public void testTraversalMethod_group_String() throws Exception {
+ public void shouldParseTraversalMethod_group_String() throws Exception {
compare(g.V().group("age"), eval("g.V().group('age')"));
}
@Test
- public void testTraversalMethod_groupCount_Empty() throws Exception {
+ public void shouldParseTraversalMethod_groupCount_Empty() throws Exception {
compare(g.V().groupCount(), eval("g.V().groupCount()"));
}
@Test
- public void testTraversalMethod_groupCount_String() throws Exception {
+ public void shouldParseTraversalMethod_groupCount_String() throws Exception {
compare(g.V().groupCount("age"), eval("g.V().groupCount('age')"));
}
@Test
- public void testTraversalMethod_has_String() throws Exception {
+ public void shouldParseTraversalMethod_has_String() throws Exception {
compare(g.V().has("age"), eval("g.V().has('age')"));
}
@Test
- public void testTraversalMethod_has_String_Object() throws Exception {
+ public void shouldParseTraversalMethod_has_String_Object() throws Exception {
compare(g.V().has("age", 132), eval("g.V().has('age', 132)"));
}
@Test
- public void testTraversalMethod_has_String_P() throws Exception {
+ public void shouldParseTraversalMethod_has_String_P() throws Exception {
compare(g.V().has("a", eq("b")), eval("g.V().has(\"a\", eq(\"b\"))"));
}
@Test
- public void testTraversalMethod_has_String_String_Object() throws Exception {
+ public void shouldParseTraversalMethod_has_String_String_Object() throws Exception {
compare(g.V().has("a", "b", 3), eval("g.V().has(\"a\", \"b\", 3)"));
}
@Test
- public void testTraversalMethod_has_String_String_P() throws Exception {
+ public void shouldParseTraversalMethod_has_String_String_P() throws Exception {
compare(g.V().has("a", "b", eq("c")), eval("g.V().has(\"a\", \"b\", eq(\"c\"))"));
}
@Test
- public void testTraversalMethod_has_String_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_has_String_Traversal() throws Exception {
compare(g.V().has("age", bothE()), eval("g.V().has('age', bothE())"));
}
@Test
- public void testTraversalMethod_has_T_Object() throws Exception {
+ public void shouldParseTraversalMethod_has_T_Object() throws Exception {
compare(g.V().has(T.id, 6), eval("g.V().has(id, 6)"));
}
@Test
- public void testTraversalMethod_has_T_P() throws Exception {
+ public void shouldParseTraversalMethod_has_T_P() throws Exception {
compare(g.V().has(T.id, eq("asd")), eval("g.V().has(id, eq('asd'))"));
}
@Test
- public void testTraversalMethod_has_T_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_has_T_Traversal() throws Exception {
compare(g.V().has(T.id, bothE()), eval("g.V().has(id, bothE())"));
}
@Test
- public void testTraversalMethod_hasId_Object_Object() throws Exception {
+ public void shouldParseTraversalMethod_hasId_Object_Object() throws Exception {
compare(g.V().hasId(3, 4), eval("g.V().hasId(3, 4)"));
}
@Test
- public void testTraversalMethod_hasId_P() throws Exception {
+ public void shouldParseTraversalMethod_hasId_P() throws Exception {
compare(g.V().hasId(gt(4)), eval("g.V().hasId(gt(4))"));
}
@Test
- public void testTraversalMethod_hasKey_P() throws Exception {
+ public void shouldParseTraversalMethod_hasKey_P() throws Exception {
compare(g.V().hasKey(eq("asd")), eval("g.V().hasKey(eq(\"asd\"))"));
}
@Test
- public void testTraversalMethod_hasKey_String_String() throws Exception {
+ public void shouldParseTraversalMethod_hasKey_String_String() throws Exception {
compare(g.V().hasKey("age"), eval("g.V().hasKey('age')"));
compare(g.V().hasKey("age", "3"), eval("g.V().hasKey('age', '3')"));
}
@Test
- public void testTraversalMethod_hasLabel_P() throws Exception {
+ public void shouldParseTraversalMethod_hasLabel_P() throws Exception {
compare(g.V().hasLabel(eq("asd")), eval("g.V().hasLabel(eq(\"asd\"))"));
}
@Test
- public void testTraversalMethod_hasLabel_String_String() throws Exception {
+ public void shouldParseTraversalMethod_hasLabel_String_String() throws Exception {
compare(g.V().hasLabel("age"), eval("g.V().hasLabel('age')"));
compare(g.V().hasLabel("age", "3"), eval("g.V().hasLabel('age', '3')"));
}
@Test
- public void testTraversalMethod_hasNot() throws Exception {
+ public void shouldParseTraversalMethod_hasNot() throws Exception {
compare(g.V().hasNot("know"), eval("g.V().hasNot('know')"));
}
@Test
- public void testTraversalMethod_hasValue_Object_Object() throws Exception {
+ public void shouldParseTraversalMethod_hasValue_Object_Object() throws Exception {
compare(g.V().hasValue(3, 4), eval("g.V().hasValue(3, 4)"));
}
@Test
- public void testTraversalMethod_hasValue_P() throws Exception {
+ public void shouldParseTraversalMethod_hasValue_P() throws Exception {
compare(g.V().hasValue(eq(2)), eval("g.V().hasValue(eq(2))"));
}
@Test
- public void testTraversalMethod_id() throws Exception {
+ public void shouldParseTraversalMethod_id() throws Exception {
compare(g.V().id(), eval("g.V().id()"));
}
@Test
- public void testTraversalMethod_identity() throws Exception {
+ public void shouldParseTraversalMethod_identity() throws Exception {
compare(g.V().identity(), eval("g.V().identity()"));
}
@Test
- public void testTraversalMethod_in() throws Exception {
+ public void shouldParseTraversalMethod_in() throws Exception {
compare(g.V().in("created"), eval("g.V().in('created')"));
}
@Test
- public void testTraversalMethod_index() throws Exception {
+ public void shouldParseTraversalMethod_index() throws Exception {
compare(g.V().hasLabel("software").index(), eval("g.V().hasLabel('software').index()"));
}
@Test
- public void testTraversalMethod_inE() throws Exception {
+ public void shouldParseTraversalMethod_inE() throws Exception {
compare(g.V().inE("created"), eval("g.V().inE('created')"));
}
@Test
- public void testTraversalMethod_inV() throws Exception {
+ public void shouldParseTraversalMethod_inV() throws Exception {
compare(g.V().inV(), eval("g.V().inV()"));
}
@Test
- public void testTraversalMethod_inject() throws Exception {
+ public void shouldParseTraversalMethod_inject() throws Exception {
compare(g.V(4).out().values("name").inject("daniel"),
eval("g.V(4).out().values(\"name\").inject(\"daniel\")"));
}
@Test
- public void testTraversalMethod_is_Object() throws Exception {
+ public void shouldParseTraversalMethod_is_Object() throws Exception {
compare(g.V().is(4), eval("g.V().is(4)"));
}
@Test
- public void testTraversalMethod_is_P() throws Exception {
+ public void shouldParseTraversalMethod_is_P() throws Exception {
compare(g.V().is(gt(4)), eval("g.V().is(gt(4))"));
}
@Test
- public void testTraversalMethod_iterate() throws Exception {
+ public void shouldParseTraversalMethod_iterate() throws Exception {
compare(g.V().iterate(), eval("g.V().iterate()"));
}
@Test
- public void testTraversalMethod_key() throws Exception {
+ public void shouldParseTraversalMethod_key() throws Exception {
compare(g.V().key(), eval("g.V().key()"));
}
@Test
- public void testTraversalMethod_label() throws Exception {
+ public void shouldParseTraversalMethod_label() throws Exception {
compare(g.V().label(), eval("g.V().label()"));
}
@Test
- public void testTraversalMethod_limit_Scope_long() throws Exception {
+ public void shouldParseTraversalMethod_limit_Scope_long() throws Exception {
compare(g.V().limit(global, 3), eval("g.V().limit(global, 3)"));
}
@Test
- public void testTraversalMethod_limit_long() throws Exception {
+ public void shouldParseTraversalMethod_limit_long() throws Exception {
compare(g.V().limit(2), eval("g.V().limit(2)"));
}
@Test
- public void testTraversalMethod_local() throws Exception {
+ public void shouldParseTraversalMethod_local() throws Exception {
compare(g.V().local(bothE()), eval("g.V().local(bothE())"));
}
@Test
- public void testTraversalMethod_loops() throws Exception {
+ public void shouldParseTraversalMethod_loops() throws Exception {
compare(g.V().loops(), eval("g.V().loops()"));
}
@Test
- public void testTraversalMethod_map_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_map_Traversal() throws Exception {
compare(g.V().map(bothE()), eval("g.V().map(bothE())"));
}
@Test
- public void testTraversalMethod_match() throws Exception {
+ public void shouldParseTraversalMethod_match() throws Exception {
compare(g.V().match(as("a"), as("b")), eval("g.V().match(as(\"a\"), as(\"b\"))"));
}
@Test
- public void testTraversalMethod_max_Empty() throws Exception {
+ public void shouldParseTraversalMethod_max_Empty() throws Exception {
compare(g.V().max(), eval("g.V().max()"));
}
@Test
- public void testTraversalMethod_max_Scope() throws Exception {
+ public void shouldParseTraversalMethod_max_Scope() throws Exception {
compare(g.V().max(Scope.local), eval("g.V().max(local)"));
}
@Test
- public void testTraversalMethod_math() throws Exception {
+ public void shouldParseTraversalMethod_math() throws Exception {
compare(g.V().count().math("_ + 10"), eval("g.V().count().math('_ + 10')"));
}
@Test
- public void testTraversalMethod_mean_Empty() throws Exception {
+ public void shouldParseTraversalMethod_mean_Empty() throws Exception {
compare(g.V().mean(), eval("g.V().mean()"));
}
@Test
- public void testTraversalMethod_mean_Scope() throws Exception {
+ public void shouldParseTraversalMethod_mean_Scope() throws Exception {
compare(g.V().mean(global), eval("g.V().mean(global)"));
}
@Test
- public void testTraversalMethod_min_Empty() throws Exception {
+ public void shouldParseTraversalMethod_min_Empty() throws Exception {
compare(g.V().min(), eval("g.V().min()"));
}
@Test
- public void testTraversalMethod_min_Scope() throws Exception {
+ public void shouldParseTraversalMethod_min_Scope() throws Exception {
compare(g.V().min(Scope.local), eval("g.V().min(local)"));
}
@Test
- public void testTraversalMethod_not() throws Exception {
+ public void shouldParseTraversalMethod_not() throws Exception {
compare(g.V().not(both()), eval("g.V().not(both())"));
}
@Test
- public void testTraversalMethod_option_Object_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_option_Object_Traversal() throws Exception {
compare(g.V().branch(values("name")).option(2, bothE()),
eval("g.V().branch(values(\"name\")).option(2, bothE())"));
}
@Test
- public void testTraversalMethod_option_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_option_Traversal() throws Exception {
compare(g.V().branch(values("name")).option(both()), eval("g.V().branch(values(\"name\")).option(both())"));
}
@Test
- public void testTraversalMethod_optional() throws Exception {
+ public void shouldParseTraversalMethod_optional() throws Exception {
compare(g.V().optional(min()), eval("g.V().optional(min())"));
}
@Test
- public void testTraversalMethod_or() throws Exception {
+ public void shouldParseTraversalMethod_or() throws Exception {
compare(g.V().or(as("a"), as("b")), eval("g.V().or(as(\"a\"), as(\"b\"))"));
}
@Test
- public void testTraversalMethod_order_Empty() throws Exception {
+ public void shouldParseTraversalMethod_order_Empty() throws Exception {
compare(g.V().order(), eval("g.V().order()"));
}
@Test
- public void testTraversalMethod_order_Scope() throws Exception {
+ public void shouldParseTraversalMethod_order_Scope() throws Exception {
compare(g.V().order(global), eval("g.V().order(global)"));
}
@Test
- public void testTraversalMethod_otherV() throws Exception {
+ public void shouldParseTraversalMethod_otherV() throws Exception {
compare(g.V().otherV(), eval("g.V().otherV()"));
}
@Test
- public void testTraversalMethod_out() throws Exception {
+ public void shouldParseTraversalMethod_out() throws Exception {
compare(g.V().out("a", "b"), eval("g.V().out(\"a\", \"b\")"));
}
@Test
- public void testTraversalMethod_outE() throws Exception {
+ public void shouldParseTraversalMethod_outE() throws Exception {
compare(g.V().outE("a", "b"), eval("g.V().outE(\"a\", \"b\")"));
}
@Test
- public void testTraversalMethod_outV() throws Exception {
+ public void shouldParseTraversalMethod_outV() throws Exception {
compare(g.V().outV(), eval("g.V().outV()"));
}
@Test
- public void testTraversalMethod_pageRank_Empty() throws Exception {
+ public void shouldParseTraversalMethod_pageRank_Empty() throws Exception {
compare(g.V().pageRank(), eval("g.V().pageRank()"));
}
@Test
- public void testTraversalMethod_pageRank_double() throws Exception {
+ public void shouldParseTraversalMethod_pageRank_double() throws Exception {
compare(g.V().pageRank(2.6), eval("g.V().pageRank(2.6)"));
}
@Test
- public void testTraversalMethod_path() throws Exception {
+ public void shouldParseTraversalMethod_path() throws Exception {
compare(g.V().path(), eval("g.V().path()"));
}
@Test
- public void testTraversalMethod_peerPressure() throws Exception {
+ public void shouldParseTraversalMethod_peerPressure() throws Exception {
compare(g.V().peerPressure(), eval("g.V().peerPressure()"));
}
@Test
- public void testTraversalMethod_profile_Empty() throws Exception {
+ public void shouldParseTraversalMethod_profile_Empty() throws Exception {
compare(g.V().profile(), eval("g.V().profile()"));
}
@Test
- public void testTraversalMethod_profile_String() throws Exception {
+ public void shouldParseTraversalMethod_profile_String() throws Exception {
compare(g.V().profile("neptune"), eval("g.V().profile('neptune')"));
}
@Test
- public void testTraversalMethod_project() throws Exception {
+ public void shouldParseTraversalMethod_project() throws Exception {
compare(g.V().project("neptune"), eval("g.V().project('neptune')"));
compare(g.V().project("neptune", "uranus"), eval("g.V().project('neptune', 'uranus')"));
}
@Test
- public void testTraversalMethod_properties() throws Exception {
+ public void shouldParseTraversalMethod_properties() throws Exception {
compare(g.V().properties("venus", "mars"), eval("g.V().properties('venus', 'mars')"));
}
@Test
- public void testTraversalMethod_property_Cardinality_Object_Object_Object() throws Exception {
+ public void shouldParseTraversalMethod_property_Cardinality_Object_Object_Object() throws Exception {
compare(g.V().property(VertexProperty.Cardinality.list,1,2,"key", 4),
eval("g.V().property(list, 1,2,'key',4)"));
}
@Test
- public void testTraversalMethod_property_Object_Object_Object() throws Exception {
+ public void shouldParseTraversalMethod_property_Object_Object_Object() throws Exception {
compare(g.V().property(1,2,"key", 4), eval("g.V().property(1,2,'key',4)"));
}
@Test
- public void testTraversalMethod_property_Object() throws Exception {
+ public void shouldParseTraversalMethod_property_Object() throws Exception {
final LinkedHashMap<Object, Object> map = new LinkedHashMap<>();
map.put("key", "foo");
map.put("key1", "bar");
@@ -717,7 +715,7 @@ public class TraversalMethodVisitorTest {
}
@Test
- public void testTraversalMethod_property_Cardinality_Object() throws Exception {
+ public void shouldParseTraversalMethod_property_Cardinality_Object() throws Exception {
final LinkedHashMap<Object, Object> map = new LinkedHashMap<>();
map.put("key", "foo");
map.put("key1", "bar");
@@ -725,27 +723,27 @@ public class TraversalMethodVisitorTest {
}
@Test
- public void testTraversalMethod_propertyMap() throws Exception {
+ public void shouldParseTraversalMethod_propertyMap() throws Exception {
compare(g.V().propertyMap("venus", "mars"), eval("g.V().propertyMap('venus', 'mars')"));
}
@Test
- public void testTraversalMethod_range_Scope_long_long() throws Exception {
+ public void shouldParseTraversalMethod_range_Scope_long_long() throws Exception {
compare(g.V().range(global, 3,5), eval("g.V().range(global, 3,5)"));
}
@Test
- public void testTraversalMethod_range_long_long() throws Exception {
+ public void shouldParseTraversalMethod_range_long_long() throws Exception {
compare(g.V().range(3,5), eval("g.V().range(3,5)"));
}
@Test
- public void testTraversalMethod_repeat() throws Exception {
+ public void shouldParseTraversalMethod_repeat() throws Exception {
compare(g.V().repeat(both()), eval("g.V().repeat(both())"));
}
@Test
- public void testTraversalMethod_sack_BiFunction() throws Exception {
+ public void shouldParseTraversalMethod_sack_BiFunction() throws Exception {
compare(g.V().sack(), eval("g.V().sack()"));
compare(g.V().sack(Operator.addAll), eval("g.V().sack(addAll)"));
compare(g.V().sack(Operator.and), eval("g.V().sack(and)"));
@@ -761,223 +759,223 @@ public class TraversalMethodVisitorTest {
}
@Test
- public void testTraversalMethod_sack_Empty() throws Exception {
+ public void shouldParseTraversalMethod_sack_Empty() throws Exception {
compare(g.V().sack(), eval("g.V().sack()"));
}
@Test
- public void testTraversalMethod_sample_Scope_int() throws Exception {
+ public void shouldParseTraversalMethod_sample_Scope_int() throws Exception {
compare(g.V().sample(global, 2), eval("g.V().sample(global, 2)"));
}
@Test
- public void testTraversalMethod_sample_int() throws Exception {
+ public void shouldParseTraversalMethod_sample_int() throws Exception {
compare(g.V().sample(4), eval("g.V().sample(4)"));
}
@Test
- public void testTraversalMethod_select_Column() throws Exception {
+ public void shouldParseTraversalMethod_select_Column() throws Exception {
compare(g.V().select(Column.keys), eval("g.V().select(keys)"));
}
@Test
- public void testTraversalMethod_select_Pop_String() throws Exception {
+ public void shouldParseTraversalMethod_select_Pop_String() throws Exception {
compare(g.V().select(Pop.first, "asd"), eval("g.V().select(first, 'asd')"));
}
@Test
- public void testTraversalMethod_select_Pop_String_String_String() throws Exception {
+ public void shouldParseTraversalMethod_select_Pop_String_String_String() throws Exception {
compare(g.V().select(Pop.all, "a", "b", "c", "d"), eval("g.V().select(all, \"a\", \"b\", \"c\", \"d\")"));
}
@Test
- public void testTraversalMethod_select_Pop_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_select_Pop_Traversal() throws Exception {
compare(g.V().select(Pop.all, out().properties("a")), eval("g.V().select(all, out().properties(\"a\"))"));
}
@Test
- public void testTraversalMethod_select_String() throws Exception {
+ public void shouldParseTraversalMethod_select_String() throws Exception {
compare(g.V().select("yigit"), eval("g.V().select(\"yigit\")"));
}
@Test
- public void testTraversalMethod_select_String_String_String() throws Exception {
+ public void shouldParseTraversalMethod_select_String_String_String() throws Exception {
compare(g.V().select("a", "b", "c", "d"), eval("g.V().select(\"a\", \"b\", \"c\", \"d\")"));
}
@Test
- public void testTraversalMethod_select_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_select_Traversal() throws Exception {
compare(g.V().select(out().properties("a")), eval("g.V().select(out().properties(\"a\"))"));
}
@Test
- public void testTraversalMethod_sideEffect() throws Exception {
+ public void shouldParseTraversalMethod_sideEffect() throws Exception {
compare(g.V().sideEffect(bothE()), eval("g.V().sideEffect(bothE())"));
}
@Test
- public void testTraversalMethod_simplePath() throws Exception {
+ public void shouldParseTraversalMethod_simplePath() throws Exception {
compare(g.V().simplePath(), eval("g.V().simplePath()"));
}
@Test
- public void testTraversalMethod_skip_Scope_long() throws Exception {
+ public void shouldParseTraversalMethod_skip_Scope_long() throws Exception {
compare(g.V().skip(global, 8), eval("g.V().skip(global, 8)"));
}
@Test
- public void testTraversalMethod_skip_long() throws Exception {
+ public void shouldParseTraversalMethod_skip_long() throws Exception {
compare(g.V().skip(8), eval("g.V().skip(8)"));
}
@Test
- public void testTraversalMethod_store() throws Exception {
+ public void shouldParseTraversalMethod_store() throws Exception {
compare(g.V().store("asd"), eval("g.V().store(\"asd\")"));
}
@Test
- public void testTraversalMethod_subgraph() throws Exception {
+ public void shouldParseTraversalMethod_subgraph() throws Exception {
compare(g.V().subgraph("asd"), eval("g.V().subgraph('asd')"));
}
@Test
- public void testTraversalMethod_sum_Empty() throws Exception {
+ public void shouldParseTraversalMethod_sum_Empty() throws Exception {
compare(g.V().sum(), eval("g.V().sum()"));
}
@Test
- public void testTraversalMethod_sum_Scope() throws Exception {
+ public void shouldParseTraversalMethod_sum_Scope() throws Exception {
compare(g.V().sum(Scope.local), eval("g.V().sum(local)"));
}
@Test
- public void testTraversalMethod_tail_Empty() throws Exception {
+ public void shouldParseTraversalMethod_tail_Empty() throws Exception {
compare(g.V().tail(), eval("g.V().tail()"));
}
@Test
- public void testTraversalMethod_tail_Scope() throws Exception {
+ public void shouldParseTraversalMethod_tail_Scope() throws Exception {
compare(g.V().tail(Scope.local), eval("g.V().tail(local)"));
}
@Test
- public void testTraversalMethod_tail_Scope_long() throws Exception {
+ public void shouldParseTraversalMethod_tail_Scope_long() throws Exception {
compare(g.V().tail(Scope.local, 3), eval("g.V().tail(local, 3)"));
}
@Test
- public void testTraversalMethod_tail_long() throws Exception {
+ public void shouldParseTraversalMethod_tail_long() throws Exception {
compare(g.V().tail(4), eval("g.V().tail(4)"));
}
@Test
- public void testTraversalMethod_timeLimit() throws Exception {
+ public void shouldParseTraversalMethod_timeLimit() throws Exception {
compare(g.V().timeLimit(5), eval("g.V().timeLimit(5)"));
}
@Test
- public void testTraversalMethod_times() throws Exception {
+ public void shouldParseTraversalMethod_times() throws Exception {
compare(g.V().times(6), eval("g.V().times(6)"));
}
@Test
- public void testTraversalMethod_to_Direction_String() throws Exception {
+ public void shouldParseTraversalMethod_to_Direction_String() throws Exception {
compare(g.V().to(Direction.IN, "asd"), eval("g.V().to(IN, 'asd')"));
}
@Test
- public void testTraversalMethod_to_String() throws Exception {
+ public void shouldParseTraversalMethod_to_String() throws Exception {
compare(g.V().path().to("home"), eval("g.V().path().to(\"home\")"));
}
@Test
- public void testTraversalMethod_to_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_to_Traversal() throws Exception {
compare(g.V().addE("as").to(V()), eval("g.V().addE('as').to(V())"));
}
@Test
- public void testTraversalMethod_toE() throws Exception {
+ public void shouldParseTraversalMethod_toE() throws Exception {
compare(g.V().toE(Direction.IN, "asd"), eval("g.V().toE(IN, 'asd')"));
}
@Test
- public void testTraversalMethod_toV() throws Exception {
+ public void shouldParseTraversalMethod_toV() throws Exception {
compare(g.V().toV(Direction.IN), eval("g.V().toV(IN)"));
}
@Test
- public void testTraversalMethod_tree_Empty() throws Exception {
+ public void shouldParseTraversalMethod_tree_Empty() throws Exception {
compare(g.V().tree(), eval("g.V().tree()"));
}
@Test
- public void testTraversalMethod_tree_String() throws Exception {
+ public void shouldParseTraversalMethod_tree_String() throws Exception {
compare(g.V().tree("hello"), eval("g.V().tree(\"hello\")"));
}
@Test
- public void testTraversalMethod_unfold() throws Exception {
+ public void shouldParseTraversalMethod_unfold() throws Exception {
compare(g.V().unfold(), eval("g.V().unfold()"));
}
@Test
- public void testTraversalMethod_union() throws Exception {
+ public void shouldParseTraversalMethod_union() throws Exception {
compare(g.V().union(in(), out()), eval("g.V().union(in(), out())"));
}
@Test
- public void testTraversalMethod_until_Predicate() throws Exception {
+ public void shouldParseTraversalMethod_until_Predicate() throws Exception {
compare(g.V().until(is("123")), eval("g.V().until(is(\"123\"))"));
}
@Test
- public void testTraversalMethod_until_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_until_Traversal() throws Exception {
compare(g.V().until(has("ripple")), eval("g.V().until(has(\"ripple\"))"));
}
@Test
- public void testTraversalMethod_value() throws Exception {
+ public void shouldParseTraversalMethod_value() throws Exception {
compare(g.V().value(), eval("g.V().value()"));
}
@Test
- public void testTraversalMethod_valueMap_String() throws Exception {
+ public void shouldParseTraversalMethod_valueMap_String() throws Exception {
compare(g.V().valueMap("yigit"), eval("g.V().valueMap(\"yigit\")"));
}
@Test
- public void testTraversalMethod_valueMap_boolean_String1() throws Exception {
+ public void shouldParseTraversalMethod_valueMap_boolean_String1() throws Exception {
compare(g.V().valueMap(true), eval("g.V().valueMap(true)"));
}
@Test
- public void testTraversalMethod_valueMap_boolean_String2() throws Exception {
+ public void shouldParseTraversalMethod_valueMap_boolean_String2() throws Exception {
compare(g.V().valueMap(true, "that"), eval("g.V().valueMap(true, \"that\")"));
}
@Test
- public void testTraversalMethod_valueMap_withOption() throws Exception {
+ public void shouldParseTraversalMethod_valueMap_withOption() throws Exception {
compare(g.V().valueMap().with(WithOptions.tokens, WithOptions.labels),
eval("g.V().valueMap().with(WithOptions.tokens, WithOptions.labels)"));
}
@Test
- public void testTraversalMethod_values() throws Exception {
+ public void shouldParseTraversalMethod_values() throws Exception {
compare(g.V().values("earth", "mars"), eval("g.V().values(\"earth\", \"mars\")"));
}
@Test
- public void testTraversalMethod_where_P() throws Exception {
+ public void shouldParseTraversalMethod_where_P() throws Exception {
compare(g.V().where(eq("123")), eval("g.V().where(eq(\"123\"))"));
}
@Test
- public void testTraversalMethod_where_String_P() throws Exception {
+ public void shouldParseTraversalMethod_where_String_P() throws Exception {
compare(g.V().where("age", eq("123")), eval("g.V().where('age', eq(\"123\"))"));
}
@Test
- public void testTraversalMethod_where_Traversal() throws Exception {
+ public void shouldParseTraversalMethod_where_Traversal() throws Exception {
compare(g.V().where(both()), eval("g.V().where(both())"));
}
@@ -1040,73 +1038,73 @@ public class TraversalMethodVisitorTest {
}
@Test
- public void testTraversalMethod_peerPressure_withPropertyName() throws Exception {
+ public void shouldParseTraversalMethod_peerPressure_withPropertyName() throws Exception {
compare(g.V().peerPressure().with(PeerPressure.propertyName, "cluster"),
eval("g.V().peerPressure().with(PeerPressure.propertyName, 'cluster')"));
}
@Test
- public void testTraversalMethod_peerPressure_withEdges() throws Exception {
+ public void shouldParseTraversalMethod_peerPressure_withEdges() throws Exception {
compare(g.V().peerPressure().with(PeerPressure.edges, outE("knows")),
eval("g.V().peerPressure().with(PeerPressure.edges, __.outE('knows'))"));
}
@Test
- public void testTraversalMethod_peerPressure_withTimes() throws Exception {
+ public void shouldParseTraversalMethod_peerPressure_withTimes() throws Exception {
compare(g.V().peerPressure().with(PeerPressure.times, 2),
eval("g.V().peerPressure().with(PeerPressure.times, 2)"));
}
@Test
- public void testTraversalMethod_pageRank_withOutEdges() throws Exception {
+ public void shouldParseTraversalMethod_pageRank_withOutEdges() throws Exception {
compare(g.V().pageRank(2.6).with(PageRank.edges, outE("knows")),
eval("g.V().pageRank(2.6).with(PageRank.edges, __.outE('knows'))"));
}
@Test
- public void testTraversalMethod_pageRank_withTimes() throws Exception {
+ public void shouldParseTraversalMethod_pageRank_withTimes() throws Exception {
compare(g.V().pageRank(2.6).with(PageRank.times, 2),
eval("g.V().pageRank(2.6).with(PageRank.times, 2)"));
}
@Test
- public void testTraversalMethod_pageRank_withPropertyName() throws Exception {
+ public void shouldParseTraversalMethod_pageRank_withPropertyName() throws Exception {
compare(g.V().pageRank(2.6).with(PageRank.propertyName, "blah"),
eval("g.V().pageRank(2.6).with(PageRank.propertyName, 'blah')"));
}
@Test
- public void testTraversalMethod_shortestPath_withEdges() throws Exception {
+ public void shouldParseTraversalMethod_shortestPath_withEdges() throws Exception {
compare(g.V().shortestPath().with(ShortestPath.edges, outE("knows")),
eval("g.V().shortestPath().with(ShortestPath.edges, __.outE('knows'))"));
}
@Test
- public void testTraversalMethod_shortestPath_withIncludeEdges() throws Exception {
+ public void shouldParseTraversalMethod_shortestPath_withIncludeEdges() throws Exception {
compare(g.V().shortestPath().with(ShortestPath.includeEdges, true),
eval("g.V().shortestPath().with(ShortestPath.includeEdges, true)"));
}
@Test
- public void testTraversalMethod_shortestPath_withDistance() throws Exception {
+ public void shouldParseTraversalMethod_shortestPath_withDistance() throws Exception {
compare(g.V().shortestPath().with(ShortestPath.distance, "asd"),
eval("g.V().shortestPath().with(ShortestPath.distance, 'asd')"));
}
@Test
- public void testTraversalMethod_shortestPath_withMaxDistance() throws Exception {
+ public void shouldParseTraversalMethod_shortestPath_withMaxDistance() throws Exception {
compare(g.V().shortestPath().with(ShortestPath.maxDistance, 2),
eval("g.V().shortestPath().with(ShortestPath.maxDistance, 2)"));
}
@Test
- public void testTraversalMethod_shortestPath_withTarget() throws Exception {
+ public void shouldParseTraversalMethod_shortestPath_withTarget() throws Exception {
compare(g.V().shortestPath().with(ShortestPath.target, has("name", "peter")),
eval("g.V().shortestPath().with(ShortestPath.target, __.has('name','peter'))"));
}
@Test
- public void testTraversalMethod_shortestPath_withEdgesWithTarget() throws Exception {
+ public void shouldParseTraversalMethod_shortestPath_withEdgesWithTarget() throws Exception {
compare(g.V().shortestPath().with(ShortestPath.edges, Direction.IN).with(ShortestPath.target, has("name", "josh")),
eval("g.V().shortestPath().\n" +
" with(ShortestPath.edges, IN).\n" +
@@ -1114,34 +1112,34 @@ public class TraversalMethodVisitorTest {
}
@Test
- public void testTraversalMethod_with() throws Exception {
+ public void shouldParseTraversalMethod_with() throws Exception {
compare(g.V().with("blah"),
eval("g.V().with('blah')"));
}
@Test
- public void testTraversalMethod_with_multipleArgs() throws Exception {
+ public void shouldParseTraversalMethod_with_multipleArgs() throws Exception {
compare(g.V().with("blah", "bleh"),
eval("g.V().with('blah', 'bleh')"));
}
@Test
- public void testTraversalMethod_midTraversal_E() throws Exception {
+ public void shouldParseTraversalMethod_midTraversal_E() throws Exception {
compare(g.inject(1).E(), eval("g.inject(1).E()"));
}
@Test
- public void testTraversalMethod_midTraversal_E_multipleArgs() throws Exception {
+ public void shouldParseTraversalMethod_midTraversal_E_multipleArgs() throws Exception {
compare(g.inject(1).E(2,null), eval("g.inject(1).E(2,null)"));
}
@Test
- public void testTraversalMethod_midTraversal_E_spawning() throws Exception {
+ public void shouldParseTraversalMethod_midTraversal_E_spawning() throws Exception {
compare(g.V().coalesce(E(),addE("person")), eval("g.V().coalesce(__.E(),__.addE('person'))"));
}
@Test
- public void testTraversalMethod_midTraversal_E_multipleArgs_spawning() throws Exception {
+ public void shouldParseTraversalMethod_midTraversal_E_multipleArgs_spawning() throws Exception {
compare(g.V().coalesce(E(1,2),addE("person")),
eval("g.V().coalesce(__.E(1,2),__.addE('person'))"));
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalPredicateVisitorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalPredicateVisitorTest.java
index e784d5cd55..cb7b49acb5 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalPredicateVisitorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalPredicateVisitorTest.java
@@ -99,11 +99,11 @@ public class TraversalPredicateVisitorTest {
}
@Test
- public void testPredicate() {
+ public void shouldParsePredicate() {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.TraversalPredicateContext ctx = parser.traversalPredicate();
- final P predicate = TraversalPredicateVisitor.instance().visitTraversalPredicate(ctx);
+ final P predicate = new TraversalPredicateVisitor(new GremlinAntlrToJava()).visitTraversalPredicate(ctx);
Assert.assertEquals(expected, predicate);
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalRootVisitorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalRootVisitorTest.java
index 6272c41d17..a6bc04f0e6 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalRootVisitorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalRootVisitorTest.java
@@ -41,7 +41,7 @@ public class TraversalRootVisitorTest {
}
@Test
- public void testTraversalMethod_none() {
+ public void shouldParseTraversalMethod_none() {
compare(g.V().none(), eval("g.V().none()"));
compare(g.V().union(__.identity().none()), eval("g.V().union(__.identity().none())"));
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSelfMethodVisitorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSelfMethodVisitorTest.java
index 145fd9f0d8..6c555c6c99 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSelfMethodVisitorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSelfMethodVisitorTest.java
@@ -73,7 +73,7 @@ public class TraversalSourceSelfMethodVisitorTest {
}
@Test
- public void testTraversalSourceSelfMethod() {
+ public void shouldParseTraversalSourceSelfMethod() {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.TraversalSourceSelfMethodContext ctx = parser.traversalSourceSelfMethod();
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnVisitorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnVisitorTest.java
index 33204e1a8a..88475a7e7b 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnVisitorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnVisitorTest.java
@@ -46,11 +46,25 @@ public class TraversalSourceSpawnVisitorTest {
}
@Test
- public void testTraversalSourceSpawnMethod_inject() {
- // a random spawn of inject method.
- compare(g.inject(1,2,3,4), eval("g.inject(1,2,3,4)"));
- compare(g.inject(1,2,3,new HashMap<>()), eval("g.inject(1,2,3,[:])"));
+ public void shouldParseTraversalSourceSpawnMethod_inject() {
+ compare(g.inject(1), eval("g.inject(1)"));
+ compare(g.inject(1, 2, 3, 4), eval("g.inject(1,2,3,4)"));
+ compare(g.inject(1, 2, 3, new HashMap<>()), eval("g.inject(1,2,3,[:])"));
+ }
+
+ @Test
+ public void shouldParseTraversalSourceSpawnMethod_V() {
+ compare(g.V().out().values("name").inject("daniel"), eval("g.V().out().values('name').inject('daniel')"));
compare(g.V(4).out().values("name").inject("daniel"), eval("g.V(4).out().values('name').inject('daniel')"));
+ compare(g.V(4, 5).out().values("name").inject("daniel"), eval("g.V(4, 5).out().values('name').inject('daniel')"));
+ }
+
+ @Test
+ public void shouldParseTraversalSourceSpawnMethod_E() {
+ compare(g.E().values("name").inject("daniel"), eval("g.E().values('name').inject('daniel')"));
+ compare(g.E(4).values("name").inject("daniel"), eval("g.E(4).values('name').inject('daniel')"));
+ compare(g.E(4, 5).values("name").inject("daniel"), eval("g.E(4, 5).values('name').inject('daniel')"));
+
}
private Object eval(final String query) {
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalStrategyVisitorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalStrategyVisitorTest.java
index df3ed2f5b7..445c6ff9db 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalStrategyVisitorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalStrategyVisitorTest.java
@@ -79,11 +79,11 @@ public class TraversalStrategyVisitorTest {
}
@Test
- public void testTraversalStrategy() {
+ public void shouldParseTraversalStrategy() {
final GremlinLexer lexer = new GremlinLexer(CharStreams.fromString(script));
final GremlinParser parser = new GremlinParser(new CommonTokenStream(lexer));
final GremlinParser.TraversalStrategyContext ctx = parser.traversalStrategy();
- final TraversalStrategy strategy = new TraversalStrategyVisitor((DefaultGremlinBaseVisitor) antlrToLanguage.tvisitor).visitTraversalStrategy(ctx);
+ final TraversalStrategy strategy = new TraversalStrategyVisitor(antlrToLanguage).visitTraversalStrategy(ctx);
assertEquals(expected, strategy);
assertEquals(ConfigurationConverter.getMap(expected.getConfiguration()),
diff --git a/gremlin-language/src/main/antlr4/Gremlin.g4 b/gremlin-language/src/main/antlr4/Gremlin.g4
index 6f2f9414dc..f280cae1bc 100644
--- a/gremlin-language/src/main/antlr4/Gremlin.g4
+++ b/gremlin-language/src/main/antlr4/Gremlin.g4
@@ -67,7 +67,7 @@ traversalSourceSelfMethod
;
traversalSourceSelfMethod_withBulk
- : 'withBulk' LPAREN booleanLiteral RPAREN
+ : 'withBulk' LPAREN booleanArgument RPAREN
;
traversalSourceSelfMethod_withPath
@@ -75,12 +75,12 @@ traversalSourceSelfMethod_withPath
;
traversalSourceSelfMethod_withSack
- : 'withSack' LPAREN genericLiteral RPAREN
- | 'withSack' LPAREN genericLiteral COMMA traversalOperator RPAREN
+ : 'withSack' LPAREN genericLiteralArgument RPAREN
+ | 'withSack' LPAREN genericLiteralArgument COMMA traversalBiFunctionArgument RPAREN
;
traversalSourceSelfMethod_withSideEffect
- : 'withSideEffect' LPAREN stringBasedLiteral COMMA genericLiteral RPAREN
+ : 'withSideEffect' LPAREN stringArgument COMMA genericLiteralArgument RPAREN
;
traversalSourceSelfMethod_withStrategies
@@ -88,8 +88,8 @@ traversalSourceSelfMethod_withStrategies
;
traversalSourceSelfMethod_with
- : 'with' LPAREN stringBasedLiteral RPAREN
- | 'with' LPAREN stringBasedLiteral COMMA genericLiteral RPAREN
+ : 'with' LPAREN stringArgument RPAREN
+ | 'with' LPAREN stringArgument COMMA genericLiteralArgument RPAREN
;
traversalSourceSpawnMethod
@@ -106,48 +106,48 @@ traversalSourceSpawnMethod
;
traversalSourceSpawnMethod_addE
- : 'addE' LPAREN stringBasedLiteral RPAREN
+ : 'addE' LPAREN stringArgument RPAREN
| 'addE' LPAREN nestedTraversal RPAREN
;
traversalSourceSpawnMethod_addV
: 'addV' LPAREN RPAREN
- | 'addV' LPAREN stringBasedLiteral RPAREN
+ | 'addV' LPAREN stringArgument RPAREN
| 'addV' LPAREN nestedTraversal RPAREN
;
traversalSourceSpawnMethod_E
- : 'E' LPAREN genericLiteralList RPAREN
+ : 'E' LPAREN genericLiteralVarargs RPAREN
;
traversalSourceSpawnMethod_V
- : 'V' LPAREN genericLiteralList RPAREN
+ : 'V' LPAREN genericLiteralVarargs RPAREN
;
traversalSourceSpawnMethod_inject
- : 'inject' LPAREN genericLiteralList RPAREN
+ : 'inject' LPAREN genericLiteralVarargs RPAREN
;
traversalSourceSpawnMethod_io
- : 'io' LPAREN stringBasedLiteral RPAREN
+ : 'io' LPAREN stringArgument RPAREN
;
traversalSourceSpawnMethod_mergeV
- : 'mergeV' LPAREN (genericLiteralMap | nullLiteral) RPAREN #traversalSourceSpawnMethod_mergeV_Map
+ : 'mergeV' LPAREN genericLiteralMapNullableArgument RPAREN #traversalSourceSpawnMethod_mergeV_Map
| 'mergeV' LPAREN nestedTraversal RPAREN #traversalSourceSpawnMethod_mergeV_Traversal
;
traversalSourceSpawnMethod_mergeE
- : 'mergeE' LPAREN (genericLiteralMap | nullLiteral) RPAREN #traversalSourceSpawnMethod_mergeE_Map
+ : 'mergeE' LPAREN genericLiteralMapNullableArgument RPAREN #traversalSourceSpawnMethod_mergeE_Map
| 'mergeE' LPAREN nestedTraversal RPAREN #traversalSourceSpawnMethod_mergeE_Traversal
;
traversalSourceSpawnMethod_call
: 'call' LPAREN RPAREN #traversalSourceSpawnMethod_call_empty
- | 'call' LPAREN stringBasedLiteral RPAREN #traversalSourceSpawnMethod_call_string
- | 'call' LPAREN stringBasedLiteral COMMA genericLiteralMap RPAREN #traversalSourceSpawnMethod_call_string_map
- | 'call' LPAREN stringBasedLiteral COMMA nestedTraversal RPAREN #traversalSourceSpawnMethod_call_string_traversal
- | 'call' LPAREN stringBasedLiteral COMMA genericLiteralMap COMMA nestedTraversal RPAREN #traversalSourceSpawnMethod_call_string_map_traversal
+ | 'call' LPAREN stringArgument RPAREN #traversalSourceSpawnMethod_call_string
+ | 'call' LPAREN stringArgument COMMA genericLiteralMapArgument RPAREN #traversalSourceSpawnMethod_call_string_map
+ | 'call' LPAREN stringArgument COMMA nestedTraversal RPAREN #traversalSourceSpawnMethod_call_string_traversal
+ | 'call' LPAREN stringArgument COMMA genericLiteralMapArgument COMMA nestedTraversal RPAREN #traversalSourceSpawnMethod_call_string_map_traversal
;
traversalSourceSpawnMethod_union
@@ -289,39 +289,39 @@ traversalMethod
| traversalMethod_call
;
traversalMethod_V
- : 'V' LPAREN genericLiteralList RPAREN
+ : 'V' LPAREN genericLiteralVarargs RPAREN
;
traversalMethod_E
- : 'E' LPAREN genericLiteralList RPAREN
+ : 'E' LPAREN genericLiteralVarargs RPAREN
;
traversalMethod_addE
- : 'addE' LPAREN stringBasedLiteral RPAREN #traversalMethod_addE_String
+ : 'addE' LPAREN stringArgument RPAREN #traversalMethod_addE_String
| 'addE' LPAREN nestedTraversal RPAREN #traversalMethod_addE_Traversal
;
traversalMethod_addV
: 'addV' LPAREN RPAREN #traversalMethod_addV_Empty
- | 'addV' LPAREN stringBasedLiteral RPAREN #traversalMethod_addV_String
+ | 'addV' LPAREN stringArgument RPAREN #traversalMethod_addV_String
| 'addV' LPAREN nestedTraversal RPAREN #traversalMethod_addV_Traversal
;
traversalMethod_mergeV
: 'mergeV' LPAREN RPAREN #traversalMethod_mergeV_empty
- | 'mergeV' LPAREN (genericLiteralMap | nullLiteral) RPAREN #traversalMethod_mergeV_Map
+ | 'mergeV' LPAREN genericLiteralMapNullableArgument RPAREN #traversalMethod_mergeV_Map
| 'mergeV' LPAREN nestedTraversal RPAREN #traversalMethod_mergeV_Traversal
;
traversalMethod_mergeE
: 'mergeE' LPAREN RPAREN #traversalMethod_mergeE_empty
- | 'mergeE' LPAREN (genericLiteralMap | nullLiteral) RPAREN #traversalMethod_mergeE_Map
+ | 'mergeE' LPAREN genericLiteralMapNullableArgument RPAREN #traversalMethod_mergeE_Map
| 'mergeE' LPAREN nestedTraversal RPAREN #traversalMethod_mergeE_Traversal
;
traversalMethod_aggregate
- : 'aggregate' LPAREN traversalScope COMMA stringBasedLiteral RPAREN #traversalMethod_aggregate_Scope_String
- | 'aggregate' LPAREN stringBasedLiteral RPAREN #traversalMethod_aggregate_String
+ : 'aggregate' LPAREN traversalScopeArgument COMMA stringArgument RPAREN #traversalMethod_aggregate_Scope_String
+ | 'aggregate' LPAREN stringArgument RPAREN #traversalMethod_aggregate_String
;
traversalMethod_and
@@ -329,21 +329,21 @@ traversalMethod_and
;
traversalMethod_as
- : 'as' LPAREN stringBasedLiteral (COMMA stringLiteralList)? RPAREN
+ : 'as' LPAREN stringArgument (COMMA stringLiteralVarargs)? RPAREN
;
traversalMethod_barrier
- : 'barrier' LPAREN traversalSackMethod RPAREN #traversalMethod_barrier_Consumer
+ : 'barrier' LPAREN traversalSackMethodArgument RPAREN #traversalMethod_barrier_Consumer
| 'barrier' LPAREN RPAREN #traversalMethod_barrier_Empty
- | 'barrier' LPAREN integerLiteral RPAREN #traversalMethod_barrier_int
+ | 'barrier' LPAREN integerArgument RPAREN #traversalMethod_barrier_int
;
traversalMethod_both
- : 'both' LPAREN stringLiteralList RPAREN
+ : 'both' LPAREN stringLiteralVarargs RPAREN
;
traversalMethod_bothE
- : 'bothE' LPAREN stringLiteralList RPAREN
+ : 'bothE' LPAREN stringLiteralVarargs RPAREN
;
traversalMethod_bothV
@@ -355,24 +355,24 @@ traversalMethod_branch
;
traversalMethod_by
- : 'by' LPAREN traversalComparator RPAREN #traversalMethod_by_Comparator
+ : 'by' LPAREN traversalComparatorArgument 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 stringBasedLiteral RPAREN #traversalMethod_by_String
- | 'by' LPAREN stringBasedLiteral COMMA traversalComparator RPAREN #traversalMethod_by_String_Comparator
- | 'by' LPAREN traversalToken RPAREN #traversalMethod_by_T
+ | 'by' LPAREN traversalFunctionArgument RPAREN #traversalMethod_by_Function
+ | 'by' LPAREN traversalFunctionArgument COMMA traversalComparatorArgument RPAREN #traversalMethod_by_Function_Comparator
+ | 'by' LPAREN traversalOrderArgument RPAREN #traversalMethod_by_Order
+ | 'by' LPAREN stringArgument RPAREN #traversalMethod_by_String
+ | 'by' LPAREN stringArgument COMMA traversalComparatorArgument RPAREN #traversalMethod_by_String_Comparator
+ | 'by' LPAREN traversalTokenArgument RPAREN #traversalMethod_by_T
| 'by' LPAREN nestedTraversal RPAREN #traversalMethod_by_Traversal
- | 'by' LPAREN nestedTraversal COMMA traversalComparator RPAREN #traversalMethod_by_Traversal_Comparator
+ | 'by' LPAREN nestedTraversal COMMA traversalComparatorArgument RPAREN #traversalMethod_by_Traversal_Comparator
;
traversalMethod_cap
- : 'cap' LPAREN stringBasedLiteral (COMMA stringLiteralList)? RPAREN
+ : 'cap' LPAREN stringArgument (COMMA stringLiteralVarargs)? RPAREN
;
traversalMethod_choose
- : 'choose' LPAREN traversalFunction RPAREN #traversalMethod_choose_Function
+ : 'choose' LPAREN traversalFunctionArgument 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
@@ -385,7 +385,7 @@ traversalMethod_coalesce
;
traversalMethod_coin
- : 'coin' LPAREN floatLiteral RPAREN
+ : 'coin' LPAREN floatArgument RPAREN
;
traversalMethod_connectedComponent
@@ -393,12 +393,12 @@ traversalMethod_connectedComponent
;
traversalMethod_constant
- : 'constant' LPAREN genericLiteral RPAREN
+ : 'constant' LPAREN genericLiteralArgument RPAREN
;
traversalMethod_count
: 'count' LPAREN RPAREN #traversalMethod_count_Empty
- | 'count' LPAREN traversalScope RPAREN #traversalMethod_count_Scope
+ | 'count' LPAREN traversalScopeArgument RPAREN #traversalMethod_count_Scope
;
traversalMethod_cyclicPath
@@ -406,8 +406,8 @@ traversalMethod_cyclicPath
;
traversalMethod_dedup
- : 'dedup' LPAREN traversalScope (COMMA stringLiteralList)? RPAREN #traversalMethod_dedup_Scope_String
- | 'dedup' LPAREN stringLiteralList RPAREN #traversalMethod_dedup_String
+ : 'dedup' LPAREN traversalScopeArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_dedup_Scope_String
+ | 'dedup' LPAREN stringLiteralVarargs RPAREN #traversalMethod_dedup_String
;
traversalMethod_drop
@@ -415,7 +415,7 @@ traversalMethod_drop
;
traversalMethod_elementMap
- : 'elementMap' LPAREN stringLiteralList RPAREN
+ : 'elementMap' LPAREN stringLiteralVarargs RPAREN
;
traversalMethod_emit
@@ -435,58 +435,58 @@ traversalMethod_flatMap
traversalMethod_fold
: 'fold' LPAREN RPAREN #traversalMethod_fold_Empty
- | 'fold' LPAREN genericLiteral COMMA traversalBiFunction RPAREN #traversalMethod_fold_Object_BiFunction
+ | 'fold' LPAREN genericLiteralArgument COMMA traversalBiFunctionArgument RPAREN #traversalMethod_fold_Object_BiFunction
;
traversalMethod_from
- : 'from' LPAREN stringBasedLiteral RPAREN #traversalMethod_from_String
- | 'from' LPAREN structureVertex RPAREN #traversalMethod_from_Vertex
+ : 'from' LPAREN stringArgument RPAREN #traversalMethod_from_String
+ | 'from' LPAREN structureVertexArgument RPAREN #traversalMethod_from_Vertex
| 'from' LPAREN nestedTraversal RPAREN #traversalMethod_from_Traversal
;
traversalMethod_group
: 'group' LPAREN RPAREN #traversalMethod_group_Empty
- | 'group' LPAREN stringBasedLiteral RPAREN #traversalMethod_group_String
+ | 'group' LPAREN stringArgument RPAREN #traversalMethod_group_String
;
traversalMethod_groupCount
: 'groupCount' LPAREN RPAREN #traversalMethod_groupCount_Empty
- | 'groupCount' LPAREN stringBasedLiteral RPAREN #traversalMethod_groupCount_String
+ | 'groupCount' LPAREN stringArgument RPAREN #traversalMethod_groupCount_String
;
traversalMethod_has
- : 'has' LPAREN stringBasedLiteral RPAREN #traversalMethod_has_String
- | 'has' LPAREN stringBasedLiteral COMMA genericLiteral RPAREN #traversalMethod_has_String_Object
- | 'has' LPAREN stringBasedLiteral COMMA traversalPredicate RPAREN #traversalMethod_has_String_P
- | 'has' LPAREN stringBasedLiteral COMMA stringBasedLiteral COMMA genericLiteral RPAREN #traversalMethod_has_String_String_Object
- | 'has' LPAREN stringBasedLiteral COMMA stringBasedLiteral COMMA traversalPredicate RPAREN #traversalMethod_has_String_String_P
- | 'has' LPAREN stringBasedLiteral 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
+ : 'has' LPAREN stringNullableArgument RPAREN #traversalMethod_has_String
+ | 'has' LPAREN stringNullableArgument COMMA genericLiteralArgument RPAREN #traversalMethod_has_String_Object
+ | 'has' LPAREN stringNullableArgument COMMA traversalPredicate RPAREN #traversalMethod_has_String_P
+ | 'has' LPAREN stringNullableArgument COMMA stringNullableArgument COMMA genericLiteralArgument RPAREN #traversalMethod_has_String_String_Object
+ | 'has' LPAREN stringNullableArgument COMMA stringNullableArgument COMMA traversalPredicate RPAREN #traversalMethod_has_String_String_P
+ | 'has' LPAREN stringNullableArgument COMMA nestedTraversal RPAREN #traversalMethod_has_String_Traversal
+ | 'has' LPAREN traversalTokenArgument COMMA genericLiteralArgument RPAREN #traversalMethod_has_T_Object
+ | 'has' LPAREN traversalTokenArgument COMMA traversalPredicate RPAREN #traversalMethod_has_T_P
+ | 'has' LPAREN traversalTokenArgument COMMA nestedTraversal RPAREN #traversalMethod_has_T_Traversal
;
traversalMethod_hasId
- : 'hasId' LPAREN genericLiteral (COMMA genericLiteralList)? RPAREN #traversalMethod_hasId_Object_Object
+ : 'hasId' LPAREN genericLiteralArgument (COMMA genericLiteralVarargs)? RPAREN #traversalMethod_hasId_Object_Object
| 'hasId' LPAREN traversalPredicate RPAREN #traversalMethod_hasId_P
;
traversalMethod_hasKey
: 'hasKey' LPAREN traversalPredicate RPAREN #traversalMethod_hasKey_P
- | 'hasKey' LPAREN stringBasedLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_hasKey_String_String
+ | 'hasKey' LPAREN stringNullableArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_hasKey_String_String
;
traversalMethod_hasLabel
: 'hasLabel' LPAREN traversalPredicate RPAREN #traversalMethod_hasLabel_P
- | 'hasLabel' LPAREN stringBasedLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_hasLabel_String_String
+ | 'hasLabel' LPAREN stringNullableArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_hasLabel_String_String
;
traversalMethod_hasNot
- : 'hasNot' LPAREN stringBasedLiteral RPAREN
+ : 'hasNot' LPAREN stringNullableArgument RPAREN
;
traversalMethod_hasValue
- : 'hasValue' LPAREN genericLiteral (COMMA genericLiteralList)? RPAREN #traversalMethod_hasValue_Object_Object
+ : 'hasValue' LPAREN genericLiteralArgument (COMMA genericLiteralVarargs)? RPAREN #traversalMethod_hasValue_Object_Object
| 'hasValue' LPAREN traversalPredicate RPAREN #traversalMethod_hasValue_P
;
@@ -499,11 +499,11 @@ traversalMethod_identity
;
traversalMethod_in
- : 'in' LPAREN stringLiteralList RPAREN
+ : 'in' LPAREN stringLiteralVarargs RPAREN
;
traversalMethod_inE
- : 'inE' LPAREN stringLiteralList RPAREN
+ : 'inE' LPAREN stringLiteralVarargs RPAREN
;
traversalMethod_inV
@@ -515,11 +515,11 @@ traversalMethod_index
;
traversalMethod_inject
- : 'inject' LPAREN genericLiteralList RPAREN
+ : 'inject' LPAREN genericLiteralVarargs RPAREN
;
traversalMethod_is
- : 'is' LPAREN genericLiteral RPAREN #traversalMethod_is_Object
+ : 'is' LPAREN genericLiteralArgument RPAREN #traversalMethod_is_Object
| 'is' LPAREN traversalPredicate RPAREN #traversalMethod_is_P
;
@@ -532,8 +532,8 @@ traversalMethod_label
;
traversalMethod_limit
- : 'limit' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_limit_Scope_long
- | 'limit' LPAREN integerLiteral RPAREN #traversalMethod_limit_long
+ : 'limit' LPAREN traversalScopeArgument COMMA integerArgument RPAREN #traversalMethod_limit_Scope_long
+ | 'limit' LPAREN integerArgument RPAREN #traversalMethod_limit_long
;
traversalMethod_local
@@ -542,7 +542,7 @@ traversalMethod_local
traversalMethod_loops
: 'loops' LPAREN RPAREN #traversalMethod_loops_Empty
- | 'loops' LPAREN stringBasedLiteral RPAREN #traversalMethod_loops_String
+ | 'loops' LPAREN stringArgument RPAREN #traversalMethod_loops_String
;
traversalMethod_map
@@ -554,22 +554,22 @@ traversalMethod_match
;
traversalMethod_math
- : 'math' LPAREN stringBasedLiteral RPAREN
+ : 'math' LPAREN stringArgument RPAREN
;
traversalMethod_max
: 'max' LPAREN RPAREN #traversalMethod_max_Empty
- | 'max' LPAREN traversalScope RPAREN #traversalMethod_max_Scope
+ | 'max' LPAREN traversalScopeArgument RPAREN #traversalMethod_max_Scope
;
traversalMethod_mean
: 'mean' LPAREN RPAREN #traversalMethod_mean_Empty
- | 'mean' LPAREN traversalScope RPAREN #traversalMethod_mean_Scope
+ | 'mean' LPAREN traversalScopeArgument RPAREN #traversalMethod_mean_Scope
;
traversalMethod_min
: 'min' LPAREN RPAREN #traversalMethod_min_Empty
- | 'min' LPAREN traversalScope RPAREN #traversalMethod_min_Scope
+ | 'min' LPAREN traversalScopeArgument RPAREN #traversalMethod_min_Scope
;
traversalMethod_not
@@ -578,9 +578,9 @@ traversalMethod_not
traversalMethod_option
: 'option' LPAREN traversalPredicate COMMA nestedTraversal RPAREN #traversalMethod_option_Predicate_Traversal
- | 'option' LPAREN traversalMerge COMMA (genericLiteralMap | nullLiteral) RPAREN #traversalMethod_option_Merge_Map
- | 'option' LPAREN traversalMerge COMMA nestedTraversal RPAREN #traversalMethod_option_Merge_Traversal
- | 'option' LPAREN genericLiteral COMMA nestedTraversal RPAREN #traversalMethod_option_Object_Traversal
+ | 'option' LPAREN traversalMergeArgument COMMA genericLiteralMapNullableArgument RPAREN #traversalMethod_option_Merge_Map
+ | 'option' LPAREN traversalMergeArgument COMMA nestedTraversal RPAREN #traversalMethod_option_Merge_Traversal
+ | 'option' LPAREN genericLiteralArgument COMMA nestedTraversal RPAREN #traversalMethod_option_Object_Traversal
| 'option' LPAREN nestedTraversal RPAREN #traversalMethod_option_Traversal
;
@@ -594,7 +594,7 @@ traversalMethod_or
traversalMethod_order
: 'order' LPAREN RPAREN #traversalMethod_order_Empty
- | 'order' LPAREN traversalScope RPAREN #traversalMethod_order_Scope
+ | 'order' LPAREN traversalScopeArgument RPAREN #traversalMethod_order_Scope
;
traversalMethod_otherV
@@ -602,11 +602,11 @@ traversalMethod_otherV
;
traversalMethod_out
- : 'out' LPAREN stringLiteralList RPAREN
+ : 'out' LPAREN stringLiteralVarargs RPAREN
;
traversalMethod_outE
- : 'outE' LPAREN stringLiteralList RPAREN
+ : 'outE' LPAREN stringLiteralVarargs RPAREN
;
traversalMethod_outV
@@ -615,7 +615,7 @@ traversalMethod_outV
traversalMethod_pageRank
: 'pageRank' LPAREN RPAREN #traversalMethod_pageRank_Empty
- | 'pageRank' LPAREN floatLiteral RPAREN #traversalMethod_pageRank_double
+ | 'pageRank' LPAREN floatArgument RPAREN #traversalMethod_pageRank_double
;
traversalMethod_path
@@ -628,31 +628,31 @@ traversalMethod_peerPressure
traversalMethod_profile
: 'profile' LPAREN RPAREN #traversalMethod_profile_Empty
- | 'profile' LPAREN stringBasedLiteral RPAREN #traversalMethod_profile_String
+ | 'profile' LPAREN stringArgument RPAREN #traversalMethod_profile_String
;
traversalMethod_project
- : 'project' LPAREN stringBasedLiteral (COMMA stringLiteralList)? RPAREN
+ : 'project' LPAREN stringArgument (COMMA stringLiteralVarargs)? RPAREN
;
traversalMethod_properties
- : 'properties' LPAREN stringLiteralList RPAREN
+ : 'properties' LPAREN stringLiteralVarargs RPAREN
;
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
- | 'property' LPAREN (genericLiteralMap | nullLiteral) RPAREN # traversalMethod_property_Object
- | 'property' LPAREN traversalCardinality COMMA (genericLiteralMap | nullLiteral) RPAREN # traversalMethod_property_Cardinality_Object
+ : 'property' LPAREN traversalCardinalityArgument COMMA genericLiteralArgument COMMA genericLiteralArgument (COMMA genericLiteralVarargs)? RPAREN #traversalMethod_property_Cardinality_Object_Object_Object
+ | 'property' LPAREN genericLiteralArgument COMMA genericLiteralArgument (COMMA genericLiteralVarargs)? RPAREN #traversalMethod_property_Object_Object_Object
+ | 'property' LPAREN genericLiteralMapNullableArgument RPAREN # traversalMethod_property_Object
+ | 'property' LPAREN traversalCardinalityArgument COMMA genericLiteralMapNullableArgument RPAREN # traversalMethod_property_Cardinality_Object
;
traversalMethod_propertyMap
- : 'propertyMap' LPAREN stringLiteralList RPAREN
+ : 'propertyMap' LPAREN stringLiteralVarargs RPAREN
;
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
+ : 'range' LPAREN traversalScopeArgument COMMA integerArgument COMMA integerArgument RPAREN #traversalMethod_range_Scope_long_long
+ | 'range' LPAREN integerArgument COMMA integerArgument RPAREN #traversalMethod_range_long_long
;
traversalMethod_read
@@ -660,27 +660,27 @@ traversalMethod_read
;
traversalMethod_repeat
- : 'repeat' LPAREN stringBasedLiteral COMMA nestedTraversal RPAREN #traversalMethod_repeat_String_Traversal
+ : 'repeat' LPAREN stringArgument COMMA nestedTraversal RPAREN #traversalMethod_repeat_String_Traversal
| 'repeat' LPAREN nestedTraversal RPAREN #traversalMethod_repeat_Traversal
;
traversalMethod_sack
- : 'sack' LPAREN traversalBiFunction RPAREN #traversalMethod_sack_BiFunction
+ : 'sack' LPAREN traversalBiFunctionArgument RPAREN #traversalMethod_sack_BiFunction
| 'sack' LPAREN RPAREN #traversalMethod_sack_Empty
;
traversalMethod_sample
- : 'sample' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_sample_Scope_int
- | 'sample' LPAREN integerLiteral RPAREN #traversalMethod_sample_int
+ : 'sample' LPAREN traversalScopeArgument COMMA integerArgument RPAREN #traversalMethod_sample_Scope_int
+ | 'sample' LPAREN integerArgument RPAREN #traversalMethod_sample_int
;
traversalMethod_select
- : 'select' LPAREN traversalColumn RPAREN #traversalMethod_select_Column
- | 'select' LPAREN traversalPop COMMA stringBasedLiteral RPAREN #traversalMethod_select_Pop_String
- | 'select' LPAREN traversalPop COMMA stringBasedLiteral COMMA stringBasedLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_select_Pop_String_String_String
- | 'select' LPAREN traversalPop COMMA nestedTraversal RPAREN #traversalMethod_select_Pop_Traversal
- | 'select' LPAREN stringBasedLiteral RPAREN #traversalMethod_select_String
- | 'select' LPAREN stringBasedLiteral COMMA stringBasedLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_select_String_String_String
+ : 'select' LPAREN traversalColumnArgument RPAREN #traversalMethod_select_Column
+ | 'select' LPAREN traversalPopArgument COMMA stringArgument RPAREN #traversalMethod_select_Pop_String
+ | 'select' LPAREN traversalPopArgument COMMA stringArgument COMMA stringArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_select_Pop_String_String_String
+ | 'select' LPAREN traversalPopArgument COMMA nestedTraversal RPAREN #traversalMethod_select_Pop_Traversal
+ | 'select' LPAREN stringArgument RPAREN #traversalMethod_select_String
+ | 'select' LPAREN stringArgument COMMA stringArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_select_String_String_String
| 'select' LPAREN nestedTraversal RPAREN #traversalMethod_select_Traversal
;
@@ -697,61 +697,61 @@ traversalMethod_simplePath
;
traversalMethod_skip
- : 'skip' LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_skip_Scope_long
- | 'skip' LPAREN integerLiteral RPAREN #traversalMethod_skip_long
+ : 'skip' LPAREN traversalScopeArgument COMMA integerArgument RPAREN #traversalMethod_skip_Scope_long
+ | 'skip' LPAREN integerArgument RPAREN #traversalMethod_skip_long
;
traversalMethod_store
- : 'store' LPAREN stringBasedLiteral RPAREN
+ : 'store' LPAREN stringArgument RPAREN
;
traversalMethod_subgraph
- : 'subgraph' LPAREN stringBasedLiteral RPAREN
+ : 'subgraph' LPAREN stringArgument RPAREN
;
traversalMethod_sum
: 'sum' LPAREN RPAREN #traversalMethod_sum_Empty
- | 'sum' LPAREN traversalScope RPAREN #traversalMethod_sum_Scope
+ | 'sum' LPAREN traversalScopeArgument RPAREN #traversalMethod_sum_Scope
;
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
+ | 'tail' LPAREN traversalScopeArgument RPAREN #traversalMethod_tail_Scope
+ | 'tail' LPAREN traversalScopeArgument COMMA integerArgument RPAREN #traversalMethod_tail_Scope_long
+ | 'tail' LPAREN integerArgument RPAREN #traversalMethod_tail_long
;
traversalMethod_fail
: 'fail' LPAREN RPAREN #traversalMethod_fail_Empty
- | 'fail' LPAREN stringBasedLiteral RPAREN #traversalMethod_fail_String
+ | 'fail' LPAREN stringArgument RPAREN #traversalMethod_fail_String
;
traversalMethod_timeLimit
- : 'timeLimit' LPAREN integerLiteral RPAREN
+ : 'timeLimit' LPAREN integerArgument RPAREN
;
traversalMethod_times
- : 'times' LPAREN integerLiteral RPAREN
+ : 'times' LPAREN integerArgument RPAREN
;
traversalMethod_to
- : 'to' LPAREN traversalDirection (COMMA stringLiteralList)? RPAREN #traversalMethod_to_Direction_String
- | 'to' LPAREN stringBasedLiteral RPAREN #traversalMethod_to_String
- | 'to' LPAREN structureVertex RPAREN #traversalMethod_to_Vertex
+ : 'to' LPAREN traversalDirectionArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_to_Direction_String
+ | 'to' LPAREN stringArgument RPAREN #traversalMethod_to_String
+ | 'to' LPAREN structureVertexArgument RPAREN #traversalMethod_to_Vertex
| 'to' LPAREN nestedTraversal RPAREN #traversalMethod_to_Traversal
;
traversalMethod_toE
- : 'toE' LPAREN traversalDirection (COMMA stringLiteralList)? RPAREN
+ : 'toE' LPAREN traversalDirectionArgument (COMMA stringLiteralVarargs)? RPAREN
;
traversalMethod_toV
- : 'toV' LPAREN traversalDirection RPAREN
+ : 'toV' LPAREN traversalDirectionArgument RPAREN
;
traversalMethod_tree
: 'tree' LPAREN RPAREN #traversalMethod_tree_Empty
- | 'tree' LPAREN stringBasedLiteral RPAREN #traversalMethod_tree_String
+ | 'tree' LPAREN stringArgument RPAREN #traversalMethod_tree_String
;
traversalMethod_unfold
@@ -772,23 +772,23 @@ traversalMethod_value
;
traversalMethod_valueMap
- : 'valueMap' LPAREN stringLiteralList RPAREN #traversalMethod_valueMap_String
- | 'valueMap' LPAREN booleanLiteral (COMMA stringLiteralList)? RPAREN #traversalMethod_valueMap_boolean_String
+ : 'valueMap' LPAREN stringLiteralVarargs RPAREN #traversalMethod_valueMap_String
+ | 'valueMap' LPAREN booleanArgument (COMMA stringLiteralVarargs)? RPAREN #traversalMethod_valueMap_boolean_String
;
traversalMethod_values
- : 'values' LPAREN stringLiteralList RPAREN
+ : 'values' LPAREN stringLiteralVarargs RPAREN
;
traversalMethod_where
: 'where' LPAREN traversalPredicate RPAREN #traversalMethod_where_P
- | 'where' LPAREN stringBasedLiteral COMMA traversalPredicate RPAREN #traversalMethod_where_String_P
+ | 'where' LPAREN stringArgument COMMA traversalPredicate RPAREN #traversalMethod_where_String_P
| 'where' LPAREN nestedTraversal RPAREN #traversalMethod_where_Traversal
;
traversalMethod_with
- : 'with' LPAREN stringBasedLiteral RPAREN #traversalMethod_with_String
- | 'with' LPAREN stringBasedLiteral COMMA genericLiteral RPAREN #traversalMethod_with_String_Object
+ : 'with' LPAREN (withOptionKeys | stringArgument) RPAREN #traversalMethod_with_String
+ | 'with' LPAREN (withOptionKeys | stringArgument) COMMA (withOptionsValues | ioOptionsValues | genericLiteralArgument) RPAREN #traversalMethod_with_String_Object
;
traversalMethod_write
@@ -800,10 +800,10 @@ traversalMethod_element
;
traversalMethod_call
- : 'call' LPAREN stringBasedLiteral RPAREN #traversalMethod_call_string
- | 'call' LPAREN stringBasedLiteral COMMA genericLiteralMap RPAREN #traversalMethod_call_string_map
- | 'call' LPAREN stringBasedLiteral COMMA nestedTraversal RPAREN #traversalMethod_call_string_traversal
- | 'call' LPAREN stringBasedLiteral COMMA genericLiteralMap COMMA nestedTraversal RPAREN #traversalMethod_call_string_map_traversal
+ : 'call' LPAREN stringArgument RPAREN #traversalMethod_call_string
+ | 'call' LPAREN stringArgument COMMA genericLiteralMapArgument RPAREN #traversalMethod_call_string_map
+ | 'call' LPAREN stringArgument COMMA nestedTraversal RPAREN #traversalMethod_call_string_traversal
+ | 'call' LPAREN stringArgument COMMA genericLiteralMapArgument COMMA nestedTraversal RPAREN #traversalMethod_call_string_map_traversal
;
@@ -816,7 +816,7 @@ traversalMethod_call
// fail fast scenarios in that processing model. It is not relevant to the grammar however when a user is creating
// the Vertex to be used in a Traversal and therefore both id and label are required.
structureVertex
- : NEW ('Vertex'|'ReferenceVertex') LPAREN genericLiteral COMMA stringBasedLiteral RPAREN
+ : NEW ('Vertex'|'ReferenceVertex') LPAREN genericLiteralArgument COMMA stringArgument RPAREN
;
traversalStrategy
@@ -828,7 +828,7 @@ traversalStrategy
: 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()
- | NEW 'SeedStrategy' LPAREN 'seed' COLON integerLiteral RPAREN
+ | NEW 'SeedStrategy' LPAREN 'seed' COLON integerArgument RPAREN
// | '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()
@@ -862,9 +862,9 @@ traversalStrategyArgs_ProductiveByStrategy
;
traversalStrategyArgs_PartitionStrategy
- : 'includeMetaProperties' COLON booleanLiteral
- | 'writePartition' COLON stringBasedLiteral
- | 'partitionKey' COLON stringBasedLiteral
+ : 'includeMetaProperties' COLON booleanArgument
+ | 'writePartition' COLON stringArgument
+ | 'partitionKey' COLON stringArgument
| 'readPartitions' COLON stringLiteralList
;
@@ -872,18 +872,18 @@ traversalStrategyArgs_SubgraphStrategy
: 'vertices' COLON nestedTraversal
| 'edges' COLON nestedTraversal
| 'vertexProperties' COLON nestedTraversal
- | 'checkAdjacentVertices' COLON booleanLiteral
+ | 'checkAdjacentVertices' COLON booleanArgument
;
traversalStrategyArgs_EdgeLabelVerificationStrategy
- : 'throwException' COLON booleanLiteral
- | 'logWarning' COLON booleanLiteral
+ : 'throwException' COLON booleanArgument
+ | 'logWarning' COLON booleanArgument
;
traversalStrategyArgs_ReservedKeysVerificationStrategy
: 'keys' COLON stringLiteralList
- | 'throwException' COLON booleanLiteral
- | 'logWarning' COLON booleanLiteral
+ | 'throwException' COLON booleanArgument
+ | 'logWarning' COLON booleanArgument
;
traversalScope
@@ -1018,49 +1018,49 @@ traversalBiFunction
;
traversalPredicate_eq
- : ('P.eq' | 'eq') LPAREN genericLiteral RPAREN
+ : ('P.eq' | 'eq') LPAREN genericLiteralArgument RPAREN
;
traversalPredicate_neq
- : ('P.neq' | 'neq') LPAREN genericLiteral RPAREN
+ : ('P.neq' | 'neq') LPAREN genericLiteralArgument RPAREN
;
traversalPredicate_lt
- : ('P.lt' | 'lt') LPAREN genericLiteral RPAREN
+ : ('P.lt' | 'lt') LPAREN genericLiteralArgument RPAREN
;
traversalPredicate_lte
- : ('P.lte' | 'lte') LPAREN genericLiteral RPAREN
+ : ('P.lte' | 'lte') LPAREN genericLiteralArgument RPAREN
;
traversalPredicate_gt
- : ('P.gt' | 'gt') LPAREN genericLiteral RPAREN
+ : ('P.gt' | 'gt') LPAREN genericLiteralArgument RPAREN
;
traversalPredicate_gte
- : ('P.gte' | 'gte') LPAREN genericLiteral RPAREN
+ : ('P.gte' | 'gte') LPAREN genericLiteralArgument RPAREN
;
traversalPredicate_inside
- : ('P.inside' | 'inside') LPAREN genericLiteral COMMA genericLiteral RPAREN
+ : ('P.inside' | 'inside') LPAREN genericLiteralArgument COMMA genericLiteralArgument RPAREN
;
traversalPredicate_outside
- : ('P.outside' | 'outside') LPAREN genericLiteral COMMA genericLiteral RPAREN
+ : ('P.outside' | 'outside') LPAREN genericLiteralArgument COMMA genericLiteralArgument RPAREN
;
traversalPredicate_between
- : ('P.between' | 'between') LPAREN genericLiteral COMMA genericLiteral RPAREN
+ : ('P.between' | 'between') LPAREN genericLiteralArgument COMMA genericLiteralArgument RPAREN
;
traversalPredicate_within
: ('P.within' | 'within') LPAREN RPAREN
- | ('P.within' | 'within') LPAREN genericLiteralList RPAREN
+ | ('P.within' | 'within') LPAREN genericLiteralListArgument RPAREN
;
traversalPredicate_without
: ('P.without' | 'without') LPAREN RPAREN
- | ('P.without' | 'without') LPAREN genericLiteralList RPAREN
+ | ('P.without' | 'without') LPAREN genericLiteralListArgument RPAREN
;
traversalPredicate_not
@@ -1068,35 +1068,35 @@ traversalPredicate_not
;
traversalPredicate_containing
- : ('TextP.containing' | 'containing') LPAREN stringBasedLiteral RPAREN
+ : ('TextP.containing' | 'containing') LPAREN stringArgument RPAREN
;
traversalPredicate_notContaining
- : ('TextP.notContaining' | 'notContaining') LPAREN stringBasedLiteral RPAREN
+ : ('TextP.notContaining' | 'notContaining') LPAREN stringArgument RPAREN
;
traversalPredicate_startingWith
- : ('TextP.startingWith' | 'startingWith') LPAREN stringBasedLiteral RPAREN
+ : ('TextP.startingWith' | 'startingWith') LPAREN stringArgument RPAREN
;
traversalPredicate_notStartingWith
- : ('TextP.notStartingWith' | 'notStartingWith') LPAREN stringBasedLiteral RPAREN
+ : ('TextP.notStartingWith' | 'notStartingWith') LPAREN stringArgument RPAREN
;
traversalPredicate_endingWith
- : ('TextP.endingWith' | 'endingWith') LPAREN stringBasedLiteral RPAREN
+ : ('TextP.endingWith' | 'endingWith') LPAREN stringArgument RPAREN
;
traversalPredicate_notEndingWith
- : ('TextP.notEndingWith' | 'notEndingWith') LPAREN stringBasedLiteral RPAREN
+ : ('TextP.notEndingWith' | 'notEndingWith') LPAREN stringArgument RPAREN
;
traversalPredicate_regex
- : ('TextP.regex' | 'regex') LPAREN stringBasedLiteral RPAREN
+ : ('TextP.regex' | 'regex') LPAREN stringArgument RPAREN
;
traversalPredicate_notRegex
- : ('TextP.notRegex' | 'notRegex') LPAREN stringBasedLiteral RPAREN
+ : ('TextP.notRegex' | 'notRegex') LPAREN stringArgument RPAREN
;
traversalTerminalMethod_explain
@@ -1138,175 +1138,178 @@ traversalSelfMethod_none
// Gremlin specific lexer rules
-gremlinStringConstants
- : withOptionsStringConstants
- | shortestPathStringConstants
+withOptionKeys
+ : shortestPathConstants
| connectedComponentConstants
- | pageRankStringConstants
- | peerPressureStringConstants
- | ioOptionsStringConstants
+ | pageRankConstants
+ | peerPressureConstants
+ | ioOptionsKeys
+ | withOptionsConstants_tokens
+ | withOptionsConstants_indexer
;
connectedComponentConstants
- : gremlinStringConstants_connectedComponentStringConstants_component
- | gremlinStringConstants_connectedComponentStringConstants_edges
- | gremlinStringConstants_connectedComponentStringConstants_propertyName
+ : connectedComponentConstants_component
+ | connectedComponentConstants_edges
+ | connectedComponentConstants_propertyName
;
-pageRankStringConstants
- : gremlinStringConstants_pageRankStringConstants_edges
- | gremlinStringConstants_pageRankStringConstants_times
- | gremlinStringConstants_pageRankStringConstants_propertyName
+pageRankConstants
+ : pageRankConstants_edges
+ | pageRankConstants_times
+ | pageRankConstants_propertyName
;
-peerPressureStringConstants
- : gremlinStringConstants_peerPressureStringConstants_edges
- | gremlinStringConstants_peerPressureStringConstants_times
- | gremlinStringConstants_peerPressureStringConstants_propertyName
+peerPressureConstants
+ : peerPressureConstants_edges
+ | peerPressureConstants_times
+ | peerPressureConstants_propertyName
;
-shortestPathStringConstants
- : gremlinStringConstants_shortestPathStringConstants_target
- | gremlinStringConstants_shortestPathStringConstants_edges
- | gremlinStringConstants_shortestPathStringConstants_distance
- | gremlinStringConstants_shortestPathStringConstants_maxDistance
- | gremlinStringConstants_shortestPathStringConstants_includeEdges
+shortestPathConstants
+ : shortestPathConstants_target
+ | shortestPathConstants_edges
+ | shortestPathConstants_distance
+ | shortestPathConstants_maxDistance
+ | shortestPathConstants_includeEdges
;
-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
+withOptionsValues
+ : withOptionsConstants_tokens
+ | withOptionsConstants_none
+ | withOptionsConstants_ids
+ | withOptionsConstants_labels
+ | withOptionsConstants_keys
+ | withOptionsConstants_values
+ | withOptionsConstants_all
+ | withOptionsConstants_list
+ | withOptionsConstants_map
;
-ioOptionsStringConstants
- : gremlinStringConstants_ioOptionsStringConstants_reader
- | gremlinStringConstants_ioOptionsStringConstants_writer
- | gremlinStringConstants_ioOptionsStringConstants_gryo
- | gremlinStringConstants_ioOptionsStringConstants_graphson
- | gremlinStringConstants_ioOptionsStringConstants_graphml
+ioOptionsKeys
+ : ioOptionsConstants_reader
+ | ioOptionsConstants_writer
;
-gremlinStringConstants_connectedComponentStringConstants_component
+ioOptionsValues
+ : ioOptionsConstants_gryo
+ | ioOptionsConstants_graphson
+ | ioOptionsConstants_graphml
+ ;
+
+connectedComponentConstants_component
: connectedComponentStringConstant DOT 'component'
;
-gremlinStringConstants_connectedComponentStringConstants_edges
+connectedComponentConstants_edges
: connectedComponentStringConstant DOT 'edges'
;
-gremlinStringConstants_connectedComponentStringConstants_propertyName
+connectedComponentConstants_propertyName
: connectedComponentStringConstant DOT 'propertyName'
;
-gremlinStringConstants_pageRankStringConstants_edges
+pageRankConstants_edges
: pageRankStringConstant DOT 'edges'
;
-gremlinStringConstants_pageRankStringConstants_times
+pageRankConstants_times
: pageRankStringConstant DOT 'times'
;
-gremlinStringConstants_pageRankStringConstants_propertyName
+pageRankConstants_propertyName
: pageRankStringConstant DOT 'propertyName'
;
-gremlinStringConstants_peerPressureStringConstants_edges
+peerPressureConstants_edges
: peerPressureStringConstant DOT 'edges'
;
-gremlinStringConstants_peerPressureStringConstants_times
+peerPressureConstants_times
: peerPressureStringConstant DOT 'times'
;
-gremlinStringConstants_peerPressureStringConstants_propertyName
+peerPressureConstants_propertyName
: peerPressureStringConstant DOT 'propertyName'
;
-gremlinStringConstants_shortestPathStringConstants_target
+shortestPathConstants_target
: shortestPathStringConstant DOT 'target'
;
-gremlinStringConstants_shortestPathStringConstants_edges
+shortestPathConstants_edges
: shortestPathStringConstant DOT 'edges'
;
-gremlinStringConstants_shortestPathStringConstants_distance
+shortestPathConstants_distance
: shortestPathStringConstant DOT 'distance'
;
-gremlinStringConstants_shortestPathStringConstants_maxDistance
+shortestPathConstants_maxDistance
: shortestPathStringConstant DOT 'maxDistance'
;
-gremlinStringConstants_shortestPathStringConstants_includeEdges
+shortestPathConstants_includeEdges
: shortestPathStringConstant DOT 'includeEdges'
;
-gremlinStringConstants_withOptionsStringConstants_tokens
+withOptionsConstants_tokens
: withOptionsStringConstant DOT 'tokens'
;
-gremlinStringConstants_withOptionsStringConstants_none
+withOptionsConstants_none
: withOptionsStringConstant DOT 'none'
;
-gremlinStringConstants_withOptionsStringConstants_ids
+withOptionsConstants_ids
: withOptionsStringConstant DOT 'ids'
;
-gremlinStringConstants_withOptionsStringConstants_labels
+withOptionsConstants_labels
: withOptionsStringConstant DOT 'labels'
;
-gremlinStringConstants_withOptionsStringConstants_keys
+withOptionsConstants_keys
: withOptionsStringConstant DOT 'keys'
;
-gremlinStringConstants_withOptionsStringConstants_values
+withOptionsConstants_values
: withOptionsStringConstant DOT 'values'
;
-gremlinStringConstants_withOptionsStringConstants_all
+withOptionsConstants_all
: withOptionsStringConstant DOT 'all'
;
-gremlinStringConstants_withOptionsStringConstants_indexer
+withOptionsConstants_indexer
: withOptionsStringConstant DOT 'indexer'
;
-gremlinStringConstants_withOptionsStringConstants_list
+withOptionsConstants_list
: withOptionsStringConstant DOT 'list'
;
-gremlinStringConstants_withOptionsStringConstants_map
+withOptionsConstants_map
: withOptionsStringConstant DOT 'map'
;
-gremlinStringConstants_ioOptionsStringConstants_reader
+ioOptionsConstants_reader
: ioOptionsStringConstant DOT 'reader'
;
-gremlinStringConstants_ioOptionsStringConstants_writer
+ioOptionsConstants_writer
: ioOptionsStringConstant DOT 'writer'
;
-gremlinStringConstants_ioOptionsStringConstants_gryo
+ioOptionsConstants_gryo
: ioOptionsStringConstant DOT 'gryo'
;
-gremlinStringConstants_ioOptionsStringConstants_graphson
+ioOptionsConstants_graphson
: ioOptionsStringConstant DOT 'graphson'
;
-gremlinStringConstants_ioOptionsStringConstants_graphml
+ioOptionsConstants_graphml
: ioOptionsStringConstant DOT 'graphml'
;
@@ -1334,6 +1337,117 @@ ioOptionsStringConstant
: 'IO'
;
+booleanArgument
+ : booleanLiteral
+ | variable
+ ;
+
+integerArgument
+ : integerLiteral
+ | variable
+ ;
+
+floatArgument
+ : floatLiteral
+ | variable
+ ;
+
+stringArgument
+ : stringLiteral
+ | variable
+ ;
+
+stringNullableArgument
+ : stringNullableLiteral
+ | variable
+ ;
+
+genericLiteralArgument
+ : genericLiteral
+ | variable
+ ;
+
+genericLiteralListArgument
+ : genericLiteralList
+ | variable
+ ;
+
+genericLiteralMapArgument
+ : genericLiteralMap
+ | variable
+ ;
+
+genericLiteralMapNullableArgument
+ : genericLiteralMap
+ | nullLiteral
+ | variable
+ ;
+
+structureVertexArgument
+ : structureVertex
+ | variable
+ ;
+
+traversalCardinalityArgument
+ : traversalCardinality
+ | variable
+ ;
+
+traversalColumnArgument
+ : traversalColumn
+ | variable
+ ;
+
+traversalDirectionArgument
+ : traversalDirection
+ | variable
+ ;
+
+traversalMergeArgument
+ : traversalMerge
+ | variable
+ ;
+
+traversalOrderArgument
+ : traversalOrder
+ | variable
+ ;
+
+traversalPopArgument
+ : traversalPop
+ | variable
+ ;
+
+traversalSackMethodArgument
+ : traversalSackMethod
+ | variable
+ ;
+
+traversalScopeArgument
+ : traversalScope
+ | variable
+ ;
+
+traversalTokenArgument
+ : traversalToken
+ | variable
+ ;
+
+traversalComparatorArgument
+ : traversalComparator
+ | variable
+ ;
+
+traversalFunctionArgument
+ : traversalFunction
+ | variable
+ ;
+
+traversalBiFunctionArgument
+ : traversalBiFunction
+ | variable
+ ;
+
traversalStrategyList
: traversalStrategyExpr?
;
@@ -1350,6 +1464,10 @@ nestedTraversalExpr
: nestedTraversal (COMMA nestedTraversal)*
;
+genericLiteralVarargs
+ : (genericLiteralArgument (COMMA genericLiteralArgument)*)?
+ ;
+
genericLiteralList
: genericLiteralExpr?
;
@@ -1367,19 +1485,23 @@ genericLiteralCollection
: LBRACK (genericLiteral (COMMA genericLiteral)*)? RBRACK
;
+stringLiteralVarargs
+ : (stringNullableArgument (COMMA stringNullableArgument)*)?
+ ;
+
stringLiteralList
: stringLiteralExpr?
| LBRACK stringLiteralExpr? RBRACK
;
stringLiteralExpr
- : stringBasedLiteral (COMMA stringBasedLiteral)*
+ : stringNullableLiteral (COMMA stringNullableLiteral)*
;
genericLiteral
: numericLiteral
| booleanLiteral
- | stringBasedLiteral
+ | stringLiteral
| dateLiteral
| nullLiteral
| nanLiteral
@@ -1403,7 +1525,7 @@ genericLiteralMap
| LBRACK mapEntry (COMMA mapEntry)* RBRACK
;
-// allow builds of Map that sorta make sense in the Gremlin context
+// allow builds of Map that sorta make sense in the Gremlin context.
mapEntry
: NEW COLON genericLiteral // explicit for [new: true] - if we had other keywords like that maybe we'd group them up?
| (LPAREN stringLiteral RPAREN | stringLiteral) COLON genericLiteral
@@ -1420,6 +1542,12 @@ stringLiteral
| NonEmptyStringLiteral
;
+stringNullableLiteral
+ : EmptyStringLiteral
+ | NonEmptyStringLiteral
+ | NullLiteral
+ ;
+
integerLiteral
: IntegerLiteral
;
@@ -1437,15 +1565,8 @@ booleanLiteral
: BooleanLiteral
;
-stringBasedLiteral
- : EmptyStringLiteral
- | NonEmptyStringLiteral
- | NullLiteral
- | gremlinStringConstants
- ;
-
dateLiteral
- : 'datetime' LPAREN stringLiteral RPAREN
+ : 'datetime' LPAREN stringArgument RPAREN
;
nullLiteral
@@ -1460,6 +1581,10 @@ infLiteral
: SignedInfLiteral
;
+variable
+ : Identifier
+ ;
+
/*********************************************
LEXER RULES
**********************************************/
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinDriverIntegrateTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinDriverIntegrateTest.java
index ad380f9c81..209f16710b 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinDriverIntegrateTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinDriverIntegrateTest.java
@@ -1084,6 +1084,25 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
}
}
+ @Test
+ public void shouldEvalInGremlinLangWithParameters() throws Exception {
+ final Cluster cluster = TestClientFactory.open();
+ final Client client = cluster.connect();
+
+ try {
+ final RequestOptions ro = RequestOptions.build().language("gremlin-lang").
+ addParameter("x", 100).
+ addParameter("y", "test").
+ addParameter("z", true).create();
+ final List<Result> l = client.submit("g.inject(x, y, z)", ro).all().get();
+ assertEquals(100, l.get(0).getInt());
+ assertEquals("test", l.get(1).getString());
+ assertEquals(true, l.get(2).getBoolean());
+ } finally {
+ cluster.close();
+ }
+ }
+
@Test
public void shouldCloseSession() throws Exception {
final Cluster cluster = TestClientFactory.build().create();