, JsonCodec> exactCodecs;
+ private final JsonCodegen codegen;
+
+ public JsonSharedRegistry(
+ boolean codegenEnabled, boolean writeNullFields, CodecRegistry customCodecs) {
+ this.customCodecs = customCodecs.copy();
+ exactCodecs = new IdentityHashMap<>();
+ codegen = codegenEnabled ? new JsonCodegen(writeNullFields) : null;
+ registerExactCodecs();
+ }
+
+ public JsonCodec createCodec(
+ Class rawType, TypeRef typeRef, JsonTypeResolver localResolver) {
+ JsonCodec customCodec = customCodecs.get(rawType);
+ if (customCodec != null) {
+ return customCodec;
+ }
+ JsonCodec codec = exactCodecs.get(rawType);
+ if (codec != null) {
+ return codec;
+ }
+ if (rawType.isEnum()) {
+ return new ScalarCodecs.EnumCodec(rawType);
+ }
+ if (rawType.isArray()) {
+ return ArrayCodec.create(rawType.getComponentType(), localResolver);
+ }
+ if (rawType == Optional.class) {
+ return new ScalarCodecs.OptionalCodec(
+ CodecUtils.elementType(typeRef.getType()), localResolver);
+ }
+ if (rawType == AtomicReference.class) {
+ return new ScalarCodecs.AtomicReferenceCodec(
+ CodecUtils.elementType(typeRef.getType()), localResolver);
+ }
+ if (Calendar.class.isAssignableFrom(rawType)) {
+ return ScalarCodecs.CalendarCodec.INSTANCE;
+ }
+ if (Date.class.isAssignableFrom(rawType)) {
+ return ScalarCodecs.DateCodec.INSTANCE;
+ }
+ if (ZoneId.class.isAssignableFrom(rawType)) {
+ return ScalarCodecs.ZoneIdCodec.INSTANCE;
+ }
+ if (ByteBuffer.class.isAssignableFrom(rawType)) {
+ return ScalarCodecs.ByteBufferCodec.INSTANCE;
+ }
+ if (Collection.class.isAssignableFrom(rawType)) {
+ return CollectionCodec.create(rawType, typeRef, localResolver);
+ }
+ if (Map.class.isAssignableFrom(rawType)) {
+ return MapCodec.create(rawType, typeRef, localResolver);
+ }
+ return null;
+ }
+
+ public JsonFieldKind kind(Class type) {
+ if (type == boolean.class || type == Boolean.class) {
+ return JsonFieldKind.BOOLEAN;
+ }
+ if (type == byte.class || type == Byte.class) {
+ return JsonFieldKind.BYTE;
+ }
+ if (type == short.class || type == Short.class) {
+ return JsonFieldKind.SHORT;
+ }
+ if (type == int.class || type == Integer.class) {
+ return JsonFieldKind.INT;
+ }
+ if (type == long.class || type == Long.class) {
+ return JsonFieldKind.LONG;
+ }
+ if (type == float.class || type == Float.class) {
+ return JsonFieldKind.FLOAT;
+ }
+ if (type == double.class || type == Double.class) {
+ return JsonFieldKind.DOUBLE;
+ }
+ if (type == char.class || type == Character.class) {
+ return JsonFieldKind.CHAR;
+ }
+ if (type == String.class) {
+ return JsonFieldKind.STRING;
+ }
+ if (type.isEnum()) {
+ return JsonFieldKind.ENUM;
+ }
+ if (type.isArray()) {
+ return JsonFieldKind.ARRAY;
+ }
+ if (Collection.class.isAssignableFrom(type)) {
+ return JsonFieldKind.COLLECTION;
+ }
+ if (Map.class.isAssignableFrom(type)) {
+ return JsonFieldKind.MAP;
+ }
+ return JsonFieldKind.OBJECT;
+ }
+
+ public ObjectCodecs compileObject(BaseObjectCodec codec, JsonTypeResolver localResolver) {
+ return codegen == null ? null : codegen.compile(codec, localResolver);
+ }
+
+ private void registerExactCodecs() {
+ exactCodecs.put(Object.class, ScalarCodecs.NaturalCodec.INSTANCE);
+ exactCodecs.put(void.class, ScalarCodecs.VoidCodec.INSTANCE);
+ exactCodecs.put(Void.class, ScalarCodecs.VoidCodec.INSTANCE);
+ exactCodecs.put(String.class, ScalarCodecs.StringCodec.INSTANCE);
+ exactCodecs.put(boolean.class, ScalarCodecs.BooleanCodec.INSTANCE);
+ exactCodecs.put(Boolean.class, ScalarCodecs.BooleanCodec.INSTANCE);
+ exactCodecs.put(int.class, ScalarCodecs.IntCodec.INSTANCE);
+ exactCodecs.put(Integer.class, ScalarCodecs.IntCodec.INSTANCE);
+ exactCodecs.put(long.class, ScalarCodecs.LongCodec.INSTANCE);
+ exactCodecs.put(Long.class, ScalarCodecs.LongCodec.INSTANCE);
+ exactCodecs.put(short.class, ScalarCodecs.ShortCodec.INSTANCE);
+ exactCodecs.put(Short.class, ScalarCodecs.ShortCodec.INSTANCE);
+ exactCodecs.put(byte.class, ScalarCodecs.ByteCodec.INSTANCE);
+ exactCodecs.put(Byte.class, ScalarCodecs.ByteCodec.INSTANCE);
+ exactCodecs.put(char.class, ScalarCodecs.CharCodec.INSTANCE);
+ exactCodecs.put(Character.class, ScalarCodecs.CharCodec.INSTANCE);
+ exactCodecs.put(float.class, ScalarCodecs.FloatCodec.INSTANCE);
+ exactCodecs.put(Float.class, ScalarCodecs.FloatCodec.INSTANCE);
+ exactCodecs.put(double.class, ScalarCodecs.DoubleCodec.INSTANCE);
+ exactCodecs.put(Double.class, ScalarCodecs.DoubleCodec.INSTANCE);
+ exactCodecs.put(BigInteger.class, ScalarCodecs.BigIntegerCodec.INSTANCE);
+ exactCodecs.put(BigDecimal.class, ScalarCodecs.BigDecimalCodec.INSTANCE);
+ exactCodecs.put(Float16.class, ScalarCodecs.Float16Codec.INSTANCE);
+ exactCodecs.put(BFloat16.class, ScalarCodecs.BFloat16Codec.INSTANCE);
+ exactCodecs.put(Class.class, ScalarCodecs.ClassCodec.INSTANCE);
+ exactCodecs.put(StringBuilder.class, ScalarCodecs.StringBuilderCodec.INSTANCE);
+ exactCodecs.put(StringBuffer.class, ScalarCodecs.StringBufferCodec.INSTANCE);
+ exactCodecs.put(AtomicBoolean.class, ScalarCodecs.AtomicBooleanCodec.INSTANCE);
+ exactCodecs.put(AtomicInteger.class, ScalarCodecs.AtomicIntegerCodec.INSTANCE);
+ exactCodecs.put(AtomicLong.class, ScalarCodecs.AtomicLongCodec.INSTANCE);
+ exactCodecs.put(Currency.class, ScalarCodecs.CurrencyCodec.INSTANCE);
+ exactCodecs.put(URI.class, ScalarCodecs.UriCodec.INSTANCE);
+ exactCodecs.put(URL.class, ScalarCodecs.UrlCodec.INSTANCE);
+ exactCodecs.put(Pattern.class, ScalarCodecs.PatternCodec.INSTANCE);
+ exactCodecs.put(UUID.class, ScalarCodecs.UuidCodec.INSTANCE);
+ exactCodecs.put(Locale.class, ScalarCodecs.LocaleCodec.INSTANCE);
+ exactCodecs.put(Charset.class, ScalarCodecs.CharsetCodec.INSTANCE);
+ exactCodecs.put(Date.class, ScalarCodecs.DateCodec.INSTANCE);
+ exactCodecs.put(java.sql.Date.class, ScalarCodecs.SqlDateCodec.INSTANCE);
+ exactCodecs.put(java.sql.Time.class, ScalarCodecs.SqlTimeCodec.INSTANCE);
+ exactCodecs.put(java.sql.Timestamp.class, ScalarCodecs.TimestampCodec.INSTANCE);
+ exactCodecs.put(Calendar.class, ScalarCodecs.CalendarCodec.INSTANCE);
+ exactCodecs.put(TimeZone.class, ScalarCodecs.TimeZoneCodec.INSTANCE);
+ exactCodecs.put(LocalDate.class, ScalarCodecs.LocalDateCodec.INSTANCE);
+ exactCodecs.put(LocalTime.class, ScalarCodecs.LocalTimeCodec.INSTANCE);
+ exactCodecs.put(LocalDateTime.class, ScalarCodecs.LocalDateTimeCodec.INSTANCE);
+ exactCodecs.put(Instant.class, ScalarCodecs.InstantCodec.INSTANCE);
+ exactCodecs.put(Duration.class, ScalarCodecs.DurationCodec.INSTANCE);
+ exactCodecs.put(ZoneOffset.class, ScalarCodecs.ZoneOffsetCodec.INSTANCE);
+ exactCodecs.put(ZoneId.class, ScalarCodecs.ZoneIdCodec.INSTANCE);
+ exactCodecs.put(ZonedDateTime.class, ScalarCodecs.ZonedDateTimeCodec.INSTANCE);
+ exactCodecs.put(Year.class, ScalarCodecs.YearCodec.INSTANCE);
+ exactCodecs.put(YearMonth.class, ScalarCodecs.YearMonthCodec.INSTANCE);
+ exactCodecs.put(MonthDay.class, ScalarCodecs.MonthDayCodec.INSTANCE);
+ exactCodecs.put(Period.class, ScalarCodecs.PeriodCodec.INSTANCE);
+ exactCodecs.put(OffsetTime.class, ScalarCodecs.OffsetTimeCodec.INSTANCE);
+ exactCodecs.put(OffsetDateTime.class, ScalarCodecs.OffsetDateTimeCodec.INSTANCE);
+ exactCodecs.put(OptionalInt.class, ScalarCodecs.OptionalIntCodec.INSTANCE);
+ exactCodecs.put(OptionalLong.class, ScalarCodecs.OptionalLongCodec.INSTANCE);
+ exactCodecs.put(OptionalDouble.class, ScalarCodecs.OptionalDoubleCodec.INSTANCE);
+ exactCodecs.put(ByteBuffer.class, ScalarCodecs.ByteBufferCodec.INSTANCE);
+ }
+}
diff --git a/java/fory-json/src/main/java/org/apache/fory/json/resolver/JsonTypeInfo.java b/java/fory-json/src/main/java/org/apache/fory/json/resolver/JsonTypeInfo.java
new file mode 100644
index 0000000000..dd61f69221
--- /dev/null
+++ b/java/fory-json/src/main/java/org/apache/fory/json/resolver/JsonTypeInfo.java
@@ -0,0 +1,69 @@
+/*
+ * 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.fory.json.resolver;
+
+import java.lang.reflect.Type;
+import org.apache.fory.json.codec.JsonCodec;
+import org.apache.fory.json.meta.JsonFieldKind;
+import org.apache.fory.reflect.TypeRef;
+
+/** Immutable JSON type binding resolved and owned by {@link JsonTypeResolver}. */
+public final class JsonTypeInfo {
+ private final Type type;
+ private final TypeRef typeRef;
+ private final Class rawType;
+ private final JsonFieldKind kind;
+ private final JsonCodec codec;
+ private final boolean primitive;
+
+ JsonTypeInfo(
+ Type type, TypeRef typeRef, Class rawType, JsonFieldKind kind, JsonCodec codec) {
+ this.type = type;
+ this.typeRef = typeRef;
+ this.rawType = rawType;
+ this.kind = kind;
+ this.codec = codec;
+ primitive = rawType.isPrimitive();
+ }
+
+ public Type type() {
+ return type;
+ }
+
+ public TypeRef typeRef() {
+ return typeRef;
+ }
+
+ public Class rawType() {
+ return rawType;
+ }
+
+ public JsonFieldKind kind() {
+ return kind;
+ }
+
+ public JsonCodec codec() {
+ return codec;
+ }
+
+ public boolean primitive() {
+ return primitive;
+ }
+}
diff --git a/java/fory-json/src/main/java/org/apache/fory/json/resolver/JsonTypeResolver.java b/java/fory-json/src/main/java/org/apache/fory/json/resolver/JsonTypeResolver.java
new file mode 100644
index 0000000000..0b23bbb38b
--- /dev/null
+++ b/java/fory-json/src/main/java/org/apache/fory/json/resolver/JsonTypeResolver.java
@@ -0,0 +1,154 @@
+/*
+ * 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.fory.json.resolver;
+
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import org.apache.fory.json.codec.BaseObjectCodec;
+import org.apache.fory.json.codec.CodecUtils;
+import org.apache.fory.json.codec.JsonCodec;
+import org.apache.fory.json.codec.ObjectCodec;
+import org.apache.fory.json.codec.ObjectCodecs;
+import org.apache.fory.reflect.TypeRef;
+
+/**
+ * Local JSON type dispatcher and cache used by one borrowed {@code ForyJson} state at a time.
+ *
+ * This cache is limited to schema/static metadata such as resolved codecs and object layouts.
+ * Runtime JSON values, including non-enumerated string or number values/tokens, must stay uncached.
+ */
+public final class JsonTypeResolver {
+ private final IdentityHashMap, BaseObjectCodec> objectCodecs = new IdentityHashMap<>();
+ private final Map typeInfos = new HashMap<>();
+ private final JsonSharedRegistry sharedRegistry;
+
+ private enum RuntimeObjectKey {
+ INSTANCE
+ }
+
+ public JsonTypeResolver(JsonSharedRegistry sharedRegistry) {
+ this.sharedRegistry = sharedRegistry;
+ }
+
+ public BaseObjectCodec getObjectCodec(Class type) {
+ BaseObjectCodec codec = objectCodecs.get(type);
+ if (codec != null) {
+ return codec;
+ }
+ return buildObjectCodec(type);
+ }
+
+ public JsonTypeInfo getTypeInfo(Type declaredType, Class fallback) {
+ Class rawType = CodecUtils.rawType(declaredType, fallback);
+ Object key = typeInfoKey(declaredType, rawType);
+ JsonTypeInfo typeInfo = typeInfos.get(key);
+ if (typeInfo != null) {
+ return typeInfo;
+ }
+ return buildTypeInfo(key, rawType, declaredType);
+ }
+
+ public JsonTypeInfo getRuntimeTypeInfo(Class runtimeType) {
+ Object key = runtimeType == Object.class ? RuntimeObjectKey.INSTANCE : runtimeType;
+ JsonTypeInfo typeInfo = typeInfos.get(key);
+ if (typeInfo != null) {
+ return typeInfo;
+ }
+ return buildRuntimeTypeInfo(key, runtimeType);
+ }
+
+ private BaseObjectCodec buildObjectCodec(Class type) {
+ BaseObjectCodec cached = objectCodecs.get(type);
+ if (cached != null) {
+ return cached;
+ }
+ ObjectCodec codec = BaseObjectCodec.build(type);
+ // Codegen may ask for nested object metadata that points back to this type.
+ // Publishing before compiling keeps recursive ownership in this resolver cache.
+ objectCodecs.put(type, codec);
+ try {
+ codec.resolveTypes(this);
+ ObjectCodecs codecs = sharedRegistry.compileObject(codec, this);
+ if (codecs != null) {
+ BaseObjectCodec generated = codec.withCodecs(codecs);
+ objectCodecs.put(type, generated);
+ return generated;
+ }
+ return codec;
+ } catch (RuntimeException | Error e) {
+ objectCodecs.remove(type, codec);
+ throw e;
+ }
+ }
+
+ private JsonTypeInfo buildTypeInfo(Object key, Class rawType, Type declaredType) {
+ JsonTypeInfo cached = typeInfos.get(key);
+ if (cached != null) {
+ return cached;
+ }
+ JsonTypeInfo typeInfo = buildTypeInfo(rawType, declaredType);
+ typeInfos.put(key, typeInfo);
+ return typeInfo;
+ }
+
+ private JsonTypeInfo buildTypeInfo(Class rawType, Type declaredType) {
+ TypeRef typeRef = typeRef(declaredType, rawType);
+ JsonCodec codec = sharedRegistry.createCodec(rawType, typeRef, this);
+ if (codec == null) {
+ codec = getObjectCodec(rawType);
+ }
+ return new JsonTypeInfo(declaredType, typeRef, rawType, sharedRegistry.kind(rawType), codec);
+ }
+
+ private JsonTypeInfo buildRuntimeTypeInfo(Object key, Class rawType) {
+ JsonTypeInfo cached = typeInfos.get(key);
+ if (cached != null) {
+ return cached;
+ }
+ TypeRef typeRef = TypeRef.of(rawType);
+ JsonCodec codec =
+ rawType == Object.class
+ ? getObjectCodec(Object.class)
+ : sharedRegistry.createCodec(rawType, typeRef, this);
+ if (codec == null) {
+ codec = getObjectCodec(rawType);
+ }
+ JsonTypeInfo typeInfo =
+ new JsonTypeInfo(rawType, typeRef, rawType, sharedRegistry.kind(rawType), codec);
+ typeInfos.put(key, typeInfo);
+ return typeInfo;
+ }
+
+ private static Object typeInfoKey(Type declaredType, Class rawType) {
+ if (declaredType instanceof Class) {
+ return rawType;
+ }
+ return declaredType;
+ }
+
+ private static TypeRef typeRef(Type declaredType, Class rawType) {
+ if (declaredType == null || declaredType == Object.class && rawType != Object.class) {
+ return TypeRef.of(rawType);
+ }
+ return TypeRef.of(declaredType);
+ }
+}
diff --git a/java/fory-json/src/main/java/org/apache/fory/json/writer/GeneratedObjectWriter.java b/java/fory-json/src/main/java/org/apache/fory/json/writer/GeneratedObjectWriter.java
new file mode 100644
index 0000000000..130ae08812
--- /dev/null
+++ b/java/fory-json/src/main/java/org/apache/fory/json/writer/GeneratedObjectWriter.java
@@ -0,0 +1,34 @@
+/*
+ * 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.fory.json.writer;
+
+import org.apache.fory.json.codec.JsonCodec;
+import org.apache.fory.json.meta.JsonFieldInfo;
+
+/** Immutable metadata carrier shared by generated JSON object writers. */
+public abstract class GeneratedObjectWriter {
+ protected final JsonFieldInfo[] fields;
+ protected final JsonCodec[] codecs;
+
+ protected GeneratedObjectWriter(JsonFieldInfo[] fields, JsonCodec[] codecs) {
+ this.fields = fields;
+ this.codecs = codecs;
+ }
+}
diff --git a/java/fory-json/src/main/java/org/apache/fory/json/writer/JsonStringEscaper.java b/java/fory-json/src/main/java/org/apache/fory/json/writer/JsonStringEscaper.java
new file mode 100644
index 0000000000..4bd812ec18
--- /dev/null
+++ b/java/fory-json/src/main/java/org/apache/fory/json/writer/JsonStringEscaper.java
@@ -0,0 +1,115 @@
+/*
+ * 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.fory.json.writer;
+
+import java.nio.charset.StandardCharsets;
+import org.apache.fory.json.ForyJsonException;
+
+public final class JsonStringEscaper {
+ private JsonStringEscaper() {}
+
+ public static String escapedNamePrefix(String name, boolean escapeNonLatin1) {
+ StringBuilder builder = new StringBuilder(name.length() + 3);
+ appendQuoted(builder, name, escapeNonLatin1);
+ builder.append(':');
+ return builder.toString();
+ }
+
+ public static byte[] stringValue(String value) {
+ return escapedString(value, true).getBytes(StandardCharsets.ISO_8859_1);
+ }
+
+ public static byte[] utf8Value(String value) {
+ return escapedString(value, false).getBytes(StandardCharsets.UTF_8);
+ }
+
+ private static String escapedString(String value, boolean escapeNonLatin1) {
+ StringBuilder builder = new StringBuilder(value.length() + 2);
+ appendQuoted(builder, value, escapeNonLatin1);
+ return builder.toString();
+ }
+
+ private static void appendQuoted(StringBuilder builder, String value, boolean escapeNonLatin1) {
+ builder.append('"');
+ int length = value.length();
+ for (int i = 0; i < length; i++) {
+ char ch = value.charAt(i);
+ switch (ch) {
+ case '"':
+ builder.append("\\\"");
+ break;
+ case '\\':
+ builder.append("\\\\");
+ break;
+ case '\b':
+ builder.append("\\b");
+ break;
+ case '\f':
+ builder.append("\\f");
+ break;
+ case '\n':
+ builder.append("\\n");
+ break;
+ case '\r':
+ builder.append("\\r");
+ break;
+ case '\t':
+ builder.append("\\t");
+ break;
+ default:
+ if (Character.isHighSurrogate(ch)) {
+ if (i + 1 >= length) {
+ throw new ForyJsonException("Unpaired high surrogate in string");
+ }
+ char low = value.charAt(++i);
+ if (!Character.isLowSurrogate(low)) {
+ throw new ForyJsonException("Unpaired high surrogate in string");
+ }
+ if (escapeNonLatin1) {
+ appendUnicodeEscape(builder, ch);
+ appendUnicodeEscape(builder, low);
+ } else {
+ builder.append(ch);
+ builder.append(low);
+ }
+ } else if (Character.isLowSurrogate(ch)) {
+ throw new ForyJsonException("Unpaired low surrogate in string");
+ } else if (ch < 0x20 || escapeNonLatin1 && ch > 0xff) {
+ appendUnicodeEscape(builder, ch);
+ } else {
+ builder.append(ch);
+ }
+ }
+ }
+ builder.append('"');
+ }
+
+ private static void appendUnicodeEscape(StringBuilder builder, char ch) {
+ builder.append("\\u");
+ builder.append(hex((ch >>> 12) & 0xF));
+ builder.append(hex((ch >>> 8) & 0xF));
+ builder.append(hex((ch >>> 4) & 0xF));
+ builder.append(hex(ch & 0xF));
+ }
+
+ private static char hex(int value) {
+ return (char) (value < 10 ? '0' + value : 'a' + value - 10);
+ }
+}
diff --git a/java/fory-json/src/main/java/org/apache/fory/json/writer/JsonWriter.java b/java/fory-json/src/main/java/org/apache/fory/json/writer/JsonWriter.java
new file mode 100644
index 0000000000..f849538978
--- /dev/null
+++ b/java/fory-json/src/main/java/org/apache/fory/json/writer/JsonWriter.java
@@ -0,0 +1,70 @@
+/*
+ * 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.fory.json.writer;
+
+import org.apache.fory.json.meta.JsonFieldInfo;
+
+public abstract class JsonWriter {
+ private final boolean writeNullFields;
+
+ JsonWriter(boolean writeNullFields) {
+ this.writeNullFields = writeNullFields;
+ }
+
+ public final boolean writeNullFields() {
+ return writeNullFields;
+ }
+
+ public abstract void writeNull();
+
+ public abstract void writeBoolean(boolean value);
+
+ public abstract void writeInt(int value);
+
+ public abstract void writeLong(long value);
+
+ public abstract void writeFloat(float value);
+
+ public abstract void writeDouble(double value);
+
+ public abstract void writeNumber(String value);
+
+ public abstract void writeChar(char value);
+
+ public abstract void writeString(String value);
+
+ public abstract void writeFieldName(String name);
+
+ public abstract void writeFieldName(JsonFieldInfo field);
+
+ public abstract void writeIntFieldName(int value);
+
+ public abstract void writeLongFieldName(long value);
+
+ public abstract void writeObjectStart();
+
+ public abstract void writeObjectEnd();
+
+ public abstract void writeArrayStart();
+
+ public abstract void writeArrayEnd();
+
+ public abstract void writeComma(int index);
+}
diff --git a/java/fory-json/src/main/java/org/apache/fory/json/writer/StringJsonWriter.java b/java/fory-json/src/main/java/org/apache/fory/json/writer/StringJsonWriter.java
new file mode 100644
index 0000000000..ebe10dcffc
--- /dev/null
+++ b/java/fory-json/src/main/java/org/apache/fory/json/writer/StringJsonWriter.java
@@ -0,0 +1,1151 @@
+/*
+ * 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.fory.json.writer;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import org.apache.fory.json.ForyJsonException;
+import org.apache.fory.json.meta.JsonFieldInfo;
+import org.apache.fory.memory.LittleEndian;
+import org.apache.fory.memory.NativeByteOrder;
+import org.apache.fory.serializer.StringSerializer;
+
+public final class StringJsonWriter extends JsonWriter {
+ private static final byte LATIN1 = 0;
+ private static final byte UTF16 = 1;
+ private static final int RETAINED_CAPACITY = 8192;
+ private static final byte[] MIN_INT_BYTES = "-2147483648".getBytes(StandardCharsets.ISO_8859_1);
+ private static final byte[] MIN_LONG_BYTES =
+ "-9223372036854775808".getBytes(StandardCharsets.ISO_8859_1);
+ private static final long HIGH_BITS = 0x8080808080808080L;
+ private static final int INT_HIGH_BITS = 0x80808080;
+ private static final long ASCII_CONTROL_OFFSET = 0x6060606060606060L;
+ private static final int INT_ASCII_CONTROL_OFFSET = 0x60606060;
+ private static final long ONE_BYTES = 0x0101010101010101L;
+ private static final int INT_ONE_BYTES = 0x01010101;
+ private static final long QUOTE_BYTES_COMPLEMENT = ~0x2222222222222222L;
+ private static final int INT_QUOTE_BYTES_COMPLEMENT = ~0x22222222;
+ private static final long BACKSLASH_BYTES_COMPLEMENT = ~0x5C5C5C5C5C5C5C5CL;
+ private static final int INT_BACKSLASH_BYTES_COMPLEMENT = ~0x5C5C5C5C;
+ private static final byte[] DIGIT_HUNDREDS = new byte[1000];
+ private static final byte[] DIGIT_TENS = new byte[1000];
+ private static final byte[] DIGIT_ONES = new byte[1000];
+ private static final int[] DIGIT_TRIPLES = new int[1000];
+ private static final int[] DIGIT_QUADS = new int[10000];
+ private static final long UTF16_BYTE_MASK = 0x00FF00FF00FF00FFL;
+ private static final long UTF16_PAIR_MASK = 0x0000FFFF0000FFFFL;
+ private static final boolean STRING_BYTES_BACKED = StringSerializer.isBytesBackedString();
+ private static final boolean LITTLE_ENDIAN = NativeByteOrder.IS_LITTLE_ENDIAN;
+
+ static {
+ for (int i = 0; i < 1000; i++) {
+ int c0 = '0' + i / 100;
+ int c1 = '0' + (i / 10) % 10;
+ int c2 = '0' + i % 10;
+ DIGIT_HUNDREDS[i] = (byte) c0;
+ DIGIT_TENS[i] = (byte) c1;
+ DIGIT_ONES[i] = (byte) c2;
+ int skip = i < 10 ? 2 : i < 100 ? 1 : 0;
+ DIGIT_TRIPLES[i] = skip | (c0 << 8) | (c1 << 16) | (c2 << 24);
+ }
+ for (int i = 0; i < 10000; i++) {
+ int high = i / 100;
+ int low = i - high * 100;
+ int c0 = '0' + high / 10;
+ int c1 = '0' + high % 10;
+ int c2 = '0' + low / 10;
+ int c3 = '0' + low % 10;
+ DIGIT_QUADS[i] = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
+ }
+ }
+
+ private byte[] buffer;
+ private byte[] scratch;
+ private byte coder;
+ private int position;
+
+ public StringJsonWriter(boolean writeNullFields) {
+ this(writeNullFields, new byte[512]);
+ }
+
+ public StringJsonWriter(boolean writeNullFields, byte[] buffer) {
+ super(writeNullFields);
+ this.buffer = buffer;
+ scratch = new byte[buffer.length];
+ }
+
+ public void reset() {
+ if (buffer.length > RETAINED_CAPACITY) {
+ buffer = new byte[RETAINED_CAPACITY];
+ }
+ if (scratch.length > RETAINED_CAPACITY) {
+ scratch = new byte[RETAINED_CAPACITY];
+ }
+ coder = LATIN1;
+ position = 0;
+ }
+
+ public String toJson() {
+ // The returned String may zero-copy this exact array, so pooled writer storage is never
+ // exposed.
+ byte[] bytes = Arrays.copyOf(buffer, position);
+ return StringSerializer.newBytesStringZeroCopy(coder, bytes);
+ }
+
+ @Override
+ public void writeNull() {
+ writeAscii("null");
+ }
+
+ @Override
+ public void writeBoolean(boolean value) {
+ writeAscii(value ? "true" : "false");
+ }
+
+ @Override
+ public void writeInt(int value) {
+ if (coder == LATIN1) {
+ ensure(11);
+ writeIntLatin1NoEnsure(value);
+ return;
+ }
+ ensure(22);
+ writeIntUtf16NoEnsure(value);
+ }
+
+ @Override
+ public void writeLong(long value) {
+ if (coder == LATIN1) {
+ writeLongLatin1(value);
+ return;
+ }
+ writeLongUtf16(value);
+ }
+
+ private void writeLongLatin1(long value) {
+ if (value == Long.MIN_VALUE) {
+ writeRaw(MIN_LONG_BYTES);
+ return;
+ }
+ ensure(20);
+ if (value < 0) {
+ buffer[position++] = (byte) '-';
+ value = -value;
+ }
+ if (value <= Integer.MAX_VALUE) {
+ writePositiveIntNoEnsure((int) value);
+ return;
+ }
+ int start = position;
+ do {
+ buffer[position++] = (byte) ('0' + value % 10);
+ value /= 10;
+ } while (value != 0);
+ reverse(start, position - 1);
+ }
+
+ @Override
+ public void writeFloat(float value) {
+ if (!Float.isFinite(value)) {
+ throw new ForyJsonException("JSON does not support non-finite float " + value);
+ }
+ writeAscii(Float.toString(value));
+ }
+
+ @Override
+ public void writeDouble(double value) {
+ if (!Double.isFinite(value)) {
+ throw new ForyJsonException("JSON does not support non-finite double " + value);
+ }
+ writeAscii(Double.toString(value));
+ }
+
+ @Override
+ public void writeNumber(String value) {
+ writeAscii(value);
+ }
+
+ @Override
+ public void writeChar(char value) {
+ if (Character.isSurrogate(value)) {
+ throw new ForyJsonException("JSON char cannot be a surrogate: " + Integer.toHexString(value));
+ }
+ writeByteRaw((byte) '"');
+ writeEscapedChar(value);
+ writeByteRaw((byte) '"');
+ }
+
+ @Override
+ public void writeString(String value) {
+ if (coder == LATIN1) {
+ writeStringLatin1(value);
+ return;
+ }
+ writeStringUtf16(value);
+ }
+
+ private void writeStringLatin1(String value) {
+ if (STRING_BYTES_BACKED) {
+ byte[] bytes = StringSerializer.getStringBytes(value);
+ byte stringCoder = StringSerializer.getStringCoder(value);
+ if (StringSerializer.isLatin1Coder(stringCoder)) {
+ ensure(bytes.length + 2);
+ writeLatin1StringNoEnsure(bytes);
+ return;
+ }
+ }
+ ensure(value.length() * 6 + 2);
+ writeStringCharsNoEnsure(value);
+ }
+
+ @Override
+ public void writeFieldName(String name) {
+ writeString(name);
+ writeByteRaw((byte) ':');
+ }
+
+ @Override
+ public void writeFieldName(JsonFieldInfo field) {
+ writeRaw(field.stringNamePrefix());
+ }
+
+ public void writeFieldName(JsonFieldInfo field, int index) {
+ writeRaw(index == 0 ? field.stringNamePrefix() : field.stringCommaNamePrefix());
+ }
+
+ @Override
+ public void writeIntFieldName(int value) {
+ writeByteRaw((byte) '"');
+ writeInt(value);
+ writeByteRaw((byte) '"');
+ writeByteRaw((byte) ':');
+ }
+
+ @Override
+ public void writeLongFieldName(long value) {
+ writeByteRaw((byte) '"');
+ writeLong(value);
+ writeByteRaw((byte) '"');
+ writeByteRaw((byte) ':');
+ }
+
+ public void writeBooleanField(
+ byte[] namePrefix, byte[] commaNamePrefix, int index, boolean value) {
+ byte[] prefix = index == 0 ? namePrefix : commaNamePrefix;
+ if (coder == UTF16) {
+ writeBooleanFieldUtf16(prefix, value);
+ return;
+ }
+ ensure(prefix.length + 5);
+ writeRawLatin1NoEnsure(prefix);
+ writeAsciiLatin1NoEnsure(value ? "true" : "false");
+ }
+
+ private void writeBooleanFieldUtf16(byte[] prefix, boolean value) {
+ ensure((prefix.length + 5) << 1);
+ writeRawUtf16NoEnsure(prefix);
+ writeAsciiUtf16NoEnsure(value ? "true" : "false", value ? 4 : 5);
+ }
+
+ public void writeIntField(byte[] namePrefix, byte[] commaNamePrefix, int index, int value) {
+ byte[] prefix = index == 0 ? namePrefix : commaNamePrefix;
+ writeIntField(prefix, value);
+ }
+
+ public void writeIntField(byte[] prefix, int value) {
+ if (coder == LATIN1) {
+ writeIntFieldLatin1(prefix, value);
+ return;
+ }
+ writeIntFieldUtf16(prefix, value);
+ }
+
+ private void writeIntFieldLatin1(byte[] prefix, int value) {
+ ensure(prefix.length + 11);
+ writeRawLatin1NoEnsure(prefix);
+ writeIntNoEnsure(value);
+ }
+
+ private void writeIntFieldUtf16(byte[] prefix, int value) {
+ ensure((prefix.length << 1) + 22);
+ writeRawUtf16NoEnsure(prefix);
+ writeIntUtf16NoEnsure(value);
+ }
+
+ public void writeObjectIntField(byte[] namePrefix, int value) {
+ if (coder == LATIN1) {
+ writeObjectIntFieldLatin1(namePrefix, value);
+ return;
+ }
+ writeObjectIntFieldUtf16(namePrefix, value);
+ }
+
+ private void writeObjectIntFieldLatin1(byte[] namePrefix, int value) {
+ ensure(namePrefix.length + 12);
+ buffer[position++] = (byte) '{';
+ writeRawLatin1NoEnsure(namePrefix);
+ writeIntNoEnsure(value);
+ }
+
+ private void writeObjectIntFieldUtf16(byte[] namePrefix, int value) {
+ ensure(((namePrefix.length + 1) << 1) + 22);
+ writeUtf16ByteNoEnsure((byte) '{');
+ writeRawUtf16NoEnsure(namePrefix);
+ writeIntUtf16NoEnsure(value);
+ }
+
+ public void writeLongField(byte[] namePrefix, byte[] commaNamePrefix, int index, long value) {
+ byte[] prefix = index == 0 ? namePrefix : commaNamePrefix;
+ writeLongField(prefix, value);
+ }
+
+ public void writeLongField(byte[] prefix, long value) {
+ if (coder == LATIN1) {
+ writeLongFieldLatin1(prefix, value);
+ return;
+ }
+ writeLongFieldUtf16(prefix, value);
+ }
+
+ private void writeLongFieldLatin1(byte[] prefix, long value) {
+ ensure(prefix.length + 20);
+ writeRawLatin1NoEnsure(prefix);
+ writeLongNoEnsure(value);
+ }
+
+ private void writeLongFieldUtf16(byte[] prefix, long value) {
+ ensure((prefix.length << 1) + 40);
+ writeRawUtf16NoEnsure(prefix);
+ writeLongUtf16NoEnsure(value);
+ }
+
+ public void writeObjectLongField(byte[] namePrefix, long value) {
+ if (coder == LATIN1) {
+ writeObjectLongFieldLatin1(namePrefix, value);
+ return;
+ }
+ writeObjectLongFieldUtf16(namePrefix, value);
+ }
+
+ private void writeObjectLongFieldLatin1(byte[] namePrefix, long value) {
+ ensure(namePrefix.length + 21);
+ buffer[position++] = (byte) '{';
+ writeRawLatin1NoEnsure(namePrefix);
+ writeLongNoEnsure(value);
+ }
+
+ private void writeObjectLongFieldUtf16(byte[] namePrefix, long value) {
+ ensure(((namePrefix.length + 1) << 1) + 40);
+ writeUtf16ByteNoEnsure((byte) '{');
+ writeRawUtf16NoEnsure(namePrefix);
+ writeLongUtf16NoEnsure(value);
+ }
+
+ public void writeStringField(byte[] namePrefix, byte[] commaNamePrefix, int index, String value) {
+ byte[] prefix = index == 0 ? namePrefix : commaNamePrefix;
+ writeStringField(prefix, value);
+ }
+
+ public void writeStringField(byte[] prefix, String value) {
+ if (coder == LATIN1) {
+ writeStringFieldLatin1(prefix, value);
+ return;
+ }
+ writeStringFieldUtf16(prefix, value);
+ }
+
+ private void writeStringFieldLatin1(byte[] prefix, String value) {
+ if (STRING_BYTES_BACKED) {
+ byte[] bytes = StringSerializer.getStringBytes(value);
+ byte stringCoder = StringSerializer.getStringCoder(value);
+ if (StringSerializer.isLatin1Coder(stringCoder)) {
+ ensure(prefix.length + bytes.length + 2);
+ writeRawLatin1NoEnsure(prefix);
+ writeLatin1StringNoEnsure(bytes);
+ return;
+ }
+ }
+ ensure(prefix.length + value.length() * 6 + 2);
+ writeRawLatin1NoEnsure(prefix);
+ writeStringCharsNoEnsure(value);
+ }
+
+ private void writeStringFieldUtf16(byte[] prefix, String value) {
+ ensure(prefix.length << 1);
+ writeRawUtf16NoEnsure(prefix);
+ writeString(value);
+ }
+
+ public void writeStringElement(int index, String value) {
+ int comma = index == 0 ? 0 : 1;
+ if (value == null) {
+ writeNullStringElement(comma);
+ return;
+ }
+ if (coder == LATIN1) {
+ writeStringElementLatin1(comma, value);
+ return;
+ }
+ writeStringElementUtf16(comma, value);
+ }
+
+ private void writeNullStringElement(int comma) {
+ if (coder == UTF16) {
+ ensure((comma + 4) << 1);
+ if (comma != 0) {
+ writeUtf16ByteNoEnsure((byte) ',');
+ }
+ writeAsciiUtf16NoEnsure("null", 4);
+ return;
+ }
+ ensure(comma + 4);
+ if (comma != 0) {
+ buffer[position++] = ',';
+ }
+ writeAsciiLatin1NoEnsure("null");
+ }
+
+ private void writeStringElementLatin1(int comma, String value) {
+ if (STRING_BYTES_BACKED) {
+ byte[] bytes = StringSerializer.getStringBytes(value);
+ if (StringSerializer.isLatin1Coder(StringSerializer.getStringCoder(value))) {
+ ensure(comma + bytes.length + 2);
+ if (comma != 0) {
+ buffer[position++] = ',';
+ }
+ writeLatin1StringNoEnsure(bytes);
+ return;
+ }
+ }
+ ensure(comma + value.length() * 6 + 2);
+ if (comma != 0) {
+ buffer[position++] = ',';
+ }
+ writeStringNoEnsure(value);
+ }
+
+ private void writeStringElementUtf16(int comma, String value) {
+ ensure(comma << 1);
+ if (comma != 0) {
+ writeUtf16ByteNoEnsure((byte) ',');
+ }
+ writeStringUtf16(value);
+ }
+
+ public void writeRawValue(byte[] value) {
+ writeRaw(value);
+ }
+
+ @Override
+ public void writeObjectStart() {
+ writeByteRaw((byte) '{');
+ }
+
+ @Override
+ public void writeObjectEnd() {
+ writeByteRaw((byte) '}');
+ }
+
+ @Override
+ public void writeArrayStart() {
+ writeByteRaw((byte) '[');
+ }
+
+ @Override
+ public void writeArrayEnd() {
+ writeByteRaw((byte) ']');
+ }
+
+ @Override
+ public void writeComma(int index) {
+ if (index != 0) {
+ writeByteRaw((byte) ',');
+ }
+ }
+
+ private void writeStringNoEnsure(String value) {
+ if (coder == LATIN1) {
+ if (STRING_BYTES_BACKED) {
+ byte[] bytes = StringSerializer.getStringBytes(value);
+ byte stringCoder = StringSerializer.getStringCoder(value);
+ if (StringSerializer.isLatin1Coder(stringCoder)) {
+ writeLatin1StringNoEnsure(bytes);
+ return;
+ }
+ }
+ writeStringCharsNoEnsure(value);
+ return;
+ }
+ writeStringUtf16(value);
+ }
+
+ private void writeStringCharsNoEnsure(String value) {
+ int length = value.length();
+ byte[] bytes = buffer;
+ int pos = position;
+ bytes[pos++] = (byte) '"';
+ int i = 0;
+ while (i + 4 <= length) {
+ char c0 = value.charAt(i);
+ char c1 = value.charAt(i + 1);
+ char c2 = value.charAt(i + 2);
+ char c3 = value.charAt(i + 3);
+ if (isJsonLatin1(c0) && isJsonLatin1(c1) && isJsonLatin1(c2) && isJsonLatin1(c3)) {
+ bytes[pos] = (byte) c0;
+ bytes[pos + 1] = (byte) c1;
+ bytes[pos + 2] = (byte) c2;
+ bytes[pos + 3] = (byte) c3;
+ pos += 4;
+ i += 4;
+ } else {
+ break;
+ }
+ }
+ while (i < length) {
+ char ch = value.charAt(i);
+ if (isJsonLatin1(ch)) {
+ bytes[pos++] = (byte) ch;
+ i++;
+ } else {
+ position = pos;
+ writeStringSlow(value, i, length);
+ return;
+ }
+ }
+ bytes[pos++] = (byte) '"';
+ position = pos;
+ }
+
+ private void writeLatin1StringNoEnsure(byte[] value) {
+ int length = value.length;
+ byte[] bytes = buffer;
+ int pos = position;
+ bytes[pos++] = (byte) '"';
+ int i = 0;
+ int upperBound = length & ~15;
+ for (; i < upperBound; i += 16) {
+ long word0 = LittleEndian.getInt64(value, i);
+ long word1 = LittleEndian.getInt64(value, i + 8);
+ if (!isJsonAsciiWord(word0) || !isJsonAsciiWord(word1)) {
+ break;
+ }
+ LittleEndian.putInt64(bytes, pos, word0);
+ LittleEndian.putInt64(bytes, pos + 8, word1);
+ pos += 16;
+ }
+ upperBound = length & ~7;
+ for (; i < upperBound; i += 8) {
+ long word = LittleEndian.getInt64(value, i);
+ if (!isJsonAsciiWord(word)) {
+ break;
+ }
+ LittleEndian.putInt64(bytes, pos, word);
+ pos += 8;
+ }
+ if (i + 4 <= length) {
+ int word = LittleEndian.getInt32(value, i);
+ if (isJsonAsciiInt(word)) {
+ LittleEndian.putInt32(bytes, pos, word);
+ pos += 4;
+ i += 4;
+ }
+ }
+ while (i < length) {
+ byte ch = value[i];
+ if (isJsonLatin1Byte(ch)) {
+ bytes[pos++] = ch;
+ i++;
+ } else {
+ position = pos;
+ writeLatin1StringSlow(value, i, length);
+ return;
+ }
+ }
+ bytes[pos++] = (byte) '"';
+ position = pos;
+ }
+
+ private void writeStringSlow(String value, int index, int length) {
+ for (int i = index; i < length; i++) {
+ char ch = value.charAt(i);
+ if (Character.isHighSurrogate(ch)) {
+ if (i + 1 >= length) {
+ throw new ForyJsonException("Unpaired high surrogate in string");
+ }
+ char low = value.charAt(++i);
+ if (!Character.isLowSurrogate(low)) {
+ throw new ForyJsonException("Unpaired high surrogate in string");
+ }
+ writeCharRaw(ch);
+ writeCharRaw(low);
+ } else if (Character.isLowSurrogate(ch)) {
+ throw new ForyJsonException("Unpaired low surrogate in string");
+ } else {
+ writeEscapedChar(ch);
+ }
+ }
+ writeByteRaw((byte) '"');
+ }
+
+ private void writeLatin1StringSlow(byte[] value, int index, int length) {
+ for (int i = index; i < length; i++) {
+ writeEscapedChar((char) (value[i] & 0xff));
+ }
+ writeByteRaw((byte) '"');
+ }
+
+ private void writeEscapedChar(char ch) {
+ switch (ch) {
+ case '"':
+ writeAscii("\\\"");
+ return;
+ case '\\':
+ writeAscii("\\\\");
+ return;
+ case '\b':
+ writeAscii("\\b");
+ return;
+ case '\f':
+ writeAscii("\\f");
+ return;
+ case '\n':
+ writeAscii("\\n");
+ return;
+ case '\r':
+ writeAscii("\\r");
+ return;
+ case '\t':
+ writeAscii("\\t");
+ return;
+ default:
+ if (ch < 0x20) {
+ writeUnicodeEscape(ch);
+ } else {
+ writeCharRaw(ch);
+ }
+ }
+ }
+
+ private void writeStringUtf16(String value) {
+ int length = value.length();
+ ensure((length + 2) << 1);
+ writeUtf16ByteNoEnsure((byte) '"');
+ for (int i = 0; i < length; i++) {
+ char ch = value.charAt(i);
+ if (isJsonUtf16(ch)) {
+ writeUtf16CharNoEnsure(ch);
+ } else {
+ writeStringUtf16Slow(value, i, length);
+ return;
+ }
+ }
+ writeByteRaw((byte) '"');
+ }
+
+ private void writeStringUtf16Slow(String value, int index, int length) {
+ for (int i = index; i < length; i++) {
+ char ch = value.charAt(i);
+ if (Character.isHighSurrogate(ch)) {
+ if (i + 1 >= length) {
+ throw new ForyJsonException("Unpaired high surrogate in string");
+ }
+ char low = value.charAt(++i);
+ if (!Character.isLowSurrogate(low)) {
+ throw new ForyJsonException("Unpaired high surrogate in string");
+ }
+ ensure(4);
+ writeUtf16CharNoEnsure(ch);
+ writeUtf16CharNoEnsure(low);
+ } else if (Character.isLowSurrogate(ch)) {
+ throw new ForyJsonException("Unpaired low surrogate in string");
+ } else {
+ writeEscapedChar(ch);
+ }
+ }
+ writeByteRaw((byte) '"');
+ }
+
+ private void writeUnicodeEscape(char ch) {
+ if (coder == UTF16) {
+ ensure(12);
+ writeUtf16ByteNoEnsure((byte) '\\');
+ writeUtf16ByteNoEnsure((byte) 'u');
+ writeUtf16CharNoEnsure(hex((ch >>> 12) & 0xF));
+ writeUtf16CharNoEnsure(hex((ch >>> 8) & 0xF));
+ writeUtf16CharNoEnsure(hex((ch >>> 4) & 0xF));
+ writeUtf16CharNoEnsure(hex(ch & 0xF));
+ } else {
+ ensure(6);
+ buffer[position++] = '\\';
+ buffer[position++] = 'u';
+ buffer[position++] = (byte) hex((ch >>> 12) & 0xF);
+ buffer[position++] = (byte) hex((ch >>> 8) & 0xF);
+ buffer[position++] = (byte) hex((ch >>> 4) & 0xF);
+ buffer[position++] = (byte) hex(ch & 0xF);
+ }
+ }
+
+ private void writeAscii(String value) {
+ int length = value.length();
+ if (coder == LATIN1) {
+ ensure(length);
+ writeAsciiNoEnsure(value);
+ return;
+ }
+ writeAsciiUtf16(value, length);
+ }
+
+ private void writeAsciiNoEnsure(String value) {
+ int length = value.length();
+ if (coder == LATIN1) {
+ for (int i = 0; i < length; i++) {
+ buffer[position++] = (byte) value.charAt(i);
+ }
+ return;
+ }
+ writeAsciiUtf16NoEnsure(value, length);
+ }
+
+ private void writeAsciiUtf16(String value, int length) {
+ ensure(length << 1);
+ writeAsciiUtf16NoEnsure(value, length);
+ }
+
+ private void writeAsciiUtf16NoEnsure(String value, int length) {
+ byte[] bytes = buffer;
+ int pos = position;
+ for (int i = 0; i < length; i++) {
+ pos = putUtf16Char(bytes, pos, value.charAt(i));
+ }
+ position = pos;
+ }
+
+ private void writeAsciiLatin1NoEnsure(String value) {
+ int length = value.length();
+ for (int i = 0; i < length; i++) {
+ buffer[position++] = (byte) value.charAt(i);
+ }
+ }
+
+ private void writeRaw(byte[] bytes) {
+ if (coder == LATIN1) {
+ ensure(bytes.length);
+ writeRawNoEnsure(bytes);
+ return;
+ }
+ writeRawUtf16(bytes);
+ }
+
+ private void writeRawNoEnsure(byte[] bytes) {
+ if (coder == LATIN1) {
+ System.arraycopy(bytes, 0, buffer, position, bytes.length);
+ position += bytes.length;
+ return;
+ }
+ writeRawUtf16NoEnsure(bytes);
+ }
+
+ private void writeRawUtf16(byte[] bytes) {
+ ensure(bytes.length << 1);
+ writeRawUtf16NoEnsure(bytes);
+ }
+
+ private void writeRawUtf16NoEnsure(byte[] bytes) {
+ byte[] target = buffer;
+ int pos = position;
+ for (byte value : bytes) {
+ pos = putUtf16Char(target, pos, (char) (value & 0xff));
+ }
+ position = pos;
+ }
+
+ private void writeRawLatin1NoEnsure(byte[] bytes) {
+ System.arraycopy(bytes, 0, buffer, position, bytes.length);
+ position += bytes.length;
+ }
+
+ private void writeByteRaw(byte value) {
+ if (coder == LATIN1) {
+ ensure(1);
+ buffer[position++] = value;
+ return;
+ }
+ writeByteRawUtf16(value);
+ }
+
+ private void writeByteRawUtf16(byte value) {
+ ensure(2);
+ writeUtf16ByteNoEnsure(value);
+ }
+
+ private void writeCharRaw(char value) {
+ if (coder == LATIN1 && value <= 0xff) {
+ ensure(1);
+ buffer[position++] = (byte) value;
+ return;
+ }
+ writeCharRawUtf16(value);
+ }
+
+ private void writeCharRawUtf16(char value) {
+ if (coder == LATIN1) {
+ upgradeToUtf16((position << 1) + 2);
+ } else {
+ ensure(2);
+ }
+ writeUtf16CharNoEnsure(value);
+ }
+
+ private void reverse(int start, int end) {
+ while (start < end) {
+ byte tmp = buffer[start];
+ buffer[start++] = buffer[end];
+ buffer[end--] = tmp;
+ }
+ }
+
+ private void reverseUtf16Chars(int start, int end) {
+ while (start < end) {
+ byte b0 = buffer[start];
+ byte b1 = buffer[start + 1];
+ buffer[start] = buffer[end];
+ buffer[start + 1] = buffer[end + 1];
+ buffer[end] = b0;
+ buffer[end + 1] = b1;
+ start += 2;
+ end -= 2;
+ }
+ }
+
+ private void writeUtf16ByteNoEnsure(byte value) {
+ position = putUtf16Char(buffer, position, (char) (value & 0xff));
+ }
+
+ private void writeUtf16CharNoEnsure(char value) {
+ position = putUtf16Char(buffer, position, value);
+ }
+
+ private static int putUtf16Char(byte[] bytes, int pos, char value) {
+ if (LITTLE_ENDIAN) {
+ bytes[pos] = (byte) value;
+ bytes[pos + 1] = (byte) (value >>> 8);
+ } else {
+ bytes[pos] = (byte) (value >>> 8);
+ bytes[pos + 1] = (byte) value;
+ }
+ return pos + 2;
+ }
+
+ private void ensure(int additional) {
+ int minCapacity = position + additional;
+ if (minCapacity > buffer.length) {
+ grow(minCapacity);
+ }
+ }
+
+ private void grow(int minCapacity) {
+ buffer = Arrays.copyOf(buffer, growCapacity(buffer.length, minCapacity));
+ }
+
+ private void upgradeToUtf16(int minCapacity) {
+ int oldPosition = position;
+ int newPosition = oldPosition << 1;
+ int required = Math.max(minCapacity, newPosition);
+ byte[] source = buffer;
+ byte[] target = scratch;
+ int minTargetCapacity = Math.max(source.length, required);
+ if (target.length < minTargetCapacity) {
+ target = growScratch(minTargetCapacity);
+ }
+ if (LITTLE_ENDIAN) {
+ widenLatin1ToUtf16LE(source, target, oldPosition);
+ } else {
+ widenLatin1ToUtf16BE(source, target, oldPosition);
+ }
+ scratch = source;
+ buffer = target;
+ coder = UTF16;
+ position = newPosition;
+ }
+
+ private byte[] growScratch(int minCapacity) {
+ return new byte[growCapacity(buffer.length, minCapacity)];
+ }
+
+ private static int growCapacity(int capacity, int minCapacity) {
+ int expanded = capacity + Math.max(capacity, 1);
+ return expanded >= minCapacity && expanded > 0 ? expanded : minCapacity;
+ }
+
+ private static void widenLatin1ToUtf16LE(byte[] source, byte[] target, int length) {
+ // JDK21 AArch64 C2 does not SuperWord-vectorize the plain byte-stride widening loop; hsdis
+ // shows scalar ldrsb/strb. Keep this explicit 8-byte widening path so the hot upgrade uses
+ // wide loads/stores without direct Unsafe in fory-json.
+ int i = 0;
+ int j = 0;
+ int bulkEnd = length & ~7;
+ for (; i < bulkEnd; i += 8, j += 16) {
+ long word = LittleEndian.getInt64(source, i);
+ LittleEndian.putInt64(target, j, spreadLatin1ToUtf16(word & 0xFFFFFFFFL));
+ LittleEndian.putInt64(target, j + 8, spreadLatin1ToUtf16(word >>> 32));
+ }
+ for (; i < length; i++, j += 2) {
+ target[j] = source[i];
+ target[j + 1] = 0;
+ }
+ }
+
+ private static void widenLatin1ToUtf16BE(byte[] source, byte[] target, int length) {
+ int i = 0;
+ int j = 0;
+ int bulkEnd = length & ~7;
+ for (; i < bulkEnd; i += 8, j += 16) {
+ long word = LittleEndian.getInt64(source, i);
+ LittleEndian.putInt64(target, j, spreadLatin1ToUtf16(word & 0xFFFFFFFFL) << 8);
+ LittleEndian.putInt64(target, j + 8, spreadLatin1ToUtf16(word >>> 32) << 8);
+ }
+ for (; i < length; i++, j += 2) {
+ target[j] = 0;
+ target[j + 1] = source[i];
+ }
+ }
+
+ private static long spreadLatin1ToUtf16(long value) {
+ value = (value | (value << 16)) & UTF16_PAIR_MASK;
+ return (value | (value << 8)) & UTF16_BYTE_MASK;
+ }
+
+ private static boolean isJsonLatin1(char ch) {
+ return ch > 0x1F && ch <= 0xff && ch != '"' && ch != '\\';
+ }
+
+ private static boolean isJsonUtf16(char ch) {
+ return ch > 0x1F && ch != '"' && ch != '\\' && !Character.isSurrogate(ch);
+ }
+
+ private static boolean isJsonLatin1Byte(byte value) {
+ int ch = value & 0xff;
+ return ch > 0x1F && ch != '"' && ch != '\\';
+ }
+
+ private static boolean isJsonAsciiWord(long word) {
+ return (((word + ASCII_CONTROL_OFFSET) & ~word) & HIGH_BITS) == HIGH_BITS
+ && (((word ^ QUOTE_BYTES_COMPLEMENT) + ONE_BYTES) & HIGH_BITS) == HIGH_BITS
+ && (((word ^ BACKSLASH_BYTES_COMPLEMENT) + ONE_BYTES) & HIGH_BITS) == HIGH_BITS;
+ }
+
+ private static boolean isJsonAsciiInt(int word) {
+ return (((word + INT_ASCII_CONTROL_OFFSET) & ~word) & INT_HIGH_BITS) == INT_HIGH_BITS
+ && (((word ^ INT_QUOTE_BYTES_COMPLEMENT) + INT_ONE_BYTES) & INT_HIGH_BITS) == INT_HIGH_BITS
+ && (((word ^ INT_BACKSLASH_BYTES_COMPLEMENT) + INT_ONE_BYTES) & INT_HIGH_BITS)
+ == INT_HIGH_BITS;
+ }
+
+ private void writeIntNoEnsure(int value) {
+ if (coder == LATIN1) {
+ writeIntLatin1NoEnsure(value);
+ return;
+ }
+ writeIntUtf16NoEnsure(value);
+ }
+
+ private void writeIntLatin1NoEnsure(int value) {
+ if (value == Integer.MIN_VALUE) {
+ writeRawLatin1NoEnsure(MIN_INT_BYTES);
+ return;
+ }
+ if (value < 0) {
+ buffer[position++] = (byte) '-';
+ value = -value;
+ }
+ writePositiveIntNoEnsure(value);
+ }
+
+ private void writeLongNoEnsure(long value) {
+ if (coder == LATIN1) {
+ writeLongLatin1NoEnsure(value);
+ return;
+ }
+ writeLongUtf16NoEnsure(value);
+ }
+
+ private void writeLongLatin1NoEnsure(long value) {
+ if (value == Long.MIN_VALUE) {
+ writeRawLatin1NoEnsure(MIN_LONG_BYTES);
+ return;
+ }
+ if (value < 0) {
+ buffer[position++] = (byte) '-';
+ value = -value;
+ }
+ if (value <= Integer.MAX_VALUE) {
+ writePositiveIntNoEnsure((int) value);
+ return;
+ }
+ int start = position;
+ do {
+ buffer[position++] = (byte) ('0' + value % 10);
+ value /= 10;
+ } while (value != 0);
+ reverse(start, position - 1);
+ }
+
+ private void writeLongUtf16(long value) {
+ ensure(40);
+ writeLongUtf16NoEnsure(value);
+ }
+
+ private void writeIntUtf16NoEnsure(int value) {
+ if (value == Integer.MIN_VALUE) {
+ writeRawUtf16NoEnsure(MIN_INT_BYTES);
+ return;
+ }
+ if (value < 0) {
+ writeUtf16ByteNoEnsure((byte) '-');
+ value = -value;
+ }
+ writePositiveIntUtf16NoEnsure(value);
+ }
+
+ private void writeLongUtf16NoEnsure(long value) {
+ if (value == Long.MIN_VALUE) {
+ writeRawUtf16NoEnsure(MIN_LONG_BYTES);
+ return;
+ }
+ if (value < 0) {
+ writeUtf16ByteNoEnsure((byte) '-');
+ value = -value;
+ }
+ if (value <= Integer.MAX_VALUE) {
+ writePositiveIntUtf16NoEnsure((int) value);
+ return;
+ }
+ int start = position;
+ do {
+ writeUtf16CharNoEnsure((char) ('0' + value % 10));
+ value /= 10;
+ } while (value != 0);
+ reverseUtf16Chars(start, position - 2);
+ }
+
+ private void writePositiveIntNoEnsure(int value) {
+ byte[] bytes = buffer;
+ int pos = position;
+ if (value < 10000) {
+ position = writeIntUpTo4(bytes, pos, value);
+ return;
+ }
+ int high = divide10000(value);
+ int low = value - high * 10000;
+ if (high < 10000) {
+ if (high >= 1000) {
+ position = writePadded8(bytes, pos, high, low);
+ return;
+ }
+ pos = writeIntUpTo4(bytes, pos, high);
+ position = writePadded4(bytes, pos, low);
+ return;
+ }
+ int top = divide10000(high);
+ int middle = high - top * 10000;
+ pos = writeIntUpTo4(bytes, pos, top);
+ position = writePadded8(bytes, pos, middle, low);
+ }
+
+ private void writePositiveIntUtf16NoEnsure(int value) {
+ if (value < 10000) {
+ writeIntUpTo4Utf16(value);
+ return;
+ }
+ int high = divide10000(value);
+ int low = value - high * 10000;
+ if (high < 10000) {
+ writeIntUpTo4Utf16(high);
+ writePadded4Utf16(low);
+ return;
+ }
+ int top = divide10000(high);
+ int middle = high - top * 10000;
+ writeIntUpTo4Utf16(top);
+ writePadded4Utf16(middle);
+ writePadded4Utf16(low);
+ }
+
+ private static int divide10000(int value) {
+ return (int) (((long) value * 1759218605L) >> 44);
+ }
+
+ private static int writeIntUpTo4(byte[] bytes, int pos, int value) {
+ if (value < 1000) {
+ return writeIntUpTo3(bytes, pos, value);
+ }
+ return writePadded4(bytes, pos, value);
+ }
+
+ private static int writeIntUpTo3(byte[] bytes, int pos, int value) {
+ int digits = DIGIT_TRIPLES[value];
+ int skip = digits & 0xFF;
+ LittleEndian.putInt32(bytes, pos, digits >>> ((skip + 1) << 3));
+ return pos + 3 - skip;
+ }
+
+ private static int writePadded4(byte[] bytes, int pos, int value) {
+ LittleEndian.putInt32(bytes, pos, DIGIT_QUADS[value]);
+ return pos + 4;
+ }
+
+ private static int writePadded8(byte[] bytes, int pos, int high, int low) {
+ long value = (DIGIT_QUADS[high] & 0xFFFFFFFFL) | ((DIGIT_QUADS[low] & 0xFFFFFFFFL) << 32);
+ LittleEndian.putInt64(bytes, pos, value);
+ return pos + 8;
+ }
+
+ private void writeIntUpTo4Utf16(int value) {
+ if (value < 10) {
+ writeUtf16ByteNoEnsure(DIGIT_ONES[value]);
+ } else if (value < 100) {
+ writeUtf16ByteNoEnsure(DIGIT_TENS[value]);
+ writeUtf16ByteNoEnsure(DIGIT_ONES[value]);
+ } else if (value < 1000) {
+ writePadded3Utf16(value);
+ } else {
+ writePadded4Utf16(value);
+ }
+ }
+
+ private void writePadded3Utf16(int value) {
+ writeUtf16ByteNoEnsure(DIGIT_HUNDREDS[value]);
+ writeUtf16ByteNoEnsure(DIGIT_TENS[value]);
+ writeUtf16ByteNoEnsure(DIGIT_ONES[value]);
+ }
+
+ private void writePadded4Utf16(int value) {
+ int high = value / 100;
+ int low = value - high * 100;
+ writeUtf16ByteNoEnsure((byte) ('0' + high / 10));
+ writeUtf16ByteNoEnsure((byte) ('0' + high % 10));
+ writeUtf16ByteNoEnsure((byte) ('0' + low / 10));
+ writeUtf16ByteNoEnsure((byte) ('0' + low % 10));
+ }
+
+ private static char hex(int value) {
+ return (char) (value < 10 ? '0' + value : 'a' + value - 10);
+ }
+}
diff --git a/java/fory-json/src/main/java/org/apache/fory/json/writer/StringObjectWriter.java b/java/fory-json/src/main/java/org/apache/fory/json/writer/StringObjectWriter.java
new file mode 100644
index 0000000000..ccee0cf237
--- /dev/null
+++ b/java/fory-json/src/main/java/org/apache/fory/json/writer/StringObjectWriter.java
@@ -0,0 +1,26 @@
+/*
+ * 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.fory.json.writer;
+
+import org.apache.fory.json.resolver.JsonTypeResolver;
+
+public interface StringObjectWriter {
+ void writeString(StringJsonWriter writer, Object value, JsonTypeResolver typeResolver);
+}
diff --git a/java/fory-json/src/main/java/org/apache/fory/json/writer/Utf8JsonWriter.java b/java/fory-json/src/main/java/org/apache/fory/json/writer/Utf8JsonWriter.java
new file mode 100644
index 0000000000..5ba1ec5e08
--- /dev/null
+++ b/java/fory-json/src/main/java/org/apache/fory/json/writer/Utf8JsonWriter.java
@@ -0,0 +1,817 @@
+/*
+ * 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.fory.json.writer;
+
+import java.util.Arrays;
+import org.apache.fory.json.ForyJsonException;
+import org.apache.fory.json.meta.JsonFieldInfo;
+import org.apache.fory.memory.LittleEndian;
+import org.apache.fory.serializer.StringSerializer;
+
+public final class Utf8JsonWriter extends JsonWriter {
+ private static final int RETAINED_CAPACITY = 8192;
+ private static final byte[] MIN_INT_BYTES =
+ "-2147483648".getBytes(java.nio.charset.StandardCharsets.ISO_8859_1);
+ private static final byte[] MIN_LONG_BYTES =
+ "-9223372036854775808".getBytes(java.nio.charset.StandardCharsets.ISO_8859_1);
+ private static final long HIGH_BITS = 0x8080808080808080L;
+ private static final int INT_HIGH_BITS = 0x80808080;
+ private static final long ASCII_CONTROL_OFFSET = 0x6060606060606060L;
+ private static final int INT_ASCII_CONTROL_OFFSET = 0x60606060;
+ private static final long ONE_BYTES = 0x0101010101010101L;
+ private static final int INT_ONE_BYTES = 0x01010101;
+ private static final long QUOTE_BYTES_COMPLEMENT = ~0x2222222222222222L;
+ private static final int INT_QUOTE_BYTES_COMPLEMENT = ~0x22222222;
+ private static final long BACKSLASH_BYTES_COMPLEMENT = ~0x5C5C5C5C5C5C5C5CL;
+ private static final int INT_BACKSLASH_BYTES_COMPLEMENT = ~0x5C5C5C5C;
+ private static final long UTF16_ASCII_MASK = 0xFF80FF80FF80FF80L;
+ private static final int[] DIGIT_TRIPLES = new int[1000];
+ private static final int[] DIGIT_QUADS = new int[10000];
+ private static final boolean STRING_BYTES_BACKED = StringSerializer.isBytesBackedString();
+
+ static {
+ for (int i = 0; i < 1000; i++) {
+ int c0 = '0' + i / 100;
+ int c1 = '0' + (i / 10) % 10;
+ int c2 = '0' + i % 10;
+ int skip = i < 10 ? 2 : i < 100 ? 1 : 0;
+ DIGIT_TRIPLES[i] = skip | (c0 << 8) | (c1 << 16) | (c2 << 24);
+ }
+ for (int i = 0; i < 10000; i++) {
+ int high = i / 100;
+ int low = i - high * 100;
+ int c0 = '0' + high / 10;
+ int c1 = '0' + high % 10;
+ int c2 = '0' + low / 10;
+ int c3 = '0' + low % 10;
+ DIGIT_QUADS[i] = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
+ }
+ }
+
+ private byte[] buffer;
+ private int position;
+
+ public Utf8JsonWriter(boolean writeNullFields) {
+ this(writeNullFields, new byte[512]);
+ }
+
+ public Utf8JsonWriter(boolean writeNullFields, byte[] buffer) {
+ super(writeNullFields);
+ this.buffer = buffer;
+ }
+
+ public void reset() {
+ if (buffer.length > RETAINED_CAPACITY) {
+ buffer = new byte[RETAINED_CAPACITY];
+ }
+ position = 0;
+ }
+
+ public byte[] toJsonBytes() {
+ return Arrays.copyOf(buffer, position);
+ }
+
+ @Override
+ public void writeNull() {
+ writeAscii("null");
+ }
+
+ @Override
+ public void writeBoolean(boolean value) {
+ writeAscii(value ? "true" : "false");
+ }
+
+ @Override
+ public void writeInt(int value) {
+ ensure(11);
+ writeIntNoEnsure(value);
+ }
+
+ @Override
+ public void writeLong(long value) {
+ if (value == Long.MIN_VALUE) {
+ writeRaw(MIN_LONG_BYTES);
+ return;
+ }
+ ensure(20);
+ if (value < 0) {
+ buffer[position++] = (byte) '-';
+ value = -value;
+ }
+ if (value <= Integer.MAX_VALUE) {
+ writePositiveIntNoEnsure((int) value);
+ return;
+ }
+ int start = position;
+ do {
+ buffer[position++] = (byte) ('0' + value % 10);
+ value /= 10;
+ } while (value != 0);
+ reverse(start, position - 1);
+ }
+
+ @Override
+ public void writeFloat(float value) {
+ if (!Float.isFinite(value)) {
+ throw new ForyJsonException("JSON does not support non-finite float " + value);
+ }
+ writeAscii(Float.toString(value));
+ }
+
+ @Override
+ public void writeDouble(double value) {
+ if (!Double.isFinite(value)) {
+ throw new ForyJsonException("JSON does not support non-finite double " + value);
+ }
+ writeAscii(Double.toString(value));
+ }
+
+ @Override
+ public void writeNumber(String value) {
+ writeAscii(value);
+ }
+
+ @Override
+ public void writeChar(char value) {
+ if (Character.isSurrogate(value)) {
+ throw new ForyJsonException("JSON char cannot be a surrogate: " + Integer.toHexString(value));
+ }
+ writeByteRaw((byte) '"');
+ writeEscapedChar(value);
+ writeByteRaw((byte) '"');
+ }
+
+ @Override
+ public void writeString(String value) {
+ if (STRING_BYTES_BACKED) {
+ byte[] bytes = StringSerializer.getStringBytes(value);
+ byte stringCoder = StringSerializer.getStringCoder(value);
+ if (StringSerializer.isLatin1Coder(stringCoder)) {
+ if (writeLatin1String(bytes)) {
+ return;
+ }
+ } else if (StringSerializer.isUtf16Coder(stringCoder)) {
+ if (writeUtf16String(bytes)) {
+ return;
+ }
+ }
+ }
+ writeStringChars(value);
+ }
+
+ private void writeStringChars(String value) {
+ int length = value.length();
+ ensure(length + 2);
+ byte[] bytes = buffer;
+ int pos = position;
+ bytes[pos++] = (byte) '"';
+ int i = 0;
+ while (i + 4 <= length) {
+ char c0 = value.charAt(i);
+ char c1 = value.charAt(i + 1);
+ char c2 = value.charAt(i + 2);
+ char c3 = value.charAt(i + 3);
+ if (isJsonAscii(c0) && isJsonAscii(c1) && isJsonAscii(c2) && isJsonAscii(c3)) {
+ bytes[pos] = (byte) c0;
+ bytes[pos + 1] = (byte) c1;
+ bytes[pos + 2] = (byte) c2;
+ bytes[pos + 3] = (byte) c3;
+ pos += 4;
+ i += 4;
+ } else {
+ break;
+ }
+ }
+ while (i < length) {
+ char ch = value.charAt(i);
+ if (isJsonAscii(ch)) {
+ bytes[pos++] = (byte) ch;
+ i++;
+ } else {
+ position = pos;
+ writeStringSlow(value, i, length);
+ return;
+ }
+ }
+ bytes[pos++] = (byte) '"';
+ position = pos;
+ }
+
+ @Override
+ public void writeFieldName(String name) {
+ writeString(name);
+ writeByteRaw((byte) ':');
+ }
+
+ @Override
+ public void writeFieldName(JsonFieldInfo field) {
+ writeRaw(field.utf8NamePrefix());
+ }
+
+ public void writeFieldName(JsonFieldInfo field, int index) {
+ writeRaw(index == 0 ? field.utf8NamePrefix() : field.utf8CommaNamePrefix());
+ }
+
+ @Override
+ public void writeIntFieldName(int value) {
+ writeByteRaw((byte) '"');
+ writeInt(value);
+ writeByteRaw((byte) '"');
+ writeByteRaw((byte) ':');
+ }
+
+ @Override
+ public void writeLongFieldName(long value) {
+ writeByteRaw((byte) '"');
+ writeLong(value);
+ writeByteRaw((byte) '"');
+ writeByteRaw((byte) ':');
+ }
+
+ public void writeBooleanField(
+ byte[] namePrefix, byte[] commaNamePrefix, int index, boolean value) {
+ byte[] prefix = index == 0 ? namePrefix : commaNamePrefix;
+ ensure(prefix.length + 5);
+ writeRawNoEnsure(prefix);
+ writeAsciiNoEnsure(value ? "true" : "false");
+ }
+
+ public void writeIntField(byte[] namePrefix, byte[] commaNamePrefix, int index, int value) {
+ byte[] prefix = index == 0 ? namePrefix : commaNamePrefix;
+ writeIntField(prefix, value);
+ }
+
+ public void writeIntField(byte[] prefix, int value) {
+ ensure(prefix.length + 11);
+ writeRawNoEnsure(prefix);
+ writeIntNoEnsure(value);
+ }
+
+ public void writeObjectIntField(byte[] namePrefix, int value) {
+ ensure(namePrefix.length + 12);
+ buffer[position++] = (byte) '{';
+ writeRawNoEnsure(namePrefix);
+ writeIntNoEnsure(value);
+ }
+
+ public void writeLongField(byte[] namePrefix, byte[] commaNamePrefix, int index, long value) {
+ byte[] prefix = index == 0 ? namePrefix : commaNamePrefix;
+ writeLongField(prefix, value);
+ }
+
+ public void writeLongField(byte[] prefix, long value) {
+ ensure(prefix.length + 20);
+ writeRawNoEnsure(prefix);
+ writeLongNoEnsure(value);
+ }
+
+ public void writeObjectLongField(byte[] namePrefix, long value) {
+ ensure(namePrefix.length + 21);
+ buffer[position++] = (byte) '{';
+ writeRawNoEnsure(namePrefix);
+ writeLongNoEnsure(value);
+ }
+
+ public void writeStringField(byte[] namePrefix, byte[] commaNamePrefix, int index, String value) {
+ byte[] prefix = index == 0 ? namePrefix : commaNamePrefix;
+ writeStringField(prefix, value);
+ }
+
+ public void writeStringField(byte[] prefix, String value) {
+ if (STRING_BYTES_BACKED) {
+ byte[] bytes = StringSerializer.getStringBytes(value);
+ byte stringCoder = StringSerializer.getStringCoder(value);
+ int start = position;
+ if (StringSerializer.isLatin1Coder(stringCoder)) {
+ ensure(prefix.length + bytes.length + 2);
+ writeRawNoEnsure(prefix);
+ if (writeLatin1StringNoEnsure(bytes)) {
+ return;
+ }
+ position = start;
+ } else if (StringSerializer.isUtf16Coder(stringCoder)) {
+ ensure(prefix.length + (bytes.length >> 1) * 3 + 2);
+ writeRawNoEnsure(prefix);
+ if (writeUtf16StringNoEnsure(bytes)) {
+ return;
+ }
+ position = start;
+ }
+ }
+ writeStringFieldChars(prefix, value);
+ }
+
+ private void writeStringFieldChars(byte[] prefix, String value) {
+ ensure(prefix.length + value.length() * 3 + 2);
+ writeRawNoEnsure(prefix);
+ writeStringNoEnsure(value);
+ }
+
+ public void writeStringElement(int index, String value) {
+ int comma = index == 0 ? 0 : 1;
+ if (value == null) {
+ writeNullStringElement(comma);
+ return;
+ }
+ if (STRING_BYTES_BACKED) {
+ byte[] bytes = StringSerializer.getStringBytes(value);
+ byte stringCoder = StringSerializer.getStringCoder(value);
+ int start = position;
+ if (StringSerializer.isLatin1Coder(stringCoder)) {
+ ensure(comma + bytes.length + 2);
+ if (comma != 0) {
+ buffer[position++] = ',';
+ }
+ if (writeLatin1StringNoEnsure(bytes)) {
+ return;
+ }
+ position = start;
+ } else if (StringSerializer.isUtf16Coder(stringCoder)) {
+ ensure(comma + (bytes.length >> 1) * 3 + 2);
+ if (comma != 0) {
+ buffer[position++] = ',';
+ }
+ if (writeUtf16StringNoEnsure(bytes)) {
+ return;
+ }
+ position = start;
+ }
+ }
+ writeStringElementChars(comma, value);
+ }
+
+ private void writeNullStringElement(int comma) {
+ ensure(comma + 4);
+ if (comma != 0) {
+ buffer[position++] = ',';
+ }
+ writeAsciiNoEnsure("null");
+ }
+
+ private void writeStringElementChars(int comma, String value) {
+ ensure(comma + value.length() * 3 + 2);
+ if (comma != 0) {
+ buffer[position++] = ',';
+ }
+ writeStringNoEnsure(value);
+ }
+
+ public void writeRawValue(byte[] value) {
+ writeRaw(value);
+ }
+
+ @Override
+ public void writeObjectStart() {
+ writeByteRaw((byte) '{');
+ }
+
+ @Override
+ public void writeObjectEnd() {
+ writeByteRaw((byte) '}');
+ }
+
+ @Override
+ public void writeArrayStart() {
+ writeByteRaw((byte) '[');
+ }
+
+ @Override
+ public void writeArrayEnd() {
+ writeByteRaw((byte) ']');
+ }
+
+ @Override
+ public void writeComma(int index) {
+ if (index != 0) {
+ writeByteRaw((byte) ',');
+ }
+ }
+
+ private boolean writeLatin1String(byte[] value) {
+ int length = value.length;
+ ensure(length + 2);
+ return writeLatin1StringNoEnsure(value);
+ }
+
+ private boolean writeLatin1StringNoEnsure(byte[] value) {
+ int length = value.length;
+ byte[] bytes = buffer;
+ int start = position;
+ int pos = start;
+ bytes[pos++] = (byte) '"';
+ int i = 0;
+ int upperBound = length & ~15;
+ for (; i < upperBound; i += 16) {
+ long word0 = LittleEndian.getInt64(value, i);
+ long word1 = LittleEndian.getInt64(value, i + 8);
+ if (!isJsonAsciiWord(word0) || !isJsonAsciiWord(word1)) {
+ break;
+ }
+ LittleEndian.putInt64(bytes, pos, word0);
+ LittleEndian.putInt64(bytes, pos + 8, word1);
+ pos += 16;
+ }
+ upperBound = length & ~7;
+ for (; i < upperBound; i += 8) {
+ long word = LittleEndian.getInt64(value, i);
+ if (!isJsonAsciiWord(word)) {
+ break;
+ }
+ LittleEndian.putInt64(bytes, pos, word);
+ pos += 8;
+ }
+ if (i + 4 <= length) {
+ int word = LittleEndian.getInt32(value, i);
+ if (isJsonAsciiInt(word)) {
+ LittleEndian.putInt32(bytes, pos, word);
+ pos += 4;
+ i += 4;
+ }
+ }
+ for (; i < length; i++) {
+ byte ch = value[i];
+ if (isJsonAsciiByte(ch)) {
+ bytes[pos++] = ch;
+ } else {
+ position = start;
+ return false;
+ }
+ }
+ bytes[pos++] = (byte) '"';
+ position = pos;
+ return true;
+ }
+
+ private boolean writeUtf16String(byte[] value) {
+ int length = value.length;
+ ensure((length >> 1) * 3 + 2);
+ return writeUtf16StringNoEnsure(value);
+ }
+
+ private boolean writeUtf16StringNoEnsure(byte[] value) {
+ int length = value.length;
+ byte[] bytes = buffer;
+ int start = position;
+ int pos = start;
+ bytes[pos++] = (byte) '"';
+ int i = 0;
+ int upperBound = length & ~7;
+ for (; i < upperBound; i += 8) {
+ long word = LittleEndian.getInt64(value, i);
+ if ((word & UTF16_ASCII_MASK) != 0) {
+ break;
+ }
+ int packed = packUtf16Ascii(word);
+ if (!isJsonAsciiInt(packed)) {
+ break;
+ }
+ LittleEndian.putInt32(bytes, pos, packed);
+ pos += 4;
+ }
+ for (; i < length; i += 2) {
+ char ch = StringSerializer.getBytesChar(value, i);
+ if (ch < 0x80) {
+ if (!isJsonAscii(ch)) {
+ position = start;
+ return false;
+ }
+ bytes[pos++] = (byte) ch;
+ } else if (ch < 0x800) {
+ bytes[pos++] = (byte) (0xC0 | (ch >>> 6));
+ bytes[pos++] = (byte) (0x80 | (ch & 0x3F));
+ } else if (Character.isSurrogate(ch)) {
+ position = start;
+ return false;
+ } else {
+ bytes[pos++] = (byte) (0xE0 | (ch >>> 12));
+ bytes[pos++] = (byte) (0x80 | ((ch >>> 6) & 0x3F));
+ bytes[pos++] = (byte) (0x80 | (ch & 0x3F));
+ }
+ }
+ bytes[pos++] = (byte) '"';
+ position = pos;
+ return true;
+ }
+
+ private void writeEscapedChar(char ch) {
+ switch (ch) {
+ case '"':
+ writeAscii("\\\"");
+ return;
+ case '\\':
+ writeAscii("\\\\");
+ return;
+ case '\b':
+ writeAscii("\\b");
+ return;
+ case '\f':
+ writeAscii("\\f");
+ return;
+ case '\n':
+ writeAscii("\\n");
+ return;
+ case '\r':
+ writeAscii("\\r");
+ return;
+ case '\t':
+ writeAscii("\\t");
+ return;
+ default:
+ if (ch < 0x20) {
+ writeUnicodeEscape(ch);
+ } else if (ch < 0x80) {
+ writeByteRaw((byte) ch);
+ } else if (ch < 0x800) {
+ ensure(2);
+ buffer[position++] = (byte) (0xC0 | (ch >>> 6));
+ buffer[position++] = (byte) (0x80 | (ch & 0x3F));
+ } else {
+ ensure(3);
+ buffer[position++] = (byte) (0xE0 | (ch >>> 12));
+ buffer[position++] = (byte) (0x80 | ((ch >>> 6) & 0x3F));
+ buffer[position++] = (byte) (0x80 | (ch & 0x3F));
+ }
+ }
+ }
+
+ private void writeStringSlow(String value, int index, int length) {
+ for (int i = index; i < length; i++) {
+ char ch = value.charAt(i);
+ if (Character.isHighSurrogate(ch)) {
+ if (i + 1 >= length) {
+ throw new ForyJsonException("Unpaired high surrogate in string");
+ }
+ char low = value.charAt(++i);
+ if (!Character.isLowSurrogate(low)) {
+ throw new ForyJsonException("Unpaired high surrogate in string");
+ }
+ writeCodePoint(Character.toCodePoint(ch, low));
+ } else if (Character.isLowSurrogate(ch)) {
+ throw new ForyJsonException("Unpaired low surrogate in string");
+ } else {
+ writeEscapedChar(ch);
+ }
+ }
+ writeByteRaw((byte) '"');
+ }
+
+ private void writeStringNoEnsure(String value) {
+ if (STRING_BYTES_BACKED) {
+ byte[] bytes = StringSerializer.getStringBytes(value);
+ byte stringCoder = StringSerializer.getStringCoder(value);
+ if (StringSerializer.isLatin1Coder(stringCoder)) {
+ if (writeLatin1StringNoEnsure(bytes)) {
+ return;
+ }
+ } else if (StringSerializer.isUtf16Coder(stringCoder)) {
+ if (writeUtf16StringNoEnsure(bytes)) {
+ return;
+ }
+ }
+ }
+ writeStringCharsNoEnsure(value);
+ }
+
+ private void writeStringCharsNoEnsure(String value) {
+ int length = value.length();
+ byte[] bytes = buffer;
+ int pos = position;
+ bytes[pos++] = (byte) '"';
+ int i = 0;
+ while (i + 4 <= length) {
+ char c0 = value.charAt(i);
+ char c1 = value.charAt(i + 1);
+ char c2 = value.charAt(i + 2);
+ char c3 = value.charAt(i + 3);
+ if (isJsonAscii(c0) && isJsonAscii(c1) && isJsonAscii(c2) && isJsonAscii(c3)) {
+ bytes[pos] = (byte) c0;
+ bytes[pos + 1] = (byte) c1;
+ bytes[pos + 2] = (byte) c2;
+ bytes[pos + 3] = (byte) c3;
+ pos += 4;
+ i += 4;
+ } else {
+ break;
+ }
+ }
+ while (i < length) {
+ char ch = value.charAt(i);
+ if (isJsonAscii(ch)) {
+ bytes[pos++] = (byte) ch;
+ i++;
+ } else {
+ position = pos;
+ writeStringSlow(value, i, length);
+ return;
+ }
+ }
+ bytes[pos++] = (byte) '"';
+ position = pos;
+ }
+
+ private void writeCodePoint(int codePoint) {
+ ensure(4);
+ buffer[position++] = (byte) (0xF0 | (codePoint >>> 18));
+ buffer[position++] = (byte) (0x80 | ((codePoint >>> 12) & 0x3F));
+ buffer[position++] = (byte) (0x80 | ((codePoint >>> 6) & 0x3F));
+ buffer[position++] = (byte) (0x80 | (codePoint & 0x3F));
+ }
+
+ private void writeUnicodeEscape(char ch) {
+ ensure(6);
+ buffer[position++] = '\\';
+ buffer[position++] = 'u';
+ buffer[position++] = '0';
+ buffer[position++] = '0';
+ buffer[position++] = (byte) hex((ch >>> 4) & 0xF);
+ buffer[position++] = (byte) hex(ch & 0xF);
+ }
+
+ private void writeAscii(String value) {
+ int length = value.length();
+ ensure(length);
+ writeAsciiNoEnsure(value);
+ }
+
+ private void writeAsciiNoEnsure(String value) {
+ int length = value.length();
+ for (int i = 0; i < length; i++) {
+ buffer[position++] = (byte) value.charAt(i);
+ }
+ }
+
+ private void writeRaw(byte[] bytes) {
+ ensure(bytes.length);
+ writeRawNoEnsure(bytes);
+ }
+
+ private void writeRawNoEnsure(byte[] bytes) {
+ System.arraycopy(bytes, 0, buffer, position, bytes.length);
+ position += bytes.length;
+ }
+
+ private void writeByteRaw(byte value) {
+ ensure(1);
+ buffer[position++] = value;
+ }
+
+ private void reverse(int start, int end) {
+ while (start < end) {
+ byte tmp = buffer[start];
+ buffer[start++] = buffer[end];
+ buffer[end--] = tmp;
+ }
+ }
+
+ private void ensure(int additional) {
+ int minCapacity = position + additional;
+ if (minCapacity > buffer.length) {
+ grow(minCapacity);
+ }
+ }
+
+ private void grow(int minCapacity) {
+ int newCapacity = buffer.length << 1;
+ while (newCapacity < minCapacity) {
+ newCapacity <<= 1;
+ }
+ buffer = Arrays.copyOf(buffer, newCapacity);
+ }
+
+ private static char hex(int value) {
+ return (char) (value < 10 ? '0' + value : 'a' + value - 10);
+ }
+
+ private static boolean isJsonAscii(char ch) {
+ return ch > 0x1F && ch < 0x80 && ch != '"' && ch != '\\';
+ }
+
+ private static boolean isJsonAsciiByte(byte value) {
+ int ch = value & 0xff;
+ return ch > 0x1F && ch < 0x80 && ch != '"' && ch != '\\';
+ }
+
+ private static boolean isJsonAsciiWord(long word) {
+ return (((word + ASCII_CONTROL_OFFSET) & ~word) & HIGH_BITS) == HIGH_BITS
+ && (((word ^ QUOTE_BYTES_COMPLEMENT) + ONE_BYTES) & HIGH_BITS) == HIGH_BITS
+ && (((word ^ BACKSLASH_BYTES_COMPLEMENT) + ONE_BYTES) & HIGH_BITS) == HIGH_BITS;
+ }
+
+ private static boolean isJsonAsciiInt(int word) {
+ return (((word + INT_ASCII_CONTROL_OFFSET) & ~word) & INT_HIGH_BITS) == INT_HIGH_BITS
+ && (((word ^ INT_QUOTE_BYTES_COMPLEMENT) + INT_ONE_BYTES) & INT_HIGH_BITS) == INT_HIGH_BITS
+ && (((word ^ INT_BACKSLASH_BYTES_COMPLEMENT) + INT_ONE_BYTES) & INT_HIGH_BITS)
+ == INT_HIGH_BITS;
+ }
+
+ private static int packUtf16Ascii(long word) {
+ return (int)
+ ((word & 0xFFL)
+ | ((word >>> 8) & 0xFF00L)
+ | ((word >>> 16) & 0xFF0000L)
+ | ((word >>> 24) & 0xFF000000L));
+ }
+
+ private void writeIntNoEnsure(int value) {
+ if (value == Integer.MIN_VALUE) {
+ writeRawNoEnsure(MIN_INT_BYTES);
+ return;
+ }
+ if (value < 0) {
+ buffer[position++] = (byte) '-';
+ value = -value;
+ }
+ writePositiveIntNoEnsure(value);
+ }
+
+ private void writeLongNoEnsure(long value) {
+ if (value == Long.MIN_VALUE) {
+ writeRawNoEnsure(MIN_LONG_BYTES);
+ return;
+ }
+ if (value < 0) {
+ buffer[position++] = (byte) '-';
+ value = -value;
+ }
+ if (value <= Integer.MAX_VALUE) {
+ writePositiveIntNoEnsure((int) value);
+ return;
+ }
+ int start = position;
+ do {
+ buffer[position++] = (byte) ('0' + value % 10);
+ value /= 10;
+ } while (value != 0);
+ reverse(start, position - 1);
+ }
+
+ private void writePositiveIntNoEnsure(int value) {
+ byte[] bytes = buffer;
+ int pos = position;
+ if (value < 10000) {
+ position = writeIntUpTo4(bytes, pos, value);
+ return;
+ }
+ int high = divide10000(value);
+ int low = value - high * 10000;
+ if (high < 10000) {
+ if (high >= 1000) {
+ position = writePadded8(bytes, pos, high, low);
+ return;
+ }
+ pos = writeIntUpTo4(bytes, pos, high);
+ position = writePadded4(bytes, pos, low);
+ return;
+ }
+ int top = divide10000(high);
+ int middle = high - top * 10000;
+ pos = writeIntUpTo4(bytes, pos, top);
+ position = writePadded8(bytes, pos, middle, low);
+ }
+
+ private static int divide10000(int value) {
+ return (int) (((long) value * 1759218605L) >> 44);
+ }
+
+ private static int writeIntUpTo4(byte[] bytes, int pos, int value) {
+ if (value < 1000) {
+ return writeIntUpTo3(bytes, pos, value);
+ }
+ return writePadded4(bytes, pos, value);
+ }
+
+ private static int writeIntUpTo3(byte[] bytes, int pos, int value) {
+ int digits = DIGIT_TRIPLES[value];
+ int skip = digits & 0xFF;
+ LittleEndian.putInt32(bytes, pos, digits >>> ((skip + 1) << 3));
+ return pos + 3 - skip;
+ }
+
+ private static int writePadded4(byte[] bytes, int pos, int value) {
+ LittleEndian.putInt32(bytes, pos, DIGIT_QUADS[value]);
+ return pos + 4;
+ }
+
+ private static int writePadded8(byte[] bytes, int pos, int high, int low) {
+ long value = (DIGIT_QUADS[high] & 0xFFFFFFFFL) | ((DIGIT_QUADS[low] & 0xFFFFFFFFL) << 32);
+ LittleEndian.putInt64(bytes, pos, value);
+ return pos + 8;
+ }
+}
diff --git a/java/fory-json/src/main/java/org/apache/fory/json/writer/Utf8ObjectWriter.java b/java/fory-json/src/main/java/org/apache/fory/json/writer/Utf8ObjectWriter.java
new file mode 100644
index 0000000000..a1005ed522
--- /dev/null
+++ b/java/fory-json/src/main/java/org/apache/fory/json/writer/Utf8ObjectWriter.java
@@ -0,0 +1,26 @@
+/*
+ * 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.fory.json.writer;
+
+import org.apache.fory.json.resolver.JsonTypeResolver;
+
+public interface Utf8ObjectWriter {
+ void writeUtf8(Utf8JsonWriter writer, Object value, JsonTypeResolver typeResolver);
+}
diff --git a/java/fory-json/src/main/java9/module-info.java b/java/fory-json/src/main/java9/module-info.java
new file mode 100644
index 0000000000..438ecd0b2c
--- /dev/null
+++ b/java/fory-json/src/main/java9/module-info.java
@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+
+module org.apache.fory.json {
+ requires org.apache.fory.core;
+ requires static java.sql;
+
+ exports org.apache.fory.json;
+ exports org.apache.fory.json.annotation;
+}
diff --git a/java/fory-json/src/test/java/org/apache/fory/json/ForyJsonTestModels.java b/java/fory-json/src/test/java/org/apache/fory/json/ForyJsonTestModels.java
new file mode 100644
index 0000000000..cdbd4b4d19
--- /dev/null
+++ b/java/fory-json/src/test/java/org/apache/fory/json/ForyJsonTestModels.java
@@ -0,0 +1,317 @@
+/*
+ * 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.fory.json;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+import org.apache.fory.json.data.FastContainers;
+import org.apache.fory.json.data.GeneratedCollectionFields;
+import org.apache.fory.json.data.JsonTestData;
+import org.apache.fory.json.data.Kind;
+import org.apache.fory.json.data.MethodsIgnored;
+import org.apache.fory.json.data.NumericBoundaries;
+import org.apache.fory.json.data.PrivateFields;
+import org.apache.fory.json.data.PublicFields;
+import org.apache.fory.json.data.TokenValues;
+import org.apache.fory.json.data.UnicodeMatrix;
+import org.apache.fory.platform.JdkVersion;
+import org.apache.fory.reflect.FieldAccessor;
+import org.testng.SkipException;
+
+public abstract class ForyJsonTestModels {
+ protected static final String TWO_BYTE_TEXT = JsonTestData.TWO_BYTE_TEXT;
+ protected static final String THREE_BYTE_TEXT = JsonTestData.THREE_BYTE_TEXT;
+ protected static final String SUPPLEMENTARY_TEXT = JsonTestData.SUPPLEMENTARY_TEXT;
+ protected static final String MIXED_SCRIPT_TEXT = JsonTestData.MIXED_SCRIPT_TEXT;
+ protected static final String COMBINING_TEXT = JsonTestData.COMBINING_TEXT;
+ protected static final String ZH_TEXT = JsonTestData.ZH_TEXT;
+ protected static final String EU_TEXT = JsonTestData.EU_TEXT;
+
+ protected static TokenValues tokenValue(int count, String name, List tags, long total) {
+ TokenValues value = new TokenValues();
+ value.count = count;
+ value.name = name;
+ value.tags = tags;
+ value.total = total;
+ return value;
+ }
+
+ protected static String hiddenValue(MethodsIgnored value) {
+ return MethodsIgnored.hiddenValue(value);
+ }
+
+ protected static int privateId(PrivateFields value) {
+ return PrivateFields.id(value);
+ }
+
+ protected static String privateName(PrivateFields value) {
+ return PrivateFields.name(value);
+ }
+
+ protected static String privateNullable(PrivateFields value) {
+ return PrivateFields.nullable(value);
+ }
+
+ protected static String privateTransientValue(PrivateFields value) {
+ return PrivateFields.transientValue(value);
+ }
+
+ protected static String privateStaticValue() {
+ return PrivateFields.staticValue();
+ }
+
+ protected static Map scores() {
+ return JsonTestData.scores();
+ }
+
+ protected static Map flags() {
+ return JsonTestData.flags();
+ }
+
+ protected static Map intNames() {
+ return JsonTestData.intNames();
+ }
+
+ protected static EnumMap enumScores() {
+ return JsonTestData.enumScores();
+ }
+
+ protected static Calendar calendar(long millis) {
+ return JsonTestData.calendar(millis);
+ }
+
+ protected static byte[] byteBufferBytes(ByteBuffer buffer) {
+ ByteBuffer copy = buffer.duplicate();
+ byte[] bytes = new byte[copy.remaining()];
+ copy.get(bytes);
+ return bytes;
+ }
+
+ protected static Map unicodeMap() {
+ return JsonTestData.unicodeMap();
+ }
+
+ protected static String unicodeMatrixJson() {
+ return "{\"boxedChar\":\"\u20ac\",\"charThreeByte\":\"\u4f60\","
+ + "\"charTwoByte\":\"\u0100\",\"chars\":[\"\u0100\",\"\u07ff\",\"\u0800\","
+ + "\"\u20ac\",\"\u4f60\"],\"combining\":\""
+ + COMBINING_TEXT
+ + "\",\"eu\":\""
+ + EU_TEXT
+ + "\",\"mixedScripts\":\""
+ + MIXED_SCRIPT_TEXT
+ + "\",\"supplementary\":\""
+ + SUPPLEMENTARY_TEXT
+ + "\",\"threeByte\":\""
+ + THREE_BYTE_TEXT
+ + "\",\"twoByte\":\""
+ + TWO_BYTE_TEXT
+ + "\",\"valueMap\":{\""
+ + TWO_BYTE_TEXT
+ + "\":\""
+ + THREE_BYTE_TEXT
+ + "\",\""
+ + ZH_TEXT
+ + "\":\""
+ + EU_TEXT
+ + "\",\"\u043a\u043b\u044e\u0447\":\"\uD83D\uDE00\","
+ + "\"\u0645\u0631\u062d\u0628\u0627\":\"\u0928\u092e\u0938\u094d\u0924\u0947\"},"
+ + "\"values\":[\""
+ + TWO_BYTE_TEXT
+ + "\",\""
+ + THREE_BYTE_TEXT
+ + "\",\""
+ + SUPPLEMENTARY_TEXT
+ + "\",\""
+ + MIXED_SCRIPT_TEXT
+ + "\",\""
+ + COMBINING_TEXT
+ + "\",\""
+ + ZH_TEXT
+ + "\",\""
+ + EU_TEXT
+ + "\"],\"zh\":\""
+ + ZH_TEXT
+ + "\"}";
+ }
+
+ protected static void assertUnicodeMatrix(UnicodeMatrix value) {
+ assertEquals(value.boxedChar, Character.valueOf('€'));
+ assertEquals(value.charThreeByte, '你');
+ assertEquals(value.charTwoByte, 'Ā');
+ assertEquals(value.chars, new char[] {'Ā', '߿', 'ࠀ', '€', '你'});
+ assertEquals(value.combining, COMBINING_TEXT);
+ assertEquals(value.eu, EU_TEXT);
+ assertEquals(value.mixedScripts, MIXED_SCRIPT_TEXT);
+ assertEquals(value.supplementary, SUPPLEMENTARY_TEXT);
+ assertEquals(value.threeByte, THREE_BYTE_TEXT);
+ assertEquals(value.twoByte, TWO_BYTE_TEXT);
+ assertEquals(value.valueMap, unicodeMap());
+ assertEquals(
+ value.values,
+ Arrays.asList(
+ TWO_BYTE_TEXT,
+ THREE_BYTE_TEXT,
+ SUPPLEMENTARY_TEXT,
+ MIXED_SCRIPT_TEXT,
+ COMBINING_TEXT,
+ ZH_TEXT,
+ EU_TEXT));
+ assertEquals(value.zh, ZH_TEXT);
+ }
+
+ protected static void assertFastContainers(FastContainers value) {
+ assertEquals(value.booleans, Arrays.asList(Boolean.TRUE, Boolean.FALSE));
+ assertEquals(value.flags, flags());
+ assertEquals(value.intNames, intNames());
+ assertEquals(value.ints, Arrays.asList(1, 2));
+ assertEquals(value.names, Arrays.asList("alpha", ZH_TEXT));
+ assertEquals(value.scores, scores());
+ }
+
+ protected static void assertGeneratedCollections(GeneratedCollectionFields value) {
+ assertTrue(value.kinds instanceof EnumSet);
+ assertEquals(value.kinds, EnumSet.of(Kind.FAST, Kind.SMALL));
+ assertTrue(value.names instanceof LinkedHashSet);
+ assertEquals(value.names, new LinkedHashSet<>(Arrays.asList("alpha", ZH_TEXT)));
+ assertTrue(value.numbers instanceof ArrayDeque);
+ assertEquals(new ArrayList<>(value.numbers), Arrays.asList(1, 2));
+ }
+
+ protected static void assertNumericBoundaries(NumericBoundaries value, String text) {
+ assertEquals(value.intMax, Integer.MAX_VALUE);
+ assertEquals(value.intMin, Integer.MIN_VALUE);
+ assertEquals(value.longMax, Long.MAX_VALUE);
+ assertEquals(value.longMin, Long.MIN_VALUE);
+ assertEquals(value.small, -7);
+ assertEquals(value.text, text);
+ }
+
+ protected static Class compileRecordClass(String simpleName, String source) throws Exception {
+ JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+ assertTrue(compiler != null);
+ Path output =
+ Paths.get(
+ ForyJsonTestModels.class.getProtectionDomain().getCodeSource().getLocation().toURI());
+ Path sourceDir = Files.createTempDirectory("fory-json-record");
+ Files.createDirectories(sourceDir);
+ Path sourceFile = sourceDir.resolve(simpleName + ".java");
+ Files.write(sourceFile, source.getBytes(StandardCharsets.UTF_8));
+ int exit =
+ compiler.run(
+ null, null, null, "--release", "17", "-d", output.toString(), sourceFile.toString());
+ assertEquals(exit, 0);
+ return Class.forName(
+ "org.apache.fory.json.records." + simpleName,
+ true,
+ ForyJsonTestModels.class.getClassLoader());
+ }
+
+ protected static void assertRecordValue(Object value, Class childType) throws Exception {
+ Class type = value.getClass();
+ assertEquals(type.getMethod("id").invoke(value), Integer.valueOf(7));
+ assertEquals(type.getMethod("name").invoke(value), ZH_TEXT);
+ assertEquals(type.getMethod("tags").invoke(value), Arrays.asList("a", "b"));
+ Object child = type.getMethod("child").invoke(value);
+ assertEquals(childType.getMethod("label").invoke(child), "kid");
+ }
+
+ protected static void assertTextRoundTrip(ForyJson json, String text) {
+ String rootJson = "\"" + text + "\"";
+ assertEquals(json.toJson(text), rootJson);
+ assertEquals(new String(json.toJsonBytes(text), StandardCharsets.UTF_8), rootJson);
+ assertEquals(json.fromJson(rootJson, String.class), text);
+ assertEquals(json.fromJson(rootJson.getBytes(StandardCharsets.UTF_8), String.class), text);
+
+ PublicFields fields = new PublicFields();
+ fields.name = text;
+ String objectJson = "{\"active\":true,\"id\":7,\"name\":\"" + text + "\"}";
+ assertEquals(json.toJson(fields), objectJson);
+ assertEquals(new String(json.toJsonBytes(fields), StandardCharsets.UTF_8), objectJson);
+ assertEquals(json.fromJson(objectJson, PublicFields.class).name, text);
+ assertEquals(
+ json.fromJson(objectJson.getBytes(StandardCharsets.UTF_8), PublicFields.class).name, text);
+ }
+
+ protected static void assertGeneratedWhenSupported(ForyJson json, Class type) {
+ assertEquals(json.hasGeneratedWriter(type), JdkVersion.MAJOR_VERSION >= 15);
+ }
+
+ protected static String repeat(char ch, int length) {
+ char[] chars = new char[length];
+ Arrays.fill(chars, ch);
+ return new String(chars);
+ }
+
+ protected static String nestedArray(int depth) {
+ StringBuilder builder = new StringBuilder(depth * 2 + 1);
+ for (int i = 0; i < depth; i++) {
+ builder.append('[');
+ }
+ builder.append('0');
+ for (int i = 0; i < depth; i++) {
+ builder.append(']');
+ }
+ return builder.toString();
+ }
+
+ protected static int arrayCapacity(ArrayList list) {
+ try {
+ Field field = ArrayList.class.getDeclaredField("elementData");
+ Object[] array = (Object[]) FieldAccessor.createAccessor(field).getObject(list);
+ return array.length;
+ } catch (Throwable cause) {
+ throw new SkipException("Cannot inspect ArrayList capacity on this runtime", cause);
+ }
+ }
+
+ protected static int mapCapacity(HashMap map) {
+ try {
+ Field field = HashMap.class.getDeclaredField("table");
+ Object[] table = (Object[]) FieldAccessor.createAccessor(field).getObject(map);
+ return table == null ? 0 : table.length;
+ } catch (Throwable cause) {
+ throw new SkipException("Cannot inspect HashMap capacity on this runtime", cause);
+ }
+ }
+
+ protected static Map values() {
+ return JsonTestData.values();
+ }
+}
diff --git a/java/fory-json/src/test/java/org/apache/fory/json/JsonContainerTest.java b/java/fory-json/src/test/java/org/apache/fory/json/JsonContainerTest.java
new file mode 100644
index 0000000000..9357fea10f
--- /dev/null
+++ b/java/fory-json/src/test/java/org/apache/fory/json/JsonContainerTest.java
@@ -0,0 +1,238 @@
+/*
+ * 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.fory.json;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertThrows;
+import static org.testng.Assert.assertTrue;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import org.apache.fory.json.data.FastContainers;
+import org.apache.fory.json.data.MapKeyFields;
+import org.apache.fory.json.data.Nested;
+import org.apache.fory.json.data.TokenValues;
+import org.apache.fory.reflect.TypeRef;
+import org.testng.annotations.Test;
+
+public class JsonContainerTest extends ForyJsonTestModels {
+ @Test
+ public void writeNestedCollections() {
+ ForyJson json = ForyJson.builder().build();
+ assertEquals(
+ json.toJson(new Nested()),
+ "{\"kind\":\"FAST\",\"names\":[\"a\",\"b\"],\"scores\":{\"one\":1,\"two\":2}}");
+ }
+
+ @Test
+ public void readTypeRefList() {
+ ForyJson json = ForyJson.builder().build();
+ List values =
+ json.fromJson(
+ "[{\"count\":1,\"name\":\"alpha\",\"tags\":[\"x\",\"y\"],\"total\":2},"
+ + "{\"count\":3,\"name\":\"beta\",\"tags\":[\"z\"],\"total\":4}]",
+ new TypeRef>() {});
+ assertEquals(values.size(), 2);
+ assertEquals(values.get(0).name, "alpha");
+ assertEquals(values.get(0).tags, Arrays.asList("x", "y"));
+ assertEquals(values.get(1).count, 3);
+ assertEquals(values.get(1).total, 4);
+ }
+
+ @Test
+ public void readTypeRefMapBytes() {
+ ForyJson json = ForyJson.builder().build();
+ byte[] bytes =
+ "{\"first\":{\"count\":5,\"name\":\"gamma\",\"tags\":[\"u\"],\"total\":6}}"
+ .getBytes(StandardCharsets.UTF_8);
+ Map values =
+ json.fromJson(bytes, new TypeRef>() {});
+ assertEquals(values.size(), 1);
+ assertEquals(values.get("first").name, "gamma");
+ assertEquals(values.get("first").tags, Arrays.asList("u"));
+ assertEquals(values.get("first").total, 6);
+ }
+
+ @Test
+ public void readJsonContainers() {
+ ForyJson json = ForyJson.builder().build();
+ JSONObject object =
+ json.fromJson("{\"name\":\"fory\",\"items\":[1,\"你好，Fory\"]}", JSONObject.class);
+ assertEquals(object.get("name"), "fory");
+ assertTrue(object.get("items") instanceof JSONArray);
+ JSONArray items = (JSONArray) object.get("items");
+ assertEquals(items.get(0), Long.valueOf(1));
+ assertEquals(items.get(1), ZH_TEXT);
+
+ Object natural = json.fromJson("{\"items\":[true]}", Object.class);
+ assertTrue(natural instanceof JSONObject);
+ assertTrue(((JSONObject) natural).get("items") instanceof JSONArray);
+ }
+
+ @Test
+ public void parsedContainersStartSmall() {
+ ForyJson json = ForyJson.builder().build();
+ JSONArray array = json.fromJson("[1]", JSONArray.class);
+ assertEquals(arrayCapacity(array), 1);
+ assertEquals(arrayCapacity(json.fromJson("[]", JSONArray.class)), 0);
+
+ List