JOHNZON-441 - implement currentEvent for RewindableJsonParser and JsonValueParserAdapter

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

@@ -28,8 +28,6 @@
 import jakarta.json.stream.JsonParser;
 import jakarta.json.stream.JsonParserFactory;
 
-import org.apache.johnzon.mapper.jsonp.RewindableJsonParser;
-
 class JsonValueParserAdapter<T extends JsonValue> implements JsonParser {
 
     private static class JsonStringParserAdapter extends JsonValueParserAdapter<JsonString> {
@@ -73,7 +71,7 @@ public BigDecimal getBigDecimal() {
 
     public static JsonParser createFor(final JsonValue jsonValue,
                                        final Supplier<JsonParserFactory> parserFactoryProvider) {
-        return new RewindableJsonParser(doCreate(jsonValue, parserFactoryProvider));
+        return doCreate(jsonValue, parserFactoryProvider);
     }
 
     private static JsonParser doCreate(final JsonValue jsonValue,
@@ -103,6 +101,20 @@ public Event next() {
         throw new UnsupportedOperationException("next() no supported for " + jsonValue.getValueType());
     }
 
+    @Override
+    public Event currentEvent() {
+        switch (jsonValue.getValueType()) {
+            case STRING: return Event.VALUE_STRING;
+            case NUMBER: return Event.VALUE_NUMBER;
+            case TRUE: return Event.VALUE_TRUE;
+            case FALSE: return Event.VALUE_FALSE;
+            case NULL: return Event.VALUE_NULL;
+            case OBJECT: return Event.START_OBJECT;
+            case ARRAY: return Event.START_ARRAY;
+            default: throw new UnsupportedOperationException("currentEvent() not supported for " + jsonValue.getValueType());
+        }
+    }
+
     @Override
     public String getString() {
         throw new UnsupportedOperationException("next() no supported for " + jsonValue.getValueType());

johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/serializer/JohnzonDeserializationContext.java

@@ -55,8 +55,7 @@ public <T> T deserialize(final Type type, final JsonParser parser) {
     }
 
     private JsonValue read(final JsonParser parser) {
-        final JsonParser.Event next = /*RewindableJsonParser.class.isInstance(parser) ?
-                RewindableJsonParser.class.cast(parser).getLast() : */ parser.next();
+        final JsonParser.Event next = parser.next();
         switch (next) {
             case START_OBJECT: {
                 final JsonObjectBuilder objectBuilder = builderFactory.createObjectBuilder();

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

@@ -0,0 +1,178 @@
+/*
+ * 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;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+import java.math.BigDecimal;
+import java.util.Collections;
+
+import jakarta.json.Json;
+import jakarta.json.JsonArray;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonValue;
+import jakarta.json.stream.JsonParser;
+import jakarta.json.stream.JsonParser.Event;
+
+import org.junit.Test;
+
+public class JsonValueParserAdapterTest {
+    @Test
+    public void currentEventForString() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(Json.createValue("test"), null)) {
+            assertEquals(Event.VALUE_STRING, parser.currentEvent());
+        }
+    }
+
+    @Test
+    public void currentEventForNumber() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(Json.createValue(42), null)) {
+            assertEquals(Event.VALUE_NUMBER, parser.currentEvent());
+        }
+    }
+
+    @Test
+    public void currentEventForTrue() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(JsonValue.TRUE, null)) {
+            assertEquals(Event.VALUE_TRUE, parser.currentEvent());
+        }
+    }
+
+    @Test
+    public void currentEventForFalse() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(JsonValue.FALSE, null)) {
+            assertEquals(Event.VALUE_FALSE, parser.currentEvent());
+        }
+    }
+
+    @Test
+    public void currentEventForNull() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(JsonValue.NULL, null)) {
+            assertEquals(Event.VALUE_NULL, parser.currentEvent());
+        }
+    }
+
+    @Test
+    public void currentEventForObject() {
+        try (final JsonParser parser = new JsonValueParserAdapter<>(JsonValue.EMPTY_JSON_OBJECT)) {
+            assertEquals(Event.START_OBJECT, parser.currentEvent());
+        }
+    }
+
+    @Test
+    public void currentEventForArray() {
+        try (final JsonParser parser = new JsonValueParserAdapter<>(JsonValue.EMPTY_JSON_ARRAY)) {
+            assertEquals(Event.START_ARRAY, parser.currentEvent());
+        }
+    }
+
+    @Test
+    public void createForObjectDelegatesToParserFactory() {
+        final JsonObject object = Json.createObjectBuilder().add("value", "simple").build();
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(
+                object, () -> Json.createParserFactory(Collections.emptyMap()))) {
+            assertTrue(parser.hasNext());
+            assertEquals(Event.START_OBJECT, parser.next());
+            assertEquals(Event.KEY_NAME, parser.next());
+            assertEquals("value", parser.getString());
+        }
+    }
+
+    @Test
+    public void createForArrayDelegatesToParserFactory() {
+        final JsonArray array = Json.createArrayBuilder().add(1).build();
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(
+                array, () -> Json.createParserFactory(Collections.emptyMap()))) {
+            assertTrue(parser.hasNext());
+            assertEquals(Event.START_ARRAY, parser.next());
+            assertEquals(Event.VALUE_NUMBER, parser.next());
+            assertEquals(1, parser.getInt());
+        }
+    }
+
+    @Test
+    public void hasNextIsFalse() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(Json.createValue("test"), null)) {
+            assertFalse(parser.hasNext());
+        }
+    }
+
+    @Test
+    public void nextIsUnsupported() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(Json.createValue("test"), null)) {
+            assertThrows(UnsupportedOperationException.class, parser::next);
+        }
+    }
+
+    @Test
+    public void getValueReturnsWrappedValue() {
+        final JsonValue value = Json.createValue("test");
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(value, null)) {
+            assertSame(value, parser.getValue());
+        }
+    }
+
+    @Test
+    public void getStringForString() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(Json.createValue("test"), null)) {
+            assertEquals("test", parser.getString());
+        }
+    }
+
+    @Test
+    public void numberAccessorsForIntegralNumber() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(Json.createValue(42), null)) {
+            assertTrue(parser.isIntegralNumber());
+            assertEquals(42, parser.getInt());
+            assertEquals(42L, parser.getLong());
+            assertEquals(new BigDecimal(42), parser.getBigDecimal());
+        }
+    }
+
+    @Test
+    public void numberAccessorsForDecimalNumber() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(Json.createValue(new BigDecimal("1.5")), null)) {
+            assertFalse(parser.isIntegralNumber());
+            assertEquals(new BigDecimal("1.5"), parser.getBigDecimal());
+        }
+    }
+
+    @Test
+    public void unsupportedOperationsForNonNumberValue() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(JsonValue.TRUE, null)) {
+            assertThrows(UnsupportedOperationException.class, parser::getString);
+            assertThrows(UnsupportedOperationException.class, parser::isIntegralNumber);
+            assertThrows(UnsupportedOperationException.class, parser::getInt);
+            assertThrows(UnsupportedOperationException.class, parser::getLong);
+            assertThrows(UnsupportedOperationException.class, parser::getBigDecimal);
+            assertThrows(UnsupportedOperationException.class, parser::getLocation);
+        }
+    }
+
+    @Test
+    public void getStringForNumberIsUnsupported() {
+        try (final JsonParser parser = JsonValueParserAdapter.createFor(Json.createValue(42), null)) {
+            assertThrows(UnsupportedOperationException.class, parser::getString);
+        }
+    }
+}