JOHNZON-421 Defer start of object/array

This is necessary as we don't know what Serializers/Adapters/Converters actually do write.
If we start an object with { and the JsonbSerializer just writes a string value (json primitive)
then we will blow up. Deferring the start fixes this issue.

Author: struberg

johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JohnzonBuilder.java

@@ -321,9 +321,9 @@ public byte[] fromString(final String text) {
                     throw new IllegalArgumentException("We only support serializer on Class for now");
                 }
                 builder.addObjectConverter(
-                    Class.class.cast(args[0]), (ObjectConverter.Writer) (instance, jsonbGenerator) ->
+                    Class.class.cast(args[0]), (ObjectConverter.Writer) (instance, jsonbGenerator, generator) ->
                         s.serialize(
-                                instance, jsonbGenerator.getJsonGenerator(),
+                                instance, generator,
                                 new JohnzonSerializationContext(jsonbGenerator)));
             });
         });

johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JsonbAccessMode.java

@@ -337,7 +337,7 @@ private Object mapItem(final JsonValue jsonValue, final Type targetType,
                                 }
 
                                 @Override
-                                public void writeJson(final Object instance, final MappingGenerator jsonbGenerator) {
+                                public void writeJson(final Object instance, final MappingGenerator jsonbGenerator, JsonGenerator generator) {
                                     // no-op, it's for factories only
                                 }
                             };
@@ -1183,8 +1183,7 @@ private class WriterConverters {
                 final JsonbSerializer jsonbSerializer = instance.getValue();
                 writer = new ObjectConverter.Writer() {
                     @Override
-                    public void writeJson(final Object instance, final MappingGenerator jsonbGenerator) {
-                        final JsonGenerator generator = jsonbGenerator.getJsonGenerator();
+                    public void writeJson(final Object instance, final MappingGenerator jsonbGenerator, JsonGenerator generator) {
                         jsonbSerializer.serialize(instance, generator, new JohnzonSerializationContext(jsonbGenerator));
                     }
 

johnzon-jsonb/src/test/java/org/apache/johnzon/jsonb/JohnzonConverterInJsonbTest.java

@@ -27,6 +27,7 @@
 import jakarta.json.JsonValue;
 import jakarta.json.bind.Jsonb;
 import jakarta.json.bind.spi.JsonbProvider;
+import jakarta.json.stream.JsonGenerator;
 
 import org.apache.johnzon.mapper.Converter;
 import org.apache.johnzon.mapper.JohnzonConverter;
@@ -88,8 +89,8 @@ public static class TestDTOConverter implements ObjectConverter.Codec<TestDTO> {
         private static final String TIMESTAMP_JSON_KEY = "timestamp";
 
         @Override
-        public void writeJson(TestDTO instance, MappingGenerator jsonbGenerator) {
-            jsonbGenerator.getJsonGenerator().write(TIMESTAMP_JSON_KEY, instance.instant.atZone(ZoneId.of("UTC")).toString());
+        public void writeJson(TestDTO instance, MappingGenerator jsonbGenerator, JsonGenerator generator) {
+            generator.write(TIMESTAMP_JSON_KEY, instance.instant.atZone(ZoneId.of("UTC")).toString());
         }
 
         @Override

johnzon-jsonb/src/test/java/org/apache/johnzon/jsonb/SerializerTest.java

@@ -69,7 +69,7 @@ public void passthroughSerializer() {
         nameHolder.name.detailName = new DetailName();
         nameHolder.name.detailName.name = "Another Test String";
         assertEquals(
-                "{\"detailName\":{\"name\":\"Another Test String\",\"detail\":true},\"name\":{\"name\":\"Test String\"}}",
+                "{\"name\":{\"detailName\":{\"name\":\"Another Test String\",\"detail\":true},\"name\":\"Test String\"}}",
                 jsonb.toJson(nameHolder));
 
     }

johnzon-jsonb/src/test/java/org/apache/johnzon/jsonb/SerializersRoundTripTest.java

@@ -564,7 +564,8 @@ public void roundTrip() throws Exception {
         original.color = Color.GREEN;*/
 
         try (final Jsonb jsonb = JsonbBuilder.create()) {
-            final Wrapper deserialized = jsonb.fromJson(jsonb.toJson(original), Wrapper.class);
+            final String json = jsonb.toJson(original);
+            final Wrapper deserialized = jsonb.fromJson(json, Wrapper.class);
             assertEquals(original, deserialized);
         }
     }

johnzon-jsonb/src/test/java/org/apache/johnzon/jsonb/serializer/SerialiseAsPrimitiveAnnotatedAtClassTest.java

@@ -0,0 +1,129 @@
+/*
+ * 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.johnzon.jsonb.serializer;
+
+import java.lang.reflect.Type;
+
+import org.junit.Test;
+
+import jakarta.json.bind.Jsonb;
+import jakarta.json.bind.JsonbBuilder;
+import jakarta.json.bind.annotation.JsonbTypeDeserializer;
+import jakarta.json.bind.annotation.JsonbTypeSerializer;
+import jakarta.json.bind.serializer.DeserializationContext;
+import jakarta.json.bind.serializer.JsonbDeserializer;
+import jakarta.json.bind.serializer.JsonbSerializer;
+import jakarta.json.bind.serializer.SerializationContext;
+import jakarta.json.stream.JsonGenerator;
+import jakarta.json.stream.JsonParser;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * This test checks a JsonbSerialize/JsonbDeserialize roundtrip when using a primitive as placeholder
+ */
+public class SerialiseAsPrimitiveAnnotatedAtClassTest {
+
+
+    @JsonbTypeSerializer(ConstantJsonbSerialiser.class)
+    @JsonbTypeDeserializer(ConstantJsonbDeserializer.class)
+    public static class TestConstant {
+        public final static TestConstant VAL_1 = new TestConstant("A");
+        public final static TestConstant VAL_2 = new TestConstant("B");
+        public final static TestConstant VAL_3 = new TestConstant("C");
+
+        private final String code;
+
+        public TestConstant(String code) {
+            this.code = code;
+        }
+
+        public String getCode() {
+            return code;
+        }
+
+        public static TestConstant getByCode(String code) {
+            switch (code) {
+                case "A": return VAL_1;
+                case "B": return VAL_2;
+                case "C": return VAL_3;
+                default: return null;
+            }
+        }
+    }
+    
+    public static class ConstantUsage {
+        private int i;
+
+        private TestConstant testConstant;
+
+        public int getI() {
+            return i;
+        }
+
+        public void setI(int i) {
+            this.i = i;
+        }
+
+        public TestConstant getTestConstant() {
+            return testConstant;
+        }
+
+        public void setTestConstant(TestConstant testEnum) {
+            this.testConstant = testEnum;
+        }
+    }
+
+    public static class ConstantJsonbSerialiser implements JsonbSerializer<TestConstant> {
+        @Override
+        public void serialize(TestConstant val, JsonGenerator generator, SerializationContext ctx) {
+            if (val == null) {
+                ctx.serialize(null, generator);
+            } else {
+                ctx.serialize(val.getCode(), generator);
+            }
+        }
+    }
+
+    public static class ConstantJsonbDeserializer implements JsonbDeserializer<TestConstant> {
+
+    @Override
+    public TestConstant deserialize(JsonParser parser, DeserializationContext ctx, Type rtType) {
+        if (rtType instanceof TestConstant) {
+            final String key = parser.getString();
+            if (key != null) {
+                return TestConstant.getByCode(key);
+            }
+        }
+        
+        return null;
+    }
+}
+
+
+
+    @Test
+    public void testEnumJsonb() {
+        ConstantUsage enumVerwender = new ConstantUsage();
+        enumVerwender.setI(1);
+        enumVerwender.setTestConstant(TestConstant.VAL_2);
+        
+        Jsonb jsonb = JsonbBuilder.create();
+        final String json = jsonb.toJson(enumVerwender);
+        assertTrue(json.contains("\"testConstant\":\"B\""));
+    }
+
+}

johnzon-mapper/src/main/java/org/apache/johnzon/mapper/DynamicMappingGenerator.java

@@ -23,6 +23,7 @@
 import java.math.BigDecimal;
 import java.math.BigInteger;
 
+@Deprecated
 public class DynamicMappingGenerator implements MappingGenerator {
     private final MappingGenerator delegate;
     private final Runnable writeStart;
@@ -40,33 +41,16 @@ public DynamicMappingGenerator(final MappingGenerator delegate,
         this.writeEnd = writeEnd;
         this.keyName = keyName;
     }
-
-    protected JsonGenerator getRawJsonGenerator() {
-        return delegate.getJsonGenerator();
-    }
-
-    @Override
-    public JsonGenerator getJsonGenerator() {
-        return generator == null ? generator = new InObjectOrPrimitiveJsonGenerator(
-                getRawJsonGenerator(), writeStart, keyName, writeEnd) : generator;
-    }
+    
 
     @Override
     public MappingGenerator writeObject(final String key, final Object o, final JsonGenerator generator) {
-        return delegate.writeObject(key, o, ensureGenerator(generator));
+        return delegate.writeObject(key, o, generator);
     }
 
     @Override
     public MappingGenerator writeObject(final Object o, final JsonGenerator generator) {
-        return delegate.writeObject(o, ensureGenerator(generator));
-    }
-
-    private JsonGenerator ensureGenerator(final JsonGenerator generator) {
-        if (this.generator != null && this.generator != generator && this.generator.delegate != generator) {
-            this.generator = null;
-            reset();
-        }
-        return getJsonGenerator(); // ensure we wrap it
+        return delegate.writeObject(o, generator);
     }
 
     protected void reset() {
@@ -593,24 +577,5 @@ public SkipEnclosingWriteEnd(final MappingGenerator delegate, final String keyNa
             super(delegate, NOOP, NOOP, keyName);
             this.rawGenerator = generator;
         }
-
-        @Override
-        protected JsonGenerator getRawJsonGenerator() {
-            return rawGenerator;
-        }
-
-        @Override
-        public JsonGenerator getJsonGenerator() {
-            if (skippingGenerator == null) {
-                skippingGenerator = new SkipLastWriteEndGenerator(super.getJsonGenerator());
-            }
-            return skippingGenerator;
-        }
-
-        @Override
-        protected void reset() {
-            super.reset();
-            skippingGenerator = null;
-        }
     }
 }

johnzon-mapper/src/main/java/org/apache/johnzon/mapper/Mapper.java

@@ -203,7 +203,7 @@ public void writeObject(final Object object, final OutputStream stream) {
 
     private void writeObject(final Object object, final JsonGenerator generator, final Collection<String> ignored,
                              final JsonPointerTracker tracker) {
-        final MappingGeneratorImpl mappingGenerator = new MappingGeneratorImpl(config, generator, mappings);
+        final MappingGeneratorImpl mappingGenerator = new MappingGeneratorImpl(config, mappings);
         mappingGenerator.doWriteObject(object, generator, true, ignored, tracker);
     }
 

johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MapperConfig.java

@@ -25,6 +25,8 @@
 
 import jakarta.json.Json;
 import jakarta.json.JsonValue;
+import jakarta.json.stream.JsonGenerator;
+
 import java.lang.reflect.Type;
 import java.nio.charset.Charset;
 import java.util.Collection;
@@ -48,7 +50,7 @@
 
     private static final ObjectConverter.Codec NO_CONVERTER = new ObjectConverter.Codec() {
         @Override
-        public void writeJson(Object instance, MappingGenerator jsonbGenerator) {
+        public void writeJson(Object instance, MappingGenerator jsonbGenerator, JsonGenerator generator) {
             // just a dummy
         }
 

johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MappingGenerator.java

@@ -24,16 +24,11 @@
  * Handles writing Json for Objects.
  * Internally it uses a {@link JsonGenerator} to write JSON
  *
- * To write JSON-P structure elements you can use the {@link #getJsonGenerator()} method.
+ * To write JSON-P structure elements you can use the {@link JsonGenerator}.
  *
  */
 public interface MappingGenerator {
 
-    /**
-     * @return the {@link JsonGenerator} used internally to write the JSON output.
-     */
-    JsonGenerator getJsonGenerator();
-
     /**
      * Write the given Object o into the current JSON layer.
      * This will <em>not</em> open a new json layer ('{', '}')