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 2015/04/15 19:48:12 UTC
[50/50] incubator-tinkerpop git commit: Merge remote-tracking branch
'origin/master' into variables
Merge remote-tracking branch 'origin/master' into variables
Conflicts:
tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphTest.java
Project: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/commit/c15ab5e7
Tree: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/tree/c15ab5e7
Diff: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/diff/c15ab5e7
Branch: refs/heads/variables
Commit: c15ab5e749e9776ada8b81cf662f9c698e63193c
Parents: 7783d4f d09ffa8
Author: Stephen Mallette <sp...@genoprime.com>
Authored: Wed Apr 15 13:46:50 2015 -0400
Committer: Stephen Mallette <sp...@genoprime.com>
Committed: Wed Apr 15 13:46:50 2015 -0400
----------------------------------------------------------------------
CHANGELOG.asciidoc | 21 +
README.asciidoc | 15 +-
docs/preprocessor/preprocess.sh | 12 +-
docs/src/acknowledgements.asciidoc | 2 +-
docs/src/gremlin-applications.asciidoc | 39 +-
docs/src/implementations.asciidoc | 24 +-
docs/src/the-graph.asciidoc | 51 +-
docs/src/the-graphcomputer.asciidoc | 7 +-
docs/src/the-traversal.asciidoc | 34 +-
docs/static/images/ketrina-tinkerpop3.png | Bin 0 -> 646438 bytes
gremlin-console/pom.xml | 2 +-
gremlin-console/src/main/LICENSE | 2 +-
gremlin-core/pom.xml | 2 +-
.../gremlin/process/computer/GraphComputer.java | 4 +
.../gremlin/process/computer/Memory.java | 3 +
.../gremlin/process/computer/MessageScope.java | 31 +-
.../gremlin/process/computer/Messenger.java | 7 +-
.../peerpressure/PeerPressureVertexProgram.java | 15 +-
.../ranking/pagerank/PageRankVertexProgram.java | 11 +-
.../computer/traversal/SingleMessenger.java | 2 +-
.../traversal/TraversalScriptSupplier.java | 5 +-
.../traversal/TraversalVertexProgram.java | 3 +-
.../computer/traversal/TraverserExecutor.java | 7 +-
.../traversal/step/map/ComputerResultStep.java | 2 +-
.../process/computer/util/ComputerGraph.java | 2 +-
.../process/computer/util/LambdaHolder.java | 2 +-
.../process/computer/util/ShellGraph.java | 283 +++++
.../process/traversal/TraversalStrategies.java | 13 +-
.../gremlin/process/traversal/Traverser.java | 2 +-
.../traversal/dsl/graph/GraphTraversal.java | 9 +-
.../dsl/graph/GraphTraversalSource.java | 5 +-
.../gremlin/process/traversal/dsl/graph/__.java | 8 +-
.../process/traversal/step/map/BackStep.java | 64 --
.../traversal/step/sideEffect/GraphStep.java | 18 +-
.../step/sideEffect/SideEffectCapStep.java | 9 +-
.../traversal/step/util/HasContainer.java | 4 +-
.../strategy/decoration/ElementIdStrategy.java | 8 +-
.../traverser/util/AbstractTraverser.java | 18 +-
.../traversal/traverser/util/TraverserSet.java | 8 +-
.../traversal/util/DefaultTraversal.java | 2 +-
.../util/DefaultTraversalSideEffects.java | 3 +-
.../tinkerpop/gremlin/structure/Edge.java | 3 +
.../tinkerpop/gremlin/structure/Element.java | 9 +-
.../tinkerpop/gremlin/structure/Graph.java | 135 ++-
.../tinkerpop/gremlin/structure/Property.java | 11 +-
.../gremlin/structure/Transaction.java | 4 +
.../tinkerpop/gremlin/structure/Vertex.java | 16 +-
.../gremlin/structure/VertexProperty.java | 6 +-
.../io/graphson/LegacyGraphSONReader.java | 3 +-
.../structure/io/gryo/GremlinClassResolver.java | 206 ----
.../structure/io/gryo/GryoClassResolver.java | 211 ++++
.../gremlin/structure/io/gryo/GryoMapper.java | 19 +-
.../gremlin/structure/util/Attachable.java | 76 ++
.../gremlin/structure/util/ElementHelper.java | 7 +-
.../structure/util/batch/BatchGraph.java | 5 +
.../structure/util/detached/Attachable.java | 33 -
.../structure/util/detached/DetachedEdge.java | 10 +-
.../util/detached/DetachedElement.java | 11 +-
.../util/detached/DetachedFactory.java | 4 +
.../structure/util/detached/DetachedPath.java | 5 +-
.../util/detached/DetachedProperty.java | 14 +-
.../structure/util/detached/DetachedVertex.java | 36 +-
.../util/detached/DetachedVertexProperty.java | 7 +-
.../structure/util/reference/ReferenceEdge.java | 89 ++
.../util/reference/ReferenceElement.java | 74 ++
.../util/reference/ReferenceFactory.java | 81 ++
.../structure/util/reference/ReferencePath.java | 75 ++
.../util/reference/ReferenceProperty.java | 111 ++
.../util/reference/ReferenceVertex.java | 106 ++
.../util/reference/ReferenceVertexProperty.java | 106 ++
.../gremlin/structure/util/star/StarGraph.java | 673 ++++++++++++
.../tinkerpop/gremlin/util/StreamFactory.java | 32 -
.../gremlin/util/iterator/IteratorUtils.java | 24 +
.../util/iterator/IteratorUtilsTest.java | 24 +
gremlin-driver/pom.xml | 2 +-
.../ser/GryoMessageSerializerV1D0Test.java | 9 +-
.../JsonMessageSerializerGremlinV1d0Test.java | 5 +-
.../ser/JsonMessageSerializerV1d0Test.java | 3 +-
gremlin-groovy-test/pom.xml | 2 +-
.../GroovyTraversalSideEffectsTest.groovy | 35 +
.../traversal/step/filter/GroovyHasTest.groovy | 10 +
.../step/filter/GroovyRangeTest.groovy | 36 -
.../traversal/step/map/GroovyBackTest.groovy | 146 ---
.../step/map/GroovyPropertiesTest.groovy | 19 +-
.../traversal/step/map/GroovySelectTest.groovy | 112 +-
.../traversal/step/map/GroovyVertexTest.groovy | 10 +
.../groovy/GroovyEnvironmentIntegrateSuite.java | 35 +-
.../GroovyEnvironmentPerformanceSuite.java | 38 +-
.../gremlin/groovy/GroovyEnvironmentSuite.java | 35 +-
.../engine/GremlinExecutorPerformanceTest.java | 2 +-
.../GremlinGroovyScriptEngineOverGraphTest.java | 7 +-
.../process/GroovyProcessComputerSuite.java | 17 +-
.../process/GroovyProcessStandardSuite.java | 21 +-
gremlin-groovy/pom.xml | 2 +-
.../gremlin/groovy/engine/GremlinExecutor.java | 8 +-
.../jsr223/GremlinGroovyScriptEngine.java | 4 +-
gremlin-server/conf/gremlin-server-classic.yaml | 2 +-
gremlin-server/conf/gremlin-server-min.yaml | 2 +-
gremlin-server/conf/gremlin-server-modern.yaml | 2 +-
.../conf/gremlin-server-rest-modern.yaml | 2 +-
gremlin-server/conf/gremlin-server.yaml | 5 +-
gremlin-server/pom.xml | 2 +-
gremlin-server/scripts/empty-sample.groovy | 4 +
gremlin-server/scripts/generate-classic.groovy | 6 +-
gremlin-server/scripts/generate-modern.groovy | 6 +-
gremlin-server/scripts/load-sample.groovy | 7 +-
gremlin-server/src/main/LICENSE | 2 +-
.../apache/tinkerpop/gremlin/server/Graphs.java | 13 +-
.../tinkerpop/gremlin/server/GremlinServer.java | 9 +
.../server/GremlinDriverIntegrateTest.java | 8 +-
.../server/GremlinServerHttpIntegrateTest.java | 6 +-
.../server/GremlinServerIntegrateTest.java | 2 +-
.../server/GremlinTraversalPerformanceTest.java | 10 +-
.../server/gremlin-server-integration.yaml | 2 +-
.../server/gremlin-server-performance.yaml | 2 +-
gremlin-shaded/pom.xml | 2 +-
gremlin-test/pom.xml | 2 +-
.../gremlin/AbstractGraphProvider.java | 16 +-
.../tinkerpop/gremlin/AbstractGremlinSuite.java | 144 +--
.../tinkerpop/gremlin/AbstractGremlinTest.java | 30 +-
.../apache/tinkerpop/gremlin/GraphProvider.java | 48 +-
.../apache/tinkerpop/gremlin/LoadGraphWith.java | 4 +-
.../generator/CommunityGeneratorTest.java | 7 +-
.../generator/DistributionGeneratorTest.java | 6 +-
.../gremlin/process/ProcessComputerSuite.java | 135 ++-
.../process/ProcessPerformanceSuite.java | 31 +-
.../gremlin/process/ProcessStandardSuite.java | 136 ++-
.../process/TraversalPerformanceTest.java | 8 +-
.../process/computer/GraphComputerTest.java | 22 +-
.../process/traversal/CoreTraversalTest.java | 24 +-
.../traversal/step/filter/ExceptTest.java | 2 +-
.../process/traversal/step/filter/HasTest.java | 47 +-
.../traversal/step/filter/RangeTest.java | 79 +-
.../process/traversal/step/map/BackTest.java | 220 ----
.../traversal/step/map/PropertiesTest.java | 25 +
.../process/traversal/step/map/SelectTest.java | 183 +++-
.../process/traversal/step/map/VertexTest.java | 94 +-
.../traversal/step/sideEffect/SubgraphTest.java | 4 +-
.../decoration/EventStrategyProcessTest.java | 8 +-
.../tinkerpop/gremlin/structure/BatchTest.java | 22 +-
.../tinkerpop/gremlin/structure/EdgeTest.java | 35 +-
.../gremlin/structure/FeatureSupportTest.java | 100 +-
.../structure/GraphConstructionTest.java | 4 +-
.../tinkerpop/gremlin/structure/GraphTest.java | 1029 +++++++++++++++++-
.../structure/GraphWritePerformanceTest.java | 6 +-
.../tinkerpop/gremlin/structure/IoTest.java | 217 ++--
.../gremlin/structure/PropertyTest.java | 4 +-
.../structure/StructurePerformanceSuite.java | 29 +-
.../structure/StructureStandardSuite.java | 59 +-
.../gremlin/structure/TransactionTest.java | 12 +-
.../gremlin/structure/VertexPropertyTest.java | 43 +-
.../tinkerpop/gremlin/structure/VertexTest.java | 170 ++-
.../util/detached/DetachedEdgeTest.java | 21 +-
.../util/detached/DetachedPropertyTest.java | 2 +-
.../detached/DetachedVertexPropertyTest.java | 20 +-
.../util/detached/DetachedVertexTest.java | 26 +-
.../util/reference/ReferenceEdgeTest.java | 152 +++
.../reference/ReferenceVertexPropertyTest.java | 101 ++
.../util/reference/ReferenceVertexTest.java | 176 +++
.../structure/util/star/StarGraphTest.java | 171 +++
.../structure/io/script/script-input.groovy | 8 +-
hadoop-gremlin/conf/hadoop-gryo.properties | 6 +-
hadoop-gremlin/pom.xml | 7 +-
.../hadoop/groovy/plugin/HadoopLoader.groovy | 40 +-
.../computer/example/TraversalSupplier1.java | 3 +-
.../computer/example/TraversalSupplier2.java | 3 +-
.../computer/example/TraversalSupplier3.java | 3 +-
.../computer/giraph/GiraphMessenger.java | 4 +-
.../process/computer/spark/SparkExecutor.java | 16 +-
.../computer/spark/SparkGraphComputer.java | 19 +-
.../process/computer/spark/SparkMessenger.java | 7 +-
.../gremlin/hadoop/structure/HadoopGraph.java | 51 +-
.../gremlin/hadoop/structure/HadoopVertex.java | 6 +-
.../gremlin/hadoop/structure/io/IOClasses.java | 52 +
.../hadoop/structure/io/VertexWritable.java | 11 +-
.../structure/io/VertexWritableIterator.java | 95 ++
.../io/graphson/GraphSONRecordReader.java | 8 +-
.../structure/io/gryo/GryoRecordReader.java | 9 +-
.../structure/io/script/ScriptRecordReader.java | 6 +-
.../gremlin/hadoop/HadoopGraphProvider.java | 5 +-
pom.xml | 2 +-
tinkergraph-gremlin/pom.xml | 2 +-
.../process/computer/TinkerGraphComputer.java | 2 +-
.../process/computer/TinkerMessageBoard.java | 7 +
.../process/computer/TinkerMessenger.java | 48 +-
.../dsl/graph/VariableGraphTraversal.java | 9 +-
.../tinkergraph/structure/TinkerFactory.java | 9 +-
.../tinkergraph/structure/TinkerGraph.java | 232 +++-
.../tinkergraph/structure/TinkerHelper.java | 8 +-
.../tinkergraph/structure/TinkerProperty.java | 3 +
.../tinkergraph/structure/TinkerVertex.java | 16 +-
.../structure/TinkerVertexProperty.java | 13 +-
.../tinkergraph/TinkerGraphProvider.java | 87 +-
.../structure/TinkerGraphIdManagerTest.java | 158 +++
.../tinkergraph/structure/TinkerGraphTest.java | 19 +-
195 files changed, 6256 insertions(+), 2029 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/c15ab5e7/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/dsl/graph/VariableGraphTraversal.java
----------------------------------------------------------------------
diff --cc tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/dsl/graph/VariableGraphTraversal.java
index eb7b3eb,0000000..52f0876
mode 100644,000000..100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/dsl/graph/VariableGraphTraversal.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/dsl/graph/VariableGraphTraversal.java
@@@ -1,832 -1,0 +1,827 @@@
+/*
+ * 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.tinkergraph.process.traversal.dsl.graph;
+
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
+import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+import org.apache.tinkerpop.gremlin.process.traversal.Scopeable;
+import org.apache.tinkerpop.gremlin.process.traversal.Step;
+import org.apache.tinkerpop.gremlin.process.traversal.T;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.ElementValueTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.FilterTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.FilterTraverserTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.IdentityTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.LoopTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.MapTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.MapTraverserTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.TokenTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.lambda.TrueTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.step.ComparatorHolder;
+import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalOptionParent;
+import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
+import org.apache.tinkerpop.gremlin.process.traversal.step.branch.BranchStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.branch.ChooseStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.branch.LocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.branch.RepeatStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.branch.UnionStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.AndStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.CoinStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.CyclicPathStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.DedupGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.DropStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.ExceptStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTraversalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.IsStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.LambdaFilterStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.OrStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.RangeGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.RetainStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.SampleGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.SimplePathStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.TimeLimitStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.WhereStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeByPathStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStep;
- import org.apache.tinkerpop.gremlin.process.traversal.step.map.BackStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.CoalesceStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.CountGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.CountLocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.DedupLocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.EdgeOtherVertexStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.EdgeVertexStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.FoldStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.GroupCountStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.GroupStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.IdStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.KeyStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.LabelStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.LambdaFlatMapStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.LambdaMapStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.MaxGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.MaxLocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.MeanGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.MeanLocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.MinGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.MinLocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.OrderLocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.PathStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertiesStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertyMapStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertyValueStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.RangeLocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.SackStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.SampleLocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.SelectOneStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.SelectStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.SumGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.SumLocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.TreeStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.UnfoldStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.VertexStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.match.MatchStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AddPropertyStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AggregateStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupCountSideEffectStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GroupSideEffectStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.IdentityStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.LambdaSideEffectStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.ProfileStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SackElementValueStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SackObjectStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SideEffectCapStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.StartStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.StoreStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.SubgraphStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.TreeSideEffectStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.CollectingBarrierStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.ElementFunctionComparator;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.ElementValueComparator;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.PathIdentityStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.TraversalComparator;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
+import org.apache.tinkerpop.gremlin.process.traversal.traverser.util.TraverserSet;
+import org.apache.tinkerpop.gremlin.structure.Compare;
+import org.apache.tinkerpop.gremlin.structure.Contains;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Element;
+import org.apache.tinkerpop.gremlin.structure.Order;
+import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.PropertyType;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+import org.apache.tinkerpop.gremlin.util.function.ConstantSupplier;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.BiFunction;
+import java.util.function.BiPredicate;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/**
+ * @author Stephen Mallette (http://stephen.genoprime.com)
+ */
+public interface VariableGraphTraversal<S, E> extends Traversal<S, E> {
+
+ public interface Admin<S, E> extends Traversal.Admin<S, E>, VariableGraphTraversal<S, E> {
+
+ @Override
+ public default <E2> VariableGraphTraversal.Admin<S, E2> addStep(final Step<?, E2> step) {
+ return (VariableGraphTraversal.Admin<S, E2>) Traversal.Admin.super.addStep((Step) step);
+ }
+
+ @Override
+ public default VariableGraphTraversal<S, E> iterate() {
+ return VariableGraphTraversal.super.iterate();
+ }
+
+ @Override
+ public VariableGraphTraversal.Admin<S, E> clone();
+ }
+
+ @Override
+ public default VariableGraphTraversal.Admin<S, E> asAdmin() {
+ return (VariableGraphTraversal.Admin<S, E>) this;
+ }
+
+ public Map<Step, List<TraversalVariablePosition>> getStepVariables();
+
+ ///////////////////// MAP STEPS /////////////////////
+
+ public default <E2> VariableGraphTraversal<S, E2> map(final Function<Traverser<E>, E2> function) {
+ return this.asAdmin().addStep(new LambdaMapStep<>(this.asAdmin(), function));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> flatMap(final Function<Traverser<E>, Iterator<E2>> function) {
+ return this.asAdmin().addStep(new LambdaFlatMapStep<>(this.asAdmin(), function));
+ }
+
+ public default VariableGraphTraversal<S, Object> id() {
+ return this.asAdmin().addStep(new IdStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, String> label() {
+ return this.asAdmin().addStep(new LabelStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, E> identity() {
+ return this.asAdmin().addStep(new IdentityStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, Vertex> to(final Direction direction, final String... edgeLabels) {
+ return this.asAdmin().addStep(new VertexStep<>(this.asAdmin(), Vertex.class, direction, edgeLabels));
+ }
+
+ public default VariableGraphTraversal<S, Vertex> out(final String... edgeLabels) {
+ return this.to(Direction.OUT, edgeLabels);
+ }
+
+ public default VariableGraphTraversal<S, Vertex> in(final String... edgeLabels) {
+ return this.to(Direction.IN, edgeLabels);
+ }
+
+ public default VariableGraphTraversal<S, Vertex> both(final String... edgeLabels) {
+ return this.to(Direction.BOTH, edgeLabels);
+ }
+
+ public default VariableGraphTraversal<S, Edge> toE(final Direction direction, final String... edgeLabels) {
+ return this.asAdmin().addStep(new VertexStep<>(this.asAdmin(), Edge.class, direction, edgeLabels));
+ }
+
+ public default VariableGraphTraversal<S, Edge> outE(final String... edgeLabels) {
+ return this.toE(Direction.OUT, edgeLabels);
+ }
+
+ public default VariableGraphTraversal<S, Edge> inE(final String... edgeLabels) {
+ return this.toE(Direction.IN, edgeLabels);
+ }
+
+ public default VariableGraphTraversal<S, Edge> bothE(final String... edgeLabels) {
+ return this.toE(Direction.BOTH, edgeLabels);
+ }
+
+ public default VariableGraphTraversal<S, Vertex> toV(final Direction direction) {
+ return this.asAdmin().addStep(new EdgeVertexStep(this.asAdmin(), direction));
+ }
+
+ public default VariableGraphTraversal<S, Vertex> inV() {
+ return this.toV(Direction.IN);
+ }
+
+ public default VariableGraphTraversal<S, Vertex> outV() {
+ return this.toV(Direction.OUT);
+ }
+
+ public default VariableGraphTraversal<S, Vertex> bothV() {
+ return this.toV(Direction.BOTH);
+ }
+
+ public default VariableGraphTraversal<S, Vertex> otherV() {
+ return this.asAdmin().addStep(new EdgeOtherVertexStep(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, E> order() {
+ return this.order(Scope.global);
+ }
+
+ public default VariableGraphTraversal<S, E> order(final Scope scope) {
+ return this.asAdmin().addStep(scope.equals(Scope.global) ? new OrderGlobalStep<>(this.asAdmin()) : new OrderLocalStep<>(this.asAdmin()));
+ }
+
+ public default <E2> VariableGraphTraversal<S, ? extends Property<E2>> properties(final String... propertyKeys) {
+ return this.asAdmin().addStep(new PropertiesStep<>(this.asAdmin(), PropertyType.PROPERTY, propertyKeys));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> values(final String... propertyKeys) {
+ return this.asAdmin().addStep(new PropertiesStep<>(this.asAdmin(), PropertyType.VALUE, propertyKeys));
+ }
+
+ public default <E2> VariableGraphTraversal<S, Map<String, E2>> propertyMap(final String... propertyKeys) {
+ return this.asAdmin().addStep(new PropertyMapStep<>(this.asAdmin(), false, PropertyType.PROPERTY, propertyKeys));
+ }
+
+ public default <E2> VariableGraphTraversal<S, Map<String, E2>> valueMap(final String... propertyKeys) {
+ return this.asAdmin().addStep(new PropertyMapStep<>(this.asAdmin(), false, PropertyType.VALUE, propertyKeys));
+ }
+
+ public default <E2> VariableGraphTraversal<S, Map<String, E2>> valueMap(final boolean includeTokens, final String... propertyKeys) {
+ return this.asAdmin().addStep(new PropertyMapStep<>(this.asAdmin(), includeTokens, PropertyType.VALUE, propertyKeys));
+ }
+
+ public default VariableGraphTraversal<S, String> key() {
+ return this.asAdmin().addStep(new KeyStep(this.asAdmin()));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> value() {
+ return this.asAdmin().addStep(new PropertyValueStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, Path> path() {
+ return this.asAdmin().addStep(new PathStep<>(this.asAdmin()));
+ }
+
- public default <E2> VariableGraphTraversal<S, E2> back(final String stepLabel) {
- return this.asAdmin().addStep(new BackStep<>(this.asAdmin(), stepLabel));
- }
-
+ public default <E2> VariableGraphTraversal<S, Map<String, E2>> match(final String startLabel, final Traversal... traversals) {
+ return (VariableGraphTraversal) this.asAdmin().addStep(new MatchStep<E, Map<String, E2>>(this.asAdmin(), startLabel, traversals));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> sack() {
+ return this.asAdmin().addStep(new SackStep<>(this.asAdmin()));
+ }
+
+ public default <E2> VariableGraphTraversal<S, Map<String, E2>> select(final String... stepLabels) {
+ return this.asAdmin().addStep(new SelectStep<>(this.asAdmin(), stepLabels));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> select(final String stepLabel) {
+ return this.asAdmin().addStep(new SelectOneStep(this.asAdmin(), stepLabel));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> unfold() {
+ return this.asAdmin().addStep(new UnfoldStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, List<E>> fold() {
+ return this.asAdmin().addStep(new FoldStep<>(this.asAdmin()));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> fold(final E2 seed, final BiFunction<E2, E, E2> foldFunction) {
+ return this.asAdmin().addStep(new FoldStep<>(this.asAdmin(), new ConstantSupplier<>(seed), foldFunction)); // TODO: User should provide supplier?
+ }
+
+ public default VariableGraphTraversal<S, Long> count() {
+ return this.count(Scope.global);
+ }
+
+ public default VariableGraphTraversal<S, Long> count(final Scope scope) {
+ return this.asAdmin().addStep(scope.equals(Scope.global) ? new CountGlobalStep<>(this.asAdmin()) : new CountLocalStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, Double> sum() {
+ return this.sum(Scope.global);
+ }
+
+ public default VariableGraphTraversal<S, Double> sum(final Scope scope) {
+ return this.asAdmin().addStep(scope.equals(Scope.global) ? new SumGlobalStep(this.asAdmin()) : new SumLocalStep<>(this.asAdmin()));
+ }
+
+ public default <E2 extends Number> VariableGraphTraversal<S, E2> max() {
+ return this.max(Scope.global);
+ }
+
+ public default <E2 extends Number> VariableGraphTraversal<S, E2> max(final Scope scope) {
+ return this.asAdmin().addStep(scope.equals(Scope.global) ? new MaxGlobalStep<E2>(this.asAdmin()) : new MaxLocalStep(this.asAdmin()));
+ }
+
+ public default <E2 extends Number> VariableGraphTraversal<S, E2> min() {
+ return this.min(Scope.global);
+ }
+
+ public default <E2 extends Number> VariableGraphTraversal<S, E2> min(final Scope scope) {
+ return this.asAdmin().addStep(scope.equals(Scope.global) ? new MinGlobalStep<E2>(this.asAdmin()) : new MinLocalStep(this.asAdmin()));
+ }
+
+
+ public default VariableGraphTraversal<S, Double> mean() {
+ return this.mean(Scope.global);
+ }
+
+ public default VariableGraphTraversal<S, Double> mean(final Scope scope) {
+ return this.asAdmin().addStep(scope.equals(Scope.global) ? new MeanGlobalStep<>(this.asAdmin()) : new MeanLocalStep<>(this.asAdmin()));
+ }
+
+ public default <K, R> VariableGraphTraversal<S, Map<K, R>> group() {
+ return this.asAdmin().addStep(new GroupStep<>(this.asAdmin()));
+ }
+
+ public default <E2> VariableGraphTraversal<S, Map<E2, Long>> groupCount() {
+ return this.asAdmin().addStep(new GroupCountStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, Tree> tree() {
+ return this.asAdmin().addStep(new TreeStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, Vertex> addV(final Object... keyValues) {
+ return this.asAdmin().addStep(new AddVertexStep<>(this.asAdmin(), keyValues));
+ }
+
+ public default VariableGraphTraversal<S, Edge> addE(final Direction direction, final String edgeLabel, final String stepLabel, final Object... propertyKeyValues) {
+ return this.asAdmin().addStep(new AddEdgeByPathStep(this.asAdmin(), direction, edgeLabel, stepLabel, propertyKeyValues));
+ }
+
+ public default VariableGraphTraversal<S, Edge> addE(final Direction direction, final String edgeLabel, final Vertex otherVertex, final Object... propertyKeyValues) {
+ return this.asAdmin().addStep(new AddEdgeStep(this.asAdmin(), direction, edgeLabel, otherVertex, propertyKeyValues));
+ }
+
+ public default VariableGraphTraversal<S, Edge> addE(final Direction direction, final String edgeLabel, final Iterator<Vertex> otherVertices, final Object... propertyKeyValues) {
+ return this.asAdmin().addStep(new AddEdgeStep(this.asAdmin(), direction, edgeLabel, otherVertices, propertyKeyValues));
+ }
+
+ public default VariableGraphTraversal<S, Edge> addInE(final String edgeLabel, final String stepLabel, final Object... propertyKeyValues) {
+ return this.addE(Direction.IN, edgeLabel, stepLabel, propertyKeyValues);
+ }
+
+ public default VariableGraphTraversal<S, Edge> addInE(final String edgeLabel, final Vertex otherVertex, final Object... propertyKeyValues) {
+ return this.addE(Direction.IN, edgeLabel, otherVertex, propertyKeyValues);
+ }
+
+ public default VariableGraphTraversal<S, Edge> addInE(final String edgeLabel, final Iterator<Vertex> otherVertices, final Object... propertyKeyValues) {
+ return this.addE(Direction.IN, edgeLabel, otherVertices, propertyKeyValues);
+ }
+
+ public default VariableGraphTraversal<S, Edge> addOutE(final String edgeLabel, final String stepLabel, final Object... propertyKeyValues) {
+ return this.addE(Direction.OUT, edgeLabel, stepLabel, propertyKeyValues);
+ }
+
+ public default VariableGraphTraversal<S, Edge> addOutE(final String edgeLabel, final Vertex otherVertex, final Object... propertyKeyValues) {
+ return this.addE(Direction.OUT, edgeLabel, otherVertex, propertyKeyValues);
+ }
+
+ public default VariableGraphTraversal<S, Edge> addOutE(final String edgeLabel, final Iterator<Vertex> otherVertices, final Object... propertyKeyValues) {
+ return this.addE(Direction.OUT, edgeLabel, otherVertices, propertyKeyValues);
+ }
+
+ ///////////////////// FILTER STEPS /////////////////////
+
+ public default VariableGraphTraversal<S, E> filter(final Predicate<Traverser<E>> predicate) {
+ return this.asAdmin().addStep(new LambdaFilterStep<>(this.asAdmin(), predicate));
+ }
+
+ public default VariableGraphTraversal<S, E> or(final Traversal<?, ?>... orTraversals) {
+ return this.asAdmin().addStep(0 == orTraversals.length ?
+ new OrStep.OrMarker<>(this.asAdmin()) :
+ new OrStep(this.asAdmin(), Arrays.copyOf(orTraversals, orTraversals.length, Traversal.Admin[].class)));
+ }
+
+ public default VariableGraphTraversal<S, E> and(final Traversal<?, ?>... andTraversals) {
+ return this.asAdmin().addStep(0 == andTraversals.length ?
+ new AndStep.AndMarker<>(this.asAdmin()) :
+ new AndStep(this.asAdmin(), Arrays.copyOf(andTraversals, andTraversals.length, Traversal.Admin[].class)));
+ }
+
+ public default VariableGraphTraversal<S, E> inject(final E... injections) {
+ return this.asAdmin().addStep(new InjectStep<>(this.asAdmin(), injections));
+ }
+
+ public default VariableGraphTraversal<S, E> dedup() {
+ return this.dedup(Scope.global);
+ }
+
+ public default VariableGraphTraversal<S, E> dedup(final Scope scope) {
+ return this.asAdmin().addStep(scope.equals(Scope.global) ? new DedupGlobalStep<>(this.asAdmin()) : new DedupLocalStep(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, E> except(final String sideEffectKeyOrPathLabel) {
+ return this.asAdmin().addStep(new ExceptStep<E>(this.asAdmin(), sideEffectKeyOrPathLabel));
+ }
+
+ public default VariableGraphTraversal<S, E> except(final E exceptObject) {
+ return this.asAdmin().addStep(new ExceptStep<>(this.asAdmin(), exceptObject));
+ }
+
+ public default VariableGraphTraversal<S, E> except(final Collection<E> exceptCollection) {
+ return this.asAdmin().addStep(new ExceptStep<>(this.asAdmin(), exceptCollection));
+ }
+
+ public default <E2> VariableGraphTraversal<S, Map<String, E2>> where(final String firstKey, final String secondKey, final BiPredicate predicate) {
+ return this.asAdmin().addStep(new WhereStep(this.asAdmin(), firstKey, secondKey, predicate));
+ }
+
+ public default <E2> VariableGraphTraversal<S, Map<String, E2>> where(final String firstKey, final BiPredicate predicate, final String secondKey) {
+ return this.where(firstKey, secondKey, predicate);
+ }
+
+ public default <E2> VariableGraphTraversal<S, Map<String, E2>> where(final Traversal constraint) {
+ return this.asAdmin().addStep(new WhereStep<>(this.asAdmin(), constraint.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, E> has(final Traversal<?, ?> hasNextTraversal) {
+ return this.asAdmin().addStep(new HasTraversalStep<>(this.asAdmin(), (Traversal.Admin<E, ?>) hasNextTraversal, false));
+ }
+
+ public default VariableGraphTraversal<S, E> hasNot(final Traversal<?, ?> hasNotNextTraversal) {
+ return this.asAdmin().addStep(new HasTraversalStep<>(this.asAdmin(), (Traversal.Admin<E, ?>) hasNotNextTraversal, true));
+ }
+
+ public default VariableGraphTraversal<S, E> has(final String key) {
+ return this.asAdmin().addStep(new HasStep(this.asAdmin(), new HasContainer(key, Contains.within)));
+ }
+
+ public default VariableGraphTraversal<S, E> has(final String key, final Object value) {
+ return this.has(key, Compare.eq, value);
+ }
+
+ public default VariableGraphTraversal<S, E> has(final T accessor, final Object value) {
+ return this.has(accessor.getAccessor(), value);
+ }
+
+ public VariableGraphTraversal<S, E> has(final CharSequence key, final BiPredicate predicate, final Object value);
+
+ public default VariableGraphTraversal<S, E> has(final T accessor, final BiPredicate predicate, final Object value) {
+ return this.has(accessor.getAccessor(), predicate, value);
+ }
+
+ public default VariableGraphTraversal<S, E> has(final String label, final String key, final Object value) {
+ return this.has(label, key, Compare.eq, value);
+ }
+
+ public default VariableGraphTraversal<S, E> has(final String label, final String key, final BiPredicate predicate, final Object value) {
+ return this.has(T.label, label).has(key, predicate, value);
+ }
+
+ public default VariableGraphTraversal<S, E> hasNot(final String key) {
+ return this.asAdmin().addStep(new HasStep(this.asAdmin(), new HasContainer(key, Contains.without)));
+ }
+
+ public default VariableGraphTraversal<S, E> hasLabel(final String... labels) {
+ return labels.length == 1 ? this.has(T.label, labels[0]) : this.has(T.label, Contains.within, Arrays.asList(labels));
+ }
+
+ public default VariableGraphTraversal<S, E> hasId(final Object... ids) {
+ return ids.length == 1 ? this.has(T.id, ids[0]) : this.has(T.id, Contains.within, Arrays.asList(ids));
+ }
+
+ public default VariableGraphTraversal<S, E> hasKey(final String... keys) {
+ return keys.length == 1 ? this.has(T.key, keys[0]) : this.has(T.key, Contains.within, Arrays.asList(keys));
+ }
+
+ public default VariableGraphTraversal<S, E> hasValue(final Object... values) {
+ return values.length == 1 ? this.has(T.value, values[0]) : this.has(T.value, Contains.within, Arrays.asList(values));
+ }
+
+ public default VariableGraphTraversal<S, E> is(final Object value) {
+ return this.is(Compare.eq, value);
+ }
+
+ public VariableGraphTraversal<S, E> is(final BiPredicate predicate, final Object value);
+
+ public default VariableGraphTraversal<S, E> coin(final double probability) {
+ return this.asAdmin().addStep(new CoinStep<>(this.asAdmin(), probability));
+ }
+
+ public default VariableGraphTraversal<S, E> range(final Number low, final Number high) {
+ return this.range(Scope.global, low, high);
+ }
+
+ public VariableGraphTraversal<S, E> range(final Scopeable scope, final Number low, final Number high);
+
+ public default VariableGraphTraversal<S, E> limit(final long limit) {
+ return this.range(Scope.global, 0, limit);
+ }
+
+ public default VariableGraphTraversal<S, E> limit(final Scope scope, final long limit) {
+ return this.range(scope, 0, limit);
+ }
+
+ public default VariableGraphTraversal<S, E> retain(final String sideEffectKeyOrPathLabel) {
+ return this.asAdmin().addStep(new RetainStep<>(this.asAdmin(), sideEffectKeyOrPathLabel));
+ }
+
+ public default VariableGraphTraversal<S, E> retain(final E retainObject) {
+ return this.asAdmin().addStep(new RetainStep<>(this.asAdmin(), retainObject));
+ }
+
+ public default VariableGraphTraversal<S, E> retain(final Collection<E> retainCollection) {
+ return this.asAdmin().addStep(new RetainStep<>(this.asAdmin(), retainCollection));
+ }
+
+ public default VariableGraphTraversal<S, E> simplePath() {
+ return this.asAdmin().addStep(new SimplePathStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, E> cyclicPath() {
+ return this.asAdmin().addStep(new CyclicPathStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, E> sample(final int amountToSample) {
+ return this.sample(Scope.global, amountToSample);
+ }
+
+ public default VariableGraphTraversal<S, E> sample(final Scope scope, final int amountToSample) {
+ return this.asAdmin().addStep(scope.equals(Scope.global)
+ ? new SampleGlobalStep<>(this.asAdmin(), amountToSample)
+ : new SampleLocalStep<>(this.asAdmin(), amountToSample));
+ }
+
+ public default VariableGraphTraversal<S, E> drop() {
+ return this.asAdmin().addStep(new DropStep<>(this.asAdmin()));
+ }
+
+ ///////////////////// SIDE-EFFECT STEPS /////////////////////
+
+ public default VariableGraphTraversal<S, E> sideEffect(final Consumer<Traverser<E>> consumer) {
+ return this.asAdmin().addStep(new LambdaSideEffectStep<>(this.asAdmin(), consumer));
+ }
+
- public default <E2> VariableGraphTraversal<S, E2> cap(final String... sideEffectKeys) {
- return this.asAdmin().addStep(new SideEffectCapStep<>(this.asAdmin(), sideEffectKeys));
++ public default <E2> VariableGraphTraversal<S, E2> cap(final String sideEffectKey, final String... sideEffectKeys) {
++ return this.asAdmin().addStep(new SideEffectCapStep<>(this.asAdmin(), sideEffectKey, sideEffectKeys));
+ }
+
+ public default VariableGraphTraversal<S, Edge> subgraph(final String sideEffectKey) {
+ return this.asAdmin().addStep(new SubgraphStep(this.asAdmin(), sideEffectKey));
+ }
+
+ public default VariableGraphTraversal<S, E> aggregate(final String sideEffectKey) {
+ return this.asAdmin().addStep(new AggregateStep<>(this.asAdmin(), sideEffectKey));
+ }
+
+ public default VariableGraphTraversal<S, E> group(final String sideEffectKey) {
+ return this.asAdmin().addStep(new GroupSideEffectStep<>(this.asAdmin(), sideEffectKey));
+ }
+
+ public default VariableGraphTraversal<S, E> groupCount(final String sideEffectKey) {
+ return this.asAdmin().addStep(new GroupCountSideEffectStep<>(this.asAdmin(), sideEffectKey));
+ }
+
+ public default VariableGraphTraversal<S, E> timeLimit(final long timeLimit) {
+ return this.asAdmin().addStep(new TimeLimitStep<E>(this.asAdmin(), timeLimit));
+ }
+
+ public default VariableGraphTraversal<S, E> tree(final String sideEffectKey) {
+ return this.asAdmin().addStep(new TreeSideEffectStep<>(this.asAdmin(), sideEffectKey));
+ }
+
+ public default <V> VariableGraphTraversal<S, E> sack(final BiFunction<V, E, V> sackFunction) {
+ return this.asAdmin().addStep(new SackObjectStep<>(this.asAdmin(), sackFunction));
+ }
+
+ public default <V> VariableGraphTraversal<S, E> sack(final BinaryOperator<V> sackOperator, final String elementPropertyKey) {
+ return this.asAdmin().addStep(new SackElementValueStep(this.asAdmin(), sackOperator, elementPropertyKey));
+ }
+
+ public default VariableGraphTraversal<S, E> store(final String sideEffectKey) {
+ return this.asAdmin().addStep(new StoreStep<>(this.asAdmin(), sideEffectKey));
+ }
+
+ public default VariableGraphTraversal<S, E> profile() {
+ return this.asAdmin().addStep(new ProfileStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, E> property(final String key, final Object value, final Object... keyValues) {
+ return this.asAdmin().addStep(new AddPropertyStep(this.asAdmin(), key, value, keyValues));
+ }
+
+ public default VariableGraphTraversal<S, E> property(final VertexProperty.Cardinality cardinality, final String key, final Object value, final Object... keyValues) {
+ return this.asAdmin().addStep(new AddPropertyStep(this.asAdmin(), cardinality, key, value, keyValues));
+ }
+
+ ///////////////////// BRANCH STEPS /////////////////////
+
+ public default <M, E2> VariableGraphTraversal<S, E2> branch(final Traversal<?, M> branchTraversal) {
+ final BranchStep<E, E2, M> branchStep = new BranchStep<>(this.asAdmin());
+ branchStep.setBranchTraversal((Traversal.Admin<E, M>) branchTraversal);
+ return this.asAdmin().addStep(branchStep);
+ }
+
+ public default <M, E2> VariableGraphTraversal<S, E2> branch(final Function<Traverser<E>, M> function) {
+ return this.branch(new MapTraverserTraversal<>(function));
+ }
+
+ public default <M, E2> VariableGraphTraversal<S, E2> choose(final Traversal<?, M> choiceTraversal) {
+ return this.asAdmin().addStep(new ChooseStep<>(this.asAdmin(), (Traversal.Admin<E, M>) choiceTraversal));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> choose(final Traversal<?, ?> traversalPredicate, final Traversal<?, E2> trueChoice, final Traversal<?, E2> falseChoice) {
+ return this.asAdmin().addStep(new ChooseStep<E, E2, Boolean>(this.asAdmin(), (Traversal.Admin<E, ?>) traversalPredicate, (Traversal.Admin<E, E2>) trueChoice, (Traversal.Admin<E, E2>) falseChoice));
+ }
+
+ public default <M, E2> VariableGraphTraversal<S, E2> choose(final Function<E, M> choiceFunction) {
+ return this.choose(new MapTraversal<>(choiceFunction));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> choose(final Predicate<E> choosePredicate, final Traversal<?, E2> trueChoice, final Traversal<?, E2> falseChoice) {
+ return this.choose(new FilterTraversal<>(choosePredicate), trueChoice, falseChoice);
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> union(final Traversal<?, E2>... unionTraversals) {
+ return this.asAdmin().addStep(new UnionStep(this.asAdmin(), Arrays.copyOf(unionTraversals, unionTraversals.length, Traversal.Admin[].class)));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> coalesce(final Traversal<?, E2>... coalesceTraversals) {
+ return this.asAdmin().addStep(new CoalesceStep(this.asAdmin(), Arrays.copyOf(coalesceTraversals, coalesceTraversals.length, Traversal.Admin[].class)));
+ }
+
+ public default VariableGraphTraversal<S, E> repeat(final Traversal<?, E> repeatTraversal) {
+ return RepeatStep.addRepeatToTraversal(this, (Traversal.Admin<E, E>) repeatTraversal);
+ }
+
+ public default VariableGraphTraversal<S, E> emit(final Traversal<?, ?> emitTraversal) {
+ return RepeatStep.addEmitToTraversal(this, (Traversal.Admin<E, ?>) emitTraversal);
+ }
+
+ public default VariableGraphTraversal<S, E> emit(final Predicate<Traverser<E>> emitPredicate) {
+ return this.emit(new FilterTraverserTraversal<>(emitPredicate));
+ }
+
+ public default VariableGraphTraversal<S, E> emit() {
+ return this.emit(TrueTraversal.instance());
+ }
+
+ public default VariableGraphTraversal<S, E> until(final Traversal<?, ?> untilTraversal) {
+ return RepeatStep.addUntilToTraversal(this, (Traversal.Admin<E, ?>) untilTraversal);
+ }
+
+ public default VariableGraphTraversal<S, E> until(final Predicate<Traverser<E>> untilPredicate) {
+ return this.until(new FilterTraverserTraversal<>(untilPredicate));
+ }
+
+ public default VariableGraphTraversal<S, E> times(final int maxLoops) {
+ return this.until(new LoopTraversal(maxLoops));
+ }
+
+ public default <E2> VariableGraphTraversal<S, E2> local(final Traversal<?, E2> localTraversal) {
+ return this.asAdmin().addStep(new LocalStep<>(this.asAdmin(), localTraversal.asAdmin()));
+ }
+
+ ///////////////////// UTILITY STEPS /////////////////////
+
+ public default VariableGraphTraversal<S, E> withSideEffect(final String key, final Supplier supplier) {
+ this.asAdmin().getSideEffects().registerSupplier(key, supplier);
+ return this;
+ }
+
+ public default <A> VariableGraphTraversal<S, E> withSack(final Supplier<A> initialValue, final UnaryOperator<A> splitOperator) {
+ this.asAdmin().getSideEffects().setSack(initialValue, Optional.of(splitOperator));
+ return this;
+ }
+
+ public default <A> VariableGraphTraversal<S, E> withSack(final Supplier<A> initialValue) {
+ this.asAdmin().getSideEffects().setSack(initialValue, Optional.empty());
+ return this;
+ }
+
+ public default <A> VariableGraphTraversal<S, E> withSack(final A initialValue, final UnaryOperator<A> splitOperator) {
+ this.asAdmin().getSideEffects().setSack(new ConstantSupplier<>(initialValue), Optional.of(splitOperator));
+ return this;
+ }
+
+ public default <A> VariableGraphTraversal<S, E> withSack(A initialValue) {
+ this.asAdmin().getSideEffects().setSack(new ConstantSupplier<>(initialValue), Optional.empty());
+ return this;
+ }
+
+ public default VariableGraphTraversal<S, E> withPath() {
+ return this.asAdmin().addStep(new PathIdentityStep<>(this.asAdmin()));
+ }
+
+ public default VariableGraphTraversal<S, E> as(final String stepLabel) {
+ if (this.asAdmin().getSteps().size() == 0) this.asAdmin().addStep(new StartStep<>(this.asAdmin()));
+ this.asAdmin().getEndStep().setLabel(stepLabel);
+ return this;
+ }
+
+ public default VariableGraphTraversal<S, E> barrier() {
+ return this.asAdmin().addStep(new CollectingBarrierStep(asAdmin()) {
+ @Override
+ public void barrierConsumer(TraverserSet traverserSet) {
+
+ }
+ }); // TODO: THIS IS NOT SERIALIZABLE
+ }
+
+ ////
+
+ public default VariableGraphTraversal<S, E> by() {
+ ((TraversalParent) this.asAdmin().getEndStep()).addLocalChild(new IdentityTraversal<>());
+ return this;
+ }
+
+ public default <V> VariableGraphTraversal<S, E> by(final Function<V, Object> functionProjection) {
+ ((TraversalParent) this.asAdmin().getEndStep()).addLocalChild(new MapTraversal<>(functionProjection));
+ return this;
+ }
+
+ public default VariableGraphTraversal<S, E> by(final T tokenProjection) {
+ ((TraversalParent) this.asAdmin().getEndStep()).addLocalChild(new TokenTraversal<>(tokenProjection));
+ return this;
+ }
+
+ public default VariableGraphTraversal<S, E> by(final String elementPropertyKey) {
+ ((TraversalParent) this.asAdmin().getEndStep()).addLocalChild(new ElementValueTraversal<>(elementPropertyKey));
+ return this;
+ }
+
+ public default VariableGraphTraversal<S, E> by(final Traversal<?, ?> byTraversal) {
+ ((TraversalParent) this.asAdmin().getEndStep()).addLocalChild(byTraversal.asAdmin());
+ return this;
+ }
+
+ ////
+
+ public default VariableGraphTraversal<S, E> by(final Order order) {
+ ((ComparatorHolder) this.asAdmin().getEndStep()).addComparator(order);
+ return this;
+ }
+
+ public default VariableGraphTraversal<S, E> by(final Comparator<E> comparator) {
+ ((ComparatorHolder<E>) this.asAdmin().getEndStep()).addComparator(comparator);
+ return this;
+ }
+
+ public default <V> VariableGraphTraversal<S, E> by(final Function<Element, V> elementFunctionProjection, final Comparator<V> elementFunctionValueComparator) {
+ ((ComparatorHolder<Element>) this.asAdmin().getEndStep()).addComparator(new ElementFunctionComparator<>(elementFunctionProjection, elementFunctionValueComparator));
+ return this;
+ }
+
+ public default <V> VariableGraphTraversal<S, E> by(final String elementPropertyProjection, final Comparator<V> propertyValueComparator) {
+ ((ComparatorHolder<Element>) this.asAdmin().getEndStep()).addComparator(new ElementValueComparator<>(elementPropertyProjection, propertyValueComparator));
+ return this;
+ }
+
+ public default <V> VariableGraphTraversal<S, E> by(final Traversal<?, ?> traversal, final Comparator<V> endComparator) {
+ ((ComparatorHolder<E>) this.asAdmin().getEndStep()).addComparator(new TraversalComparator(traversal.asAdmin(), endComparator));
+ return this;
+ }
+
+ ////
+
+ public default <M, E2> VariableGraphTraversal<S, E> option(final M pickToken, final Traversal<E, E2> traversalOption) {
+ ((TraversalOptionParent<M, E, E2>) this.asAdmin().getEndStep()).addGlobalChildOption(pickToken, traversalOption.asAdmin());
+ return this;
+ }
+
+ public default <E2> VariableGraphTraversal<S, E> option(final Traversal<E, E2> traversalOption) {
+ ((TraversalOptionParent<TraversalOptionParent.Pick, E, E2>) this.asAdmin().getEndStep()).addGlobalChildOption(TraversalOptionParent.Pick.any, traversalOption.asAdmin());
+ return this;
+ }
+
+ ////
+
+ @Override
+ public default VariableGraphTraversal<S, E> iterate() {
+ Traversal.super.iterate();
+ return this;
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/c15ab5e7/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphTest.java
----------------------------------------------------------------------
diff --cc tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphTest.java
index 4d75cbb,291dddd..d75d183
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphTest.java
@@@ -20,19 -20,11 +20,20 @@@ package org.apache.tinkerpop.gremlin.ti
import org.apache.commons.io.FileUtils;
import org.apache.tinkerpop.gremlin.AbstractGremlinTest;
+import org.apache.tinkerpop.gremlin.groovy.jsr223.GremlinGroovyScriptEngine;
+import org.apache.tinkerpop.gremlin.process.traversal.Step;
import org.apache.tinkerpop.gremlin.TestHelper;
+ import org.apache.tinkerpop.gremlin.structure.util.star.StarGraph;
import org.apache.tinkerpop.gremlin.process.traversal.T;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.process.traversal.engine.StandardTraversalEngine;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.IsStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.PropertiesStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GraphStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Graph;
@@@ -45,12 -36,7 +45,13 @@@ import org.apache.tinkerpop.gremlin.str
import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONWriter;
import org.apache.tinkerpop.gremlin.structure.io.gryo.GryoReader;
import org.apache.tinkerpop.gremlin.structure.io.gryo.GryoWriter;
+ import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedFactory;
+import org.apache.tinkerpop.gremlin.tinkergraph.process.traversal.dsl.graph.DefaultVariableGraphTraversal;
+import org.apache.tinkerpop.gremlin.tinkergraph.process.traversal.dsl.graph.TraversalVariable;
+import org.apache.tinkerpop.gremlin.tinkergraph.process.traversal.dsl.graph.TraversalVariablePosition;
+import org.apache.tinkerpop.gremlin.tinkergraph.process.traversal.dsl.graph.VariableGraphTraversal;
+import org.apache.tinkerpop.gremlin.tinkergraph.process.traversal.dsl.graph.VariableGraphTraversalSource;
+import org.apache.tinkerpop.gremlin.util.StreamFactory;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;