This is an automated email from the ASF dual-hosted git repository.

spmallette pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git


The following commit(s) were added to refs/heads/master by this push:
     new a72704be3a Fixed bug in go translator for strategies - namespace 
missing CTR
     new 4f27528cfb Merge branch '3.8-dev'
a72704be3a is described below

commit a72704be3a32da7ae0be07cd0bc216b93447a153
Author: Stephen Mallette <[email protected]>
AuthorDate: Wed Mar 26 12:46:54 2025 -0400

    Fixed bug in go translator for strategies - namespace missing CTR
---
 .../language/translator/GoTranslateVisitor.java    | 15 +++++
 .../language/translator/GremlinTranslatorTest.java |  4 +-
 gremlin-go/driver/cucumber/gremlin.go              | 66 +++++++++++-----------
 3 files changed, 50 insertions(+), 35 deletions(-)

diff --git 
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GoTranslateVisitor.java
 
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GoTranslateVisitor.java
index 6bf7324c80..c6df7f29d6 100644
--- 
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GoTranslateVisitor.java
+++ 
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GoTranslateVisitor.java
@@ -215,6 +215,21 @@ public class GoTranslateVisitor extends 
AbstractTranslateVisitor {
         return null;
     }
 
+    @Override
+    public Void visitTraversalSourceSelfMethod_withoutStrategies(final 
GremlinParser.TraversalSourceSelfMethod_withoutStrategiesContext ctx) {
+        sb.append("WithoutStrategies(");
+        sb.append(GO_PACKAGE_NAME).append(ctx.classType().getText());
+
+        if (ctx.classTypeList() != null && ctx.classTypeList().classTypeExpr() 
!= null) {
+            for (GremlinParser.ClassTypeContext classTypeContext : 
ctx.classTypeList().classTypeExpr().classType()) {
+                sb.append(", 
").append(GO_PACKAGE_NAME).append(classTypeContext.getText());
+            }
+        }
+
+        sb.append(")");
+        return null;
+    }
+
     @Override
     public Void visitConfiguration(final GremlinParser.ConfigurationContext 
ctx) {
         // form of three tokens of key:value to become key=value
diff --git 
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
 
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
index fcf023a83c..2a7f51c1b7 100644
--- 
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
+++ 
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
@@ -662,7 +662,7 @@ public class GremlinTranslatorTest {
                             null,
                             null,
                             "g.WithoutStrategies(typeof(ReadOnlyStrategy))",
-                            "g.WithoutStrategies(ReadOnlyStrategy)", // go - 
needs TINKERPOP-3055
+                            "g.WithoutStrategies(gremlingo.ReadOnlyStrategy)", 
// go - needs TINKERPOP-3055
                             null,
                             "g.withoutStrategies(ReadOnlyStrategy.class)",
                             "g.withoutStrategies(ReadOnlyStrategy)",  // 
javascript needs TINKERPOP-3055
@@ -671,7 +671,7 @@ public class GremlinTranslatorTest {
                             null,
                             null,
                             "g.WithoutStrategies(typeof(ReadOnlyStrategy), 
typeof(PathRetractionStrategy), typeof(FilterRankingStrategy))",
-                            "g.WithoutStrategies(ReadOnlyStrategy, 
PathRetractionStrategy, FilterRankingStrategy)", // go - needs TINKERPOP-3055
+                            "g.WithoutStrategies(gremlingo.ReadOnlyStrategy, 
gremlingo.PathRetractionStrategy, gremlingo.FilterRankingStrategy)", // go - 
needs TINKERPOP-3055
                             null,
                             "g.withoutStrategies(ReadOnlyStrategy.class, 
PathRetractionStrategy.class, FilterRankingStrategy.class)",
                             "g.withoutStrategies(ReadOnlyStrategy, 
PathRetractionStrategy, FilterRankingStrategy)",  // javascript - needs 
TINKERPOP-3055
diff --git a/gremlin-go/driver/cucumber/gremlin.go 
b/gremlin-go/driver/cucumber/gremlin.go
index c8fe498894..f2c7887bf1 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -371,58 +371,58 @@ var translationMap = map[string][]func(g 
*gremlingo.GraphTraversalSource, p map[
     
"g_V_asXnX_whereXorXselectXnX_hasLabelXsoftwareX_selectXnX_hasLabelXpersonXXX_selectXnX_byXnameX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().As("n").Where(gremlingo.T__.Or(gremlingo.T__.Select("n").HasLabel("software"),
 gremlingo.T__.Select("n").HasLabel("person"))).Select("n").By("name")}}, 
     "g_V_hasLabelXpersonX_asXxX_whereXinEXknowsX_count_isXgteX1XXX_selectXxX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.V().HasLabel("person").As("x").Where(gremlingo.T__.InE("knows").Count().Is(gremlingo.P.Gte(1))).Select("x")}},
 
     "g_withStrategiesXAdjacentToIncidentStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.AdjacentToIncidentStrategy()).V()}}, 
-    "g_withoutStrategiesXAdjacentToIncidentStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(AdjacentToIncidentStrategy).V()}}, 
+    "g_withoutStrategiesXAdjacentToIncidentStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.AdjacentToIncidentStrategy).V()}}, 
     "g_withStrategiesXAdjacentToIncidentStrategyX_V_out_count": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.AdjacentToIncidentStrategy()).V().Out().Count()}}, 
     "g_withStrategiesXAdjacentToIncidentStrategyX_V_whereXoutX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.AdjacentToIncidentStrategy()).V().Where(gremlingo.T__.Out())}},
 
     
"g_withStrategiesXByModulatorOptimizationStrategyX_V_order_byXvaluesXnameXX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ByModulatorOptimizationStrategy()).V().Order().By(gremlingo.T__.Values("name"))}},
 
-    
"g_withoutStrategiesXByModulatorOptimizationStrategyX_V_order_byXvaluesXnameXX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(ByModulatorOptimizationStrategy).V().Order().By(gremlingo.T__.Values("name"))}},
 
+    
"g_withoutStrategiesXByModulatorOptimizationStrategyX_V_order_byXvaluesXnameXX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.ByModulatorOptimizationStrategy).V().Order().By(gremlingo.T__.Values("name"))}},
 
     "g_withStrategiesXComputerFinalizationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ComputerFinalizationStrategy()).V()}}, 
-    "g_withoutStrategiesXByModulatorOptimizationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(ComputerFinalizationStrategy).V()}}, 
+    "g_withoutStrategiesXByModulatorOptimizationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.ComputerFinalizationStrategy).V()}}, 
     "g_withStrategiesXComputerVerificationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ComputerVerificationStrategy()).V()}}, 
-    "g_withoutStrategiesXComputerVerificationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(ComputerVerificationStrategy).V()}}, 
+    "g_withoutStrategiesXComputerVerificationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.ComputerVerificationStrategy).V()}}, 
     
"g_withStrategiesXConnectiveStrategyStrategyX_V_hasXname_markoX_or_whereXinXknowsX_hasXname_markoXX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ConnectiveStrategy()).V().Has("name", 
"marko").Or().Where(gremlingo.T__.In("knows").Has("name", "marko"))}}, 
-    
"g_withoutStrategiesXConnectiveStrategyX_V_hasXname_markoX_or_whereXinXknowsX_hasXname_markoXX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(ConnectiveStrategy).V().Has("name", 
"marko").Or().Where(gremlingo.T__.In("knows").Has("name", "marko"))}}, 
+    
"g_withoutStrategiesXConnectiveStrategyX_V_hasXname_markoX_or_whereXinXknowsX_hasXname_markoXX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.ConnectiveStrategy).V().Has("name", 
"marko").Or().Where(gremlingo.T__.In("knows").Has("name", "marko"))}}, 
     "g_withStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.CountStrategy()).V().Where(gremlingo.T__.OutE().Count().Is(0))}},
 
-    "g_withoutStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(CountStrategy).V().Where(gremlingo.T__.OutE().Count().Is(0))}},
 
+    "g_withoutStrategiesXCountStrategyX_V_whereXoutE_count_isX0XX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.CountStrategy).V().Where(gremlingo.T__.OutE().Count().Is(0))}},
 
     
"g_withStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.EarlyLimitStrategy()).V().Out().Order().ValueMap().Limit(3).Select("name")}},
 
-    
"g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(EarlyLimitStrategy).V().Out().Order().ValueMap().Limit(3).Select("name")}},
 
+    
"g_withoutStrategiesXEarlyLimitStrategyX_V_out_order_valueMap_limitX3X_selectXnameX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.EarlyLimitStrategy).V().Out().Order().ValueMap().Limit(3).Select("name")}},
 
     
"g_withStrategiesXEdgeLabelVerificationStrategyXthrowException_true_logWarning_falseXX_V":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.EdgeLabelVerificationStrategy(gremlingo.EdgeLabelVerificationStrategyConfig{ThrowException:
 true, LogWarning: false})).V().Out()}}, 
     
"g_withStrategiesXEdgeLabelVerificationStrategyXthrowException_false_logWarning_falseXX_V":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.EdgeLabelVerificationStrategy(gremlingo.EdgeLabelVerificationStrategyConfig{ThrowException:
 false, LogWarning: false})).V().Out()}}, 
-    "g_withoutStrategiesXEdgeLabelVerificationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(EdgeLabelVerificationStrategy).V().Out()}}, 
+    "g_withoutStrategiesXEdgeLabelVerificationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.EdgeLabelVerificationStrategy).V().Out()}}, 
     "g_withStrategiesXElementIdStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ElementIdStrategy()).V()}}, 
-    "g_withoutStrategiesXElementIdStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithoutStrategies(ElementIdStrategy).V()}}, 
+    "g_withoutStrategiesXElementIdStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.ElementIdStrategy).V()}}, 
     "g_withStrategiesXFilterRankingStrategyX_V_out_order_dedup": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.FilterRankingStrategy()).V().Out().Order().Dedup()}},
 
-    "g_withoutStrategiesXFilterRankingStrategyX_V_out_order_dedup": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(FilterRankingStrategy).V().Out().Order().Dedup()}}, 
+    "g_withoutStrategiesXFilterRankingStrategyX_V_out_order_dedup": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.FilterRankingStrategy).V().Out().Order().Dedup()}},
 
     "g_withStrategiesXGraphFilterStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.GraphFilterStrategy()).V()}}, 
-    "g_withoutStrategiesXGraphFilterStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(GraphFilterStrategy).V()}}, 
+    "g_withoutStrategiesXGraphFilterStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.GraphFilterStrategy).V()}}, 
     "g_withStrategiesXHaltedTraverserStrategyXDetachedFactoryXX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.HaltedTraverserStrategy(gremlingo.HaltedTraverserStrategyConfig{HaltedTraverserFactory:
 
"org.apache.tinkerpop.gremlin.structure.util.detached.DetachedFactory"})).V()}},
 
     "g_withStrategiesXHaltedTraverserStrategyXReferenceFactoryXX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.HaltedTraverserStrategy(gremlingo.HaltedTraverserStrategyConfig{HaltedTraverserFactory:
 
"org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceFactory"})).V()}},
 
-    "g_withoutStrategiesXHaltedTraverserStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(HaltedTraverserStrategy).V()}}, 
+    "g_withoutStrategiesXHaltedTraverserStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.HaltedTraverserStrategy).V()}}, 
     "g_withStrategiesXIdentityRemovalStrategyX_V_identity_out": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.IdentityRemovalStrategy()).V().Identity().Out()}}, 
-    "g_withoutStrategiesXIdentityRemovalStrategyX_V_identity_out": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(IdentityRemovalStrategy).V().Identity().Out()}}, 
+    "g_withoutStrategiesXIdentityRemovalStrategyX_V_identity_out": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.IdentityRemovalStrategy).V().Identity().Out()}}, 
     "g_withStrategiesXIncidentToAdjacentStrategyX_V_outE_inV": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.IncidentToAdjacentStrategy()).V().OutE().InV()}}, 
-    "g_withoutStrategiesXIncidentToAdjacentStrategyX_V_outE_inV": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(IncidentToAdjacentStrategy).V().OutE().InV()}}, 
+    "g_withoutStrategiesXIncidentToAdjacentStrategyX_V_outE_inV": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.IncidentToAdjacentStrategy).V().OutE().InV()}}, 
     "g_withStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.InlineFilterStrategy()).V().Filter(gremlingo.T__.Has("name",
 "marko"))}}, 
-    "g_withoutStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(InlineFilterStrategy).V().Filter(gremlingo.T__.Has("name", 
"marko"))}}, 
+    "g_withoutStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.InlineFilterStrategy).V().Filter(gremlingo.T__.Has("name",
 "marko"))}}, 
     "g_withStrategiesXLambdaRestrictionStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
     "g_withoutStrategiesXLambdaRestrictionStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return nil}},  // skipping as it contains a lambda
     "g_withStrategiesXLazyBarrierStrategyX_V_out_bothE_count": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.LazyBarrierStrategy()).V().Out().BothE().Count()}}, 
-    "g_withoutStrategiesXLazyBarrierStrategyX_V_out_bothE_count": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(LazyBarrierStrategy).V().Out().BothE().Count()}}, 
+    "g_withoutStrategiesXLazyBarrierStrategyX_V_out_bothE_count": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.LazyBarrierStrategy).V().Out().BothE().Count()}}, 
     
"g_withStrategiesXMatchAlgorithmStrategyXmatchAlgorithm_CountMatchAlgorithmXX_V_matchXa_knows_b__a_created_cX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.MatchAlgorithmStrategy(gremlingo.MatchAlgorithmStrategyConfig{MatchAlgorithm:
 
"org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchStep$CountMatchAlgorithm"})).V().Match(gremlingo.T__.As("a").Out("knows").As("b"),
 gremlingo.T__.As("a").Out [...]
     
"g_withStrategiesXMatchAlgorithmStrategyXmatchAlgorithm_GreedyMatchAlgorithmXX_V_matchXa_knows_b__a_created_cX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.MatchAlgorithmStrategy(gremlingo.MatchAlgorithmStrategyConfig{MatchAlgorithm:
 
"org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchStep$GreedyMatchAlgorithm"})).V().Match(gremlingo.T__.As("a").Out("knows").As("b"),
 gremlingo.T__.As("a").O [...]
-    
"g_withoutStrategiesXMatchAlgorithmStrategyX_V_matchXa_knows_b__a_created_cX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(MatchAlgorithmStrategy).V().Match(gremlingo.T__.As("a").Out("knows").As("b"),
 gremlingo.T__.As("a").Out("created").As("c"))}}, 
+    
"g_withoutStrategiesXMatchAlgorithmStrategyX_V_matchXa_knows_b__a_created_cX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.MatchAlgorithmStrategy).V().Match(gremlingo.T__.As("a").Out("knows").As("b"),
 gremlingo.T__.As("a").Out("created").As("c"))}}, 
     
"g_withStrategiesXMatchPredicateStrategyX_V_matchXa_created_lop_b__b_0created_29_cX_whereXc_repeatXoutX_timesX2XX_selectXa_b_cX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.MatchPredicateStrategy()).V().Match(gremlingo.T__.As("a").Out("created").Has("name",
 "lop").As("b"), gremlingo.T__.As("b").In("created").Has("age", 
29).As("c")).Where(gremlingo.T__.As("c").Repeat(gremlingo.T__.Out()).Times(2)).Sel
 [...]
-    
"g_withoutStrategiesXMatchPredicateStrategyX_V_matchXa_created_lop_b__b_0created_29_cX_whereXc_repeatXoutX_timesX2XX_selectXa_b_cX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(MatchPredicateStrategy).V().Match(gremlingo.T__.As("a").Out("created").Has("name",
 "lop").As("b"), gremlingo.T__.As("b").In("created").Has("age", 
29).As("c")).Where(gremlingo.T__.As("c").Repeat(gremlingo.T__.Out()).Times(2)).Select("a
 [...]
+    
"g_withoutStrategiesXMatchPredicateStrategyX_V_matchXa_created_lop_b__b_0created_29_cX_whereXc_repeatXoutX_timesX2XX_selectXa_b_cX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.MatchPredicateStrategy).V().Match(gremlingo.T__.As("a").Out("created").Has("name",
 "lop").As("b"), gremlingo.T__.As("b").In("created").Has("age", 
29).As("c")).Where(gremlingo.T__.As("c").Repeat(gremlingo.T__.Out()).Times(2)) 
[...]
     "g_withStrategiesXMessagePassingReductionStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.MessagePassingReductionStrategy()).V()}}, 
-    "g_withoutStrategiesXMessagePassingReductionStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(MessagePassingReductionStrategy).V()}}, 
+    "g_withoutStrategiesXMessagePassingReductionStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.MessagePassingReductionStrategy).V()}}, 
   "g_withoutStrategiesXCountStrategyX_V_count": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.Inject(6)}}, 
     "g_V_coworker": {func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return 
g.V().HasLabel("person").Filter(gremlingo.T__.OutE("created")).Aggregate("p").As("p1").Values("name").As("p1n").Select("p").Unfold().Where(gremlingo.P.Neq("p1")).As("p2").Values("name").As("p2n").Select("p2").Out("created").Choose(gremlingo.T__.In("created").Where(gremlingo.P.Eq("p1")),
 gremlingo.T__.Values("name"), 
gremlingo.T__.Constant(p["xx1"])).Group().By(gremling [...]
     "g_V_coworker_with_midV": {func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return 
g.V().HasLabel("person").Filter(gremlingo.T__.OutE("created")).As("p1").V().HasLabel("person").Where(gremlingo.P.Neq("p1")).Filter(gremlingo.T__.OutE("created")).As("p2").Map(gremlingo.T__.Out("created").Where(gremlingo.T__.In("created").As("p1")).Values("name").Fold()).Group().By(gremlingo.T__.Select("p1").By("name")).By(gremlingo.T__.Group().By(gremlingo.T_
 [...]
     "g_withStrategiesXOptionsStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.OptionsStrategy()).V()}}, 
     "g_withStrategiesXOptionsStrategyXmyVar_myValueXX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.OptionsStrategy(gremlingo.OptionsStrategyConfig{MyVar:
 "myValue"})).V()}}, 
-    "g_withoutStrategiesXOptionsStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithoutStrategies(OptionsStrategy).V()}}, 
+    "g_withoutStrategiesXOptionsStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.OptionsStrategy).V()}}, 
     "g_withStrategiesXOrderLimitStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.OrderLimitStrategy()).V()}}, 
-    "g_withoutStrategiesXOrderLimitStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(OrderLimitStrategy).V()}}, 
+    "g_withoutStrategiesXOrderLimitStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.OrderLimitStrategy).V()}}, 
     "g_withStrategiesXPartitionStrategyXwrite_a_read_aXX_V_name": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.AddV("person").Property("_partition", 
"a").Property("name", "alice").AddV("person").Property("_partition", 
"b").Property("name", "bob")}, func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.PartitionStrategy(gremlingo.PartitionStrategyConfig{Partit
 [...]
     "g_withStrategiesXPartitionStrategyXwrite_a_read_a_bXX_V_name": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.AddV("person").Property("_partition", 
"a").Property("name", "alice").AddV("person").Property("_partition", 
"b").Property("name", "bob")}, func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.PartitionStrategy(gremlingo.PartitionStrategyConfig{Part
 [...]
     "g_withStrategiesXPartitionStrategyXwrite_a_read_cXX_V_name": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.AddV("person").Property("_partition", 
"a").Property("name", "alice").AddV("person").Property("_partition", 
"b").Property("name", "bob")}, func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.PartitionStrategy(gremlingo.PartitionStrategyConfig{Partit
 [...]
@@ -448,14 +448,14 @@ var translationMap = map[string][]func(g 
*gremlingo.GraphTraversalSource, p map[
     
"g_withStrategiesXPartitionStrategyXwrite_a_read_aXX_mergeV_optionXonCreateX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.AddV("person").Property("_partition", 
"b").Property("name", "alice")}, func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.PartitionStrategy(gremlingo.PartitionStrategyConfig{PartitionKey:
 "_partition", WritePartition: "a", ReadPar [...]
     
"g_withStrategiesXPartitionStrategyXwrite_a_read_aXX_injectX0X__mergeV_optionXonCreateX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.AddV("person").Property("_partition", 
"b").Property("name", "alice")}, func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.PartitionStrategy(gremlingo.PartitionStrategyConfig{PartitionKey:
 "_partition", WritePartition: " [...]
     
"g_withStrategiesXPathProcessorStrategyX_V_asXaX_selectXaX_byXvaluesXnameXX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.PathProcessorStrategy()).V().As("a").Select("a").By(gremlingo.T__.Values("name"))}},
 
-    
"g_withoutStrategiesXPathProcessorStrategyX_V_asXaX_selectXaX_byXvaluesXnameXX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(PathProcessorStrategy).V().As("a").Select("a").By(gremlingo.T__.Values("name"))}},
 
+    
"g_withoutStrategiesXPathProcessorStrategyX_V_asXaX_selectXaX_byXvaluesXnameXX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.PathProcessorStrategy).V().As("a").Select("a").By(gremlingo.T__.Values("name"))}},
 
     "g_withStrategiesXPathRetractionStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.PathRetractionStrategy()).V()}}, 
-    "g_withoutStrategiesXPathRetractionStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(PathRetractionStrategy).V()}}, 
+    "g_withoutStrategiesXPathRetractionStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.PathRetractionStrategy).V()}}, 
     "g_V_shortestpath": {func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return 
g.V().As("v").Both().As("v").Project("src", "tgt", 
"p").By(gremlingo.T__.Select(gremlingo.Pop.First, 
"v")).By(gremlingo.T__.Select(gremlingo.Pop.Last, 
"v")).By(gremlingo.T__.Select(gremlingo.Pop.All, 
"v")).As("triple").Group("x").By(gremlingo.T__.Select("src", 
"tgt")).By(gremlingo.T__.Select("p").Fold()).Select("tgt").Barrier().Repeat(gremlingo.T__.Both().As("v").P
 [...]
     "g_withStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ProductiveByStrategy()).V().Group().By("age").By("name")}},
 
-    "g_withoutStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(ProductiveByStrategy).V().Group().By("age").By("name")}}, 
+    "g_withoutStrategiesXProductiveByStrategyX_V_group_byXageX_byXnameX": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.ProductiveByStrategy).V().Group().By("age").By("name")}},
 
     "g_withStrategiesXProfileStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ProfileStrategy()).V()}}, 
-    "g_withoutStrategiesXProfileStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithoutStrategies(ProfileStrategy).V()}}, 
+    "g_withoutStrategiesXProfileStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.ProfileStrategy).V()}}, 
     "g_withStrategiesXReadOnlyStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ReadOnlyStrategy()).V()}}, 
     "g_withStrategiesXReadOnlyStrategyX_V_outXknowsX_name": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ReadOnlyStrategy()).V().Out("knows").Values("name")}},
 
     "g_withStrategiesXReadOnlyStrategyX_addVXpersonX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ReadOnlyStrategy()).AddV("person")}}, 
@@ -465,16 +465,16 @@ var translationMap = map[string][]func(g 
*gremlingo.GraphTraversalSource, p map[
     "g_withStrategiesXReadOnlyStrategyX_E_propertyXweight_0X": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ReadOnlyStrategy()).E().Property("weight", 0)}}, 
     "g_V_classic_recommendation": {func(g *gremlingo.GraphTraversalSource, p 
map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", 
"DARK 
STAR").As("a").Out("followedBy").Aggregate("stash").In("followedBy").Where(gremlingo.P.Neq("a").And(gremlingo.P.Not(gremlingo.P.Within("stash")))).GroupCount().Unfold().Project("x",
 "y", 
"z").By(gremlingo.T__.Select(gremlingo.Column.Keys).Values("name")).By(gremlingo.T__.Select(gremlingo.Column.Keys).Values("performances")).By(grem
 [...]
     "g_withStrategiesXReferenceElementStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ReferenceElementStrategy()).V()}}, 
-    "g_withoutStrategiesXReferenceElementStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(ReferenceElementStrategy).V()}}, 
+    "g_withoutStrategiesXReferenceElementStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.ReferenceElementStrategy).V()}}, 
     "g_withStrategiesXRepeatUnrollStrategyX_V_repeatXoutX_timesX2X": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.RepeatUnrollStrategy()).V().Repeat(gremlingo.T__.Out()).Times(2)}},
 
-    "g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXoutX_timesX2X": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(RepeatUnrollStrategy).V().Repeat(gremlingo.T__.Out()).Times(2)}},
 
+    "g_withoutStrategiesXRepeatUnrollStrategyX_V_repeatXoutX_timesX2X": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.RepeatUnrollStrategy).V().Repeat(gremlingo.T__.Out()).Times(2)}},
 
     
"g_withStrategiesXReservedKeysVerificationStrategyXthrowException_trueXX_addVXpersonX_propertyXid_123X_propertyXname_markoX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ReservedKeysVerificationStrategy(gremlingo.ReservedKeysVerificationStrategyConfig{ThrowException:
 true})).AddV("person").Property("id", 123).Property("name", "marko")}}, 
     
"g_withStrategiesXReservedKeysVerificationStrategyXthrowException_trueXX_addVXpersonX_propertyXage_29X_propertyXname_markoX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.ReservedKeysVerificationStrategy(gremlingo.ReservedKeysVerificationStrategyConfig{ThrowException:
 true, Keys: []interface{}{"age"}})).AddV("person").Property("age", 
29).Property("name", "marko")}}, 
-    
"g_withoutStrategiesXReservedKeysVerificationStrategyX_addVXpersonX_propertyXid_123X_propertyXname_markoX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(ReservedKeysVerificationStrategy).AddV("person").Property("id",
 123).Property("name", "marko")}}, 
+    
"g_withoutStrategiesXReservedKeysVerificationStrategyX_addVXpersonX_propertyXid_123X_propertyXname_markoX":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.ReservedKeysVerificationStrategy).AddV("person").Property("id",
 123).Property("name", "marko")}}, 
     "g_withStrategiesXSeedStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.SeedStrategy(gremlingo.SeedStrategyConfig{Seed: 
7})).V().Coin(0.5)}}, 
-    "g_withoutStrategiesXSeedStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.WithoutStrategies(SeedStrategy).V()}}, 
+    "g_withoutStrategiesXSeedStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.SeedStrategy).V()}}, 
     "g_withStrategiesXStandardVerificationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.StandardVerificationStrategy()).V()}}, 
-    "g_withoutStrategiesXStandardVerificationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(StandardVerificationStrategy).V()}}, 
+    "g_withoutStrategiesXStandardVerificationStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.StandardVerificationStrategy).V()}}, 
     "g_withStrategiesXSubgraphStrategyXsubgraphAXX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.SubgraphStrategy(gremlingo.SubgraphStrategyConfig{Vertices:
 gremlingo.T__.Has("name", gremlingo.P.Within("josh", "lop", 
"ripple"))})).V()}}, 
     "g_withStrategiesXSubgraphStrategyXsubgraphAXX_E": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.SubgraphStrategy(gremlingo.SubgraphStrategyConfig{Vertices:
 gremlingo.T__.Has("name", gremlingo.P.Within("josh", "lop", 
"ripple"))})).E()}}, 
     "g_withStrategiesXSubgraphStrategyXsubgraphAXX_VX4X_outE": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.SubgraphStrategy(gremlingo.SubgraphStrategyConfig{Vertices:
 gremlingo.T__.Has("name", gremlingo.P.Within("josh", "lop", 
"ripple"))})).V(p["vid4"]).OutE()}}, 
@@ -536,11 +536,11 @@ var translationMap = map[string][]func(g 
*gremlingo.GraphTraversalSource, p map[
     "g_withStrategiesXSubgraphStrategyXsubgraphDXX_EX12X_bothV": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.SubgraphStrategy(gremlingo.SubgraphStrategyConfig{CheckAdjacentVertices:
 false, Vertices: gremlingo.T__.Has("name", gremlingo.P.Within("josh", "lop", 
"ripple")), Edges: gremlingo.T__.Or(gremlingo.T__.Has("weight", 
0.4).HasLabel("created"), gremlingo.T__.Has("weight", 
1.0).HasLabel("created"))})).E( [...]
     "g_withStrategiesXSubgraphStrategyXsubgraphDXX_EX9X_bothV": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.SubgraphStrategy(gremlingo.SubgraphStrategyConfig{CheckAdjacentVertices:
 false, Vertices: gremlingo.T__.Has("name", gremlingo.P.Within("josh", "lop", 
"ripple")), Edges: gremlingo.T__.Or(gremlingo.T__.Has("weight", 
0.4).HasLabel("created"), gremlingo.T__.Has("weight", 
1.0).HasLabel("created"))})).E(p [...]
     
"g_withStrategiesXSubgraphStrategyXcheckAdjacentVertices_subgraphDXX_EX9X_bothV":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.SubgraphStrategy(gremlingo.SubgraphStrategyConfig{CheckAdjacentVertices:
 true, Vertices: gremlingo.T__.Has("name", gremlingo.P.Within("josh", "lop", 
"ripple")), Edges: gremlingo.T__.Or(gremlingo.T__.Has("weight", 
0.4).HasLabel("created"), gremlingo.T__.Has("weight", 1.0).HasLab [...]
-    
"g_withStrategiesXVertexProgramRestrictionStrategyX_withoutStrategiesXVertexProgramStrategyX_V":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.VertexProgramRestrictionStrategy()).WithoutStrategies(VertexProgramStrategy).V()}},
 
+    
"g_withStrategiesXVertexProgramRestrictionStrategyX_withoutStrategiesXVertexProgramStrategyX_V":
 {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.VertexProgramRestrictionStrategy()).WithoutStrategies(gremlingo.VertexProgramStrategy).V()}},
 
     
"g_withStrategiesXVertexProgramRestrictionStrategy_VertexProgramStrategyX_V": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.VertexProgramRestrictionStrategy(), 
gremlingo.VertexProgramStrategy()).V()}}, 
-    "g_withoutStrategiesXVertexProgramRestrictionStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(VertexProgramRestrictionStrategy).WithStrategies(gremlingo.VertexProgramStrategy()).V()}},
 
+    "g_withoutStrategiesXVertexProgramRestrictionStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.VertexProgramRestrictionStrategy).WithStrategies(gremlingo.VertexProgramStrategy()).V()}},
 
     "g_withStrategiesXVertexProgramStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithStrategies(gremlingo.VertexProgramStrategy()).V()}}, 
-    "g_withoutStrategiesXVertexProgramStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(VertexProgramStrategy).V()}}, 
+    "g_withoutStrategiesXVertexProgramStrategyX_V": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return 
g.WithoutStrategies(gremlingo.VertexProgramStrategy).V()}}, 
     "g_VX1X_asXaX_outXcreatedX_addEXcreatedByX_toXaX": {func(g 
*gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.AddV("person").Property("name", 
"marko").Property("age", 29).As("marko").AddV("person").Property("name", 
"vadas").Property("age", 27).As("vadas").AddV("software").Property("name", 
"lop").Property("lang", "java").As("lop").AddV("person").Property("name", 
"josh").Property("age", 32).As("josh").AddV("software").Property("name", 
"ripple [...]
     "g_VX1X_asXaX_outXcreatedX_addEXcreatedByX_toXaX_propertyXweight_2X": 
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) 
*gremlingo.GraphTraversal {return g.AddV("person").Property("name", 
"marko").Property("age", 29).As("marko").AddV("person").Property("name", 
"vadas").Property("age", 27).As("vadas").AddV("software").Property("name", 
"lop").Property("lang", "java").As("lop").AddV("person").Property("name", 
"josh").Property("age", 32).As("josh").AddV("software").Prope [...]
     "g_V_outE_propertyXweight_nullX": {func(g *gremlingo.GraphTraversalSource, 
p map[string]interface{}) *gremlingo.GraphTraversal {return 
g.AddV("person").Property("name", "marko").Property("age", 
29).As("marko").AddV("person").Property("name", "vadas").Property("age", 
27).As("vadas").AddV("software").Property("name", "lop").Property("lang", 
"java").As("lop").AddV("person").Property("name", "josh").Property("age", 
32).As("josh").AddV("software").Property("name", "ripple").Property("lang [...]


Reply via email to