├── .idea ├── .name ├── .gitignore ├── codeStyles │ ├── codeStyleConfig.xml │ └── Project.xml ├── vcs.xml ├── encodings.xml ├── modules.xml ├── inspectionProfiles │ └── Project_Default.xml └── misc.xml ├── .gitignore ├── .settings ├── org.eclipse.core.runtime.prefs ├── org.eclipse.core.resources.prefs ├── org.eclipse.jdt.ui.prefs └── org.eclipse.jdt.core.prefs ├── lib └── org.eclipse.jdt.annotation-2.2.600.jar ├── README.md ├── .project ├── .classpath ├── test └── jason │ ├── TestJdk16.java │ ├── TestJsonParser.java │ ├── TestJson5.java │ ├── TestStringParser.java │ ├── JsonToken.java │ ├── TestNumberParser.java │ ├── TestWriter.java │ ├── Test.java │ └── Wast.java ├── LICENSE ├── jason.iml └── src └── jason ├── Json.java └── JsonWriter.java /.idea/.name: -------------------------------------------------------------------------------- 1 | jason -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /bin/ 2 | /out/ 3 | /classes/ 4 | /*.jar 5 | ~$* 6 | -------------------------------------------------------------------------------- /.settings/org.eclipse.core.runtime.prefs: -------------------------------------------------------------------------------- 1 | eclipse.preferences.version=1 2 | line.separator=\n 3 | -------------------------------------------------------------------------------- /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /uiDesigner.xml 4 | /workspace.xml 5 | -------------------------------------------------------------------------------- /.settings/org.eclipse.core.resources.prefs: -------------------------------------------------------------------------------- 1 | eclipse.preferences.version=1 2 | encoding/=UTF-8 3 | -------------------------------------------------------------------------------- /lib/org.eclipse.jdt.annotation-2.2.600.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dwing4g/jason/HEAD/lib/org.eclipse.jdt.annotation-2.2.600.jar -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # jason 2 | An ultra fast and lightweight JSON parser and binder 3 | 4 | ## benchmark(Chinese): 5 | https://zhuanlan.zhihu.com/p/108486101 6 | -------------------------------------------------------------------------------- /.idea/codeStyles/codeStyleConfig.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/encodings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | jason 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.jdt.core.javabuilder 10 | 11 | 12 | 13 | 14 | 15 | org.eclipse.jdt.core.javanature 16 | 17 | 18 | -------------------------------------------------------------------------------- /.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /test/jason/TestJdk16.java: -------------------------------------------------------------------------------- 1 | package jason; 2 | 3 | public class TestJdk16 { 4 | record Record(int v, String s) { 5 | } 6 | 7 | public static void test1() throws ReflectiveOperationException { 8 | Record r = new Record(123, "abc"); 9 | String json = JsonWriter.local().clear().write(r).toString(); 10 | // System.out.println(json); // {"v":123,"s":"abc"} 11 | Record r2 = JsonReader.local().buf(json).parse(Record.class); 12 | Test.assertEquals(r, r2); 13 | } 14 | 15 | public static void main(String[] args) throws ReflectiveOperationException { 16 | test1(); 17 | System.out.println(TestJdk16.class.getSimpleName() + ": 1 test OK!"); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /test/jason/TestJsonParser.java: -------------------------------------------------------------------------------- 1 | package jason; 2 | 3 | public final class TestJsonParser { 4 | public static class C { 5 | int a; 6 | String b; 7 | C c; 8 | } 9 | 10 | public static void main(String[] args) throws ReflectiveOperationException { 11 | byte[] bytes = "{\"b\":\"xyz\", \"a\":123,\"c\":{\"a\":456,\"b\":\"abc\"}}".getBytes(); 12 | long v = 0; 13 | long t = System.nanoTime(); 14 | JsonReader jr = new JsonReader(); 15 | for (int i = 0; i < 10_000_000; ++i) { 16 | C c = jr.buf(bytes).parse(C.class); 17 | if (c == null) 18 | throw new RuntimeException(); 19 | v += c.a + c.c.a; 20 | } 21 | System.out.println(TestJsonParser.class.getSimpleName() + ": " + v + ", " + 22 | (System.nanoTime() - t) / 1_000_000 + " ms"); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 dwing4g 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /.idea/codeStyles/Project.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 24 | -------------------------------------------------------------------------------- /jason.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | -------------------------------------------------------------------------------- /test/jason/TestJson5.java: -------------------------------------------------------------------------------- 1 | package jason; 2 | 3 | import java.util.LinkedHashMap; 4 | import java.util.Map; 5 | 6 | public final class TestJson5 { 7 | private static int checkCount = 0; 8 | 9 | private static void checkObj(String json5, String resJson) throws ReflectiveOperationException { 10 | final Map map = JsonReader.local().buf(json5).parseMap(new LinkedHashMap<>()); 11 | final String res = JsonWriter.local().clear().setFlags(0x10_0000).setNoQuoteKey(true).write(map).toString(); 12 | if (!res.equals(resJson)) 13 | throw new AssertionError("unmatched: " + json5 + " <---> " + res); 14 | checkCount++; 15 | } 16 | 17 | public static void main(String[] args) throws ReflectiveOperationException { 18 | checkObj("{'a':1}", "{a:1}"); 19 | checkObj("{a:1}", "{a:1}"); 20 | checkObj("{$_:1,_$:2,a\\u200C:3}", "{$_:1,_$:2,a\u200C:3}"); 21 | checkObj("{中文key\\0:9}", "{中文key\\u0000:9}"); 22 | checkObj("{\\u0061\\u0062:1,\\u0024\\u005F:2,\\u005F\\u0024:3}", "{ab:1,$_:2,_$:3}"); 23 | checkObj("{abc:1,def:2,,,}", "{abc:1,def:2}"); 24 | checkObj("{a:{b:2,},}", "{a:{b:2}}"); 25 | checkObj("{a:+5,b:+1.23e,c:+1.23e+1,d:-.5,e:-5.,f:-0.,g:-.,h:.}", "{a:5,b:1.23,c:12.3,d:-0.5,e:-5.0,f:-0.0,g:-0.0,h:0.0}"); 26 | checkObj("{a:Infinity,b:-infinity,c:Inf,d:NaN,e:nan}", "{a:Infinity,b:-Infinity,c:Infinity,d:NaN,e:NaN}"); 27 | System.out.println(TestJson5.class.getSimpleName() + ": " + checkCount + " TESTS OK!"); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /test/jason/TestStringParser.java: -------------------------------------------------------------------------------- 1 | package jason; 2 | 3 | import java.nio.charset.StandardCharsets; 4 | 5 | public final class TestStringParser { 6 | public static void main(String[] args) { 7 | String[] strs = {"\"\"", "\"abc\"", "\"abcdefghijklmn\"", "\"\\\"\\\\\\/\\b\\f\\n\\r\\t\"", 8 | "\"\\u0123\\u4567\\u89ab\\ucdef\"", "\"opqrst\\r\\nuvwxyz\"", "\"《汉字》\"", 9 | "\"\\u0030\\'\\uABCD\\u00EF\""}; 10 | //noinspection UnnecessaryUnicodeEscape 11 | String[] chks = {"", "abc", "abcdefghijklmn", "\"\\/\b\f\n\r\t", "\u0123\u4567\u89ab\ucdef", 12 | "opqrst\r\nuvwxyz", "《汉字》", "\u0030'\uABCD\u00EF"}; 13 | byte[][] tests = new byte[8][]; 14 | for (int i = 0; i < 8; i++) 15 | tests[i] = strs[i].getBytes(StandardCharsets.UTF_8); 16 | 17 | JsonReader jr = new JsonReader(); 18 | for (int j = 0; j < 8; j++) { 19 | String s = jr.buf(tests[j]).parseString(); 20 | if (!s.equals(chks[j])) { 21 | System.err.println("ERROR! j=" + j + ':'); 22 | for (int i = 0; i < s.length(); i++) 23 | System.out.format(" %4X", (int)s.charAt(i)); 24 | System.out.println(); 25 | for (int i = 0; i < chks[j].length(); i++) 26 | System.out.format(" %4X", (int)chks[j].charAt(i)); 27 | System.out.println(); 28 | return; 29 | } 30 | } 31 | long r = 0; 32 | for (int i = 0; i < 2_000_000; i++) 33 | for (int j = 0; j < 8; j++) { 34 | String s = jr.buf(tests[j]).parseString(); 35 | r += s.length(); 36 | } 37 | System.out.println(TestStringParser.class.getSimpleName() + ": " + r); // 102000000 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /.idea/inspectionProfiles/Project_Default.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 30 | -------------------------------------------------------------------------------- /test/jason/JsonToken.java: -------------------------------------------------------------------------------- 1 | package jason; 2 | 3 | public final class JsonToken { 4 | public static final int TYPE_SHIFT = 30; 5 | public static final int TYPE_PRIMITIVE = 0; // number, boolean(true/false) or null 6 | public static final int TYPE_STRING = 1 << TYPE_SHIFT; 7 | public static final int TYPE_ARRAY = 2 << TYPE_SHIFT; 8 | public static final int TYPE_OBJECT = 3 << TYPE_SHIFT; 9 | public static final int TYPE_MASK = 3 << TYPE_SHIFT; 10 | public static final int SIZE_MASK = ~TYPE_MASK; 11 | 12 | /** 13 | * Reference: original C implement: jsmn 14 | * 15 | * @param in json string (readonly byte array) 16 | * @param inPos start offset from json array 17 | * @param inLen length from json array offset 18 | * @param out output: {type|size, start, end, parent}* 19 | * @return updated outPos(>=0) or -1-outPos(<0) for error 20 | */ 21 | public static int parse(final byte[] in, int inPos, final int inLen, final int[] out) { 22 | int outPos = 0, parentPos = -1; 23 | for (final int inEnd = inPos + inLen; inPos < inEnd; inPos++) { 24 | final int c = in[inPos]; 25 | switch (c) { 26 | case '{': 27 | case '[': 28 | out[outPos] = c == '{' ? TYPE_OBJECT : TYPE_ARRAY; 29 | out[outPos + 1] = inPos; 30 | out[outPos + 2] = -1; 31 | out[outPos + 3] = parentPos; 32 | if (parentPos >= 0) 33 | out[parentPos]++; 34 | parentPos = outPos; 35 | outPos += 4; 36 | continue; 37 | case '}': 38 | case ']': 39 | final int type = c == '}' ? TYPE_OBJECT : TYPE_ARRAY; 40 | if (outPos <= 0) 41 | return -1; 42 | for (int pos = outPos - 4; ; pos = out[pos + 3]) { 43 | if (out[pos + 2] < 0) { 44 | if ((out[pos] & TYPE_MASK) != type) 45 | return -1 - outPos; 46 | out[pos + 2] = inPos + 1; 47 | parentPos = out[pos + 3]; 48 | break; 49 | } 50 | if (out[pos + 3] < 0) { 51 | if ((out[pos] & TYPE_MASK) != type || parentPos < 0) 52 | return -1 - outPos; 53 | break; 54 | } 55 | } 56 | continue; 57 | case '\'': 58 | case '"': 59 | out[outPos] = TYPE_STRING; 60 | out[outPos + 1] = ++inPos; 61 | for (; inPos < inEnd; inPos++) { 62 | final int d = in[inPos]; 63 | if (d == c) 64 | break; 65 | if (d == '\\' && inPos + 1 < inEnd) 66 | inPos++; 67 | } 68 | out[outPos + 2] = inPos; 69 | out[outPos + 3] = parentPos; 70 | outPos += 4; 71 | if (parentPos >= 0) 72 | out[parentPos]++; 73 | continue; 74 | case '\t': 75 | case '\r': 76 | case '\n': 77 | case ' ': 78 | continue; 79 | case ':': 80 | parentPos = outPos - 4; 81 | continue; 82 | case ',': 83 | if (parentPos >= 0 && out[parentPos] >= 0) // != ARRAY && != OBJECT 84 | parentPos = out[parentPos + 3]; 85 | continue; 86 | } 87 | out[outPos] = TYPE_PRIMITIVE; 88 | out[outPos + 1] = inPos; 89 | end: 90 | for (; inPos < inEnd; inPos++) { 91 | switch (in[inPos]) { 92 | case '\t': 93 | case '\r': 94 | case '\n': 95 | case ' ': 96 | case ':': 97 | case ',': 98 | case ']': 99 | case '}': 100 | break end; 101 | } 102 | } 103 | out[outPos + 2] = inPos--; 104 | out[outPos + 3] = parentPos; 105 | outPos += 4; 106 | if (parentPos >= 0) 107 | out[parentPos]++; 108 | } 109 | // for (int pos = outPos - 4; pos >= 0; pos -= 4) 110 | // if (out[pos + 2] < 0) 111 | // return ERROR_PART; 112 | return outPos; 113 | } 114 | 115 | private JsonToken() { 116 | } 117 | 118 | public static void main(String[] args) { 119 | String json = "{a:12,\"b\":{\"c\":[3,4],\"d\":\"测试\"},'ef':{}}"; 120 | final byte[] jsonBytes = json.getBytes(); 121 | final int[] tokens = new int[1024]; 122 | final int n = parse(jsonBytes, 0, jsonBytes.length, tokens); 123 | System.out.println(n + ": " + jsonBytes.length + "/" + json.length()); 124 | for (int i = 0; i < n; i += 4) { 125 | System.out.printf("%2d: %d[%d]: %2d-%2d %2d: %s%n", 126 | i, tokens[i] >>> TYPE_SHIFT, tokens[i] & SIZE_MASK, tokens[i + 1], tokens[i + 2], tokens[i + 3], 127 | new String(jsonBytes, tokens[i + 1], tokens[i + 2] - tokens[i + 1])); 128 | } 129 | System.out.println("==="); 130 | } 131 | } 132 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 29 | 52 | 53 | 54 | 55 | 56 | -------------------------------------------------------------------------------- /test/jason/TestNumberParser.java: -------------------------------------------------------------------------------- 1 | package jason; 2 | 3 | import java.nio.charset.StandardCharsets; 4 | import java.util.concurrent.ThreadLocalRandom; 5 | 6 | public final class TestNumberParser { 7 | public static void testReader() { 8 | byte[][] tests = {"3.1234567 ".getBytes(), "31234567 ".getBytes(), "0.31234567 ".getBytes(), 9 | "312.34567 ".getBytes(), "3.1234567e7 ".getBytes(), "3.1234567E-7 ".getBytes(), "0 ".getBytes(), 10 | "1.0 ".getBytes()}; 11 | JsonReader jr = new JsonReader(); 12 | double r = 0; 13 | for (int i = 0; i < 10_000_000; i++) { 14 | for (int j = 0; j < 8; j++) 15 | r += jr.buf(tests[j]).parseDouble(); 16 | } 17 | System.out.format("%s.testReader: %15.6f\n", TestNumberParser.class.getSimpleName(), r); // 624694507922444.400000 18 | } 19 | 20 | public static void testWriter() { 21 | double[] tests = {3.1234567, 31234567, 0.31234567, 312.34567, 3.1234567e7, 3.1234567E-7, 0, 1.0}; 22 | JsonWriter jw = new JsonWriter(); 23 | int n = 0; 24 | for (int i = 0; i < 10_000_000; i++) { 25 | for (int j = 0; j < 8; j++) { 26 | // n += Double.toString(tests[j]).length(); 27 | jw.clear().write(tests[j]); 28 | n += jw.size(); 29 | // System.out.println(new String(jw.buf, 0, jw.pos)); 30 | } 31 | } 32 | System.out.format("%s.testWriter: %d\n", TestNumberParser.class.getSimpleName(), n); // 660000000 33 | } 34 | 35 | public static void testRandomDoubleParser() { 36 | int e1 = 0, e2 = 0; 37 | final JsonReader jr = JsonReader.local(); 38 | final ThreadLocalRandom r = ThreadLocalRandom.current(); 39 | final long t = System.nanoTime(); 40 | for (int i = 0; i < 10_000_000; i++) { 41 | long v; 42 | if (i < 400) { 43 | if (i < 100) 44 | v = i; 45 | else if (i < 200) 46 | v = 0x10_0000_0000_0000L - (i - 99); 47 | else if (i < 300) 48 | v = 0x7fe0_0000_0000_0000L + (i - 200); 49 | else 50 | v = 0x7ff0_0000_0000_0000L - (i - 299); 51 | } else { 52 | do 53 | v = r.nextLong(); 54 | while ((v & 0x7ff0_0000_0000_0000L) == 0x7ff0_0000_0000_0000L); 55 | } 56 | final double f = Double.longBitsToDouble(v); 57 | final double f2 = jr.buf((f + " ").getBytes(StandardCharsets.ISO_8859_1)).parseDouble(); 58 | if (f != f2) { 59 | double f3, f4, f5, f6; 60 | if (f == (f3 = Math.nextDown(f2)) || f == (f5 = Math.nextUp(f2))) 61 | e1++; 62 | else if (f == (f4 = Math.nextDown(f3)) || f == (f6 = Math.nextUp(f5))) 63 | e2++; 64 | else { 65 | throw new AssertionError("testRandomDoubleParser[" + i + "]:" 66 | + "\n " + f 67 | + "\n != " + f2 68 | + "\n-2: " + f4 69 | + "\n-1: " + f3 70 | + "\n+1: " + f5 71 | + "\n+2: " + f6); 72 | } 73 | } 74 | } 75 | System.out.println("testRandomDoubleParser OK! " + (System.nanoTime() - t) / 1_000_000 76 | + " ms, errors=" + e1 + "+" + e2); 77 | } 78 | 79 | public static void testRandomFloatParser() { 80 | final JsonReader jr = JsonReader.local(); 81 | final ThreadLocalRandom r = ThreadLocalRandom.current(); 82 | final long t = System.nanoTime(); 83 | for (int i = 0; i < 10_000_000; i++) { 84 | int v; 85 | if (i < 400) { 86 | if (i < 100) 87 | v = i; 88 | else if (i < 200) 89 | v = 0x80_0000 - (i - 99); 90 | else if (i < 300) 91 | v = 0x7f00_0000 + (i - 200); 92 | else 93 | v = 0x7f80_0000 - (i - 299); 94 | } else { 95 | do 96 | v = r.nextInt(); 97 | while ((v & 0x7f80_0000) == 0x7f80_0000); 98 | } 99 | final float f = Float.intBitsToFloat(v); 100 | final float f2 = (float)jr.buf((f + " ").getBytes(StandardCharsets.ISO_8859_1)).parseDouble(); 101 | if (f != f2) 102 | throw new AssertionError("testRandomFloatParser[" + i + "]: " + f + " != " + f2); 103 | } 104 | System.out.println("testRandomFloatParser OK! " + (System.nanoTime() - t) / 1_000_000 + " ms"); 105 | } 106 | 107 | public static void main(String[] args) { 108 | for (int i = 0; i < 5; i++) 109 | testRandomDoubleParser(); 110 | for (int i = 0; i < 5; i++) 111 | testRandomFloatParser(); 112 | 113 | long t = System.nanoTime(); 114 | testReader(); 115 | System.out.println(TestNumberParser.class.getSimpleName() + ".testReader: " + 116 | (System.nanoTime() - t) / 1_000_000 + " ms"); 117 | t = System.nanoTime(); 118 | testWriter(); 119 | System.out.println(TestNumberParser.class.getSimpleName() + ".testWriter: " + 120 | (System.nanoTime() - t) / 1_000_000 + " ms"); 121 | } 122 | } 123 | -------------------------------------------------------------------------------- /.settings/org.eclipse.jdt.ui.prefs: -------------------------------------------------------------------------------- 1 | cleanup.add_default_serial_version_id=true 2 | cleanup.add_generated_serial_version_id=false 3 | cleanup.add_missing_annotations=true 4 | cleanup.add_missing_deprecated_annotations=true 5 | cleanup.add_missing_methods=true 6 | cleanup.add_missing_nls_tags=false 7 | cleanup.add_missing_override_annotations=true 8 | cleanup.add_missing_override_annotations_interface_methods=true 9 | cleanup.add_serial_version_id=false 10 | cleanup.always_use_blocks=false 11 | cleanup.always_use_parentheses_in_expressions=false 12 | cleanup.always_use_this_for_non_static_field_access=false 13 | cleanup.always_use_this_for_non_static_method_access=false 14 | cleanup.convert_functional_interfaces=true 15 | cleanup.convert_to_enhanced_for_loop=true 16 | cleanup.correct_indentation=false 17 | cleanup.format_source_code=true 18 | cleanup.format_source_code_changes_only=false 19 | cleanup.insert_inferred_type_arguments=false 20 | cleanup.make_local_variable_final=false 21 | cleanup.make_parameters_final=false 22 | cleanup.make_private_fields_final=true 23 | cleanup.make_type_abstract_if_missing_method=false 24 | cleanup.make_variable_declarations_final=true 25 | cleanup.never_use_blocks=true 26 | cleanup.never_use_parentheses_in_expressions=true 27 | cleanup.number_suffix=true 28 | cleanup.organize_imports=true 29 | cleanup.push_down_negation=true 30 | cleanup.qualify_static_field_accesses_with_declaring_class=false 31 | cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true 32 | cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true 33 | cleanup.qualify_static_member_accesses_with_declaring_class=true 34 | cleanup.qualify_static_method_accesses_with_declaring_class=false 35 | cleanup.remove_private_constructors=true 36 | cleanup.remove_redundant_modifiers=true 37 | cleanup.remove_redundant_semicolons=true 38 | cleanup.remove_redundant_type_arguments=true 39 | cleanup.remove_trailing_whitespaces=true 40 | cleanup.remove_trailing_whitespaces_all=true 41 | cleanup.remove_trailing_whitespaces_ignore_empty=false 42 | cleanup.remove_unnecessary_array_creation=true 43 | cleanup.remove_unnecessary_casts=true 44 | cleanup.remove_unnecessary_nls_tags=true 45 | cleanup.remove_unused_imports=true 46 | cleanup.remove_unused_local_variables=true 47 | cleanup.remove_unused_private_fields=true 48 | cleanup.remove_unused_private_members=false 49 | cleanup.remove_unused_private_methods=true 50 | cleanup.remove_unused_private_types=true 51 | cleanup.simplify_lambda_expression_and_method_ref=true 52 | cleanup.sort_members=false 53 | cleanup.sort_members_all=false 54 | cleanup.use_anonymous_class_creation=false 55 | cleanup.use_autoboxing=true 56 | cleanup.use_blocks=false 57 | cleanup.use_blocks_only_for_return_and_throw=false 58 | cleanup.use_directly_map_method=true 59 | cleanup.use_lambda=true 60 | cleanup.use_parentheses_in_expressions=false 61 | cleanup.use_this_for_non_static_field_access=true 62 | cleanup.use_this_for_non_static_field_access_only_if_necessary=true 63 | cleanup.use_this_for_non_static_method_access=true 64 | cleanup.use_this_for_non_static_method_access_only_if_necessary=true 65 | cleanup.use_type_arguments=false 66 | cleanup.use_unboxing=true 67 | cleanup_profile=_my 68 | cleanup_settings_version=2 69 | eclipse.preferences.version=1 70 | editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true 71 | formatter_profile=_Eclipse fixed 72 | formatter_settings_version=19 73 | org.eclipse.jdt.ui.exception.name=e 74 | org.eclipse.jdt.ui.gettersetter.use.is=true 75 | org.eclipse.jdt.ui.keywordthis=false 76 | org.eclipse.jdt.ui.overrideannotation=true 77 | org.eclipse.jdt.ui.text.custom_code_templates= 78 | sp_cleanup.add_default_serial_version_id=true 79 | sp_cleanup.add_generated_serial_version_id=false 80 | sp_cleanup.add_missing_annotations=false 81 | sp_cleanup.add_missing_deprecated_annotations=true 82 | sp_cleanup.add_missing_methods=false 83 | sp_cleanup.add_missing_nls_tags=false 84 | sp_cleanup.add_missing_override_annotations=true 85 | sp_cleanup.add_missing_override_annotations_interface_methods=true 86 | sp_cleanup.add_serial_version_id=false 87 | sp_cleanup.always_use_blocks=true 88 | sp_cleanup.always_use_parentheses_in_expressions=false 89 | sp_cleanup.always_use_this_for_non_static_field_access=false 90 | sp_cleanup.always_use_this_for_non_static_method_access=false 91 | sp_cleanup.convert_functional_interfaces=false 92 | sp_cleanup.convert_to_enhanced_for_loop=false 93 | sp_cleanup.correct_indentation=false 94 | sp_cleanup.format_source_code=false 95 | sp_cleanup.format_source_code_changes_only=false 96 | sp_cleanup.insert_inferred_type_arguments=false 97 | sp_cleanup.make_local_variable_final=false 98 | sp_cleanup.make_parameters_final=false 99 | sp_cleanup.make_private_fields_final=true 100 | sp_cleanup.make_type_abstract_if_missing_method=false 101 | sp_cleanup.make_variable_declarations_final=false 102 | sp_cleanup.never_use_blocks=false 103 | sp_cleanup.never_use_parentheses_in_expressions=true 104 | sp_cleanup.on_save_use_additional_actions=true 105 | sp_cleanup.organize_imports=false 106 | sp_cleanup.push_down_negation=false 107 | sp_cleanup.qualify_static_field_accesses_with_declaring_class=false 108 | sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true 109 | sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true 110 | sp_cleanup.qualify_static_member_accesses_with_declaring_class=false 111 | sp_cleanup.qualify_static_method_accesses_with_declaring_class=false 112 | sp_cleanup.remove_private_constructors=true 113 | sp_cleanup.remove_redundant_modifiers=false 114 | sp_cleanup.remove_redundant_semicolons=false 115 | sp_cleanup.remove_redundant_type_arguments=false 116 | sp_cleanup.remove_trailing_whitespaces=true 117 | sp_cleanup.remove_trailing_whitespaces_all=true 118 | sp_cleanup.remove_trailing_whitespaces_ignore_empty=false 119 | sp_cleanup.remove_unnecessary_array_creation=false 120 | sp_cleanup.remove_unnecessary_casts=false 121 | sp_cleanup.remove_unnecessary_nls_tags=false 122 | sp_cleanup.remove_unused_imports=true 123 | sp_cleanup.remove_unused_local_variables=false 124 | sp_cleanup.remove_unused_private_fields=true 125 | sp_cleanup.remove_unused_private_members=false 126 | sp_cleanup.remove_unused_private_methods=true 127 | sp_cleanup.remove_unused_private_types=true 128 | sp_cleanup.sort_members=false 129 | sp_cleanup.sort_members_all=false 130 | sp_cleanup.use_anonymous_class_creation=false 131 | sp_cleanup.use_autoboxing=false 132 | sp_cleanup.use_blocks=false 133 | sp_cleanup.use_blocks_only_for_return_and_throw=false 134 | sp_cleanup.use_lambda=false 135 | sp_cleanup.use_parentheses_in_expressions=false 136 | sp_cleanup.use_this_for_non_static_field_access=false 137 | sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true 138 | sp_cleanup.use_this_for_non_static_method_access=false 139 | sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true 140 | sp_cleanup.use_type_arguments=false 141 | sp_cleanup.use_unboxing=false 142 | -------------------------------------------------------------------------------- /test/jason/TestWriter.java: -------------------------------------------------------------------------------- 1 | package jason; 2 | 3 | import java.util.concurrent.ThreadLocalRandom; 4 | 5 | public class TestWriter { 6 | static final JsonWriter jw = new JsonWriter(); 7 | static final JsonReader jr = new JsonReader(); 8 | static int count; 9 | 10 | static void testInt(int d) { 11 | jw.free().ensure(11); 12 | jw.write(d); 13 | String ss = jw.toString(); 14 | jr.buf(jw.toBytes()); 15 | long d2 = jr.parseInt(); 16 | if (d != d2) 17 | throw new IllegalStateException("check err: " + d + " => '" + ss + "' => " + d2); 18 | if (jw.size() > 11) 19 | throw new IllegalStateException("too long size: " + d + " => '" + ss + "' => " + d2); 20 | count++; 21 | } 22 | 23 | static void testInt(int d, String s) { 24 | jw.free().ensure(11); 25 | jw.write(d); 26 | String ss = jw.toString(); 27 | jr.buf(jw.toBytes()); 28 | long d2 = jr.parseInt(); 29 | if (d != d2) 30 | throw new IllegalStateException("check err: " + d + " => '" + ss + "' => " + d2); 31 | if (jw.size() > 11) 32 | throw new IllegalStateException("too long size: " + d + " => '" + ss + "' => " + d2); 33 | if (!ss.equals(s)) 34 | throw new IllegalStateException("check err: " + d + " => '" + ss + "' != '" + s + "'"); 35 | count++; 36 | } 37 | 38 | static void testLong(long d) { 39 | if (d >= Integer.MIN_VALUE && d <= Integer.MAX_VALUE) 40 | testInt((int)d); 41 | jw.free().ensure(20); 42 | jw.write(d); 43 | String ss = jw.toString(); 44 | jr.buf(jw.toBytes()); 45 | long d2 = jr.parseLong(); 46 | if (d != d2) 47 | throw new IllegalStateException("check err: " + d + " => '" + ss + "' => " + d2); 48 | if (jw.size() > 20) 49 | throw new IllegalStateException("too long size: " + d + " => '" + ss + "' => " + d2); 50 | count++; 51 | } 52 | 53 | static void testLong(long d, String s) { 54 | if (d >= Integer.MIN_VALUE && d <= Integer.MAX_VALUE) 55 | testInt((int)d); 56 | jw.free().ensure(20); 57 | jw.write(d); 58 | String ss = jw.toString(); 59 | jr.buf(jw.toBytes()); 60 | long d2 = jr.parseLong(); 61 | if (d != d2) 62 | throw new IllegalStateException("check err: " + d + " => '" + ss + "' => " + d2); 63 | if (jw.size() > 20) 64 | throw new IllegalStateException("too long size: " + d + " => '" + ss + "' => " + d2); 65 | if (!ss.equals(s)) 66 | throw new IllegalStateException("check err: " + d + " => '" + ss + "' != '" + s + "'"); 67 | count++; 68 | } 69 | 70 | static void testDouble(double d) { 71 | jw.free().ensure(25); 72 | jw.write(d); 73 | String ss = jw.toString(); 74 | jr.buf(jw.toBytes()); 75 | double d2 = jr.parseDouble(); 76 | if (d != d2) 77 | throw new IllegalStateException("check err: " + d + " => '" + ss + "' => " + d2); 78 | if (jw.size() > 25) 79 | throw new IllegalStateException("too long size: " + d + " => '" + ss + "' => " + d2); 80 | count++; 81 | } 82 | 83 | static void testDouble(double d, String s) { 84 | jw.free().ensure(25); 85 | jw.write(d); 86 | String ss = jw.toString(); 87 | jr.buf(jw.toBytes()); 88 | double d2 = jr.parseDouble(); 89 | if (d != d2) 90 | throw new IllegalStateException("check err: " + d + " => '" + ss + "' => " + d2); 91 | if (jw.size() > 25) 92 | throw new IllegalStateException("too long size: " + d + " => '" + ss + "' => " + d2); 93 | if (!ss.equals(s)) 94 | throw new IllegalStateException("check err: " + d + " => '" + ss + "' != '" + s + "'"); 95 | count++; 96 | } 97 | 98 | static void testDouble(int maxDecimalPlaces, double d, String s) { 99 | testDouble(d); 100 | jw.free().ensure(25); 101 | jw.write(d, maxDecimalPlaces); 102 | String ss = jw.toString(); 103 | if (!ss.equals(s)) 104 | throw new IllegalStateException("check err: " + d + " => '" + ss + "' != '" + s + "'"); 105 | count++; 106 | } 107 | 108 | public static void testDoubleRange() { 109 | final JsonWriter jw = JsonWriter.local(); 110 | double d = 0.01; 111 | for (int j = 0; j < 5; j++, d *= 10) { 112 | long dd = Double.doubleToRawLongBits(d); 113 | for (int i = 0; i < 1_000_000; i++) { 114 | final double f = Double.longBitsToDouble(dd + i); 115 | jw.clear().write(f); 116 | final String s = jw.toString(); 117 | final double f2 = Double.parseDouble(s); 118 | if (f != f2) 119 | throw new AssertionError("testDoubleRange[" + j + "," + i + "]: " + f + " != " + f2 + ", " + s); 120 | } 121 | } 122 | for (long e = 0; e < 2048; e++) { 123 | final double f = Double.doubleToRawLongBits(e << 52); 124 | jw.clear().write(f); 125 | final String s = jw.toString(); 126 | final double f2 = Double.parseDouble(s); 127 | if (f != f2) 128 | throw new AssertionError("testDoubleRange[e" + e + "]: " + f + " != " + f2 + ", " + s); 129 | } 130 | for (long e = 0; e < 2048; e++) { 131 | final double f = Double.doubleToRawLongBits((e << 52) + 1); 132 | jw.clear().write(f); 133 | final String s = jw.toString(); 134 | final double f2 = Double.parseDouble(s); 135 | //noinspection ConstantValue 136 | if (f != f2 && !(Double.isNaN(f) && Double.isNaN(f2))) 137 | throw new AssertionError("testDoubleRange[e" + e + ":1]: " + f + " != " + f2 + ", " + s); 138 | } 139 | for (int i = 0; i < 1_000_000; i++) { 140 | final double f = Double.doubleToRawLongBits(i); 141 | jw.clear().write(f); 142 | final String s = jw.toString(); 143 | final double f2 = Double.parseDouble(s); 144 | if (f != f2) 145 | throw new AssertionError("testDoubleRange[" + i + "]: " + f + " != " + f2 + ", " + s); 146 | } 147 | System.out.println("testDoubleRange OK!"); 148 | } 149 | 150 | public static void testDoubleRandom() { 151 | final JsonWriter jw = JsonWriter.local(); 152 | final ThreadLocalRandom r = ThreadLocalRandom.current(); 153 | for (int i = 0; i < 10_000_000; i++) { 154 | long v = r.nextLong(); 155 | if ((v & 0x7ff0_0000_0000_0000L) == 0x7ff0_0000_0000_0000L) { 156 | v &= 0xfff8_0000_0000_0000L; // Infinity/-Infinity/NaN 157 | if (v == 0xfff8_0000_0000_0000L) 158 | v = 0x7ff8_0000_0000_0000L; 159 | } 160 | final double f = Double.longBitsToDouble(v); 161 | jw.clear().write(f); 162 | final String s = jw.toString(); 163 | final double f2 = Double.parseDouble(s); 164 | if (f != f2 && !(Double.isNaN(f) && Double.isNaN(f2))) 165 | throw new AssertionError("testDoubleRandom[" + i + "]: " + f + " != " + f2 + ", " + s); 166 | } 167 | System.out.println("testDoubleRandom OK!"); 168 | } 169 | 170 | public static void main(String[] args) { 171 | testLong(0); 172 | testLong(1); 173 | testLong(-1); 174 | testLong(9); 175 | testLong(-9); 176 | testLong(10); 177 | testLong(-10); 178 | testLong(11); 179 | testLong(-11); 180 | testLong(Integer.MAX_VALUE); 181 | testLong(-Integer.MAX_VALUE); 182 | testLong(Integer.MIN_VALUE); 183 | testLong(0x8000_0000L); 184 | testLong(Long.MAX_VALUE); 185 | testLong(-Long.MAX_VALUE); 186 | testLong(Long.MIN_VALUE); 187 | for (int i = 0; i < 32; i++) { 188 | testLong(0x5a5a_5a5a_5a5a_5a5aL >> i); 189 | testLong(0xa5a5_a5a5_a5a5_a5a5L >> i); 190 | } 191 | 192 | testDouble(0.0, "0.0"); 193 | testDouble(-0.0, "-0.0"); 194 | testDouble(1.0, "1.0"); 195 | testDouble(-1.0, "-1.0"); 196 | testDouble(1.2345, "1.2345"); 197 | testDouble(1.2345678, "1.2345678"); 198 | testDouble(0.123456789012, "0.123456789012"); 199 | testDouble(1234567.8, "1234567.8"); 200 | testDouble(-79.39773355813419, "-79.39773355813419"); 201 | testDouble(-36.973846435546875, "-36.973846435546875"); 202 | testDouble(0.000001, "0.000001"); 203 | testDouble(0.0000001, "1e-7"); 204 | testDouble(1e30, "1e30"); 205 | testDouble(1.234567890123456e30, "1.234567890123456e30"); 206 | testDouble(5e-324, "5e-324"); // Min subnormal positive double 207 | testDouble(2.225073858507201e-308, "2.225073858507201e-308"); // Max subnormal positive double 208 | testDouble(2.2250738585072014e-308, "2.2250738585072014e-308"); // Min normal positive double 209 | testDouble(1.7976931348623157e308, "1.7976931348623157e308"); // Max double 210 | 211 | testDouble(3, 0.0, "0.0"); 212 | testDouble(1, 0.0, "0.0"); 213 | testDouble(3, -0.0, "-0.0"); 214 | testDouble(3, 1.0, "1.0"); 215 | testDouble(3, -1.0, "-1.0"); 216 | testDouble(3, 1.2345, "1.234"); 217 | testDouble(2, 1.2345, "1.23"); 218 | testDouble(1, 1.2345, "1.2"); 219 | testDouble(3, 1.2345678, "1.234"); 220 | testDouble(3, 1.0001, "1.0"); 221 | testDouble(2, 1.0001, "1.0"); 222 | testDouble(1, 1.0001, "1.0"); 223 | testDouble(3, 0.123456789012, "0.123"); 224 | testDouble(2, 0.123456789012, "0.12"); 225 | testDouble(1, 0.123456789012, "0.1"); 226 | testDouble(4, 0.0001, "0.0001"); 227 | testDouble(3, 0.0001, "0.0"); 228 | testDouble(2, 0.0001, "0.0"); 229 | testDouble(1, 0.0001, "0.0"); 230 | testDouble(3, 1234567.8, "1234567.8"); 231 | testDouble(3, 1e30, "1e30"); 232 | testDouble(3, 5e-324, "0.0"); // Min subnormal positive double 233 | testDouble(3, 2.225073858507201e-308, "0.0"); // Max subnormal positive double 234 | testDouble(3, 2.2250738585072014e-308, "0.0"); // Min normal positive double 235 | testDouble(3, 1.7976931348623157e308, "1.7976931348623157e308"); // Max double 236 | testDouble(5, -0.14000000000000001, "-0.14"); 237 | testDouble(4, -0.14000000000000001, "-0.14"); 238 | testDouble(3, -0.14000000000000001, "-0.14"); 239 | testDouble(3, -0.10000000000000001, "-0.1"); 240 | testDouble(2, -0.10000000000000001, "-0.1"); 241 | testDouble(1, -0.10000000000000001, "-0.1"); 242 | System.out.println(TestWriter.class.getSimpleName() + ": " + count + " tests OK!"); 243 | 244 | testDoubleRange(); 245 | testDoubleRandom(); 246 | } 247 | } 248 | -------------------------------------------------------------------------------- /test/jason/Test.java: -------------------------------------------------------------------------------- 1 | package jason; 2 | 3 | import java.net.Inet4Address; 4 | import java.nio.charset.StandardCharsets; 5 | import java.util.*; 6 | 7 | public final class Test { 8 | static class A { 9 | int a; 10 | } 11 | 12 | static class B extends A { 13 | int b; 14 | } 15 | 16 | static class C { 17 | A a = new B(); 18 | C c; 19 | Map m = new HashMap<>(); 20 | } 21 | 22 | public static void assertNotNull(Object a) { 23 | if (a == null) 24 | throw new AssertionError("null"); 25 | } 26 | 27 | public static void assertEquals(int a, int b) { 28 | if (a != b) 29 | throw new AssertionError(a + " != " + b); 30 | } 31 | 32 | public static void assertEquals(Object a, Object b) { 33 | if (!Objects.equals(a, b)) 34 | throw new AssertionError(a + " != " + b); 35 | } 36 | 37 | public static void test1() throws ReflectiveOperationException { 38 | byte[] buf = "{a:[{x:1,y:2},{x:3,y:4},{x:5,y:6}]}".getBytes(); 39 | Object obj = JsonReader.local().buf(buf).parse(); 40 | assertNotNull(obj); 41 | assertEquals("{a=[{x=1, y=2}, {x=3, y=4}, {x=5, y=6}]}", obj.toString()); 42 | } 43 | 44 | public static void test2() throws ReflectiveOperationException { 45 | C c = JsonReader.local().buf("{a:{a:1,b:2}}").parse(C.class); 46 | assertNotNull(c); 47 | assertEquals(B.class, c.a.getClass()); 48 | assertEquals(1, c.a.a); 49 | assertEquals(2, ((B)c.a).b); 50 | 51 | c.a = new A(); 52 | c = JsonReader.local().buf("{a:{a:3,b:4}}").parse(c); 53 | assertNotNull(c); 54 | assertEquals(A.class, c.a.getClass()); 55 | assertEquals(3, c.a.a); 56 | 57 | c.a = null; 58 | c = JsonReader.local().buf("{a:{a:5,b:6}}").parse(c); 59 | assertNotNull(c); 60 | assertEquals(A.class, c.a.getClass()); 61 | assertEquals(5, c.a.a); 62 | 63 | Json.instance.getClassMeta(A.class).setParser((json, __, ___, ____, _____) -> json.parse(B.class)); 64 | c.a = null; 65 | c = JsonReader.local().buf("{a:{a:7,b:8}}").parse(c); 66 | assertNotNull(c); 67 | assertEquals(B.class, c.a.getClass()); 68 | assertEquals(7, c.a.a); 69 | assertEquals(8, ((B)c.a).b); 70 | 71 | B b = JsonReader.local().buf("{a:5 \n b:6}").parse(B.class); 72 | assertNotNull(b); 73 | assertEquals(B.class, b.getClass()); 74 | assertEquals(5, b.a); 75 | assertEquals(6, b.b); 76 | } 77 | 78 | public static void test3() { 79 | C c = new C(); 80 | c.a.a = 1; 81 | ((B)c.a).b = -1; 82 | String json = JsonWriter.local().clear().setNoQuoteKey(false).write(c).toString(); 83 | assertEquals("{\"a\":{\"a\":1,\"b\":-1},\"m\":{}}", json); 84 | } 85 | 86 | public static void test4() { 87 | C c = new C(); 88 | c.a.a = 1; 89 | ((B)c.a).b = -1; 90 | String json = JsonWriter.local().clear().setFlags(JsonWriter.FLAG_PRETTY_FORMAT).write(c).toString(); 91 | assertEquals("{\n" + 92 | "\t\"a\": {\n" + 93 | "\t\t\"a\": 1,\n" + 94 | "\t\t\"b\": -1\n" + 95 | "\t},\n" + 96 | "\t\"m\": {}\n" + 97 | "}", json); 98 | } 99 | 100 | public static void test5() { 101 | C c = new C(); 102 | c.a.a = 1; 103 | ((B)c.a).b = -1; 104 | String json = JsonWriter.local().clear().setFlags(JsonWriter.FLAG_NO_QUOTE_KEY).write(c).toString(); 105 | assertEquals("{a:{a:1,b:-1},m:{}}", json); 106 | } 107 | 108 | public static void test6() { 109 | C c = new C(); 110 | c.a.a = 1; 111 | ((B)c.a).b = -1; 112 | String json = JsonWriter.local().clear().setFlags(JsonWriter.FLAG_WRITE_NULL).write(c).toString(); 113 | assertEquals("{\"a\":{\"a\":1,\"b\":-1},\"c\":null,\"m\":{}}", json); 114 | } 115 | 116 | public static void test7() { 117 | System.out.println(System.getProperty("java.version")); 118 | System.out.println(Json.instance.getClassMeta(Inet4Address.class)); 119 | } 120 | 121 | static class D { 122 | final HashMap m = new HashMap<>(); 123 | } 124 | 125 | public static void test8() throws ReflectiveOperationException { 126 | D d = new D(); 127 | d.m.put(123, 456); 128 | String s = JsonWriter.local().clear().setFlags(0).write(d).toString(); 129 | assertEquals("{\"m\":{\"123\":456}}", s); 130 | d.m.clear(); 131 | JsonReader.local().buf("{\"m\":{123:456}}").parse(d); 132 | assertEquals(1, d.m.size()); 133 | assertEquals(String.valueOf(456), String.valueOf(d.m.get(123))); 134 | assertEquals(Integer.class, d.m.entrySet().iterator().next().getKey().getClass()); 135 | } 136 | 137 | static class E { 138 | int a; 139 | E e; 140 | } 141 | 142 | public static void test9() { 143 | E e = new E(); 144 | e.a = 123; 145 | e.e = e; 146 | String json = JsonWriter.local().clear().setDepthLimit(4).write(e).toString(); 147 | assertEquals("{\"a\":123,\"e\":{\"a\":123,\"e\":{\"a\":123,\"e\":{\"a\":123,\"e\":\"!OVERDEPTH!\"}}}}", json); 148 | } 149 | 150 | abstract static class F1 { 151 | int f; 152 | } 153 | 154 | static class F2 extends ArrayList