[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733218#comment-17733218
]
ASF GitHub Bot commented on TINKERPOP-2959:
-------------------------------------------
vkagamlyk commented on code in PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#discussion_r1231504873
##########
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 {
Review Comment:
is it possible to get Vararg as `Iterable`?
> Allow the grammar to support parameters
> ---------------------------------------
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
> Affects Versions: 3.6.4
> Reporter: Stephen Mallette
> Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
