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 2016/08/22 20:40:33 UTC
[48/48] tinkerpop git commit: Merge remote-tracking branch
'origin/master' into TINKERPOP-1278
Merge remote-tracking branch 'origin/master' into TINKERPOP-1278
Conflicts:
CHANGELOG.asciidoc
docs/src/upgrade/release-3.2.x-incubating.asciidoc
gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONMapperTest.java
gremlin-server/conf/gremlin-server-classic.yaml
gremlin-server/pom.xml
Project: http://git-wip-us.apache.org/repos/asf/tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/tinkerpop/commit/67b4d113
Tree: http://git-wip-us.apache.org/repos/asf/tinkerpop/tree/67b4d113
Diff: http://git-wip-us.apache.org/repos/asf/tinkerpop/diff/67b4d113
Branch: refs/heads/TINKERPOP-1278
Commit: 67b4d113301174365163f7902ec4c0e6ef36aa7c
Parents: fb8c25c f929db0
Author: Stephen Mallette <sp...@genoprime.com>
Authored: Mon Aug 22 16:39:13 2016 -0400
Committer: Stephen Mallette <sp...@genoprime.com>
Committed: Mon Aug 22 16:39:13 2016 -0400
----------------------------------------------------------------------
CHANGELOG.asciidoc | 11 +
data/grateful-dead-typed.json | 422 +++++-----
data/grateful-dead-v2d0-typed.json | 808 +++++++++++++++++++
data/grateful-dead-v2d0.json | 808 +++++++++++++++++++
data/grateful-dead.json | 422 +++++-----
data/tinkerpop-classic-v2d0-typed.json | 6 +
data/tinkerpop-classic-v2d0.json | 6 +
data/tinkerpop-crew-v2d0-typed.json | 6 +
data/tinkerpop-crew-v2d0.json | 6 +
data/tinkerpop-modern-v2d0-typed.json | 6 +
data/tinkerpop-modern-v2d0.json | 6 +
docs/src/index.asciidoc | 91 +++
.../src/reference/gremlin-applications.asciidoc | 10 +-
docs/src/reference/the-graph.asciidoc | 139 +++-
.../upgrade/release-3.2.x-incubating.asciidoc | 78 +-
docs/static/images/gremlin-gym-cropped.png | Bin 0 -> 32532 bytes
.../images/gremlin-house-of-mirrors-cropped.png | Bin 0 -> 290361 bytes
.../main/resources/archetype-resources/pom.xml | 5 +
gremlin-console/pom.xml | 11 +
gremlin-core/pom.xml | 8 +-
.../traversal/step/filter/TailGlobalStep.java | 5 +-
.../StandardVerificationStrategy.java | 15 +-
.../traversal/util/DefaultTraversalMetrics.java | 13 +-
.../process/traversal/util/MutableMetrics.java | 14 +-
.../tinkerpop/gremlin/structure/io/Io.java | 16 +
.../gremlin/structure/io/graphml/GraphMLIo.java | 27 +-
.../structure/io/graphson/GraphSONIo.java | 28 +-
.../structure/io/graphson/GraphSONMapper.java | 164 +++-
.../structure/io/graphson/GraphSONModule.java | 259 +++++-
.../structure/io/graphson/GraphSONReader.java | 8 +-
.../io/graphson/GraphSONSerializerProvider.java | 15 +-
.../io/graphson/GraphSONSerializers.java | 466 -----------
.../io/graphson/GraphSONSerializersV1d0.java | 466 +++++++++++
.../io/graphson/GraphSONSerializersV2d0.java | 581 +++++++++++++
.../structure/io/graphson/GraphSONTokens.java | 3 +
.../graphson/GraphSONTraversalSerializers.java | 27 +-
.../io/graphson/GraphSONTypeDeserializer.java | 227 ++++++
.../io/graphson/GraphSONTypeIdResolver.java | 108 +++
.../graphson/GraphSONTypeResolverBuilder.java | 67 ++
.../io/graphson/GraphSONTypeSerializer.java | 201 +++++
.../structure/io/graphson/GraphSONUtil.java | 37 +
.../structure/io/graphson/GraphSONVersion.java | 3 +-
.../structure/io/graphson/GraphSONWriter.java | 11 +-
.../io/graphson/JavaTimeSerializers.java | 326 --------
.../io/graphson/JavaTimeSerializersV1d0.java | 326 ++++++++
.../io/graphson/JavaTimeSerializersV2d0.java | 323 ++++++++
.../io/graphson/JavaUtilSerializers.java | 86 --
.../io/graphson/JavaUtilSerializersV1d0.java | 86 ++
.../io/graphson/JavaUtilSerializersV2d0.java | 87 ++
.../structure/io/graphson/JsonParserConcat.java | 83 ++
.../io/graphson/LegacyGraphSONReader.java | 4 +-
.../io/graphson/TinkerPopJacksonModule.java | 48 ++
.../io/graphson/ToStringGraphSONSerializer.java | 42 +
.../gremlin/structure/io/graphson/TypeInfo.java | 29 +
.../gremlin/structure/io/gryo/GryoIo.java | 28 +-
.../structure/util/detached/DetachedEdge.java | 11 +-
.../structure/util/detached/DetachedVertex.java | 10 +-
.../util/star/DirectionalStarGraph.java | 39 +
.../gremlin/structure/util/star/StarGraph.java | 17 +-
.../star/StarGraphGraphSONDeserializer.java | 91 +++
.../util/star/StarGraphGraphSONSerializer.java | 250 ------
.../star/StarGraphGraphSONSerializerV1d0.java | 178 ++++
.../star/StarGraphGraphSONSerializerV2d0.java | 165 ++++
.../TraversalStrategyPerformanceTest.java | 2 +-
.../StandardVerificationStrategyTest.java | 41 +-
.../GraphSONMapperEmbeddedTypeTest.java | 22 +-
.../io/graphson/GraphSONMapperTest.java | 32 +-
...hSONMapperV1d0ToV2d0BuilderSettingsTest.java | 86 ++
...aphSONMapperV2d0PartialEmbeddedTypeTest.java | 351 ++++++++
gremlin-driver/pom.xml | 6 +
.../tinkerpop/gremlin/driver/Cluster.java | 154 +++-
.../AbstractGraphSONMessageSerializerV1d0.java | 2 +-
.../AbstractGraphSONMessageSerializerV2d0.java | 245 ++++++
.../GraphSONMessageSerializerGremlinV2d0.java | 69 ++
.../ser/GraphSONMessageSerializerV2d0.java | 125 +++
.../tinkerpop/gremlin/driver/ser/SerTokens.java | 1 +
...raphSONMessageSerializerGremlinTestV1d0.java | 334 ++++++++
...raphSONMessageSerializerGremlinTestV2d0.java | 341 ++++++++
...raphSONMessageSerializerGremlinV1d0Test.java | 334 --------
.../ser/GraphSONMessageSerializerV1d0Test.java | 9 +-
.../ser/GraphSONMessageSerializerV2d0Test.java | 507 ++++++++++++
.../traversal/step/filter/GroovyTailTest.groovy | 5 +
gremlin-groovy/pom.xml | 7 +
gremlin-server/conf/gremlin-server-classic.yaml | 3 -
gremlin-server/conf/gremlin-server-min.yaml | 17 -
.../conf/gremlin-server-modern-readonly.yaml | 3 -
gremlin-server/conf/gremlin-server-modern.yaml | 3 -
gremlin-server/conf/gremlin-server-neo4j.yaml | 4 +-
.../conf/gremlin-server-rest-modern.yaml | 4 +-
.../conf/gremlin-server-rest-secure.yaml | 4 +-
gremlin-server/conf/gremlin-server-secure.yaml | 4 +-
gremlin-server/conf/gremlin-server-spark.yaml | 4 +-
gremlin-server/conf/gremlin-server.yaml | 4 +-
gremlin-server/data/sample.kryo | Bin 2416053 -> 2436147 bytes
gremlin-server/pom.xml | 11 +
.../gremlin/server/AbstractChannelizer.java | 23 +-
.../tinkerpop/gremlin/server/GremlinServer.java | 6 +
.../tinkerpop/gremlin/server/Settings.java | 27 +-
.../server/GremlinServerHttpIntegrateTest.java | 22 +
.../gremlin/util/Log4jRecordingAppender.java | 66 ++
.../util/Log4jRecordingAppenderTest.java | 86 ++
.../remote/gremlin-server-integration.yaml | 4 +-
.../server/gremlin-server-integration.yaml | 4 +-
.../server/gremlin-server-performance.yaml | 3 -
gremlin-test/pom.xml | 6 +
.../process/traversal/step/filter/TailTest.java | 18 +
.../traversal/step/map/PropertiesTest.java | 6 +-
.../structure/util/star/StarGraphTest.java | 34 +
.../gremlin/util/Log4jRecordingAppender.java | 66 --
.../io/graphson/grateful-dead-typed.json | 422 +++++-----
.../io/graphson/grateful-dead-v2d0-typed.json | 808 +++++++++++++++++++
.../io/graphson/grateful-dead-v2d0.json | 808 +++++++++++++++++++
.../structure/io/graphson/grateful-dead.json | 422 +++++-----
.../tinkerpop-classic-normalized-v2d0.json | 6 +
.../graphson/tinkerpop-classic-v2d0-typed.json | 6 +
.../io/graphson/tinkerpop-classic-v2d0.json | 6 +
.../io/graphson/tinkerpop-crew-v2d0-typed.json | 6 +
.../io/graphson/tinkerpop-crew-v2d0.json | 6 +
.../tinkerpop-modern-normalized-v2d0.json | 6 +
.../graphson/tinkerpop-modern-v2d0-typed.json | 6 +
.../io/graphson/tinkerpop-modern-v2d0.json | 6 +
.../util/Log4jRecordingAppenderTest.java | 80 --
pom.xml | 27 +
tinkergraph-gremlin/pom.xml | 4 +-
.../tinkergraph/structure/TinkerGraph.java | 2 +-
.../structure/TinkerIoRegistryV2d0.java | 213 +++++
.../structure/IoDataGenerationTest.java | 115 ++-
.../TinkerGraphGraphSONSerializerV2d0Test.java | 565 +++++++++++++
.../tinkergraph/structure/TinkerGraphTest.java | 28 +-
129 files changed, 11771 insertions(+), 2715 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/67b4d113/CHANGELOG.asciidoc
----------------------------------------------------------------------
diff --cc CHANGELOG.asciidoc
index 22d6953,5f49bea..91d6fed
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@@ -26,21 -26,12 +26,27 @@@ image::https://raw.githubusercontent.co
TinkerPop 3.2.2 (NOT OFFICIALLY RELEASED YET)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+* Added `gremlin-python` package as a Gremlin language variant in Python.
+* Added `Bytecode` which specifies the instructions and arguments used to construct a traversal.
+* Created an experimental GraphSON representation of `Bytecode` that will be considered unstable until 3.3.0.
+* Added `Translator` which allows from the translation of `Bytecode` into some other form (e.g. script, `Traversal`, etc.).
+* Added `JavaTranslator`, `GroovyTranslator`, `PythonTranslator`, and `JythonTranslator` for translating `Bytecode` accordingly.
+* Added `TranslationStrategy` to `gremlin-test` so translators can be tested against the the process test suite.
+* Added `Traversal.Admin.nextTraverser()` to get the next result in bulk-form (w/ default implementation).
+* Added `TraversalSource.getAnonymousTraversalClass()` (w/ default implementation).
+* Added `GremlinScriptEngine` interface which specifies a `eval(Bytecode, Bindings)` method.
+* Deprecated `RemoteGraph` in favor of `TraversalSource.withRemote()` as it is more technically correct to tie a remote traversal to the `TraversalSource` than a `Graph` instance.
+* `GremlinGroovyScriptEngine` implements `GremlinScriptEngine`.
+* Added `GremlinJythonScriptEngine` which implements `GremlinScriptEngine`.
+* Removed support for submitting a Java serialized `Traversal` to Gremlin Server.
+* Removed a largely internal feature that supported automatic unrolling of traversers in the Gremlin Driver.
+* Made it possible to directly initialize `OpProcessor` implementations with server `Settings`.
+ * Included GraphSON as a default serializer (in addition to Gryo, which was already present) in Gremlin Server if none are defined
+ * Introduced GraphSON 2.0.
+ * Deprecated `embedTypes` on the builder for `GraphSONMapper`.
+ * Defaulted the `gremlinPool` setting in Gremlin Server to be zero, which will instructs it to use `Runtime.availableProcessors()` for that settings.
+ * Changed scope of log4j dependencies so that they would only be used in tests and the binary distributions of Gremlin Console and Server.
+ * Deprecated `Io.Builder.registry()` in favor of the newly introduced `Io.Builder.onMapper()`.
* Added new recipe for "Traversal Induced Values".
* Fixed a potential leak of a `ReferenceCounted` resource in Gremlin Server.
* Added class registrations for `Map.Entry` implementations to `GryoMapper`.
http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/67b4d113/docs/src/reference/gremlin-applications.asciidoc
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/67b4d113/docs/src/upgrade/release-3.2.x-incubating.asciidoc
----------------------------------------------------------------------
diff --cc docs/src/upgrade/release-3.2.x-incubating.asciidoc
index fa55403,77333d4..fb2ec21
--- a/docs/src/upgrade/release-3.2.x-incubating.asciidoc
+++ b/docs/src/upgrade/release-3.2.x-incubating.asciidoc
@@@ -30,18 -66,47 +66,56 @@@ See: https://issues.apache.org/jira/bro
Upgrading for Providers
~~~~~~~~~~~~~~~~~~~~~~~
- Driver Providers
- ^^^^^^^^^^^^^^^^
+ Graph System Providers
+ ^^^^^^^^^^^^^^^^^^^^^^
+
+ Deprecated Io.Builder.registry()
+ ++++++++++++++++++++++++++++++++
+
+ The `Io.Builder.registry()` has been deprecated in favor of `Io.Builder.onMapper(Consumer<Mapper>)`. This change gives
+ the `Graph` implementation greater flexibility over how to modify the `Mapper` implementation. In most cases, the
+ implementation will simply add its `IoRegistry` to allow the `Mapper` access to custom serialization classes, but this
+ approach makes it possible to also set other specific settings that aren't generalized across all IO implementations.
+ A good example of this type of usage would be to provide a custom `ClassRessolver` implementation to a `GryoMapper`.
+
+ See: link:https://issues.apache.org/jira/browse/TINKERPOP-1402[TINKERPOP-1402]
+
+ Log4j Dependencies
+ ++++++++++++++++++
+
+ There were a number of changes to the Log4j dependencies in the various modules. Log4j was formerly included as part
+ of the `slf4j-log4j12` in `gremlin-core`, however that "forced" use of log4j as a logger implementation when that
+ really wasn't necessary or desired. The `slf4j-log4j12` dependency is now in "test" scope for most of the modules. The
+ exception to that rule is `gremlin-test` which prescribes it as "optional". That change means that developers
+ dependending on `gremlin-test` (or `gremlin-groovy-test`) will need to explicitly specify it as a dependency in their
+ `pom.xml` (or a different slf4j implementation if that better suits them).
+
+ See: link:https://issues.apache.org/jira/browse/TINKERPOP-1151[TINKERPOP-1151]
+
-Graph Drivers Providers
-^^^^^^^^^^^^^^^^^^^^^^
++Drivers Providers
++^^^^^^^^^^^^^^^^^
+
+ GraphSON 2.0
+ ++++++++++++
+
+ Drivers providers can exploit the new format of typed values JSON serialization offered by GraphSON 2.0. This format
+ has been created to allow easy and agnostic parsing of a GraphSON payload without type loss. Drivers of non-Java
+ languages can then implement their own mapping of the GraphSON's language agnostic type IDs (e.g. `UUID`, `LocalDate`)
+ to the appropriate representation for the driver's language.
+
+ See: link:https://issues.apache.org/jira/browse/TINKERPOP-1274[TINKERPOP-1274],
+ link:http://tinkerpop.apache.org/docs/3.2.1-incubating/reference/#graphson-2.0-types[Reference Documentation -
+ GraphSON 2.0].
+Traversal Serialization
++++++++++++++++++++++++
+
+There was an "internal" serialization format in place for `Traversal` which allowed one to be submitted to Gremlin
+Server directly over `RemoteGraph`. That format has been removed completely and is wholly replaced by the non-JVM
+specific approach of serializing `Bytecode`.
+
+See: link:https://issues.apache.org/jira/browse/TINKERPOP-1392[TINKERPOP-1392]
+
TinkerPop 3.2.1
---------------
http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/67b4d113/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
----------------------------------------------------------------------
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
index f7d340c,a0303cf..f65d64f
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
@@@ -18,30 -18,20 +18,33 @@@
*/
package org.apache.tinkerpop.gremlin.structure.io.graphson;
+import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
+import org.apache.tinkerpop.gremlin.process.traversal.Operator;
+import org.apache.tinkerpop.gremlin.process.traversal.Order;
+import org.apache.tinkerpop.gremlin.process.traversal.P;
import org.apache.tinkerpop.gremlin.process.traversal.Path;
+import org.apache.tinkerpop.gremlin.process.traversal.Pop;
+import org.apache.tinkerpop.gremlin.process.traversal.SackFunctions;
+import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
+ import org.apache.tinkerpop.gremlin.process.traversal.util.Metrics;
import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation;
import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalMetrics;
+import org.apache.tinkerpop.gremlin.structure.Column;
+import org.apache.tinkerpop.gremlin.structure.Direction;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.T;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.apache.tinkerpop.gremlin.structure.VertexProperty;
- import org.apache.tinkerpop.gremlin.structure.util.star.StarGraphGraphSONSerializer;
+ import org.apache.tinkerpop.gremlin.structure.util.star.DirectionalStarGraph;
+ import org.apache.tinkerpop.gremlin.structure.util.star.StarGraphGraphSONSerializerV1d0;
+ import org.apache.tinkerpop.gremlin.structure.util.star.StarGraphGraphSONSerializerV2d0;
+import org.apache.tinkerpop.gremlin.util.function.Lambda;
- import org.apache.tinkerpop.shaded.jackson.databind.module.SimpleModule;
+ import java.nio.ByteBuffer;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
@@@ -74,6 -65,140 +78,167 @@@ abstract class GraphSONModule extends T
}
/**
+ * Version 2.0 of GraphSON.
+ */
+ static final class GraphSONModuleV2d0 extends GraphSONModule {
+ /**
+ * Constructs a new object.
+ */
+ protected GraphSONModuleV2d0(final boolean normalize) {
+ super("graphson-2.0");
+
+ /////////////////////// SERIALIZERS ////////////////////////////
+
+ // graph
+ addSerializer(Edge.class, new GraphSONSerializersV2d0.EdgeJacksonSerializer(normalize));
+ addSerializer(Vertex.class, new GraphSONSerializersV2d0.VertexJacksonSerializer(normalize));
+ addSerializer(VertexProperty.class, new GraphSONSerializersV2d0.VertexPropertyJacksonSerializer(normalize, true));
+ addSerializer(Property.class, new GraphSONSerializersV2d0.PropertyJacksonSerializer());
+ addSerializer(Metrics.class, new GraphSONSerializersV2d0.MetricsJacksonSerializer());
+ addSerializer(TraversalMetrics.class, new GraphSONSerializersV2d0.TraversalMetricsJacksonSerializer());
+ addSerializer(TraversalExplanation.class, new GraphSONSerializersV2d0.TraversalExplanationJacksonSerializer());
+ addSerializer(Path.class, new GraphSONSerializersV2d0.PathJacksonSerializer());
+ addSerializer(DirectionalStarGraph.class, new StarGraphGraphSONSerializerV2d0(normalize));
+ addSerializer(Tree.class, new GraphSONSerializersV2d0.TreeJacksonSerializer());
+
+ // java.util
+ addSerializer(Map.Entry.class, new JavaUtilSerializersV2d0.MapEntryJacksonSerializer());
+
+ // need to explicitly add serializers for those types because Jackson doesn't do it at all.
+ addSerializer(Integer.class, new GraphSONSerializersV2d0.IntegerGraphSONSerializer());
+ addSerializer(Double.class, new GraphSONSerializersV2d0.DoubleGraphSONSerializer());
+
+ // java.time
+ addSerializer(Duration.class, new JavaTimeSerializersV2d0.DurationJacksonSerializer());
+ addSerializer(Instant.class, new JavaTimeSerializersV2d0.InstantJacksonSerializer());
+ addSerializer(LocalDate.class, new JavaTimeSerializersV2d0.LocalDateJacksonSerializer());
+ addSerializer(LocalDateTime.class, new JavaTimeSerializersV2d0.LocalDateTimeJacksonSerializer());
+ addSerializer(LocalTime.class, new JavaTimeSerializersV2d0.LocalTimeJacksonSerializer());
+ addSerializer(MonthDay.class, new JavaTimeSerializersV2d0.MonthDayJacksonSerializer());
+ addSerializer(OffsetDateTime.class, new JavaTimeSerializersV2d0.OffsetDateTimeJacksonSerializer());
+ addSerializer(OffsetTime.class, new JavaTimeSerializersV2d0.OffsetTimeJacksonSerializer());
+ addSerializer(Period.class, new JavaTimeSerializersV2d0.PeriodJacksonSerializer());
+ addSerializer(Year.class, new JavaTimeSerializersV2d0.YearJacksonSerializer());
+ addSerializer(YearMonth.class, new JavaTimeSerializersV2d0.YearMonthJacksonSerializer());
+ addSerializer(ZonedDateTime.class, new JavaTimeSerializersV2d0.ZonedDateTimeJacksonSerializer());
+ addSerializer(ZoneOffset.class, new JavaTimeSerializersV2d0.ZoneOffsetJacksonSerializer());
+
++ // traversal
++ // TODO: review (added for integration with new GraphSON model for GLV bytecode)
++ addSerializer(Traversal.class, new GraphSONTraversalSerializers.TraversalJacksonSerializer());
++ addSerializer(Bytecode.class, new GraphSONTraversalSerializers.BytecodeJacksonSerializer());
++ addSerializer(VertexProperty.Cardinality.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
++ addSerializer(Column.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
++ addSerializer(Direction.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
++ addSerializer(SackFunctions.Barrier.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
++ addSerializer(Operator.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
++ addSerializer(Order.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
++ addSerializer(Pop.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
++ addSerializer(Scope.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
++ addSerializer(T.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
++ addSerializer(P.class, new GraphSONTraversalSerializers.PJacksonSerializer());
++ addSerializer(Lambda.class, new GraphSONTraversalSerializers.LambdaJacksonSerializer());
++ addSerializer(Bytecode.Binding.class, new GraphSONTraversalSerializers.BindingJacksonSerializer());
++ addSerializer(Traverser.class, new GraphSONTraversalSerializers.TraverserSerializer());
++
+ /////////////////////// DESERIALIZERS ////////////////////////////
+
+ // Tinkerpop Graph
+ addDeserializer(Vertex.class, new GraphSONSerializersV2d0.VertexJacksonDeserializer());
+ addDeserializer(Edge.class, new GraphSONSerializersV2d0.EdgeJacksonDeserializer());
+ addDeserializer(Property.class, new GraphSONSerializersV2d0.PropertyJacksonDeserializer());
+ addDeserializer(Path.class, new GraphSONSerializersV2d0.PathJacksonDeserializer());
+ addDeserializer(VertexProperty.class, new GraphSONSerializersV2d0.VertexPropertyJacksonDeserializer());
+ addDeserializer(Metrics.class, new GraphSONSerializersV2d0.MetricsJacksonDeserializer());
+ addDeserializer(TraversalMetrics.class, new GraphSONSerializersV2d0.TraversalMetricsJacksonDeserializer());
+ addDeserializer(Tree.class, new GraphSONSerializersV2d0.TreeJacksonDeserializer());
+
+ // java.time
+ addDeserializer(Duration.class, new JavaTimeSerializersV2d0.DurationJacksonDeserializer());
+ addDeserializer(Instant.class, new JavaTimeSerializersV2d0.InstantJacksonDeserializer());
+ addDeserializer(LocalDate.class, new JavaTimeSerializersV2d0.LocalDateJacksonDeserializer());
+ addDeserializer(LocalDateTime.class, new JavaTimeSerializersV2d0.LocalDateTimeJacksonDeserializer());
+ addDeserializer(LocalTime.class, new JavaTimeSerializersV2d0.LocalTimeJacksonDeserializer());
+ addDeserializer(MonthDay.class, new JavaTimeSerializersV2d0.MonthDayJacksonDeserializer());
+ addDeserializer(OffsetDateTime.class, new JavaTimeSerializersV2d0.OffsetDateTimeJacksonDeserializer());
+ addDeserializer(OffsetTime.class, new JavaTimeSerializersV2d0.OffsetTimeJacksonDeserializer());
+ addDeserializer(Period.class, new JavaTimeSerializersV2d0.PeriodJacksonDeserializer());
+ addDeserializer(Year.class, new JavaTimeSerializersV2d0.YearJacksonDeserializer());
+ addDeserializer(YearMonth.class, new JavaTimeSerializersV2d0.YearMonthJacksonDeserializer());
+ addDeserializer(ZonedDateTime.class, new JavaTimeSerializersV2d0.ZonedDateTimeJacksonDeserializer());
+ addDeserializer(ZoneOffset.class, new JavaTimeSerializersV2d0.ZoneOffsetJacksonDeserializer());
++
++ // traversal
++ addDeserializer(Bytecode.class, new GraphSONTraversalSerializers.BytecodeJacksonDeserializer());
++ addDeserializer(Enum.class, new GraphSONTraversalSerializers.EnumJacksonDeserializer());
++ addDeserializer(P.class, new GraphSONTraversalSerializers.PJacksonDeserializer());
++ addDeserializer(Lambda.class, new GraphSONTraversalSerializers.LambdaJacksonDeserializer());
++ addDeserializer(Bytecode.Binding.class, new GraphSONTraversalSerializers.BindingJacksonDeserializer());
++ addDeserializer(Traverser.class, new GraphSONTraversalSerializers.TraverserJacksonDeserializer());
+ }
+
+ public static Builder build() {
+ return new Builder();
+ }
+
+ @Override
+ public Map<Class, String> getTypeDefinitions() {
+ return new LinkedHashMap<Class, String>(){{
+ // Those don't have deserializers because handled by Jackson,
+ // but we still want to rename them in GraphSON
+ put(ByteBuffer.class, "bytebuffer");
+ put(Short.class, "int16");
+ put(Integer.class, "int32");
+ put(Long.class, "int64");
+ put(Double.class, "double");
+ put(Float.class, "float");
+
+ // Time serializers/deserializers
+ put(Duration.class, "duration");
+ put(Instant.class, "instant");
+ put(LocalDate.class, "localdate");
+ put(LocalDateTime.class, "localdatetime");
+ put(LocalTime.class, "localtime");
+ put(MonthDay.class, "monthday");
+ put(OffsetDateTime.class, "offsetdatetime");
+ put(OffsetTime.class, "offsettime");
+ put(Period.class, "period");
+ put(Year.class, "year");
+ put(YearMonth.class, "yearmonth");
+ put(ZonedDateTime.class, "zoneddatetime");
+ put(ZoneOffset.class, "zoneoffset");
+
+ // Tinkerpop Graph objects
+ put(Vertex.class, "vertex");
+ put(Edge.class, "edge");
+ put(Property.class, "property");
+ put(Path.class, "path");
+ put(VertexProperty.class, "vertexproperty");
+ put(Metrics.class, "metrics");
+ put(TraversalMetrics.class, "traversalmetrics");
++ put(Traverser.class, "traverser");
+ put(Tree.class, "tree");
+ }};
+ }
+
+ @Override
+ public String getTypeNamespace() {
+ return GraphSONTokens.GREMLIN_TYPE_NAMESPACE;
+ }
+
+ static final class Builder implements GraphSONModuleBuilder {
+
+ private Builder() {}
+
+ @Override
+ public GraphSONModule create(final boolean normalize) {
+ return new GraphSONModuleV2d0(normalize);
+ }
+
+ }
+ }
+
+ /**
* Version 1.0 of GraphSON.
*/
static final class GraphSONModuleV1d0 extends GraphSONModule {
@@@ -84,82 -209,68 +249,94 @@@
protected GraphSONModuleV1d0(final boolean normalize) {
super("graphson-1.0");
// graph
- addSerializer(Edge.class, new GraphSONSerializers.EdgeJacksonSerializer(normalize));
- addSerializer(Vertex.class, new GraphSONSerializers.VertexJacksonSerializer(normalize));
- addSerializer(VertexProperty.class, new GraphSONSerializers.VertexPropertyJacksonSerializer(normalize));
- addSerializer(Property.class, new GraphSONSerializers.PropertyJacksonSerializer());
- addSerializer(TraversalMetrics.class, new GraphSONSerializers.TraversalMetricsJacksonSerializer());
- addSerializer(TraversalExplanation.class, new GraphSONSerializers.TraversalExplanationJacksonSerializer());
- addSerializer(Path.class, new GraphSONSerializers.PathJacksonSerializer());
- addSerializer(StarGraphGraphSONSerializer.DirectionalStarGraph.class, new StarGraphGraphSONSerializer(normalize));
- addSerializer(Tree.class, new GraphSONSerializers.TreeJacksonSerializer());
-
+ addSerializer(Edge.class, new GraphSONSerializersV1d0.EdgeJacksonSerializer(normalize));
+ addSerializer(Vertex.class, new GraphSONSerializersV1d0.VertexJacksonSerializer(normalize));
+ addSerializer(VertexProperty.class, new GraphSONSerializersV1d0.VertexPropertyJacksonSerializer(normalize));
+ addSerializer(Property.class, new GraphSONSerializersV1d0.PropertyJacksonSerializer());
+ addSerializer(TraversalMetrics.class, new GraphSONSerializersV1d0.TraversalMetricsJacksonSerializer());
+ addSerializer(TraversalExplanation.class, new GraphSONSerializersV1d0.TraversalExplanationJacksonSerializer());
+ addSerializer(Path.class, new GraphSONSerializersV1d0.PathJacksonSerializer());
+ addSerializer(DirectionalStarGraph.class, new StarGraphGraphSONSerializerV1d0(normalize));
+ addSerializer(Tree.class, new GraphSONSerializersV1d0.TreeJacksonSerializer());
+
// java.util
- addSerializer(Map.Entry.class, new JavaUtilSerializers.MapEntryJacksonSerializer());
+ addSerializer(Map.Entry.class, new JavaUtilSerializersV1d0.MapEntryJacksonSerializer());
// java.time
- addSerializer(Duration.class, new JavaTimeSerializers.DurationJacksonSerializer());
- addSerializer(Instant.class, new JavaTimeSerializers.InstantJacksonSerializer());
- addSerializer(LocalDate.class, new JavaTimeSerializers.LocalDateJacksonSerializer());
- addSerializer(LocalDateTime.class, new JavaTimeSerializers.LocalDateTimeJacksonSerializer());
- addSerializer(LocalTime.class, new JavaTimeSerializers.LocalTimeJacksonSerializer());
- addSerializer(MonthDay.class, new JavaTimeSerializers.MonthDayJacksonSerializer());
- addSerializer(OffsetDateTime.class, new JavaTimeSerializers.OffsetDateTimeJacksonSerializer());
- addSerializer(OffsetTime.class, new JavaTimeSerializers.OffsetTimeJacksonSerializer());
- addSerializer(Period.class, new JavaTimeSerializers.PeriodJacksonSerializer());
- addSerializer(Year.class, new JavaTimeSerializers.YearJacksonSerializer());
- addSerializer(YearMonth.class, new JavaTimeSerializers.YearMonthJacksonSerializer());
- addSerializer(ZonedDateTime.class, new JavaTimeSerializers.ZonedDateTimeJacksonSerializer());
- addSerializer(ZoneOffset.class, new JavaTimeSerializers.ZoneOffsetJacksonSerializer());
-
- addDeserializer(Duration.class, new JavaTimeSerializers.DurationJacksonDeserializer());
- addDeserializer(Instant.class, new JavaTimeSerializers.InstantJacksonDeserializer());
- addDeserializer(LocalDate.class, new JavaTimeSerializers.LocalDateJacksonDeserializer());
- addDeserializer(LocalDateTime.class, new JavaTimeSerializers.LocalDateTimeJacksonDeserializer());
- addDeserializer(LocalTime.class, new JavaTimeSerializers.LocalTimeJacksonDeserializer());
- addDeserializer(MonthDay.class, new JavaTimeSerializers.MonthDayJacksonDeserializer());
- addDeserializer(OffsetDateTime.class, new JavaTimeSerializers.OffsetDateTimeJacksonDeserializer());
- addDeserializer(OffsetTime.class, new JavaTimeSerializers.OffsetTimeJacksonDeserializer());
- addDeserializer(Period.class, new JavaTimeSerializers.PeriodJacksonDeserializer());
- addDeserializer(Year.class, new JavaTimeSerializers.YearJacksonDeserializer());
- addDeserializer(YearMonth.class, new JavaTimeSerializers.YearMonthJacksonDeserializer());
- addDeserializer(ZonedDateTime.class, new JavaTimeSerializers.ZonedDateTimeJacksonDeserializer());
- addDeserializer(ZoneOffset.class, new JavaTimeSerializers.ZoneOffsetJacksonDeserializer());
+ addSerializer(Duration.class, new JavaTimeSerializersV1d0.DurationJacksonSerializer());
+ addSerializer(Instant.class, new JavaTimeSerializersV1d0.InstantJacksonSerializer());
+ addSerializer(LocalDate.class, new JavaTimeSerializersV1d0.LocalDateJacksonSerializer());
+ addSerializer(LocalDateTime.class, new JavaTimeSerializersV1d0.LocalDateTimeJacksonSerializer());
+ addSerializer(LocalTime.class, new JavaTimeSerializersV1d0.LocalTimeJacksonSerializer());
+ addSerializer(MonthDay.class, new JavaTimeSerializersV1d0.MonthDayJacksonSerializer());
+ addSerializer(OffsetDateTime.class, new JavaTimeSerializersV1d0.OffsetDateTimeJacksonSerializer());
+ addSerializer(OffsetTime.class, new JavaTimeSerializersV1d0.OffsetTimeJacksonSerializer());
+ addSerializer(Period.class, new JavaTimeSerializersV1d0.PeriodJacksonSerializer());
+ addSerializer(Year.class, new JavaTimeSerializersV1d0.YearJacksonSerializer());
+ addSerializer(YearMonth.class, new JavaTimeSerializersV1d0.YearMonthJacksonSerializer());
+ addSerializer(ZonedDateTime.class, new JavaTimeSerializersV1d0.ZonedDateTimeJacksonSerializer());
+ addSerializer(ZoneOffset.class, new JavaTimeSerializersV1d0.ZoneOffsetJacksonSerializer());
+
+ addDeserializer(Duration.class, new JavaTimeSerializersV1d0.DurationJacksonDeserializer());
+ addDeserializer(Instant.class, new JavaTimeSerializersV1d0.InstantJacksonDeserializer());
+ addDeserializer(LocalDate.class, new JavaTimeSerializersV1d0.LocalDateJacksonDeserializer());
+ addDeserializer(LocalDateTime.class, new JavaTimeSerializersV1d0.LocalDateTimeJacksonDeserializer());
+ addDeserializer(LocalTime.class, new JavaTimeSerializersV1d0.LocalTimeJacksonDeserializer());
+ addDeserializer(MonthDay.class, new JavaTimeSerializersV1d0.MonthDayJacksonDeserializer());
+ addDeserializer(OffsetDateTime.class, new JavaTimeSerializersV1d0.OffsetDateTimeJacksonDeserializer());
+ addDeserializer(OffsetTime.class, new JavaTimeSerializersV1d0.OffsetTimeJacksonDeserializer());
+ addDeserializer(Period.class, new JavaTimeSerializersV1d0.PeriodJacksonDeserializer());
+ addDeserializer(Year.class, new JavaTimeSerializersV1d0.YearJacksonDeserializer());
+ addDeserializer(YearMonth.class, new JavaTimeSerializersV1d0.YearMonthJacksonDeserializer());
+ addDeserializer(ZonedDateTime.class, new JavaTimeSerializersV1d0.ZonedDateTimeJacksonDeserializer());
+ addDeserializer(ZoneOffset.class, new JavaTimeSerializersV1d0.ZoneOffsetJacksonDeserializer());
+
+ // traversal
+ // TODO: review (added for integration with new GraphSON model for GLV bytecode)
+ addSerializer(Traversal.class, new GraphSONTraversalSerializers.TraversalJacksonSerializer());
+ addSerializer(Bytecode.class, new GraphSONTraversalSerializers.BytecodeJacksonSerializer());
+ addSerializer(VertexProperty.Cardinality.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
+ addSerializer(Column.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
+ addSerializer(Direction.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
+ addSerializer(SackFunctions.Barrier.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
+ addSerializer(Operator.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
+ addSerializer(Order.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
+ addSerializer(Pop.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
+ addSerializer(Scope.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
+ addSerializer(T.class, new GraphSONTraversalSerializers.EnumJacksonSerializer());
+ addSerializer(P.class, new GraphSONTraversalSerializers.PJacksonSerializer());
+ addSerializer(Lambda.class, new GraphSONTraversalSerializers.LambdaJacksonSerializer());
+ addSerializer(Bytecode.Binding.class, new GraphSONTraversalSerializers.BindingJacksonSerializer());
+ addSerializer(Traverser.class, new GraphSONTraversalSerializers.TraverserSerializer());
+ // -- deserializers for traversal
+ addDeserializer(Bytecode.class, new GraphSONTraversalSerializers.BytecodeJacksonDeserializer());
+ addDeserializer(Enum.class, new GraphSONTraversalSerializers.EnumJacksonDeserializer());
+ addDeserializer(P.class, new GraphSONTraversalSerializers.PJacksonDeserializer());
+ addDeserializer(Lambda.class, new GraphSONTraversalSerializers.LambdaJacksonDeserializer());
+ addDeserializer(Bytecode.Binding.class, new GraphSONTraversalSerializers.BindingJacksonDeserializer());
+
}
public static Builder build() {
return new Builder();
}
+ @Override
+ public Map<Class, String> getTypeDefinitions() {
+ // null is fine and handled by the GraphSONMapper
+ return null;
+ }
+
+ @Override
+ public String getTypeNamespace() {
+ // null is fine and handled by the GraphSONMapper
+ return null;
+ }
+
static final class Builder implements GraphSONModuleBuilder {
- private Builder() {}
+ private Builder() {
+ }
@Override
public GraphSONModule create(final boolean normalize) {
http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/67b4d113/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV1d0.java
----------------------------------------------------------------------
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV1d0.java
index 0000000,2fc9e47..c5c2ded
mode 000000,100644..100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV1d0.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV1d0.java
@@@ -1,0 -1,465 +1,466 @@@
+ /*
+ * 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.structure.io.graphson;
+
+ import org.apache.tinkerpop.gremlin.process.traversal.Path;
+ import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+ import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
+ import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
+ import org.apache.tinkerpop.gremlin.process.traversal.util.Metrics;
+ import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation;
+ import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalMetrics;
+ import org.apache.tinkerpop.gremlin.structure.Edge;
+ import org.apache.tinkerpop.gremlin.structure.Element;
+ import org.apache.tinkerpop.gremlin.structure.Property;
+ import org.apache.tinkerpop.gremlin.structure.Vertex;
+ import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+ import org.apache.tinkerpop.gremlin.structure.util.Comparators;
+ import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedVertexProperty;
+ import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
+ import org.apache.tinkerpop.shaded.jackson.core.JsonGenerationException;
+ import org.apache.tinkerpop.shaded.jackson.core.JsonGenerator;
+ import org.apache.tinkerpop.shaded.jackson.core.JsonProcessingException;
+ import org.apache.tinkerpop.shaded.jackson.databind.SerializerProvider;
+ import org.apache.tinkerpop.shaded.jackson.databind.jsontype.TypeSerializer;
+ import org.apache.tinkerpop.shaded.jackson.databind.ser.std.StdKeySerializer;
+ import org.apache.tinkerpop.shaded.jackson.databind.ser.std.StdSerializer;
+ import org.javatuples.Pair;
+
+ import java.io.IOException;
+ import java.util.ArrayList;
+ import java.util.Comparator;
+ import java.util.HashMap;
+ import java.util.Iterator;
+ import java.util.List;
+ import java.util.Map;
+ import java.util.Set;
+ import java.util.concurrent.TimeUnit;
+
+ /**
+ * GraphSON serializers for graph-based objects such as vertices, edges, properties, and paths. These serializers
+ * present a generalized way to serialize the implementations of core interfaces.
+ *
+ * @author Stephen Mallette (http://stephen.genoprime.com)
+ */
+ final class GraphSONSerializersV1d0 {
+
+ private GraphSONSerializersV1d0() {}
+
+ final static class VertexPropertyJacksonSerializer extends StdSerializer<VertexProperty> {
+
+ private final boolean normalize;
+
+ public VertexPropertyJacksonSerializer(final boolean normalize) {
+ super(VertexProperty.class);
+ this.normalize = normalize;
+ }
+
+ @Override
+ public void serialize(final VertexProperty property, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ serializerVertexProperty(property, jsonGenerator, serializerProvider, null, normalize, true);
+ }
+
+ @Override
+ public void serializeWithType(final VertexProperty property, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
+ serializerVertexProperty(property, jsonGenerator, serializerProvider, typeSerializer, normalize, true);
+ }
+ }
+
+ final static class PropertyJacksonSerializer extends StdSerializer<Property> {
+
+ public PropertyJacksonSerializer() {
+ super(Property.class);
+ }
+
+ @Override
+ public void serialize(final Property property, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ ser(property, jsonGenerator, serializerProvider, null);
+ }
++
+ @Override
+ public void serializeWithType(final Property property, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
+ ser(property, jsonGenerator, serializerProvider, typeSerializer);
+ }
+
+ private static void ser(final Property property, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
+ jsonGenerator.writeStartObject();
+ if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
+ serializerProvider.defaultSerializeField(GraphSONTokens.KEY, property.key(), jsonGenerator);
+ serializerProvider.defaultSerializeField(GraphSONTokens.VALUE, property.value(), jsonGenerator);
+ jsonGenerator.writeEndObject();
+ }
+ }
+
+ final static class EdgeJacksonSerializer extends StdSerializer<Edge> {
+
+ private final boolean normalize;
+
+ public EdgeJacksonSerializer(final boolean normalize) {
+ super(Edge.class);
+ this.normalize = normalize;
+ }
+
+
+ @Override
+ public void serialize(final Edge edge, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ ser(edge, jsonGenerator, serializerProvider, null);
+ }
+ @Override
+ public void serializeWithType(final Edge edge, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
+ ser(edge, jsonGenerator, serializerProvider, typeSerializer);
+ }
+
+ private void ser(final Edge edge, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
+ jsonGenerator.writeStartObject();
+ if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
+ GraphSONUtil.writeWithType(GraphSONTokens.ID, edge.id(), jsonGenerator, serializerProvider, typeSerializer);
+
+ jsonGenerator.writeStringField(GraphSONTokens.LABEL, edge.label());
+ jsonGenerator.writeStringField(GraphSONTokens.TYPE, GraphSONTokens.EDGE);
+ jsonGenerator.writeStringField(GraphSONTokens.IN_LABEL, edge.inVertex().label());
+ jsonGenerator.writeStringField(GraphSONTokens.OUT_LABEL, edge.outVertex().label());
+ GraphSONUtil.writeWithType(GraphSONTokens.IN, edge.inVertex().id(), jsonGenerator, serializerProvider, typeSerializer);
+ GraphSONUtil.writeWithType(GraphSONTokens.OUT, edge.outVertex().id(), jsonGenerator, serializerProvider, typeSerializer);
+ writeProperties(edge, jsonGenerator, serializerProvider, typeSerializer);
+ jsonGenerator.writeEndObject();
+ }
+
+ private void writeProperties(final Edge edge, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider,
+ final TypeSerializer typeSerializer) throws IOException {
+ final Iterator<Property<Object>> elementProperties = normalize ?
+ IteratorUtils.list(edge.properties(), Comparators.PROPERTY_COMPARATOR).iterator() : edge.properties();
+ if (elementProperties.hasNext()) {
+ jsonGenerator.writeObjectFieldStart(GraphSONTokens.PROPERTIES);
+ if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
+ while (elementProperties.hasNext()) {
+ final Property<Object> elementProperty = elementProperties.next();
+ GraphSONUtil.writeWithType(elementProperty.key(), elementProperty.value(), jsonGenerator, serializerProvider, typeSerializer);
+ }
+ jsonGenerator.writeEndObject();
+ }
+ }
+
+ }
+
+ final static class VertexJacksonSerializer extends StdSerializer<Vertex> {
+
+ private final boolean normalize;
+
+ public VertexJacksonSerializer(final boolean normalize) {
+ super(Vertex.class);
+ this.normalize = normalize;
+ }
+
+ @Override
+ public void serialize(final Vertex vertex, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ ser(vertex, jsonGenerator, serializerProvider, null);
+ }
+
+ @Override
+ public void serializeWithType(final Vertex vertex, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
+ ser(vertex, jsonGenerator, serializerProvider, typeSerializer);
+
+ }
+
+ private void ser(final Vertex vertex, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer)
+ throws IOException {
+ jsonGenerator.writeStartObject();
+ if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
+ GraphSONUtil.writeWithType(GraphSONTokens.ID, vertex.id(), jsonGenerator, serializerProvider, typeSerializer);
+ jsonGenerator.writeStringField(GraphSONTokens.LABEL, vertex.label());
+ jsonGenerator.writeStringField(GraphSONTokens.TYPE, GraphSONTokens.VERTEX);
+ writeProperties(vertex, jsonGenerator, serializerProvider, typeSerializer);
+ jsonGenerator.writeEndObject();
+ }
+
+ private void writeProperties(final Vertex vertex, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
+ jsonGenerator.writeObjectFieldStart(GraphSONTokens.PROPERTIES);
+ if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
+
+ final List<String> keys = normalize ?
+ IteratorUtils.list(vertex.keys().iterator(), Comparator.naturalOrder()) : new ArrayList<>(vertex.keys());
+ for (String key : keys) {
+ final Iterator<VertexProperty<Object>> vertexProperties = normalize ?
+ IteratorUtils.list(vertex.properties(key), Comparators.PROPERTY_COMPARATOR).iterator() : vertex.properties(key);
+
+ if (vertexProperties.hasNext()) {
+ jsonGenerator.writeArrayFieldStart(key);
+ if (typeSerializer != null) {
+ jsonGenerator.writeString(ArrayList.class.getName());
+ jsonGenerator.writeStartArray();
+ }
+
+ while (vertexProperties.hasNext()) {
+ serializerVertexProperty(vertexProperties.next(), jsonGenerator, serializerProvider, typeSerializer, normalize, false);
+ }
+
+ jsonGenerator.writeEndArray();
+ if (typeSerializer != null) jsonGenerator.writeEndArray();
+ }
+ }
+
+ jsonGenerator.writeEndObject();
+ }
+
+ }
+
+ final static class PathJacksonSerializer extends StdSerializer<Path> {
+
+ public PathJacksonSerializer() {
+ super(Path.class);
+ }
+ @Override
+ public void serialize(final Path path, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException, JsonGenerationException {
+ ser(path, jsonGenerator, null);
+ }
+
+ @Override
+ public void serializeWithType(final Path path, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer)
+ throws IOException, JsonProcessingException {
+ ser(path, jsonGenerator, typeSerializer);
+ }
+ private static void ser(final Path path, final JsonGenerator jsonGenerator, final TypeSerializer typeSerializer)
+ throws IOException {
+ jsonGenerator.writeStartObject();
+ if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
+ jsonGenerator.writeObjectField(GraphSONTokens.LABELS, path.labels());
+ jsonGenerator.writeObjectField(GraphSONTokens.OBJECTS, path.objects());
+ jsonGenerator.writeEndObject();
+ }
+
+ }
+
+ final static class TreeJacksonSerializer extends StdSerializer<Tree> {
+
+ public TreeJacksonSerializer() {
+ super(Tree.class);
+ }
+
+ @Override
+ public void serialize(final Tree tree, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider) throws IOException, JsonGenerationException {
+ ser(tree, jsonGenerator, null);
+ }
+
+ @Override
+ public void serializeWithType(final Tree tree, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer)
+ throws IOException, JsonProcessingException {
+ ser(tree, jsonGenerator, typeSerializer);
+ }
+
+ private static void ser(final Tree tree, final JsonGenerator jsonGenerator, final TypeSerializer typeSerializer)
+ throws IOException {
+ jsonGenerator.writeStartObject();
+ if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
+
+ Set<Map.Entry<Element, Tree>> set = tree.entrySet();
+ for(Map.Entry<Element, Tree> entry : set)
+ {
+ jsonGenerator.writeObjectFieldStart(entry.getKey().id().toString());
+ if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
+ jsonGenerator.writeObjectField(GraphSONTokens.KEY, entry.getKey());
+ jsonGenerator.writeObjectField(GraphSONTokens.VALUE, entry.getValue());
+ jsonGenerator.writeEndObject();
+ }
+ jsonGenerator.writeEndObject();
+ }
+ }
+
+ /**
+ * Maps in the JVM can have {@link Object} as a key, but in JSON they must be a {@link String}.
+ */
+ final static class GraphSONKeySerializer extends StdKeySerializer {
+
+ @Override
+ public void serialize(final Object o, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider) throws IOException {
+ ser(o, jsonGenerator, serializerProvider);
+ }
+ @Override
+ public void serializeWithType(final Object o, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
+ ser(o, jsonGenerator, serializerProvider);
+ }
+
+ private void ser(final Object o, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider) throws IOException {
+ if (Element.class.isAssignableFrom(o.getClass()))
+ jsonGenerator.writeFieldName((((Element) o).id()).toString());
+ else
+ super.serialize(o, jsonGenerator, serializerProvider);
+ }
+ }
+
+ final static class TraversalExplanationJacksonSerializer extends StdSerializer<TraversalExplanation> {
+ public TraversalExplanationJacksonSerializer() {
+ super(TraversalExplanation.class);
+ }
+
+ @Override
+ public void serialize(final TraversalExplanation traversalExplanation, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider) throws IOException {
+ ser(traversalExplanation, jsonGenerator);
+ }
+
+ @Override
+ public void serializeWithType(final TraversalExplanation value, final JsonGenerator gen,
+ final SerializerProvider serializers, final TypeSerializer typeSer) throws IOException {
+ ser(value, gen);
+ }
+
+ public void ser(final TraversalExplanation te, final JsonGenerator jsonGenerator) throws IOException {
+ final Map<String, Object> m = new HashMap<>();
+ m.put(GraphSONTokens.ORIGINAL, getStepsAsList(te.getOriginalTraversal()));
+
+ final List<Pair<TraversalStrategy, Traversal.Admin<?,?>>> strategyTraversals = te.getStrategyTraversals();
+
+ final List<Map<String,Object>> intermediates = new ArrayList<>();
+ for (final Pair<TraversalStrategy, Traversal.Admin<?, ?>> pair : strategyTraversals) {
+ final Map<String,Object> intermediate = new HashMap<>();
+ intermediate.put(GraphSONTokens.STRATEGY, pair.getValue0().toString());
+ intermediate.put(GraphSONTokens.CATEGORY, pair.getValue0().getTraversalCategory().getSimpleName());
+ intermediate.put(GraphSONTokens.TRAVERSAL, getStepsAsList(pair.getValue1()));
+ intermediates.add(intermediate);
+ }
+ m.put(GraphSONTokens.INTERMEDIATE, intermediates);
+
+ if (strategyTraversals.isEmpty())
+ m.put(GraphSONTokens.FINAL, getStepsAsList(te.getOriginalTraversal()));
+ else
+ m.put(GraphSONTokens.FINAL, getStepsAsList(strategyTraversals.get(strategyTraversals.size() - 1).getValue1()));
+
+ jsonGenerator.writeObject(m);
+ }
+
+ private List<String> getStepsAsList(final Traversal.Admin<?,?> t) {
+ final List<String> steps = new ArrayList<>();
+ t.getSteps().iterator().forEachRemaining(s -> steps.add(s.toString()));
+ return steps;
+ }
+ }
+
+ final static class TraversalMetricsJacksonSerializer extends StdSerializer<TraversalMetrics> {
+ public TraversalMetricsJacksonSerializer() {
+ super(TraversalMetrics.class);
+ }
+
+ @Override
+ public void serialize(final TraversalMetrics property, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ serializeInternal(property, jsonGenerator);
+ }
+
+ @Override
+ public void serializeWithType(final TraversalMetrics property, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
+ serializeInternal(property, jsonGenerator);
+ }
+
+ private static void serializeInternal(final TraversalMetrics traversalMetrics, final JsonGenerator jsonGenerator) throws IOException {
+ // creation of the map enables all the fields to be properly written with their type if required
+ final Map<String, Object> m = new HashMap<>();
+ m.put(GraphSONTokens.DURATION, traversalMetrics.getDuration(TimeUnit.NANOSECONDS) / 1000000d);
+ final List<Map<String, Object>> metrics = new ArrayList<>();
+ traversalMetrics.getMetrics().forEach(it -> metrics.add(metricsToMap(it)));
+ m.put(GraphSONTokens.METRICS, metrics);
+
+ jsonGenerator.writeObject(m);
+ }
+
+ private static Map<String, Object> metricsToMap(final Metrics metrics) {
+ final Map<String, Object> m = new HashMap<>();
+ m.put(GraphSONTokens.ID, metrics.getId());
+ m.put(GraphSONTokens.NAME, metrics.getName());
+ m.put(GraphSONTokens.COUNTS, metrics.getCounts());
+ m.put(GraphSONTokens.DURATION, metrics.getDuration(TimeUnit.NANOSECONDS) / 1000000d);
+
+ if (!metrics.getAnnotations().isEmpty()) {
+ m.put(GraphSONTokens.ANNOTATIONS, metrics.getAnnotations());
+ }
+
+ if (!metrics.getNested().isEmpty()) {
+ final List<Map<String, Object>> nested = new ArrayList<>();
+ metrics.getNested().forEach(it -> nested.add(metricsToMap(it)));
+ m.put(GraphSONTokens.METRICS, nested);
+ }
+ return m;
+ }
+ }
+
+ private static void serializerVertexProperty(final VertexProperty property, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider,
+ final TypeSerializer typeSerializer, final boolean normalize,
+ final boolean includeLabel) throws IOException {
+ jsonGenerator.writeStartObject();
+ if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
+ GraphSONUtil.writeWithType(GraphSONTokens.ID, property.id(), jsonGenerator, serializerProvider, typeSerializer);
+ GraphSONUtil.writeWithType(GraphSONTokens.VALUE, property.value(), jsonGenerator, serializerProvider, typeSerializer);
+ if (includeLabel) jsonGenerator.writeStringField(GraphSONTokens.LABEL, property.label());
+ tryWriteMetaProperties(property, jsonGenerator, serializerProvider, typeSerializer, normalize);
+ jsonGenerator.writeEndObject();
+ }
+
+ private static void tryWriteMetaProperties(final VertexProperty property, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider,
+ final TypeSerializer typeSerializer, final boolean normalize) throws IOException {
+ // when "detached" you can't check features of the graph it detached from so it has to be
+ // treated differently from a regular VertexProperty implementation.
+ if (property instanceof DetachedVertexProperty) {
+ // only write meta properties key if they exist
+ if (property.properties().hasNext()) {
+ writeMetaProperties(property, jsonGenerator, serializerProvider, typeSerializer, normalize);
+ }
+ } else {
+ // still attached - so we can check the features to see if it's worth even trying to write the
+ // meta properties key
+ if (property.graph().features().vertex().supportsMetaProperties() && property.properties().hasNext()) {
+ writeMetaProperties(property, jsonGenerator, serializerProvider, typeSerializer, normalize);
+ }
+ }
+ }
+
+ private static void writeMetaProperties(final VertexProperty property, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider,
+ final TypeSerializer typeSerializer, final boolean normalize) throws IOException {
+ jsonGenerator.writeObjectFieldStart(GraphSONTokens.PROPERTIES);
+ if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
+ final Iterator<Property<Object>> metaProperties = normalize ?
+ IteratorUtils.list(( Iterator<Property<Object>>) property.properties(), Comparators.PROPERTY_COMPARATOR).iterator() : property.properties();
+ while (metaProperties.hasNext()) {
+ final Property<Object> metaProperty = metaProperties.next();
+ GraphSONUtil.writeWithType(metaProperty.key(), metaProperty.value(), jsonGenerator, serializerProvider, typeSerializer);
+ }
+ jsonGenerator.writeEndObject();
+ }
+
+ }
http://git-wip-us.apache.org/repos/asf/tinkerpop/blob/67b4d113/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONTraversalSerializers.java
----------------------------------------------------------------------
diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONTraversalSerializers.java
index 6fa8ef6,0000000..ea47d54
mode 100644,000000..100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONTraversalSerializers.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONTraversalSerializers.java
@@@ -1,409 -1,0 +1,424 @@@
+/*
+ * 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.structure.io.graphson;
+
++import org.apache.tinkerpop.gremlin.process.remote.traversal.DefaultRemoteTraverser;
+import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
+import org.apache.tinkerpop.gremlin.process.traversal.Operator;
+import org.apache.tinkerpop.gremlin.process.traversal.Order;
+import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Pop;
+import org.apache.tinkerpop.gremlin.process.traversal.SackFunctions;
+import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
++import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
+import org.apache.tinkerpop.gremlin.process.traversal.util.AndP;
+import org.apache.tinkerpop.gremlin.process.traversal.util.ConnectiveP;
+import org.apache.tinkerpop.gremlin.process.traversal.util.OrP;
+import org.apache.tinkerpop.gremlin.structure.Column;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+import org.apache.tinkerpop.gremlin.util.function.Lambda;
+import org.apache.tinkerpop.shaded.jackson.core.JsonGenerator;
+import org.apache.tinkerpop.shaded.jackson.core.JsonParser;
+import org.apache.tinkerpop.shaded.jackson.core.JsonProcessingException;
+import org.apache.tinkerpop.shaded.jackson.core.ObjectCodec;
+import org.apache.tinkerpop.shaded.jackson.databind.DeserializationContext;
+import org.apache.tinkerpop.shaded.jackson.databind.JsonNode;
+import org.apache.tinkerpop.shaded.jackson.databind.SerializerProvider;
+import org.apache.tinkerpop.shaded.jackson.databind.deser.std.StdDeserializer;
+import org.apache.tinkerpop.shaded.jackson.databind.jsontype.TypeSerializer;
+import org.apache.tinkerpop.shaded.jackson.databind.node.JsonNodeType;
+import org.apache.tinkerpop.shaded.jackson.databind.ser.std.StdSerializer;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
++import java.util.Map;
+
+/**
+ * @author Marko A. Rodriguez (http://markorodriguez.com)
+ */
+public final class GraphSONTraversalSerializers {
+
+ private GraphSONTraversalSerializers() {
+ }
+
+ /////////////////
+ // SERIALIZERS //
+ ////////////////
+
+ final static class TraversalJacksonSerializer extends StdSerializer<Traversal> {
+
+ public TraversalJacksonSerializer() {
+ super(Traversal.class);
+ }
+
+ @Override
+ public void serialize(final Traversal traversal, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ jsonGenerator.writeObject(traversal.asAdmin().getBytecode());
+ }
+
+ }
+
+ final static class BytecodeJacksonSerializer extends StdSerializer<Bytecode> {
+
+ public BytecodeJacksonSerializer() {
+ super(Bytecode.class);
+ }
+
+ @Override
+ public void serialize(final Bytecode bytecode, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ jsonGenerator.writeStartObject();
+ jsonGenerator.writeStringField("@type", "Bytecode");
+ if (bytecode.getSourceInstructions().iterator().hasNext()) {
+ jsonGenerator.writeArrayFieldStart("source");
+ for (final Bytecode.Instruction instruction : bytecode.getSourceInstructions()) {
+ jsonGenerator.writeStartArray();
+ jsonGenerator.writeString(instruction.getOperator());
+ for (final Object argument : instruction.getArguments()) {
+ jsonGenerator.writeObject(argument);
+ }
+ jsonGenerator.writeEndArray();
+ }
+ jsonGenerator.writeEndArray();
+ }
+ if (bytecode.getStepInstructions().iterator().hasNext()) {
+ jsonGenerator.writeArrayFieldStart("step");
+ for (final Bytecode.Instruction instruction : bytecode.getStepInstructions()) {
+ jsonGenerator.writeStartArray();
+ jsonGenerator.writeString(instruction.getOperator());
+ for (final Object argument : instruction.getArguments()) {
+ jsonGenerator.writeObject(argument);
+ }
+ jsonGenerator.writeEndArray();
+ }
+ jsonGenerator.writeEndArray();
+ }
+
+ jsonGenerator.writeEndObject();
+ }
+ }
+
+ final static class EnumJacksonSerializer extends StdSerializer<Enum> {
+
+ public EnumJacksonSerializer() {
+ super(Enum.class);
+ }
+
+ @Override
+ public void serialize(final Enum enumInstance, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ jsonGenerator.writeStartObject();
+ jsonGenerator.writeObjectField("@type", enumInstance.getDeclaringClass().getSimpleName());
+ jsonGenerator.writeObjectField("value", enumInstance.name());
+ jsonGenerator.writeEndObject();
+ }
+
+ }
+
+ final static class PJacksonSerializer extends StdSerializer<P> {
+
+ public PJacksonSerializer() {
+ super(P.class);
+ }
+
+ @Override
+ public void serialize(final P p, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ jsonGenerator.writeStartObject();
+ jsonGenerator.writeStringField("@type", "P");
+ jsonGenerator.writeStringField("predicate", p instanceof ConnectiveP ? p instanceof AndP ? "and" : "or" : p.getBiPredicate().toString());
+ jsonGenerator.writeObjectField("value", p instanceof ConnectiveP ? ((ConnectiveP) p).getPredicates() : p.getValue());
+ jsonGenerator.writeEndObject();
+ }
+
+ }
+
+ final static class LambdaJacksonSerializer extends StdSerializer<Lambda> {
+
+ public LambdaJacksonSerializer() {
+ super(Lambda.class);
+ }
+
+ @Override
+ public void serialize(final Lambda lambda, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ jsonGenerator.writeStartObject();
+ jsonGenerator.writeStringField("@type", "Lambda");
+ jsonGenerator.writeStringField("value", lambda.getLambdaScript());
+ jsonGenerator.writeStringField("language", lambda.getLambdaLanguage());
+ jsonGenerator.writeNumberField("arguments", lambda.getLambdaArguments());
+ jsonGenerator.writeEndObject();
+ }
+
+ }
+
+ final static class BindingJacksonSerializer extends StdSerializer<Bytecode.Binding> {
+
+ public BindingJacksonSerializer() {
+ super(Bytecode.Binding.class);
+ }
+
+ @Override
+ public void serialize(final Bytecode.Binding binding, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ jsonGenerator.writeStartObject();
+ jsonGenerator.writeStringField("@type", "Binding");
+ jsonGenerator.writeStringField("variable", binding.variable());
+ jsonGenerator.writeObjectField("value", binding.value());
+ jsonGenerator.writeEndObject();
+ }
+
+ }
+
+ final static class TraverserSerializer extends StdSerializer<Traverser> {
+
+ public TraverserSerializer() {
+ super(Traverser.class);
+ }
+
+ @Override
+ public void serialize(final Traverser traverserInstance, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
- ser(traverserInstance, jsonGenerator, serializerProvider, null);
++ ser(traverserInstance, jsonGenerator);
+ }
+
+ @Override
- public void serializeWithType(final Traverser traverserInstance, final JsonGenerator jsonGenerator,
++ public void serializeWithType(final Traverser traverser, final JsonGenerator jsonGenerator,
+ final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
- ser(traverserInstance, jsonGenerator, serializerProvider, typeSerializer);
++ ser(traverser, jsonGenerator);
+ }
+
- private static void ser(final Traverser traverserInstance, final JsonGenerator jsonGenerator,
- final SerializerProvider serializerProvider, final TypeSerializer typeSerializer) throws IOException {
++ private void ser(final Traverser traverserInstance, final JsonGenerator jsonGenerator) throws IOException {
+ jsonGenerator.writeStartObject();
- if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, Traverser.class.getName());
++ jsonGenerator.writeStringField("@type", "Traverser");
+ jsonGenerator.writeObjectField("bulk", traverserInstance.bulk());
+ jsonGenerator.writeObjectField("value", traverserInstance.get());
+ jsonGenerator.writeEndObject();
+ }
+ }
+
+ ///////////////////
+ // DESERIALIZERS //
+ //////////////////
+
+ final static class BytecodeJacksonDeserializer extends StdDeserializer<Bytecode> {
+
+ public BytecodeJacksonDeserializer() {
+ super(Bytecode.class);
+ }
+
+ private static void processInstruction(final JsonNode instruction, final ObjectCodec oc, final Bytecode bytecode, final boolean source) throws IOException {
+ final String operator = instruction.get(0).textValue();
+ final List<Object> arguments = new ArrayList<>();
+ for (int j = 1; j < instruction.size(); j++) {
+ final JsonNode argument = instruction.get(j);
+ if (argument.getNodeType().equals(JsonNodeType.OBJECT)) {
+ if (argument.has("@type")) {
+ final String type = argument.get("@type").textValue();
+ if (type.equals("Bytecode"))
+ arguments.add(oc.readValue(argument.traverse(oc), Bytecode.class));
+ else if (type.equals("Binding"))
+ arguments.add(oc.readValue(argument.traverse(oc), Bytecode.Binding.class));
+ else if (type.equals("P"))
+ arguments.add(oc.readValue(argument.traverse(oc), P.class));
+ else if (type.equals("Lambda"))
+ arguments.add(oc.readValue(argument.traverse(oc), Lambda.class));
+ else
+ arguments.add(oc.readValue(argument.traverse(oc), Enum.class));
+ } else {
+ arguments.add(oc.readValue(argument.traverse(oc), Object.class)); // TODO: vertices/edges/etc. don't get processed correctly
+ }
+ } else if (argument.getNodeType().equals(JsonNodeType.NUMBER)) {
+ arguments.add(argument.asInt()); // TODO
+ } else if (argument.getNodeType().equals(JsonNodeType.STRING)) {
+ arguments.add(argument.textValue());
+ } else if (argument.getNodeType().equals(JsonNodeType.BOOLEAN)) {
+ arguments.add(argument.booleanValue());
+ } else if (argument.getNodeType().equals(JsonNodeType.ARRAY)) {
+ final List<Object> list = new ArrayList<>();
+ for (int k = 0; k < argument.size(); k++) {
+ list.add(oc.readValue(argument.get(k).traverse(oc), Object.class));
+ //list.add(argument.get(k).textValue());
+ }
+ arguments.add(list);
+ } else {
+ throw new IOException("Unknown argument: " + argument);
+ }
+ }
+ if (source)
+ bytecode.addSource(operator, arguments.toArray());
+ else
+ bytecode.addStep(operator, arguments.toArray());
+ }
+
+ @Override
+ public Bytecode deserialize(final JsonParser jsonParser, final DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
+ final Bytecode bytecode = new Bytecode();
+ final ObjectCodec oc = jsonParser.getCodec();
+ final JsonNode node = oc.readTree(jsonParser);
+ assert node.get("@type").textValue().equals("Bytecode");
+ if (node.has("source")) {
+ final JsonNode source = node.get("source");
+ for (int i = 0; i < source.size(); i++) {
+ processInstruction(source.get(i), oc, bytecode, true);
+ }
+ }
+ if (node.has("step")) {
+ final JsonNode step = node.get("step");
+ for (int i = 0; i < step.size(); i++) {
+ processInstruction(step.get(i), oc, bytecode, false);
+
+ }
+ }
+ return bytecode;
+ }
+ }
+
+ final static class EnumJacksonDeserializer extends StdDeserializer<Enum> {
+
+ public EnumJacksonDeserializer() {
+ super(Enum.class);
+ }
+
+ @Override
+ public Enum deserialize(final JsonParser jsonParser, final DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
+
+ final ObjectCodec oc = jsonParser.getCodec();
+ final JsonNode node = oc.readTree(jsonParser);
+ final String type = node.get("@type").textValue();
+ if (type.equals("Cardinality"))
+ return VertexProperty.Cardinality.valueOf(node.get("value").textValue());
+ else if (type.equals("Column"))
+ return Column.valueOf(node.get("value").textValue());
+ else if (type.equals("Direction"))
+ return Direction.valueOf(node.get("value").textValue());
+ else if (type.equals("Barrier"))
+ return SackFunctions.Barrier.valueOf(node.get("value").textValue());
+ else if (type.equals("Operator"))
+ return Operator.valueOf(node.get("value").textValue());
+ else if (type.equals("Order"))
+ return Order.valueOf(node.get("value").textValue());
+ else if (type.equals("Pop"))
+ return Pop.valueOf(node.get("value").textValue());
+ else if (type.equals("Scope"))
+ return Scope.valueOf(node.get("value").textValue());
+ else if (type.equals("T"))
+ return T.valueOf(node.get("value").textValue());
+ else
+ throw new IOException("Unknown enum type: " + type);
+
+ }
+ }
+
+ final static class PJacksonDeserializer extends StdDeserializer<P> {
+
+ public PJacksonDeserializer() {
+ super(P.class);
+ }
+
+ @Override
+ public P deserialize(final JsonParser jsonParser, final DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
+
+ final ObjectCodec oc = jsonParser.getCodec();
+ final JsonNode node = oc.readTree(jsonParser);
+ assert node.get("@type").textValue().equals("P");
+ final JsonNode predicate = node.get("predicate");
+ if (predicate.textValue().equals("and") || predicate.textValue().equals("or")) {
+ final List<P<?>> arguments = new ArrayList<>();
+ for (int i = 0; i < node.get("value").size(); i++) {
+ arguments.add(oc.readValue(node.get("value").get(i).traverse(oc), P.class));
+ }
+ return predicate.textValue().equals("and") ? new AndP(arguments) : new OrP(arguments);
+ } else {
+ try {
+ final Object argument = oc.readValue(node.get("value").traverse(oc), Object.class);
+ return (P) P.class.getMethod(predicate.textValue(), argument instanceof Collection ? Collection.class : Object.class).invoke(null, argument); // TODO: number stuff, eh?
+ } catch (final Exception e) {
+ throw new IOException(e.getMessage(), e);
+ }
+ }
+ }
+ }
+
+ final static class LambdaJacksonDeserializer extends StdDeserializer<Lambda> {
+
+ public LambdaJacksonDeserializer() {
+ super(Lambda.class);
+ }
+
+ @Override
+ public Lambda deserialize(final JsonParser jsonParser, final DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
+
+ final ObjectCodec oc = jsonParser.getCodec();
+ final JsonNode node = oc.readTree(jsonParser);
+ assert node.get("@type").textValue().equals("Lambda");
+ final String lambdaScript = node.get("value").textValue();
+ final String lambdaLanguage = node.get("language").textValue();
+ final int lambdaArguments = node.get("arguments").intValue();
+ if (-1 == lambdaArguments || lambdaArguments > 2)
+ return new Lambda.UnknownArgLambda(lambdaScript, lambdaLanguage, lambdaArguments);
+ else if (0 == lambdaArguments)
+ return new Lambda.ZeroArgLambda<>(lambdaScript, lambdaLanguage);
+ else if (1 == lambdaArguments)
+ return new Lambda.OneArgLambda<>(lambdaScript, lambdaLanguage);
+ else
+ return new Lambda.TwoArgLambda<>(lambdaScript, lambdaLanguage);
+ }
+ }
+
+ final static class BindingJacksonDeserializer extends StdDeserializer<Bytecode.Binding> {
+
+ public BindingJacksonDeserializer() {
+ super(Bytecode.Binding.class);
+ }
+
+ @Override
+ public Bytecode.Binding deserialize(final JsonParser jsonParser, final DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
+ final ObjectCodec oc = jsonParser.getCodec();
+ final JsonNode node = oc.readTree(jsonParser);
+ assert node.get("@type").textValue().equals("Binding");
+ final String variable = node.get("variable").textValue();
+ final Object value = oc.readValue(node.get("value").traverse(oc), Object.class);
+ return new Bytecode.Binding<>(variable, value);
+ }
+ }
+
++ static class TraverserJacksonDeserializer extends StdDeserializer<Traverser> {
+
++ public TraverserJacksonDeserializer() {
++ super(Traverser.class);
++ }
++
++ @Override
++ public Traverser deserialize(final JsonParser jsonParser, final DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
++ jsonParser.nextToken();
++ // This will automatically parse all typed stuff.
++ final Map<String, Object> mapData = deserializationContext.readValue(jsonParser, Map.class);
++ return new DefaultRemoteTraverser<>(mapData.get("value"), (Long) mapData.get("bulk"));
++ }
++ }
+}