protected GraphSONModuleV3()

in gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java [355:484]
108 lines of code
3 McCabe index (conditional complexity)

        protected GraphSONModuleV3(final boolean normalize, final TypeInfo typeInfo) {
            super("graphson-3.0");

            /////////////////////// SERIALIZERS ////////////////////////////

            // graph
            addSerializer(Edge.class, new GraphSONSerializersV3.EdgeJacksonSerializer(normalize, typeInfo));
            addSerializer(Vertex.class, new GraphSONSerializersV3.VertexJacksonSerializer(normalize, typeInfo));
            addSerializer(VertexProperty.class, new GraphSONSerializersV3.VertexPropertyJacksonSerializer(normalize, true));
            addSerializer(Property.class, new GraphSONSerializersV3.PropertyJacksonSerializer());
            addSerializer(Metrics.class, new GraphSONSerializersV3.MetricsJacksonSerializer());
            addSerializer(TraversalMetrics.class, new GraphSONSerializersV3.TraversalMetricsJacksonSerializer());
            addSerializer(TraversalExplanation.class, new GraphSONSerializersV3.TraversalExplanationJacksonSerializer());
            addSerializer(Path.class, new GraphSONSerializersV3.PathJacksonSerializer());
            addSerializer(DirectionalStarGraph.class, new StarGraphGraphSONSerializerV3(normalize));
            addSerializer(Tree.class, new GraphSONSerializersV3.TreeJacksonSerializer());

            // java.util - use the standard jackson serializers for collections when types aren't embedded
            if (typeInfo != TypeInfo.NO_TYPES) {
                addSerializer(Map.Entry.class, new JavaUtilSerializersV3.MapEntryJacksonSerializer());
                addSerializer(Map.class, new JavaUtilSerializersV3.MapJacksonSerializer());
                addSerializer(List.class, new JavaUtilSerializersV3.ListJacksonSerializer());
                addSerializer(Set.class, new JavaUtilSerializersV3.SetJacksonSerializer());
            }

            // need to explicitly add serializers for these types because Jackson doesn't do it at all.
            addSerializer(Integer.class, new GraphSONSerializersV3.IntegerGraphSONSerializer());
            addSerializer(Double.class, new GraphSONSerializersV3.DoubleGraphSONSerializer());

            // traversal
            addSerializer(BulkSet.class, new TraversalSerializersV3.BulkSetJacksonSerializer());
            addSerializer(Traversal.class, new TraversalSerializersV3.TraversalJacksonSerializer());
            Stream.of(VertexProperty.Cardinality.class,
                    Column.class,
                    Direction.class,
                    DT.class,
                    Merge.class,
                    Operator.class,
                    Order.class,
                    Pop.class,
                    SackFunctions.Barrier.class,
                    Scope.class,
                    Pick.class,
                    T.class).forEach(e -> addSerializer(e, new TraversalSerializersV3.EnumJacksonSerializer()));
            addSerializer(P.class, new TraversalSerializersV3.PJacksonSerializer());
            addSerializer(Lambda.class, new TraversalSerializersV3.LambdaJacksonSerializer());
            addSerializer(Traverser.class, new TraversalSerializersV3.TraverserJacksonSerializer());
            addSerializer(TraversalStrategy.class, new TraversalSerializersV3.TraversalStrategyJacksonSerializer());

            /////////////////////// DESERIALIZERS ////////////////////////////

            // Tinkerpop Graph
            addDeserializer(Vertex.class, new GraphSONSerializersV3.VertexJacksonDeserializer());
            addDeserializer(Edge.class, new GraphSONSerializersV3.EdgeJacksonDeserializer());
            addDeserializer(Property.class, new GraphSONSerializersV3.PropertyJacksonDeserializer());
            addDeserializer(Path.class, new GraphSONSerializersV3.PathJacksonDeserializer());
            addDeserializer(TraversalExplanation.class, new GraphSONSerializersV3.TraversalExplanationJacksonDeserializer());
            addDeserializer(VertexProperty.class, new GraphSONSerializersV3.VertexPropertyJacksonDeserializer());
            addDeserializer(Metrics.class, new GraphSONSerializersV3.MetricsJacksonDeserializer());
            addDeserializer(TraversalMetrics.class, new GraphSONSerializersV3.TraversalMetricsJacksonDeserializer());
            addDeserializer(Tree.class, new GraphSONSerializersV3.TreeJacksonDeserializer());
            addDeserializer(TraversalStrategyProxy.class, new TraversalSerializersV3.TraversalStrategyProxyJacksonDeserializer<>());

            // java.util - use the standard jackson serializers for collections when types aren't embedded
            if (typeInfo != TypeInfo.NO_TYPES) {
                addDeserializer(Map.class, new JavaUtilSerializersV3.MapJacksonDeserializer());
                addDeserializer(List.class, new JavaUtilSerializersV3.ListJacksonDeserializer());
                addDeserializer(Set.class, new JavaUtilSerializersV3.SetJacksonDeserializer());
            }

            // numbers
            addDeserializer(Integer.class, new GraphSONSerializersV3.IntegerJackonsDeserializer());
            addDeserializer(Double.class, new GraphSONSerializersV3.DoubleJacksonDeserializer());

            // traversal
            addDeserializer(BulkSet.class, new TraversalSerializersV3.BulkSetJacksonDeserializer());
            Stream.of(VertexProperty.Cardinality.values(),
                    Column.values(),
                    Direction.values(),
                    DT.values(),
                    Merge.values(),
                    Operator.values(),
                    Order.values(),
                    Pop.values(),
                    SackFunctions.Barrier.values(),
                    Scope.values(),
                    Pick.values(),
                    T.values()).flatMap(Stream::of).forEach(e -> addDeserializer(e.getClass(), new TraversalSerializersV3.EnumJacksonDeserializer(e.getDeclaringClass())));
            addDeserializer(P.class, new TraversalSerializersV3.PJacksonDeserializer());
            addDeserializer(TextP.class, new TraversalSerializersV3.TextPJacksonDeserializer());
            addDeserializer(Lambda.class, new TraversalSerializersV3.LambdaJacksonDeserializer());
            addDeserializer(Traverser.class, new TraversalSerializersV3.TraverserJacksonDeserializer());
            Arrays.asList(
                    ConnectiveStrategy.class,
                    ElementIdStrategy.class,
                    EventStrategy.class,
                    HaltedTraverserStrategy.class,
                    PartitionStrategy.class,
                    SubgraphStrategy.class,
                    SeedStrategy.class,
                    LazyBarrierStrategy.class,
                    MatchAlgorithmStrategy.class,
                    AdjacentToIncidentStrategy.class,
                    ByModulatorOptimizationStrategy.class,
                    ProductiveByStrategy.class,
                    CountStrategy.class,
                    FilterRankingStrategy.class,
                    IdentityRemovalStrategy.class,
                    IncidentToAdjacentStrategy.class,
                    InlineFilterStrategy.class,
                    MatchPredicateStrategy.class,
                    OrderLimitStrategy.class,
                    OptionsStrategy.class,
                    PathProcessorStrategy.class,
                    PathRetractionStrategy.class,
                    RepeatUnrollStrategy.class,
                    ComputerVerificationStrategy.class,
                    LambdaRestrictionStrategy.class,
                    ReadOnlyStrategy.class,
                    StandardVerificationStrategy.class,
                    EarlyLimitStrategy.class,
                    EdgeLabelVerificationStrategy.class,
                    ReservedKeysVerificationStrategy.class,
                    //
                    GraphFilterStrategy.class,
                    VertexProgramStrategy.class
            ).forEach(strategy -> addDeserializer(strategy, new TraversalSerializersV3.TraversalStrategyProxyJacksonDeserializer(strategy)));

            GraphSONModule.tryLoadSparqlStrategy().ifPresent(s -> addDeserializer(s, new TraversalSerializersV3.TraversalStrategyProxyJacksonDeserializer(s)));
        }