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/05/01 17:53:21 UTC
[50/50] [abbrv] 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/bd54cf69
Tree: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/tree/bd54cf69
Diff: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/diff/bd54cf69
Branch: refs/heads/variables
Commit: bd54cf691358ece7df12fe5b1478011d6442b039
Parents: 69ba367 433f584
Author: Stephen Mallette <sp...@genoprime.com>
Authored: Fri May 1 11:51:31 2015 -0400
Committer: Stephen Mallette <sp...@genoprime.com>
Committed: Fri May 1 11:51:31 2015 -0400
----------------------------------------------------------------------
CHANGELOG.asciidoc | 20 +
NOTICE | 9 +-
README.asciidoc | 10 +-
bin/publish-docs.sh | 4 +-
data/grateful-dead-typed.json | 808 +++++++++++++++++
data/grateful-dead-vertices.kryo | Bin 975214 -> 0 bytes
data/grateful-dead-vertices.ldjson | 808 -----------------
data/grateful-dead.json | 809 ++++++++++++++++-
data/grateful-dead.kryo | Bin 493339 -> 331418 bytes
data/tinkerpop-classic-normalized.json | 1 -
data/tinkerpop-classic-typed.json | 7 +-
data/tinkerpop-classic-vertices.kryo | Bin 1179 -> 0 bytes
data/tinkerpop-classic-vertices.ldjson | 6 -
data/tinkerpop-classic.json | 7 +-
data/tinkerpop-classic.kryo | Bin 765 -> 723 bytes
data/tinkerpop-crew-typed.json | 7 +-
data/tinkerpop-crew-vertices.kryo | Bin 2575 -> 0 bytes
data/tinkerpop-crew-vertices.ldjson | 6 -
data/tinkerpop-crew.json | 7 +-
data/tinkerpop-crew.kryo | Bin 1858 -> 1380 bytes
data/tinkerpop-modern-normalized.json | 1 -
data/tinkerpop-modern-typed.json | 7 +-
data/tinkerpop-modern-vertices.kryo | Bin 1295 -> 0 bytes
data/tinkerpop-modern-vertices.ldjson | 6 -
data/tinkerpop-modern.json | 7 +-
data/tinkerpop-modern.kryo | Bin 825 -> 775 bytes
docs/src/gremlin-applications.asciidoc | 14 +-
docs/src/implementations.asciidoc | 31 +-
docs/src/the-graph.asciidoc | 409 +++------
docs/src/the-traversal.asciidoc | 64 +-
gremlin-console/bin/gremlin.sh | 2 +-
.../traversal/TraversalScriptSupplier.java | 15 +-
.../traversal/TraversalVertexProgram.java | 4 +-
.../computer/traversal/TraverserExecutor.java | 3 +-
.../traversal/VertexTraversalSideEffects.java | 13 +-
.../traversal/step/map/ComputerResultStep.java | 3 +-
.../tinkerpop/gremlin/process/traversal/T.java | 114 ---
.../process/traversal/TraversalSideEffects.java | 51 +-
.../gremlin/process/traversal/Traverser.java | 25 +-
.../dsl/graph/EmptyGraphTraversal.java | 5 -
.../traversal/dsl/graph/GraphTraversal.java | 100 +--
.../dsl/graph/GraphTraversalSource.java | 115 ++-
.../gremlin/process/traversal/dsl/graph/__.java | 70 +-
.../traversal/lambda/TokenTraversal.java | 2 +-
.../traversal/step/filter/ExceptStep.java | 4 +-
.../process/traversal/step/filter/HasStep.java | 20 +-
.../process/traversal/step/filter/IsStep.java | 32 +-
.../traversal/step/filter/RetainStep.java | 4 +-
.../traversal/step/filter/WhereStep.java | 11 +-
.../traversal/step/map/CountGlobalStep.java | 12 +-
.../process/traversal/step/map/MapStep.java | 4 -
.../traversal/step/map/MaxGlobalStep.java | 9 +-
.../traversal/step/map/MinGlobalStep.java | 15 +-
.../traversal/step/map/PropertyMapStep.java | 2 +-
.../traversal/step/map/SelectOneStep.java | 30 +-
.../process/traversal/step/map/SelectStep.java | 48 +-
.../traversal/step/map/SumGlobalStep.java | 6 +-
.../traversal/step/map/match/MatchStep.java | 4 +-
.../step/sideEffect/AggregateStep.java | 16 +-
.../sideEffect/GroupCountSideEffectStep.java | 12 +-
.../step/sideEffect/GroupSideEffectStep.java | 17 +-
.../traversal/step/sideEffect/ProfileStep.java | 16 +-
.../step/sideEffect/SideEffectCapStep.java | 22 +-
.../traversal/step/sideEffect/StoreStep.java | 12 +-
.../traversal/step/sideEffect/SubgraphStep.java | 2 +-
.../step/sideEffect/TreeSideEffectStep.java | 2 +-
.../traversal/step/util/HasContainer.java | 2 +-
.../process/traversal/step/util/SparsePath.java | 95 --
.../strategy/decoration/ElementIdStrategy.java | 5 +-
.../strategy/decoration/EventStrategy.java | 2 +-
.../optimization/RangeByIsCountStrategy.java | 47 +-
.../traverser/B_O_PA_S_SE_SL_Traverser.java | 86 --
.../B_O_PA_S_SE_SL_TraverserGenerator.java | 62 --
.../traverser/B_O_P_PA_S_SE_SL_Traverser.java | 58 --
.../B_O_P_PA_S_SE_SL_TraverserGenerator.java | 61 --
.../traverser/B_O_P_S_SE_SL_Traverser.java | 106 +++
.../B_O_P_S_SE_SL_TraverserGenerator.java | 58 ++
.../traverser/B_O_S_SE_SL_Traverser.java | 119 +++
.../B_O_S_SE_SL_TraverserGenerator.java | 59 ++
.../traverser/TraverserRequirement.java | 1 -
.../traverser/util/AbstractPathTraverser.java | 213 -----
.../traverser/util/AbstractTraverser.java | 16 +-
.../util/DefaultTraverserGeneratorFactory.java | 12 +-
.../traverser/util/EmptyTraverser.java | 8 +-
.../util/DefaultTraversalSideEffects.java | 27 +-
.../util/EmptyTraversalSideEffects.java | 4 +-
.../tinkerpop/gremlin/structure/Compare.java | 58 +-
.../tinkerpop/gremlin/structure/Element.java | 4 +-
.../tinkerpop/gremlin/structure/Graph.java | 190 +---
.../apache/tinkerpop/gremlin/structure/P.java | 130 +++
.../tinkerpop/gremlin/structure/Property.java | 4 +-
.../apache/tinkerpop/gremlin/structure/T.java | 110 +++
.../gremlin/structure/Transaction.java | 2 +-
.../tinkerpop/gremlin/structure/Vertex.java | 4 +-
.../gremlin/structure/VertexProperty.java | 2 +-
.../gremlin/structure/io/DefaultIo.java | 82 --
.../gremlin/structure/io/GraphMigrator.java | 28 +-
.../gremlin/structure/io/GraphReader.java | 145 +++-
.../gremlin/structure/io/GraphWriter.java | 91 +-
.../tinkerpop/gremlin/structure/io/Io.java | 108 +++
.../tinkerpop/gremlin/structure/io/IoCore.java | 43 +
.../gremlin/structure/io/IoRegistry.java | 81 ++
.../tinkerpop/gremlin/structure/io/Mapper.java | 15 +
.../gremlin/structure/io/graphml/GraphMLIo.java | 116 +++
.../structure/io/graphml/GraphMLMapper.java | 51 ++
.../structure/io/graphml/GraphMLReader.java | 203 +++--
.../structure/io/graphml/GraphMLWriter.java | 75 +-
.../io/graphml/GraphMLWriterHelper.java | 190 ++--
.../structure/io/graphson/GraphSONGraph.java | 90 --
.../structure/io/graphson/GraphSONIo.java | 117 +++
.../structure/io/graphson/GraphSONMapper.java | 30 +-
.../structure/io/graphson/GraphSONModule.java | 287 +------
.../structure/io/graphson/GraphSONReader.java | 293 ++++---
.../io/graphson/GraphSONSerializers.java | 360 ++++++++
.../structure/io/graphson/GraphSONTokens.java | 5 +-
.../structure/io/graphson/GraphSONUtil.java | 45 +
.../structure/io/graphson/GraphSONVertex.java | 94 --
.../io/graphson/GraphSONVertexProperty.java | 93 --
.../structure/io/graphson/GraphSONWriter.java | 120 ++-
.../io/graphson/LegacyGraphSONReader.java | 136 ++-
.../structure/io/gryo/EdgeTerminator.java | 48 --
.../structure/io/gryo/GraphSerializer.java | 164 ----
.../structure/io/gryo/GryoClassResolver.java | 2 +-
.../gremlin/structure/io/gryo/GryoIo.java | 117 +++
.../gremlin/structure/io/gryo/GryoMapper.java | 95 +-
.../gremlin/structure/io/gryo/GryoReader.java | 464 ++++------
.../structure/io/gryo/GryoSerializers.java | 135 +++
.../gremlin/structure/io/gryo/GryoWriter.java | 145 ++--
.../io/gryo/VertexByteArrayInputStream.java | 5 +-
.../structure/io/gryo/VertexTerminator.java | 6 +-
.../structure/util/AbstractTransaction.java | 2 +-
.../gremlin/structure/util/Attachable.java | 369 +++++++-
.../gremlin/structure/util/ElementHelper.java | 26 +-
.../tinkerpop/gremlin/structure/util/Host.java | 27 +
.../structure/util/batch/BatchFeatures.java | 216 -----
.../structure/util/batch/BatchGraph.java | 643 --------------
.../gremlin/structure/util/batch/Exists.java | 62 --
.../structure/util/batch/VertexIdType.java | 65 --
.../util/batch/cache/AbstractIDVertexCache.java | 78 --
.../util/batch/cache/LongIDVertexCache.java | 94 --
.../util/batch/cache/ObjectIDVertexCache.java | 25 -
.../util/batch/cache/StringCompression.java | 29 -
.../util/batch/cache/StringIDVertexCache.java | 87 --
.../util/batch/cache/URLCompression.java | 67 --
.../structure/util/batch/cache/VertexCache.java | 36 -
.../structure/util/detached/DetachedEdge.java | 41 +-
.../util/detached/DetachedElement.java | 4 +
.../structure/util/detached/DetachedPath.java | 19 +-
.../util/detached/DetachedProperty.java | 32 +-
.../structure/util/detached/DetachedVertex.java | 47 +-
.../util/detached/DetachedVertexProperty.java | 38 +-
.../structure/util/reference/ReferenceEdge.java | 19 -
.../util/reference/ReferenceElement.java | 4 +
.../structure/util/reference/ReferencePath.java | 19 +-
.../util/reference/ReferenceProperty.java | 24 +-
.../util/reference/ReferenceVertex.java | 19 -
.../util/reference/ReferenceVertexProperty.java | 32 +-
.../gremlin/structure/util/star/StarGraph.java | 173 ++--
.../util/star/StarGraphGraphSONSerializer.java | 252 ++++++
.../util/star/StarGraphGryoSerializer.java | 148 ++++
.../gremlin/util/iterator/IteratorUtils.java | 14 +
.../step/filter/ConjunctionStepTest.java | 6 +-
.../RangeByIsCountStrategyTest.java | 54 +-
.../process/util/TraversalHelperTest.java | 12 +-
.../gremlin/structure/CompareTest.java | 30 +-
.../gremlin/structure/io/IoRegistryTest.java | 99 +++
.../structure/io/gryo/GryoReaderWriterTest.java | 7 +-
.../structure/util/ElementHelperTest.java | 2 +-
.../tinkerpop/gremlin/driver/Cluster.java | 6 +-
.../ser/AbstractJsonMessageSerializerV1d0.java | 77 +-
.../driver/ser/GryoMessageSerializerV1d0.java | 3 +-
.../ser/JsonMessageSerializerGremlinV1d0.java | 2 +-
.../driver/ser/JsonMessageSerializerV1d0.java | 2 +-
.../gremlin/driver/simple/NioClient.java | 3 +
.../gremlin/driver/simple/WebSocketClient.java | 3 +
.../driver/benchmark/ProfilingApplication.java | 27 +-
.../ser/GryoMessageSerializerV1D0Test.java | 2 +-
.../JsonMessageSerializerGremlinV1d0Test.java | 8 +-
.../ser/JsonMessageSerializerV1d0Test.java | 13 +-
.../process/computer/ComputerTestHelper.groovy | 11 +-
.../step/branch/GroovyLocalTest.groovy | 19 +-
.../step/branch/GroovyRepeatTest.groovy | 12 +-
.../step/branch/GroovyUnionTest.groovy | 10 +-
.../traversal/step/filter/GroovyAndTest.groovy | 13 +-
.../step/filter/GroovyCyclicPathTest.groovy | 8 +-
.../step/filter/GroovyDedupTest.groovy | 2 +-
.../step/filter/GroovyExceptTest.groovy | 12 +-
.../step/filter/GroovyFilterTest.groovy | 6 +-
.../step/filter/GroovyHasNotTest.groovy | 4 +-
.../traversal/step/filter/GroovyHasTest.groovy | 35 +-
.../traversal/step/filter/GroovyIsTest.groovy | 28 +-
.../traversal/step/filter/GroovyOrTest.groovy | 16 +-
.../step/filter/GroovyRetainTest.groovy | 10 +-
.../step/filter/GroovySampleTest.groovy | 2 +-
.../step/filter/GroovySimplePathTest.groovy | 6 +-
.../step/filter/GroovyWhereTest.groovy | 10 +-
.../step/map/GroovyAddVertexTest.groovy | 2 +-
.../step/map/GroovyCoalesceTest.groovy | 8 +-
.../traversal/step/map/GroovyMapTest.groovy | 20 +-
.../traversal/step/map/GroovyMatchTest.groovy | 6 +-
.../traversal/step/map/GroovyPathTest.groovy | 6 +-
.../step/map/GroovyPropertiesTest.groovy | 8 +-
.../traversal/step/map/GroovySelectTest.groovy | 47 +-
.../step/map/GroovyValueMapTest.groovy | 6 +-
.../traversal/step/map/GroovyVertexTest.groovy | 53 +-
.../step/sideEffect/GroovySackTest.groovy | 26 +-
.../sideEffect/GroovySideEffectCapTest.groovy | 2 +-
.../step/sideEffect/GroovySideEffectTest.groovy | 4 +-
.../step/sideEffect/GroovyStoreTest.groovy | 4 +-
.../step/sideEffect/GroovySubgraphTest.groovy | 4 +-
.../step/sideEffect/GroovyTreeTest.groovy | 2 +-
.../groovy/GroovyEnvironmentIntegrateSuite.java | 4 +-
.../GroovyEnvironmentPerformanceSuite.java | 4 +-
.../gremlin/groovy/GroovyEnvironmentSuite.java | 2 +-
.../engine/GremlinExecutorPerformanceTest.java | 4 +-
.../GremlinGroovyScriptEngineOverGraphTest.java | 6 +-
.../process/GroovyProcessComputerSuite.java | 2 +-
.../process/GroovyProcessStandardSuite.java | 2 +-
.../gremlin/groovy/loaders/StepLoader.groovy | 18 +-
.../gremlin/groovy/loaders/SugarLoader.groovy | 38 +-
.../AbstractImportCustomizerProvider.java | 27 +-
.../gremlin/groovy/engine/GremlinExecutor.java | 2 +-
.../groovy/jsr223/DependencyManager.java | 2 +-
.../jsr223/GremlinGroovyScriptEngine.java | 2 +-
gremlin-server/data/sample.kryo | Bin 4781767 -> 2406053 bytes
gremlin-server/scripts/load-sample.groovy | 2 +-
.../gremlin/server/AbstractChannelizer.java | 3 +-
.../handler/HttpGremlinEndpointHandler.java | 4 +-
.../gremlin/server/handler/IteratorHandler.java | 6 +-
.../handler/NioGremlinResponseEncoder.java | 8 +-
.../server/handler/OpExecutorHandler.java | 2 +-
.../server/handler/OpSelectorHandler.java | 2 +-
.../handler/WsGremlinResponseEncoder.java | 8 +-
.../server/op/AbstractEvalOpProcessor.java | 57 +-
.../gremlin/server/op/control/ControlOps.java | 13 +-
.../server/GremlinDriverIntegrateTest.java | 9 +-
.../server/GremlinServerHttpIntegrateTest.java | 3 +-
.../server/GremlinServerIntegrateTest.java | 66 +-
gremlin-shaded/pom.xml | 14 +-
.../gremlin/AbstractGraphProvider.java | 6 +-
.../apache/tinkerpop/gremlin/GraphProvider.java | 23 +-
.../apache/tinkerpop/gremlin/LoadGraphWith.java | 4 +-
.../apache/tinkerpop/gremlin/TestHelper.java | 98 +++
.../process/AbstractGremlinProcessTest.java | 2 +-
.../gremlin/process/ProcessComputerSuite.java | 2 +-
.../process/ProcessPerformanceSuite.java | 2 +-
.../gremlin/process/ProcessStandardSuite.java | 2 +-
.../process/traversal/CoreTraversalTest.java | 2 +-
.../traversal/TraversalSideEffectsTest.java | 6 +-
.../traversal/step/branch/BranchTest.java | 4 +-
.../traversal/step/branch/ChooseTest.java | 2 +-
.../traversal/step/branch/LocalTest.java | 2 +-
.../traversal/step/branch/RepeatTest.java | 8 +-
.../traversal/step/branch/UnionTest.java | 3 +-
.../process/traversal/step/filter/AndTest.java | 15 +-
.../traversal/step/filter/CyclicPathTest.java | 2 +-
.../traversal/step/filter/DedupTest.java | 4 +-
.../traversal/step/filter/ExceptTest.java | 18 +-
.../traversal/step/filter/FilterTest.java | 8 +-
.../traversal/step/filter/HasNotTest.java | 4 +-
.../process/traversal/step/filter/HasTest.java | 19 +-
.../process/traversal/step/filter/IsTest.java | 24 +-
.../process/traversal/step/filter/OrTest.java | 12 +-
.../traversal/step/filter/SampleTest.java | 2 +-
.../traversal/step/filter/WhereTest.java | 14 +-
.../traversal/step/map/AddVertexTest.java | 2 +-
.../traversal/step/map/CoalesceTest.java | 20 +-
.../process/traversal/step/map/FoldTest.java | 6 +-
.../process/traversal/step/map/MapTest.java | 18 +-
.../process/traversal/step/map/MatchTest.java | 16 +-
.../traversal/step/map/PropertiesTest.java | 2 +-
.../process/traversal/step/map/SelectTest.java | 88 +-
.../process/traversal/step/map/VertexTest.java | 7 +-
.../step/sideEffect/AggregateTest.java | 10 +-
.../step/sideEffect/GroupCountTest.java | 4 +-
.../traversal/step/sideEffect/GroupTest.java | 2 +-
.../traversal/step/sideEffect/InjectTest.java | 2 +-
.../traversal/step/sideEffect/ProfileTest.java | 14 +-
.../traversal/step/sideEffect/SackTest.java | 28 +-
.../step/sideEffect/SideEffectCapTest.java | 4 +-
.../step/sideEffect/SideEffectTest.java | 10 +-
.../traversal/step/sideEffect/StoreTest.java | 6 +-
.../traversal/step/sideEffect/SubgraphTest.java | 10 +-
.../traversal/step/sideEffect/TreeTest.java | 8 +-
.../ElementIdStrategyProcessTest.java | 2 +-
.../decoration/EventStrategyProcessTest.java | 13 +-
.../tinkerpop/gremlin/structure/BatchTest.java | 476 ----------
.../gremlin/structure/FeatureSupportTest.java | 1 -
.../tinkerpop/gremlin/structure/GraphTest.java | 1 -
.../structure/GraphWritePerformanceTest.java | 9 +-
.../tinkerpop/gremlin/structure/IoTest.java | 860 ++++++++-----------
.../gremlin/structure/PropertyTest.java | 4 +-
.../gremlin/structure/SerializationTest.java | 79 +-
.../structure/StructurePerformanceSuite.java | 2 +-
.../structure/StructureStandardSuite.java | 12 +-
.../gremlin/structure/VertexPropertyTest.java | 3 +-
.../tinkerpop/gremlin/structure/VertexTest.java | 4 -
.../util/detached/DetachedEdgeTest.java | 5 +-
.../util/detached/DetachedGraphTest.java | 96 +++
.../util/detached/DetachedPropertyTest.java | 9 +-
.../detached/DetachedVertexPropertyTest.java | 9 +-
.../util/detached/DetachedVertexTest.java | 23 +-
.../util/reference/ReferenceEdgeTest.java | 7 +-
.../util/reference/ReferenceGraphTest.java | 54 ++
.../reference/ReferenceVertexPropertyTest.java | 9 +-
.../util/reference/ReferenceVertexTest.java | 5 +-
.../structure/util/star/StarGraphTest.java | 231 ++---
.../gremlin/util/Log4jRecordingAppender.java | 66 ++
.../io/graphson/grateful-dead-typed.json | 808 +++++++++++++++++
.../io/graphson/grateful-dead-vertices.ldjson | 808 -----------------
.../structure/io/graphson/grateful-dead.json | 809 ++++++++++++++++-
.../graphson/tinkerpop-classic-normalized.json | 7 +-
.../io/graphson/tinkerpop-classic-typed.json | 7 +-
.../graphson/tinkerpop-classic-vertices.ldjson | 6 -
.../io/graphson/tinkerpop-classic.json | 7 +-
.../io/graphson/tinkerpop-crew-typed.json | 7 +-
.../io/graphson/tinkerpop-crew-vertices.ldjson | 6 -
.../structure/io/graphson/tinkerpop-crew.json | 7 +-
.../graphson/tinkerpop-modern-normalized.json | 7 +-
.../io/graphson/tinkerpop-modern-typed.json | 7 +-
.../graphson/tinkerpop-modern-vertices.ldjson | 6 -
.../structure/io/graphson/tinkerpop-modern.json | 7 +-
.../io/gryo/grateful-dead-vertices.kryo | Bin 975214 -> 0 bytes
.../structure/io/gryo/grateful-dead.kryo | Bin 493339 -> 331418 bytes
.../io/gryo/tinkerpop-classic-vertices.kryo | Bin 1179 -> 0 bytes
.../structure/io/gryo/tinkerpop-classic.kryo | Bin 765 -> 723 bytes
.../io/gryo/tinkerpop-crew-vertices.kryo | Bin 2575 -> 0 bytes
.../structure/io/gryo/tinkerpop-crew.kryo | Bin 1858 -> 1380 bytes
.../io/gryo/tinkerpop-modern-vertices.kryo | Bin 1295 -> 0 bytes
.../structure/io/gryo/tinkerpop-modern.kryo | Bin 825 -> 775 bytes
.../util/Log4jRecordingAppenderTest.java | 79 ++
.../hadoop/groovy/plugin/HadoopLoader.groovy | 16 +-
.../computer/giraph/GiraphWorkerContext.java | 1 -
.../process/computer/spark/SparkExecutor.java | 28 +-
.../computer/spark/SparkGraphComputer.java | 6 +-
.../hadoop/structure/io/ObjectWritable.java | 5 +-
.../hadoop/structure/io/VertexWritable.java | 10 +-
.../io/graphson/GraphSONRecordReader.java | 9 +-
.../structure/io/gryo/GryoOutputFormat.java | 4 -
.../structure/io/gryo/GryoRecordReader.java | 37 +-
.../structure/io/script/ScriptRecordReader.java | 2 +-
.../gremlin/hadoop/HadoopGraphProvider.java | 26 +-
.../io/TestFileReaderWriterHelper.java | 123 +++
.../hadoop/structure/io/VertexWritableTest.java | 96 +++
.../GraphSONRecordReaderWriterTest.java | 87 +-
.../io/gryo/GryoRecordReaderWriterTest.java | 83 +-
pom.xml | 4 +-
tinkergraph-gremlin/pom.xml | 5 +-
.../graph/DefaultVariableGraphTraversal.java | 8 +-
.../dsl/graph/VariableGraphTraversal.java | 21 +-
.../tinkergraph/structure/TinkerEdge.java | 2 +-
.../tinkergraph/structure/TinkerFactory.java | 2 +-
.../tinkergraph/structure/TinkerGraph.java | 6 +-
.../tinkergraph/TinkerGraphProvider.java | 8 +-
.../structure/IoDataGenerationTest.java | 278 ++++++
.../structure/TinkerGraphIdManagerTest.java | 2 +-
.../tinkergraph/structure/TinkerGraphTest.java | 397 +--------
357 files changed, 10511 insertions(+), 9131 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/bd54cf69/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/dsl/graph/DefaultVariableGraphTraversal.java
----------------------------------------------------------------------
diff --cc tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/dsl/graph/DefaultVariableGraphTraversal.java
index eb05e27,0000000..124726f
mode 100644,000000..100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/dsl/graph/DefaultVariableGraphTraversal.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/dsl/graph/DefaultVariableGraphTraversal.java
@@@ -1,155 -1,0 +1,153 @@@
+/*
+ * 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.Scope;
+import org.apache.tinkerpop.gremlin.process.traversal.Scopeable;
+import org.apache.tinkerpop.gremlin.process.traversal.Step;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+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.filter.RangeGlobalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.RangeLocalStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.HasContainer;
+import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversal;
+import org.apache.tinkerpop.gremlin.structure.Graph;
++import org.apache.tinkerpop.gremlin.structure.P;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiPredicate;
+
+/**
+ * @author Stephen Mallette (http://stephen.genoprime.com)
+ */
+public class DefaultVariableGraphTraversal<S, E> extends DefaultTraversal<S, E> implements VariableGraphTraversal.Admin<S, E> {
+
+ private final Map<Step, List<TraversalVariablePosition>> stepVariables = new HashMap<>();
+
+ public DefaultVariableGraphTraversal(final Graph graph) {
+ super(graph);
+ }
+
+ @Override
+ public VariableGraphTraversal.Admin<S, E> asAdmin() {
+ return this;
+ }
+
+ @Override
+ public VariableGraphTraversal<S, E> iterate() {
+ return VariableGraphTraversal.Admin.super.iterate();
+ }
+
+ @Override
+ public DefaultVariableGraphTraversal<S, E> clone() {
+ return (DefaultVariableGraphTraversal<S, E>) super.clone();
+ }
+
+ @Override
+ public Map<Step, List<TraversalVariablePosition>> getStepVariables() {
+ return stepVariables;
+ }
+
+ @Override
+ public VariableGraphTraversal<S, E> has(final CharSequence key, final BiPredicate predicate, final Object value) {
+ final String k;
+ final List<TraversalVariablePosition> variablePositions = new ArrayList<>();
+ if ((key instanceof TraversalVariable)) {
+ final TraversalVariable var = (TraversalVariable) key;
+ k = var.getDefaultString();
+
+ final TraversalVariablePosition variablePosition = new TraversalVariablePosition(var, 0);
+ variablePositions.add(variablePosition);
+ } else {
+ k = key != null ? key.toString() : null;
+ }
+
+ if ((predicate instanceof TraversalVariable))
+ variablePositions.add(new TraversalVariablePosition((TraversalVariable) predicate, 1));
+ if ((value instanceof TraversalVariable))
+ variablePositions.add(new TraversalVariablePosition((TraversalVariable) value, 2));
+
+ final Step s = new HasStep(this.asAdmin(), new HasContainer(k, predicate, value));
+ stepVariables.put(s, variablePositions);
+ return this.asAdmin().addStep(s);
+ }
+
+ @Override
- public VariableGraphTraversal<S, E> is(final BiPredicate predicate, final Object value) {
++ public VariableGraphTraversal<S, E> is(final Object value) {
+ final List<TraversalVariablePosition> variablePositions = new ArrayList<>();
- if ((predicate instanceof TraversalVariable))
- variablePositions.add(new TraversalVariablePosition((TraversalVariable) predicate, 0));
-
+ if ((value instanceof TraversalVariable))
+ variablePositions.add(new TraversalVariablePosition((TraversalVariable) value, 1));
+
- final Step s = new IsStep(this.asAdmin(), predicate, value);
++ final Step s = new IsStep(this.asAdmin(), P.eq(value));
+ stepVariables.put(s, variablePositions);
+ return this.asAdmin().addStep(s);
+ }
+
+ @Override
+ public VariableGraphTraversal<S, E> range(final Scopeable scope, final Number low, final Number high) {
+ // this one is tricky because Scope is an enum - enums would have to implement an interface that
+ // TraversalVariable could implement. maybe we just add a Scopeable interface as a marker to
+ // arrange for that. that seems pretty non-intrusive.
+ final List<TraversalVariablePosition> variablePositions = new ArrayList<>();
+
+ final int l;
+ if ((low instanceof TraversalVariable)) {
+ final TraversalVariable var = (TraversalVariable) low;
+ l = var.intValue();
+
+ final TraversalVariablePosition variablePosition = new TraversalVariablePosition(var, 0);
+ variablePositions.add(variablePosition);
+ } else {
+ l = low != null ? low.intValue() : 0;
+ }
+
+ final int h;
+ if ((high instanceof TraversalVariable)) {
+ final TraversalVariable var = (TraversalVariable) high;
+ h = var.intValue();
+
+ final TraversalVariablePosition variablePosition = new TraversalVariablePosition(var, 1);
+ variablePositions.add(variablePosition);
+ } else {
+ h = high != null ? high.intValue() : 0;
+ }
+
+ // scope is a tricky one. scope determines the step that is added. if it is parameterized then there is
+ // no way to know which step will be used. added a "decision" step to mark that position and be a holder
+ // for the variables.
+ final Step s;
+ if ((scope instanceof TraversalVariable)) {
+ final TraversalVariable var = (TraversalVariable) scope;
+ s = new RangeDecisionStep(this.asAdmin(), l, h, var);
+ final TraversalVariablePosition variablePosition = new TraversalVariablePosition(var, -1);
+ variablePositions.add(variablePosition);
+ } else {
+ s = scope.equals(Scope.global)
+ ? new RangeGlobalStep<>(this.asAdmin(), l, h)
+ : new RangeLocalStep<>(this.asAdmin(), l, h);
+ }
+
+ stepVariables.put(s, variablePositions);
+ return this.asAdmin().addStep(s);
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/bd54cf69/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 52f0876,0000000..eda9307
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,827 -1,0 +1,824 @@@
+/*
+ * 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.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.P;
+import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.PropertyType;
++import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+import org.apache.tinkerpop.gremlin.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, 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 String firstKey, final P<?> predicate) {
++ return this.asAdmin().addStep(new WhereStep<>(this.asAdmin(), firstKey, 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 default VariableGraphTraversal<S, E> is(final P<E>... predicates) {
++ return this.asAdmin().addStep(new IsStep<>(this.asAdmin(), predicates));
+ }
+
- public VariableGraphTraversal<S, E> is(final BiPredicate predicate, final Object value);
++ public default VariableGraphTraversal<S, E> is(final Object value) {
++ return this.is(new P[]{value instanceof P ? (P) value : P.eq(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 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/bd54cf69/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 e71bb66,290b818..27b020c
--- 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
@@@ -18,61 -18,24 +18,35 @@@
*/
package org.apache.tinkerpop.gremlin.tinkergraph.structure;
- import org.apache.commons.io.FileUtils;
- import org.apache.tinkerpop.gremlin.AbstractGremlinTest;
+ import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
-import org.apache.tinkerpop.gremlin.structure.Order;
+ import org.apache.tinkerpop.gremlin.structure.P;
+ import org.apache.tinkerpop.gremlin.structure.T;
+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.algorithm.generator.DistributionGenerator;
- import org.apache.tinkerpop.gremlin.algorithm.generator.PowerLawDistribution;
- 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;
import org.apache.tinkerpop.gremlin.structure.Operator;
import org.apache.tinkerpop.gremlin.structure.Vertex;
- import org.apache.tinkerpop.gremlin.structure.io.GraphReader;
- import org.apache.tinkerpop.gremlin.structure.io.graphml.GraphMLWriter;
- import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper;
- 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.structure.io.graphml.GraphMLIo;
+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;
+import javax.script.Bindings;
+import javax.script.CompiledScript;
+import javax.script.ScriptException;
+import javax.script.SimpleBindings;
- import java.io.File;
- import java.io.FileOutputStream;
- import java.io.IOException;
- import java.io.InputStream;
- import java.io.OutputStream;
import java.util.Arrays;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import java.util.function.Supplier;
- import java.util.stream.IntStream;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.*;
import static org.junit.Assert.assertEquals;
@@@ -636,181 -383,11 +394,96 @@@ public class TinkerGraphTest
// is used because only oid 1 should pass through the pipeline due to the inclusion of the
// key index lookup on "oid". If there's an weight of something other than 0.5f in the pipeline being
// evaluated then something is wrong.
- assertEquals(new Long(1), g.traversal().E().has("weight", (t, u) -> {
+ assertEquals(new Long(1), g.traversal().E().has("weight", P.test((t, u) -> {
assertEquals(0.5f, t);
return true;
- }, 0.5).has("oid", "1").count().next());
- }
-
- @Test
- public void shouldWriteSampleForGremlinServer() throws IOException {
- final Graph g = TinkerGraph.open();
- IntStream.range(0, 10000).forEach(i -> g.addVertex("oid", i));
- DistributionGenerator.build(g)
- .label("knows")
- .seedGenerator(() -> 987654321l)
- .outDistribution(new PowerLawDistribution(2.1))
- .inDistribution(new PowerLawDistribution(2.1))
- .expectedNumEdges(100000).create().generate();
-
- final OutputStream os = new FileOutputStream(tempPath + "sample.kryo");
- GryoWriter.build().create().writeGraph(os, g);
- os.close();
- }
-
- /**
- * This test helps with data conversions on Grateful Dead. No Assertions...run as needed. Never read from the
- * GraphML source as it will always use a String identifier.
- */
- @Test
- public void shouldWriteGratefulDead() throws IOException {
- final Graph g = TinkerGraph.open();
-
- final GraphReader reader = GryoReader.build().create();
- try (final InputStream stream = AbstractGremlinTest.class.getResourceAsStream("/org/apache/tinkerpop/gremlin/structure/io/gryo/grateful-dead.kryo")) {
- reader.readGraph(stream, g);
- }
-
- /* keep this hanging around because changes to gryo format will need grateful dead generated from json so you can generate the gio
- final GraphSONMapper mapper = GraphSONMapper.build().embedTypes(true).create();
- final GraphReader reader = org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONReader.build().mapper(mapper).create();
- try (final InputStream stream = AbstractGremlinTest.class.getResourceAsStream("/org/apache/tinkerpop/gremlin/structure/io/graphson/grateful-dead.json")) {
- reader.readGraph(stream, g);
- }
- */
-
- final Graph ng = TinkerGraph.open();
- g.traversal().V().sideEffect(ov -> {
- final Vertex v = ov.get();
- if (v.label().equals("song"))
- ng.addVertex(T.id, Integer.parseInt(v.id().toString()), T.label, "song", "name", v.value("name"), "performances", v.property("performances").orElse(0), "songType", v.property("songType").orElse(""));
- else if (v.label().equals("artist"))
- ng.addVertex(T.id, Integer.parseInt(v.id().toString()), T.label, "artist", "name", v.value("name"));
- else
- throw new RuntimeException("damn");
- }).iterate();
-
- g.traversal().E().sideEffect(oe -> {
- final Edge e = oe.get();
- final Vertex v2 = ng.traversal().V(Integer.parseInt(e.inVertex().id().toString())).next();
- final Vertex v1 = ng.traversal().V(Integer.parseInt(e.outVertex().id().toString())).next();
-
- if (e.label().equals("followedBy"))
- v1.addEdge("followedBy", v2, T.id, Integer.parseInt(e.id().toString()), "weight", e.value("weight"));
- else if (e.label().equals("sungBy"))
- v1.addEdge("sungBy", v2, T.id, Integer.parseInt(e.id().toString()));
- else if (e.label().equals("writtenBy"))
- v1.addEdge("writtenBy", v2, T.id, Integer.parseInt(e.id().toString()));
- else
- throw new RuntimeException("bah");
-
- }).iterate();
-
- final OutputStream os = new FileOutputStream(tempPath + "grateful-dead.kryo");
- GryoWriter.build().create().writeGraph(os, ng);
- os.close();
-
- final OutputStream os2 = new FileOutputStream(tempPath + "grateful-dead.json");
- GraphSONWriter.build().mapper(GraphSONMapper.build().embedTypes(true).create()).create().writeGraph(os2, g);
- os2.close();
-
- final OutputStream os3 = new FileOutputStream(tempPath + "grateful-dead.xml");
- GraphMLWriter.build().create().writeGraph(os3, g);
- os3.close();
-
- final OutputStream os4 = new FileOutputStream(tempPath + "grateful-dead-vertices.kryo");
- GryoWriter.build().create().writeVertices(os4, g.traversal().V(), Direction.BOTH);
- os.close();
-
- final OutputStream os5 = new FileOutputStream(tempPath + "grateful-dead-vertices.ldjson");
- GraphSONWriter.build().create().writeVertices(os5, g.traversal().V(), Direction.BOTH);
- os.close();
+ }, 0.5)).has("oid", "1").count().next());
}
+ @Test
+ public void shouldGrabParameters() throws Exception {
+ // compile() should cache the script to avoid future compilation
+ final GremlinGroovyScriptEngine engine = new GremlinGroovyScriptEngine();
+
+ final Graph graph = TinkerFactory.createModern();
+
+ // initially bind "g" to the variablized version of a Traversal
+ final VariableGraphTraversalSource gVar = graph.traversal(VariableGraphTraversalSource.build().engine(StandardTraversalEngine.build()));
+
+ final String script = "g.V(x).out().has('name',y).values('age').is(z).range(aa,10)";
+ final CompiledScript compilable = engine.compile(script);
+
+ // get the variablized Traversal instance. variables are tracked within the Traversal implementation itself
+ // and are referenced by step as a key within a Map
+ try {
+ final Bindings b = new SimpleBindings();
+ b.put("g", gVar);
+ b.put("x", new TraversalVariable("x"));
+ b.put("y", new TraversalVariable("y"));
+ b.put("z", new TraversalVariable("z"));
+ b.put("aa", new TraversalVariable("aa"));
+ final VariableGraphTraversal o = (VariableGraphTraversal) compilable.eval(b);
+ System.out.println(o);
+
+ final Map<Step, List<TraversalVariablePosition>> variables = o.getStepVariables();
+
+ assertEquals(b.get("x"), variables.get(o.asAdmin().getStartStep()).get(0).getVariable());
+ assertEquals(b.get("y"), variables.get(o.asAdmin().getSteps().get(2)).get(0).getVariable());
+ assertEquals(b.get("z"), variables.get(o.asAdmin().getSteps().get(4)).get(0).getVariable());
+ assertEquals(b.get("aa"), variables.get(o.asAdmin().getSteps().get(5)).get(0).getVariable());
+ } catch (ScriptException se) {
+ se.printStackTrace();
+ }
+
+ // at this point the script is compiled so we saved that step and can re-use it with a different
+ // and standard GraphTraversalSource for the binding to "g" in the ScriptEngine:
+ final GraphTraversalSource g = graph.traversal();
+ final Bindings b = new SimpleBindings();
+ b.put("g", g);
+ b.put("x", 1);
+ b.put("y", "josh");
+ b.put("z", 32);
+ b.put("aa", 0);
+
+ final Traversal t = (Traversal) engine.eval(script, b);
+ assertEquals(32, t.next());
+ }
+ @Test
+ public void shouldTrackTraversalVariables() throws Exception {
+ final Graph graph = TinkerFactory.createModern();
+
+ final VariableGraphTraversalSource gVar = graph.traversal(VariableGraphTraversalSource.build().engine(StandardTraversalEngine.build()));
+ final TraversalVariable varX = new TraversalVariable("x");
+ final TraversalVariable varY = new TraversalVariable("y");
+ final TraversalVariable varZ = new TraversalVariable("z");
+ final TraversalVariable varAa = new TraversalVariable("aa");
+
+ final VariableGraphTraversal<Vertex,Object> t = gVar.V(varX).out().has("name", varY)
+ .values("age").is(varZ).range(varAa, 10);
+
+ final Map<Step, List<TraversalVariablePosition>> variables = t.getStepVariables();
+
+ assertEquals(varX, variables.get(t.asAdmin().getStartStep()).get(0).getVariable());
+ assertEquals(varY, variables.get(t.asAdmin().getSteps().get(2)).get(0).getVariable());
+ assertEquals(varZ, variables.get(t.asAdmin().getSteps().get(4)).get(0).getVariable());
+ assertEquals(varAa, variables.get(t.asAdmin().getSteps().get(5)).get(0).getVariable());
+
+ /*
+ final Map<String,Object> bindings = new HashMap<>();
+ bindings.put("x", 1);
+ bindings.put("y", "josh");
+ bindings.put("z", 32);
+ bindings.put("aa", 0);
+
+ // bind() would clone "t" with traversals applied, as possible, given statically defined steps (i.e. that
+ // don't have variables). in this way the traversal is "prepared" as best it can be given the information
+ // that it has available. TraversalVariables would be replaced with the values from the "bindings" Map
+ // thus making the traversal "final" or "static"
+ final Traversal t1 = t.bind(bindings);
+
+ // when next() is called on "t1", remaining strategies can be executed given that the bindings are final
+ assertEquals(32, t1.next());
+ */
+ }
}