This is an automated email from the ASF dual-hosted git repository.
rmannibucau pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/johnzon.git
The following commit(s) were added to refs/heads/master by this push:
new 09e0369 JOHNZON-210 reworking JsonObject/JsonArray#toString to use
JsonGenerator
09e0369 is described below
commit 09e03694b0460d0a65c3eb6e2600d92b2dd6b948
Author: Romain Manni-Bucau <[email protected]>
AuthorDate: Mon Apr 29 11:27:08 2019 +0200
JOHNZON-210 reworking JsonObject/JsonArray#toString to use JsonGenerator
---
.../java/org/apache/johnzon/core/DiffBase.java | 3 +-
.../apache/johnzon/core/JohnzonJsonParserImpl.java | 7 ++--
.../apache/johnzon/core/JsonArrayBuilderImpl.java | 25 +++++++++-----
.../org/apache/johnzon/core/JsonArrayImpl.java | 29 +++++++----------
.../johnzon/core/JsonBuilderFactoryImpl.java | 30 +++++++++++------
.../apache/johnzon/core/JsonInMemoryParser.java | 12 +++++--
.../apache/johnzon/core/JsonMergePatchDiff.java | 11 +++++--
.../apache/johnzon/core/JsonMergePatchImpl.java | 11 ++++---
.../apache/johnzon/core/JsonObjectBuilderImpl.java | 23 ++++++++-----
.../org/apache/johnzon/core/JsonObjectImpl.java | 38 +++++++---------------
.../apache/johnzon/core/JsonParserFactoryImpl.java | 4 +--
.../org/apache/johnzon/core/JsonProviderImpl.java | 13 +++++---
.../apache/johnzon/core/JsonReaderFactoryImpl.java | 10 ++++--
.../org/apache/johnzon/core/JsonReaderImpl.java | 34 +++++++++++--------
.../apache/johnzon/core/JsonStreamParserImpl.java | 5 +++
.../org/apache/johnzon/core/JsonStringImpl.java | 4 ++-
.../main/java/org/apache/johnzon/core/Strings.java | 15 ---------
.../org/apache/johnzon/core/SerializationTest.java | 6 ++--
.../org/apache/johnzon/jsonb/JohnzonBuilder.java | 8 +++--
.../org/apache/johnzon/jsonb/JsonbAccessMode.java | 20 ++++++++----
.../serializer/JohnzonDeserializationContext.java | 8 +++--
21 files changed, 179 insertions(+), 137 deletions(-)
diff --git a/johnzon-core/src/main/java/org/apache/johnzon/core/DiffBase.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/DiffBase.java
index d6abfdf..b25f5e5 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/DiffBase.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/DiffBase.java
@@ -19,11 +19,12 @@ package org.apache.johnzon.core;
import javax.json.JsonArray;
import javax.json.JsonObject;
import javax.json.JsonValue;
+import java.io.Serializable;
/**
* Commonly used methods for diffs
*/
-class DiffBase {
+class DiffBase implements Serializable {
protected boolean isJsonObject(JsonValue jsonValue) {
return jsonValue instanceof JsonObject;
}
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JohnzonJsonParserImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JohnzonJsonParserImpl.java
index 1a0cc3d..40dbeb5 100644
---
a/johnzon-core/src/main/java/org/apache/johnzon/core/JohnzonJsonParserImpl.java
+++
b/johnzon-core/src/main/java/org/apache/johnzon/core/JohnzonJsonParserImpl.java
@@ -34,6 +34,7 @@ public abstract class JohnzonJsonParserImpl implements
JohnzonJsonParser {
* @return {@code true} if we are currently inside an array
*/
protected abstract boolean isInArray();
+ protected abstract BufferStrategy.BufferProvider<char[]>
getCharArrayProvider();
@Override
public JsonObject getObject() {
@@ -42,7 +43,7 @@ public abstract class JohnzonJsonParserImpl implements
JohnzonJsonParser {
throw new IllegalStateException(current + " doesn't support
getObject()");
}
- JsonReaderImpl jsonReader = new JsonReaderImpl(this, true);
+ JsonReaderImpl jsonReader = new JsonReaderImpl(this, true,
getCharArrayProvider());
return jsonReader.readObject();
}
@@ -54,7 +55,7 @@ public abstract class JohnzonJsonParserImpl implements
JohnzonJsonParser {
throw new IllegalStateException(current + " doesn't support
getArray()");
}
- JsonReaderImpl jsonReader = new JsonReaderImpl(this, true);
+ JsonReaderImpl jsonReader = new JsonReaderImpl(this, true,
getCharArrayProvider());
return jsonReader.readArray();
}
@@ -64,7 +65,7 @@ public abstract class JohnzonJsonParserImpl implements
JohnzonJsonParser {
switch (current) {
case START_ARRAY:
case START_OBJECT:
- JsonReaderImpl jsonReader = new JsonReaderImpl(this, true);
+ JsonReaderImpl jsonReader = new JsonReaderImpl(this, true,
getCharArrayProvider());
return jsonReader.readValue();
case VALUE_TRUE:
return JsonValue.TRUE;
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonArrayBuilderImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonArrayBuilderImpl.java
index 57cceb7..1819309 100644
---
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonArrayBuilderImpl.java
+++
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonArrayBuilderImpl.java
@@ -33,18 +33,25 @@ import java.util.List;
class JsonArrayBuilderImpl implements JsonArrayBuilder, Serializable {
private List<JsonValue> tmpList;
+ private BufferStrategy.BufferProvider<char[]> bufferProvider;
- public JsonArrayBuilderImpl() {
+ protected JsonArrayBuilderImpl() {
+ // no-op: serialization
}
- public JsonArrayBuilderImpl(JsonArray initialData) {
- tmpList = new ArrayList<>(initialData);
+ public JsonArrayBuilderImpl(final JsonArray initialData,
+ final BufferStrategy.BufferProvider<char[]>
provider) {
+ this.tmpList = new ArrayList<>(initialData);
+ this.bufferProvider = provider;
}
- public JsonArrayBuilderImpl(Collection<?> initialData) {
- tmpList = new ArrayList<>();
- for (Object initialValue : initialData) {
- add(initialValue);
+ public JsonArrayBuilderImpl(final Collection<?> initialData, final
BufferStrategy.BufferProvider<char[]> provider) {
+ this.bufferProvider = provider;
+ this.tmpList = new ArrayList<>();
+ if (!initialData.isEmpty()) {
+ for (Object initialValue : initialData) {
+ add(initialValue);
+ }
}
}
@@ -316,9 +323,9 @@ class JsonArrayBuilderImpl implements JsonArrayBuilder,
Serializable {
@Override
public JsonArray build() {
if(tmpList == null) {
- return new JsonArrayImpl(Collections.emptyList());
+ return new JsonArrayImpl(Collections.emptyList(), bufferProvider);
}
- return new JsonArrayImpl(Collections.unmodifiableList(tmpList));
+ return new JsonArrayImpl(Collections.unmodifiableList(tmpList),
bufferProvider);
}
private static NullPointerException npe() {
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonArrayImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonArrayImpl.java
index 1d880c7..fd1b59f 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonArrayImpl.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonArrayImpl.java
@@ -23,20 +23,22 @@ import javax.json.JsonNumber;
import javax.json.JsonObject;
import javax.json.JsonString;
import javax.json.JsonValue;
+import javax.json.stream.JsonGenerator;
import java.io.ObjectStreamException;
import java.io.Serializable;
+import java.io.StringWriter;
import java.util.AbstractList;
-import java.util.Iterator;
import java.util.List;
class JsonArrayImpl extends AbstractList<JsonValue> implements JsonArray,
Serializable {
+ private final BufferStrategy.BufferProvider<char[]> provider;
private Integer hashCode = null;
private final List<JsonValue> unmodifieableBackingList;
private int size = -1;
- JsonArrayImpl(final List<JsonValue> backingList) {
- super();
+ JsonArrayImpl(final List<JsonValue> backingList, final
BufferStrategy.BufferProvider<char[]> provider) {
this.unmodifieableBackingList = backingList;
+ this.provider = provider;
}
private <T> T value(final int idx, final Class<T> type) {
@@ -159,22 +161,13 @@ class JsonArrayImpl extends AbstractList<JsonValue>
implements JsonArray, Serial
@Override
public String toString() {
- final StringBuilder builder = new StringBuilder("[");
- final Iterator<JsonValue> it = unmodifieableBackingList.iterator();
- boolean hasNext = it.hasNext();
- while (hasNext) {
- final JsonValue jsonValue = it.next();
- if (JsonString.class.isInstance(jsonValue)) {
- builder.append(jsonValue.toString());
- } else {
- builder.append(jsonValue != JsonValue.NULL ?
jsonValue.toString() : JsonChars.NULL);
- }
- hasNext = it.hasNext();
- if (hasNext) {
- builder.append(",");
- }
+ final StringWriter writer = new StringWriter();
+ try (final JsonGenerator generator = new JsonGeneratorImpl(writer,
provider, false)) {
+ generator.writeStartArray();
+ unmodifieableBackingList.forEach(generator::write);
+ generator.writeEnd();
}
- return builder.append(']').toString();
+ return writer.toString();
}
@Override
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonBuilderFactoryImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonBuilderFactoryImpl.java
index 81719ff..1d54c89 100644
---
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonBuilderFactoryImpl.java
+++
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonBuilderFactoryImpl.java
@@ -18,6 +18,7 @@
*/
package org.apache.johnzon.core;
+import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
@@ -32,15 +33,24 @@ import javax.json.JsonBuilderFactory;
import javax.json.JsonObject;
import javax.json.JsonObjectBuilder;
-class JsonBuilderFactoryImpl implements JsonBuilderFactory {
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
+
+class JsonBuilderFactoryImpl implements JsonBuilderFactory, Serializable {
private final Map<String, Object> internalConfig = new HashMap<String,
Object>();
+ private BufferStrategy.BufferProvider<char[]> bufferProvider;
private static final String[] SUPPORTED_CONFIG_KEYS = new String[] {
- //nothing yet
-
+ // nothing yet
};
+
protected final Logger logger =
Logger.getLogger(this.getClass().getName());
- JsonBuilderFactoryImpl(final Map<String, ?> config) {
+ protected JsonBuilderFactoryImpl() {
+ // no-op: serialization
+ }
+
+ JsonBuilderFactoryImpl(final Map<String, ?> config, final
BufferStrategy.BufferProvider<char[]> bufferProvider) {
+ this.bufferProvider = bufferProvider;
if (config != null && config.size() > 0) {
final List<String> supportedConfigKeys =
Arrays.asList(SUPPORTED_CONFIG_KEYS);
for (String configKey : config.keySet()) {
@@ -55,28 +65,28 @@ class JsonBuilderFactoryImpl implements JsonBuilderFactory {
@Override
public JsonObjectBuilder createObjectBuilder() {
- return new JsonObjectBuilderImpl();
+ return new JsonObjectBuilderImpl(emptyMap(), bufferProvider);
}
@Override
public JsonObjectBuilder createObjectBuilder(JsonObject initialData) {
- return new JsonObjectBuilderImpl(initialData);
+ return new JsonObjectBuilderImpl(initialData, bufferProvider);
}
@Override
public JsonArrayBuilder createArrayBuilder() {
- return new JsonArrayBuilderImpl();
+ return new JsonArrayBuilderImpl(emptyList(), bufferProvider);
}
@Override
public JsonArrayBuilder createArrayBuilder(JsonArray initialData) {
- return new JsonArrayBuilderImpl(initialData);
+ return new JsonArrayBuilderImpl(initialData, bufferProvider);
}
@Override
public JsonArrayBuilder createArrayBuilder(Collection<?> initialData) {
- return new JsonArrayBuilderImpl(initialData);
+ return new JsonArrayBuilderImpl(initialData, bufferProvider);
}
@Override
@@ -86,7 +96,7 @@ class JsonBuilderFactoryImpl implements JsonBuilderFactory {
@Override
public JsonObjectBuilder createObjectBuilder(Map<String, Object>
initialValues) {
- return new JsonObjectBuilderImpl(initialValues);
+ return new JsonObjectBuilderImpl(initialValues, bufferProvider);
}
}
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonInMemoryParser.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonInMemoryParser.java
index f94e437..014d276 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonInMemoryParser.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonInMemoryParser.java
@@ -34,6 +34,7 @@ import javax.json.stream.JsonLocation;
class JsonInMemoryParser extends JohnzonJsonParserImpl {
private final SimpleStack<Iterator<Event>> stack = new
SimpleStack<Iterator<Event>>();
+ private final BufferStrategy.BufferProvider<char[]> bufferProvider;
private Event currentEvent;
private JsonValue currentValue;
@@ -184,6 +185,11 @@ class JsonInMemoryParser extends JohnzonJsonParserImpl {
return arrayDepth > 0;
}
+ @Override
+ protected BufferStrategy.BufferProvider<char[]> getCharArrayProvider() {
+ return bufferProvider;
+ }
+
private static Event getEvent(final ValueType value) {
switch (value) {
@@ -204,12 +210,14 @@ class JsonInMemoryParser extends JohnzonJsonParserImpl {
}
- JsonInMemoryParser(final JsonObject object) {
+ JsonInMemoryParser(final JsonObject object, final
BufferStrategy.BufferProvider<char[]> bufferProvider) {
stack.push(new ObjectIterator(object));
+ this.bufferProvider = bufferProvider;
}
- JsonInMemoryParser(final JsonArray array) {
+ JsonInMemoryParser(final JsonArray array, final
BufferStrategy.BufferProvider<char[]> bufferProvider) {
stack.push(new ArrayIterator(array));
+ this.bufferProvider = bufferProvider;
}
@Override
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonMergePatchDiff.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonMergePatchDiff.java
index 5175e8d..1ca3bf9 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonMergePatchDiff.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonMergePatchDiff.java
@@ -23,24 +23,29 @@ import javax.json.JsonObject;
import javax.json.JsonObjectBuilder;
import javax.json.JsonValue;
+import static java.util.Collections.emptyMap;
+
/**
* Creates a JsonMergePatch as diff between two JsonValues
*/
class JsonMergePatchDiff extends DiffBase {
+ private final BufferStrategy.BufferProvider<char[]> bufferProvider;
private final JsonValue source;
private final JsonValue target;
- public JsonMergePatchDiff(JsonValue source, JsonValue target) {
+ public JsonMergePatchDiff(final JsonValue source, final JsonValue target,
+ final BufferStrategy.BufferProvider<char[]>
bufferProvider) {
+ this.bufferProvider = bufferProvider;
this.source = source;
this.target = target;
}
public JsonMergePatch calculateDiff() {
- return new JsonMergePatchImpl(diff(source, target));
+ return new JsonMergePatchImpl(diff(source, target), bufferProvider);
}
private JsonValue diff(JsonValue source, JsonValue target) {
- JsonObjectBuilder builder = new JsonObjectBuilderImpl();
+ JsonObjectBuilder builder = new JsonObjectBuilderImpl(emptyMap(),
bufferProvider);
if (isJsonObject(source) && isJsonObject(target)) {
JsonObject srcObj = source.asJsonObject();
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonMergePatchImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonMergePatchImpl.java
index b3f55c6..56518cd 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonMergePatchImpl.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonMergePatchImpl.java
@@ -17,6 +17,7 @@
package org.apache.johnzon.core;
+import java.io.Serializable;
import java.util.Map;
import javax.json.JsonMergePatch;
@@ -27,11 +28,13 @@ import javax.json.JsonValue;
/**
* @author <a href="mailto:[email protected]";>Mark Struberg</a>
*/
-public class JsonMergePatchImpl implements JsonMergePatch {
- private final JsonValue patch;
+public class JsonMergePatchImpl implements JsonMergePatch, Serializable {
+ private JsonValue patch;
+ private BufferStrategy.BufferProvider<char[]> bufferProvider;
- public JsonMergePatchImpl(JsonValue patch) {
+ public JsonMergePatchImpl(final JsonValue patch, final
BufferStrategy.BufferProvider<char[]> bufferProvider) {
this.patch = patch;
+ this.bufferProvider = bufferProvider;
}
@Override
@@ -55,7 +58,7 @@ public class JsonMergePatchImpl implements JsonMergePatch {
}
private JsonValue applyJsonObjectPatch(JsonObject jsonObject, JsonObject
patch) {
- JsonObjectBuilder builder = new JsonObjectBuilderImpl(jsonObject);
+ JsonObjectBuilder builder = new JsonObjectBuilderImpl(jsonObject,
bufferProvider);
for (Map.Entry<String, JsonValue> patchAttrib : patch.entrySet()) {
String attribName = patchAttrib.getKey();
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonObjectBuilderImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonObjectBuilderImpl.java
index b89a671..003cb77 100644
---
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonObjectBuilderImpl.java
+++
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonObjectBuilderImpl.java
@@ -31,19 +31,26 @@ import java.util.LinkedHashMap;
import java.util.Map;
class JsonObjectBuilderImpl implements JsonObjectBuilder, Serializable {
+ private BufferStrategy.BufferProvider<char[]> bufferProvider;
private Map<String, JsonValue> attributeMap = new LinkedHashMap<>();
- public JsonObjectBuilderImpl() {
+ protected JsonObjectBuilderImpl() {
+ // no-op: serialization
}
- public JsonObjectBuilderImpl(JsonObject initialData) {
+ public JsonObjectBuilderImpl(final JsonObject initialData,
+ final BufferStrategy.BufferProvider<char[]>
bufferProvider) {
+ this.bufferProvider = bufferProvider;
attributeMap = new LinkedHashMap<>(initialData);
}
- public JsonObjectBuilderImpl(Map<String, Object> initialValues) {
- this();
- for (Map.Entry<String, Object> entry : initialValues.entrySet()) {
- add(entry.getKey(), entry.getValue());
+ public JsonObjectBuilderImpl(final Map<String, Object> initialValues,
+ final BufferStrategy.BufferProvider<char[]>
bufferProvider) {
+ this.bufferProvider = bufferProvider;
+ if (!initialValues.isEmpty()) {
+ for (Map.Entry<String, Object> entry : initialValues.entrySet()) {
+ add(entry.getKey(), entry.getValue());
+ }
}
}
@@ -166,10 +173,10 @@ class JsonObjectBuilderImpl implements JsonObjectBuilder,
Serializable {
public JsonObject build() {
if(attributeMap == null || attributeMap.isEmpty()) {
- return new JsonObjectImpl(Collections.EMPTY_MAP);
+ return new JsonObjectImpl(Collections.EMPTY_MAP, bufferProvider);
} else {
Map<String, JsonValue> dump =
(Collections.unmodifiableMap(attributeMap));
- return new JsonObjectImpl(dump);
+ return new JsonObjectImpl(dump, bufferProvider);
}
}
}
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonObjectImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonObjectImpl.java
index a70c410..af00c6f 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonObjectImpl.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonObjectImpl.java
@@ -23,16 +23,18 @@ import javax.json.JsonNumber;
import javax.json.JsonObject;
import javax.json.JsonString;
import javax.json.JsonValue;
+import javax.json.stream.JsonGenerator;
import java.io.ObjectStreamException;
import java.io.Serializable;
+import java.io.StringWriter;
import java.util.AbstractMap;
-import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
-
final class JsonObjectImpl extends AbstractMap<String, JsonValue> implements
JsonObject, Serializable {
+ private final BufferStrategy.BufferProvider<char[]> provider;
+
private transient Integer hashCode = null;
private final Map<String, JsonValue> unmodifieableBackingMap;
@@ -53,9 +55,9 @@ final class JsonObjectImpl extends AbstractMap<String,
JsonValue> implements Jso
return value;
}
- JsonObjectImpl(final Map<String, JsonValue> backingMap) {
- super();
+ JsonObjectImpl(final Map<String, JsonValue> backingMap, final
BufferStrategy.BufferProvider<char[]> provider) {
this.unmodifieableBackingMap = new LinkedHashMap<>(backingMap);
+ this.provider = provider;
}
@Override
@@ -141,29 +143,13 @@ final class JsonObjectImpl extends AbstractMap<String,
JsonValue> implements Jso
@Override
public String toString() {
- final StringBuilder builder = new StringBuilder("{");
- final Iterator<Map.Entry<String, JsonValue>> it =
unmodifieableBackingMap.entrySet().iterator();
- boolean hasNext = it.hasNext();
- while (hasNext) {
- final Map.Entry<String, JsonValue> entry = it.next();
-
- builder.append('"');
- Strings.appendEscaped(entry.getKey(), builder);
- builder.append("\":");
-
- final JsonValue value = entry.getValue();
- if (JsonString.class.isInstance(value)) {
- builder.append(value.toString());
- } else {
- builder.append(value != JsonValue.NULL ? value.toString() :
JsonChars.NULL);
- }
-
- hasNext = it.hasNext();
- if (hasNext) {
- builder.append(",");
- }
+ final StringWriter writer = new StringWriter();
+ try (final JsonGenerator generator = new JsonGeneratorImpl(writer,
provider, false)) {
+ generator.writeStartObject();
+ unmodifieableBackingMap.forEach(generator::write);
+ generator.writeEnd();
}
- return builder.append('}').toString();
+ return writer.toString();
}
@Override
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonParserFactoryImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonParserFactoryImpl.java
index 440b4cb..437a2ca 100644
---
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonParserFactoryImpl.java
+++
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonParserFactoryImpl.java
@@ -109,13 +109,13 @@ public class JsonParserFactoryImpl extends
AbstractJsonFactory implements JsonPa
@Override
public JsonParser createParser(final JsonObject obj) {
// no need of a comment version since JsonObject has no comment event
- return new JsonInMemoryParser(obj);
+ return new JsonInMemoryParser(obj, bufferProvider);
}
@Override
public JsonParser createParser(final JsonArray array) {
// no need of a comment version since JsonObject has no comment event
- return new JsonInMemoryParser(array);
+ return new JsonInMemoryParser(array, bufferProvider);
}
@Override
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonProviderImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonProviderImpl.java
index 37483da..4447a7d 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonProviderImpl.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonProviderImpl.java
@@ -215,11 +215,15 @@ public class JsonProviderImpl extends JsonProvider
implements Serializable {
}
static class JsonProviderDelegate extends JsonProvider {
+ private final BufferStrategy.BufferProvider<char[]> bufferProvider =
+
BufferStrategy.valueOf(System.getProperty("johnzon.global-char-provider.strategy",
"QUEUE"))
+
.newCharProvider(Integer.getInteger("org.apache.johnzon.default-char-provider.length",
1024));
+
private final JsonReaderFactory readerFactory = new
JsonReaderFactoryImpl(null);
private final JsonParserFactory parserFactory = new
JsonParserFactoryImpl(null);
private final JsonGeneratorFactory generatorFactory = new
JsonGeneratorFactoryImpl(null);
private final JsonWriterFactory writerFactory = new
JsonWriterFactoryImpl(null);
- private final JsonBuilderFactoryImpl builderFactory = new
JsonBuilderFactoryImpl(null);
+ private final JsonBuilderFactoryImpl builderFactory = new
JsonBuilderFactoryImpl(null, bufferProvider);
@Override
public JsonParser createParser(final InputStream in) {
@@ -342,7 +346,8 @@ public class JsonProviderImpl extends JsonProvider
implements Serializable {
@Override
public JsonBuilderFactory createBuilderFactory(final Map<String, ?>
config) {
- return (config == null || config.isEmpty()) ? builderFactory : new
JsonBuilderFactoryImpl(config);
+ return (config == null || config.isEmpty()) ?
+ builderFactory : new JsonBuilderFactoryImpl(config,
bufferProvider);
}
@Override
@@ -370,12 +375,12 @@ public class JsonProviderImpl extends JsonProvider
implements Serializable {
}
public JsonMergePatch createMergePatch(JsonValue patch) {
- return new JsonMergePatchImpl(patch);
+ return new JsonMergePatchImpl(patch, bufferProvider);
}
@Override
public JsonMergePatch createMergeDiff(JsonValue source, JsonValue
target) {
- return new JsonMergePatchDiff(source, target).calculateDiff();
+ return new JsonMergePatchDiff(source, target,
bufferProvider).calculateDiff();
}
}
}
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonReaderFactoryImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonReaderFactoryImpl.java
index 98484b1..106de0a 100644
---
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonReaderFactoryImpl.java
+++
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonReaderFactoryImpl.java
@@ -43,21 +43,25 @@ class JsonReaderFactoryImpl extends AbstractJsonFactory
implements JsonReaderFac
@Override
public JsonReader createReader(final Reader reader) {
- return new JsonReaderImpl(parserFactory.createInternalParser(reader));
+ return new JsonReaderImpl(parserFactory.createInternalParser(reader),
getCharArrayProvider());
}
@Override
public JsonReader createReader(final InputStream in) {
- return new JsonReaderImpl(parserFactory.createInternalParser(in));
+ return new JsonReaderImpl(parserFactory.createInternalParser(in),
getCharArrayProvider());
}
@Override
public JsonReader createReader(final InputStream in, final Charset
charset) {
- return new JsonReaderImpl(parserFactory.createInternalParser(in,
charset));
+ return new JsonReaderImpl(parserFactory.createInternalParser(in,
charset), getCharArrayProvider());
}
@Override
public Map<String, ?> getConfigInUse() {
return Collections.unmodifiableMap(internalConfig);
}
+
+ private BufferStrategy.BufferProvider<char[]> getCharArrayProvider() {
+ return getBufferProvider().newCharProvider(1024);
+ }
}
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonReaderImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonReaderImpl.java
index 02d1d39..531e371 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonReaderImpl.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonReaderImpl.java
@@ -30,23 +30,29 @@ import javax.json.JsonValue;
import javax.json.stream.JsonParser;
import javax.json.stream.JsonParsingException;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
+
public class JsonReaderImpl implements JsonReader {
private final JohnzonJsonParser parser;
+ private final BufferStrategy.BufferProvider<char[]> bufferProvider;
private boolean closed = false;
private boolean subStreamReader;
- public JsonReaderImpl(final JsonParser parser) {
- this(parser, false);
+ public JsonReaderImpl(final JsonParser parser, final
BufferStrategy.BufferProvider<char[]> bufferProvider) {
+ this(parser, false, bufferProvider);
}
/**
- *
- * @param parser
+ * @param parser json parser.
* @param subStreamReader {@code true} if the Stream already got started
and the first
* operation should not be next() but {@link
JohnzonJsonParser#current()} instead.
+ * @param bufferProvider buffer provider for toString of created instances.
*/
- public JsonReaderImpl(final JsonParser parser, boolean subStreamReader) {
+ public JsonReaderImpl(final JsonParser parser, boolean subStreamReader,
+ final BufferStrategy.BufferProvider<char[]>
bufferProvider) {
+ this.bufferProvider = bufferProvider;
if (parser instanceof JohnzonJsonParser) {
this.parser = (JohnzonJsonParser) parser;
} else {
@@ -79,7 +85,7 @@ public class JsonReaderImpl implements JsonReader {
switch (next) {
case START_OBJECT:
- final JsonObjectBuilder objectBuilder = new
JsonObjectBuilderImpl();
+ final JsonObjectBuilder objectBuilder = new
JsonObjectBuilderImpl(emptyMap(), bufferProvider);
parseObject(objectBuilder);
if (!subStreamReader) {
if (parser.hasNext()) {
@@ -89,7 +95,7 @@ public class JsonReaderImpl implements JsonReader {
}
return objectBuilder.build();
case START_ARRAY:
- final JsonArrayBuilder arrayBuilder = new
JsonArrayBuilderImpl();
+ final JsonArrayBuilder arrayBuilder = new
JsonArrayBuilderImpl(emptyList(), bufferProvider);
parseArray(arrayBuilder);
if (!subStreamReader) {
if (parser.hasNext()) {
@@ -190,14 +196,14 @@ public class JsonReaderImpl implements JsonReader {
break;
case START_OBJECT:
- JsonObjectBuilder subObject = null;
- parseObject(subObject = new JsonObjectBuilderImpl());
+ JsonObjectBuilder subObject = new
JsonObjectBuilderImpl(emptyMap(), bufferProvider);
+ parseObject(subObject);
builder.add(key, subObject);
break;
case START_ARRAY:
- JsonArrayBuilder subArray = null;
- parseArray(subArray = new JsonArrayBuilderImpl());
+ JsonArrayBuilder subArray = new
JsonArrayBuilderImpl(emptyList(), bufferProvider);
+ parseArray(subArray);
builder.add(key, subArray);
break;
@@ -250,14 +256,14 @@ public class JsonReaderImpl implements JsonReader {
break;
case START_OBJECT:
- JsonObjectBuilder subObject = null;
- parseObject(subObject = new JsonObjectBuilderImpl());
+ JsonObjectBuilder subObject = new
JsonObjectBuilderImpl(emptyMap(), bufferProvider);
+ parseObject(subObject);
builder.add(subObject);
break;
case START_ARRAY:
JsonArrayBuilder subArray = null;
- parseArray(subArray = new JsonArrayBuilderImpl());
+ parseArray(subArray = new
JsonArrayBuilderImpl(emptyList(), bufferProvider));
builder.add(subArray);
break;
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonStreamParserImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonStreamParserImpl.java
index 18f0a1c..79f72ae 100644
---
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonStreamParserImpl.java
+++
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonStreamParserImpl.java
@@ -558,6 +558,11 @@ public class JsonStreamParserImpl extends
JohnzonJsonParserImpl implements JsonC
return arrayDepth > 0;
}
+ @Override
+ protected BufferStrategy.BufferProvider<char[]> getCharArrayProvider() {
+ return bufferProvider;
+ }
+
//read a string, gets called recursively
//Handles escape/d characters
//if string contains escape chars and/or cross buffer boundary then copy
in the value buffer
diff --git
a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonStringImpl.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonStringImpl.java
index 5ec8a36..9cb1128 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/JsonStringImpl.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/JsonStringImpl.java
@@ -54,7 +54,9 @@ final class JsonStringImpl implements JsonString,
Serializable {
public String toString() {
String s = escape;
if (s == null) {
- s =
JsonChars.QUOTE_CHAR+Strings.escape(value)+JsonChars.QUOTE_CHAR;
+ final StringBuilder builder = new StringBuilder();
+ Strings.appendEscaped(value, builder);
+ s = JsonChars.QUOTE_CHAR + builder.toString() +
JsonChars.QUOTE_CHAR;
escape=s;
}
return s;
diff --git a/johnzon-core/src/main/java/org/apache/johnzon/core/Strings.java
b/johnzon-core/src/main/java/org/apache/johnzon/core/Strings.java
index cbcf509..5ea3305 100644
--- a/johnzon-core/src/main/java/org/apache/johnzon/core/Strings.java
+++ b/johnzon-core/src/main/java/org/apache/johnzon/core/Strings.java
@@ -60,21 +60,6 @@ class Strings implements JsonChars {
}
- static String escape(final String value) {
-
- if(value == null || value.length()==0) {
- return value;
- }
-
- final StringBuilder builder = BUILDER_CACHE.newBuffer();
- try {
- appendEscaped(value, builder);
- return builder.toString();
- } finally {
- BUILDER_CACHE.release(builder);
- }
- }
-
static void appendEscaped(final String value, final StringBuilder builder)
{
final int length = value.length();
int nextStart = 0;
diff --git
a/johnzon-core/src/test/java/org/apache/johnzon/core/SerializationTest.java
b/johnzon-core/src/test/java/org/apache/johnzon/core/SerializationTest.java
index 383dae9..de90ff3 100644
--- a/johnzon-core/src/test/java/org/apache/johnzon/core/SerializationTest.java
+++ b/johnzon-core/src/test/java/org/apache/johnzon/core/SerializationTest.java
@@ -82,7 +82,8 @@ public class SerializationTest {
final Map<String, JsonValue> map = new LinkedHashMap<String,
JsonValue>();
map.put("test", new JsonStringImpl("val"));
map.put("test2", JsonValue.TRUE);
- final JsonObject source = new
JsonObjectImpl(Collections.unmodifiableMap(map));
+ final JsonObject source = new
JsonObjectImpl(Collections.unmodifiableMap(map),
+ BufferStrategy.BY_INSTANCE.newCharProvider(512));
final JsonObject serialization = serialDeser(source);
assertNotSame(source, serialization);
assertTrue(serialization.containsKey("test"));
@@ -96,7 +97,8 @@ public class SerializationTest {
final List<JsonValue> list = new ArrayList<JsonValue>();
list.add(new JsonStringImpl("test"));
list.add(JsonValue.TRUE); // not ser but we should be able to handle
that
- final JsonArray source = new
JsonArrayImpl(Collections.unmodifiableList(list));
+ final JsonArray source = new
JsonArrayImpl(Collections.unmodifiableList(list),
+ BufferStrategy.BY_INSTANCE.newCharProvider(512));
final JsonArray serialization = serialDeser(source);
assertNotSame(source, serialization);
assertEquals(2, serialization.size());
diff --git
a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JohnzonBuilder.java
b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JohnzonBuilder.java
index 70e3a45..f227a3a 100644
--- a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JohnzonBuilder.java
+++ b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JohnzonBuilder.java
@@ -82,6 +82,7 @@ import javax.json.stream.JsonGenerator;
import javax.json.stream.JsonParserFactory;
import org.apache.johnzon.core.AbstractJsonFactory;
+import org.apache.johnzon.core.BufferStrategy;
import org.apache.johnzon.core.JsonGeneratorFactoryImpl;
import org.apache.johnzon.core.JsonParserFactoryImpl;
import org.apache.johnzon.core.Types;
@@ -189,6 +190,7 @@ public class JohnzonBuilder implements JsonbBuilder {
throw new IllegalArgumentException("Unsupported factory: " + val);
}).orElseGet(this::findFactory);
+ final BufferStrategy.BufferProvider<char[]> bufferProvider =
BufferStrategy.QUEUE.newCharProvider(1024);
final AccessMode accessMode = config.getProperty("johnzon.accessMode")
.map(this::toAccessMode)
.orElseGet(() -> new JsonbAccessMode(
@@ -201,7 +203,8 @@ public class JohnzonBuilder implements JsonbBuilder {
.orElseGet(() -> new
FieldAndMethodAccessMode(true, true, false)),
config.getProperty("johnzon.failOnMissingCreatorValues")
.map(it -> String.class.isInstance(it) ?
Boolean.parseBoolean(it.toString()) : Boolean.class.cast(it))
- .orElse(true) /*spec 1.0 requirement*/));
+ .orElse(true) /*spec 1.0 requirement*/,
+ bufferProvider));
builder.setAccessMode(accessMode);
// user adapters
@@ -300,7 +303,8 @@ public class JohnzonBuilder implements JsonbBuilder {
builder.addObjectConverter(
Class.class.cast(args[0]), (ObjectConverter.Reader)
(jsonObject, targetType, parser) ->
d.deserialize(
-
JsonValueParserAdapter.createFor(jsonObject, parserFactoryProvider), new
JohnzonDeserializationContext(parser), targetType));
+
JsonValueParserAdapter.createFor(jsonObject, parserFactoryProvider),
+ new
JohnzonDeserializationContext(parser, bufferProvider), targetType));
});
});
diff --git
a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JsonbAccessMode.java
b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JsonbAccessMode.java
index f9d0ce2..e515818 100644
--- a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JsonbAccessMode.java
+++ b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JsonbAccessMode.java
@@ -81,6 +81,7 @@ import javax.json.bind.serializer.JsonbDeserializer;
import javax.json.bind.serializer.JsonbSerializer;
import javax.json.stream.JsonParserFactory;
+import org.apache.johnzon.core.BufferStrategy;
import org.apache.johnzon.core.Types;
import org.apache.johnzon.jsonb.converter.JohnzonJsonbAdapter;
import org.apache.johnzon.jsonb.converter.JsonbDateConverter;
@@ -132,6 +133,7 @@ public class JsonbAccessMode implements AccessMode,
Closeable {
throw new UnsupportedOperationException();
}
};
+ private final BufferStrategy.BufferProvider<char[]> bufferProvider;
private boolean failOnMissingCreatorValues;
private final Types types = new Types();
@@ -139,7 +141,8 @@ public class JsonbAccessMode implements AccessMode,
Closeable {
final PropertyVisibilityStrategy
visibilityStrategy, final boolean caseSensitive,
final Map<AdapterKey, Adapter<?, ?>>
defaultConverters, final JohnzonAdapterFactory factory,
final Supplier<JsonParserFactory> parserFactory,
final AccessMode delegate,
- final boolean failOnMissingCreatorValues) {
+ final boolean failOnMissingCreatorValues,
+ final BufferStrategy.BufferProvider<char[]>
bufferProvider) {
this.naming = propertyNamingStrategy;
this.order = orderValue;
this.visibility = visibilityStrategy;
@@ -149,6 +152,7 @@ public class JsonbAccessMode implements AccessMode,
Closeable {
this.factory = factory;
this.parserFactory = parserFactory;
this.failOnMissingCreatorValues = failOnMissingCreatorValues;
+ this.bufferProvider = bufferProvider;
}
@Override
@@ -512,7 +516,7 @@ public class JsonbAccessMode implements AccessMode,
Closeable {
writer = finalWriter::write;
}
- final ReaderConverters converters = new
ReaderConverters(initialWriter);
+ final ReaderConverters converters = new
ReaderConverters(initialWriter, bufferProvider);
final JsonbProperty property =
initialWriter.getAnnotation(JsonbProperty.class);
final JsonbNillable nillable =
initialWriter.getClassOrPackageAnnotation(JsonbNillable.class);
final boolean isNillable = nillable != null || (property != null
&& property.nillable());
@@ -613,7 +617,7 @@ public class JsonbAccessMode implements AccessMode,
Closeable {
private ParsingCacheEntry getClassEntry(final Class<?> clazz) {
ParsingCacheEntry cache = parsingCache.get(clazz);
if (cache == null) {
- cache = new ParsingCacheEntry(new ClassDecoratedType(clazz),
types);
+ cache = new ParsingCacheEntry(new ClassDecoratedType(clazz),
types, bufferProvider);
parsingCache.putIfAbsent(clazz, cache);
}
return cache;
@@ -720,7 +724,8 @@ public class JsonbAccessMode implements AccessMode,
Closeable {
private Adapter<?, ?> converter;
private ObjectConverter.Reader reader;
- ReaderConverters(final DecoratedType annotationHolder) {
+ ReaderConverters(final DecoratedType annotationHolder,
+ final BufferStrategy.BufferProvider<char[]>
bufferProvider) {
final JsonbTypeDeserializer deserializer =
annotationHolder.getAnnotation(JsonbTypeDeserializer.class);
final JsonbTypeAdapter adapter =
annotationHolder.getAnnotation(JsonbTypeAdapter.class);
final JsonbDateFormat dateFormat =
annotationHolder.getAnnotation(JsonbDateFormat.class);
@@ -779,7 +784,7 @@ public class JsonbAccessMode implements AccessMode,
Closeable {
final MappingParser parser, final
JsonbDeserializer jsonbDeserializer) {
return jsonbDeserializer.deserialize(
JsonValueParserAdapter.createFor(jsonValue,
parserFactory),
- new JohnzonDeserializationContext(parser),
targetType);
+ new JohnzonDeserializationContext(parser,
bufferProvider), targetType);
}
};
} else if (johnzonConverter != null) {
@@ -871,8 +876,9 @@ public class JsonbAccessMode implements AccessMode,
Closeable {
private final ReaderConverters readers;
private final WriterConverters writers;
- ParsingCacheEntry(final DecoratedType type, final Types types) {
- readers = new ReaderConverters(type);
+ ParsingCacheEntry(final DecoratedType type, final Types types,
+ final BufferStrategy.BufferProvider<char[]>
bufferProvider) {
+ readers = new ReaderConverters(type, bufferProvider);
writers = new WriterConverters(type, types);
}
}
diff --git
a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/serializer/JohnzonDeserializationContext.java
b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/serializer/JohnzonDeserializationContext.java
index 004b440..4c426e4 100644
---
a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/serializer/JohnzonDeserializationContext.java
+++
b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/serializer/JohnzonDeserializationContext.java
@@ -18,6 +18,7 @@
*/
package org.apache.johnzon.jsonb.serializer;
+import org.apache.johnzon.core.BufferStrategy;
import org.apache.johnzon.core.JsonReaderImpl;
import org.apache.johnzon.mapper.MappingParser;
@@ -26,12 +27,13 @@ import javax.json.bind.serializer.DeserializationContext;
import javax.json.stream.JsonParser;
import java.lang.reflect.Type;
-// TODO: test it
public class JohnzonDeserializationContext implements DeserializationContext {
private final MappingParser runtime;
+ private final BufferStrategy.BufferProvider<char[]> bufferProvider;
- public JohnzonDeserializationContext(final MappingParser runtime) {
+ public JohnzonDeserializationContext(final MappingParser runtime, final
BufferStrategy.BufferProvider<char[]> bufferProvider) {
this.runtime = runtime;
+ this.bufferProvider = bufferProvider;
}
@Override
@@ -45,6 +47,6 @@ public class JohnzonDeserializationContext implements
DeserializationContext {
}
private JsonValue read(final JsonParser parser) { // TODO: use jsonp 1.1
and not johnzon internals
- return new JsonReaderImpl(parser, true).readValue();
+ return new JsonReaderImpl(parser, true, bufferProvider).readValue();
}
}
