pax_global_header00006660000000000000000000000064130466417110014515gustar00rootroot0000000000000052 comment=4d2b0beacf139f30591a8411a4128613e82b739c java-jsoniter-java-0.9.8/000077500000000000000000000000001304664171100152265ustar00rootroot00000000000000java-jsoniter-java-0.9.8/.gitignore000066400000000000000000000000661304664171100172200ustar00rootroot00000000000000*.iml /target /release.properties /demo/target /.idea java-jsoniter-java-0.9.8/LICENSE000066400000000000000000000020501304664171100162300ustar00rootroot00000000000000MIT License Copyright (c) 2016 Tao Wen Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. java-jsoniter-java-0.9.8/README.md000066400000000000000000000003061304664171100165040ustar00rootroot00000000000000Documentation: [http://jsoniter.com/java-features.html](http://jsoniter.com/java-features.html) [![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/json-iterator/Lobby)java-jsoniter-java-0.9.8/demo/000077500000000000000000000000001304664171100161525ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/pom.xml000066400000000000000000000132441304664171100174730ustar00rootroot00000000000000 4.0.0 com.jsoniter 0.9.8-SNAPSHOT jsoniter-demo json iterator jsoniter (json-iterator) is fast and flexible JSON parser available in Java and Go http://jsoniter.com jar MIT License http://www.opensource.org/licenses/mit-license.php Tao Wen taowen@gmail.com jsoniter http://jsoniter.com scm:git:git://github.com/json-iterator/java.git scm:git:ssh://github.com:json-iterator/java.git http://github.com/json-iterator/java/tree/master UTF-8 junit junit 4.12 org.javassist javassist 3.21.0-GA com.jsoniter jsoniter 0.9.8-SNAPSHOT org.openjdk.jmh jmh-core 1.17.3 org.openjdk.jmh jmh-generator-annprocess 1.17.3 com.fasterxml.jackson.core jackson-databind 2.8.5 com.fasterxml.jackson.module jackson-module-afterburner 2.8.5 com.dslplatform dsl-json 1.3.2 org.apache.thrift libthrift 0.9.1 org.slf4j slf4j-api 1.7.22 com.dslplatform dsl-json-processor 1.4.1 com.alibaba fastjson 1.2.22 com.squareup.moshi moshi 1.3.1 com.google.protobuf protobuf-java 3.2.0rc2 org.apache.maven.plugins maven-compiler-plugin 3.6.0 1.8 1.8 UTF-8 org.codehaus.mojo exec-maven-plugin 1.5.0 static-codegen compile exec java ${project.build.sourceDirectory} -classpath com.jsoniter.StaticCodeGenerator com.jsoniter.demo.DemoCodegenConfig ossrh https://oss.sonatype.org/content/repositories/snapshots java-jsoniter-java-0.9.8/demo/src/000077500000000000000000000000001304664171100167415ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/000077500000000000000000000000001304664171100176655ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/000077500000000000000000000000001304664171100206065ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/com/000077500000000000000000000000001304664171100213645ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/com/jsoniter/000077500000000000000000000000001304664171100232215ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/com/jsoniter/demo/000077500000000000000000000000001304664171100241455ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/com/jsoniter/demo/Demo.java000066400000000000000000000014741304664171100257020ustar00rootroot00000000000000package com.jsoniter.demo; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; public class Demo { static { // ensure the jsoniter is properly setup new DemoCodegenConfig().setup(); JsonIterator.setMode(DecodingMode.STATIC_MODE); JsonStream.setMode(EncodingMode.STATIC_MODE); JsonStream.defaultIndentionStep = 2; } public static void main(String[] args) { User user = JsonIterator.deserialize("{\"firstName\": \"tao\", \"lastName\": \"wen\", \"score\": \"1024\"}", User.class); System.out.println(user.firstName); System.out.println(user.lastName); System.out.println(user.score); System.out.println(JsonStream.serialize(user)); } } java-jsoniter-java-0.9.8/demo/src/main/java/com/jsoniter/demo/DemoCodegenConfig.java000066400000000000000000000031451304664171100303120ustar00rootroot00000000000000package com.jsoniter.demo; import com.jsoniter.JsonIterator; import com.jsoniter.StaticCodeGenerator; import com.jsoniter.annotation.JsoniterAnnotationSupport; import com.jsoniter.spi.CodegenConfig; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.util.List; import java.util.Map; public class DemoCodegenConfig implements CodegenConfig { @Override public void setup() { JsoniterAnnotationSupport.enable(); // register custom decoder or extensions before codegen // so that we doing codegen, we know in which case, we need to callback JsoniterSpi.registerPropertyDecoder(User.class, "score", new Decoder.IntDecoder() { @Override public int decodeInt(JsonIterator iter) throws IOException { return Integer.valueOf(iter.readString()); } }); } @Override public TypeLiteral[] whatToCodegen() { return new TypeLiteral[]{ // generic types, need to use this syntax new TypeLiteral>() { }, new TypeLiteral>() { }, new TypeLiteral>() { }, // array TypeLiteral.create(int[].class), // object TypeLiteral.create(User.class) }; } public static void main(String[] args) throws Exception { StaticCodeGenerator.main(new String[]{DemoCodegenConfig.class.getCanonicalName()}); } } java-jsoniter-java-0.9.8/demo/src/main/java/com/jsoniter/demo/User.java000066400000000000000000000003671304664171100257340ustar00rootroot00000000000000package com.jsoniter.demo; import com.jsoniter.annotation.JsonProperty; public class User { @JsonProperty(nullable = false) public String firstName; @JsonProperty(nullable = false) public String lastName; public int score; } java-jsoniter-java-0.9.8/demo/src/main/java/decoder/000077500000000000000000000000001304664171100222135ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/com/000077500000000000000000000000001304664171100227715ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/com/jsoniter/000077500000000000000000000000001304664171100246265ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/com/jsoniter/demo/000077500000000000000000000000001304664171100255525ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/com/jsoniter/demo/User.java000066400000000000000000000043731304664171100273420ustar00rootroot00000000000000package decoder.com.jsoniter.demo; public class User implements com.jsoniter.spi.Decoder { public static java.lang.Object decode_(com.jsoniter.JsonIterator iter) throws java.io.IOException { if (iter.readNull()) { com.jsoniter.CodegenAccess.resetExistingObject(iter); return null; } com.jsoniter.demo.User obj = (com.jsoniter.CodegenAccess.existingObject(iter) == null ? new com.jsoniter.demo.User() : (com.jsoniter.demo.User)com.jsoniter.CodegenAccess.resetExistingObject(iter)); if (!com.jsoniter.CodegenAccess.readObjectStart(iter)) { return obj; } int hash = com.jsoniter.CodegenAccess.readObjectFieldAsHash(iter); if (hash == -1078100014) { obj.lastName = (java.lang.String)iter.readString(); } else { switch (hash) { case -1078100014: obj.lastName = (java.lang.String)iter.readString(); break; case -799547430: obj.firstName = (java.lang.String)iter.readString(); break; case -768634731: obj.score = com.jsoniter.CodegenAccess.readInt("score@decoder.com.jsoniter.demo.User", iter); break; default: iter.skip(); } } while (true) { if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { break; } hash = com.jsoniter.CodegenAccess.readObjectFieldAsHash(iter); if (hash == -799547430) { obj.firstName = (java.lang.String)iter.readString(); } else { switch (hash) { case -1078100014: obj.lastName = (java.lang.String)iter.readString(); continue; case -799547430: obj.firstName = (java.lang.String)iter.readString(); continue; case -768634731: obj.score = com.jsoniter.CodegenAccess.readInt("score@decoder.com.jsoniter.demo.User", iter); continue; default: iter.skip(); } } if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { break; } hash = com.jsoniter.CodegenAccess.readObjectFieldAsHash(iter); if (hash == -768634731) { obj.score = com.jsoniter.CodegenAccess.readInt("score@decoder.com.jsoniter.demo.User", iter); } else { switch (hash) { case -1078100014: obj.lastName = (java.lang.String)iter.readString(); continue; case -799547430: obj.firstName = (java.lang.String)iter.readString(); continue; case -768634731: obj.score = com.jsoniter.CodegenAccess.readInt("score@decoder.com.jsoniter.demo.User", iter); continue; default: iter.skip(); } } } return obj; }public java.lang.Object decode(com.jsoniter.JsonIterator iter) throws java.io.IOException { return decode_(iter); } } java-jsoniter-java-0.9.8/demo/src/main/java/decoder/int_array.java000066400000000000000000000023031304664171100250440ustar00rootroot00000000000000package decoder; public class int_array implements com.jsoniter.spi.Decoder { public static java.lang.Object decode_(com.jsoniter.JsonIterator iter) throws java.io.IOException { com.jsoniter.CodegenAccess.resetExistingObject(iter); if (iter.readNull()) { return null; } if (!com.jsoniter.CodegenAccess.readArrayStart(iter)) { return new int[0]; } int a1 = iter.readInt(); if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { return new int[]{ a1 }; } int a2 = iter.readInt(); if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { return new int[]{ a1, a2 }; } int a3 = iter.readInt(); if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { return new int[]{ a1, a2, a3 }; } int a4 = (int) iter.readInt(); int[] arr = new int[8]; arr[0] = a1; arr[1] = a2; arr[2] = a3; arr[3] = a4; int i = 4; while (com.jsoniter.CodegenAccess.nextToken(iter) == ',') { if (i == arr.length) { int[] newArr = new int[arr.length * 2]; System.arraycopy(arr, 0, newArr, 0, arr.length); arr = newArr; } arr[i++] = iter.readInt(); } int[] result = new int[i]; System.arraycopy(arr, 0, result, 0, i); return result; }public java.lang.Object decode(com.jsoniter.JsonIterator iter) throws java.io.IOException { return decode_(iter); } } java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/000077500000000000000000000000001304664171100231345ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/000077500000000000000000000000001304664171100241115ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/List_com/000077500000000000000000000000001304664171100256625ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/List_com/jsoniter/000077500000000000000000000000001304664171100275175ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/List_com/jsoniter/demo/000077500000000000000000000000001304664171100304435ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/List_com/jsoniter/demo/User.java000066400000000000000000000035511304664171100322300ustar00rootroot00000000000000package decoder.java.util.List_com.jsoniter.demo; public class User implements com.jsoniter.spi.Decoder { public static java.lang.Object decode_(com.jsoniter.JsonIterator iter) throws java.io.IOException { java.util.ArrayList col = (java.util.ArrayList)com.jsoniter.CodegenAccess.resetExistingObject(iter); if (iter.readNull()) { return null; } if (!com.jsoniter.CodegenAccess.readArrayStart(iter)) { return col == null ? new java.util.ArrayList(0): (java.util.ArrayList)com.jsoniter.CodegenAccess.reuseCollection(col); } Object a1 = decoder.com.jsoniter.demo.User.decode_(iter); if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { java.util.ArrayList obj = col == null ? new java.util.ArrayList(1): (java.util.ArrayList)com.jsoniter.CodegenAccess.reuseCollection(col); obj.add(a1); return obj; } Object a2 = decoder.com.jsoniter.demo.User.decode_(iter); if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { java.util.ArrayList obj = col == null ? new java.util.ArrayList(2): (java.util.ArrayList)com.jsoniter.CodegenAccess.reuseCollection(col); obj.add(a1); obj.add(a2); return obj; } Object a3 = decoder.com.jsoniter.demo.User.decode_(iter); if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { java.util.ArrayList obj = col == null ? new java.util.ArrayList(3): (java.util.ArrayList)com.jsoniter.CodegenAccess.reuseCollection(col); obj.add(a1); obj.add(a2); obj.add(a3); return obj; } Object a4 = decoder.com.jsoniter.demo.User.decode_(iter); java.util.ArrayList obj = col == null ? new java.util.ArrayList(8): (java.util.ArrayList)com.jsoniter.CodegenAccess.reuseCollection(col); obj.add(a1); obj.add(a2); obj.add(a3); obj.add(a4); while (com.jsoniter.CodegenAccess.nextToken(iter) == ',') { obj.add(decoder.com.jsoniter.demo.User.decode_(iter)); } return obj; }public java.lang.Object decode(com.jsoniter.JsonIterator iter) throws java.io.IOException { return decode_(iter); } } java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/List_java/000077500000000000000000000000001304664171100260255ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/List_java/lang/000077500000000000000000000000001304664171100267465ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/List_java/lang/Integer.java000066400000000000000000000035251304664171100312130ustar00rootroot00000000000000package decoder.java.util.List_java.lang; public class Integer implements com.jsoniter.spi.Decoder { public static java.lang.Object decode_(com.jsoniter.JsonIterator iter) throws java.io.IOException { java.util.ArrayList col = (java.util.ArrayList)com.jsoniter.CodegenAccess.resetExistingObject(iter); if (iter.readNull()) { return null; } if (!com.jsoniter.CodegenAccess.readArrayStart(iter)) { return col == null ? new java.util.ArrayList(0): (java.util.ArrayList)com.jsoniter.CodegenAccess.reuseCollection(col); } Object a1 = java.lang.Integer.valueOf(iter.readInt()); if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { java.util.ArrayList obj = col == null ? new java.util.ArrayList(1): (java.util.ArrayList)com.jsoniter.CodegenAccess.reuseCollection(col); obj.add(a1); return obj; } Object a2 = java.lang.Integer.valueOf(iter.readInt()); if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { java.util.ArrayList obj = col == null ? new java.util.ArrayList(2): (java.util.ArrayList)com.jsoniter.CodegenAccess.reuseCollection(col); obj.add(a1); obj.add(a2); return obj; } Object a3 = java.lang.Integer.valueOf(iter.readInt()); if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') { java.util.ArrayList obj = col == null ? new java.util.ArrayList(3): (java.util.ArrayList)com.jsoniter.CodegenAccess.reuseCollection(col); obj.add(a1); obj.add(a2); obj.add(a3); return obj; } Object a4 = java.lang.Integer.valueOf(iter.readInt()); java.util.ArrayList obj = col == null ? new java.util.ArrayList(8): (java.util.ArrayList)com.jsoniter.CodegenAccess.reuseCollection(col); obj.add(a1); obj.add(a2); obj.add(a3); obj.add(a4); while (com.jsoniter.CodegenAccess.nextToken(iter) == ',') { obj.add(java.lang.Integer.valueOf(iter.readInt())); } return obj; }public java.lang.Object decode(com.jsoniter.JsonIterator iter) throws java.io.IOException { return decode_(iter); } } java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/Map_java/000077500000000000000000000000001304664171100256275ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/Map_java/lang/000077500000000000000000000000001304664171100265505ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/Map_java/lang/String_java/000077500000000000000000000000001304664171100310175ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/Map_java/lang/String_java/lang/000077500000000000000000000000001304664171100317405ustar00rootroot00000000000000Object.java000066400000000000000000000015401304664171100337320ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/decoder/java/util/Map_java/lang/String_java/langpackage decoder.java.util.Map_java.lang.String_java.lang; public class Object implements com.jsoniter.spi.Decoder { public static java.lang.Object decode_(com.jsoniter.JsonIterator iter) throws java.io.IOException { java.util.HashMap map = (java.util.HashMap)com.jsoniter.CodegenAccess.resetExistingObject(iter); if (iter.readNull()) { return null; } if (map == null) { map = new java.util.HashMap(); } if (!com.jsoniter.CodegenAccess.readObjectStart(iter)) { return map; } String field = com.jsoniter.CodegenAccess.readObjectFieldAsString(iter); map.put(field, iter.read()); while (com.jsoniter.CodegenAccess.nextToken(iter) == ',') { field = com.jsoniter.CodegenAccess.readObjectFieldAsString(iter); map.put(field, iter.read()); } return map; }public java.lang.Object decode(com.jsoniter.JsonIterator iter) throws java.io.IOException { return decode_(iter); } } java-jsoniter-java-0.9.8/demo/src/main/java/encoder/000077500000000000000000000000001304664171100222255ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/com/000077500000000000000000000000001304664171100230035ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/com/jsoniter/000077500000000000000000000000001304664171100246405ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/com/jsoniter/demo/000077500000000000000000000000001304664171100255645ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/com/jsoniter/demo/User.java000066400000000000000000000014341304664171100273470ustar00rootroot00000000000000package encoder.com.jsoniter.demo; public class User extends com.jsoniter.spi.EmptyEncoder { public void encode(Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException { if (obj == null) { stream.writeNull(); return; } stream.writeRaw("{\"lastName\":\"", 13); encode_((com.jsoniter.demo.User)obj, stream); stream.write((byte)'}'); } public static void encode_(com.jsoniter.demo.User obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException { com.jsoniter.output.CodegenAccess.writeStringWithoutQuote((java.lang.String)obj.lastName, stream); stream.writeRaw("\",\"firstName\":\"", 15); com.jsoniter.output.CodegenAccess.writeStringWithoutQuote((java.lang.String)obj.firstName, stream); stream.writeRaw("\",\"score\":", 10); stream.writeVal((int)obj.score); } } java-jsoniter-java-0.9.8/demo/src/main/java/encoder/int_array.java000066400000000000000000000011621304664171100250600ustar00rootroot00000000000000package encoder; public class int_array extends com.jsoniter.spi.EmptyEncoder { public void encode(Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException { if (obj == null) { stream.writeNull(); return; } stream.write((byte)'['); encode_((int[])obj, stream); stream.write((byte)']'); } public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException { int[] arr = (int[])obj; if (arr.length == 0) { return; } int i = 0; int e = arr[i++]; stream.writeVal((int)e); while (i < arr.length) { stream.write(','); e = arr[i++]; stream.writeVal((int)e); } } } java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/000077500000000000000000000000001304664171100231465ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/000077500000000000000000000000001304664171100241235ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/List_com/000077500000000000000000000000001304664171100256745ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/List_com/jsoniter/000077500000000000000000000000001304664171100275315ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/List_com/jsoniter/demo/000077500000000000000000000000001304664171100304555ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/List_com/jsoniter/demo/User.java000066400000000000000000000020241304664171100322340ustar00rootroot00000000000000package encoder.java.util.List_com.jsoniter.demo; public class User extends com.jsoniter.spi.EmptyEncoder { public void encode(Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException { if (obj == null) { stream.writeNull(); return; } stream.write((byte)'['); encode_((java.util.List)obj, stream); stream.write((byte)']'); } public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException { java.util.List list = (java.util.List)obj; int size = list.size(); if (size == 0) { return; } java.lang.Object e = list.get(0); if (e == null) { stream.writeNull(); } else { stream.writeRaw("{\"lastName\":\"", 13); encoder.com.jsoniter.demo.User.encode_((com.jsoniter.demo.User)e, stream); stream.write((byte)'}'); } for (int i = 1; i < size; i++) { stream.write(','); e = list.get(i); if (e == null) { stream.writeNull(); } else { stream.writeRaw("{\"lastName\":\"", 13); encoder.com.jsoniter.demo.User.encode_((com.jsoniter.demo.User)e, stream); stream.write((byte)'}'); } } } } java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/List_java/000077500000000000000000000000001304664171100260375ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/List_java/lang/000077500000000000000000000000001304664171100267605ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/List_java/lang/Integer.java000066400000000000000000000015031304664171100312170ustar00rootroot00000000000000package encoder.java.util.List_java.lang; public class Integer extends com.jsoniter.spi.EmptyEncoder { public void encode(Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException { if (obj == null) { stream.writeNull(); return; } stream.write((byte)'['); encode_((java.util.List)obj, stream); stream.write((byte)']'); } public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException { java.util.List list = (java.util.List)obj; int size = list.size(); if (size == 0) { return; } java.lang.Object e = list.get(0); if (e == null) { stream.writeNull(); } else { stream.writeVal((java.lang.Integer)e); } for (int i = 1; i < size; i++) { stream.write(','); e = list.get(i); if (e == null) { stream.writeNull(); } else { stream.writeVal((java.lang.Integer)e); } } } } java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/Map_java/000077500000000000000000000000001304664171100256415ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/Map_java/lang/000077500000000000000000000000001304664171100265625ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/Map_java/lang/String_java/000077500000000000000000000000001304664171100310315ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/Map_java/lang/String_java/lang/000077500000000000000000000000001304664171100317525ustar00rootroot00000000000000Object.java000066400000000000000000000022001304664171100337360ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/main/java/encoder/java/util/Map_java/lang/String_java/langpackage encoder.java.util.Map_java.lang.String_java.lang; public class Object extends com.jsoniter.spi.EmptyEncoder { public void encode(Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException { if (obj == null) { stream.writeNull(); return; } stream.write((byte)'{'); encode_((java.util.Map)obj, stream); stream.write((byte)'}'); } public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException { if (obj == null) { stream.writeNull(); return; } java.util.Map map = (java.util.Map)obj; java.util.Iterator iter = map.entrySet().iterator(); if(!iter.hasNext()) { return; } java.util.Map.Entry entry = (java.util.Map.Entry)iter.next(); stream.writeVal((String)entry.getKey()); stream.write((byte)':'); if (entry.getValue() == null) { stream.writeNull(); } else { stream.writeVal((java.lang.Object)entry.getValue()); } while(iter.hasNext()) { entry = (java.util.Map.Entry)iter.next(); stream.write((byte)','); stream.writeObjectField((String)entry.getKey()); if (entry.getValue() == null) { stream.writeNull(); } else { stream.writeVal((java.lang.Object)entry.getValue()); } } } } java-jsoniter-java-0.9.8/demo/src/test/000077500000000000000000000000001304664171100177205ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/000077500000000000000000000000001304664171100206415ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/000077500000000000000000000000001304664171100214175ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/dslplatform/000077500000000000000000000000001304664171100237465ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/dslplatform/json/000077500000000000000000000000001304664171100247175ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/dslplatform/json/CustomJsonReader.java000066400000000000000000000003431304664171100310110ustar00rootroot00000000000000package com.dslplatform.json; public class CustomJsonReader extends JsonReader { public CustomJsonReader(byte[] buffer) { super(buffer, null); } public void reset() { super.reset(length()); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/dslplatform/json/ExternalSerialization.java000066400000000000000000001407161304664171100321130ustar00rootroot00000000000000/* * Created by DSL Platform * v1.7.6218.18384 */ package com.dslplatform.json; public class ExternalSerialization implements Configuration { @SuppressWarnings("unchecked") public void configure(final DslJson json) { setup(json); } @SuppressWarnings("unchecked") public static void setup(final DslJson json) { json.registerReader(com.jsoniter.demo.object_with_1_double_field.TestObject.class, JSON_READER_struct5); json.registerWriter(com.jsoniter.demo.object_with_1_double_field.TestObject.class, new JsonWriter.WriteObject() { @Override public void write(JsonWriter writer, com.jsoniter.demo.object_with_1_double_field.TestObject value) { serialize(value, writer, json.omitDefaults); } }); json.registerReader(com.jsoniter.demo.object_with_1_field.TestObject.class, JSON_READER_struct1); json.registerWriter(com.jsoniter.demo.object_with_1_field.TestObject.class, new JsonWriter.WriteObject() { @Override public void write(JsonWriter writer, com.jsoniter.demo.object_with_1_field.TestObject value) { serialize(value, writer, json.omitDefaults); } }); json.registerReader(com.jsoniter.demo.object_with_10_fields.TestObject.class, JSON_READER_struct6); json.registerWriter(com.jsoniter.demo.object_with_10_fields.TestObject.class, new JsonWriter.WriteObject() { @Override public void write(JsonWriter writer, com.jsoniter.demo.object_with_10_fields.TestObject value) { serialize(value, writer, json.omitDefaults); } }); json.registerReader(com.jsoniter.demo.object_with_1_int_field.TestObject.class, JSON_READER_struct0); json.registerWriter(com.jsoniter.demo.object_with_1_int_field.TestObject.class, new JsonWriter.WriteObject() { @Override public void write(JsonWriter writer, com.jsoniter.demo.object_with_1_int_field.TestObject value) { serialize(value, writer, json.omitDefaults); } }); json.registerReader(com.jsoniter.demo.object_with_5_fields.TestObject.class, JSON_READER_struct2); json.registerWriter(com.jsoniter.demo.object_with_5_fields.TestObject.class, new JsonWriter.WriteObject() { @Override public void write(JsonWriter writer, com.jsoniter.demo.object_with_5_fields.TestObject value) { serialize(value, writer, json.omitDefaults); } }); json.registerReader(com.jsoniter.demo.object_with_15_fields.TestObject.class, JSON_READER_struct4); json.registerWriter(com.jsoniter.demo.object_with_15_fields.TestObject.class, new JsonWriter.WriteObject() { @Override public void write(JsonWriter writer, com.jsoniter.demo.object_with_15_fields.TestObject value) { serialize(value, writer, json.omitDefaults); } }); json.registerReader(com.jsoniter.demo.SimpleObjectBinding.TestObject.class, JSON_READER_struct3); json.registerWriter(com.jsoniter.demo.SimpleObjectBinding.TestObject.class, new JsonWriter.WriteObject() { @Override public void write(JsonWriter writer, com.jsoniter.demo.SimpleObjectBinding.TestObject value) { serialize(value, writer, json.omitDefaults); } }); } public static void serialize(final com.jsoniter.demo.object_with_1_double_field.TestObject self, final JsonWriter sw, final boolean minimal) { sw.writeByte(JsonWriter.OBJECT_START); if (minimal) { __serializeJsonObjectMinimal(self, sw, false); } else { __serializeJsonObjectFull(self, sw, false); } sw.writeByte(JsonWriter.OBJECT_END); } static void __serializeJsonObjectMinimal(final com.jsoniter.demo.object_with_1_double_field.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field1 != 0.0) { hasWrittenProperty = true; sw.writeAscii("\"field1\":", 9); NumberConverter.serialize(self.field1, sw); } } static void __serializeJsonObjectFull(final com.jsoniter.demo.object_with_1_double_field.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { sw.writeAscii("\"field1\":", 9); NumberConverter.serialize(self.field1, sw); } public static final JsonReader.ReadObject JSON_READER_struct5 = new JsonReader.ReadObject() { @SuppressWarnings("unchecked") @Override public com.jsoniter.demo.object_with_1_double_field.TestObject read(final JsonReader reader) throws java.io.IOException { if(reader.last() != '{') { throw new java.io.IOException("Expecting \'{\' at position " + reader.positionInStream() + ". Found " + (char)reader.last()); } reader.getNextToken(); final com.jsoniter.demo.object_with_1_double_field.TestObject instance = new com.jsoniter.demo.object_with_1_double_field.TestObject(); deserialize(instance, reader); return instance; } }; @SuppressWarnings("unchecked") static com.jsoniter.demo.object_with_1_double_field.TestObject deserializestruct5(final JsonReader reader) throws java.io.IOException { final com.jsoniter.demo.object_with_1_double_field.TestObject instance = new com.jsoniter.demo.object_with_1_double_field.TestObject(); deserialize(instance, reader); return instance; } @SuppressWarnings("unchecked") static void deserialize(final com.jsoniter.demo.object_with_1_double_field.TestObject instance, final JsonReader reader) throws java.io.IOException { double _field1_ = 0.0; byte nextToken = reader.last(); if(nextToken != '}') { int nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } else { switch(nameHash) { case 1212206434: _field1_ = NumberConverter.deserializeDouble(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } while (nextToken == ',') { nextToken = reader.getNextToken(); nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); continue; } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } switch(nameHash) { case 1212206434: _field1_ = NumberConverter.deserializeDouble(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } if (nextToken != '}') { throw new java.io.IOException("Expecting '}' at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } instance.field1 = _field1_; } public static void serialize(final com.jsoniter.demo.object_with_1_field.TestObject self, final JsonWriter sw, final boolean minimal) { sw.writeByte(JsonWriter.OBJECT_START); if (minimal) { __serializeJsonObjectMinimal(self, sw, false); } else { __serializeJsonObjectFull(self, sw, false); } sw.writeByte(JsonWriter.OBJECT_END); } static void __serializeJsonObjectMinimal(final com.jsoniter.demo.object_with_1_field.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field1 != null) { hasWrittenProperty = true; sw.writeAscii("\"field1\":", 9); sw.writeString(self.field1); } } static void __serializeJsonObjectFull(final com.jsoniter.demo.object_with_1_field.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field1 != null) { sw.writeAscii("\"field1\":", 9); sw.writeString(self.field1); } else { sw.writeAscii("\"field1\":null", 13); } } public static final JsonReader.ReadObject JSON_READER_struct1 = new JsonReader.ReadObject() { @SuppressWarnings("unchecked") @Override public com.jsoniter.demo.object_with_1_field.TestObject read(final JsonReader reader) throws java.io.IOException { if(reader.last() != '{') { throw new java.io.IOException("Expecting \'{\' at position " + reader.positionInStream() + ". Found " + (char)reader.last()); } reader.getNextToken(); final com.jsoniter.demo.object_with_1_field.TestObject instance = new com.jsoniter.demo.object_with_1_field.TestObject(); deserialize(instance, reader); return instance; } }; @SuppressWarnings("unchecked") static com.jsoniter.demo.object_with_1_field.TestObject deserializestruct1(final JsonReader reader) throws java.io.IOException { final com.jsoniter.demo.object_with_1_field.TestObject instance = new com.jsoniter.demo.object_with_1_field.TestObject(); deserialize(instance, reader); return instance; } @SuppressWarnings("unchecked") static void deserialize(final com.jsoniter.demo.object_with_1_field.TestObject instance, final JsonReader reader) throws java.io.IOException { String _field1_ = null; byte nextToken = reader.last(); if(nextToken != '}') { int nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } else { switch(nameHash) { case 1212206434: _field1_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } while (nextToken == ',') { nextToken = reader.getNextToken(); nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); continue; } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } switch(nameHash) { case 1212206434: _field1_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } if (nextToken != '}') { throw new java.io.IOException("Expecting '}' at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } instance.field1 = _field1_; } public static void serialize(final com.jsoniter.demo.object_with_10_fields.TestObject self, final JsonWriter sw, final boolean minimal) { sw.writeByte(JsonWriter.OBJECT_START); if (minimal) { __serializeJsonObjectMinimal(self, sw, false); } else { __serializeJsonObjectFull(self, sw, false); } sw.writeByte(JsonWriter.OBJECT_END); } static void __serializeJsonObjectMinimal(final com.jsoniter.demo.object_with_10_fields.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field1 != null) { hasWrittenProperty = true; sw.writeAscii("\"field1\":", 9); sw.writeString(self.field1); } if (self.field10 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field10\":", 10); sw.writeString(self.field10); } if (self.field7 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field7\":", 9); sw.writeString(self.field7); } if (self.field6 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field6\":", 9); sw.writeString(self.field6); } if (self.field9 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field9\":", 9); sw.writeString(self.field9); } if (self.field8 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field8\":", 9); sw.writeString(self.field8); } if (self.field3 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field3\":", 9); sw.writeString(self.field3); } if (self.field2 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field2\":", 9); sw.writeString(self.field2); } if (self.field5 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field5\":", 9); sw.writeString(self.field5); } if (self.field4 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field4\":", 9); sw.writeString(self.field4); } } static void __serializeJsonObjectFull(final com.jsoniter.demo.object_with_10_fields.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field1 != null) { sw.writeAscii("\"field1\":", 9); sw.writeString(self.field1); } else { sw.writeAscii("\"field1\":null", 13); } if (self.field10 != null) { sw.writeAscii(",\"field10\":", 11); sw.writeString(self.field10); } else { sw.writeAscii(",\"field10\":null", 15); } if (self.field7 != null) { sw.writeAscii(",\"field7\":", 10); sw.writeString(self.field7); } else { sw.writeAscii(",\"field7\":null", 14); } if (self.field6 != null) { sw.writeAscii(",\"field6\":", 10); sw.writeString(self.field6); } else { sw.writeAscii(",\"field6\":null", 14); } if (self.field9 != null) { sw.writeAscii(",\"field9\":", 10); sw.writeString(self.field9); } else { sw.writeAscii(",\"field9\":null", 14); } if (self.field8 != null) { sw.writeAscii(",\"field8\":", 10); sw.writeString(self.field8); } else { sw.writeAscii(",\"field8\":null", 14); } if (self.field3 != null) { sw.writeAscii(",\"field3\":", 10); sw.writeString(self.field3); } else { sw.writeAscii(",\"field3\":null", 14); } if (self.field2 != null) { sw.writeAscii(",\"field2\":", 10); sw.writeString(self.field2); } else { sw.writeAscii(",\"field2\":null", 14); } if (self.field5 != null) { sw.writeAscii(",\"field5\":", 10); sw.writeString(self.field5); } else { sw.writeAscii(",\"field5\":null", 14); } if (self.field4 != null) { sw.writeAscii(",\"field4\":", 10); sw.writeString(self.field4); } else { sw.writeAscii(",\"field4\":null", 14); } } public static final JsonReader.ReadObject JSON_READER_struct6 = new JsonReader.ReadObject() { @SuppressWarnings("unchecked") @Override public com.jsoniter.demo.object_with_10_fields.TestObject read(final JsonReader reader) throws java.io.IOException { if(reader.last() != '{') { throw new java.io.IOException("Expecting \'{\' at position " + reader.positionInStream() + ". Found " + (char)reader.last()); } reader.getNextToken(); final com.jsoniter.demo.object_with_10_fields.TestObject instance = new com.jsoniter.demo.object_with_10_fields.TestObject(); deserialize(instance, reader); return instance; } }; @SuppressWarnings("unchecked") static com.jsoniter.demo.object_with_10_fields.TestObject deserializestruct6(final JsonReader reader) throws java.io.IOException { final com.jsoniter.demo.object_with_10_fields.TestObject instance = new com.jsoniter.demo.object_with_10_fields.TestObject(); deserialize(instance, reader); return instance; } @SuppressWarnings("unchecked") public static void deserialize(final com.jsoniter.demo.object_with_10_fields.TestObject instance, final JsonReader reader) throws java.io.IOException { String _field1_ = null; String _field10_ = null; String _field7_ = null; String _field6_ = null; String _field9_ = null; String _field8_ = null; String _field3_ = null; String _field2_ = null; String _field5_ = null; String _field4_ = null; byte nextToken = reader.last(); if(nextToken != '}') { int nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } else { switch(nameHash) { case 1212206434: _field1_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 268646422: _field10_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1111540720: _field7_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1128318339: _field6_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1346427386: _field9_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1363205005: _field8_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1178651196: _field3_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1195428815: _field2_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1145095958: _field5_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1161873577: _field4_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } while (nextToken == ',') { nextToken = reader.getNextToken(); nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); continue; } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } switch(nameHash) { case 1212206434: _field1_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 268646422: _field10_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1111540720: _field7_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1128318339: _field6_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1346427386: _field9_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1363205005: _field8_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1178651196: _field3_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1195428815: _field2_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1145095958: _field5_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1161873577: _field4_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } if (nextToken != '}') { throw new java.io.IOException("Expecting '}' at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } instance.field1 = _field1_; instance.field10 = _field10_; instance.field7 = _field7_; instance.field6 = _field6_; instance.field9 = _field9_; instance.field8 = _field8_; instance.field3 = _field3_; instance.field2 = _field2_; instance.field5 = _field5_; instance.field4 = _field4_; } public static void serialize(final com.jsoniter.demo.object_with_1_int_field.TestObject self, final JsonWriter sw, final boolean minimal) { sw.writeByte(JsonWriter.OBJECT_START); if (minimal) { __serializeJsonObjectMinimal(self, sw, false); } else { __serializeJsonObjectFull(self, sw, false); } sw.writeByte(JsonWriter.OBJECT_END); } static void __serializeJsonObjectMinimal(final com.jsoniter.demo.object_with_1_int_field.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field1 != 0) { hasWrittenProperty = true; sw.writeAscii("\"field1\":", 9); NumberConverter.serialize(self.field1, sw); } } static void __serializeJsonObjectFull(final com.jsoniter.demo.object_with_1_int_field.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { sw.writeAscii("\"field1\":", 9); NumberConverter.serialize(self.field1, sw); } public static final JsonReader.ReadObject JSON_READER_struct0 = new JsonReader.ReadObject() { @SuppressWarnings("unchecked") @Override public com.jsoniter.demo.object_with_1_int_field.TestObject read(final JsonReader reader) throws java.io.IOException { if(reader.last() != '{') { throw new java.io.IOException("Expecting \'{\' at position " + reader.positionInStream() + ". Found " + (char)reader.last()); } reader.getNextToken(); final com.jsoniter.demo.object_with_1_int_field.TestObject instance = new com.jsoniter.demo.object_with_1_int_field.TestObject(); deserialize(instance, reader); return instance; } }; @SuppressWarnings("unchecked") static com.jsoniter.demo.object_with_1_int_field.TestObject deserializestruct0(final JsonReader reader) throws java.io.IOException { final com.jsoniter.demo.object_with_1_int_field.TestObject instance = new com.jsoniter.demo.object_with_1_int_field.TestObject(); deserialize(instance, reader); return instance; } @SuppressWarnings("unchecked") static void deserialize(final com.jsoniter.demo.object_with_1_int_field.TestObject instance, final JsonReader reader) throws java.io.IOException { int _field1_ = 0; byte nextToken = reader.last(); if(nextToken != '}') { int nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } else { switch(nameHash) { case 1212206434: _field1_ = NumberConverter.deserializeInt(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } while (nextToken == ',') { nextToken = reader.getNextToken(); nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); continue; } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } switch(nameHash) { case 1212206434: _field1_ = NumberConverter.deserializeInt(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } if (nextToken != '}') { throw new java.io.IOException("Expecting '}' at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } instance.field1 = _field1_; } public static void serialize(final com.jsoniter.demo.object_with_5_fields.TestObject self, final JsonWriter sw, final boolean minimal) { sw.writeByte(JsonWriter.OBJECT_START); if (minimal) { __serializeJsonObjectMinimal(self, sw, false); } else { __serializeJsonObjectFull(self, sw, false); } sw.writeByte(JsonWriter.OBJECT_END); } static void __serializeJsonObjectMinimal(final com.jsoniter.demo.object_with_5_fields.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field1 != null) { hasWrittenProperty = true; sw.writeAscii("\"field1\":", 9); sw.writeString(self.field1); } if (self.field3 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field3\":", 9); sw.writeString(self.field3); } if (self.field2 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field2\":", 9); sw.writeString(self.field2); } if (self.field5 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field5\":", 9); sw.writeString(self.field5); } if (self.field4 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field4\":", 9); sw.writeString(self.field4); } } static void __serializeJsonObjectFull(final com.jsoniter.demo.object_with_5_fields.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field1 != null) { sw.writeAscii("\"field1\":", 9); sw.writeString(self.field1); } else { sw.writeAscii("\"field1\":null", 13); } if (self.field3 != null) { sw.writeAscii(",\"field3\":", 10); sw.writeString(self.field3); } else { sw.writeAscii(",\"field3\":null", 14); } if (self.field2 != null) { sw.writeAscii(",\"field2\":", 10); sw.writeString(self.field2); } else { sw.writeAscii(",\"field2\":null", 14); } if (self.field5 != null) { sw.writeAscii(",\"field5\":", 10); sw.writeString(self.field5); } else { sw.writeAscii(",\"field5\":null", 14); } if (self.field4 != null) { sw.writeAscii(",\"field4\":", 10); sw.writeString(self.field4); } else { sw.writeAscii(",\"field4\":null", 14); } } public static final JsonReader.ReadObject JSON_READER_struct2 = new JsonReader.ReadObject() { @SuppressWarnings("unchecked") @Override public com.jsoniter.demo.object_with_5_fields.TestObject read(final JsonReader reader) throws java.io.IOException { if(reader.last() != '{') { throw new java.io.IOException("Expecting \'{\' at position " + reader.positionInStream() + ". Found " + (char)reader.last()); } reader.getNextToken(); final com.jsoniter.demo.object_with_5_fields.TestObject instance = new com.jsoniter.demo.object_with_5_fields.TestObject(); deserialize(instance, reader); return instance; } }; @SuppressWarnings("unchecked") static com.jsoniter.demo.object_with_5_fields.TestObject deserializestruct2(final JsonReader reader) throws java.io.IOException { final com.jsoniter.demo.object_with_5_fields.TestObject instance = new com.jsoniter.demo.object_with_5_fields.TestObject(); deserialize(instance, reader); return instance; } @SuppressWarnings("unchecked") public static void deserialize(final com.jsoniter.demo.object_with_5_fields.TestObject instance, final JsonReader reader) throws java.io.IOException { String _field1_ = null; String _field3_ = null; String _field2_ = null; String _field5_ = null; String _field4_ = null; byte nextToken = reader.last(); if(nextToken != '}') { int nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } else { switch(nameHash) { case 1212206434: _field1_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1178651196: _field3_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1195428815: _field2_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1145095958: _field5_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1161873577: _field4_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } while (nextToken == ',') { nextToken = reader.getNextToken(); nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); continue; } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } switch(nameHash) { case 1212206434: _field1_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1178651196: _field3_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1195428815: _field2_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1145095958: _field5_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1161873577: _field4_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } if (nextToken != '}') { throw new java.io.IOException("Expecting '}' at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } instance.field1 = _field1_; instance.field3 = _field3_; instance.field2 = _field2_; instance.field5 = _field5_; instance.field4 = _field4_; } public static void serialize(final com.jsoniter.demo.object_with_15_fields.TestObject self, final JsonWriter sw, final boolean minimal) { sw.writeByte(JsonWriter.OBJECT_START); if (minimal) { __serializeJsonObjectMinimal(self, sw, false); } else { __serializeJsonObjectFull(self, sw, false); } sw.writeByte(JsonWriter.OBJECT_END); } static void __serializeJsonObjectMinimal(final com.jsoniter.demo.object_with_15_fields.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field11 != null) { hasWrittenProperty = true; sw.writeAscii("\"field11\":", 10); sw.writeString(self.field11); } if (self.field12 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field12\":", 10); sw.writeString(self.field12); } if (self.field1 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field1\":", 9); sw.writeString(self.field1); } if (self.field10 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field10\":", 10); sw.writeString(self.field10); } if (self.field15 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field15\":", 10); sw.writeString(self.field15); } if (self.field13 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field13\":", 10); sw.writeString(self.field13); } if (self.field14 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field14\":", 10); sw.writeString(self.field14); } if (self.field7 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field7\":", 9); sw.writeString(self.field7); } if (self.field6 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field6\":", 9); sw.writeString(self.field6); } if (self.field9 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field9\":", 9); sw.writeString(self.field9); } if (self.field8 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field8\":", 9); sw.writeString(self.field8); } if (self.field3 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field3\":", 9); sw.writeString(self.field3); } if (self.field2 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field2\":", 9); sw.writeString(self.field2); } if (self.field5 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field5\":", 9); sw.writeString(self.field5); } if (self.field4 != null) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field4\":", 9); sw.writeString(self.field4); } } static void __serializeJsonObjectFull(final com.jsoniter.demo.object_with_15_fields.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field11 != null) { sw.writeAscii("\"field11\":", 10); sw.writeString(self.field11); } else { sw.writeAscii("\"field11\":null", 14); } if (self.field12 != null) { sw.writeAscii(",\"field12\":", 11); sw.writeString(self.field12); } else { sw.writeAscii(",\"field12\":null", 15); } if (self.field1 != null) { sw.writeAscii(",\"field1\":", 10); sw.writeString(self.field1); } else { sw.writeAscii(",\"field1\":null", 14); } if (self.field10 != null) { sw.writeAscii(",\"field10\":", 11); sw.writeString(self.field10); } else { sw.writeAscii(",\"field10\":null", 15); } if (self.field15 != null) { sw.writeAscii(",\"field15\":", 11); sw.writeString(self.field15); } else { sw.writeAscii(",\"field15\":null", 15); } if (self.field13 != null) { sw.writeAscii(",\"field13\":", 11); sw.writeString(self.field13); } else { sw.writeAscii(",\"field13\":null", 15); } if (self.field14 != null) { sw.writeAscii(",\"field14\":", 11); sw.writeString(self.field14); } else { sw.writeAscii(",\"field14\":null", 15); } if (self.field7 != null) { sw.writeAscii(",\"field7\":", 10); sw.writeString(self.field7); } else { sw.writeAscii(",\"field7\":null", 14); } if (self.field6 != null) { sw.writeAscii(",\"field6\":", 10); sw.writeString(self.field6); } else { sw.writeAscii(",\"field6\":null", 14); } if (self.field9 != null) { sw.writeAscii(",\"field9\":", 10); sw.writeString(self.field9); } else { sw.writeAscii(",\"field9\":null", 14); } if (self.field8 != null) { sw.writeAscii(",\"field8\":", 10); sw.writeString(self.field8); } else { sw.writeAscii(",\"field8\":null", 14); } if (self.field3 != null) { sw.writeAscii(",\"field3\":", 10); sw.writeString(self.field3); } else { sw.writeAscii(",\"field3\":null", 14); } if (self.field2 != null) { sw.writeAscii(",\"field2\":", 10); sw.writeString(self.field2); } else { sw.writeAscii(",\"field2\":null", 14); } if (self.field5 != null) { sw.writeAscii(",\"field5\":", 10); sw.writeString(self.field5); } else { sw.writeAscii(",\"field5\":null", 14); } if (self.field4 != null) { sw.writeAscii(",\"field4\":", 10); sw.writeString(self.field4); } else { sw.writeAscii(",\"field4\":null", 14); } } public static final JsonReader.ReadObject JSON_READER_struct4 = new JsonReader.ReadObject() { @SuppressWarnings("unchecked") @Override public com.jsoniter.demo.object_with_15_fields.TestObject read(final JsonReader reader) throws java.io.IOException { if(reader.last() != '{') { throw new java.io.IOException("Expecting \'{\' at position " + reader.positionInStream() + ". Found " + (char)reader.last()); } reader.getNextToken(); final com.jsoniter.demo.object_with_15_fields.TestObject instance = new com.jsoniter.demo.object_with_15_fields.TestObject(); deserialize(instance, reader); return instance; } }; @SuppressWarnings("unchecked") static com.jsoniter.demo.object_with_15_fields.TestObject deserializestruct4(final JsonReader reader) throws java.io.IOException { final com.jsoniter.demo.object_with_15_fields.TestObject instance = new com.jsoniter.demo.object_with_15_fields.TestObject(); deserialize(instance, reader); return instance; } @SuppressWarnings("unchecked") public static void deserialize(final com.jsoniter.demo.object_with_15_fields.TestObject instance, final JsonReader reader) throws java.io.IOException { String _field11_ = null; String _field12_ = null; String _field1_ = null; String _field10_ = null; String _field15_ = null; String _field13_ = null; String _field14_ = null; String _field7_ = null; String _field6_ = null; String _field9_ = null; String _field8_ = null; String _field3_ = null; String _field2_ = null; String _field5_ = null; String _field4_ = null; byte nextToken = reader.last(); if(nextToken != '}') { int nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } else { switch(nameHash) { case 285424041: _field11_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 235091184: _field12_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1212206434: _field1_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 268646422: _field10_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 352534517: _field15_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 251868803: _field13_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 335756898: _field14_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1111540720: _field7_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1128318339: _field6_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1346427386: _field9_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1363205005: _field8_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1178651196: _field3_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1195428815: _field2_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1145095958: _field5_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1161873577: _field4_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } while (nextToken == ',') { nextToken = reader.getNextToken(); nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); continue; } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } switch(nameHash) { case 285424041: _field11_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 235091184: _field12_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1212206434: _field1_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 268646422: _field10_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 352534517: _field15_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 251868803: _field13_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 335756898: _field14_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1111540720: _field7_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1128318339: _field6_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1346427386: _field9_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1363205005: _field8_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1178651196: _field3_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1195428815: _field2_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1145095958: _field5_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; case 1161873577: _field4_ = StringConverter.deserialize(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } if (nextToken != '}') { throw new java.io.IOException("Expecting '}' at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } instance.field11 = _field11_; instance.field12 = _field12_; instance.field1 = _field1_; instance.field10 = _field10_; instance.field15 = _field15_; instance.field13 = _field13_; instance.field14 = _field14_; instance.field7 = _field7_; instance.field6 = _field6_; instance.field9 = _field9_; instance.field8 = _field8_; instance.field3 = _field3_; instance.field2 = _field2_; instance.field5 = _field5_; instance.field4 = _field4_; } public static void serialize(final com.jsoniter.demo.SimpleObjectBinding.TestObject self, final JsonWriter sw, final boolean minimal) { sw.writeByte(JsonWriter.OBJECT_START); if (minimal) { __serializeJsonObjectMinimal(self, sw, false); } else { __serializeJsonObjectFull(self, sw, false); } sw.writeByte(JsonWriter.OBJECT_END); } static void __serializeJsonObjectMinimal(final com.jsoniter.demo.SimpleObjectBinding.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { if (self.field1 != 0) { hasWrittenProperty = true; sw.writeAscii("\"field1\":", 9); NumberConverter.serialize(self.field1, sw); } if (self.field2 != 0) { if(hasWrittenProperty) sw.writeByte(JsonWriter.COMMA); hasWrittenProperty = true; sw.writeAscii("\"field2\":", 9); NumberConverter.serialize(self.field2, sw); } } static void __serializeJsonObjectFull(final com.jsoniter.demo.SimpleObjectBinding.TestObject self, JsonWriter sw, boolean hasWrittenProperty) { sw.writeAscii("\"field1\":", 9); NumberConverter.serialize(self.field1, sw); sw.writeAscii(",\"field2\":", 10); NumberConverter.serialize(self.field2, sw); } public static final JsonReader.ReadObject JSON_READER_struct3 = new JsonReader.ReadObject() { @SuppressWarnings("unchecked") @Override public com.jsoniter.demo.SimpleObjectBinding.TestObject read(final JsonReader reader) throws java.io.IOException { if(reader.last() != '{') { throw new java.io.IOException("Expecting \'{\' at position " + reader.positionInStream() + ". Found " + (char)reader.last()); } reader.getNextToken(); final com.jsoniter.demo.SimpleObjectBinding.TestObject instance = new com.jsoniter.demo.SimpleObjectBinding.TestObject(); deserialize(instance, reader); return instance; } }; @SuppressWarnings("unchecked") static com.jsoniter.demo.SimpleObjectBinding.TestObject deserializestruct3(final JsonReader reader) throws java.io.IOException { final com.jsoniter.demo.SimpleObjectBinding.TestObject instance = new com.jsoniter.demo.SimpleObjectBinding.TestObject(); deserialize(instance, reader); return instance; } @SuppressWarnings("unchecked") static void deserialize(final com.jsoniter.demo.SimpleObjectBinding.TestObject instance, final JsonReader reader) throws java.io.IOException { int _field1_ = 0; int _field2_ = 0; byte nextToken = reader.last(); if(nextToken != '}') { int nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } else { switch(nameHash) { case 1212206434: _field1_ = NumberConverter.deserializeInt(reader); nextToken = reader.getNextToken(); break; case 1195428815: _field2_ = NumberConverter.deserializeInt(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } while (nextToken == ',') { nextToken = reader.getNextToken(); nameHash = reader.fillName(); nextToken = reader.getNextToken(); if(nextToken == 'n') { if (reader.wasNull()) { nextToken = reader.getNextToken(); continue; } else { throw new java.io.IOException("Expecting 'u' (as null) at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } switch(nameHash) { case 1212206434: _field1_ = NumberConverter.deserializeInt(reader); nextToken = reader.getNextToken(); break; case 1195428815: _field2_ = NumberConverter.deserializeInt(reader); nextToken = reader.getNextToken(); break; default: nextToken = reader.skip(); break; } } if (nextToken != '}') { throw new java.io.IOException("Expecting '}' at position " + reader.positionInStream() + ". Found " + (char)nextToken); } } instance.field1 = _field1_; instance.field2 = _field2_; } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/000077500000000000000000000000001304664171100232545ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/000077500000000000000000000000001304664171100242005ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/ArrayBinding.java000066400000000000000000000064251304664171100274230ustar00rootroot00000000000000package com.jsoniter.demo; import com.dslplatform.json.DslJson; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import com.jsoniter.JsonIterator; import com.jsoniter.annotation.JacksonAnnotationSupport; import com.jsoniter.spi.TypeLiteral; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import java.io.IOException; @State(Scope.Thread) public class ArrayBinding { private TypeLiteral typeLiteral; private ObjectMapper jackson; private byte[] input; private TypeReference typeRef; private String inputStr; private JsonIterator iter; private DslJson dslJson; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { inputStr = "[1,2,3,4,5,6,7,8,9]".replace('\'', '"'); input = inputStr.getBytes(); iter = JsonIterator.parse(input); typeLiteral = new TypeLiteral() { }; typeRef = new TypeReference() { }; JacksonAnnotationSupport.enable(); jackson = new ObjectMapper(); jackson.registerModule(new AfterburnerModule()); dslJson = new DslJson(); } @Test public void test() throws IOException { benchSetup(null); System.out.println(withJsoniter()); System.out.println(withIterator()); System.out.println(withJackson()); System.out.println(withDsljson()); } public static void main(String[] args) throws Exception { Main.main(new String[]{ "ArrayBinding", "-i", "5", "-wi", "5", "-f", "1", }); } @Benchmark public void withJsoniterBinding(Blackhole bh) throws IOException { bh.consume(withJsoniter()); } @Benchmark public void withJsoniterIterator(Blackhole bh) throws IOException { bh.consume(withIterator()); } @Benchmark public void withJackson(Blackhole bh) throws IOException { bh.consume(withJackson()); } @Benchmark public void withDsljson(Blackhole bh) throws IOException { bh.consume(withDsljson()); } private int withJsoniter() throws IOException { iter.reset(input); int[] arr = iter.read(typeLiteral); int total = 0; for (int i = 0; i < arr.length; i++) { total += arr[i]; } return total; } private int withJackson() throws IOException { int[] arr = jackson.readValue(input, typeRef); int total = 0; for (int i = 0; i < arr.length; i++) { total += arr[i]; } return total; } private int withDsljson() throws IOException { int[] arr = (int[]) dslJson.deserialize(int[].class, input, input.length); int total = 0; for (int i = 0; i < arr.length; i++) { total += arr[i]; } return total; } private int withIterator() throws IOException { iter.reset(input); int total = 0; while (iter.readArray()) { total += iter.readInt(); } return total; } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/ConstructorBinding.java000066400000000000000000000074411304664171100306710ustar00rootroot00000000000000package com.jsoniter.demo; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.ReflectionDecoderFactory; import com.jsoniter.annotation.JacksonAnnotationSupport; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.TypeLiteral; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import java.io.IOException; @State(Scope.Thread) public class ConstructorBinding { private TypeLiteral typeLiteral; private ObjectMapper jackson; private byte[] input; private TypeReference typeRef; private String inputStr; public static class TestObject { @JsonIgnore private int field1; @JsonIgnore private int field2; @JsonCreator public TestObject( @JsonProperty("field1") int field1, @JsonProperty("field2") int field2) { this.field1 = field1; this.field2 = field2; } @Override public String toString() { return "TestObject1{" + "field1=" + field1 + ", field2=" + field2 + '}'; } } private JsonIterator iter; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { inputStr = "{'field1':100,'field2':101}"; input = inputStr.replace('\'', '"').getBytes(); iter = JsonIterator.parse(input); typeLiteral = new TypeLiteral() { }; typeRef = new TypeReference() { }; JacksonAnnotationSupport.enable(); jackson = new ObjectMapper(); jackson.registerModule(new AfterburnerModule()); if (params != null) { if (params.getBenchmark().contains("withJsoniterStrictMode")) { JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_STRICTLY); } if (params.getBenchmark().contains("withJsoniterReflection")) { JsoniterSpi.registerTypeDecoder(TestObject.class, ReflectionDecoderFactory.create(TestObject.class)); } } } @Test public void test() throws IOException { benchSetup(null); JsoniterSpi.registerTypeDecoder(TestObject.class, ReflectionDecoderFactory.create(TestObject.class)); System.out.println(withJsoniter()); System.out.println(withJackson()); } public static void main(String[] args) throws Exception { Main.main(new String[]{ "ConstructorBinding", "-i", "5", "-wi", "5", "-f", "1", }); } @Benchmark public void withJsoniterHashMode(Blackhole bh) throws IOException { bh.consume(withJsoniter()); } @Benchmark public void withJsoniterStrictMode(Blackhole bh) throws IOException { bh.consume(withJsoniter()); } @Benchmark public void withJsoniterReflection(Blackhole bh) throws IOException { bh.consume(withJsoniter()); } @Benchmark public void withJackson(Blackhole bh) throws IOException { bh.consume(withJackson()); } private TestObject withJsoniter() throws IOException { iter.reset(input); return iter.read(typeLiteral); } private TestObject withJackson() throws IOException { return jackson.readValue(input, typeRef); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/FieldMatching.java000066400000000000000000000105731304664171100275470ustar00rootroot00000000000000package com.jsoniter.demo; import com.jsoniter.DecodingMode; import com.jsoniter.spi.JsonException; import com.jsoniter.JsonIterator; import com.jsoniter.annotation.JsonProperty; import com.jsoniter.annotation.JsonObject; import com.jsoniter.annotation.JsoniterAnnotationSupport; import com.jsoniter.spi.TypeLiteral; import org.junit.Assert; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.Blackhole; import java.io.IOException; @State(Scope.Thread) public class FieldMatching { private TypeLiteral testObject0Type; private TypeLiteral testObject1Type; private TypeLiteral testObject2Type; private TypeLiteral testObject3Type; private TypeLiteral testObject4Type; private JsonIterator iter0; private JsonIterator iter1Success; private byte[] iter0Input; private byte[] iter1SuccessInput; public static class TestObject0 { public int field1; public int field2; public int field3; } public static class TestObject1 { @JsonProperty(required = true) public int field1; @JsonProperty(required = true) public int field2; @JsonProperty(required = true) public int field3; } @JsonObject(asExtraForUnknownProperties = true) public static class TestObject2 { public int field1; public int field2; } @JsonObject(asExtraForUnknownProperties = true, unknownPropertiesWhitelist = {"field2"}) public static class TestObject3 { public int field1; } @JsonObject(unknownPropertiesBlacklist = {"field3"}) public static class TestObject4 { public int field1; } @Setup(Level.Trial) public void benchSetup() { JsoniterAnnotationSupport.enable(); JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_STRICTLY); iter0Input = "{'field1':101,'field2':101,'field3':101}".replace('\'', '"').getBytes(); iter0 = JsonIterator.parse(iter0Input); iter1SuccessInput = "{'field1':101,'field2':101,'field3':101}".replace('\'', '"').getBytes(); iter1Success = JsonIterator.parse(iter1SuccessInput); testObject0Type = new TypeLiteral() { }; testObject1Type = new TypeLiteral() { }; testObject2Type = new TypeLiteral() { }; testObject3Type = new TypeLiteral() { }; testObject4Type = new TypeLiteral() { }; } @Test public void test() throws IOException { benchSetup(); try { JsonIterator iter1Failure = JsonIterator.parse("{'field2':101}".replace('\'', '"').getBytes()); iter1Failure.read(testObject1Type); Assert.fail(); } catch (JsonException e) { System.out.println(e); } try { JsonIterator iter2Failure = JsonIterator.parse("{'field1':101,'field2':101,'field3':101}".replace('\'', '"').getBytes()); iter2Failure.read(testObject2Type); Assert.fail(); } catch (JsonException e) { System.out.println(e); } try { JsonIterator iter3Failure = JsonIterator.parse("{'field1':101,'field2':101,'field3':101}".replace('\'', '"').getBytes()); iter3Failure.read(testObject3Type); Assert.fail(); } catch (JsonException e) { System.out.println(e); } try { JsonIterator iter4Failure = JsonIterator.parse("{'field1':101,'field2':101,'field3':101}".replace('\'', '"').getBytes()); iter4Failure.read(testObject4Type); Assert.fail(); } catch (JsonException e) { System.out.println(e); } } public static void main(String[] args) throws Exception { Main.main(new String[]{ "FieldMatching", "-i", "5", "-wi", "5", "-f", "1", }); } @Benchmark public void iter0(Blackhole bh) throws IOException { iter0.reset(iter0Input); bh.consume(iter0.read(testObject0Type)); } @Benchmark public void iter1Success(Blackhole bh) throws IOException { iter1Success.reset(iter1SuccessInput); bh.consume(iter1Success.read(testObject1Type)); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/FloatOutput.java000066400000000000000000000036521304664171100273370ustar00rootroot00000000000000package com.jsoniter.demo; import com.dslplatform.json.DslJson; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.ObjectMapper; import com.jsoniter.output.JsonStream; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import java.io.ByteArrayOutputStream; import java.io.IOException; @State(Scope.Thread) public class FloatOutput { private ByteArrayOutputStream baos; private ObjectMapper objectMapper; private JsonStream stream; private byte[] buffer; private DslJson dslJson; public static void main(String[] args) throws Exception { Main.main(new String[]{ "FloatOutput", "-i", "5", "-wi", "5", "-f", "1", }); } @Test public void test() throws IOException { benchSetup(null); jsoniter(); System.out.println(baos.toString()); jackson(); System.out.println(baos.toString()); dsljson(); System.out.println(baos.toString()); } @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { baos = new ByteArrayOutputStream(1024 * 64); objectMapper = new ObjectMapper(); objectMapper.getFactory().configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true); stream = new JsonStream(baos, 4096); buffer = new byte[4096]; dslJson = new DslJson(); } @Benchmark public void jsoniter() throws IOException { baos.reset(); stream.reset(baos); stream.writeVal(10.24f); stream.flush(); } @Benchmark public void jackson() throws IOException { baos.reset(); objectMapper.writeValue(baos, 10.24f); } @Benchmark public void dsljson() throws IOException { baos.reset(); dslJson.serialize(10.24f, baos); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/IntegerOutput.java000066400000000000000000000045571304664171100276740ustar00rootroot00000000000000package com.jsoniter.demo; import com.dslplatform.json.DslJson; import com.dslplatform.json.JsonWriter; import com.dslplatform.json.NumberConverter; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.ObjectMapper; import com.jsoniter.annotation.JsonWrapper; import com.jsoniter.output.JsonStream; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import java.io.ByteArrayOutputStream; import java.io.IOException; @State(Scope.Thread) public class IntegerOutput { private ByteArrayOutputStream baos; private ObjectMapper objectMapper; private JsonStream stream; private byte[] buffer; private DslJson dslJson; private JsonWriter jsonWriter; public static void main(String[] args) throws Exception { Main.main(new String[]{ "IntegerOutput", "-i", "5", "-wi", "5", "-f", "1", "-prof", "stack" }); } @Test public void test() throws IOException { benchSetup(null); jsoniter(null); System.out.println(baos.toString()); jackson(); System.out.println(baos.toString()); dsljson(null); System.out.println(baos.toString()); } @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { baos = new ByteArrayOutputStream(1024 * 64); objectMapper = new ObjectMapper(); objectMapper.getFactory().configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true); stream = new JsonStream(baos, 4096); buffer = new byte[4096]; dslJson = new DslJson(); jsonWriter = new JsonWriter(); } @Benchmark public void jsoniter(Blackhole bh) throws IOException { baos.reset(); stream.reset(baos); stream.writeVal(1024); stream.flush(); // bh.consume(stream); } @Benchmark public void jackson() throws IOException { baos.reset(); objectMapper.writeValue(baos, 1024); } // @Benchmark public void dsljson(Blackhole bh) throws IOException { // baos.reset(); jsonWriter.reset(); NumberConverter.serialize(1024, jsonWriter); // bh.consume(jsonWriter); // jsonWriter.toStream(baos); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/JmhFlightRecorderProfiler.java000066400000000000000000000103131304664171100321060ustar00rootroot00000000000000package com.jsoniter.demo; import java.io.File; import java.lang.management.ManagementFactory; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.List; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.profile.ExternalProfiler; import org.openjdk.jmh.results.AggregationPolicy; import org.openjdk.jmh.results.Aggregator; import org.openjdk.jmh.results.BenchmarkResult; import org.openjdk.jmh.results.Result; import org.openjdk.jmh.results.ResultRole; /** * * @author zoly */ public final class JmhFlightRecorderProfiler implements ExternalProfiler { private static final String DUMP_FOLDER = System.getProperty("jmh.stack.profiles", "/tmp"); private static final String DEFAULT_OPTIONS = System.getProperty("jmh.fr.options", "defaultrecording=true,settings=profile"); @Override public Collection addJVMInvokeOptions(final BenchmarkParams params) { return Collections.emptyList(); } private volatile String dumpFile; private static volatile String benchmarkName; public static String benchmarkName() { return benchmarkName; } /** * See: * http://docs.oracle.com/cd/E15289_01/doc.40/e15070/usingjfr.htm * and * http://docs.oracle.com/cd/E15289_01/doc.40/e15070/config_rec_data.htm * @param params * @return */ @Override public Collection addJVMOptions(final BenchmarkParams params) { final String id = params.id(); benchmarkName = id; dumpFile = DUMP_FOLDER + '/' + id + ".jfr"; String flightRecorderOptions = DEFAULT_OPTIONS + ",dumponexit=true,dumponexitpath=" + dumpFile; return Arrays.asList( "-XX:+FlightRecorder", "-XX:FlightRecorderOptions=" + flightRecorderOptions); } @Override public void beforeTrial(final BenchmarkParams benchmarkParams) { final List inputArguments = ManagementFactory.getRuntimeMXBean().getInputArguments(); // if (new Version(org.spf4j.base.Runtime.JAVA_VERSION).compareTo(new Version("1.8.0_40")) <= 0 // && !inputArguments.contains("-XX:+UnlockCommercialFeatures")) { // throw new RuntimeException("-XX:+UnlockCommercialFeatures must pre present in the JVM options," // + " current options are: " + inputArguments); // } } @Override public boolean allowPrintOut() { return true; } @Override public boolean allowPrintErr() { return false; } @Override public String getDescription() { return "Java Flight Recording profiler runs for every benchmark."; } @Override public Collection afterTrial(final BenchmarkResult bp, final long l, final File file, final File file1) { NoResult r = new NoResult("Profile saved to " + dumpFile + ", results: " + bp + ", stdOutFile = " + file + ", stdErrFile = " + file1); return Collections.singleton(r); } private static final class NoResult extends Result { private static final long serialVersionUID = 1L; private final String output; NoResult(final String output) { super(ResultRole.SECONDARY, "JFR", of(Double.NaN), "N/A", AggregationPolicy.SUM); this.output = output; } @Override protected Aggregator getThreadAggregator() { return new NoResultAggregator(); } @Override protected Aggregator getIterationAggregator() { return new NoResultAggregator(); } private static class NoResultAggregator implements Aggregator { @Override public NoResult aggregate(final Collection results) { StringBuilder agg = new StringBuilder(); for (NoResult r : results) { agg.append(r.output); } return new NoResult(agg.toString()); } } } @Override public String toString() { return "JmhFlightRecorderProfiler{" + "dumpFile=" + dumpFile + '}'; } }java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/LazyAny.java000066400000000000000000000050011304664171100264260ustar00rootroot00000000000000package com.jsoniter.demo; import com.jsoniter.any.Any; import com.jsoniter.JsonIterator; import com.jsoniter.Slice; import com.jsoniter.output.JsonStream; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import java.io.IOException; import java.io.InputStream; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; @State(Scope.Thread) public class LazyAny { private JsonIterator iter; private Slice input; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) throws IOException { InputStream resourceAsStream = LazyAny.class.getResourceAsStream("/large.json"); byte[] buf = new byte[32 * 1024]; int size = resourceAsStream.read(buf); input = new Slice(buf, 0, size); iter = new JsonIterator(); } public static void main(String[] args) throws Exception { Main.main(new String[]{ "LazyAny", "-i", "5", "-wi", "5", "-f", "1", "-prof", "stack", }); } public static class User { public int index; public String name; } @Test public void test() throws IOException { benchSetup(null); System.out.println(jsoniter()); System.out.println(jsoniter_object()); User tom = new User(); tom.index = 1; tom.name = "tom"; Map tomAsMap = Any.wrap(tom).asMap(); tomAsMap.put("age", Any.wrap(17)); System.out.println(JsonStream.serialize(tomAsMap)); } @Benchmark public void jsoniter(Blackhole bh) throws IOException { bh.consume(jsoniter()); } @Benchmark public void jsoniter_object(Blackhole bh) throws IOException { bh.consume(jsoniter_object()); } public int jsoniter() throws IOException { iter.reset(input); Any users = iter.readAny(); int total = 0; for (Any user : users) { total += user.get("friends").size(); } return total; } public int jsoniter_object() throws IOException { iter.reset(input); List users = (List) iter.read(); int total = 0; for (Object userObj : users) { Map user = (Map) userObj; List friends = (List) user.get("friends"); total += friends.size(); } return total; } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/ListBinding.java000066400000000000000000000051401304664171100272510ustar00rootroot00000000000000package com.jsoniter.demo; import com.dslplatform.json.DslJson; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import com.jsoniter.JsonIterator; import com.jsoniter.annotation.JacksonAnnotationSupport; import com.jsoniter.spi.TypeLiteral; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import java.io.IOException; import java.util.List; @State(Scope.Thread) public class ListBinding { private TypeLiteral> typeLiteral; private ObjectMapper jackson; private byte[] input; private TypeReference> typeRef; private String inputStr; private JsonIterator iter; private DslJson dslJson; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { inputStr = "['jackson','jsoniter','fastjson']".replace('\'', '"'); input = inputStr.getBytes(); iter = JsonIterator.parse(input); typeLiteral = new TypeLiteral>() { }; typeRef = new TypeReference>() { }; JacksonAnnotationSupport.enable(); jackson = new ObjectMapper(); jackson.registerModule(new AfterburnerModule()); dslJson = new DslJson(); } @Test public void test() throws IOException { benchSetup(null); System.out.println(withJsoniter()); System.out.println(withJackson()); System.out.println(withDsljson()); } public static void main(String[] args) throws Exception { Main.main(new String[]{ "ListBinding", "-i", "5", "-wi", "5", "-f", "1", }); } @Benchmark public void withJsoniterBinding(Blackhole bh) throws IOException { bh.consume(withJsoniter()); } @Benchmark public void withJackson(Blackhole bh) throws IOException { bh.consume(withJackson()); } @Benchmark public void withDsljson(Blackhole bh) throws IOException { bh.consume(withDsljson()); } private List withJsoniter() throws IOException { iter.reset(input); return iter.read(typeLiteral); } private List withJackson() throws IOException { return jackson.readValue(input, typeRef); } private List withDsljson() throws IOException { return (List) dslJson.deserializeList(String.class, input, input.length); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/MapBinding.java000066400000000000000000000052321304664171100270550ustar00rootroot00000000000000package com.jsoniter.demo; import com.dslplatform.json.DslJson; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import com.jsoniter.JsonIterator; import com.jsoniter.annotation.JacksonAnnotationSupport; import com.jsoniter.spi.TypeLiteral; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import java.io.IOException; import java.util.Arrays; import java.util.Map; @State(Scope.Thread) public class MapBinding { private TypeLiteral> typeLiteral; private ObjectMapper jackson; private byte[] input; private TypeReference> typeRef; private String inputStr; private JsonIterator iter; private DslJson dslJson; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { inputStr = "{'jsoniter':53.9123,'jackson':-8772.2131,'dsljson':99877}".replace('\'', '"'); input = inputStr.getBytes(); iter = JsonIterator.parse(input); typeLiteral = new TypeLiteral>() { }; typeRef = new TypeReference>() { }; JacksonAnnotationSupport.enable(); jackson = new ObjectMapper(); jackson.registerModule(new AfterburnerModule()); dslJson = new DslJson(); } @Test public void test() throws IOException { benchSetup(null); System.out.println(withJsoniter()); System.out.println(withJackson()); System.out.println(withDsljson()); } public static void main(String[] args) throws Exception { Main.main(new String[]{ "MapBinding", "-i", "5", "-wi", "5", "-f", "1", }); } @Benchmark public void withJsoniterBinding(Blackhole bh) throws IOException { bh.consume(withJsoniter()); } @Benchmark public void withJackson(Blackhole bh) throws IOException { bh.consume(withJackson()); } @Benchmark public void withDsljson(Blackhole bh) throws IOException { bh.consume(withDsljson()); } private Map withJsoniter() throws IOException { iter.reset(input); return iter.read(typeLiteral); } private Map withJackson() throws IOException { return jackson.readValue(input, typeRef); } private Map withDsljson() throws IOException { return (Map) dslJson.deserialize(Map.class, input, input.length); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/ModelTest.java000066400000000000000000000103031304664171100267400ustar00rootroot00000000000000package com.jsoniter.demo; import com.alibaba.fastjson.JSON; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.spi.TypeLiteral; import com.squareup.moshi.JsonAdapter; import com.squareup.moshi.Moshi; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.IOException; // Benchmark Mode Cnt Score Error Units // ModelTest.fastjson thrpt 5 7790201.506 ± 260185.529 ops/s // ModelTest.jackson thrpt 5 4063696.579 ± 169609.697 ops/s // ModelTest.jsoniter thrpt 5 16392968.819 ± 197563.536 ops/s @State(Scope.Thread) public class ModelTest { private String input; private JsonIterator iter; private byte[] inputBytes; private TypeLiteral modelTypeLiteral; // this is thread-safe can reused private ObjectMapper jackson; private TypeReference modelTypeReference; private JsonAdapter moshiAdapter; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { // JsonIterator.enableStreamingSupport(); input = "{\"name\":\"wenshao\",\"id\":1001}"; inputBytes = input.getBytes(); iter = new JsonIterator(); modelTypeLiteral = new TypeLiteral() { }; JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); jackson = new ObjectMapper(); jackson.registerModule(new AfterburnerModule()); modelTypeReference = new TypeReference() { }; Moshi moshi = new Moshi.Builder().build(); moshiAdapter = moshi.adapter(Model.class); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "ModelTest", "-i", "5", "-wi", "5", "-f", "1", // "-jvmArgsAppend", "-server -XX:+DoEscapeAnalysis", }); } @Test public void test() throws IOException { benchSetup(null); iter.reset(inputBytes); System.out.println(iter.read(modelTypeLiteral).name); System.out.println(moshiAdapter.fromJson(input).name); } // public static void main(String[] args) throws Exception { // Options opt = new OptionsBuilder() // .include("ModelTest") // .addProfiler(JmhFlightRecorderProfiler.class) // .jvmArgs("-Xmx512m", "-Xms512m", "-XX:+UnlockCommercialFeatures", // "-XX:+UnlockDiagnosticVMOptions", "-XX:+PrintAssembly", // "-Djmh.stack.profiles=" + "/tmp", // "-Djmh.executor=FJP", // "-Djmh.fr.options=defaultrecording=true,settings=profile") // .warmupIterations(5) // .measurementTime(TimeValue.seconds(5)) // .measurementIterations(5) // .forks(1) // .build(); // new Runner(opt).run(); // } @Benchmark public void jsoniter(Blackhole bh) throws IOException { iter.reset(inputBytes); bh.consume(iter.read(modelTypeLiteral)); } // @Benchmark public void jsoniter_easy_mode(Blackhole bh) throws IOException { bh.consume(JsonIterator.deserialize(inputBytes, Model.class)); } // @Benchmark public void fastjson(Blackhole bh) throws IOException { // this is not a exactly fair comparison, // as string => object is not // bytes => object bh.consume(JSON.parseObject(input, Model.class)); } @Benchmark public void moshi(Blackhole bh) throws IOException { bh.consume(moshiAdapter.fromJson(input)); } // @Benchmark public void jackson(Blackhole bh) throws IOException { bh.consume(jackson.readValue(inputBytes, modelTypeReference)); } public static class Model { public int id; public String name; } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/PrivateFieldBinding.java000066400000000000000000000063531304664171100307230ustar00rootroot00000000000000package com.jsoniter.demo; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import com.jsoniter.JsonIterator; import com.jsoniter.ReflectionDecoderFactory; import com.jsoniter.annotation.JacksonAnnotationSupport; import com.jsoniter.spi.EmptyExtension; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.ParameterizedTypeImpl; import com.jsoniter.spi.TypeLiteral; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.Blackhole; import java.io.IOException; import java.lang.reflect.Type; import java.util.LinkedList; import java.util.List; @State(Scope.Thread) public class PrivateFieldBinding { private TypeLiteral typeLiteral; private ObjectMapper jackson; private byte[] input; private TypeReference typeRef; private String inputStr; public static class TestObject { @JsonProperty private int field1; @JsonProperty private int field2; @Override public String toString() { return "TestObject1{" + "field1=" + field1 + ", field2=" + field2 + '}'; } } private JsonIterator iter; @Setup(Level.Trial) public void benchSetup() { inputStr = "{'field1':100,'field2':101}"; input = inputStr.replace('\'', '"').getBytes(); iter = JsonIterator.parse(input); typeLiteral = new TypeLiteral() { }; typeRef = new TypeReference() { }; JacksonAnnotationSupport.enable(); JsoniterSpi.registerTypeDecoder(TestObject.class, ReflectionDecoderFactory.create(TestObject.class)); jackson = new ObjectMapper(); jackson.registerModule(new AfterburnerModule()); } @Test public void test() throws IOException { JsoniterSpi.registerExtension(new EmptyExtension() { @Override public Type chooseImplementation(Type type) { if (ParameterizedTypeImpl.isSameClass(type, List.class)) { return ParameterizedTypeImpl.useImpl(type, LinkedList.class); } else { return type; } } }); benchSetup(); System.out.println(withJsoniter()); System.out.println(withJackson()); } @Benchmark public void withJsoniter(Blackhole bh) throws IOException { bh.consume(withJsoniter()); } @Benchmark public void withJackson(Blackhole bh) throws IOException { bh.consume(withJackson()); } public static void main(String[] args) throws Exception { Main.main(new String[]{ "PrivateFieldBinding.*", "-i", "5", "-wi", "5", "-f", "1", }); } private TestObject withJsoniter() throws IOException { iter.reset(input); return iter.read(typeLiteral); } private TestObject withJackson() throws IOException { return jackson.readValue(input, typeRef); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/ReadString.java000066400000000000000000000026321304664171100271100ustar00rootroot00000000000000package com.jsoniter.demo; import com.dslplatform.json.CustomJsonReader; import com.dslplatform.json.JsonReader; import com.jsoniter.JsonIterator; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import java.io.IOException; @State(Scope.Thread) public class ReadString { private JsonIterator jsonIterator; private byte[] input; private CustomJsonReader customJsonReader; public static void main(String[] args) throws Exception { Main.main(new String[]{ "ReadString", "-i", "5", "-wi", "5", "-f", "1", }); } @Test public void test() throws IOException { benchSetup(null); } @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { jsonIterator = new JsonIterator(); input = "\"hello world hello world\"".getBytes(); customJsonReader = new CustomJsonReader(input); } @Benchmark public void jsoniter(Blackhole bh) throws IOException { jsonIterator.reset(input); bh.consume(jsonIterator.readString()); } @Benchmark public void dsljson(Blackhole bh) throws IOException { customJsonReader.reset(); customJsonReader.read(); bh.consume(customJsonReader.readString()); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/SetterBinding.java000066400000000000000000000073411304664171100276110ustar00rootroot00000000000000package com.jsoniter.demo; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.ReflectionDecoderFactory; import com.jsoniter.annotation.JacksonAnnotationSupport; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.TypeLiteral; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import java.io.IOException; @State(Scope.Thread) public class SetterBinding { private TypeLiteral typeLiteral; private ObjectMapper jackson; private byte[] input; private TypeReference typeRef; private String inputStr; public static class TestObject { private int field1; private int field2; public void setField1(int field1) { this.field1 = field1; } public void setField2(int field2) { this.field2 = field2; } // @JsonWrapper // public void initialize( // @JsonProperty("field1") int field1, // @JsonProperty("field2") int field2) { // this.field1 = field1; // this.field2 = field2; // } } private JsonIterator iter; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { inputStr = "{'field1':100,'field2':101}".replace('\'', '"'); input = inputStr.getBytes(); iter = JsonIterator.parse(input); typeLiteral = new TypeLiteral() { }; typeRef = new TypeReference() { }; JacksonAnnotationSupport.enable(); jackson = new ObjectMapper(); jackson.registerModule(new AfterburnerModule()); if (params != null) { if (params.getBenchmark().contains("withJsoniterStrictMode")) { JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_STRICTLY); } if (params.getBenchmark().contains("withJsoniterReflection")) { JsoniterSpi.registerTypeDecoder(ConstructorBinding.TestObject.class, ReflectionDecoderFactory.create(TestObject.class)); } } } @Test public void test() throws IOException { benchSetup(null); JsoniterSpi.registerTypeDecoder(ConstructorBinding.TestObject.class, ReflectionDecoderFactory.create(TestObject.class)); System.out.println(withJsoniter()); System.out.println(withJackson()); } public static void main(String[] args) throws Exception { Main.main(new String[]{ "ConstructorBinding", "-i", "5", "-wi", "5", "-f", "1", }); } @Benchmark public void withJsoniterHashMode(Blackhole bh) throws IOException { bh.consume(withJsoniter()); } @Benchmark public void withJsoniterStrictMode(Blackhole bh) throws IOException { bh.consume(withJsoniter()); } @Benchmark public void withJsoniterReflection(Blackhole bh) throws IOException { bh.consume(withJsoniter()); } @Benchmark public void withJackson(Blackhole bh) throws IOException { bh.consume(withJackson()); } private ConstructorBinding.TestObject withJsoniter() throws IOException { iter.reset(input); return iter.read(typeLiteral); } private ConstructorBinding.TestObject withJackson() throws IOException { return jackson.readValue(input, typeRef); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/SimpleObjectBinding.java000066400000000000000000000156461304664171100307320ustar00rootroot00000000000000package com.jsoniter.demo; import com.alibaba.fastjson.parser.DefaultJSONParser; import com.dslplatform.json.CompiledJson; import com.dslplatform.json.DslJson; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.ReflectionDecoderFactory; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.TypeLiteral; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import java.io.IOException; @State(Scope.Thread) public class SimpleObjectBinding { private TypeLiteral typeLiteral; private ObjectMapper jackson; private byte[] input; private TypeReference typeRef; private DslJson dslJson; private Class clazz; private String inputStr; private TestObject testObject; @CompiledJson public static class TestObject { public int field1; public int field2; @Override public String toString() { return "TestObject1{" + "field1=" + field1 + ", field2=" + field2 + '}'; } } private JsonIterator iter; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { inputStr = "{'field1':100,'field2':101}".replace('\'', '"'); input = inputStr.getBytes(); iter = JsonIterator.parse(input); typeLiteral = new TypeLiteral() { }; typeRef = new TypeReference() { }; clazz = TestObject.class; jackson = new ObjectMapper(); dslJson = new DslJson(); testObject = new TestObject(); if (params != null) { if (params.getBenchmark().contains("withReflection")) { JsoniterSpi.registerTypeDecoder(TestObject.class, ReflectionDecoderFactory.create(TestObject.class)); } if (params.getBenchmark().contains("withBindApiStrictMode")) { JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_STRICTLY); } if (params.getBenchmark().contains("withJacksonAfterburner")) { jackson.registerModule(new AfterburnerModule()); } } } @Test public void test() throws IOException { benchSetup(null); JsoniterSpi.registerTypeDecoder(TestObject.class, ReflectionDecoderFactory.create(TestObject.class)); System.out.println(withIterator()); System.out.println(withIteratorIfElse()); System.out.println(withIteratorIntern()); System.out.println(withBindApi()); System.out.println(withExistingObject()); System.out.println(withJackson()); System.out.println(withDsljson()); System.out.println(withFastjson()); } public static void main(String[] args) throws Exception { Main.main(new String[]{ "SimpleObjectBinding.*", "-i", "5", "-wi", "5", "-f", "1" }); } // @Benchmark public void withIterator(Blackhole bh) throws IOException { bh.consume(withIterator()); } // @Benchmark public void withIteratorIfElse(Blackhole bh) throws IOException { bh.consume(withIteratorIfElse()); } // @Benchmark public void withIteratorIntern(Blackhole bh) throws IOException { bh.consume(withIteratorIntern()); } @Benchmark public void withoutExistingObject(Blackhole bh) throws IOException { bh.consume(withBindApi()); } @Benchmark public void withBindApiStrictMode(Blackhole bh) throws IOException { bh.consume(withBindApi()); } @Benchmark public void withReflection(Blackhole bh) throws IOException { bh.consume(withBindApi()); } @Benchmark public void withExistingObject(Blackhole bh) throws IOException { bh.consume(withExistingObject()); } @Benchmark public void withJacksonAfterburner(Blackhole bh) throws IOException { bh.consume(withJackson()); } @Benchmark public void withJacksonNoAfterburner(Blackhole bh) throws IOException { bh.consume(withJackson()); } @Benchmark public void withDsljson(Blackhole bh) throws IOException { bh.consume(withDsljson()); } @Benchmark public void withFastjson(Blackhole bh) throws IOException { bh.consume(withFastjson()); } private TestObject withIterator() throws IOException { iter.reset(input); TestObject obj = new TestObject(); for (String field = iter.readObject(); field != null; field = iter.readObject()) { switch (field) { case "field1": obj.field1 = iter.readInt(); continue; case "field2": obj.field2 = iter.readInt(); continue; default: iter.skip(); } } return obj; } private TestObject withIteratorIfElse() throws IOException { iter.reset(input); TestObject obj = new TestObject(); for (String field = iter.readObject(); field != null; field = iter.readObject()) { if (field.equals("field1")) { obj.field1 = iter.readInt(); continue; } if (field.equals("field2")) { obj.field2 = iter.readInt(); continue; } iter.skip(); } return obj; } private TestObject withIteratorIntern() throws IOException { iter.reset(input); TestObject obj = new TestObject(); for (String field = iter.readObject(); field != null; field = iter.readObject()) { field = field.intern(); if (field == "field1") { obj.field1 = iter.readInt(); continue; } if (field == "field2") { obj.field2 = iter.readInt(); continue; } iter.skip(); } return obj; } private TestObject withBindApi() throws IOException { iter.reset(input); return iter.read(typeLiteral); } private TestObject withExistingObject() throws IOException { iter.reset(input); return iter.read(typeLiteral, testObject); } private TestObject withJackson() throws IOException { return jackson.readValue(input, typeRef); } private TestObject withDsljson() throws IOException { return (TestObject) dslJson.deserialize(clazz, input, input.length); } private TestObject withFastjson() { return new DefaultJSONParser(inputStr).parseObject(TestObject.class); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/StringOutput.java000066400000000000000000000042471304664171100275410ustar00rootroot00000000000000package com.jsoniter.demo; import com.dslplatform.json.DslJson; import com.dslplatform.json.JsonWriter; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.ObjectMapper; import com.jsoniter.output.JsonStream; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import java.io.ByteArrayOutputStream; import java.io.IOException; @State(Scope.Thread) public class StringOutput { private ByteArrayOutputStream baos; private ObjectMapper objectMapper; private JsonStream stream; private byte[] buffer; private DslJson dslJson; private JsonWriter jsonWriter; public static void main(String[] args) throws Exception { Main.main(new String[]{ "StringOutput", "-i", "5", "-wi", "5", "-f", "1", }); } @Test public void test() throws IOException { benchSetup(null); jsoniter(); System.out.println(baos.toString()); jackson(); System.out.println(baos.toString()); dsljson(); System.out.println(baos.toString()); } @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { baos = new ByteArrayOutputStream(1024 * 64); objectMapper = new ObjectMapper(); objectMapper.getFactory().configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true); stream = new JsonStream(baos, 4096); buffer = new byte[4096]; dslJson = new DslJson(); jsonWriter = new JsonWriter(); } @Benchmark public void jsoniter() throws IOException { baos.reset(); stream.reset(baos); stream.writeVal("hello world ~~ hello 中文 ~~~"); stream.flush(); } @Benchmark public void jackson() throws IOException { baos.reset(); objectMapper.writeValue(baos, "hello world ~~ hello 中文 ~~~"); } @Benchmark public void dsljson() throws IOException { baos.reset(); jsonWriter.reset(); jsonWriter.write("hello world ~~ hello 中文 ~~~"); jsonWriter.toStream(baos); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/WrapperUnwrapper.java000066400000000000000000000033711304664171100303730ustar00rootroot00000000000000package com.jsoniter.demo; import com.jsoniter.JsonIterator; import com.jsoniter.annotation.*; import com.jsoniter.output.JsonStream; import org.junit.Test; import java.io.IOException; public class WrapperUnwrapper { public static class Name { private final String firstName; private final String lastName; public Name(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } } public static class User { private Name name; public int score; @JsonIgnore public Name getName() { return name; } @JsonUnwrapper public void writeName(JsonStream stream) throws IOException { stream.writeObjectField("firstName"); stream.writeVal(name.getFirstName()); stream.writeMore(); stream.writeObjectField("lastName"); stream.writeVal(name.getLastName()); } @JsonWrapper public void setName(@JsonProperty("firstName") String firstName, @JsonProperty("lastName") String lastName) { System.out.println(firstName); name = new Name(firstName, lastName); } } @Test public void test() { JsoniterAnnotationSupport.enable(); String input = "{'firstName': 'tao', 'lastName': 'wen', 'score': 100}".replace('\'', '\"'); System.out.println(input); User user = JsonIterator.deserialize(input, User.class); System.out.println(user.getName().getFirstName()); System.out.println(JsonStream.serialize(user)); System.out.println(JsonStream.serialize(new int[]{1,2,3})); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_10_fields/000077500000000000000000000000001304664171100303275ustar00rootroot00000000000000BenchDslJson.java000066400000000000000000000041021304664171100334240ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_10_fieldspackage com.jsoniter.demo.object_with_10_fields; import com.dslplatform.json.CustomJsonReader; import com.dslplatform.json.ExternalSerialization; import com.dslplatform.json.JsonWriter; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchDslJson.deser thrpt 5 22328042.432 ± 311925.080 ops/s (3.67x) BenchDslJson.ser thrpt 5 17639416.242 ± 136738.841 ops/s (2.17x) */ @State(Scope.Thread) public class BenchDslJson { private TestObject testObject; private JsonWriter jsonWriter; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private CustomJsonReader reader; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); jsonWriter = new JsonWriter(); byteArrayOutputStream = new ByteArrayOutputStream(); reader = new CustomJsonReader(testJSON); } @Benchmark public void ser(Blackhole bh) throws IOException { jsonWriter.reset(); byteArrayOutputStream.reset(); ExternalSerialization.serialize(testObject, jsonWriter, false); jsonWriter.toStream(byteArrayOutputStream); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { reader.reset(); reader.read(); reader.getNextToken(); TestObject obj = new TestObject(); ExternalSerialization.deserialize(obj, reader); bh.consume(obj); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_10_fields.BenchDslJson", "-i", "5", "-wi", "5", "-f", "1", }); } } BenchJackson.java000066400000000000000000000037441304664171100334530ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_10_fieldspackage com.jsoniter.demo.object_with_10_fields; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJackson.deser thrpt 5 3536224.629 ± 22392.435 ops/s BenchJackson.ser thrpt 5 5373951.842 ± 325328.400 ops/s */ @State(Scope.Thread) public class BenchJackson { private ObjectMapper objectMapper; private TypeReference typeReference; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private TestObject testObject; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { objectMapper = new ObjectMapper(); objectMapper.registerModule(new AfterburnerModule()); typeReference = new TypeReference() { }; byteArrayOutputStream = new ByteArrayOutputStream(); testJSON = TestObject.createTestJSON(); testObject = TestObject.createTestObject(); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); objectMapper.writeValue(byteArrayOutputStream, testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { bh.consume(objectMapper.readValue(testJSON, typeReference)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_10_fields.BenchJackson", "-i", "5", "-wi", "5", "-f", "1", }); } } BenchJsoniter.java000066400000000000000000000042101304664171100336450ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_10_fieldspackage com.jsoniter.demo.object_with_10_fields; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.TypeLiteral; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJsoniter.deser thrpt 5 7886115.451 ± 335769.969 ops/s (2.23x) BenchJsoniter.ser thrpt 5 13216858.758 ± 611385.896 ops/s (2.46x) */ @State(Scope.Thread) public class BenchJsoniter { private TestObject testObject; private JsonStream stream; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private JsonIterator iter; private TypeLiteral typeLiteral; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { JsonStream.setMode(EncodingMode.DYNAMIC_MODE); JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); stream = new JsonStream(null, 512); byteArrayOutputStream = new ByteArrayOutputStream(); iter = new JsonIterator(); typeLiteral = TypeLiteral.create(TestObject.class); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); stream.reset(byteArrayOutputStream); stream.writeVal(testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { iter.reset(testJSON); bh.consume(iter.read(typeLiteral)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_10_fields.BenchJsoniter", "-i", "5", "-wi", "5", "-f", "1", }); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_10_fields/TestObject.java000066400000000000000000000017621304664171100332460ustar00rootroot00000000000000package com.jsoniter.demo.object_with_10_fields; import com.dslplatform.json.CompiledJson; import com.jsoniter.output.JsonStream; @CompiledJson public class TestObject { public String field1; public String field2; public String field3; public String field4; public String field5; public String field6; public String field7; public String field8; public String field9; public String field10; public static TestObject createTestObject() { TestObject testObject = new TestObject(); testObject.field1 = ""; testObject.field2 = ""; testObject.field3 = ""; testObject.field4 = ""; testObject.field5 = ""; testObject.field6 = ""; testObject.field7 = ""; testObject.field8 = ""; testObject.field9 = ""; testObject.field10 = ""; return testObject; } public static byte[] createTestJSON() { return JsonStream.serialize(createTestObject()).getBytes(); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_15_fields/000077500000000000000000000000001304664171100303345ustar00rootroot00000000000000BenchDslJson.java000066400000000000000000000041021304664171100334310ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_15_fieldspackage com.jsoniter.demo.object_with_15_fields; import com.dslplatform.json.CustomJsonReader; import com.dslplatform.json.ExternalSerialization; import com.dslplatform.json.JsonWriter; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchDslJson.deser thrpt 5 22328042.432 ± 311925.080 ops/s (3.67x) BenchDslJson.ser thrpt 5 17639416.242 ± 136738.841 ops/s (2.17x) */ @State(Scope.Thread) public class BenchDslJson { private TestObject testObject; private JsonWriter jsonWriter; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private CustomJsonReader reader; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); jsonWriter = new JsonWriter(); byteArrayOutputStream = new ByteArrayOutputStream(); reader = new CustomJsonReader(testJSON); } @Benchmark public void ser(Blackhole bh) throws IOException { jsonWriter.reset(); byteArrayOutputStream.reset(); ExternalSerialization.serialize(testObject, jsonWriter, false); jsonWriter.toStream(byteArrayOutputStream); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { reader.reset(); reader.read(); reader.getNextToken(); TestObject obj = new TestObject(); ExternalSerialization.deserialize(obj, reader); bh.consume(obj); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_15_fields.BenchDslJson", "-i", "5", "-wi", "5", "-f", "1", }); } } BenchJackson.java000066400000000000000000000037441304664171100334600ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_15_fieldspackage com.jsoniter.demo.object_with_15_fields; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJackson.deser thrpt 5 1554344.234 ± 341967.936 ops/s BenchJackson.ser thrpt 5 2399893.422 ± 199116.685 ops/s */ @State(Scope.Thread) public class BenchJackson { private ObjectMapper objectMapper; private TypeReference typeReference; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private TestObject testObject; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { objectMapper = new ObjectMapper(); objectMapper.registerModule(new AfterburnerModule()); typeReference = new TypeReference() { }; byteArrayOutputStream = new ByteArrayOutputStream(); testJSON = TestObject.createTestJSON(); testObject = TestObject.createTestObject(); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); objectMapper.writeValue(byteArrayOutputStream, testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { bh.consume(objectMapper.readValue(testJSON, typeReference)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_15_fields.BenchJackson", "-i", "5", "-wi", "5", "-f", "1", }); } } BenchJsoniter.java000066400000000000000000000041651304664171100336630ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_15_fieldspackage com.jsoniter.demo.object_with_15_fields; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.TypeLiteral; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJsoniter.deser thrpt 5 3168123.269 ± 467680.688 ops/s BenchJsoniter.ser thrpt 5 8903974.466 ± 500114.000 ops/s */ @State(Scope.Thread) public class BenchJsoniter { private TestObject testObject; private JsonStream stream; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private JsonIterator iter; private TypeLiteral typeLiteral; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { JsonStream.setMode(EncodingMode.DYNAMIC_MODE); JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); stream = new JsonStream(null, 512); byteArrayOutputStream = new ByteArrayOutputStream(); iter = new JsonIterator(); typeLiteral = TypeLiteral.create(TestObject.class); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); stream.reset(byteArrayOutputStream); stream.writeVal(testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { iter.reset(testJSON); bh.consume(iter.read(typeLiteral)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_15_fields.BenchJsoniter", "-i", "5", "-wi", "5", "-f", "1", }); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_15_fields/TestObject.java000066400000000000000000000024361304664171100332520ustar00rootroot00000000000000package com.jsoniter.demo.object_with_15_fields; import com.dslplatform.json.CompiledJson; import com.jsoniter.output.JsonStream; @CompiledJson public class TestObject { public String field1; public String field2; public String field3; public String field4; public String field5; public String field6; public String field7; public String field8; public String field9; public String field10; public String field11; public String field12; public String field13; public String field14; public String field15; public static TestObject createTestObject() { TestObject testObject = new TestObject(); testObject.field1 = ""; testObject.field2 = ""; testObject.field3 = ""; testObject.field4 = ""; testObject.field5 = ""; testObject.field6 = ""; testObject.field7 = ""; testObject.field8 = ""; testObject.field9 = ""; testObject.field10 = ""; testObject.field11 = ""; testObject.field12 = ""; testObject.field13 = ""; testObject.field14 = ""; testObject.field15 = ""; return testObject; } public static byte[] createTestJSON() { return JsonStream.serialize(createTestObject()).getBytes(); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_double_field/000077500000000000000000000000001304664171100314165ustar00rootroot00000000000000BenchJackson.java000066400000000000000000000037561304664171100345450ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_double_fieldpackage com.jsoniter.demo.object_with_1_double_field; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJackson.deser thrpt 5 5822021.435 ± 208030.778 ops/s BenchJackson.ser thrpt 5 5359413.928 ± 180612.520 ops/s */ @State(Scope.Thread) public class BenchJackson { private ObjectMapper objectMapper; private TypeReference typeReference; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private TestObject testObject; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { objectMapper = new ObjectMapper(); objectMapper.registerModule(new AfterburnerModule()); typeReference = new TypeReference() { }; byteArrayOutputStream = new ByteArrayOutputStream(); testJSON = TestObject.createTestJSON(); testObject = TestObject.createTestObject(); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); objectMapper.writeValue(byteArrayOutputStream, testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { bh.consume(objectMapper.readValue(testJSON, typeReference)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_double_field.BenchJackson", "-i", "5", "-wi", "5", "-f", "1", }); } } BenchJsoniter.java000066400000000000000000000042251304664171100347420ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_double_fieldpackage com.jsoniter.demo.object_with_1_double_field; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.TypeLiteral; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJsoniter.deser thrpt 5 38116542.503 ± 1084084.112 ops/s (6.55x) BenchJsoniter.ser thrpt 5 23531684.342 ± 132018.833 ops/s (4.39x) */ @State(Scope.Thread) public class BenchJsoniter { private TestObject testObject; private JsonStream stream; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private JsonIterator iter; private TypeLiteral typeLiteral; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { JsonStream.setMode(EncodingMode.DYNAMIC_MODE); JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); stream = new JsonStream(null, 512); byteArrayOutputStream = new ByteArrayOutputStream(); iter = new JsonIterator(); typeLiteral = TypeLiteral.create(TestObject.class); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); stream.reset(byteArrayOutputStream); stream.writeVal(testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { iter.reset(testJSON); bh.consume(iter.read(typeLiteral)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_double_field.BenchJsoniter", "-i", "5", "-wi", "5", "-f", "1", }); } } BenchThrift.java000066400000000000000000000047731304664171100344150ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_double_fieldpackage com.jsoniter.demo.object_with_1_double_field; import org.apache.thrift.TDeserializer; import org.apache.thrift.TException; import org.apache.thrift.TSerializer; import org.apache.thrift.protocol.TBinaryProtocol; import org.apache.thrift.protocol.TCompactProtocol; import org.apache.thrift.protocol.TTupleProtocol; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.IOException; /* Tuple Benchmark Mode Cnt Score Error Units BenchThrift.deser thrpt 5 77600452.253 ± 3008784.281 ops/s (13.33x) BenchThrift.ser thrpt 5 17332754.587 ± 61510.842 ops/s (3.23x) Binary Benchmark Mode Cnt Score Error Units BenchThrift.deser thrpt 5 49551979.325 ± 2339931.620 ops/s (8.51x) BenchThrift.ser thrpt 5 8364225.101 ± 71229.879 ops/s (1.56x) */ @State(Scope.Thread) public class BenchThrift { private TSerializer serializer; private ThriftTestObject testObject; private TDeserializer deserializer; private byte[] testData; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) throws TException { testObject = new ThriftTestObject(); testObject.field1 = 1024; serializer = new TSerializer(new TTupleProtocol.Factory()); // serializer = new TSerializer(new TBinaryProtocol.Factory()); deserializer = new TDeserializer(new TTupleProtocol.Factory()); // deserializer = new TDeserializer(new TBinaryProtocol.Factory()); testData = serializer.serialize(testObject); } @Test public void test() throws TException { byte[] output = new TSerializer(new TCompactProtocol.Factory()).serialize(testObject); System.out.println(output.length); } @Benchmark public void ser(Blackhole bh) throws TException { bh.consume(serializer.serialize(testObject)); } @Benchmark public void deser(Blackhole bh) throws TException { ThriftTestObject obj = new ThriftTestObject(); deserializer.deserialize(testObject, testData); bh.consume(obj); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_double_field.BenchThrift", "-i", "5", "-wi", "5", "-f", "1", }); } } TestObject.java000066400000000000000000000007571304664171100342610ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_double_fieldpackage com.jsoniter.demo.object_with_1_double_field; import com.dslplatform.json.CompiledJson; import com.jsoniter.output.JsonStream; @CompiledJson public class TestObject { public double field1; public static TestObject createTestObject() { TestObject testObject = new TestObject(); testObject.field1 = 10.24d; return testObject; } public static byte[] createTestJSON() { return JsonStream.serialize(createTestObject()).getBytes(); } } TestObject.thrift000066400000000000000000000000561304664171100346300ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_double_fieldstruct ThriftTestObject { 1: double field1 }ThriftTestObject.java000066400000000000000000000271541304664171100354420ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_double_fieldpackage com.jsoniter.demo.object_with_1_double_field; /** * Autogenerated by Thrift Compiler (0.9.1) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated */ import org.apache.thrift.scheme.IScheme; import org.apache.thrift.scheme.SchemeFactory; import org.apache.thrift.scheme.StandardScheme; import org.apache.thrift.scheme.TupleScheme; import org.apache.thrift.protocol.TTupleProtocol; import org.apache.thrift.protocol.TProtocolException; import org.apache.thrift.EncodingUtils; import org.apache.thrift.TException; import org.apache.thrift.async.AsyncMethodCallback; import org.apache.thrift.server.AbstractNonblockingServer.*; import java.util.List; import java.util.ArrayList; import java.util.Map; import java.util.HashMap; import java.util.EnumMap; import java.util.Set; import java.util.HashSet; import java.util.EnumSet; import java.util.Collections; import java.util.BitSet; import java.nio.ByteBuffer; import java.util.Arrays; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class ThriftTestObject implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ThriftTestObject"); private static final org.apache.thrift.protocol.TField FIELD1_FIELD_DESC = new org.apache.thrift.protocol.TField("field1", org.apache.thrift.protocol.TType.DOUBLE, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { schemes.put(StandardScheme.class, new ThriftTestObjectStandardSchemeFactory()); schemes.put(TupleScheme.class, new ThriftTestObjectTupleSchemeFactory()); } public double field1; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { FIELD1((short)1, "field1"); private static final Map byName = new HashMap(); static { for (_Fields field : EnumSet.allOf(_Fields.class)) { byName.put(field.getFieldName(), field); } } /** * Find the _Fields constant that matches fieldId, or null if its not found. */ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 1: // FIELD1 return FIELD1; default: return null; } } /** * Find the _Fields constant that matches fieldId, throwing an exception * if it is not found. */ public static _Fields findByThriftIdOrThrow(int fieldId) { _Fields fields = findByThriftId(fieldId); if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); return fields; } /** * Find the _Fields constant that matches name, or null if its not found. */ public static _Fields findByName(String name) { return byName.get(name); } private final short _thriftId; private final String _fieldName; _Fields(short thriftId, String fieldName) { _thriftId = thriftId; _fieldName = fieldName; } public short getThriftFieldId() { return _thriftId; } public String getFieldName() { return _fieldName; } } // isset id assignments private static final int __FIELD1_ISSET_ID = 0; private byte __isset_bitfield = 0; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.FIELD1, new org.apache.thrift.meta_data.FieldMetaData("field1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ThriftTestObject.class, metaDataMap); } public ThriftTestObject() { } public ThriftTestObject( double field1) { this(); this.field1 = field1; setField1IsSet(true); } /** * Performs a deep copy on other. */ public ThriftTestObject(ThriftTestObject other) { __isset_bitfield = other.__isset_bitfield; this.field1 = other.field1; } public ThriftTestObject deepCopy() { return new ThriftTestObject(this); } @Override public void clear() { setField1IsSet(false); this.field1 = 0.0; } public double getField1() { return this.field1; } public ThriftTestObject setField1(double field1) { this.field1 = field1; setField1IsSet(true); return this; } public void unsetField1() { __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __FIELD1_ISSET_ID); } /** Returns true if field field1 is set (has been assigned a value) and false otherwise */ public boolean isSetField1() { return EncodingUtils.testBit(__isset_bitfield, __FIELD1_ISSET_ID); } public void setField1IsSet(boolean value) { __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FIELD1_ISSET_ID, value); } public void setFieldValue(_Fields field, Object value) { switch (field) { case FIELD1: if (value == null) { unsetField1(); } else { setField1((Double)value); } break; } } public Object getFieldValue(_Fields field) { switch (field) { case FIELD1: return Double.valueOf(getField1()); } throw new IllegalStateException(); } /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); } switch (field) { case FIELD1: return isSetField1(); } throw new IllegalStateException(); } @Override public boolean equals(Object that) { if (that == null) return false; if (that instanceof ThriftTestObject) return this.equals((ThriftTestObject)that); return false; } public boolean equals(ThriftTestObject that) { if (that == null) return false; boolean this_present_field1 = true; boolean that_present_field1 = true; if (this_present_field1 || that_present_field1) { if (!(this_present_field1 && that_present_field1)) return false; if (this.field1 != that.field1) return false; } return true; } @Override public int hashCode() { return 0; } @Override public int compareTo(ThriftTestObject other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; lastComparison = Boolean.valueOf(isSetField1()).compareTo(other.isSetField1()); if (lastComparison != 0) { return lastComparison; } if (isSetField1()) { lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field1, other.field1); if (lastComparison != 0) { return lastComparison; } } return 0; } public _Fields fieldForId(int fieldId) { return _Fields.findByThriftId(fieldId); } public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } @Override public String toString() { StringBuilder sb = new StringBuilder("ThriftTestObject("); boolean first = true; sb.append("field1:"); sb.append(this.field1); first = false; sb.append(")"); return sb.toString(); } public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity } private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { try { write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); } } private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. __isset_bitfield = 0; read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); } } private static class ThriftTestObjectStandardSchemeFactory implements SchemeFactory { public ThriftTestObjectStandardScheme getScheme() { return new ThriftTestObjectStandardScheme(); } } private static class ThriftTestObjectStandardScheme extends StandardScheme { public void read(org.apache.thrift.protocol.TProtocol iprot, ThriftTestObject struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) { schemeField = iprot.readFieldBegin(); if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { break; } switch (schemeField.id) { case 1: // FIELD1 if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) { struct.field1 = iprot.readDouble(); struct.setField1IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } iprot.readFieldEnd(); } iprot.readStructEnd(); // check for required fields of primitive type, which can't be checked in the validate method struct.validate(); } public void write(org.apache.thrift.protocol.TProtocol oprot, ThriftTestObject struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); oprot.writeFieldBegin(FIELD1_FIELD_DESC); oprot.writeDouble(struct.field1); oprot.writeFieldEnd(); oprot.writeFieldStop(); oprot.writeStructEnd(); } } private static class ThriftTestObjectTupleSchemeFactory implements SchemeFactory { public ThriftTestObjectTupleScheme getScheme() { return new ThriftTestObjectTupleScheme(); } } private static class ThriftTestObjectTupleScheme extends TupleScheme { @Override public void write(org.apache.thrift.protocol.TProtocol prot, ThriftTestObject struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetField1()) { optionals.set(0); } oprot.writeBitSet(optionals, 1); if (struct.isSetField1()) { oprot.writeDouble(struct.field1); } } @Override public void read(org.apache.thrift.protocol.TProtocol prot, ThriftTestObject struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { struct.field1 = iprot.readDouble(); struct.setField1IsSet(true); } } } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_field/000077500000000000000000000000001304664171100300645ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_field/BenchDslJson.java000066400000000000000000000040211304664171100332400ustar00rootroot00000000000000package com.jsoniter.demo.object_with_1_field; import com.dslplatform.json.CustomJsonReader; import com.dslplatform.json.JsonWriter; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchDslJson.deser thrpt 5 33989158.545 ± 1354434.977 ops/s (4.17x) BenchDslJson.ser thrpt 5 22636791.114 ± 66490.593 ops/s (2.36x) */ @State(Scope.Thread) public class BenchDslJson { private TestObject testObject; private JsonWriter jsonWriter; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private CustomJsonReader reader; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); jsonWriter = new JsonWriter(); byteArrayOutputStream = new ByteArrayOutputStream(); reader = new CustomJsonReader(testJSON); } @Benchmark public void ser(Blackhole bh) throws IOException { jsonWriter.reset(); byteArrayOutputStream.reset(); // ExternalSerialization.serialize(testObject, jsonWriter, false); jsonWriter.toStream(byteArrayOutputStream); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { reader.reset(); reader.read(); reader.getNextToken(); TestObject obj = new TestObject(); // ExternalSerialization.deserialize(obj, reader); bh.consume(obj); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_field.BenchDslJson", "-i", "5", "-wi", "5", "-f", "1", }); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_field/BenchJackson.java000066400000000000000000000037401304664171100332630ustar00rootroot00000000000000package com.jsoniter.demo.object_with_1_field; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJackson.deser thrpt 5 8159400.294 ± 689022.762 ops/s BenchJackson.ser thrpt 5 9580832.217 ± 469534.662 ops/s */ @State(Scope.Thread) public class BenchJackson { private ObjectMapper objectMapper; private TypeReference typeReference; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private TestObject testObject; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { objectMapper = new ObjectMapper(); objectMapper.registerModule(new AfterburnerModule()); typeReference = new TypeReference() { }; byteArrayOutputStream = new ByteArrayOutputStream(); testJSON = TestObject.createTestJSON(); testObject = TestObject.createTestObject(); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); objectMapper.writeValue(byteArrayOutputStream, testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { bh.consume(objectMapper.readValue(testJSON, typeReference)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_field.BenchJackson", "-i", "5", "-wi", "5", "-f", "1", }); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_field/BenchJsoniter.java000066400000000000000000000050101304664171100334600ustar00rootroot00000000000000package com.jsoniter.demo.object_with_1_field; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.TypeLiteral; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.NotFoundException; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJsoniter.deser thrpt 5 29611012.551 ± 1839988.704 ops/s (3.63x) BenchJsoniter.ser thrpt 5 30237005.400 ± 110653.659 ops/s (3.16x) */ @State(Scope.Thread) public class BenchJsoniter { private TestObject testObject; private JsonStream stream; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private JsonIterator iter; private TypeLiteral typeLiteral; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { JsonStream.setMode(EncodingMode.DYNAMIC_MODE); JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); stream = new JsonStream(null, 512); byteArrayOutputStream = new ByteArrayOutputStream(); iter = new JsonIterator(); typeLiteral = TypeLiteral.create(TestObject.class); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); stream.reset(byteArrayOutputStream); stream.writeVal(testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { iter.reset(testJSON); bh.consume(iter.read(typeLiteral)); } @Test public void test() throws NotFoundException, ClassNotFoundException { JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); JsonIterator.deserialize("{}", TestObject.class); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_field.BenchJsoniter", "-i", "5", "-wi", "5", "-f", "1", }); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_field/BenchThrift.java000066400000000000000000000047551304664171100331420ustar00rootroot00000000000000package com.jsoniter.demo.object_with_1_field; import org.apache.thrift.TDeserializer; import org.apache.thrift.TException; import org.apache.thrift.TSerializer; import org.apache.thrift.protocol.TBinaryProtocol; import org.apache.thrift.protocol.TCompactProtocol; import org.apache.thrift.protocol.TTupleProtocol; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.IOException; /* Tuple Benchmark Mode Cnt Score Error Units BenchThrift.deser thrpt 5 19999891.957 ± 1690769.199 ops/s (2.45x) BenchThrift.ser thrpt 5 7776020.372 ± 133622.260 ops/s (0.81x) Binary Benchmark Mode Cnt Score Error Units BenchThrift.deser thrpt 5 18565469.435 ± 669296.325 ops/s (2.28x) BenchThrift.ser thrpt 5 6213563.710 ± 26744.572 ops/s (0.65x) */ @State(Scope.Thread) public class BenchThrift { private TSerializer serializer; private ThriftTestObject testObject; private TDeserializer deserializer; private byte[] testData; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) throws TException { testObject = new ThriftTestObject(); testObject.field1 = "field1"; serializer = new TSerializer(new TTupleProtocol.Factory()); // serializer = new TSerializer(new TBinaryProtocol.Factory()); deserializer = new TDeserializer(new TTupleProtocol.Factory()); // deserializer = new TDeserializer(new TBinaryProtocol.Factory()); testData = serializer.serialize(testObject); } @Test public void test() throws TException { byte[] output = new TSerializer(new TCompactProtocol.Factory()).serialize(testObject); System.out.println(output.length); } @Benchmark public void ser(Blackhole bh) throws TException { bh.consume(serializer.serialize(testObject)); } @Benchmark public void deser(Blackhole bh) throws TException { ThriftTestObject obj = new ThriftTestObject(); deserializer.deserialize(testObject, testData); bh.consume(obj); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_field.BenchThrift", "-i", "5", "-wi", "5", "-f", "1", }); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_field/TestObject.java000066400000000000000000000010021304664171100327660ustar00rootroot00000000000000package com.jsoniter.demo.object_with_1_field; import com.dslplatform.json.CompiledJson; import com.jsoniter.output.JsonStream; @CompiledJson public class TestObject { public String field1; public static TestObject createTestObject() { TestObject testObject = new TestObject(); testObject.field1 = "field1field2field3field4field5"; return testObject; } public static byte[] createTestJSON() { return JsonStream.serialize(createTestObject()).getBytes(); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_field/TestObject.thrift000066400000000000000000000000561304664171100333550ustar00rootroot00000000000000struct ThriftTestObject { 1: string field1 }ThriftTestObject.java000066400000000000000000000264551304664171100341130ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_fieldpackage com.jsoniter.demo.object_with_1_field; /** * Autogenerated by Thrift Compiler (0.9.1) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated */ import org.apache.thrift.scheme.IScheme; import org.apache.thrift.scheme.SchemeFactory; import org.apache.thrift.scheme.StandardScheme; import org.apache.thrift.scheme.TupleScheme; import org.apache.thrift.protocol.TTupleProtocol; import org.apache.thrift.protocol.TProtocolException; import org.apache.thrift.EncodingUtils; import org.apache.thrift.TException; import org.apache.thrift.async.AsyncMethodCallback; import org.apache.thrift.server.AbstractNonblockingServer.*; import java.util.List; import java.util.ArrayList; import java.util.Map; import java.util.HashMap; import java.util.EnumMap; import java.util.Set; import java.util.HashSet; import java.util.EnumSet; import java.util.Collections; import java.util.BitSet; import java.nio.ByteBuffer; import java.util.Arrays; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class ThriftTestObject implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ThriftTestObject"); private static final org.apache.thrift.protocol.TField FIELD1_FIELD_DESC = new org.apache.thrift.protocol.TField("field1", org.apache.thrift.protocol.TType.STRING, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { schemes.put(StandardScheme.class, new ThriftTestObjectStandardSchemeFactory()); schemes.put(TupleScheme.class, new ThriftTestObjectTupleSchemeFactory()); } public String field1; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { FIELD1((short)1, "field1"); private static final Map byName = new HashMap(); static { for (_Fields field : EnumSet.allOf(_Fields.class)) { byName.put(field.getFieldName(), field); } } /** * Find the _Fields constant that matches fieldId, or null if its not found. */ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 1: // FIELD1 return FIELD1; default: return null; } } /** * Find the _Fields constant that matches fieldId, throwing an exception * if it is not found. */ public static _Fields findByThriftIdOrThrow(int fieldId) { _Fields fields = findByThriftId(fieldId); if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); return fields; } /** * Find the _Fields constant that matches name, or null if its not found. */ public static _Fields findByName(String name) { return byName.get(name); } private final short _thriftId; private final String _fieldName; _Fields(short thriftId, String fieldName) { _thriftId = thriftId; _fieldName = fieldName; } public short getThriftFieldId() { return _thriftId; } public String getFieldName() { return _fieldName; } } // isset id assignments public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.FIELD1, new org.apache.thrift.meta_data.FieldMetaData("field1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ThriftTestObject.class, metaDataMap); } public ThriftTestObject() { } public ThriftTestObject( String field1) { this(); this.field1 = field1; } /** * Performs a deep copy on other. */ public ThriftTestObject(ThriftTestObject other) { if (other.isSetField1()) { this.field1 = other.field1; } } public ThriftTestObject deepCopy() { return new ThriftTestObject(this); } @Override public void clear() { this.field1 = null; } public String getField1() { return this.field1; } public ThriftTestObject setField1(String field1) { this.field1 = field1; return this; } public void unsetField1() { this.field1 = null; } /** Returns true if field field1 is set (has been assigned a value) and false otherwise */ public boolean isSetField1() { return this.field1 != null; } public void setField1IsSet(boolean value) { if (!value) { this.field1 = null; } } public void setFieldValue(_Fields field, Object value) { switch (field) { case FIELD1: if (value == null) { unsetField1(); } else { setField1((String)value); } break; } } public Object getFieldValue(_Fields field) { switch (field) { case FIELD1: return getField1(); } throw new IllegalStateException(); } /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); } switch (field) { case FIELD1: return isSetField1(); } throw new IllegalStateException(); } @Override public boolean equals(Object that) { if (that == null) return false; if (that instanceof ThriftTestObject) return this.equals((ThriftTestObject)that); return false; } public boolean equals(ThriftTestObject that) { if (that == null) return false; boolean this_present_field1 = true && this.isSetField1(); boolean that_present_field1 = true && that.isSetField1(); if (this_present_field1 || that_present_field1) { if (!(this_present_field1 && that_present_field1)) return false; if (!this.field1.equals(that.field1)) return false; } return true; } @Override public int hashCode() { return 0; } @Override public int compareTo(ThriftTestObject other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; lastComparison = Boolean.valueOf(isSetField1()).compareTo(other.isSetField1()); if (lastComparison != 0) { return lastComparison; } if (isSetField1()) { lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field1, other.field1); if (lastComparison != 0) { return lastComparison; } } return 0; } public _Fields fieldForId(int fieldId) { return _Fields.findByThriftId(fieldId); } public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } @Override public String toString() { StringBuilder sb = new StringBuilder("ThriftTestObject("); boolean first = true; sb.append("field1:"); if (this.field1 == null) { sb.append("null"); } else { sb.append(this.field1); } first = false; sb.append(")"); return sb.toString(); } public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity } private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { try { write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); } } private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); } } private static class ThriftTestObjectStandardSchemeFactory implements SchemeFactory { public ThriftTestObjectStandardScheme getScheme() { return new ThriftTestObjectStandardScheme(); } } private static class ThriftTestObjectStandardScheme extends StandardScheme { public void read(org.apache.thrift.protocol.TProtocol iprot, ThriftTestObject struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) { schemeField = iprot.readFieldBegin(); if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { break; } switch (schemeField.id) { case 1: // FIELD1 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { struct.field1 = iprot.readString(); struct.setField1IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } iprot.readFieldEnd(); } iprot.readStructEnd(); // check for required fields of primitive type, which can't be checked in the validate method struct.validate(); } public void write(org.apache.thrift.protocol.TProtocol oprot, ThriftTestObject struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); if (struct.field1 != null) { oprot.writeFieldBegin(FIELD1_FIELD_DESC); oprot.writeString(struct.field1); oprot.writeFieldEnd(); } oprot.writeFieldStop(); oprot.writeStructEnd(); } } private static class ThriftTestObjectTupleSchemeFactory implements SchemeFactory { public ThriftTestObjectTupleScheme getScheme() { return new ThriftTestObjectTupleScheme(); } } private static class ThriftTestObjectTupleScheme extends TupleScheme { @Override public void write(org.apache.thrift.protocol.TProtocol prot, ThriftTestObject struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetField1()) { optionals.set(0); } oprot.writeBitSet(optionals, 1); if (struct.isSetField1()) { oprot.writeString(struct.field1); } } @Override public void read(org.apache.thrift.protocol.TProtocol prot, ThriftTestObject struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { struct.field1 = iprot.readString(); struct.setField1IsSet(true); } } } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_int_field/000077500000000000000000000000001304664171100307365ustar00rootroot00000000000000BenchDslJson.java000066400000000000000000000040261304664171100340400ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_int_fieldpackage com.jsoniter.demo.object_with_1_int_field; import com.dslplatform.json.CustomJsonReader; import com.dslplatform.json.JsonWriter; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchDslJson.deser thrpt 5 36999837.132 ± 765406.929 ops/s (4.46x) BenchDslJson.ser thrpt 5 23126447.202 ± 247889.872 ops/s (2.26x) */ @State(Scope.Thread) public class BenchDslJson { private TestObject testObject; private JsonWriter jsonWriter; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private CustomJsonReader reader; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); jsonWriter = new JsonWriter(); byteArrayOutputStream = new ByteArrayOutputStream(); reader = new CustomJsonReader(testJSON); } @Benchmark public void ser(Blackhole bh) throws IOException { jsonWriter.reset(); byteArrayOutputStream.reset(); // ExternalSerialization.serialize(testObject, jsonWriter, false); jsonWriter.toStream(byteArrayOutputStream); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { reader.reset(); reader.read(); reader.getNextToken(); TestObject obj = new TestObject(); // ExternalSerialization.deserialize(obj, reader); bh.consume(obj); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_int_field.BenchDslJson", "-i", "5", "-wi", "5", "-f", "1", }); } } BenchJackson.java000066400000000000000000000037531304664171100340620ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_int_fieldpackage com.jsoniter.demo.object_with_1_int_field; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJackson.deser thrpt 5 8294194.459 ± 167985.331 ops/s BenchJackson.ser thrpt 5 10240747.474 ± 372948.884 ops/s */ @State(Scope.Thread) public class BenchJackson { private ObjectMapper objectMapper; private TypeReference typeReference; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private TestObject testObject; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { objectMapper = new ObjectMapper(); objectMapper.registerModule(new AfterburnerModule()); typeReference = new TypeReference() { }; byteArrayOutputStream = new ByteArrayOutputStream(); testJSON = TestObject.createTestJSON(); testObject = TestObject.createTestObject(); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); objectMapper.writeValue(byteArrayOutputStream, testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { bh.consume(objectMapper.readValue(testJSON, typeReference)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_int_field.BenchJackson", "-i", "5", "-wi", "5", "-f", "1", }); } } BenchJsoniter.java000066400000000000000000000042171304664171100342630ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_int_fieldpackage com.jsoniter.demo.object_with_1_int_field; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.TypeLiteral; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJsoniter.deser thrpt 5 44446325.748 ± 1126285.176 ops/s (5.36x) BenchJsoniter.ser thrpt 5 33525853.836 ± 1197831.185 ops/s (3.27x) */ @State(Scope.Thread) public class BenchJsoniter { private TestObject testObject; private JsonStream stream; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private JsonIterator iter; private TypeLiteral typeLiteral; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { JsonStream.setMode(EncodingMode.DYNAMIC_MODE); JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); stream = new JsonStream(null, 512); byteArrayOutputStream = new ByteArrayOutputStream(); iter = new JsonIterator(); typeLiteral = TypeLiteral.create(TestObject.class); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); stream.reset(byteArrayOutputStream); stream.writeVal(testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { iter.reset(testJSON); bh.consume(iter.read(typeLiteral)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_int_field.BenchJsoniter", "-i", "5", "-wi", "5", "-f", "1", }); } } BenchThrift.java000066400000000000000000000047661304664171100337370ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_int_fieldpackage com.jsoniter.demo.object_with_1_int_field; import org.apache.thrift.TDeserializer; import org.apache.thrift.TException; import org.apache.thrift.TSerializer; import org.apache.thrift.protocol.TBinaryProtocol; import org.apache.thrift.protocol.TCompactProtocol; import org.apache.thrift.protocol.TTupleProtocol; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.IOException; /* Tuple Benchmark Mode Cnt Score Error Units BenchThrift.deser thrpt 5 75471992.596 ± 2732275.161 ops/s (9.10x) BenchThrift.ser thrpt 5 17130913.598 ± 74007.433 ops/s (1.67x) Binary Benchmark Mode Cnt Score Error Units BenchThrift.deser thrpt 5 56765029.626 ± 2660078.316 ops/s (6.84x) BenchThrift.ser thrpt 5 8511186.468 ± 49663.163 ops/s (0.83x) */ @State(Scope.Thread) public class BenchThrift { private TSerializer serializer; private ThriftTestObject testObject; private TDeserializer deserializer; private byte[] testData; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) throws TException { testObject = new ThriftTestObject(); testObject.setField1(1024); serializer = new TSerializer(new TTupleProtocol.Factory()); // serializer = new TSerializer(new TBinaryProtocol.Factory()); deserializer = new TDeserializer(new TTupleProtocol.Factory()); // deserializer = new TDeserializer(new TBinaryProtocol.Factory()); testData = serializer.serialize(testObject); } @Test public void test() throws TException { byte[] output = new TSerializer(new TCompactProtocol.Factory()).serialize(testObject); System.out.println(output.length); } @Benchmark public void ser(Blackhole bh) throws TException { bh.consume(serializer.serialize(testObject)); } @Benchmark public void deser(Blackhole bh) throws TException { ThriftTestObject obj = new ThriftTestObject(); deserializer.deserialize(testObject, testData); bh.consume(obj); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_1_int_field.BenchThrift", "-i", "5", "-wi", "5", "-f", "1", }); } } TestObject.java000066400000000000000000000007471304664171100336000ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_int_fieldpackage com.jsoniter.demo.object_with_1_int_field; import com.dslplatform.json.CompiledJson; import com.jsoniter.output.JsonStream; @CompiledJson public class TestObject { public int field1; public static TestObject createTestObject() { TestObject testObject = new TestObject(); testObject.field1 = 1024; return testObject; } public static byte[] createTestJSON() { return JsonStream.serialize(createTestObject()).getBytes(); } } TestObject.thrift000066400000000000000000000000531304664171100341450ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_int_fieldstruct ThriftTestObject { 1: i32 field1 }ThriftTestObject.java000066400000000000000000000271101304664171100347520ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_1_int_fieldpackage com.jsoniter.demo.object_with_1_int_field; /** * Autogenerated by Thrift Compiler (0.9.1) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated */ import org.apache.thrift.scheme.IScheme; import org.apache.thrift.scheme.SchemeFactory; import org.apache.thrift.scheme.StandardScheme; import org.apache.thrift.scheme.TupleScheme; import org.apache.thrift.protocol.TTupleProtocol; import org.apache.thrift.protocol.TProtocolException; import org.apache.thrift.EncodingUtils; import org.apache.thrift.TException; import org.apache.thrift.async.AsyncMethodCallback; import org.apache.thrift.server.AbstractNonblockingServer.*; import java.util.List; import java.util.ArrayList; import java.util.Map; import java.util.HashMap; import java.util.EnumMap; import java.util.Set; import java.util.HashSet; import java.util.EnumSet; import java.util.Collections; import java.util.BitSet; import java.nio.ByteBuffer; import java.util.Arrays; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class ThriftTestObject implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ThriftTestObject"); private static final org.apache.thrift.protocol.TField FIELD1_FIELD_DESC = new org.apache.thrift.protocol.TField("field1", org.apache.thrift.protocol.TType.I32, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { schemes.put(StandardScheme.class, new ThriftTestObjectStandardSchemeFactory()); schemes.put(TupleScheme.class, new ThriftTestObjectTupleSchemeFactory()); } public int field1; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { FIELD1((short)1, "field1"); private static final Map byName = new HashMap(); static { for (_Fields field : EnumSet.allOf(_Fields.class)) { byName.put(field.getFieldName(), field); } } /** * Find the _Fields constant that matches fieldId, or null if its not found. */ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 1: // FIELD1 return FIELD1; default: return null; } } /** * Find the _Fields constant that matches fieldId, throwing an exception * if it is not found. */ public static _Fields findByThriftIdOrThrow(int fieldId) { _Fields fields = findByThriftId(fieldId); if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); return fields; } /** * Find the _Fields constant that matches name, or null if its not found. */ public static _Fields findByName(String name) { return byName.get(name); } private final short _thriftId; private final String _fieldName; _Fields(short thriftId, String fieldName) { _thriftId = thriftId; _fieldName = fieldName; } public short getThriftFieldId() { return _thriftId; } public String getFieldName() { return _fieldName; } } // isset id assignments private static final int __FIELD1_ISSET_ID = 0; private byte __isset_bitfield = 0; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.FIELD1, new org.apache.thrift.meta_data.FieldMetaData("field1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ThriftTestObject.class, metaDataMap); } public ThriftTestObject() { } public ThriftTestObject( int field1) { this(); this.field1 = field1; setField1IsSet(true); } /** * Performs a deep copy on other. */ public ThriftTestObject(ThriftTestObject other) { __isset_bitfield = other.__isset_bitfield; this.field1 = other.field1; } public ThriftTestObject deepCopy() { return new ThriftTestObject(this); } @Override public void clear() { setField1IsSet(false); this.field1 = 0; } public int getField1() { return this.field1; } public ThriftTestObject setField1(int field1) { this.field1 = field1; setField1IsSet(true); return this; } public void unsetField1() { __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __FIELD1_ISSET_ID); } /** Returns true if field field1 is set (has been assigned a value) and false otherwise */ public boolean isSetField1() { return EncodingUtils.testBit(__isset_bitfield, __FIELD1_ISSET_ID); } public void setField1IsSet(boolean value) { __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FIELD1_ISSET_ID, value); } public void setFieldValue(_Fields field, Object value) { switch (field) { case FIELD1: if (value == null) { unsetField1(); } else { setField1((Integer)value); } break; } } public Object getFieldValue(_Fields field) { switch (field) { case FIELD1: return Integer.valueOf(getField1()); } throw new IllegalStateException(); } /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); } switch (field) { case FIELD1: return isSetField1(); } throw new IllegalStateException(); } @Override public boolean equals(Object that) { if (that == null) return false; if (that instanceof ThriftTestObject) return this.equals((ThriftTestObject)that); return false; } public boolean equals(ThriftTestObject that) { if (that == null) return false; boolean this_present_field1 = true; boolean that_present_field1 = true; if (this_present_field1 || that_present_field1) { if (!(this_present_field1 && that_present_field1)) return false; if (this.field1 != that.field1) return false; } return true; } @Override public int hashCode() { return 0; } @Override public int compareTo(ThriftTestObject other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; lastComparison = Boolean.valueOf(isSetField1()).compareTo(other.isSetField1()); if (lastComparison != 0) { return lastComparison; } if (isSetField1()) { lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field1, other.field1); if (lastComparison != 0) { return lastComparison; } } return 0; } public _Fields fieldForId(int fieldId) { return _Fields.findByThriftId(fieldId); } public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } @Override public String toString() { StringBuilder sb = new StringBuilder("ThriftTestObject("); boolean first = true; sb.append("field1:"); sb.append(this.field1); first = false; sb.append(")"); return sb.toString(); } public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity } private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { try { write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); } } private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. __isset_bitfield = 0; read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); } } private static class ThriftTestObjectStandardSchemeFactory implements SchemeFactory { public ThriftTestObjectStandardScheme getScheme() { return new ThriftTestObjectStandardScheme(); } } private static class ThriftTestObjectStandardScheme extends StandardScheme { public void read(org.apache.thrift.protocol.TProtocol iprot, ThriftTestObject struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) { schemeField = iprot.readFieldBegin(); if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { break; } switch (schemeField.id) { case 1: // FIELD1 if (schemeField.type == org.apache.thrift.protocol.TType.I32) { struct.field1 = iprot.readI32(); struct.setField1IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } iprot.readFieldEnd(); } iprot.readStructEnd(); // check for required fields of primitive type, which can't be checked in the validate method struct.validate(); } public void write(org.apache.thrift.protocol.TProtocol oprot, ThriftTestObject struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); oprot.writeFieldBegin(FIELD1_FIELD_DESC); oprot.writeI32(struct.field1); oprot.writeFieldEnd(); oprot.writeFieldStop(); oprot.writeStructEnd(); } } private static class ThriftTestObjectTupleSchemeFactory implements SchemeFactory { public ThriftTestObjectTupleScheme getScheme() { return new ThriftTestObjectTupleScheme(); } } private static class ThriftTestObjectTupleScheme extends TupleScheme { @Override public void write(org.apache.thrift.protocol.TProtocol prot, ThriftTestObject struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetField1()) { optionals.set(0); } oprot.writeBitSet(optionals, 1); if (struct.isSetField1()) { oprot.writeI32(struct.field1); } } @Override public void read(org.apache.thrift.protocol.TProtocol prot, ThriftTestObject struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { struct.field1 = iprot.readI32(); struct.setField1IsSet(true); } } } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_5_fields/000077500000000000000000000000001304664171100302535ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_5_fields/BenchDslJson.java000066400000000000000000000041001304664171100334250ustar00rootroot00000000000000package com.jsoniter.demo.object_with_5_fields; import com.dslplatform.json.CustomJsonReader; import com.dslplatform.json.ExternalSerialization; import com.dslplatform.json.JsonWriter; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchDslJson.deser thrpt 5 22328042.432 ± 311925.080 ops/s (3.67x) BenchDslJson.ser thrpt 5 17639416.242 ± 136738.841 ops/s (2.17x) */ @State(Scope.Thread) public class BenchDslJson { private TestObject testObject; private JsonWriter jsonWriter; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private CustomJsonReader reader; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); jsonWriter = new JsonWriter(); byteArrayOutputStream = new ByteArrayOutputStream(); reader = new CustomJsonReader(testJSON); } @Benchmark public void ser(Blackhole bh) throws IOException { jsonWriter.reset(); byteArrayOutputStream.reset(); ExternalSerialization.serialize(testObject, jsonWriter, false); jsonWriter.toStream(byteArrayOutputStream); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { reader.reset(); reader.read(); reader.getNextToken(); TestObject obj = new TestObject(); ExternalSerialization.deserialize(obj, reader); bh.consume(obj); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_5_fields.BenchDslJson", "-i", "5", "-wi", "5", "-f", "1", }); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_5_fields/BenchJackson.java000066400000000000000000000037421304664171100334540ustar00rootroot00000000000000package com.jsoniter.demo.object_with_5_fields; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.module.afterburner.AfterburnerModule; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJackson.deser thrpt 5 3536224.629 ± 22392.435 ops/s BenchJackson.ser thrpt 5 5373951.842 ± 325328.400 ops/s */ @State(Scope.Thread) public class BenchJackson { private ObjectMapper objectMapper; private TypeReference typeReference; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private TestObject testObject; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { objectMapper = new ObjectMapper(); objectMapper.registerModule(new AfterburnerModule()); typeReference = new TypeReference() { }; byteArrayOutputStream = new ByteArrayOutputStream(); testJSON = TestObject.createTestJSON(); testObject = TestObject.createTestObject(); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); objectMapper.writeValue(byteArrayOutputStream, testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { bh.consume(objectMapper.readValue(testJSON, typeReference)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_5_fields.BenchJackson", "-i", "5", "-wi", "5", "-f", "1", }); } } BenchJsoniter.java000066400000000000000000000042511304664171100335760ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_5_fieldspackage com.jsoniter.demo.object_with_5_fields; import com.jsoniter.CodegenAccess; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.TypeLiteral; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.ByteArrayOutputStream; import java.io.IOException; /* Benchmark Mode Cnt Score Error Units BenchJsoniter.deser thrpt 5 7886115.451 ± 335769.969 ops/s (2.23x) BenchJsoniter.ser thrpt 5 13216858.758 ± 611385.896 ops/s (2.46x) */ @State(Scope.Thread) public class BenchJsoniter { private TestObject testObject; private JsonStream stream; private ByteArrayOutputStream byteArrayOutputStream; private byte[] testJSON; private JsonIterator iter; private TypeLiteral typeLiteral; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) { JsonStream.setMode(EncodingMode.DYNAMIC_MODE); JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); testObject = TestObject.createTestObject(); testJSON = TestObject.createTestJSON(); stream = new JsonStream(null, 512); byteArrayOutputStream = new ByteArrayOutputStream(); iter = new JsonIterator(); typeLiteral = TypeLiteral.create(TestObject.class); } @Benchmark public void ser(Blackhole bh) throws IOException { byteArrayOutputStream.reset(); stream.reset(byteArrayOutputStream); stream.writeVal(testObject); bh.consume(byteArrayOutputStream); } @Benchmark public void deser(Blackhole bh) throws IOException { iter.reset(testJSON); bh.consume(iter.read(typeLiteral)); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_5_fields.BenchJsoniter", "-i", "5", "-wi", "5", "-f", "1", }); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_5_fields/BenchThrift.java000066400000000000000000000057071304664171100333270ustar00rootroot00000000000000package com.jsoniter.demo.object_with_5_fields; import org.apache.thrift.TDeserializer; import org.apache.thrift.TException; import org.apache.thrift.TSerializer; import org.apache.thrift.protocol.TBinaryProtocol; import org.apache.thrift.protocol.TCompactProtocol; import org.apache.thrift.protocol.TTupleProtocol; import org.junit.Test; import org.openjdk.jmh.Main; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.infra.BenchmarkParams; import org.openjdk.jmh.infra.Blackhole; import org.openjdk.jmh.runner.RunnerException; import java.io.IOException; /* Tuple Benchmark Mode Cnt Score Error Units BenchThrift.deser thrpt 5 4894731.174 ± 190486.954 ops/s (1.38x) BenchThrift.ser thrpt 5 2537935.619 ± 132875.762 ops/s (0.47x) Compact Benchmark Mode Cnt Score Error Units BenchThrift.deser thrpt 5 4490620.091 ± 118728.895 ops/s BenchThrift.ser thrpt 5 2114218.709 ± 66750.207 ops/s Binary Benchmark Mode Cnt Score Error Units BenchThrift.deser thrpt 5 4463916.092 ± 74085.264 ops/s BenchThrift.ser thrpt 5 1780672.495 ± 21550.292 ops/s */ @State(Scope.Thread) public class BenchThrift { private TSerializer serializer; private ThriftTestObject testObject; private TDeserializer deserializer; private byte[] testData; @Setup(Level.Trial) public void benchSetup(BenchmarkParams params) throws TException { testObject = new ThriftTestObject(); testObject.field1 = "field1"; testObject.field2 = "field2"; testObject.field3 = "field3"; testObject.field4 = "field4"; testObject.field5 = "field5"; // serializer = new TSerializer(new TTupleProtocol.Factory()); serializer = new TSerializer(new TCompactProtocol.Factory()); // serializer = new TSerializer(new TBinaryProtocol.Factory()); // deserializer = new TDeserializer(new TTupleProtocol.Factory()); deserializer = new TDeserializer(new TCompactProtocol.Factory()); // deserializer = new TDeserializer(new TBinaryProtocol.Factory()); testData = serializer.serialize(testObject); } @Test public void test() throws TException { byte[] output = new TSerializer(new TCompactProtocol.Factory()).serialize(testObject); System.out.println(output.length); } @Benchmark public void ser(Blackhole bh) throws TException { bh.consume(serializer.serialize(testObject)); } @Benchmark public void deser(Blackhole bh) throws TException { ThriftTestObject obj = new ThriftTestObject(); deserializer.deserialize(testObject, testData); bh.consume(obj); } public static void main(String[] args) throws IOException, RunnerException { Main.main(new String[]{ "object_with_5_fields.BenchThrift", "-i", "5", "-wi", "5", "-f", "1", }); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_5_fields/TestObect.proto000066400000000000000000000002221304664171100332300ustar00rootroot00000000000000syntax = "proto3"; message TestObject { string field1 = 1; string field2 = 2; string field3 = 3; string field4 = 4; string field5 = 5; }java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_5_fields/TestObject.java000066400000000000000000000013531304664171100331660ustar00rootroot00000000000000package com.jsoniter.demo.object_with_5_fields; import com.dslplatform.json.CompiledJson; import com.jsoniter.output.JsonStream; @CompiledJson public class TestObject { public String field1; public String field2; public String field3; public String field4; public String field5; public static TestObject createTestObject() { TestObject testObject = new TestObject(); testObject.field1 = "field1"; testObject.field2 = "field2"; testObject.field3 = "field3"; testObject.field4 = "field4"; testObject.field5 = "field5"; return testObject; } public static byte[] createTestJSON() { return JsonStream.serialize(createTestObject()).getBytes(); } } java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_5_fields/TestObject.thrift000066400000000000000000000001721304664171100335430ustar00rootroot00000000000000struct ThriftTestObject { 1: string field1 2: string field2 3: string field3 4: string field4 5: string field5 }ThriftTestObject.java000066400000000000000000000561361304664171100343010ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/java/com/jsoniter/demo/object_with_5_fieldspackage com.jsoniter.demo.object_with_5_fields; /** * Autogenerated by Thrift Compiler (0.9.1) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated */ import org.apache.thrift.scheme.IScheme; import org.apache.thrift.scheme.SchemeFactory; import org.apache.thrift.scheme.StandardScheme; import org.apache.thrift.scheme.TupleScheme; import org.apache.thrift.protocol.TTupleProtocol; import org.apache.thrift.protocol.TProtocolException; import org.apache.thrift.EncodingUtils; import org.apache.thrift.TException; import org.apache.thrift.async.AsyncMethodCallback; import org.apache.thrift.server.AbstractNonblockingServer.*; import java.util.List; import java.util.ArrayList; import java.util.Map; import java.util.HashMap; import java.util.EnumMap; import java.util.Set; import java.util.HashSet; import java.util.EnumSet; import java.util.Collections; import java.util.BitSet; import java.nio.ByteBuffer; import java.util.Arrays; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class ThriftTestObject implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ThriftTestObject"); private static final org.apache.thrift.protocol.TField FIELD1_FIELD_DESC = new org.apache.thrift.protocol.TField("field1", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField FIELD2_FIELD_DESC = new org.apache.thrift.protocol.TField("field2", org.apache.thrift.protocol.TType.STRING, (short)2); private static final org.apache.thrift.protocol.TField FIELD3_FIELD_DESC = new org.apache.thrift.protocol.TField("field3", org.apache.thrift.protocol.TType.STRING, (short)3); private static final org.apache.thrift.protocol.TField FIELD4_FIELD_DESC = new org.apache.thrift.protocol.TField("field4", org.apache.thrift.protocol.TType.STRING, (short)4); private static final org.apache.thrift.protocol.TField FIELD5_FIELD_DESC = new org.apache.thrift.protocol.TField("field5", org.apache.thrift.protocol.TType.STRING, (short)5); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { schemes.put(StandardScheme.class, new ThriftTestObjectStandardSchemeFactory()); schemes.put(TupleScheme.class, new ThriftTestObjectTupleSchemeFactory()); } public String field1; // required public String field2; // required public String field3; // required public String field4; // required public String field5; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { FIELD1((short)1, "field1"), FIELD2((short)2, "field2"), FIELD3((short)3, "field3"), FIELD4((short)4, "field4"), FIELD5((short)5, "field5"); private static final Map byName = new HashMap(); static { for (_Fields field : EnumSet.allOf(_Fields.class)) { byName.put(field.getFieldName(), field); } } /** * Find the _Fields constant that matches fieldId, or null if its not found. */ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 1: // FIELD1 return FIELD1; case 2: // FIELD2 return FIELD2; case 3: // FIELD3 return FIELD3; case 4: // FIELD4 return FIELD4; case 5: // FIELD5 return FIELD5; default: return null; } } /** * Find the _Fields constant that matches fieldId, throwing an exception * if it is not found. */ public static _Fields findByThriftIdOrThrow(int fieldId) { _Fields fields = findByThriftId(fieldId); if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); return fields; } /** * Find the _Fields constant that matches name, or null if its not found. */ public static _Fields findByName(String name) { return byName.get(name); } private final short _thriftId; private final String _fieldName; _Fields(short thriftId, String fieldName) { _thriftId = thriftId; _fieldName = fieldName; } public short getThriftFieldId() { return _thriftId; } public String getFieldName() { return _fieldName; } } // isset id assignments public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.FIELD1, new org.apache.thrift.meta_data.FieldMetaData("field1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.FIELD2, new org.apache.thrift.meta_data.FieldMetaData("field2", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.FIELD3, new org.apache.thrift.meta_data.FieldMetaData("field3", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.FIELD4, new org.apache.thrift.meta_data.FieldMetaData("field4", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.FIELD5, new org.apache.thrift.meta_data.FieldMetaData("field5", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ThriftTestObject.class, metaDataMap); } public ThriftTestObject() { } public ThriftTestObject( String field1, String field2, String field3, String field4, String field5) { this(); this.field1 = field1; this.field2 = field2; this.field3 = field3; this.field4 = field4; this.field5 = field5; } /** * Performs a deep copy on other. */ public ThriftTestObject(ThriftTestObject other) { if (other.isSetField1()) { this.field1 = other.field1; } if (other.isSetField2()) { this.field2 = other.field2; } if (other.isSetField3()) { this.field3 = other.field3; } if (other.isSetField4()) { this.field4 = other.field4; } if (other.isSetField5()) { this.field5 = other.field5; } } public ThriftTestObject deepCopy() { return new ThriftTestObject(this); } @Override public void clear() { this.field1 = null; this.field2 = null; this.field3 = null; this.field4 = null; this.field5 = null; } public String getField1() { return this.field1; } public ThriftTestObject setField1(String field1) { this.field1 = field1; return this; } public void unsetField1() { this.field1 = null; } /** Returns true if field field1 is set (has been assigned a value) and false otherwise */ public boolean isSetField1() { return this.field1 != null; } public void setField1IsSet(boolean value) { if (!value) { this.field1 = null; } } public String getField2() { return this.field2; } public ThriftTestObject setField2(String field2) { this.field2 = field2; return this; } public void unsetField2() { this.field2 = null; } /** Returns true if field field2 is set (has been assigned a value) and false otherwise */ public boolean isSetField2() { return this.field2 != null; } public void setField2IsSet(boolean value) { if (!value) { this.field2 = null; } } public String getField3() { return this.field3; } public ThriftTestObject setField3(String field3) { this.field3 = field3; return this; } public void unsetField3() { this.field3 = null; } /** Returns true if field field3 is set (has been assigned a value) and false otherwise */ public boolean isSetField3() { return this.field3 != null; } public void setField3IsSet(boolean value) { if (!value) { this.field3 = null; } } public String getField4() { return this.field4; } public ThriftTestObject setField4(String field4) { this.field4 = field4; return this; } public void unsetField4() { this.field4 = null; } /** Returns true if field field4 is set (has been assigned a value) and false otherwise */ public boolean isSetField4() { return this.field4 != null; } public void setField4IsSet(boolean value) { if (!value) { this.field4 = null; } } public String getField5() { return this.field5; } public ThriftTestObject setField5(String field5) { this.field5 = field5; return this; } public void unsetField5() { this.field5 = null; } /** Returns true if field field5 is set (has been assigned a value) and false otherwise */ public boolean isSetField5() { return this.field5 != null; } public void setField5IsSet(boolean value) { if (!value) { this.field5 = null; } } public void setFieldValue(_Fields field, Object value) { switch (field) { case FIELD1: if (value == null) { unsetField1(); } else { setField1((String)value); } break; case FIELD2: if (value == null) { unsetField2(); } else { setField2((String)value); } break; case FIELD3: if (value == null) { unsetField3(); } else { setField3((String)value); } break; case FIELD4: if (value == null) { unsetField4(); } else { setField4((String)value); } break; case FIELD5: if (value == null) { unsetField5(); } else { setField5((String)value); } break; } } public Object getFieldValue(_Fields field) { switch (field) { case FIELD1: return getField1(); case FIELD2: return getField2(); case FIELD3: return getField3(); case FIELD4: return getField4(); case FIELD5: return getField5(); } throw new IllegalStateException(); } /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); } switch (field) { case FIELD1: return isSetField1(); case FIELD2: return isSetField2(); case FIELD3: return isSetField3(); case FIELD4: return isSetField4(); case FIELD5: return isSetField5(); } throw new IllegalStateException(); } @Override public boolean equals(Object that) { if (that == null) return false; if (that instanceof ThriftTestObject) return this.equals((ThriftTestObject)that); return false; } public boolean equals(ThriftTestObject that) { if (that == null) return false; boolean this_present_field1 = true && this.isSetField1(); boolean that_present_field1 = true && that.isSetField1(); if (this_present_field1 || that_present_field1) { if (!(this_present_field1 && that_present_field1)) return false; if (!this.field1.equals(that.field1)) return false; } boolean this_present_field2 = true && this.isSetField2(); boolean that_present_field2 = true && that.isSetField2(); if (this_present_field2 || that_present_field2) { if (!(this_present_field2 && that_present_field2)) return false; if (!this.field2.equals(that.field2)) return false; } boolean this_present_field3 = true && this.isSetField3(); boolean that_present_field3 = true && that.isSetField3(); if (this_present_field3 || that_present_field3) { if (!(this_present_field3 && that_present_field3)) return false; if (!this.field3.equals(that.field3)) return false; } boolean this_present_field4 = true && this.isSetField4(); boolean that_present_field4 = true && that.isSetField4(); if (this_present_field4 || that_present_field4) { if (!(this_present_field4 && that_present_field4)) return false; if (!this.field4.equals(that.field4)) return false; } boolean this_present_field5 = true && this.isSetField5(); boolean that_present_field5 = true && that.isSetField5(); if (this_present_field5 || that_present_field5) { if (!(this_present_field5 && that_present_field5)) return false; if (!this.field5.equals(that.field5)) return false; } return true; } @Override public int hashCode() { return 0; } @Override public int compareTo(ThriftTestObject other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; lastComparison = Boolean.valueOf(isSetField1()).compareTo(other.isSetField1()); if (lastComparison != 0) { return lastComparison; } if (isSetField1()) { lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field1, other.field1); if (lastComparison != 0) { return lastComparison; } } lastComparison = Boolean.valueOf(isSetField2()).compareTo(other.isSetField2()); if (lastComparison != 0) { return lastComparison; } if (isSetField2()) { lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field2, other.field2); if (lastComparison != 0) { return lastComparison; } } lastComparison = Boolean.valueOf(isSetField3()).compareTo(other.isSetField3()); if (lastComparison != 0) { return lastComparison; } if (isSetField3()) { lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field3, other.field3); if (lastComparison != 0) { return lastComparison; } } lastComparison = Boolean.valueOf(isSetField4()).compareTo(other.isSetField4()); if (lastComparison != 0) { return lastComparison; } if (isSetField4()) { lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field4, other.field4); if (lastComparison != 0) { return lastComparison; } } lastComparison = Boolean.valueOf(isSetField5()).compareTo(other.isSetField5()); if (lastComparison != 0) { return lastComparison; } if (isSetField5()) { lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field5, other.field5); if (lastComparison != 0) { return lastComparison; } } return 0; } public _Fields fieldForId(int fieldId) { return _Fields.findByThriftId(fieldId); } public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } @Override public String toString() { StringBuilder sb = new StringBuilder("ThriftTestObject("); boolean first = true; sb.append("field1:"); if (this.field1 == null) { sb.append("null"); } else { sb.append(this.field1); } first = false; if (!first) sb.append(", "); sb.append("field2:"); if (this.field2 == null) { sb.append("null"); } else { sb.append(this.field2); } first = false; if (!first) sb.append(", "); sb.append("field3:"); if (this.field3 == null) { sb.append("null"); } else { sb.append(this.field3); } first = false; if (!first) sb.append(", "); sb.append("field4:"); if (this.field4 == null) { sb.append("null"); } else { sb.append(this.field4); } first = false; if (!first) sb.append(", "); sb.append("field5:"); if (this.field5 == null) { sb.append("null"); } else { sb.append(this.field5); } first = false; sb.append(")"); return sb.toString(); } public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity } private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { try { write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); } } private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); } } private static class ThriftTestObjectStandardSchemeFactory implements SchemeFactory { public ThriftTestObjectStandardScheme getScheme() { return new ThriftTestObjectStandardScheme(); } } private static class ThriftTestObjectStandardScheme extends StandardScheme { public void read(org.apache.thrift.protocol.TProtocol iprot, ThriftTestObject struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) { schemeField = iprot.readFieldBegin(); if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { break; } switch (schemeField.id) { case 1: // FIELD1 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { struct.field1 = iprot.readString(); struct.setField1IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; case 2: // FIELD2 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { struct.field2 = iprot.readString(); struct.setField2IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; case 3: // FIELD3 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { struct.field3 = iprot.readString(); struct.setField3IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; case 4: // FIELD4 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { struct.field4 = iprot.readString(); struct.setField4IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; case 5: // FIELD5 if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { struct.field5 = iprot.readString(); struct.setField5IsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } iprot.readFieldEnd(); } iprot.readStructEnd(); // check for required fields of primitive type, which can't be checked in the validate method struct.validate(); } public void write(org.apache.thrift.protocol.TProtocol oprot, ThriftTestObject struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); if (struct.field1 != null) { oprot.writeFieldBegin(FIELD1_FIELD_DESC); oprot.writeString(struct.field1); oprot.writeFieldEnd(); } if (struct.field2 != null) { oprot.writeFieldBegin(FIELD2_FIELD_DESC); oprot.writeString(struct.field2); oprot.writeFieldEnd(); } if (struct.field3 != null) { oprot.writeFieldBegin(FIELD3_FIELD_DESC); oprot.writeString(struct.field3); oprot.writeFieldEnd(); } if (struct.field4 != null) { oprot.writeFieldBegin(FIELD4_FIELD_DESC); oprot.writeString(struct.field4); oprot.writeFieldEnd(); } if (struct.field5 != null) { oprot.writeFieldBegin(FIELD5_FIELD_DESC); oprot.writeString(struct.field5); oprot.writeFieldEnd(); } oprot.writeFieldStop(); oprot.writeStructEnd(); } } private static class ThriftTestObjectTupleSchemeFactory implements SchemeFactory { public ThriftTestObjectTupleScheme getScheme() { return new ThriftTestObjectTupleScheme(); } } private static class ThriftTestObjectTupleScheme extends TupleScheme { @Override public void write(org.apache.thrift.protocol.TProtocol prot, ThriftTestObject struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetField1()) { optionals.set(0); } if (struct.isSetField2()) { optionals.set(1); } if (struct.isSetField3()) { optionals.set(2); } if (struct.isSetField4()) { optionals.set(3); } if (struct.isSetField5()) { optionals.set(4); } oprot.writeBitSet(optionals, 5); if (struct.isSetField1()) { oprot.writeString(struct.field1); } if (struct.isSetField2()) { oprot.writeString(struct.field2); } if (struct.isSetField3()) { oprot.writeString(struct.field3); } if (struct.isSetField4()) { oprot.writeString(struct.field4); } if (struct.isSetField5()) { oprot.writeString(struct.field5); } } @Override public void read(org.apache.thrift.protocol.TProtocol prot, ThriftTestObject struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { struct.field1 = iprot.readString(); struct.setField1IsSet(true); } if (incoming.get(1)) { struct.field2 = iprot.readString(); struct.setField2IsSet(true); } if (incoming.get(2)) { struct.field3 = iprot.readString(); struct.setField3IsSet(true); } if (incoming.get(3)) { struct.field4 = iprot.readString(); struct.setField4IsSet(true); } if (incoming.get(4)) { struct.field5 = iprot.readString(); struct.setField5IsSet(true); } } } } java-jsoniter-java-0.9.8/demo/src/test/resources/000077500000000000000000000000001304664171100217325ustar00rootroot00000000000000java-jsoniter-java-0.9.8/demo/src/test/resources/large.json000066400000000000000000000164061304664171100237260ustar00rootroot00000000000000[ { "friends": [ { "id": 0, "name": "Briana Gardner" }, { "id": 1, "name": "Ratliff Byrd" }, { "id": 2, "name": "Marks Bell" } ], "_id": "58659f97246aa21396247468", "index": 0, "guid": "73c7235f-121e-4871-89c2-97c986d2dc6c", "isActive": true, "balance": "$1,246.00", "picture": "http://placehold.it/32x32", "age": 35, "eyeColor": "blue", "name": "Winters Sharp", "gender": "male", "company": "POLARIA", "email": "winterssharp@polaria.com", "phone": "+1 (878) 493-3899", "address": "449 Troutman Street, Rockingham, Puerto Rico, 8953", "about": "Adipisicing eiusmod est amet pariatur velit laborum ea anim enim deserunt. Velit et do duis reprehenderit do Lorem do. Ipsum fugiat id commodo aliqua nulla. Laborum voluptate officia eiusmod dolor laborum labore nisi velit laboris aliqua ut labore adipisicing. Cupidatat tempor aute commodo fugiat nostrud nulla voluptate culpa anim do adipisicing sunt et.\r\n", "registered": "2016-05-13T03:23:52 -08:00", "latitude": -86.869083, "longitude": -42.636359, "tags": [ "pariatur", "dolor", "exercitation", "non", "irure", "sint", "cupidatat" ], "greeting": "Hello, Winters Sharp! You have 7 unread messages.", "favoriteFruit": "banana" }, { "friends": [ { "id": 0, "name": "Patti Bird" }, { "id": 1, "name": "Vinson Golden" }, { "id": 2, "name": "Jessie Gallegos" } ], "_id": "58659f97fda793c4f321294b", "index": 1, "guid": "a1d948c6-a635-40d1-a4cc-75d8c54d90b7", "isActive": true, "balance": "$2,954.82", "picture": "http://placehold.it/32x32", "age": 23, "eyeColor": "green", "name": "Ann Reilly", "gender": "female", "company": "ACCUPHARM", "email": "annreilly@accupharm.com", "phone": "+1 (879) 560-2394", "address": "906 Johnson Avenue, Bagtown, Georgia, 6009", "about": "Commodo dolor in magna occaecat nostrud cillum tempor magna exercitation aliqua. Lorem qui voluptate ut nisi irure laborum. Quis sunt sint eu quis mollit aliquip sunt nostrud deserunt ipsum dolore exercitation esse tempor. Dolore tempor magna fugiat officia culpa qui minim deserunt incididunt duis. Occaecat consectetur commodo et fugiat tempor enim laborum. Amet pariatur occaecat est pariatur ut.\r\n", "registered": "2015-10-06T10:11:21 -08:00", "latitude": 28.347215, "longitude": 119.881559, "tags": [ "excepteur", "sunt", "adipisicing", "excepteur", "qui", "quis", "veniam" ], "greeting": "Hello, Ann Reilly! You have 8 unread messages.", "favoriteFruit": "banana" }, { "friends": [ { "id": 0, "name": "Nichols Wooten" }, { "id": 1, "name": "Catalina Welch" }, { "id": 2, "name": "Stevens Vazquez" } ], "_id": "58659f97a722760b7fb775bd", "index": 2, "guid": "f75031dc-f80f-4144-888d-9fb78c50c218", "isActive": false, "balance": "$3,578.66", "picture": "http://placehold.it/32x32", "age": 32, "eyeColor": "brown", "name": "Doreen Rowland", "gender": "female", "company": "COMTRACT", "email": "doreenrowland@comtract.com", "phone": "+1 (874) 444-2553", "address": "554 Voorhies Avenue, Odessa, Northern Mariana Islands, 4525", "about": "Qui consequat adipisicing ea non aute eu magna veniam nostrud. Aliqua sint id eiusmod sint eu irure occaecat sit Lorem eu. Aliquip nostrud pariatur cupidatat minim pariatur ullamco dolore deserunt fugiat. Culpa laboris anim exercitation quis eu. Ea aute officia irure laborum sint amet quis labore aliqua ex exercitation culpa quis. Proident amet aliquip esse eiusmod sit. Veniam aute ea non cillum eiusmod deserunt magna commodo incididunt elit sint ut.\r\n", "registered": "2014-12-31T05:58:46 -08:00", "latitude": -79.177177, "longitude": -106.982224, "tags": [ "voluptate", "deserunt", "adipisicing", "proident", "exercitation", "proident", "est" ], "greeting": "Hello, Doreen Rowland! You have 4 unread messages.", "favoriteFruit": "apple" }, { "friends": [ { "id": 0, "name": "Bryant Beard" }, { "id": 1, "name": "Josephine Glover" }, { "id": 2, "name": "Socorro Koch" } ], "_id": "58659f9779501e6cd634508b", "index": 3, "guid": "9e52955b-2365-4136-b972-39e72b01b0b6", "isActive": false, "balance": "$1,612.42", "picture": "http://placehold.it/32x32", "age": 30, "eyeColor": "green", "name": "Leach Peck", "gender": "male", "company": "SLOFAST", "email": "leachpeck@slofast.com", "phone": "+1 (889) 464-3474", "address": "659 Carroll Street, Balm, New Jersey, 883", "about": "Nisi officia esse eiusmod exercitation. Fugiat sunt labore Lorem nisi aliqua deserunt fugiat nisi nisi tempor duis. Consequat nostrud anim nisi commodo eiusmod sit ex do occaecat dolor consequat incididunt Lorem duis. Est dolore elit adipisicing laborum nostrud sit labore aliqua officia quis amet ut laboris. Quis anim incididunt exercitation tempor consectetur sunt cupidatat exercitation veniam. Consequat Lorem in eu duis ut incididunt excepteur id qui anim id consectetur commodo.\r\n", "registered": "2014-03-04T02:41:37 -08:00", "latitude": 55.648581, "longitude": 152.684842, "tags": [ "laborum", "ex", "reprehenderit", "eu", "esse", "officia", "Lorem" ], "greeting": "Hello, Leach Peck! You have 2 unread messages.", "favoriteFruit": "banana" }, { "_id": "58659f976f045f9c69c53efb", "index": 4, "guid": "3cbaef3d-25ab-48d0-8807-1974f6aad336", "isActive": true, "balance": "$1,854.63", "picture": "http://placehold.it/32x32", "age": 26, "eyeColor": "brown", "name": "Briggs Larson", "gender": "male", "company": "ZOXY", "email": "briggslarson@zoxy.com", "phone": "+1 (807) 588-3350", "address": "994 Nichols Avenue, Allamuchy, Guam, 3824", "about": "Sunt velit ullamco consequat velit ad nisi in sint qui qui ut eiusmod eu. Et ut aliqua mollit cupidatat et proident tempor do est enim exercitation amet aliquip. Non exercitation proident do duis non ullamco do esse dolore in occaecat. Magna ea labore aliqua laborum ad amet est incididunt et quis cillum nulla. Adipisicing veniam nisi esse officia dolor labore. Proident fugiat consequat ullamco fugiat. Est et adipisicing eiusmod excepteur deserunt pariatur aute commodo dolore occaecat veniam dolore.\r\n", "registered": "2014-07-21T03:28:39 -08:00", "latitude": -59.741245, "longitude": -9.657004, "friends": [ { "id": 0, "name": "Herminia Mcknight" }, { "id": 1, "name": "Leann Harding" }, { "id": 2, "name": "Marisol Sykes" } ], "tags": [ "ea", "velit", "sunt", "fugiat", "do", "Lorem", "nostrud" ], "greeting": "Hello, Briggs Larson! You have 3 unread messages.", "favoriteFruit": "apple" } ]java-jsoniter-java-0.9.8/pom.xml000066400000000000000000000157271304664171100165570ustar00rootroot00000000000000 4.0.0 com.jsoniter 0.9.8 jsoniter json iterator jsoniter (json-iterator) is fast and flexible JSON parser available in Java and Go http://jsoniter.com jar MIT License http://www.opensource.org/licenses/mit-license.php Tao Wen taowen@gmail.com jsoniter http://jsoniter.com scm:git:git://github.com/json-iterator/java.git scm:git:ssh://github.com:json-iterator/java.git http://github.com/json-iterator/java/tree/master UTF-8 junit junit 4.12 test org.javassist javassist 3.21.0-GA true com.fasterxml.jackson.core jackson-annotations 2.8.5 true src/main/resources true *.xml conf/*.properties *.properties test/main/resources true *.json org.apache.maven.plugins maven-compiler-plugin 3.6.0 1.6 1.6 UTF-8 org.apache.maven.plugins maven-source-plugin 2.2.1 attach-sources jar-no-fork org.apache.maven.plugins maven-javadoc-plugin 2.9.1 attach-javadocs jar -Xdoclint:none org.apache.maven.plugins maven-gpg-plugin 1.5 sign-artifacts verify sign org.sonatype.plugins nexus-staging-maven-plugin 1.6.7 true ossrh https://oss.sonatype.org/ true org.apache.maven.plugins maven-release-plugin 2.5.3 true false release deploy org.apache.maven.plugins maven-surefire-plugin 2.19.1 methods 1 false 4 com.jsoniter.suite.StreamingTests com.jsoniter.suite.NonStreamingTests com.jsoniter.suite.NonStreamingTests4Hash com.jsoniter.suite.NonStreamingTests4Strict com.jsoniter.suite.ExtraTests ossrh https://oss.sonatype.org/content/repositories/snapshots java-jsoniter-java-0.9.8/src/000077500000000000000000000000001304664171100160155ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/000077500000000000000000000000001304664171100167415ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/java/000077500000000000000000000000001304664171100176625ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/java/com/000077500000000000000000000000001304664171100204405ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/000077500000000000000000000000001304664171100222755ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/Codegen.java000066400000000000000000000233351304664171100245120ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.*; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.*; class Codegen { // only read/write when generating code with synchronized protection private final static Set generatedClassNames = new HashSet(); static boolean isDoingStaticCodegen = false; static DecodingMode mode = DecodingMode.REFLECTION_MODE; static { String envMode = System.getenv("JSONITER_DECODING_MODE"); if (envMode != null) { mode = DecodingMode.valueOf(envMode); } } public static void setMode(DecodingMode mode) { Codegen.mode = mode; } static Decoder getDecoder(String cacheKey, Type type) { Decoder decoder = JsoniterSpi.getDecoder(cacheKey); if (decoder != null) { return decoder; } return gen(cacheKey, type); } private synchronized static Decoder gen(String cacheKey, Type type) { Decoder decoder = JsoniterSpi.getDecoder(cacheKey); if (decoder != null) { return decoder; } List extensions = JsoniterSpi.getExtensions(); for (Extension extension : extensions) { type = extension.chooseImplementation(type); } type = chooseImpl(type); for (Extension extension : extensions) { decoder = extension.createDecoder(cacheKey, type); if (decoder != null) { JsoniterSpi.addNewDecoder(cacheKey, decoder); return decoder; } } Type[] typeArgs = new Type[0]; Class clazz; if (type instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) type; clazz = (Class) pType.getRawType(); typeArgs = pType.getActualTypeArguments(); } else { clazz = (Class) type; } decoder = CodegenImplNative.NATIVE_DECODERS.get(clazz); if (decoder != null) { return decoder; } if (mode == DecodingMode.REFLECTION_MODE) { decoder = ReflectionDecoderFactory.create(clazz, typeArgs); JsoniterSpi.addNewDecoder(cacheKey, decoder); return decoder; } if (!isDoingStaticCodegen) { try { decoder = (Decoder) Class.forName(cacheKey).newInstance(); JsoniterSpi.addNewDecoder(cacheKey, decoder); return decoder; } catch (Exception e) { if (mode == DecodingMode.STATIC_MODE) { throw new JsonException("static gen should provide the decoder we need, but failed to create the decoder", e); } } } String source = genSource(clazz, typeArgs); source = "public static java.lang.Object decode_(com.jsoniter.JsonIterator iter) throws java.io.IOException { " + source + "}"; if ("true".equals(System.getenv("JSONITER_DEBUG"))) { System.out.println(">>> " + cacheKey); System.out.println(source); } try { generatedClassNames.add(cacheKey); if (isDoingStaticCodegen) { staticGen(cacheKey, source); } else { decoder = DynamicCodegen.gen(cacheKey, source); } JsoniterSpi.addNewDecoder(cacheKey, decoder); return decoder; } catch (Exception e) { String msg = "failed to generate decoder for: " + type + " with " + Arrays.toString(typeArgs) + ", exception: " + e; msg = msg + "\n" + source; throw new JsonException(msg, e); } } public static boolean canStaticAccess(String cacheKey) { return generatedClassNames.contains(cacheKey); } private static Type chooseImpl(Type type) { Type[] typeArgs = new Type[0]; Class clazz; if (type instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) type; clazz = (Class) pType.getRawType(); typeArgs = pType.getActualTypeArguments(); } else { clazz = (Class) type; } Class implClazz = JsoniterSpi.getTypeImplementation(clazz); if (Collection.class.isAssignableFrom(clazz)) { Type compType = Object.class; if (typeArgs.length == 0) { // default to List } else if (typeArgs.length == 1) { compType = typeArgs[0]; } else { throw new IllegalArgumentException( "can not bind to generic collection without argument types, " + "try syntax like TypeLiteral>{}"); } if (clazz == List.class) { clazz = implClazz == null ? ArrayList.class : implClazz; } else if (clazz == Set.class) { clazz = implClazz == null ? HashSet.class : implClazz; } return new ParameterizedTypeImpl(new Type[]{compType}, null, clazz); } if (Map.class.isAssignableFrom(clazz)) { Type keyType = String.class; Type valueType = Object.class; if (typeArgs.length == 0) { // default to Map } else if (typeArgs.length == 2) { keyType = typeArgs[0]; valueType = typeArgs[1]; } else { throw new IllegalArgumentException( "can not bind to generic collection without argument types, " + "try syntax like TypeLiteral>{}"); } if (keyType != String.class) { throw new IllegalArgumentException("map key must be String"); } if (clazz == Map.class) { clazz = implClazz == null ? HashMap.class : implClazz; } return new ParameterizedTypeImpl(new Type[]{keyType, valueType}, null, clazz); } if (implClazz != null) { if (typeArgs.length == 0) { return implClazz; } else { return new ParameterizedTypeImpl(typeArgs, null, implClazz); } } return type; } private static void staticGen(String cacheKey, String source) throws IOException { createDir(cacheKey); String fileName = cacheKey.replace('.', '/') + ".java"; FileOutputStream fileOutputStream = new FileOutputStream(fileName); try { OutputStreamWriter writer = new OutputStreamWriter(fileOutputStream); try { staticGen(cacheKey, writer, source); } finally { writer.close(); } } finally { fileOutputStream.close(); } } private static void staticGen(String cacheKey, OutputStreamWriter writer, String source) throws IOException { String className = cacheKey.substring(cacheKey.lastIndexOf('.') + 1); String packageName = cacheKey.substring(0, cacheKey.lastIndexOf('.')); writer.write("package " + packageName + ";\n"); writer.write("public class " + className + " implements com.jsoniter.spi.Decoder {\n"); writer.write(source); writer.write("public java.lang.Object decode(com.jsoniter.JsonIterator iter) throws java.io.IOException {\n"); writer.write("return decode_(iter);\n"); writer.write("}\n"); writer.write("}\n"); } private static void createDir(String cacheKey) { String[] parts = cacheKey.split("\\."); File parent = new File("."); for (int i = 0; i < parts.length - 1; i++) { String part = parts[i]; File current = new File(parent, part); current.mkdir(); parent = current; } } private static String genSource(Class clazz, Type[] typeArgs) { if (clazz.isArray()) { return CodegenImplArray.genArray(clazz); } if (Map.class.isAssignableFrom(clazz)) { return CodegenImplMap.genMap(clazz, typeArgs); } if (Collection.class.isAssignableFrom(clazz)) { return CodegenImplArray.genCollection(clazz, typeArgs); } if (clazz.isEnum()) { return CodegenImplEnum.genEnum(clazz); } ClassDescriptor desc = JsoniterSpi.getDecodingClassDescriptor(clazz, false); if (shouldUseStrictMode(desc)) { return CodegenImplObjectStrict.genObjectUsingStrict(clazz, desc); } else { return CodegenImplObjectHash.genObjectUsingHash(clazz, desc); } } private static boolean shouldUseStrictMode(ClassDescriptor desc) { if (mode == DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_STRICTLY) { return true; } List allBindings = desc.allDecoderBindings(); for (Binding binding : allBindings) { if (binding.asMissingWhenNotPresent || binding.asExtraWhenPresent || binding.shouldSkip) { // only slice support mandatory tracking return true; } } if (desc.asExtraForUnknownProperties) { // only slice support unknown field tracking return true; } if (allBindings.isEmpty()) { return true; } return false; } public static void staticGenDecoders(TypeLiteral[] typeLiterals) { isDoingStaticCodegen = true; for (TypeLiteral typeLiteral : typeLiterals) { gen(typeLiteral.getDecoderCacheKey(), typeLiteral.getType()); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/CodegenAccess.java000066400000000000000000000136141304664171100256330ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.util.Collection; import java.util.List; // only uesd by generated code to access decoder public class CodegenAccess { public static void addMissingField(List missingFields, long tracker, long mask, String fieldName) { if ((tracker & mask) == 0) { missingFields.add(fieldName); } } public static T reuseCollection(T col) { col.clear(); return col; } public static Object existingObject(JsonIterator iter) { return iter.existingObject; } public static Object resetExistingObject(JsonIterator iter) { Object obj = iter.existingObject; iter.existingObject = null; return obj; } public static void setExistingObject(JsonIterator iter, Object obj) { iter.existingObject = obj; } public final static boolean nextTokenIsComma(final JsonIterator iter) throws IOException { byte c = readByte(iter); if (c == ',') { return true; } return nextTokenIsCommaSlowPath(iter, c); } private static boolean nextTokenIsCommaSlowPath(JsonIterator iter, byte c) throws IOException { switch (c) { case ' ': case '\n': case '\r': case '\t': break; default: return false; } return nextToken(iter) == ','; } public static byte nextToken(JsonIterator iter) throws IOException { return IterImpl.nextToken(iter); } public static final boolean readBoolean(String cacheKey, JsonIterator iter) throws IOException { return ((Decoder.BooleanDecoder) JsoniterSpi.getDecoder(cacheKey)).decodeBoolean(iter); } public static final short readShort(String cacheKey, JsonIterator iter) throws IOException { return ((Decoder.ShortDecoder) JsoniterSpi.getDecoder(cacheKey)).decodeShort(iter); } public static final int readInt(String cacheKey, JsonIterator iter) throws IOException { return ((Decoder.IntDecoder) JsoniterSpi.getDecoder(cacheKey)).decodeInt(iter); } public static final long readLong(String cacheKey, JsonIterator iter) throws IOException { return ((Decoder.LongDecoder) JsoniterSpi.getDecoder(cacheKey)).decodeLong(iter); } public static final float readFloat(String cacheKey, JsonIterator iter) throws IOException { return ((Decoder.FloatDecoder) JsoniterSpi.getDecoder(cacheKey)).decodeFloat(iter); } public static final double readDouble(String cacheKey, JsonIterator iter) throws IOException { return ((Decoder.DoubleDecoder) JsoniterSpi.getDecoder(cacheKey)).decodeDouble(iter); } public static final T read(String cacheKey, JsonIterator iter) throws IOException { return (T) Codegen.getDecoder(cacheKey, null).decode(iter); } public static boolean readArrayStart(JsonIterator iter) throws IOException { byte c = IterImpl.nextToken(iter); if (c == '[') { c = IterImpl.nextToken(iter); if (c == ']') { return false; } iter.unreadByte(); return true; } throw iter.reportError("readArrayStart", "expect [ or n"); } public static boolean readObjectStart(JsonIterator iter) throws IOException { byte c = IterImpl.nextToken(iter); if (c == '{') { c = IterImpl.nextToken(iter); if (c == '}') { return false; } iter.unreadByte(); return true; } throw iter.reportError("readObjectStart", "expect { or n, found: " + (char) c); } public static void reportIncompleteObject(JsonIterator iter) { throw iter.reportError("genObject", "expect }"); } public static void reportIncompleteArray(JsonIterator iter) { throw iter.reportError("genArray", "expect ]"); } public static final String readObjectFieldAsString(JsonIterator iter) throws IOException { String field = iter.readString(); if (IterImpl.nextToken(iter) != ':') { throw iter.reportError("readObjectFieldAsString", "expect :"); } return field; } public static final int readObjectFieldAsHash(JsonIterator iter) throws IOException { return IterImpl.readObjectFieldAsHash(iter); } public static final Slice readObjectFieldAsSlice(JsonIterator iter) throws IOException { return IterImpl.readObjectFieldAsSlice(iter); } public static final Slice readSlice(JsonIterator iter) throws IOException { return IterImpl.readSlice(iter); } final static boolean skipWhitespacesWithoutLoadMore(JsonIterator iter) throws IOException { for (int i = iter.head; i < iter.tail; i++) { byte c = iter.buf[i]; switch (c) { case ' ': case '\n': case '\t': case '\r': continue; } iter.head = i; return false; } return true; } public static void staticGenDecoders(TypeLiteral[] typeLiterals) { Codegen.staticGenDecoders(typeLiterals); } public static int head(JsonIterator iter) { return iter.head; } public static void unreadByte(JsonIterator iter) throws IOException { iter.unreadByte(); } public static byte readByte(JsonIterator iter) throws IOException { return IterImpl.readByte(iter); } public static int calcHash(String str) { return CodegenImplObjectHash.calcHash(str); } public static void skipFixedBytes(JsonIterator iter, int n) throws IOException { IterImpl.skipFixedBytes(iter, n); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/CodegenImplArray.java000066400000000000000000000223451304664171100263330ustar00rootroot00000000000000package com.jsoniter; import java.lang.reflect.Type; import java.util.*; class CodegenImplArray { final static Set WITH_CAPACITY_COLLECTION_CLASSES = new HashSet() {{ add(ArrayList.class); add(HashSet.class); add(Vector.class); }}; public static String genArray(Class clazz) { Class compType = clazz.getComponentType(); if (compType.isArray()) { throw new IllegalArgumentException("nested array not supported: " + clazz.getCanonicalName()); } StringBuilder lines = new StringBuilder(); append(lines, "com.jsoniter.CodegenAccess.resetExistingObject(iter);"); append(lines, "byte nextToken = com.jsoniter.CodegenAccess.readByte(iter);"); append(lines, "if (nextToken != '[') {"); append(lines, "if (nextToken == 'n') {"); append(lines, "com.jsoniter.CodegenAccess.skipFixedBytes(iter, 3);"); append(lines, "com.jsoniter.CodegenAccess.resetExistingObject(iter); return null;"); append(lines, "} else {"); append(lines, "nextToken = com.jsoniter.CodegenAccess.nextToken(iter);"); append(lines, "if (nextToken == 'n') {"); append(lines, "com.jsoniter.CodegenAccess.skipFixedBytes(iter, 3);"); append(lines, "com.jsoniter.CodegenAccess.resetExistingObject(iter); return null;"); append(lines, "}"); append(lines, "}"); append(lines, "}"); append(lines, "nextToken = com.jsoniter.CodegenAccess.nextToken(iter);"); append(lines, "if (nextToken == ']') {"); append(lines, "return new {{comp}}[0];"); append(lines, "}"); append(lines, "com.jsoniter.CodegenAccess.unreadByte(iter);"); append(lines, "{{comp}} a1 = {{op}};"); append(lines, "if (!com.jsoniter.CodegenAccess.nextTokenIsComma(iter)) {"); append(lines, "return new {{comp}}[]{ a1 };"); append(lines, "}"); append(lines, "{{comp}} a2 = {{op}};"); append(lines, "if (!com.jsoniter.CodegenAccess.nextTokenIsComma(iter)) {"); append(lines, "return new {{comp}}[]{ a1, a2 };"); append(lines, "}"); append(lines, "{{comp}} a3 = {{op}};"); append(lines, "if (!com.jsoniter.CodegenAccess.nextTokenIsComma(iter)) {"); append(lines, "return new {{comp}}[]{ a1, a2, a3 };"); append(lines, "}"); append(lines, "{{comp}} a4 = ({{comp}}) {{op}};"); append(lines, "if (!com.jsoniter.CodegenAccess.nextTokenIsComma(iter)) {"); append(lines, "return new {{comp}}[]{ a1, a2, a3, a4 };"); append(lines, "}"); append(lines, "{{comp}} a5 = ({{comp}}) {{op}};"); append(lines, "{{comp}}[] arr = new {{comp}}[10];"); append(lines, "arr[0] = a1;"); append(lines, "arr[1] = a2;"); append(lines, "arr[2] = a3;"); append(lines, "arr[3] = a4;"); append(lines, "arr[4] = a5;"); append(lines, "int i = 5;"); append(lines, "while (com.jsoniter.CodegenAccess.nextTokenIsComma(iter)) {"); append(lines, "if (i == arr.length) {"); append(lines, "{{comp}}[] newArr = new {{comp}}[arr.length * 2];"); append(lines, "System.arraycopy(arr, 0, newArr, 0, arr.length);"); append(lines, "arr = newArr;"); append(lines, "}"); append(lines, "arr[i++] = {{op}};"); append(lines, "}"); // append(lines, "if (c != ']') { com.jsoniter.CodegenAccess.reportIncompleteArray(iter); }"); append(lines, "{{comp}}[] result = new {{comp}}[i];"); append(lines, "System.arraycopy(arr, 0, result, 0, i);"); append(lines, "return result;"); return lines.toString().replace( "{{comp}}", compType.getCanonicalName()).replace( "{{op}}", CodegenImplNative.genReadOp(compType)); } public static String genCollection(Class clazz, Type[] typeArgs) { if (WITH_CAPACITY_COLLECTION_CLASSES.contains(clazz)) { return CodegenImplArray.genCollectionWithCapacity(clazz, typeArgs[0]); } else { return CodegenImplArray.genCollectionWithoutCapacity(clazz, typeArgs[0]); } } private static String genCollectionWithCapacity(Class clazz, Type compType) { StringBuilder lines = new StringBuilder(); append(lines, "{{clazz}} col = ({{clazz}})com.jsoniter.CodegenAccess.resetExistingObject(iter);"); append(lines, "if (iter.readNull()) { com.jsoniter.CodegenAccess.resetExistingObject(iter); return null; }"); append(lines, "if (!com.jsoniter.CodegenAccess.readArrayStart(iter)) {"); append(lines, "return col == null ? new {{clazz}}(0): ({{clazz}})com.jsoniter.CodegenAccess.reuseCollection(col);"); append(lines, "}"); append(lines, "Object a1 = {{op}};"); append(lines, "if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') {"); append(lines, "{{clazz}} obj = col == null ? new {{clazz}}(1): ({{clazz}})com.jsoniter.CodegenAccess.reuseCollection(col);"); append(lines, "obj.add(a1);"); append(lines, "return obj;"); append(lines, "}"); append(lines, "Object a2 = {{op}};"); append(lines, "if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') {"); append(lines, "{{clazz}} obj = col == null ? new {{clazz}}(2): ({{clazz}})com.jsoniter.CodegenAccess.reuseCollection(col);"); append(lines, "obj.add(a1);"); append(lines, "obj.add(a2);"); append(lines, "return obj;"); append(lines, "}"); append(lines, "Object a3 = {{op}};"); append(lines, "if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') {"); append(lines, "{{clazz}} obj = col == null ? new {{clazz}}(3): ({{clazz}})com.jsoniter.CodegenAccess.reuseCollection(col);"); append(lines, "obj.add(a1);"); append(lines, "obj.add(a2);"); append(lines, "obj.add(a3);"); append(lines, "return obj;"); append(lines, "}"); append(lines, "Object a4 = {{op}};"); append(lines, "{{clazz}} obj = col == null ? new {{clazz}}(8): ({{clazz}})com.jsoniter.CodegenAccess.reuseCollection(col);"); append(lines, "obj.add(a1);"); append(lines, "obj.add(a2);"); append(lines, "obj.add(a3);"); append(lines, "obj.add(a4);"); append(lines, "while (com.jsoniter.CodegenAccess.nextToken(iter) == ',') {"); append(lines, "obj.add({{op}});"); append(lines, "}"); append(lines, "return obj;"); return lines.toString().replace( "{{clazz}}", clazz.getName()).replace( "{{op}}", CodegenImplNative.genReadOp(compType)); } private static String genCollectionWithoutCapacity(Class clazz, Type compType) { StringBuilder lines = new StringBuilder(); append(lines, "if (iter.readNull()) { com.jsoniter.CodegenAccess.resetExistingObject(iter); return null; }"); append(lines, "{{clazz}} col = ({{clazz}})com.jsoniter.CodegenAccess.resetExistingObject(iter);"); append(lines, "if (!com.jsoniter.CodegenAccess.readArrayStart(iter)) {"); append(lines, "return col == null ? new {{clazz}}(): ({{clazz}})com.jsoniter.CodegenAccess.reuseCollection(col);"); append(lines, "}"); append(lines, "Object a1 = {{op}};"); append(lines, "if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') {"); append(lines, "{{clazz}} obj = col == null ? new {{clazz}}(): ({{clazz}})com.jsoniter.CodegenAccess.reuseCollection(col);"); append(lines, "obj.add(a1);"); append(lines, "return obj;"); append(lines, "}"); append(lines, "Object a2 = {{op}};"); append(lines, "if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') {"); append(lines, "{{clazz}} obj = col == null ? new {{clazz}}(): ({{clazz}})com.jsoniter.CodegenAccess.reuseCollection(col);"); append(lines, "obj.add(a1);"); append(lines, "obj.add(a2);"); append(lines, "return obj;"); append(lines, "}"); append(lines, "Object a3 = {{op}};"); append(lines, "if (com.jsoniter.CodegenAccess.nextToken(iter) != ',') {"); append(lines, "{{clazz}} obj = col == null ? new {{clazz}}(): ({{clazz}})com.jsoniter.CodegenAccess.reuseCollection(col);"); append(lines, "obj.add(a1);"); append(lines, "obj.add(a2);"); append(lines, "obj.add(a3);"); append(lines, "return obj;"); append(lines, "}"); append(lines, "Object a4 = {{op}};"); append(lines, "{{clazz}} obj = col == null ? new {{clazz}}(): ({{clazz}})com.jsoniter.CodegenAccess.reuseCollection(col);"); append(lines, "obj.add(a1);"); append(lines, "obj.add(a2);"); append(lines, "obj.add(a3);"); append(lines, "obj.add(a4);"); append(lines, "while (com.jsoniter.CodegenAccess.nextToken(iter) == ',') {"); append(lines, "obj.add({{op}});"); append(lines, "}"); // append(lines, "if (c != ']') { com.jsoniter.CodegenAccess.reportIncompleteArray(iter); }"); append(lines, "return obj;"); return lines.toString().replace( "{{clazz}}", clazz.getName()).replace( "{{op}}", CodegenImplNative.genReadOp(compType)); } private static void append(StringBuilder lines, String str) { lines.append(str); lines.append("\n"); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/CodegenImplEnum.java000066400000000000000000000101431304664171100261520ustar00rootroot00000000000000package com.jsoniter; import java.util.*; class CodegenImplEnum { public static String genEnum(Class clazz) { StringBuilder lines = new StringBuilder(); append(lines, "if (iter.readNull()) { return null; }"); append(lines, "com.jsoniter.Slice field = com.jsoniter.CodegenAccess.readSlice(iter);"); append(lines, "switch (field.len()) {"); append(lines, renderTriTree(buildTriTree(Arrays.asList(clazz.getEnumConstants())))); append(lines, "}"); // end of switch append(lines, String.format("throw iter.reportError(\"decode enum\", field + \" is not valid enum for %s\");", clazz.getName())); return lines.toString(); } private static Map buildTriTree(List allConsts) { Map trieTree = new HashMap(); for (Object e : allConsts) { byte[] fromNameBytes = e.toString().getBytes(); Map current = (Map) trieTree.get(fromNameBytes.length); if (current == null) { current = new HashMap(); trieTree.put(fromNameBytes.length, current); } for (int i = 0; i < fromNameBytes.length - 1; i++) { byte b = fromNameBytes[i]; Map next = (Map) current.get(b); if (next == null) { next = new HashMap(); current.put(b, next); } current = next; } current.put(fromNameBytes[fromNameBytes.length - 1], e); } return trieTree; } private static String renderTriTree(Map trieTree) { StringBuilder switchBody = new StringBuilder(); for (Map.Entry entry : trieTree.entrySet()) { Integer len = entry.getKey(); append(switchBody, "case " + len + ": "); Map current = (Map) entry.getValue(); addFieldDispatch(switchBody, len, 0, current, new ArrayList()); append(switchBody, "break;"); } return switchBody.toString(); } private static void addFieldDispatch( StringBuilder lines, int len, int i, Map current, List bytesToCompare) { for (Map.Entry entry : current.entrySet()) { Byte b = entry.getKey(); if (i == len - 1) { append(lines, "if ("); for (int j = 0; j < bytesToCompare.size(); j++) { Byte a = bytesToCompare.get(j); append(lines, String.format("field.at(%d)==%s && ", i - bytesToCompare.size() + j, a)); } append(lines, String.format("field.at(%d)==%s", i, b)); append(lines, ") {"); Object e = entry.getValue(); append(lines, String.format("return %s.%s;", e.getClass().getName(), e.toString())); append(lines, "}"); continue; } Map next = (Map) entry.getValue(); if (next.size() == 1) { ArrayList nextBytesToCompare = new ArrayList(bytesToCompare); nextBytesToCompare.add(b); addFieldDispatch(lines, len, i + 1, next, nextBytesToCompare); continue; } append(lines, "if ("); for (int j = 0; j < bytesToCompare.size(); j++) { Byte a = bytesToCompare.get(j); append(lines, String.format("field.at(%d)==%s && ", i - bytesToCompare.size() + j, a)); } append(lines, String.format("field.at(%d)==%s", i, b)); append(lines, ") {"); addFieldDispatch(lines, len, i + 1, next, new ArrayList()); append(lines, "}"); } } private static void append(StringBuilder lines, String str) { lines.append(str); lines.append("\n"); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/CodegenImplMap.java000066400000000000000000000023301304664171100257620ustar00rootroot00000000000000package com.jsoniter; import java.lang.reflect.Type; import java.util.HashMap; import java.util.Map; class CodegenImplMap { public static String genMap(Class clazz, Type[] typeArgs) { Type valueType = typeArgs[1]; StringBuilder lines = new StringBuilder(); append(lines, "{{clazz}} map = ({{clazz}})com.jsoniter.CodegenAccess.resetExistingObject(iter);"); append(lines, "if (iter.readNull()) { return null; }"); append(lines, "if (map == null) { map = new {{clazz}}(); }"); append(lines, "if (!com.jsoniter.CodegenAccess.readObjectStart(iter)) {"); append(lines, "return map;"); append(lines, "}"); append(lines, "do {"); append(lines, "String field = com.jsoniter.CodegenAccess.readObjectFieldAsString(iter);"); append(lines, "map.put(field, {{op}});"); append(lines, "} while (com.jsoniter.CodegenAccess.nextToken(iter) == ',');"); append(lines, "return map;"); return lines.toString().replace("{{clazz}}", clazz.getName()).replace("{{op}}", CodegenImplNative.genReadOp(valueType)); } private static void append(StringBuilder lines, String str) { lines.append(str); lines.append("\n"); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/CodegenImplNative.java000066400000000000000000000255301304664171100265020ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.any.Any; import com.jsoniter.spi.*; import java.io.IOException; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.math.BigDecimal; import java.math.BigInteger; import java.util.HashMap; import java.util.Map; class CodegenImplNative { final static Map NATIVE_READS = new HashMap() {{ put("float", "iter.readFloat()"); put("double", "iter.readDouble()"); put("boolean", "iter.readBoolean()"); put("byte", "iter.readShort()"); put("short", "iter.readShort()"); put("int", "iter.readInt()"); put("char", "iter.readInt()"); put("long", "iter.readLong()"); put(Float.class.getName(), "java.lang.Float.valueOf(iter.readFloat())"); put(Double.class.getName(), "java.lang.Double.valueOf(iter.readDouble())"); put(Boolean.class.getName(), "java.lang.Boolean.valueOf(iter.readBoolean())"); put(Byte.class.getName(), "java.lang.Byte.valueOf((byte)iter.readShort())"); put(Character.class.getName(), "java.lang.Character.valueOf((char)iter.readShort())"); put(Short.class.getName(), "java.lang.Short.valueOf(iter.readShort())"); put(Integer.class.getName(), "java.lang.Integer.valueOf(iter.readInt())"); put(Long.class.getName(), "java.lang.Long.valueOf(iter.readLong())"); put(BigDecimal.class.getName(), "iter.readBigDecimal()"); put(BigInteger.class.getName(), "iter.readBigInteger()"); put(String.class.getName(), "iter.readString()"); put(Object.class.getName(), "iter.read()"); put(Any.class.getName(), "iter.readAny()"); }}; final static Map NATIVE_DECODERS = new HashMap() {{ put(float.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readFloat(); } }); put(Float.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readFloat(); } }); put(double.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readDouble(); } }); put(Double.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readDouble(); } }); put(boolean.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readBoolean(); } }); put(Boolean.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readBoolean(); } }); put(byte.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readShort(); } }); put(Byte.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readShort(); } }); put(short.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readShort(); } }); put(Short.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readShort(); } }); put(int.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readInt(); } }); put(Integer.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readInt(); } }); put(char.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readInt(); } }); put(Character.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readInt(); } }); put(long.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readLong(); } }); put(Long.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readLong(); } }); put(BigDecimal.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readBigDecimal(); } }); put(BigInteger.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readBigInteger(); } }); put(String.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readString(); } }); put(Object.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.read(); } }); put(Any.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { return iter.readAny(); } }); }}; public static String genReadOp(Type type) { String cacheKey = TypeLiteral.create(type).getDecoderCacheKey(); return String.format("(%s)%s", getTypeName(type), genReadOp(cacheKey, type)); } public static String getTypeName(Type fieldType) { if (fieldType instanceof Class) { Class clazz = (Class) fieldType; return clazz.getCanonicalName(); } else if (fieldType instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) fieldType; Class clazz = (Class) pType.getRawType(); return clazz.getCanonicalName(); } else { throw new JsonException("unsupported type: " + fieldType); } } static String genField(Binding field) { String fieldCacheKey = field.decoderCacheKey(); Type fieldType = field.valueType; return String.format("(%s)%s", getTypeName(fieldType), genReadOp(fieldCacheKey, fieldType)); } private static String genReadOp(String cacheKey, Type valueType) { // the field decoder might be registered directly Decoder decoder = JsoniterSpi.getDecoder(cacheKey); if (decoder == null) { // if cache key is for field, and there is no field decoder specified // update cache key for normal type cacheKey = TypeLiteral.create(valueType).getDecoderCacheKey(); decoder = JsoniterSpi.getDecoder(cacheKey); if (decoder == null) { if (valueType instanceof Class) { Class clazz = (Class) valueType; String nativeRead = NATIVE_READS.get(clazz.getCanonicalName()); if (nativeRead != null) { return nativeRead; } } Codegen.getDecoder(cacheKey, valueType); if (Codegen.canStaticAccess(cacheKey)) { return String.format("%s.decode_(iter)", cacheKey); } else { // can not use static "decode_" method to access, go through codegen cache return String.format("com.jsoniter.CodegenAccess.read(\"%s\", iter)", cacheKey); } } } if (valueType == boolean.class) { if (!(decoder instanceof Decoder.BooleanDecoder)) { throw new JsonException("decoder for " + cacheKey + "must implement Decoder.BooleanDecoder"); } return String.format("com.jsoniter.CodegenAccess.readBoolean(\"%s\", iter)", cacheKey); } if (valueType == byte.class) { if (!(decoder instanceof Decoder.ShortDecoder)) { throw new JsonException("decoder for " + cacheKey + "must implement Decoder.ShortDecoder"); } return String.format("com.jsoniter.CodegenAccess.readShort(\"%s\", iter)", cacheKey); } if (valueType == short.class) { if (!(decoder instanceof Decoder.ShortDecoder)) { throw new JsonException("decoder for " + cacheKey + "must implement Decoder.ShortDecoder"); } return String.format("com.jsoniter.CodegenAccess.readShort(\"%s\", iter)", cacheKey); } if (valueType == char.class) { if (!(decoder instanceof Decoder.IntDecoder)) { throw new JsonException("decoder for " + cacheKey + "must implement Decoder.IntDecoder"); } return String.format("com.jsoniter.CodegenAccess.readInt(\"%s\", iter)", cacheKey); } if (valueType == int.class) { if (!(decoder instanceof Decoder.IntDecoder)) { throw new JsonException("decoder for " + cacheKey + "must implement Decoder.IntDecoder"); } return String.format("com.jsoniter.CodegenAccess.readInt(\"%s\", iter)", cacheKey); } if (valueType == long.class) { if (!(decoder instanceof Decoder.LongDecoder)) { throw new JsonException("decoder for " + cacheKey + "must implement Decoder.LongDecoder"); } return String.format("com.jsoniter.CodegenAccess.readLong(\"%s\", iter)", cacheKey); } if (valueType == float.class) { if (!(decoder instanceof Decoder.FloatDecoder)) { throw new JsonException("decoder for " + cacheKey + "must implement Decoder.FloatDecoder"); } return String.format("com.jsoniter.CodegenAccess.readFloat(\"%s\", iter)", cacheKey); } if (valueType == double.class) { if (!(decoder instanceof Decoder.DoubleDecoder)) { throw new JsonException("decoder for " + cacheKey + "must implement Decoder.DoubleDecoder"); } return String.format("com.jsoniter.CodegenAccess.readDouble(\"%s\", iter)", cacheKey); } return String.format("com.jsoniter.CodegenAccess.read(\"%s\", iter)", cacheKey); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/CodegenImplObjectHash.java000066400000000000000000000167641304664171100272770ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.*; import java.util.*; public class CodegenImplObjectHash { // the implementation is from dsljson, it is the fastest although has the risk not matching field strictly public static String genObjectUsingHash(Class clazz, ClassDescriptor desc) { StringBuilder lines = new StringBuilder(); // === if null, return null append(lines, "java.lang.Object existingObj = com.jsoniter.CodegenAccess.resetExistingObject(iter);"); append(lines, "byte nextToken = com.jsoniter.CodegenAccess.readByte(iter);"); append(lines, "if (nextToken != '{') {"); append(lines, "if (nextToken == 'n') {"); append(lines, "com.jsoniter.CodegenAccess.skipFixedBytes(iter, 3);"); append(lines, "return null;"); append(lines, "} else {"); append(lines, "nextToken = com.jsoniter.CodegenAccess.nextToken(iter);"); append(lines, "if (nextToken == 'n') {"); append(lines, "com.jsoniter.CodegenAccess.skipFixedBytes(iter, 3);"); append(lines, "return null;"); append(lines, "}"); append(lines, "} // end of if null"); append(lines, "} // end of if {"); // === if empty, return empty // ctor requires binding for (Binding parameter : desc.ctor.parameters) { appendVarDef(lines, parameter); } append(lines, "nextToken = com.jsoniter.CodegenAccess.readByte(iter);"); append(lines, "if (nextToken != '\"') {"); append(lines, "if (nextToken == '}') {"); append(lines, "return {{newInst}};"); append(lines, "} else {"); append(lines, "nextToken = com.jsoniter.CodegenAccess.nextToken(iter);"); append(lines, "if (nextToken == '}') {"); append(lines, "return {{newInst}};"); append(lines, "} else {"); append(lines, "com.jsoniter.CodegenAccess.unreadByte(iter);"); append(lines, "}"); append(lines, "} // end of if end"); append(lines, "} else { com.jsoniter.CodegenAccess.unreadByte(iter); }// end of if not quote"); for (Binding field : desc.fields) { appendVarDef(lines, field); } for (Binding setter : desc.setters) { appendVarDef(lines, setter); } for (WrapperDescriptor setter : desc.wrappers) { for (Binding param : setter.parameters) { appendVarDef(lines, param); } } // === bind fields HashSet knownHashes = new HashSet(); HashMap bindings = new HashMap(); for (Binding binding : desc.allDecoderBindings()) { for (String fromName : binding.fromNames) { bindings.put(fromName, binding); } } ArrayList fromNames = new ArrayList(bindings.keySet()); Collections.sort(fromNames, new Comparator() { @Override public int compare(String o1, String o2) { int x = calcHash(o1); int y = calcHash(o2); return (x < y) ? -1 : ((x == y) ? 0 : 1); } }); // === bind more fields append(lines, "do {"); append(lines, "switch (com.jsoniter.CodegenAccess.readObjectFieldAsHash(iter)) {"); for (String fromName : fromNames) { int intHash = calcHash(fromName); if (intHash == 0) { // hash collision, 0 can not be used as sentinel return CodegenImplObjectStrict.genObjectUsingStrict(clazz, desc); } if (knownHashes.contains(intHash)) { // hash collision with other field can not be used as sentinel return CodegenImplObjectStrict.genObjectUsingStrict(clazz, desc); } knownHashes.add(intHash); append(lines, "case " + intHash + ": "); appendBindingSet(lines, desc, bindings.get(fromName)); append(lines, "continue;"); } append(lines, "}"); append(lines, "iter.skip();"); append(lines, "} while (com.jsoniter.CodegenAccess.nextTokenIsComma(iter));"); append(lines, CodegenImplNative.getTypeName(clazz) + " obj = {{newInst}};"); for (Binding field : desc.fields) { append(lines, String.format("obj.%s = _%s_;", field.field.getName(), field.name)); } for (Binding setter : desc.setters) { append(lines, String.format("obj.%s(_%s_);", setter.method.getName(), setter.name)); } appendWrappers(desc.wrappers, lines); append(lines, "return obj;"); return lines.toString() .replace("{{clazz}}", clazz.getCanonicalName()) .replace("{{newInst}}", genNewInstCode(clazz, desc.ctor)); } public static int calcHash(String fromName) { long hash = 0x811c9dc5; for (byte b : fromName.getBytes()) { hash ^= b; hash *= 0x1000193; } return (int) hash; } private static void appendBindingSet(StringBuilder lines, ClassDescriptor desc, Binding binding) { append(lines, String.format("_%s_ = %s;", binding.name, CodegenImplNative.genField(binding))); } static void appendWrappers(List wrappers, StringBuilder lines) { for (WrapperDescriptor wrapper : wrappers) { lines.append("obj."); lines.append(wrapper.method.getName()); appendInvocation(lines, wrapper.parameters); lines.append(";\n"); } } static void appendVarDef(StringBuilder lines, Binding parameter) { String typeName = CodegenImplNative.getTypeName(parameter.valueType); append(lines, String.format("%s _%s_ = %s;", typeName, parameter.name, CodegenImplObjectStrict.DEFAULT_VALUES.get(typeName))); } static String genNewInstCode(Class clazz, ConstructorDescriptor ctor) { StringBuilder code = new StringBuilder(); if (ctor.parameters.isEmpty()) { // nothing to bind, safe to reuse existing object code.append("(existingObj == null ? "); } if (ctor.objectFactory != null) { code.append(String.format("(%s)com.jsoniter.spi.JsoniterSpi.create(%s.class)", clazz.getCanonicalName(), clazz.getCanonicalName())); } else { if (ctor.staticMethodName == null) { code.append(String.format("new %s", clazz.getCanonicalName())); } else { code.append(String.format("%s.%s", clazz.getCanonicalName(), ctor.staticMethodName)); } } List params = ctor.parameters; if (ctor.objectFactory == null) { appendInvocation(code, params); } if (ctor.parameters.isEmpty()) { // nothing to bind, safe to reuse existing obj code.append(String.format(" : (%s)existingObj)", clazz.getCanonicalName())); } return code.toString(); } private static void appendInvocation(StringBuilder code, List params) { code.append("("); boolean isFirst = true; for (Binding ctorParam : params) { if (isFirst) { isFirst = false; } else { code.append(","); } code.append(String.format("_%s_", ctorParam.name)); } code.append(")"); } static void append(StringBuilder lines, String str) { lines.append(str); lines.append("\n"); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/CodegenImplObjectStrict.java000066400000000000000000000361251304664171100276550ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.*; import java.util.*; import static com.jsoniter.CodegenImplObjectHash.appendVarDef; import static com.jsoniter.CodegenImplObjectHash.appendWrappers; class CodegenImplObjectStrict { final static Map DEFAULT_VALUES = new HashMap() {{ put("float", "0.0f"); put("double", "0.0d"); put("boolean", "false"); put("byte", "0"); put("short", "0"); put("int", "0"); put("char", "0"); put("long", "0"); }}; public static String genObjectUsingStrict(Class clazz, ClassDescriptor desc) { List allBindings = desc.allDecoderBindings(); int lastRequiredIdx = assignMaskForRequiredProperties(allBindings); boolean hasRequiredBinding = lastRequiredIdx > 0; long expectedTracker = Long.MAX_VALUE >> (63 - lastRequiredIdx); Map trieTree = buildTriTree(allBindings); StringBuilder lines = new StringBuilder(); /* * only strict mode binding support missing/extra properties tracking * 1. if null, return null * 2. if empty, return empty * 3. bind first field * 4. while (nextToken() == ',') { bind more fields } * 5. handle missing/extra properties * 6. create obj with args (if ctor binding) * 7. assign fields to obj (if ctor binding) * 8. apply multi param wrappers */ // === if null, return null append(lines, "java.lang.Object existingObj = com.jsoniter.CodegenAccess.resetExistingObject(iter);"); append(lines, "if (iter.readNull()) { return null; }"); // === if input is empty obj, return empty obj if (hasRequiredBinding) { append(lines, "long tracker = 0;"); } if (desc.ctor.parameters.isEmpty()) { append(lines, "{{clazz}} obj = {{newInst}};"); append(lines, "if (!com.jsoniter.CodegenAccess.readObjectStart(iter)) {"); if (hasRequiredBinding) { appendMissingRequiredProperties(lines, desc); } append(lines, "return obj;"); append(lines, "}"); // because obj can be created without binding // so that fields and setters can be bind to obj directly without temp var } else { for (Binding parameter : desc.ctor.parameters) { appendVarDef(lines, parameter); } append(lines, "if (!com.jsoniter.CodegenAccess.readObjectStart(iter)) {"); if (hasRequiredBinding) { appendMissingRequiredProperties(lines, desc); } else { append(lines, "return {{newInst}};"); } append(lines, "}"); for (Binding field : desc.fields) { appendVarDef(lines, field); } for (Binding setter : desc.setters) { appendVarDef(lines, setter); } } for (WrapperDescriptor wrapper : desc.wrappers) { for (Binding param : wrapper.parameters) { appendVarDef(lines, param); } } // === bind first field if (desc.onExtraProperties != null) { append(lines, "java.util.Map extra = null;"); } append(lines, "com.jsoniter.Slice field = com.jsoniter.CodegenAccess.readObjectFieldAsSlice(iter);"); append(lines, "boolean once = true;"); append(lines, "while (once) {"); append(lines, "once = false;"); String rendered = renderTriTree(trieTree); if (desc.ctor.parameters.isEmpty()) { // if not field or setter, the value will set to temp variable for (Binding field : desc.fields) { rendered = updateBindingSetOp(rendered, field); } for (Binding setter : desc.setters) { rendered = updateBindingSetOp(rendered, setter); } } if (hasAnythingToBindFrom(allBindings)) { append(lines, "switch (field.len()) {"); append(lines, rendered); append(lines, "}"); // end of switch } appendOnUnknownField(lines, desc); append(lines, "}"); // end of while // === bind all fields append(lines, "while (com.jsoniter.CodegenAccess.nextToken(iter) == ',') {"); append(lines, "field = com.jsoniter.CodegenAccess.readObjectFieldAsSlice(iter);"); if (hasAnythingToBindFrom(allBindings)) { append(lines, "switch (field.len()) {"); append(lines, rendered); append(lines, "}"); // end of switch } appendOnUnknownField(lines, desc); append(lines, "}"); // end of while if (hasRequiredBinding) { append(lines, "if (tracker != " + expectedTracker + "L) {"); appendMissingRequiredProperties(lines, desc); append(lines, "}"); } if (desc.onExtraProperties != null) { appendSetExtraProperteis(lines, desc); } if (!desc.ctor.parameters.isEmpty()) { append(lines, String.format("%s obj = {{newInst}};", CodegenImplNative.getTypeName(clazz))); for (Binding field : desc.fields) { append(lines, String.format("obj.%s = _%s_;", field.field.getName(), field.name)); } for (Binding setter : desc.setters) { append(lines, String.format("obj.%s(_%s_);", setter.method.getName(), setter.name)); } } appendWrappers(desc.wrappers, lines); append(lines, "return obj;"); return lines.toString() .replace("{{clazz}}", clazz.getCanonicalName()) .replace("{{newInst}}", CodegenImplObjectHash.genNewInstCode(clazz, desc.ctor)); } private static void appendSetExtraProperteis(StringBuilder lines, ClassDescriptor desc) { Binding onExtraProperties = desc.onExtraProperties; if (ParameterizedTypeImpl.isSameClass(onExtraProperties.valueType, Map.class)) { if (onExtraProperties.field != null) { append(lines, String.format("obj.%s = extra;", onExtraProperties.field.getName())); } else { append(lines, String.format("obj.%s(extra);", onExtraProperties.method.getName())); } return; } throw new JsonException("extra properties can only be Map"); } private static boolean hasAnythingToBindFrom(List allBindings) { for (Binding binding : allBindings) { if (binding.fromNames.length > 0) { return true; } } return false; } private static int assignMaskForRequiredProperties(List allBindings) { int requiredIdx = 0; for (Binding binding : allBindings) { if (binding.asMissingWhenNotPresent) { // one bit represent one field binding.mask = 1L << requiredIdx; requiredIdx++; } } if (requiredIdx > 63) { throw new JsonException("too many required properties to track"); } return requiredIdx; } private static String updateBindingSetOp(String rendered, Binding binding) { while (true) { String marker = "_" + binding.name + "_"; int start = rendered.indexOf(marker); if (start == -1) { return rendered; } int middle = rendered.indexOf('=', start); if (middle == -1) { throw new JsonException("can not find = in: " + rendered + " ,at " + start); } middle += 1; int end = rendered.indexOf(';', start); if (end == -1) { throw new JsonException("can not find ; in: " + rendered + " ,at " + start); } String op = rendered.substring(middle, end); if (binding.field != null) { if (binding.valueCanReuse) { // reuse; then field set rendered = String.format("%scom.jsoniter.CodegenAccess.setExistingObject(iter, obj.%s);obj.%s=%s%s", rendered.substring(0, start), binding.field.getName(), binding.field.getName(), op, rendered.substring(end)); } else { // just field set rendered = String.format("%sobj.%s=%s%s", rendered.substring(0, start), binding.field.getName(), op, rendered.substring(end)); } } else { // method set rendered = String.format("%sobj.%s(%s)%s", rendered.substring(0, start), binding.method.getName(), op, rendered.substring(end)); } } } private static void appendMissingRequiredProperties(StringBuilder lines, ClassDescriptor desc) { append(lines, "java.util.List missingFields = new java.util.ArrayList();"); for (Binding binding : desc.allDecoderBindings()) { if (binding.asMissingWhenNotPresent) { long mask = binding.mask; append(lines, String.format("com.jsoniter.CodegenAccess.addMissingField(missingFields, tracker, %sL, \"%s\");", mask, binding.name)); } } if (desc.onMissingProperties == null || !desc.ctor.parameters.isEmpty()) { append(lines, "throw new com.jsoniter.spi.JsonException(\"missing required properties: \" + missingFields);"); } else { if (desc.onMissingProperties.field != null) { append(lines, String.format("obj.%s = missingFields;", desc.onMissingProperties.field.getName())); } else { append(lines, String.format("obj.%s(missingFields);", desc.onMissingProperties.method.getName())); } } } private static void appendOnUnknownField(StringBuilder lines, ClassDescriptor desc) { if (desc.asExtraForUnknownProperties) { if (desc.onExtraProperties == null) { append(lines, "throw new com.jsoniter.spi.JsonException('extra property: ' + field.toString());".replace('\'', '"')); } else { append(lines, "if (extra == null) { extra = new java.util.HashMap(); }"); append(lines, "extra.put(field.toString(), iter.readAny());"); } } else { append(lines, "iter.skip();"); } } private static Map buildTriTree(List allBindings) { Map trieTree = new HashMap(); for (Binding field : allBindings) { for (String fromName : field.fromNames) { byte[] fromNameBytes = fromName.getBytes(); Map current = (Map) trieTree.get(fromNameBytes.length); if (current == null) { current = new HashMap(); trieTree.put(fromNameBytes.length, current); } for (int i = 0; i < fromNameBytes.length - 1; i++) { byte b = fromNameBytes[i]; Map next = (Map) current.get(b); if (next == null) { next = new HashMap(); current.put(b, next); } current = next; } current.put(fromNameBytes[fromNameBytes.length - 1], field); } } return trieTree; } private static String renderTriTree(Map trieTree) { StringBuilder switchBody = new StringBuilder(); for (Map.Entry entry : trieTree.entrySet()) { Integer len = entry.getKey(); append(switchBody, "case " + len + ": "); Map current = (Map) entry.getValue(); addFieldDispatch(switchBody, len, 0, current, new ArrayList()); append(switchBody, "break;"); } return switchBody.toString(); } private static void addFieldDispatch( StringBuilder lines, int len, int i, Map current, List bytesToCompare) { for (Map.Entry entry : current.entrySet()) { Byte b = entry.getKey(); if (i == len - 1) { append(lines, "if ("); for (int j = 0; j < bytesToCompare.size(); j++) { Byte a = bytesToCompare.get(j); append(lines, String.format("field.at(%d)==%s && ", i - bytesToCompare.size() + j, a)); } append(lines, String.format("field.at(%d)==%s", i, b)); append(lines, ") {"); Binding field = (Binding) entry.getValue(); if (field.asExtraWhenPresent) { append(lines, String.format( "throw new com.jsoniter.spi.JsonException('extra property: %s');".replace('\'', '"'), field.name)); } else if (field.shouldSkip) { append(lines, "iter.skip();"); append(lines, "continue;"); } else { append(lines, String.format("_%s_ = %s;", field.name, CodegenImplNative.genField(field))); if (field.asMissingWhenNotPresent) { append(lines, "tracker = tracker | " + field.mask + "L;"); } append(lines, "continue;"); } append(lines, "}"); continue; } Map next = (Map) entry.getValue(); if (next.size() == 1) { ArrayList nextBytesToCompare = new ArrayList(bytesToCompare); nextBytesToCompare.add(b); addFieldDispatch(lines, len, i + 1, next, nextBytesToCompare); continue; } append(lines, "if ("); for (int j = 0; j < bytesToCompare.size(); j++) { Byte a = bytesToCompare.get(j); append(lines, String.format("field.at(%d)==%s && ", i - bytesToCompare.size() + j, a)); } append(lines, String.format("field.at(%d)==%s", i, b)); append(lines, ") {"); addFieldDispatch(lines, len, i + 1, next, new ArrayList()); append(lines, "}"); } } public static String genObjectUsingSkip(Class clazz, ConstructorDescriptor ctor) { StringBuilder lines = new StringBuilder(); append(lines, "if (iter.readNull()) { return null; }"); append(lines, "{{clazz}} obj = {{newInst}};"); append(lines, "iter.skip();"); append(lines, "return obj;"); return lines.toString() .replace("{{clazz}}", clazz.getCanonicalName()) .replace("{{newInst}}", CodegenImplObjectHash.genNewInstCode(clazz, ctor)); } static void append(StringBuilder lines, String str) { lines.append(str); lines.append("\n"); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/DecodingMode.java000066400000000000000000000007371304664171100254700ustar00rootroot00000000000000package com.jsoniter; public enum DecodingMode { /** * dynamically codegen, generate object decoder using hash */ DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH, /** * dynamically codegen, generate object decoder which compares fields strictly */ DYNAMIC_MODE_AND_MATCH_FIELD_STRICTLY, /** * statically codegen */ STATIC_MODE, /** * decoding only using reflection, do not need code generation */ REFLECTION_MODE } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/DynamicCodegen.java000066400000000000000000000022271304664171100260140ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.Decoder; import javassist.*; class DynamicCodegen { static ClassPool pool = ClassPool.getDefault(); static { pool.insertClassPath(new ClassClassPath(Decoder.class)); } public static Decoder gen(String cacheKey, String source) throws Exception { Decoder decoder; CtClass ctClass = pool.makeClass(cacheKey); ctClass.setInterfaces(new CtClass[]{pool.get(Decoder.class.getName())}); CtMethod staticMethod = CtNewMethod.make(source, ctClass); ctClass.addMethod(staticMethod); CtMethod interfaceMethod = CtNewMethod.make("" + "public Object decode(com.jsoniter.JsonIterator iter) {" + "return decode_(iter);" + "}", ctClass); ctClass.addMethod(interfaceMethod); decoder = (Decoder) ctClass.toClass().newInstance(); return decoder; } public static void enableStreamingSupport() throws Exception { CtClass ctClass = pool.makeClass("com.jsoniter.IterImpl"); ctClass.setSuperclass(pool.get(IterImplForStreaming.class.getName())); ctClass.toClass(); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/IterImpl.java000066400000000000000000000431301304664171100246660ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.any.Any; import com.jsoniter.spi.JsonException; import java.io.IOException; class IterImpl { public static final int readObjectFieldAsHash(JsonIterator iter) throws IOException { if (readByte(iter) != '"') { if (nextToken(iter) != '"') { throw iter.reportError("readObjectFieldAsHash", "expect \""); } } long hash = 0x811c9dc5; int i = iter.head; for (; i < iter.tail; i++) { byte c = iter.buf[i]; if (c == '"') { break; } hash ^= c; hash *= 0x1000193; } iter.head = i + 1; if (readByte(iter) != ':') { if (nextToken(iter) != ':') { throw iter.reportError("readObjectFieldAsHash", "expect :"); } } return (int) hash; } public static final Slice readObjectFieldAsSlice(JsonIterator iter) throws IOException { Slice field = readSlice(iter); if (nextToken(iter) != ':') { throw iter.reportError("readObjectFieldAsSlice", "expect : after object field"); } return field; } final static void skipArray(JsonIterator iter) throws IOException { int level = 1; for (int i = iter.head; i < iter.tail; i++) { switch (iter.buf[i]) { case '"': // If inside string, skip it iter.head = i + 1; skipString(iter); i = iter.head - 1; // it will be i++ soon break; case '[': // If open symbol, increase level level++; break; case ']': // If close symbol, increase level level--; // If we have returned to the original level, we're done if (level == 0) { iter.head = i + 1; return; } break; } } throw iter.reportError("skipArray", "incomplete array"); } final static void skipObject(JsonIterator iter) throws IOException { int level = 1; for (int i = iter.head; i < iter.tail; i++) { switch (iter.buf[i]) { case '"': // If inside string, skip it iter.head = i + 1; skipString(iter); i = iter.head - 1; // it will be i++ soon break; case '{': // If open symbol, increase level level++; break; case '}': // If close symbol, increase level level--; // If we have returned to the original level, we're done if (level == 0) { iter.head = i + 1; return; } break; } } throw iter.reportError("skipObject", "incomplete object"); } final static void skipString(JsonIterator iter) throws IOException { int end = IterImplSkip.findStringEnd(iter); if (end == -1) { throw iter.reportError("skipString", "incomplete string"); } else { iter.head = end; } } final static void skipUntilBreak(JsonIterator iter) throws IOException { // true, false, null, number for (int i = iter.head; i < iter.tail; i++) { byte c = iter.buf[i]; if (IterImplSkip.breaks[c]) { iter.head = i; return; } } iter.head = iter.tail; } final static boolean skipNumber(JsonIterator iter) throws IOException { // true, false, null, number boolean dotFound = false; for (int i = iter.head; i < iter.tail; i++) { byte c = iter.buf[i]; if (c == '.') { dotFound = true; continue; } if (IterImplSkip.breaks[c]) { iter.head = i; return dotFound; } } iter.head = iter.tail; return dotFound; } // read the bytes between " " public final static Slice readSlice(JsonIterator iter) throws IOException { if (IterImpl.nextToken(iter) != '"') { throw iter.reportError("readSlice", "expect \" for string"); } int end = IterImplString.findSliceEnd(iter); if (end == -1) { throw iter.reportError("readSlice", "incomplete string"); } else { // reuse current buffer iter.reusableSlice.reset(iter.buf, iter.head, end - 1); iter.head = end; return iter.reusableSlice; } } final static byte nextToken(final JsonIterator iter) throws IOException { int i = iter.head; for (; ; ) { byte c = iter.buf[i++]; switch (c) { case ' ': case '\n': case '\r': case '\t': continue; default: iter.head = i; return c; } } } final static byte readByte(JsonIterator iter) throws IOException { return iter.buf[iter.head++]; } public static Any readAny(JsonIterator iter) throws IOException { int start = iter.head; byte c = nextToken(iter); switch (c) { case '"': skipString(iter); return Any.lazyString(iter.buf, start, iter.head); case 't': skipFixedBytes(iter, 3); return Any.wrap(true); case 'f': skipFixedBytes(iter, 4); return Any.wrap(false); case 'n': skipFixedBytes(iter, 3); return Any.wrap((Object) null); case '[': skipArray(iter); return Any.lazyArray(iter.buf, start, iter.head); case '{': skipObject(iter); return Any.lazyObject(iter.buf, start, iter.head); default: if (skipNumber(iter)) { return Any.lazyDouble(iter.buf, start, iter.head); } else { return Any.lazyLong(iter.buf, start, iter.head); } } } public static void skipFixedBytes(JsonIterator iter, int n) throws IOException { iter.head += n; } public final static boolean loadMore(JsonIterator iter) throws IOException { return false; } public final static int readStringSlowPath(JsonIterator iter, int j) throws IOException { try { for (int i = iter.head; i < iter.tail; ) { int bc = iter.buf[i++]; if (bc == '"') { iter.head = i; return j; } if (bc == '\\') { bc = iter.buf[i++]; switch (bc) { case 'b': bc = '\b'; break; case 't': bc = '\t'; break; case 'n': bc = '\n'; break; case 'f': bc = '\f'; break; case 'r': bc = '\r'; break; case '"': case '/': case '\\': break; case 'u': bc = (IterImplString.translateHex(iter.buf[i++]) << 12) + (IterImplString.translateHex(iter.buf[i++]) << 8) + (IterImplString.translateHex(iter.buf[i++]) << 4) + IterImplString.translateHex(iter.buf[i++]); break; default: throw iter.reportError("readStringSlowPath", "invalid escape character: " + bc); } } else if ((bc & 0x80) != 0) { final int u2 = iter.buf[i++]; if ((bc & 0xE0) == 0xC0) { bc = ((bc & 0x1F) << 6) + (u2 & 0x3F); } else { final int u3 = iter.buf[i++]; if ((bc & 0xF0) == 0xE0) { bc = ((bc & 0x0F) << 12) + ((u2 & 0x3F) << 6) + (u3 & 0x3F); } else { final int u4 = iter.buf[i++]; if ((bc & 0xF8) == 0xF0) { bc = ((bc & 0x07) << 18) + ((u2 & 0x3F) << 12) + ((u3 & 0x3F) << 6) + (u4 & 0x3F); } else { throw iter.reportError("readStringSlowPath", "invalid unicode character"); } if (bc >= 0x10000) { // check if valid unicode if (bc >= 0x110000) throw iter.reportError("readStringSlowPath", "invalid unicode character"); // split surrogates final int sup = bc - 0x10000; if (iter.reusableChars.length == j) { char[] newBuf = new char[iter.reusableChars.length * 2]; System.arraycopy(iter.reusableChars, 0, newBuf, 0, iter.reusableChars.length); iter.reusableChars = newBuf; } iter.reusableChars[j++] = (char) ((sup >>> 10) + 0xd800); if (iter.reusableChars.length == j) { char[] newBuf = new char[iter.reusableChars.length * 2]; System.arraycopy(iter.reusableChars, 0, newBuf, 0, iter.reusableChars.length); iter.reusableChars = newBuf; } iter.reusableChars[j++] = (char) ((sup & 0x3ff) + 0xdc00); continue; } } } } if (iter.reusableChars.length == j) { char[] newBuf = new char[iter.reusableChars.length * 2]; System.arraycopy(iter.reusableChars, 0, newBuf, 0, iter.reusableChars.length); iter.reusableChars = newBuf; } iter.reusableChars[j++] = (char) bc; } throw iter.reportError("readStringSlowPath", "incomplete string"); } catch (IndexOutOfBoundsException e) { throw iter.reportError("readString", "incomplete string"); } } public static int updateStringCopyBound(final JsonIterator iter, final int bound) { return bound; } static final int readPositiveInt(final JsonIterator iter, byte c) throws IOException { int ind = IterImplNumber.intDigits[c]; if (ind == 0) { return 0; } if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { throw iter.reportError("readPositiveInt", "expect 0~9"); } if (iter.tail - iter.head > 9) { int i = iter.head; int ind2 = IterImplNumber.intDigits[iter.buf[i]]; if (ind2 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind; } int ind3 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind3 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 10 + ind2; } int ind4 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind4 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 100 + ind2 * 10 + ind3; } int ind5 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind5 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 1000 + ind2 * 100 + ind3 * 10 + ind4; } int ind6 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind6 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 10000 + ind2 * 1000 + ind3 * 100 + ind4 * 10 + ind5; } int ind7 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind7 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 100000 + ind2 * 10000 + ind3 * 1000 + ind4 * 100 + ind5 * 10 + ind6; } int ind8 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind8 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 1000000 + ind2 * 100000 + ind3 * 10000 + ind4 * 1000 + ind5 * 100 + ind6 * 10 + ind7; } int ind9 = IterImplNumber.intDigits[iter.buf[++i]]; ind = ind * 10000000 + ind2 * 1000000 + ind3 * 100000 + ind4 * 10000 + ind5 * 1000 + ind6 * 100 + ind7 * 10 + ind8; iter.head = i; if (ind9 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { return ind; } } return IterImplForStreaming.readIntSlowPath(iter, ind); } static final long readPositiveLong(final JsonIterator iter, byte c) throws IOException { long ind = IterImplNumber.intDigits[c]; if (ind == 0) { return 0; } if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { throw iter.reportError("readPositiveLong", "expect 0~9"); } if (iter.tail - iter.head > 9) { int i = iter.head; int ind2 = IterImplNumber.intDigits[iter.buf[i]]; if (ind2 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind; } int ind3 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind3 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 10 + ind2; } int ind4 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind4 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 100 + ind2 * 10 + ind3; } int ind5 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind5 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 1000 + ind2 * 100 + ind3 * 10 + ind4; } int ind6 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind6 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 10000 + ind2 * 1000 + ind3 * 100 + ind4 * 10 + ind5; } int ind7 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind7 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 100000 + ind2 * 10000 + ind3 * 1000 + ind4 * 100 + ind5 * 10 + ind6; } int ind8 = IterImplNumber.intDigits[iter.buf[++i]]; if (ind8 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return ind * 1000000 + ind2 * 100000 + ind3 * 10000 + ind4 * 1000 + ind5 * 100 + ind6 * 10 + ind7; } int ind9 = IterImplNumber.intDigits[iter.buf[++i]]; ind = ind * 10000000 + ind2 * 1000000 + ind3 * 100000 + ind4 * 10000 + ind5 * 1000 + ind6 * 100 + ind7 * 10 + ind8; iter.head = i; if (ind9 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { return ind; } } return IterImplForStreaming.readLongSlowPath(iter, ind); } static final double readPositiveDouble(final JsonIterator iter) throws IOException { int oldHead = iter.head; try { long value = IterImplNumber.readLong(iter); // without the dot if (iter.head == iter.tail) { return value; } byte c = iter.buf[iter.head]; if (c == '.') { iter.head++; int start = iter.head; c = iter.buf[iter.head++]; long decimalPart = readPositiveLong(iter, c); int decimalPlaces = iter.head - start; if (decimalPlaces > 0 && decimalPlaces < IterImplNumber.POW10.length && (iter.head - oldHead) < 10) { value = value * IterImplNumber.POW10[decimalPlaces] + decimalPart; return value / (double) IterImplNumber.POW10[decimalPlaces]; } else { iter.head = oldHead; return IterImplForStreaming.readDoubleSlowPath(iter); } } else { if (iter.head < iter.tail && iter.buf[iter.head] == 'e') { iter.head = oldHead; return IterImplForStreaming.readDoubleSlowPath(iter); } else { return value; } } } catch (JsonException e) { iter.head = oldHead; return IterImplForStreaming.readDoubleSlowPath(iter); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/IterImplArray.java000066400000000000000000000031151304664171100256640ustar00rootroot00000000000000package com.jsoniter; import java.io.IOException; class IterImplArray { public static final boolean readArray(final JsonIterator iter) throws IOException { byte c = IterImpl.nextToken(iter); switch (c) { case '[': c = IterImpl.nextToken(iter); if (c != ']') { iter.unreadByte(); return true; } return false; case ']': return false; case ',': return true; case 'n': return false; default: throw iter.reportError("readArray", "expect [ or , or n or ], but found: " + (char) c); } } public static final boolean readArrayCB(final JsonIterator iter, final JsonIterator.ReadArrayCallback callback, Object attachment) throws IOException { byte c = IterImpl.nextToken(iter); if (c == '[') { c = IterImpl.nextToken(iter); if (c != ']') { iter.unreadByte(); if (!callback.handle(iter, attachment)) { return false; } while (IterImpl.nextToken(iter) == ',') { if (!callback.handle(iter, attachment)) { return false; } } return true; } return true; } if (c == 'n') { return true; } throw iter.reportError("readArrayCB", "expect [ or n, but found: " + (char) c); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/IterImplForStreaming.java000066400000000000000000000530511304664171100272120ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.any.Any; import java.io.IOException; class IterImplForStreaming { public static final int readObjectFieldAsHash(JsonIterator iter) throws IOException { if (nextToken(iter) != '"') { throw iter.reportError("readObjectFieldAsHash", "expect \""); } long hash = 0x811c9dc5; for (; ; ) { byte c = 0; int i = iter.head; for (; i < iter.tail; i++) { c = iter.buf[i]; if (c == '"') { break; } hash ^= c; hash *= 0x1000193; } if (c == '"') { iter.head = i + 1; if (nextToken(iter) != ':') { throw iter.reportError("readObjectFieldAsHash", "expect :"); } return (int) hash; } if (!loadMore(iter)) { throw iter.reportError("readObjectFieldAsHash", "unmatched quote"); } } } public static final Slice readObjectFieldAsSlice(JsonIterator iter) throws IOException { Slice field = readSlice(iter); boolean notCopied = field != null; if (CodegenAccess.skipWhitespacesWithoutLoadMore(iter)) { if (notCopied) { int len = field.tail() - field.head(); byte[] newBuf = new byte[len]; System.arraycopy(field.data(), field.head(), newBuf, 0, len); field.reset(newBuf, 0, newBuf.length); } if (!loadMore(iter)) { throw iter.reportError("readObjectFieldAsSlice", "expect : after object field"); } } if (iter.buf[iter.head] != ':') { throw iter.reportError("readObjectFieldAsSlice", "expect : after object field"); } iter.head++; return field; } final static void skipArray(JsonIterator iter) throws IOException { int level = 1; for (; ; ) { for (int i = iter.head; i < iter.tail; i++) { switch (iter.buf[i]) { case '"': // If inside string, skip it iter.head = i + 1; skipString(iter); i = iter.head - 1; // it will be i++ soon break; case '[': // If open symbol, increase level level++; break; case ']': // If close symbol, increase level level--; // If we have returned to the original level, we're done if (level == 0) { iter.head = i + 1; return; } break; } } if (!loadMore(iter)) { return; } } } final static void skipObject(JsonIterator iter) throws IOException { int level = 1; for (; ; ) { for (int i = iter.head; i < iter.tail; i++) { switch (iter.buf[i]) { case '"': // If inside string, skip it iter.head = i + 1; skipString(iter); i = iter.head - 1; // it will be i++ soon break; case '{': // If open symbol, increase level level++; break; case '}': // If close symbol, increase level level--; // If we have returned to the original level, we're done if (level == 0) { iter.head = i + 1; return; } break; } } if (!loadMore(iter)) { return; } } } final static void skipString(JsonIterator iter) throws IOException { for (; ; ) { int end = IterImplSkip.findStringEnd(iter); if (end == -1) { int j = iter.tail - 1; boolean escaped = true; // can not just look the last byte is \ // because it could be \\ or \\\ for (; ; ) { // walk backward until head if (j < iter.head || iter.buf[j] != '\\') { // even number of backslashes // either end of buffer, or " found escaped = false; break; } j--; if (j < iter.head || iter.buf[j] != '\\') { // odd number of backslashes // it is \" or \\\" break; } j--; } if (!loadMore(iter)) { throw iter.reportError("skipString", "incomplete string"); } if (escaped) { iter.head = 1; // skip the first char as last char is \ } } else { iter.head = end; return; } } } final static void skipUntilBreak(JsonIterator iter) throws IOException { // true, false, null, number for (; ; ) { for (int i = iter.head; i < iter.tail; i++) { byte c = iter.buf[i]; if (IterImplSkip.breaks[c]) { iter.head = i; return; } } if (!loadMore(iter)) { iter.head = iter.tail; return; } } } final static boolean skipNumber(JsonIterator iter) throws IOException { // true, false, null, number boolean dotFound = false; for (; ; ) { for (int i = iter.head; i < iter.tail; i++) { byte c = iter.buf[i]; if (c == '.') { dotFound = true; continue; } if (IterImplSkip.breaks[c]) { iter.head = i; return dotFound; } } if (!loadMore(iter)) { iter.head = iter.tail; return dotFound; } } } // read the bytes between " " final static Slice readSlice(JsonIterator iter) throws IOException { if (IterImpl.nextToken(iter) != '"') { throw iter.reportError("readSlice", "expect \" for string"); } int end = IterImplString.findSliceEnd(iter); if (end != -1) { // reuse current buffer iter.reusableSlice.reset(iter.buf, iter.head, end - 1); iter.head = end; return iter.reusableSlice; } // TODO: avoid small memory allocation byte[] part1 = new byte[iter.tail - iter.head]; System.arraycopy(iter.buf, iter.head, part1, 0, part1.length); for (; ; ) { if (!loadMore(iter)) { throw iter.reportError("readSlice", "unmatched quote"); } end = IterImplString.findSliceEnd(iter); if (end == -1) { byte[] part2 = new byte[part1.length + iter.buf.length]; System.arraycopy(part1, 0, part2, 0, part1.length); System.arraycopy(iter.buf, 0, part2, part1.length, iter.buf.length); part1 = part2; } else { byte[] part2 = new byte[part1.length + end - 1]; System.arraycopy(part1, 0, part2, 0, part1.length); System.arraycopy(iter.buf, 0, part2, part1.length, end - 1); iter.head = end; iter.reusableSlice.reset(part2, 0, part2.length); return iter.reusableSlice; } } } final static byte nextToken(JsonIterator iter) throws IOException { for (; ; ) { for (int i = iter.head; i < iter.tail; i++) { byte c = iter.buf[i]; switch (c) { case ' ': case '\n': case '\t': case '\r': continue; default: iter.head = i + 1; return c; } } if (!loadMore(iter)) { return 0; } } } public final static boolean loadMore(JsonIterator iter) throws IOException { if (iter.in == null) { return false; } if (iter.skipStartedAt != -1) { return keepSkippedBytesThenRead(iter); } int n = iter.in.read(iter.buf); if (n < 1) { if (n == -1) { return false; } else { throw iter.reportError("loadMore", "read from input stream returned " + n); } } else { iter.head = 0; iter.tail = n; } return true; } private static boolean keepSkippedBytesThenRead(JsonIterator iter) throws IOException { int n; int offset; if (iter.skipStartedAt == 0 || iter.skipStartedAt < iter.tail / 2) { byte[] newBuf = new byte[iter.buf.length * 2]; offset = iter.tail - iter.skipStartedAt; System.arraycopy(iter.buf, iter.skipStartedAt, newBuf, 0, offset); iter.buf = newBuf; n = iter.in.read(iter.buf, offset, iter.buf.length - offset); } else { offset = iter.tail - iter.skipStartedAt; System.arraycopy(iter.buf, iter.skipStartedAt, iter.buf, 0, offset); n = iter.in.read(iter.buf, offset, iter.buf.length - offset); } iter.skipStartedAt = 0; if (n < 1) { if (n == -1) { return false; } else { throw iter.reportError("loadMore", "read from input stream returned " + n); } } else { iter.head = offset; iter.tail = offset + n; } return true; } final static byte readByte(JsonIterator iter) throws IOException { if (iter.head == iter.tail) { if (!loadMore(iter)) { throw iter.reportError("readByte", "no more to read"); } } return iter.buf[iter.head++]; } public static Any readAny(JsonIterator iter) throws IOException { // TODO: avoid small memory allocation iter.skipStartedAt = iter.head; byte c = nextToken(iter); switch (c) { case '"': skipString(iter); byte[] copied = copySkippedBytes(iter); return Any.lazyString(copied, 0, copied.length); case 't': skipFixedBytes(iter, 3); iter.skipStartedAt = -1; return Any.wrap(true); case 'f': skipFixedBytes(iter, 4); iter.skipStartedAt = -1; return Any.wrap(false); case 'n': skipFixedBytes(iter, 3); iter.skipStartedAt = -1; return Any.wrap((Object) null); case '[': skipArray(iter); copied = copySkippedBytes(iter); return Any.lazyArray(copied, 0, copied.length); case '{': skipObject(iter); copied = copySkippedBytes(iter); return Any.lazyObject(copied, 0, copied.length); default: if (skipNumber(iter)) { copied = copySkippedBytes(iter); return Any.lazyDouble(copied, 0, copied.length); } else { copied = copySkippedBytes(iter); return Any.lazyLong(copied, 0, copied.length); } } } private static byte[] copySkippedBytes(JsonIterator iter) { int start = iter.skipStartedAt; iter.skipStartedAt = -1; int end = iter.head; byte[] bytes = new byte[end - start]; System.arraycopy(iter.buf, start, bytes, 0, bytes.length); return bytes; } public static void skipFixedBytes(JsonIterator iter, int n) throws IOException { iter.head += n; if (iter.head >= iter.tail) { int more = iter.head - iter.tail; if (!loadMore(iter)) { if (more == 0) { iter.head = iter.tail; return; } throw iter.reportError("skipFixedBytes", "unexpected end"); } iter.head += more; } } public static int updateStringCopyBound(final JsonIterator iter, final int bound) { if (bound > iter.tail - iter.head) { return iter.tail - iter.head; } else { return bound; } } public final static int readStringSlowPath(JsonIterator iter, int j) throws IOException { for (;;) { int bc = readByte(iter); if (bc == '"') { return j; } if (bc == '\\') { bc = readByte(iter); switch (bc) { case 'b': bc = '\b'; break; case 't': bc = '\t'; break; case 'n': bc = '\n'; break; case 'f': bc = '\f'; break; case 'r': bc = '\r'; break; case '"': case '/': case '\\': break; case 'u': bc = (IterImplString.translateHex(readByte(iter)) << 12) + (IterImplString.translateHex(readByte(iter)) << 8) + (IterImplString.translateHex(readByte(iter)) << 4) + IterImplString.translateHex(readByte(iter)); break; default: throw iter.reportError("readStringSlowPath", "invalid escape character: " + bc); } } else if ((bc & 0x80) != 0) { final int u2 = readByte(iter); if ((bc & 0xE0) == 0xC0) { bc = ((bc & 0x1F) << 6) + (u2 & 0x3F); } else { final int u3 = readByte(iter); if ((bc & 0xF0) == 0xE0) { bc = ((bc & 0x0F) << 12) + ((u2 & 0x3F) << 6) + (u3 & 0x3F); } else { final int u4 = readByte(iter); if ((bc & 0xF8) == 0xF0) { bc = ((bc & 0x07) << 18) + ((u2 & 0x3F) << 12) + ((u3 & 0x3F) << 6) + (u4 & 0x3F); } else { throw iter.reportError("readStringSlowPath", "invalid unicode character"); } if (bc >= 0x10000) { // check if valid unicode if (bc >= 0x110000) throw iter.reportError("readStringSlowPath", "invalid unicode character"); // split surrogates final int sup = bc - 0x10000; if (iter.reusableChars.length == j) { char[] newBuf = new char[iter.reusableChars.length * 2]; System.arraycopy(iter.reusableChars, 0, newBuf, 0, iter.reusableChars.length); iter.reusableChars = newBuf; } iter.reusableChars[j++] = (char) ((sup >>> 10) + 0xd800); if (iter.reusableChars.length == j) { char[] newBuf = new char[iter.reusableChars.length * 2]; System.arraycopy(iter.reusableChars, 0, newBuf, 0, iter.reusableChars.length); iter.reusableChars = newBuf; } iter.reusableChars[j++] = (char) ((sup & 0x3ff) + 0xdc00); continue; } } } } if (iter.reusableChars.length == j) { char[] newBuf = new char[iter.reusableChars.length * 2]; System.arraycopy(iter.reusableChars, 0, newBuf, 0, iter.reusableChars.length); iter.reusableChars = newBuf; } iter.reusableChars[j++] = (char) bc; } } static long readLongSlowPath(JsonIterator iter, long value) throws IOException { for (; ; ) { for (int i = iter.head; i < iter.tail; i++) { int ind = IterImplNumber.intDigits[iter.buf[i]]; if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return value; } value = (value << 3) + (value << 1) + ind; if (value < 0) { // overflow if (value == Long.MIN_VALUE) { // if there is more number following, subsequent read will fail anyway iter.head = i; return value; } else { throw iter.reportError("readPositiveLong", "value is too large for long"); } } } if (!IterImpl.loadMore(iter)) { iter.head = iter.tail; return value; } } } static int readIntSlowPath(JsonIterator iter, int value) throws IOException { for (; ; ) { for (int i = iter.head; i < iter.tail; i++) { int ind = IterImplNumber.intDigits[iter.buf[i]]; if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { iter.head = i; return value; } value = (value << 3) + (value << 1) + ind; if (value < 0) { // overflow if (value == Integer.MIN_VALUE) { // if there is more number following, subsequent read will fail anyway iter.head = i; return value; } else { throw iter.reportError("readPositiveInt", "value is too large for int"); } } } if (!IterImpl.loadMore(iter)) { iter.head = iter.tail; return value; } } } public static final double readDoubleSlowPath(final JsonIterator iter) throws IOException { try { return Double.valueOf(readNumber(iter)); } catch (NumberFormatException e) { throw iter.reportError("readDoubleSlowPath", e.toString()); } } public static final String readNumber(final JsonIterator iter) throws IOException { int j = 0; for (; ; ) { for (int i = iter.head; i < iter.tail; i++) { if (j == iter.reusableChars.length) { char[] newBuf = new char[iter.reusableChars.length * 2]; System.arraycopy(iter.reusableChars, 0, newBuf, 0, iter.reusableChars.length); iter.reusableChars = newBuf; } byte c = iter.buf[i]; switch (c) { case '-': case '.': case 'e': case 'E': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': iter.reusableChars[j++] = (char) c; break; default: iter.head = i; return new String(iter.reusableChars, 0, j); } } if (!IterImpl.loadMore(iter)) { iter.head = iter.tail; return new String(iter.reusableChars, 0, j); } } } static final double readPositiveDouble(final JsonIterator iter) throws IOException { return readDoubleSlowPath(iter); } static final long readPositiveLong(final JsonIterator iter, byte c) throws IOException { long ind = IterImplNumber.intDigits[c]; if (ind == 0) { return 0; } if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { throw iter.reportError("readPositiveLong", "expect 0~9"); } return IterImplForStreaming.readLongSlowPath(iter, ind); } static final int readPositiveInt(final JsonIterator iter, byte c) throws IOException { int ind = IterImplNumber.intDigits[c]; if (ind == 0) { return 0; } if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) { throw iter.reportError("readPositiveInt", "expect 0~9"); } return IterImplForStreaming.readIntSlowPath(iter, ind); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/IterImplNumber.java000066400000000000000000000077431304664171100260510ustar00rootroot00000000000000/* this implementations contains significant code from https://github.com/ngs-doo/dsl-json/blob/master/LICENSE Copyright (c) 2015, Nova Generacija Softvera d.o.o. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Nova Generacija Softvera d.o.o. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package com.jsoniter; import java.io.IOException; class IterImplNumber { final static int[] intDigits = new int[127]; final static int[] floatDigits = new int[127]; final static int END_OF_NUMBER = -2; final static int DOT_IN_NUMBER = -3; final static int INVALID_CHAR_FOR_NUMBER = -1; static final long POW10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L, 1000000000000000L}; static { for (int i = 0; i < floatDigits.length; i++) { floatDigits[i] = INVALID_CHAR_FOR_NUMBER; intDigits[i] = INVALID_CHAR_FOR_NUMBER; } for (int i = '0'; i <= '9'; ++i) { floatDigits[i] = (i - '0'); intDigits[i] = (i - '0'); } floatDigits[','] = END_OF_NUMBER; floatDigits[']'] = END_OF_NUMBER; floatDigits['}'] = END_OF_NUMBER; floatDigits[' '] = END_OF_NUMBER; floatDigits['.'] = DOT_IN_NUMBER; } public static final double readDouble(final JsonIterator iter) throws IOException { final byte c = IterImpl.nextToken(iter); if (c == '-') { return -IterImpl.readPositiveDouble(iter); } else { iter.unreadByte(); return IterImpl.readPositiveDouble(iter); } } public static final float readFloat(final JsonIterator iter) throws IOException { final byte c = IterImpl.nextToken(iter); if (c == '-') { return (float)-IterImpl.readPositiveDouble(iter); } else { iter.unreadByte(); return (float) IterImpl.readPositiveDouble(iter); } } public static final int readInt(final JsonIterator iter) throws IOException { byte c = IterImpl.nextToken(iter); if (c == '-') { return -IterImpl.readPositiveInt(iter, IterImpl.readByte(iter)); } else { return IterImpl.readPositiveInt(iter, c); } } public static final long readLong(JsonIterator iter) throws IOException { byte c = IterImpl.nextToken(iter); if (c == '-') { return -IterImpl.readPositiveLong(iter, IterImpl.readByte(iter)); } else { return IterImpl.readPositiveLong(iter, c); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/IterImplObject.java000066400000000000000000000052711304664171100260210ustar00rootroot00000000000000package com.jsoniter; import java.io.IOException; class IterImplObject { public static final String readObject(JsonIterator iter) throws IOException { byte c = IterImpl.nextToken(iter); switch (c) { case 'n': IterImpl.skipFixedBytes(iter, 3); return null; case '{': c = IterImpl.nextToken(iter); if (c == '"') { iter.unreadByte(); String field = iter.readString(); if (IterImpl.nextToken(iter) != ':') { throw iter.reportError("readObject", "expect :"); } return field; } if (c == '}') { return null; // end of object } throw iter.reportError("readObject", "expect \" after {"); case ',': String field = iter.readString(); if (IterImpl.nextToken(iter) != ':') { throw iter.reportError("readObject", "expect :"); } return field; case '}': return null; // end of object default: throw iter.reportError("readObject", "expect { or , or } or n, but found: " + (char)c); } } public static final boolean readObjectCB(JsonIterator iter, JsonIterator.ReadObjectCallback cb, Object attachment) throws IOException { byte c = IterImpl.nextToken(iter); if ('{' == c) { c = IterImpl.nextToken(iter); if ('"' == c) { iter.unreadByte(); String field = iter.readString(); if (IterImpl.nextToken(iter) != ':') { throw iter.reportError("readObject", "expect :"); } if (!cb.handle(iter, field, attachment)) { return false; } while (IterImpl.nextToken(iter) == ',') { field = iter.readString(); if (IterImpl.nextToken(iter) != ':') { throw iter.reportError("readObject", "expect :"); } if (!cb.handle(iter, field, attachment)) { return false; } } return true; } if ('}' == c) { return true; } throw iter.reportError("readObjectCB", "expect \" after {"); } if ('n' == c) { IterImpl.skipFixedBytes(iter, 3); return true; } throw iter.reportError("readObjectCB", "expect { or n"); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/IterImplSkip.java000066400000000000000000000051671304664171100255250ustar00rootroot00000000000000package com.jsoniter; import java.io.IOException; class IterImplSkip { static final boolean[] breaks = new boolean[127]; static { breaks[' '] = true; breaks['\t'] = true; breaks['\n'] = true; breaks['\r'] = true; breaks[','] = true; breaks['}'] = true; breaks[']'] = true; } public static final void skip(JsonIterator iter) throws IOException { byte c = IterImpl.nextToken(iter); switch (c) { case '"': IterImpl.skipString(iter); return; case '-': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': IterImpl.skipUntilBreak(iter); return; case 't': case 'n': IterImpl.skipFixedBytes(iter, 3); // true or null return; case 'f': IterImpl.skipFixedBytes(iter, 4); // false return; case '[': IterImpl.skipArray(iter); return; case '{': IterImpl.skipObject(iter); return; default: throw iter.reportError("IterImplSkip", "do not know how to skip: " + c); } } // adapted from: https://github.com/buger/jsonparser/blob/master/parser.go // Tries to find the end of string // Support if string contains escaped quote symbols. final static int findStringEnd(JsonIterator iter) { boolean escaped = false; for (int i = iter.head; i < iter.tail; i++) { byte c = iter.buf[i]; if (c == '"') { if (!escaped) { return i + 1; } else { int j = i - 1; for (; ; ) { if (j < iter.head || iter.buf[j] != '\\') { // even number of backslashes // either end of buffer, or " found return i + 1; } j--; if (j < iter.head || iter.buf[j] != '\\') { // odd number of backslashes // it is \" or \\\" break; } j--; } } } else if (c == '\\') { escaped = true; } } return -1; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/IterImplString.java000066400000000000000000000112151304664171100260540ustar00rootroot00000000000000/* this implementations contains significant code from https://github.com/ngs-doo/dsl-json/blob/master/LICENSE Copyright (c) 2015, Nova Generacija Softvera d.o.o. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Nova Generacija Softvera d.o.o. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package com.jsoniter; import java.io.IOException; class IterImplString { final static int[] hexDigits = new int['f' + 1]; static { for (int i = 0; i < hexDigits.length; i++) { hexDigits[i] = -1; } for (int i = '0'; i <= '9'; ++i) { hexDigits[i] = (i - '0'); } for (int i = 'a'; i <= 'f'; ++i) { hexDigits[i] = ((i - 'a') + 10); } for (int i = 'A'; i <= 'F'; ++i) { hexDigits[i] = ((i - 'A') + 10); } } public static final String readString(JsonIterator iter) throws IOException { byte c = IterImpl.readByte(iter); if (c != '"') { if (readStringIsNull(iter, c)) { return null; } } int j = parse(iter); return new String(iter.reusableChars, 0, j); } private static int parse(JsonIterator iter) throws IOException { byte c;// try fast path first int i = iter.head; // this code will trigger jvm hotspot pattern matching to highly optimized assembly int bound = iter.reusableChars.length; bound = IterImpl.updateStringCopyBound(iter, bound); for(int j = 0; j < bound; j++) { c = iter.buf[i++]; if (c == '"') { iter.head = i; return j; } // If we encounter a backslash, which is a beginning of an escape sequence // or a high bit was set - indicating an UTF-8 encoded multibyte character, // there is no chance that we can decode the string without instantiating // a temporary buffer, so quit this loop if ((c ^ '\\') < 1) { break; } iter.reusableChars[j] = (char) c; } int alreadyCopied = 0; if (i > iter.head) { alreadyCopied = i - iter.head - 1; iter.head = i - 1; } return IterImpl.readStringSlowPath(iter, alreadyCopied); } private static boolean readStringIsNull(JsonIterator iter, byte c) throws IOException { if (c == 'n') { IterImpl.skipFixedBytes(iter, 3); return true; } else { c = IterImpl.nextToken(iter); if (c == 'n') { IterImpl.skipFixedBytes(iter, 3); return true; } } return false; } public static int translateHex(final byte b) { int val = hexDigits[b]; if (val == -1) { throw new IndexOutOfBoundsException(b + " is not valid hex digit"); } return val; } // slice does not allow escape final static int findSliceEnd(JsonIterator iter) { for (int i = iter.head; i < iter.tail; i++) { byte c = iter.buf[i]; if (c == '"') { return i + 1; } else if (c == '\\') { throw iter.reportError("findSliceEnd", "slice does not support escape char"); } } return -1; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/JsonIterator.java000066400000000000000000000363201304664171100255670ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.annotation.JsoniterAnnotationSupport; import com.jsoniter.any.Any; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.TypeLiteral; import java.io.Closeable; import java.io.IOException; import java.io.InputStream; import java.math.BigDecimal; import java.math.BigInteger; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class JsonIterator implements Closeable { private static boolean isStreamingEnabled = false; final static ValueType[] valueTypes = new ValueType[256]; InputStream in; byte[] buf; int head; int tail; int skipStartedAt = -1; // skip should keep bytes starting at this pos Map tempObjects = null; // used in reflection object decoder final Slice reusableSlice = new Slice(null, 0, 0); char[] reusableChars = new char[32]; Object existingObject = null; // the object should be bind to next static { for (int i = 0; i < valueTypes.length; i++) { valueTypes[i] = ValueType.INVALID; } valueTypes['"'] = ValueType.STRING; valueTypes['-'] = ValueType.NUMBER; valueTypes['0'] = ValueType.NUMBER; valueTypes['1'] = ValueType.NUMBER; valueTypes['2'] = ValueType.NUMBER; valueTypes['3'] = ValueType.NUMBER; valueTypes['4'] = ValueType.NUMBER; valueTypes['5'] = ValueType.NUMBER; valueTypes['6'] = ValueType.NUMBER; valueTypes['7'] = ValueType.NUMBER; valueTypes['8'] = ValueType.NUMBER; valueTypes['9'] = ValueType.NUMBER; valueTypes['t'] = ValueType.BOOLEAN; valueTypes['f'] = ValueType.BOOLEAN; valueTypes['n'] = ValueType.NULL; valueTypes['['] = ValueType.ARRAY; valueTypes['{'] = ValueType.OBJECT; } private JsonIterator(InputStream in, byte[] buf, int head, int tail) { this.in = in; this.buf = buf; this.head = head; this.tail = tail; } public JsonIterator() { this(null, new byte[0], 0, 0); } public static JsonIterator parse(InputStream in, int bufSize) { enableStreamingSupport(); return new JsonIterator(in, new byte[bufSize], 0, 0); } public static JsonIterator parse(byte[] buf) { return new JsonIterator(null, buf, 0, buf.length); } public static JsonIterator parse(byte[] buf, int head, int tail) { return new JsonIterator(null, buf, head, tail); } public static JsonIterator parse(String str) { return parse(str.getBytes()); } public static JsonIterator parse(Slice slice) { return new JsonIterator(null, slice.data(), slice.head(), slice.tail()); } public final void reset(byte[] buf) { this.buf = buf; this.head = 0; this.tail = buf.length; } public final void reset(byte[] buf, int head, int tail) { this.buf = buf; this.head = head; this.tail = tail; } public final void reset(Slice value) { this.buf = value.data(); this.head = value.head(); this.tail = value.tail(); } public final void reset(InputStream in) { this.in = in; this.head = 0; this.tail = 0; } public final void close() throws IOException { if (in != null) { in.close(); } } final void unreadByte() { if (head == 0) { throw reportError("unreadByte", "unread too many bytes"); } head--; } public final JsonException reportError(String op, String msg) { int peekStart = head - 10; if (peekStart < 0) { peekStart = 0; } int peekSize = head - peekStart; if (head > tail) { peekSize = tail - peekStart; } String peek = new String(buf, peekStart, peekSize); throw new JsonException(op + ": " + msg + ", head: " + head + ", peek: " + peek + ", buf: " + new String(buf)); } public final String currentBuffer() { int peekStart = head - 10; if (peekStart < 0) { peekStart = 0; } String peek = new String(buf, peekStart, head - peekStart); return "head: " + head + ", peek: " + peek + ", buf: " + new String(buf); } public final boolean readNull() throws IOException { byte c = IterImpl.nextToken(this); if (c != 'n') { unreadByte(); return false; } IterImpl.skipFixedBytes(this, 3); // null return true; } public final boolean readBoolean() throws IOException { byte c = IterImpl.nextToken(this); if ('t' == c) { IterImpl.skipFixedBytes(this, 3); // true return true; } if ('f' == c) { IterImpl.skipFixedBytes(this, 4); // false return false; } throw reportError("readBoolean", "expect t or f, found: " + c); } public final short readShort() throws IOException { int v = readInt(); if (Short.MIN_VALUE <= v && v <= Short.MAX_VALUE) { return (short) v; } else { throw reportError("readShort", "short overflow: " + v); } } public final int readInt() throws IOException { return IterImplNumber.readInt(this); } public final long readLong() throws IOException { return IterImplNumber.readLong(this); } public final boolean readArray() throws IOException { return IterImplArray.readArray(this); } public static interface ReadArrayCallback { boolean handle(JsonIterator iter, Object attachment) throws IOException; } public final boolean readArrayCB(ReadArrayCallback callback, Object attachment) throws IOException { return IterImplArray.readArrayCB(this, callback, attachment); } public final String readString() throws IOException { return IterImplString.readString(this); } public final Slice readStringAsSlice() throws IOException { return IterImpl.readSlice(this); } public final String readObject() throws IOException { return IterImplObject.readObject(this); } public static interface ReadObjectCallback { boolean handle(JsonIterator iter, String field, Object attachment) throws IOException; } public final void readObjectCB(ReadObjectCallback cb, Object attachment) throws IOException { IterImplObject.readObjectCB(this, cb, attachment); } public final float readFloat() throws IOException { return IterImplNumber.readFloat(this); } public final double readDouble() throws IOException { return IterImplNumber.readDouble(this); } public final BigDecimal readBigDecimal() throws IOException { // skip whitespace by read next if (whatIsNext() != ValueType.NUMBER) { throw reportError("readBigDecimal", "not number"); } return new BigDecimal(IterImplForStreaming.readNumber(this)); } public final BigInteger readBigInteger() throws IOException { // skip whitespace by read next if (whatIsNext() != ValueType.NUMBER) { throw reportError("readBigDecimal", "not number"); } return new BigInteger(IterImplForStreaming.readNumber(this)); } public final Any readAny() throws IOException { try { return IterImpl.readAny(this); } catch (ArrayIndexOutOfBoundsException e) { throw reportError("read", "premature end"); } } private final static ReadArrayCallback fillArray = new ReadArrayCallback() { @Override public boolean handle(JsonIterator iter, Object attachment) throws IOException { List list = (List) attachment; list.add(iter.read()); return true; } }; private final static ReadObjectCallback fillObject = new ReadObjectCallback() { @Override public boolean handle(JsonIterator iter, String field, Object attachment) throws IOException { Map map = (Map) attachment; map.put(field, iter.read()); return true; } }; public final Object read() throws IOException { try { ValueType valueType = whatIsNext(); switch (valueType) { case STRING: return readString(); case NUMBER: return readDouble(); case NULL: IterImpl.skipFixedBytes(this, 4); return null; case BOOLEAN: return readBoolean(); case ARRAY: ArrayList list = new ArrayList(4); readArrayCB(fillArray, list); return list; case OBJECT: Map map = new HashMap(4); readObjectCB(fillObject, map); return map; default: throw reportError("read", "unexpected value type: " + valueType); } } catch (ArrayIndexOutOfBoundsException e) { throw reportError("read", "premature end"); } } /** * try to bind to existing object, returned object might not the same instance * * @param existingObject the object instance to reuse * @param object type * @return data binding result, might not be the same object * @throws IOException if I/O went wrong */ public final T read(T existingObject) throws IOException { try { this.existingObject = existingObject; Class clazz = existingObject.getClass(); return (T) Codegen.getDecoder(TypeLiteral.create(clazz).getDecoderCacheKey(), clazz).decode(this); } catch (ArrayIndexOutOfBoundsException e) { throw reportError("read", "premature end"); } } /** * try to bind to existing object, returned object might not the same instance * * @param typeLiteral the type object * @param existingObject the object instance to reuse * @param object type * @return data binding result, might not be the same object * @throws IOException if I/O went wrong */ public final T read(TypeLiteral typeLiteral, T existingObject) throws IOException { try { this.existingObject = existingObject; return (T) Codegen.getDecoder(typeLiteral.getDecoderCacheKey(), typeLiteral.getType()).decode(this); } catch (ArrayIndexOutOfBoundsException e) { throw reportError("read", "premature end"); } } public final T read(Class clazz) throws IOException { try { return (T) Codegen.getDecoder(TypeLiteral.create(clazz).getDecoderCacheKey(), clazz).decode(this); } catch (ArrayIndexOutOfBoundsException e) { throw reportError("read", "premature end"); } } public final T read(TypeLiteral typeLiteral) throws IOException { try { String cacheKey = typeLiteral.getDecoderCacheKey(); return (T) Codegen.getDecoder(cacheKey, typeLiteral.getType()).decode(this); } catch (ArrayIndexOutOfBoundsException e) { throw reportError("read", "premature end"); } } public ValueType whatIsNext() throws IOException { ValueType valueType = valueTypes[IterImpl.nextToken(this)]; unreadByte(); return valueType; } public void skip() throws IOException { IterImplSkip.skip(this); } public static ThreadLocal tlsIter = new ThreadLocal() { @Override protected JsonIterator initialValue() { return new JsonIterator(); } }; public static final T deserialize(String input, Class clazz) { JsonIterator iter = tlsIter.get(); byte[] bytes = input.getBytes(); iter.reset(bytes); try { T val = iter.read(clazz); if (iter.head != bytes.length) { throw iter.reportError("deserialize", "trailing garbage found"); } return val; } catch (ArrayIndexOutOfBoundsException e) { throw iter.reportError("deserialize", "premature end"); } catch (IOException e) { throw new JsonException(e); } } public static final T deserialize(String input, TypeLiteral typeLiteral) { JsonIterator iter = tlsIter.get(); iter.reset(input.getBytes()); try { T val = iter.read(typeLiteral); if (IterImpl.nextToken(iter) != 0) { throw iter.reportError("deserialize", "trailing garbage found"); } return val; } catch (ArrayIndexOutOfBoundsException e) { throw iter.reportError("deserialize", "premature end"); } catch (IOException e) { throw new JsonException(e); } } public static final T deserialize(byte[] input, Class clazz) { JsonIterator iter = tlsIter.get(); iter.reset(input); try { T val = iter.read(clazz); if (IterImpl.nextToken(iter) != 0) { throw iter.reportError("deserialize", "trailing garbage found"); } return val; } catch (ArrayIndexOutOfBoundsException e) { throw iter.reportError("deserialize", "premature end"); } catch (IOException e) { throw new JsonException(e); } } public static final T deserialize(byte[] input, TypeLiteral typeLiteral) { JsonIterator iter = tlsIter.get(); iter.reset(input); try { T val = iter.read(typeLiteral); if (IterImpl.nextToken(iter) != 0) { throw iter.reportError("deserialize", "trailing garbage found"); } return val; } catch (ArrayIndexOutOfBoundsException e) { throw iter.reportError("deserialize", "premature end"); } catch (IOException e) { throw new JsonException(e); } } public static final Any deserialize(String input) { return deserialize(input.getBytes()); } public static final Any deserialize(byte[] input) { JsonIterator iter = tlsIter.get(); iter.reset(input); try { Any val = iter.readAny(); if (iter.head != input.length) { throw iter.reportError("deserialize", "trailing garbage found"); } return val; } catch (ArrayIndexOutOfBoundsException e) { throw iter.reportError("deserialize", "premature end"); } catch (IOException e) { throw new JsonException(e); } } public static void setMode(DecodingMode mode) { Codegen.setMode(mode); } public static void enableStreamingSupport() { if (isStreamingEnabled) { return; } isStreamingEnabled = true; try { DynamicCodegen.enableStreamingSupport(); } catch (Exception e) { throw new JsonException(e); } } public static void enableAnnotationSupport() { JsoniterAnnotationSupport.enable(); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/README.md000066400000000000000000000007661304664171100235650ustar00rootroot00000000000000there are 7 packages, listed in abstraction level order # bottom abstraction * spi: bottom of the abstraction # concrete implementations * iterator/any: these two packages are tangled together, doing decoding * output: doing encoding, should only depend on spi # addons * annotation: make spi accessible with annotation. everything here can be done using code * fuzzy: pre-defined decoders to work with messy input * extra: extra encoders/decoders, useful for a lot of people, but not all of themjava-jsoniter-java-0.9.8/src/main/java/com/jsoniter/ReflectionArrayDecoder.java000066400000000000000000000047271304664171100275310ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.lang.reflect.Array; class ReflectionArrayDecoder implements Decoder { private final Class componentType; private final Decoder compTypeDecoder; public ReflectionArrayDecoder(Class clazz) { componentType = clazz.getComponentType(); compTypeDecoder = Codegen.getDecoder(TypeLiteral.create(componentType).getDecoderCacheKey(), componentType); } @Override public Object decode(JsonIterator iter) throws IOException { CodegenAccess.resetExistingObject(iter); if (iter.readNull()) { return null; } if (!CodegenAccess.readArrayStart(iter)) { return Array.newInstance(componentType, 0); } Object a1 = compTypeDecoder.decode(iter); if (CodegenAccess.nextToken(iter) != ',') { Object arr = Array.newInstance(componentType, 1); Array.set(arr, 0, a1); return arr; } Object a2 = compTypeDecoder.decode(iter); if (CodegenAccess.nextToken(iter) != ',') { Object arr = Array.newInstance(componentType, 2); Array.set(arr, 0, a1); Array.set(arr, 1, a2); return arr; } Object a3 = compTypeDecoder.decode(iter); if (CodegenAccess.nextToken(iter) != ',') { Object arr = Array.newInstance(componentType, 3); Array.set(arr, 0, a1); Array.set(arr, 1, a2); Array.set(arr, 2, a3); return arr; } Object a4 = compTypeDecoder.decode(iter); Object arr = Array.newInstance(componentType, 8); Array.set(arr, 0, a1); Array.set(arr, 1, a2); Array.set(arr, 2, a3); Array.set(arr, 3, a4); int i = 4; int arrLen = 8; while (CodegenAccess.nextToken(iter) == ',') { if (i == arrLen) { Object newArr = Array.newInstance(componentType, 2 * arrLen); System.arraycopy(arr, 0, newArr, 0, arrLen); arr = newArr; arrLen = 2 * arrLen; } Array.set(arr, i++, compTypeDecoder.decode(iter)); } if (i == arrLen) { return arr; } Object newArr = Array.newInstance(componentType, i); System.arraycopy(arr, 0, newArr, 0, i); return newArr; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/ReflectionCollectionDecoder.java000066400000000000000000000026161304664171100305410ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.lang.reflect.Constructor; import java.lang.reflect.Type; import java.util.Collection; class ReflectionCollectionDecoder implements Decoder { private final Constructor ctor; private final Decoder compTypeDecoder; public ReflectionCollectionDecoder(Class clazz, Type[] typeArgs) { try { ctor = clazz.getConstructor(); } catch (NoSuchMethodException e) { throw new JsonException(e); } compTypeDecoder = Codegen.getDecoder(TypeLiteral.create(typeArgs[0]).getDecoderCacheKey(), typeArgs[0]); } @Override public Object decode(JsonIterator iter) throws IOException { try { return decode_(iter); } catch (Exception e) { throw new JsonException(e); } } private Object decode_(JsonIterator iter) throws Exception { Collection col = (Collection) CodegenAccess.resetExistingObject(iter); if (iter.readNull()) { return null; } if (col == null) { col = (Collection) this.ctor.newInstance(); } else { col.clear(); } while (iter.readArray()) { col.add(compTypeDecoder.decode(iter)); } return col; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/ReflectionDecoderFactory.java000066400000000000000000000013661304664171100300560ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.Decoder; import java.lang.reflect.Type; import java.util.Collection; import java.util.Map; public class ReflectionDecoderFactory { public static Decoder create(Class clazz, Type... typeArgs) { if (clazz.isArray()) { return new ReflectionArrayDecoder(clazz); } if (Collection.class.isAssignableFrom(clazz)) { return new ReflectionCollectionDecoder(clazz, typeArgs); } if (Map.class.isAssignableFrom(clazz)) { return new ReflectionMapDecoder(clazz, typeArgs); } if (clazz.isEnum()) { return new ReflectionEnumDecoder(clazz); } return new ReflectionObjectDecoder(clazz).create(); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/ReflectionEnumDecoder.java000066400000000000000000000015611304664171100273500ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.Decoder; import java.io.IOException; import java.util.HashMap; import java.util.Map; class ReflectionEnumDecoder implements Decoder{ private final Map enumMap = new HashMap(); private Class clazz; public ReflectionEnumDecoder(Class clazz) { this.clazz = clazz; for (Object e : clazz.getEnumConstants()) { enumMap.put(Slice.make(e.toString()), e); } } @Override public Object decode(JsonIterator iter) throws IOException { if (iter.readNull()) { return null; } Slice slice = IterImpl.readSlice(iter); Object e = enumMap.get(slice); if (e == null) { throw iter.reportError("ReflectionEnumDecoder", slice + " is not valid enum for " + clazz); } return e; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/ReflectionMapDecoder.java000066400000000000000000000030561304664171100271620ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.lang.reflect.Constructor; import java.lang.reflect.Type; import java.util.Map; class ReflectionMapDecoder implements Decoder { private final Constructor ctor; private final Decoder valueTypeDecoder; public ReflectionMapDecoder(Class clazz, Type[] typeArgs) { try { ctor = clazz.getConstructor(); } catch (NoSuchMethodException e) { throw new JsonException(e); } TypeLiteral valueTypeLiteral = TypeLiteral.create(typeArgs[1]); valueTypeDecoder = Codegen.getDecoder(valueTypeLiteral.getDecoderCacheKey(), typeArgs[0]); } @Override public Object decode(JsonIterator iter) throws IOException { try { return decode_(iter); } catch (Exception e) { throw new JsonException(e); } } private Object decode_(JsonIterator iter) throws Exception { Map map = (Map) CodegenAccess.resetExistingObject(iter); if (iter.readNull()) { return null; } if (map == null) { map = (Map) ctor.newInstance(); } if (!CodegenAccess.readObjectStart(iter)) { return map; } do { String field = CodegenAccess.readObjectFieldAsString(iter); map.put(field, valueTypeDecoder.decode(iter)); } while(CodegenAccess.nextToken(iter) == ','); return map; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/ReflectionObjectDecoder.java000066400000000000000000000375241304664171100276620ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.*; import java.io.IOException; import java.util.*; class ReflectionObjectDecoder { private static Object NOT_SET = new Object() { @Override public String toString() { return "NOT_SET"; } }; private Map allBindings = new HashMap(); private String tempCacheKey; private String ctorArgsCacheKey; private int tempCount; private long expectedTracker; private int requiredIdx; private int tempIdx; private ClassDescriptor desc; public ReflectionObjectDecoder(Class clazz) { try { init(clazz); } catch (Exception e) { throw new JsonException(e); } } private final void init(Class clazz) throws Exception { ClassDescriptor desc = JsoniterSpi.getDecodingClassDescriptor(clazz, true); for (Binding param : desc.ctor.parameters) { addBinding(clazz, param); } this.desc = desc; if (desc.ctor.objectFactory == null && desc.ctor.ctor == null && desc.ctor.staticFactory == null) { throw new JsonException("no constructor for: " + desc.clazz); } for (Binding field : desc.fields) { addBinding(clazz, field); } for (Binding setter : desc.setters) { addBinding(clazz, setter); } for (WrapperDescriptor setter : desc.wrappers) { for (Binding param : setter.parameters) { addBinding(clazz, param); } } if (requiredIdx > 63) { throw new JsonException("too many required properties to track"); } expectedTracker = Long.MAX_VALUE >> (63 - requiredIdx); if (!desc.ctor.parameters.isEmpty() || !desc.wrappers.isEmpty()) { tempCount = tempIdx; tempCacheKey = "temp@" + clazz.getCanonicalName(); ctorArgsCacheKey = "ctor@" + clazz.getCanonicalName(); } } private void addBinding(Class clazz, final Binding binding) { if (binding.asMissingWhenNotPresent) { binding.mask = 1L << requiredIdx; requiredIdx++; } if (binding.asExtraWhenPresent) { binding.decoder = new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { throw new JsonException("found should not present property: " + binding.name); } }; } if (binding.decoder == null) { // field decoder might be special customized binding.decoder = JsoniterSpi.getDecoder(binding.decoderCacheKey()); } if (binding.decoder == null) { binding.decoder = Codegen.getDecoder(binding.valueTypeLiteral.getDecoderCacheKey(), binding.valueType); } binding.idx = tempIdx; for (String fromName : binding.fromNames) { Slice slice = Slice.make(fromName); if (allBindings.containsKey(slice)) { throw new JsonException("name conflict found in " + clazz + ": " + fromName); } allBindings.put(slice, binding); } tempIdx++; } public Decoder create() { if (desc.ctor.parameters.isEmpty()) { if (desc.wrappers.isEmpty()) { return new OnlyField(); } else { return new WithSetter(); } } else { return new WithCtor(); } } public class OnlyField implements Decoder { public Object decode(JsonIterator iter) throws IOException { try { return decode_(iter); } catch (Exception e) { throw new JsonException(e); } } private Object decode_(JsonIterator iter) throws Exception { if (iter.readNull()) { CodegenAccess.resetExistingObject(iter); return null; } Object obj = CodegenAccess.existingObject(iter) == null ? createNewObject() : CodegenAccess.resetExistingObject(iter); if (!CodegenAccess.readObjectStart(iter)) { if (requiredIdx > 0) { if (desc.onMissingProperties == null) { throw new JsonException("missing required properties: " + collectMissingFields(0)); } else { setToBinding(obj, desc.onMissingProperties, collectMissingFields(0)); } } return obj; } Map extra = null; long tracker = 0L; Slice fieldName = CodegenAccess.readObjectFieldAsSlice(iter); Binding binding = allBindings.get(fieldName); if (binding == null) { extra = onUnknownProperty(iter, fieldName, extra); } else { if (binding.asMissingWhenNotPresent) { tracker |= binding.mask; } setToBinding(obj, binding, decodeBinding(iter, obj, binding)); } while (CodegenAccess.nextToken(iter) == ',') { fieldName = CodegenAccess.readObjectFieldAsSlice(iter); binding = allBindings.get(fieldName); if (binding == null) { extra = onUnknownProperty(iter, fieldName, extra); } else { if (binding.asMissingWhenNotPresent) { tracker |= binding.mask; } setToBinding(obj, binding, decodeBinding(iter, obj, binding)); } } if (tracker != expectedTracker) { if (desc.onMissingProperties == null) { throw new JsonException("missing required properties: " + collectMissingFields(tracker)); } else { setToBinding(obj, desc.onMissingProperties, collectMissingFields(tracker)); } } setExtra(obj, extra); return obj; } } public class WithCtor implements Decoder { @Override public Object decode(JsonIterator iter) throws IOException { try { return decode_(iter); } catch (Exception e) { throw new JsonException(e); } } private Object decode_(JsonIterator iter) throws Exception { if (iter.readNull()) { CodegenAccess.resetExistingObject(iter); return null; } if (iter.tempObjects == null) { iter.tempObjects = new HashMap(); } Object[] temp = (Object[]) iter.tempObjects.get(tempCacheKey); if (temp == null) { temp = new Object[tempCount]; iter.tempObjects.put(tempCacheKey, temp); } Arrays.fill(temp, NOT_SET); if (!CodegenAccess.readObjectStart(iter)) { if (requiredIdx > 0) { throw new JsonException("missing required properties: " + collectMissingFields(0)); } return createNewObject(iter, temp); } Map extra = null; long tracker = 0L; Slice fieldName = CodegenAccess.readObjectFieldAsSlice(iter); Binding binding = allBindings.get(fieldName); if (binding == null) { extra = onUnknownProperty(iter, fieldName, extra); } else { if (binding.asMissingWhenNotPresent) { tracker |= binding.mask; } temp[binding.idx] = decodeBinding(iter, binding); } while (CodegenAccess.nextToken(iter) == ',') { fieldName = CodegenAccess.readObjectFieldAsSlice(iter); binding = allBindings.get(fieldName); if (binding == null) { extra = onUnknownProperty(iter, fieldName, extra); } else { if (binding.asMissingWhenNotPresent) { tracker |= binding.mask; } temp[binding.idx] = decodeBinding(iter, binding); } } if (tracker != expectedTracker) { throw new JsonException("missing required properties: " + collectMissingFields(tracker)); } Object obj = createNewObject(iter, temp); setExtra(obj, extra); for (Binding field : desc.fields) { Object val = temp[field.idx]; if (val != NOT_SET) { field.field.set(obj, val); } } for (Binding setter : desc.setters) { Object val = temp[setter.idx]; if (val != NOT_SET) { setter.method.invoke(obj, val); } } applyWrappers(temp, obj); return obj; } } public class WithSetter implements Decoder { @Override public Object decode(JsonIterator iter) throws IOException { try { return decode_(iter); } catch (Exception e) { throw new JsonException(e); } } private Object decode_(JsonIterator iter) throws Exception { if (iter.readNull()) { CodegenAccess.resetExistingObject(iter); return null; } Object obj = createNewObject(); if (!CodegenAccess.readObjectStart(iter)) { if (requiredIdx > 0) { if (desc.onMissingProperties == null) { throw new JsonException("missing required properties: " + collectMissingFields(0)); } else { setToBinding(obj, desc.onMissingProperties, collectMissingFields(0)); } } return obj; } Map extra = null; long tracker = 0L; if (iter.tempObjects == null) { iter.tempObjects = new HashMap(); } Object[] temp = (Object[]) iter.tempObjects.get(tempCacheKey); if (temp == null) { temp = new Object[tempCount]; iter.tempObjects.put(tempCacheKey, temp); } Arrays.fill(temp, NOT_SET); Slice fieldName = CodegenAccess.readObjectFieldAsSlice(iter); Binding binding = allBindings.get(fieldName); if (binding == null) { extra = onUnknownProperty(iter, fieldName, extra); } else { if (binding.asMissingWhenNotPresent) { tracker |= binding.mask; } if (canNotSetDirectly(binding)) { temp[binding.idx] = decodeBinding(iter, obj, binding); } else { setToBinding(obj, binding, decodeBinding(iter, obj, binding)); } } while (CodegenAccess.nextToken(iter) == ',') { fieldName = CodegenAccess.readObjectFieldAsSlice(iter); binding = allBindings.get(fieldName); if (binding == null) { extra = onUnknownProperty(iter, fieldName, extra); } else { if (binding.asMissingWhenNotPresent) { tracker |= binding.mask; } if (canNotSetDirectly(binding)) { temp[binding.idx] = decodeBinding(iter, obj, binding); } else { setToBinding(obj, binding, decodeBinding(iter, obj, binding)); } } } if (tracker != expectedTracker) { if (desc.onMissingProperties == null) { throw new JsonException("missing required properties: " + collectMissingFields(tracker)); } else { setToBinding(obj, desc.onMissingProperties, collectMissingFields(tracker)); } } setExtra(obj, extra); applyWrappers(temp, obj); return obj; } } private void setToBinding(Object obj, Binding binding, Object value) throws Exception { if (binding.field != null) { binding.field.set(obj, value); } else { binding.method.invoke(obj, value); } } private void setExtra(Object obj, Map extra) throws Exception { if (desc.onExtraProperties != null) { setToBinding(obj, desc.onExtraProperties, extra); } } private boolean canNotSetDirectly(Binding binding) { return binding.field == null && binding.method == null; } private Object decodeBinding(JsonIterator iter, Binding binding) throws Exception { Object value; value = binding.decoder.decode(iter); return value; } private Object decodeBinding(JsonIterator iter, Object obj, Binding binding) throws Exception { if (binding.valueCanReuse) { CodegenAccess.setExistingObject(iter, binding.field.get(obj)); } return decodeBinding(iter, binding); } private Map onUnknownProperty(JsonIterator iter, Slice fieldName, Map extra) throws IOException { if (desc.asExtraForUnknownProperties) { if (desc.onExtraProperties == null) { throw new JsonException("unknown property: " + fieldName.toString()); } else { if (extra == null) { extra = new HashMap(); } extra.put(fieldName.toString(), iter.readAny()); } } else { iter.skip(); } return extra; } private List collectMissingFields(long tracker) { List missingFields = new ArrayList(); for (Binding binding : allBindings.values()) { if (binding.asMissingWhenNotPresent) { long mask = binding.mask; CodegenAccess.addMissingField(missingFields, tracker, mask, binding.name); } } return missingFields; } private void applyWrappers(Object[] temp, Object obj) throws Exception { for (WrapperDescriptor wrapper : desc.wrappers) { Object[] args = new Object[wrapper.parameters.size()]; for (int i = 0; i < wrapper.parameters.size(); i++) { args[i] = temp[wrapper.parameters.get(i).idx]; } wrapper.method.invoke(obj, args); } } private Object createNewObject(JsonIterator iter, Object[] temp) throws Exception { if (iter.tempObjects == null) { iter.tempObjects = new HashMap(); } Object[] ctorArgs = (Object[]) iter.tempObjects.get(ctorArgsCacheKey); if (ctorArgs == null) { ctorArgs = new Object[desc.ctor.parameters.size()]; iter.tempObjects.put(ctorArgsCacheKey, ctorArgs); } Arrays.fill(ctorArgs, null); for (int i = 0; i < desc.ctor.parameters.size(); i++) { Object arg = temp[desc.ctor.parameters.get(i).idx]; if (arg != NOT_SET) { ctorArgs[i] = arg; } } return createNewObject(ctorArgs); } private Object createNewObject(Object... args) throws Exception { if (desc.ctor.objectFactory != null) { return desc.ctor.objectFactory.create(desc.clazz); } if (desc.ctor.staticFactory != null) { return desc.ctor.staticFactory.invoke(null, args); } else { return desc.ctor.ctor.newInstance(args); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/Slice.java000066400000000000000000000030251304664171100241770ustar00rootroot00000000000000package com.jsoniter; public class Slice { private byte[] data; private int head; private int tail; private int hash; public Slice(byte[] data, int head, int tail) { this.data = data; this.head = head; this.tail = tail; } public void reset(byte[] data, int head, int tail) { this.data = data; this.head = head; this.tail = tail; this.hash = 0; } public final byte at(int pos) { return data[head + pos]; } public final int len() { return tail - head; } public final byte[] data() { return data; } public final int head() { return head; } public final int tail() { return tail; } public static Slice make(String str) { byte[] data = str.getBytes(); return new Slice(data, 0, data.length); } @Override public final boolean equals(Object o) { Slice slice = (Slice) o; if ((tail - head) != (slice.tail - slice.head)) return false; for (int i = head, j = slice.head; i < tail; i++, j++) if (data[i] != slice.data[j]) return false; return true; } @Override public final int hashCode() { if (hash == 0 && tail - head > 0) { for (int i = head; i < tail; i++) { hash = 31 * hash + data[i]; } } return hash; } @Override public String toString() { return new String(data, head, tail - head); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/StaticCodeGenerator.java000066400000000000000000000020541304664171100270320ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.CodegenConfig; import com.jsoniter.spi.JsonException; import java.io.File; public class StaticCodeGenerator { public static void main(String[] args) throws Exception { String configClassName = args[0]; String configJavaFile = configClassName.replace('.', '/') + ".java"; if (!new File(configJavaFile).exists()) { throw new JsonException("must execute static code generator in the java source code directory which contains: " + configJavaFile); } Class clazz = Class.forName(configClassName); CodegenConfig config = (CodegenConfig) clazz.newInstance(); JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); JsonStream.setMode(EncodingMode.DYNAMIC_MODE); config.setup(); CodegenAccess.staticGenDecoders(config.whatToCodegen()); com.jsoniter.output.CodegenAccess.staticGenEncoders(config.whatToCodegen()); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/ValueType.java000066400000000000000000000002031304664171100250510ustar00rootroot00000000000000package com.jsoniter; public enum ValueType { INVALID, STRING, NUMBER, NULL, BOOLEAN, ARRAY, OBJECT } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/000077500000000000000000000000001304664171100244475ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/JacksonAnnotationSupport.java000066400000000000000000000070771304664171100323450ustar00rootroot00000000000000package com.jsoniter.annotation; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.JsoniterSpi; import java.lang.annotation.Annotation; public class JacksonAnnotationSupport extends JsoniterAnnotationSupport { public static void enable() { JsoniterSpi.registerExtension(new JacksonAnnotationSupport()); } @Override protected JsonIgnore getJsonIgnore(Annotation[] annotations) { JsonIgnore jsoniterObj = super.getJsonIgnore(annotations); if (jsoniterObj != null) { return jsoniterObj; } final com.fasterxml.jackson.annotation.JsonIgnore jacksonObj = getAnnotation( annotations, com.fasterxml.jackson.annotation.JsonIgnore.class); if (jacksonObj == null) { return null; } return new JsonIgnore() { @Override public boolean value() { return jacksonObj.value(); } @Override public Class annotationType() { return JsonIgnore.class; } }; } @Override protected JsonProperty getJsonProperty(Annotation[] annotations) { JsonProperty jsoniterObj = super.getJsonProperty(annotations); if (jsoniterObj != null) { return jsoniterObj; } final com.fasterxml.jackson.annotation.JsonProperty jacksonObj = getAnnotation( annotations, com.fasterxml.jackson.annotation.JsonProperty.class); if (jacksonObj == null) { return null; } return new JsonProperty() { @Override public String value() { return jacksonObj.value(); } @Override public String[] from() { return new String[0]; } @Override public String[] to() { return new String[0]; } @Override public boolean required() { return jacksonObj.required(); } @Override public Class decoder() { return Decoder.class; } @Override public Class implementation() { return Object.class; } @Override public Class encoder() { return Encoder.class; } @Override public boolean nullable() { return true; } @Override public boolean collectionValueNullable() { return true; } @Override public boolean omitNull() { return true; } @Override public Class annotationType() { return JsonProperty.class; } }; } @Override protected JsonCreator getJsonCreator(Annotation[] annotations) { JsonCreator jsoniterObj = super.getJsonCreator(annotations); if (jsoniterObj != null) { return jsoniterObj; } com.fasterxml.jackson.annotation.JsonCreator jacksonObj = getAnnotation( annotations, com.fasterxml.jackson.annotation.JsonCreator.class); if (jacksonObj == null) { return null; } return new JsonCreator() { @Override public Class annotationType() { return JsonCreator.class; } }; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/JsonCreator.java000066400000000000000000000005361304664171100275470ustar00rootroot00000000000000package com.jsoniter.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR}) @Retention(RetentionPolicy.RUNTIME) public @interface JsonCreator { } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/JsonExtraProperties.java000066400000000000000000000005671304664171100313140ustar00rootroot00000000000000package com.jsoniter.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) public @interface JsonExtraProperties { } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/JsonIgnore.java000066400000000000000000000006201304664171100273650ustar00rootroot00000000000000package com.jsoniter.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) public @interface JsonIgnore { boolean value() default true; } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/JsonMissingProperties.java000066400000000000000000000005711304664171100316350ustar00rootroot00000000000000package com.jsoniter.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) public @interface JsonMissingProperties { } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/JsonObject.java000066400000000000000000000015771304664171100273640ustar00rootroot00000000000000package com.jsoniter.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface JsonObject { /** * @return if the unknown property is in this list, it will be treated as extra, * if the unknown property is in this list, it will be treated as extra */ String[] unknownPropertiesBlacklist() default {}; /** * @return if the unknown property is in this list, it will be silently ignored */ String[] unknownPropertiesWhitelist() default {}; /** * @return if true, all known properties will be treated as extra, * if @JsonExtraProperties not defined, it will be treated as error */ boolean asExtraForUnknownProperties() default false; } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/JsonProperty.java000066400000000000000000000035431304664171100277750ustar00rootroot00000000000000package com.jsoniter.annotation; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.Encoder; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) public @interface JsonProperty { /** * @return alternative name for the field/getter/setter/parameter */ String value() default ""; /** * @return when bind from multiple possible names, set this */ String[] from() default {}; /** * @return when one field will write to multiple object fields, set this */ String[] to() default {}; /** * @return used in decoding only, the field must present in the JSON, regardless null or not */ boolean required() default false; /** * @return set different decoder just for this field */ Class decoder() default Decoder.class; /** * @return used in decoding only, choose concrete class for interface/abstract type */ Class implementation() default Object.class; /** * @return set different encoder just for this field */ Class encoder() default Encoder.class; /** * @return used in encoding only, should check null for this field, * skip null checking will make encoding faster */ boolean nullable() default true; /** * @return used in encoding only, should check null for the value, if it is collection, * skip null checking will make encoding faster */ boolean collectionValueNullable() default true; /** * @return if true, do not write the field altogether if value is null */ boolean omitNull() default true; } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/JsonUnwrapper.java000066400000000000000000000005071304664171100301310ustar00rootroot00000000000000package com.jsoniter.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface JsonUnwrapper { } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/JsonWrapper.java000066400000000000000000000005051304664171100275640ustar00rootroot00000000000000package com.jsoniter.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface JsonWrapper { } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/annotation/JsoniterAnnotationSupport.java000066400000000000000000000245741304664171100325530ustar00rootroot00000000000000package com.jsoniter.annotation; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.*; import java.lang.annotation.Annotation; import java.lang.reflect.*; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class JsoniterAnnotationSupport extends EmptyExtension { private static boolean enabled = false; public static void enable() { if (enabled) { return; } enabled = true; JsoniterSpi.registerExtension(new JsoniterAnnotationSupport()); } @Override public void updateClassDescriptor(ClassDescriptor desc) { JsonObject jsonObject = (JsonObject) desc.clazz.getAnnotation(JsonObject.class); if (jsonObject != null) { if (jsonObject.asExtraForUnknownProperties()) { desc.asExtraForUnknownProperties = true; } for (String fieldName : jsonObject.unknownPropertiesWhitelist()) { Binding binding = new Binding(desc.clazz, desc.lookup, Object.class); binding.name = fieldName; binding.shouldSkip = true; desc.fields.add(binding); } for (String fieldName : jsonObject.unknownPropertiesBlacklist()) { Binding binding = new Binding(desc.clazz, desc.lookup, Object.class); binding.name = fieldName; binding.asExtraWhenPresent = true; desc.fields.add(binding); } } List allMethods = new ArrayList(); Class current = desc.clazz; while (current != null) { allMethods.addAll(Arrays.asList(current.getDeclaredMethods())); current = current.getSuperclass(); } updateBindings(desc); detectCtor(desc); detectStaticFactory(desc, allMethods); detectWrappers(desc, allMethods); detectUnwrappers(desc, allMethods); } private void detectUnwrappers(ClassDescriptor desc, List allMethods) { for (Method method : allMethods) { if (Modifier.isStatic(method.getModifiers())) { continue; } if (method.getAnnotation(JsonUnwrapper.class) == null) { continue; } desc.unWrappers.add(method); } } private void detectWrappers(ClassDescriptor desc, List allMethods) { for (Method method : allMethods) { if (Modifier.isStatic(method.getModifiers())) { continue; } if (method.getAnnotation(JsonWrapper.class) == null) { continue; } Annotation[][] annotations = method.getParameterAnnotations(); String[] paramNames = getParamNames(method, annotations.length); WrapperDescriptor setter = new WrapperDescriptor(); setter.method = method; for (int i = 0; i < annotations.length; i++) { Annotation[] paramAnnotations = annotations[i]; Binding binding = new Binding(desc.clazz, desc.lookup, method.getGenericParameterTypes()[i]); JsonProperty jsonProperty = getJsonProperty(paramAnnotations); if (jsonProperty != null) { updateBindingWithJsonProperty(binding, jsonProperty); } if (binding.name == null || binding.name.length() == 0) { binding.name = paramNames[i]; } binding.annotations = paramAnnotations; setter.parameters.add(binding); } desc.wrappers.add(setter); } } private String[] getParamNames(Object obj, int paramCount) { String[] paramNames = new String[paramCount]; try { Object params = reflectCall(obj, "getParameters"); for (int i = 0; i < paramNames.length; i++) { paramNames[i] = (String) reflectCall(Array.get(params, i), "getName"); } } catch (Exception e) { } return paramNames; } private Object reflectCall(Object obj, String methodName, Object... args) throws Exception { Method method = obj.getClass().getMethod(methodName); return method.invoke(obj, args); } private void detectStaticFactory(ClassDescriptor desc, List allMethods) { for (Method method : allMethods) { if (!Modifier.isStatic(method.getModifiers())) { continue; } JsonCreator jsonCreator = getJsonCreator(method.getAnnotations()); if (jsonCreator == null) { continue; } desc.ctor.staticMethodName = method.getName(); desc.ctor.staticFactory = method; desc.ctor.ctor = null; Annotation[][] annotations = method.getParameterAnnotations(); String[] paramNames = getParamNames(method, annotations.length); for (int i = 0; i < annotations.length; i++) { Annotation[] paramAnnotations = annotations[i]; JsonProperty jsonProperty = getJsonProperty(paramAnnotations); Binding binding = new Binding(desc.clazz, desc.lookup, method.getGenericParameterTypes()[i]); if (jsonProperty != null) { updateBindingWithJsonProperty(binding, jsonProperty); } if (binding.name == null || binding.name.length() == 0) { binding.name = paramNames[i]; } binding.annotations = paramAnnotations; desc.ctor.parameters.add(binding); } } } private void detectCtor(ClassDescriptor desc) { for (Constructor ctor : desc.clazz.getDeclaredConstructors()) { JsonCreator jsonCreator = getJsonCreator(ctor.getAnnotations()); if (jsonCreator == null) { continue; } desc.ctor.staticMethodName = null; desc.ctor.ctor = ctor; desc.ctor.staticFactory = null; Annotation[][] annotations = ctor.getParameterAnnotations(); String[] paramNames = getParamNames(ctor, annotations.length); for (int i = 0; i < annotations.length; i++) { Annotation[] paramAnnotations = annotations[i]; JsonProperty jsonProperty = getJsonProperty(paramAnnotations); Binding binding = new Binding(desc.clazz, desc.lookup, ctor.getGenericParameterTypes()[i]); if (jsonProperty != null) { updateBindingWithJsonProperty(binding, jsonProperty); } if (binding.name == null || binding.name.length() == 0) { binding.name = paramNames[i]; } binding.annotations = paramAnnotations; desc.ctor.parameters.add(binding); } } } private void updateBindings(ClassDescriptor desc) { for (Binding binding : desc.allBindings()) { JsonIgnore jsonIgnore = getJsonIgnore(binding.annotations); if (jsonIgnore != null && jsonIgnore.value()) { binding.fromNames = new String[0]; binding.toNames = new String[0]; } JsonProperty jsonProperty = getJsonProperty(binding.annotations); if (jsonProperty != null) { updateBindingWithJsonProperty(binding, jsonProperty); } if (getAnnotation(binding.annotations, JsonMissingProperties.class) != null) { // this binding will not bind from json // instead it will be set by jsoniter with missing property names binding.fromNames = new String[0]; desc.onMissingProperties = binding; } if (getAnnotation(binding.annotations, JsonExtraProperties.class) != null) { // this binding will not bind from json // instead it will be set by jsoniter with extra properties binding.fromNames = new String[0]; desc.onExtraProperties = binding; } } } private void updateBindingWithJsonProperty(Binding binding, JsonProperty jsonProperty) { binding.asMissingWhenNotPresent = jsonProperty.required(); binding.isNullable = jsonProperty.nullable(); binding.isCollectionValueNullable = jsonProperty.collectionValueNullable(); binding.shouldOmitNull = jsonProperty.omitNull(); String altName = jsonProperty.value(); if (!altName.isEmpty()) { binding.name = altName; binding.fromNames = new String[]{altName}; } if (jsonProperty.from().length > 0) { binding.fromNames = jsonProperty.from(); } if (jsonProperty.to().length > 0) { binding.toNames = jsonProperty.to(); } if (jsonProperty.decoder() != Decoder.class) { try { binding.decoder = jsonProperty.decoder().newInstance(); } catch (Exception e) { throw new JsonException(e); } } if (jsonProperty.encoder() != Encoder.class) { try { binding.encoder = jsonProperty.encoder().newInstance(); } catch (Exception e) { throw new JsonException(e); } } if (jsonProperty.implementation() != Object.class) { binding.valueType = ParameterizedTypeImpl.useImpl(binding.valueType, jsonProperty.implementation()); binding.valueTypeLiteral = TypeLiteral.create(binding.valueType); } } protected JsonCreator getJsonCreator(Annotation[] annotations) { return getAnnotation(annotations, JsonCreator.class); } protected JsonProperty getJsonProperty(Annotation[] annotations) { return getAnnotation(annotations, JsonProperty.class); } protected JsonIgnore getJsonIgnore(Annotation[] annotations) { return getAnnotation(annotations, JsonIgnore.class); } protected static T getAnnotation(Annotation[] annotations, Class annotationClass) { if (annotations == null) { return null; } for (Annotation annotation : annotations) { if (annotationClass.isAssignableFrom(annotation.getClass())) { return (T) annotation; } } return null; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/000077500000000000000000000000001304664171100230645ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/Any.java000066400000000000000000000213531304664171100244620ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.output.CodegenAccess; import com.jsoniter.spi.JsonException; import com.jsoniter.JsonIterator; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.util.*; public abstract class Any implements Iterable { static { Encoder anyEncoder = new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { Any any = (Any) obj; any.writeTo(stream); } @Override public Any wrap(Object obj) { return (Any) obj; } }; JsonStream.registerNativeEncoder(Any.class, anyEncoder); JsonStream.registerNativeEncoder(TrueAny.class, anyEncoder); JsonStream.registerNativeEncoder(FalseAny.class, anyEncoder); JsonStream.registerNativeEncoder(ArrayLazyAny.class, anyEncoder); JsonStream.registerNativeEncoder(DoubleAny.class, anyEncoder); JsonStream.registerNativeEncoder(FloatAny.class, anyEncoder); JsonStream.registerNativeEncoder(IntAny.class, anyEncoder); JsonStream.registerNativeEncoder(LongAny.class, anyEncoder); JsonStream.registerNativeEncoder(NullAny.class, anyEncoder); JsonStream.registerNativeEncoder(LongLazyAny.class, anyEncoder); JsonStream.registerNativeEncoder(DoubleLazyAny.class, anyEncoder); JsonStream.registerNativeEncoder(ObjectLazyAny.class, anyEncoder); JsonStream.registerNativeEncoder(StringAny.class, anyEncoder); JsonStream.registerNativeEncoder(StringLazyAny.class, anyEncoder); JsonStream.registerNativeEncoder(ArrayAny.class, anyEncoder); JsonStream.registerNativeEncoder(ObjectAny.class, anyEncoder); JsonStream.registerNativeEncoder(ListWrapperAny.class, anyEncoder); JsonStream.registerNativeEncoder(ArrayWrapperAny.class, anyEncoder); JsonStream.registerNativeEncoder(MapWrapperAny.class, anyEncoder); } public static Any wrapArray(Object val) { return new ArrayWrapperAny(val); } public interface EntryIterator { boolean next(); String key(); Any value(); } protected final static Set EMPTY_KEYS = Collections.unmodifiableSet(new HashSet()); protected final static EntryIterator EMPTY_ENTRIES_ITERATOR = new EntryIterator() { @Override public boolean next() { return false; } @Override public String key() { throw new NoSuchElementException(); } @Override public Any value() { throw new NoSuchElementException(); } }; protected final static Iterator EMPTY_ITERATOR = new Iterator() { @Override public void remove() { throw new UnsupportedOperationException(); } @Override public boolean hasNext() { return false; } @Override public Any next() { throw new NoSuchElementException(); } }; public abstract ValueType valueType(); public T bindTo(T obj, Object... keys) { return get(keys).bindTo(obj); } public T bindTo(T obj) { return (T) object(); } public T bindTo(TypeLiteral typeLiteral, T obj, Object... keys) { return get(keys).bindTo(typeLiteral, obj); } public T bindTo(TypeLiteral typeLiteral, T obj) { return (T) object(); } public Object object(Object... keys) { return get(keys).object(); } public abstract Object object(); public Map asMap() { return (Map) object(); } public List asList() { return (List) object(); } public T as(Class clazz, Object... keys) { return get(keys).as(clazz); } public T as(Class clazz) { return (T) object(); } public T as(TypeLiteral typeLiteral, Object... keys) { return get(keys).as(typeLiteral); } public T as(TypeLiteral typeLiteral) { return (T) object(); } public final boolean toBoolean(Object... keys) { return get(keys).toBoolean(); } public abstract boolean toBoolean(); public final int toInt(Object... keys) { return get(keys).toInt(); } public abstract int toInt(); public final long toLong(Object... keys) { return get(keys).toLong(); } public abstract long toLong(); public final float toFloat(Object... keys) { return get(keys).toFloat(); } public abstract float toFloat(); public final double toDouble(Object... keys) { return get(keys).toDouble(); } public abstract double toDouble(); public final String toString(Object... keys) { return get(keys).toString(); } public abstract String toString(); public int size() { return 0; } public Set keys() { return EMPTY_KEYS; } @Override public Iterator iterator() { return EMPTY_ITERATOR; } public EntryIterator entries() { return EMPTY_ENTRIES_ITERATOR; } public Any get(int index) { return new NotFoundAny(index, object()); } public Any get(Object key) { return new NotFoundAny(key, object()); } public final Any get(Object... keys) { return get(keys, 0); } public Any get(Object[] keys, int idx) { if (idx == keys.length) { return this; } return new NotFoundAny(keys, idx, object()); } public Any set(int newVal) { return wrap(newVal); } public Any set(long newVal) { return wrap(newVal); } public Any set(float newVal) { return wrap(newVal); } public Any set(double newVal) { return wrap(newVal); } public Any set(String newVal) { return wrap(newVal); } public JsonIterator parse() { throw new UnsupportedOperationException(); } public abstract void writeTo(JsonStream stream) throws IOException; protected JsonException reportUnexpectedType(ValueType toType) { throw new JsonException(String.format("can not convert %s to %s", valueType(), toType)); } public static Any lazyString(byte[] data, int head, int tail) { return new StringLazyAny(data, head, tail); } public static Any lazyDouble(byte[] data, int head, int tail) { return new DoubleLazyAny(data, head, tail); } public static Any lazyLong(byte[] data, int head, int tail) { return new LongLazyAny(data, head, tail); } public static Any lazyArray(byte[] data, int head, int tail) { return new ArrayLazyAny(data, head, tail); } public static Any lazyObject(byte[] data, int head, int tail) { return new ObjectLazyAny(data, head, tail); } public static Any wrap(int val) { return new IntAny(val); } public static Any wrap(long val) { return new LongAny(val); } public static Any wrap(float val) { return new FloatAny(val); } public static Any wrap(double val) { return new DoubleAny(val); } public static Any wrap(boolean val) { if (val) { return TrueAny.INSTANCE; } else { return FalseAny.INSTANCE; } } public static Any wrap(String val) { if (val == null) { return NullAny.INSTANCE; } return new StringAny(val); } public static Any wrap(Collection val) { if (val == null) { return NullAny.INSTANCE; } return new ListWrapperAny(new ArrayList(val)); } public static Any wrap(List val) { if (val == null) { return NullAny.INSTANCE; } return new ListWrapperAny(val); } public static Any wrap(Map val) { if (val == null) { return NullAny.INSTANCE; } return new MapWrapperAny(val); } public static Any wrap(Object val) { return CodegenAccess.wrap(val); } public static Any wrapNull() { return NullAny.INSTANCE; } public static Any rewrap(List val) { return new ArrayAny(val); } public static Any rewrap(Map val) { return new ObjectAny(val); } private final static int wildcardHashCode = Character.valueOf('*').hashCode(); private final static Character wildcard = '*'; protected boolean isWildcard(Object key) { return wildcardHashCode == key.hashCode() && wildcard.equals(key); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/ArrayAny.java000066400000000000000000000051011304664171100254520ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import java.io.IOException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; class ArrayAny extends Any { private final List val; public ArrayAny(List val) { this.val = val; } @Override public ValueType valueType() { return ValueType.ARRAY; } @Override public Object object() { return val; } @Override public void writeTo(JsonStream stream) throws IOException { stream.writeArrayStart(); Iterator iter = val.iterator(); if (!iter.hasNext()) { stream.writeArrayEnd(); return; } iter.next().writeTo(stream); while (iter.hasNext()) { stream.writeMore(); iter.next().writeTo(stream); } stream.writeArrayEnd(); } @Override public int size() { return val.size(); } @Override public Iterator iterator() { return val.iterator(); } @Override public Any get(int index) { try { return val.get(index); } catch (IndexOutOfBoundsException e) { return new NotFoundAny(index, object()); } } @Override public Any get(Object[] keys, int idx) { if (idx == keys.length) { return this; } Object key = keys[idx]; if (isWildcard(key)) { ArrayList result = new ArrayList(); for (Any element : val) { Any mapped = element.get(keys, idx + 1); if (mapped.valueType() != ValueType.INVALID) { result.add(mapped); } } return Any.rewrap(result); } try { return val.get((Integer) key).get(keys, idx + 1); } catch (IndexOutOfBoundsException e) { return new NotFoundAny(keys, idx, object()); } catch (ClassCastException e) { return new NotFoundAny(keys, idx, object()); } } @Override public String toString() { return JsonStream.serialize(this); } @Override public boolean toBoolean() { return !val.isEmpty(); } @Override public int toInt() { return val.size(); } @Override public long toLong() { return val.size(); } @Override public float toFloat() { return val.size(); } @Override public double toDouble() { return val.size(); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/ArrayLazyAny.java000066400000000000000000000161351304664171100263230ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.*; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; class ArrayLazyAny extends LazyAny { private final static TypeLiteral> typeLiteral = new TypeLiteral>(){}; private List cache; private int lastParsedPos; public ArrayLazyAny(byte[] data, int head, int tail) { super(data, head, tail); lastParsedPos = head; } @Override public ValueType valueType() { return ValueType.ARRAY; } @Override public Object object() { fillCache(); return cache; } @Override public boolean toBoolean() { try { return CodegenAccess.readArrayStart(parse()); } catch (IOException e) { throw new JsonException(e); } } @Override public int toInt() { return size(); } @Override public long toLong() { return size(); } @Override public float toFloat() { return size(); } @Override public double toDouble() { return size(); } @Override public int size() { fillCache(); return cache.size(); } @Override public Iterator iterator() { if (lastParsedPos == tail) { return cache.iterator(); } else { return new LazyIterator(); } } @Override public Any get(int index) { try { return fillCacheUntil(index); } catch (IndexOutOfBoundsException e) { return new NotFoundAny(index, object()); } } @Override public Any get(Object[] keys, int idx) { if (idx == keys.length) { return this; } Object key = keys[idx]; if (isWildcard(key)) { fillCache(); ArrayList result = new ArrayList(); for (Any element : cache) { Any mapped = element.get(keys, idx + 1); if (mapped.valueType() != ValueType.INVALID) { result.add(mapped); } } return Any.rewrap(result); } try { return fillCacheUntil((Integer) key).get(keys, idx + 1); } catch (IndexOutOfBoundsException e) { return new NotFoundAny(keys, idx, object()); } catch (ClassCastException e) { return new NotFoundAny(keys, idx, object()); } } private void fillCache() { if (lastParsedPos == tail) { return; } if (cache == null) { cache = new ArrayList(4); } try { JsonIterator iter = JsonIterator.tlsIter.get(); iter.reset(data, lastParsedPos, tail); if (lastParsedPos == head) { if (!CodegenAccess.readArrayStart(iter)) { lastParsedPos = tail; return; } cache.add(iter.readAny()); } while (CodegenAccess.nextToken(iter) == ',') { cache.add(iter.readAny()); } lastParsedPos = tail; } catch (IOException e) { throw new JsonException(e); } } private Any fillCacheUntil(int target) { if (lastParsedPos == tail) { return cache.get(target); } if (cache == null) { cache = new ArrayList(4); } int i = cache.size(); if (target < i) { return cache.get(target); } try { JsonIterator iter = JsonIterator.tlsIter.get(); iter.reset(data, lastParsedPos, tail); if (lastParsedPos == head) { if (!CodegenAccess.readArrayStart(iter)) { lastParsedPos = tail; throw new IndexOutOfBoundsException(); } Any element = iter.readAny(); cache.add(element); if (target == 0) { lastParsedPos = CodegenAccess.head(iter); return element; } i = 1; } while (CodegenAccess.nextToken(iter) == ',') { Any element = iter.readAny(); cache.add(element); if (i++ == target) { lastParsedPos = CodegenAccess.head(iter); return element; } } lastParsedPos = tail; } catch (IOException e) { throw new JsonException(e); } throw new IndexOutOfBoundsException(); } private class LazyIterator implements Iterator { private final int cacheSize; private int cachePos; public LazyIterator() { try { if (cache == null) { cache = new ArrayList(4); } if (lastParsedPos == head) { JsonIterator iter = JsonIterator.tlsIter.get(); iter.reset(data, lastParsedPos, tail); if (!CodegenAccess.readArrayStart(iter)) { lastParsedPos = tail; } else { lastParsedPos = CodegenAccess.head(iter); } } } catch (IOException e) { throw new JsonException(e); } cacheSize = cache.size(); cachePos = 0; } @Override public void remove() { throw new UnsupportedOperationException(); } @Override public boolean hasNext() { return cachePos != cacheSize || lastParsedPos != tail; } @Override public Any next() { try { return next_(); } catch (IOException e) { throw new JsonException(e); } } private Any next_() throws IOException { if (cachePos != cacheSize) { return cache.get(cachePos++); } JsonIterator iter = JsonIterator.tlsIter.get(); iter.reset(data, lastParsedPos, tail); Any element = iter.readAny(); cache.add(element); if (CodegenAccess.nextToken(iter) == ',') { lastParsedPos = CodegenAccess.head(iter); } else { lastParsedPos = tail; } return element; } } @Override public void writeTo(JsonStream stream) throws IOException { if (lastParsedPos == head) { super.writeTo(stream); } else { // there might be modification fillCache(); stream.writeVal(typeLiteral, cache); } } @Override public String toString() { if (lastParsedPos == head) { return super.toString(); } else { fillCache(); return JsonStream.serialize(cache); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/ArrayWrapperAny.java000066400000000000000000000100221304664171100270110ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import java.io.IOException; import java.lang.reflect.Array; import java.util.ArrayList; import java.util.Iterator; import java.util.List; class ArrayWrapperAny extends Any { private final Object val; private List cache; public ArrayWrapperAny(Object val) { this.val = val; } @Override public ValueType valueType() { return ValueType.ARRAY; } @Override public Object object() { fillCache(); return cache; } @Override public boolean toBoolean() { return size() != 0; } @Override public int toInt() { return size(); } @Override public long toLong() { return size(); } @Override public float toFloat() { return size(); } @Override public double toDouble() { return size(); } @Override public String toString() { if (cache == null) { return JsonStream.serialize(val); } else { fillCache(); return JsonStream.serialize(cache); } } @Override public void writeTo(JsonStream stream) throws IOException { if (cache == null) { stream.writeVal(val); } else { fillCache(); stream.writeVal(cache); } } @Override public int size() { return Array.getLength(val); } @Override public Any get(int index) { return fillCacheUntil(index); } @Override public Any get(Object[] keys, int idx) { if (idx == keys.length) { return this; } Object key = keys[idx]; if (isWildcard(key)) { fillCache(); ArrayList result = new ArrayList(); for (Any element : cache) { Any mapped = element.get(keys, idx + 1); if (mapped.valueType() != ValueType.INVALID) { result.add(mapped); } } return Any.rewrap(result); } try { return fillCacheUntil((Integer) key).get(keys, idx + 1); } catch (IndexOutOfBoundsException e) { return new NotFoundAny(keys, idx, object()); } catch (ClassCastException e) { return new NotFoundAny(keys, idx, object()); } } @Override public Iterator iterator() { return new WrapperIterator(); } private Any fillCacheUntil(int index) { if (cache == null) { cache = new ArrayList(); } if (index < cache.size()) { return cache.get(index); } for (int i = cache.size(); i < size(); i++) { Any element = Any.wrap(Array.get(val, i)); cache.add(element); if (index == i) { return element; } } return new NotFoundAny(index, val); } private void fillCache() { if (cache == null) { cache = new ArrayList(); } int size = size(); if (cache.size() == size) { return; } for (int i = cache.size(); i < size; i++) { Any element = Any.wrap(Array.get(val, i)); cache.add(element); } } private class WrapperIterator implements Iterator { private int index; private final int size; private WrapperIterator() { size = size(); } @Override public boolean hasNext() { return index < size; } @Override public Any next() { if (cache == null) { cache = new ArrayList(); } if (index == cache.size()) { cache.add(Any.wrap(Array.get(val, index))); } return cache.get(index++); } @Override public void remove() { throw new UnsupportedOperationException(); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/DoubleAny.java000066400000000000000000000021341304664171100256110ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; class DoubleAny extends Any { private double val; public DoubleAny(double val) { this.val = val; } @Override public ValueType valueType() { return ValueType.NUMBER; } @Override public Object object() { return val; } @Override public boolean toBoolean() { return val != 0; } @Override public int toInt() { return (int) val; } @Override public long toLong() { return (long) val; } @Override public float toFloat() { return (float) val; } @Override public double toDouble() { return val; } @Override public String toString() { return String.valueOf(val); } public Any set(double newVal) { this.val = newVal; return this; } @Override public void writeTo(JsonStream stream) throws IOException { stream.writeVal(val); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/DoubleLazyAny.java000066400000000000000000000023531304664171100264540ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.spi.JsonException; import com.jsoniter.ValueType; import java.io.IOException; class DoubleLazyAny extends LazyAny { private boolean isCached; private double cache; public DoubleLazyAny(byte[] data, int head, int tail) { super(data, head, tail); } @Override public ValueType valueType() { return ValueType.NUMBER; } @Override public Object object() { fillCache(); return cache; } @Override public boolean toBoolean() { fillCache(); return cache != 0; } @Override public int toInt() { fillCache(); return (int) cache; } @Override public long toLong() { fillCache(); return (long) cache; } @Override public float toFloat() { fillCache(); return (float) cache; } @Override public double toDouble() { fillCache(); return cache; } private void fillCache() { if (!isCached) { try { cache = parse().readDouble(); } catch (IOException e) { throw new JsonException(e); } isCached = true; } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/FalseAny.java000066400000000000000000000016331304664171100254340ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import java.io.IOException; class FalseAny extends Any { public final static FalseAny INSTANCE = new FalseAny(); @Override public ValueType valueType() { return ValueType.BOOLEAN; } @Override public Object object() { return Boolean.FALSE; } @Override public boolean toBoolean() { return false; } @Override public int toInt() { return 0; } @Override public long toLong() { return 0; } @Override public float toFloat() { return 0; } @Override public double toDouble() { return 0; } @Override public String toString() { return "false"; } @Override public void writeTo(JsonStream stream) throws IOException { stream.writeFalse(); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/FloatAny.java000066400000000000000000000021171304664171100254450ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; class FloatAny extends Any { private float val; public FloatAny(float val) { this.val = val; } @Override public ValueType valueType() { return ValueType.NUMBER; } @Override public Object object() { return val; } @Override public boolean toBoolean() { return val != 0; } @Override public int toInt() { return (int) val; } @Override public long toLong() { return (long) val; } @Override public float toFloat() { return val; } @Override public double toDouble() { return val; } @Override public String toString() { return String.valueOf(val); } public Any set(float newVal) { this.val = newVal; return this; } @Override public void writeTo(JsonStream stream) throws IOException { stream.writeVal(val); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/IntAny.java000066400000000000000000000020231304664171100251260ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import java.io.IOException; class IntAny extends Any { private int val; public IntAny(int val) { this.val = val; } @Override public ValueType valueType() { return ValueType.NUMBER; } @Override public Object object() { return val; } @Override public boolean toBoolean() { return val != 0; } @Override public int toInt() { return val; } @Override public long toLong() { return val; } @Override public float toFloat() { return val; } @Override public double toDouble() { return val; } @Override public String toString() { return String.valueOf(val); } public Any set(int newVal) { this.val = newVal; return this; } @Override public void writeTo(JsonStream stream) throws IOException { stream.writeVal(val); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/LazyAny.java000066400000000000000000000033121304664171100253150ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.spi.JsonException; import com.jsoniter.JsonIterator; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; abstract class LazyAny extends Any { protected final byte[] data; protected final int head; protected final int tail; public LazyAny(byte[] data, int head, int tail) { this.data = data; this.head = head; this.tail = tail; } public abstract ValueType valueType(); public final T bindTo(T obj) { try { return parse().read(obj); } catch (IOException e) { throw new JsonException(e); } } public final T bindTo(TypeLiteral typeLiteral, T obj) { try { return parse().read(typeLiteral, obj); } catch (IOException e) { throw new JsonException(e); } } public final T as(Class clazz) { try { return parse().read(clazz); } catch (IOException e) { throw new JsonException(e); } } public final T as(TypeLiteral typeLiteral) { try { return parse().read(typeLiteral); } catch (IOException e) { throw new JsonException(e); } } public String toString() { return new String(data, head, tail - head); } public final JsonIterator parse() { JsonIterator iter = JsonIterator.tlsIter.get(); iter.reset(data, head, tail); return iter; } @Override public void writeTo(JsonStream stream) throws IOException { stream.write(data, head, tail - head); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/ListWrapperAny.java000066400000000000000000000075411304664171100266620ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import java.io.IOException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; class ListWrapperAny extends Any { private final List val; private List cache; public ListWrapperAny(List val) { this.val = val; } @Override public ValueType valueType() { return ValueType.ARRAY; } @Override public Object object() { fillCache(); return cache; } @Override public boolean toBoolean() { return !val.isEmpty(); } @Override public int toInt() { return size(); } @Override public long toLong() { return size(); } @Override public float toFloat() { return size(); } @Override public double toDouble() { return size(); } @Override public String toString() { if (cache == null) { return JsonStream.serialize(val); } else { fillCache(); return JsonStream.serialize(cache); } } @Override public void writeTo(JsonStream stream) throws IOException { if (cache == null) { stream.writeVal(val); } else { fillCache(); stream.writeVal(cache); } } @Override public int size() { return val.size(); } @Override public Any get(int index) { return fillCacheUntil(index); } @Override public Any get(Object[] keys, int idx) { if (idx == keys.length) { return this; } Object key = keys[idx]; if (isWildcard(key)) { fillCache(); ArrayList result = new ArrayList(); for (Any element : cache) { Any mapped = element.get(keys, idx + 1); if (mapped.valueType() != ValueType.INVALID) { result.add(mapped); } } return Any.rewrap(result); } try { return fillCacheUntil((Integer) key).get(keys, idx + 1); } catch (IndexOutOfBoundsException e) { return new NotFoundAny(keys, idx, object()); } catch (ClassCastException e) { return new NotFoundAny(keys, idx, object()); } } @Override public Iterator iterator() { return new WrapperIterator(); } private void fillCache() { if (cache == null) { cache = new ArrayList(); } if (cache.size() == val.size()) { return; } for (int i = cache.size(); i < val.size(); i++) { Any element = Any.wrap(val.get(i)); cache.add(element); } } private Any fillCacheUntil(int index) { if (cache == null) { cache = new ArrayList(); } if (index < cache.size()) { return cache.get(index); } for (int i = cache.size(); i < val.size(); i++) { Any element = Any.wrap(val.get(i)); cache.add(element); if (index == i) { return element; } } return new NotFoundAny(index, val); } private class WrapperIterator implements Iterator { private int index; @Override public boolean hasNext() { return index < val.size(); } @Override public Any next() { if (cache == null) { cache = new ArrayList(); } if (index == cache.size()) { cache.add(Any.wrap(val.get(index))); } return cache.get(index++); } @Override public void remove() { throw new UnsupportedOperationException(); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/LongAny.java000066400000000000000000000021031304664171100252720ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; class LongAny extends Any { private long val; public LongAny(long val) { this.val = val; } @Override public ValueType valueType() { return ValueType.NUMBER; } @Override public Object object() { return val; } @Override public boolean toBoolean() { return val != 0; } @Override public int toInt() { return (int) val; } @Override public long toLong() { return val; } @Override public float toFloat() { return val; } @Override public double toDouble() { return val; } @Override public String toString() { return String.valueOf(val); } public Any set(long newVal) { this.val = newVal; return this; } @Override public void writeTo(JsonStream stream) throws IOException { stream.writeVal(val); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/LongLazyAny.java000066400000000000000000000023241304664171100261370ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.spi.JsonException; import com.jsoniter.ValueType; import java.io.IOException; class LongLazyAny extends LazyAny { private boolean isCached; private long cache; public LongLazyAny(byte[] data, int head, int tail) { super(data, head, tail); } @Override public ValueType valueType() { return ValueType.NUMBER; } @Override public Object object() { fillCache(); return cache; } @Override public boolean toBoolean() { fillCache(); return cache != 0; } @Override public int toInt() { fillCache(); return (int) cache; } @Override public long toLong() { fillCache(); return cache; } @Override public float toFloat() { fillCache(); return cache; } @Override public double toDouble() { fillCache(); return cache; } private void fillCache() { if (!isCached) { try { cache = parse().readLong(); } catch (IOException e) { throw new JsonException(e); } isCached = true; } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/MapWrapperAny.java000066400000000000000000000112661304664171100264630ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import java.io.IOException; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; class MapWrapperAny extends Any { private final Map val; private Map cache; public MapWrapperAny(Map val) { this.val = val; } @Override public ValueType valueType() { return ValueType.OBJECT; } @Override public Object object() { fillCache(); return cache; } @Override public boolean toBoolean() { return size() != 0; } @Override public int toInt() { return size(); } @Override public long toLong() { return size(); } @Override public float toFloat() { return size(); } @Override public double toDouble() { return size(); } @Override public String toString() { if (cache == null) { return JsonStream.serialize(val); } else { fillCache(); return JsonStream.serialize(cache); } } @Override public void writeTo(JsonStream stream) throws IOException { if (cache == null) { stream.writeVal(val); } else { fillCache(); stream.writeVal(cache); } } @Override public int size() { return val.size(); } @Override public Any get(Object key) { return fillCacheUntil(key); } @Override public Any get(Object[] keys, int idx) { if (idx == keys.length) { return this; } Object key = keys[idx]; if (isWildcard(key)) { fillCache(); HashMap result = new HashMap(); for (Map.Entry entry : cache.entrySet()) { Any mapped = entry.getValue().get(keys, idx + 1); if (mapped.valueType() != ValueType.INVALID) { result.put(entry.getKey(), mapped); } } return Any.rewrap(result); } Any child = fillCacheUntil(key); if (child == null) { return new NotFoundAny(keys, idx, object()); } return child.get(keys, idx + 1); } @Override public EntryIterator entries() { return new WrapperIterator(); } private Any fillCacheUntil(Object target) { if (cache == null) { cache = new HashMap(); } Any element = cache.get(target); if (element != null) { return element; } Set> entries = val.entrySet(); int targetHashcode = target.hashCode(); for (Map.Entry entry : entries) { String key = entry.getKey(); if (cache.containsKey(key)) { continue; } element = Any.wrap(entry.getValue()); cache.put(key, element); if (targetHashcode == key.hashCode() && target.equals(key)) { return element; } } return new NotFoundAny(target, val); } private void fillCache() { if (cache == null) { cache = new HashMap(); } Set> entries = val.entrySet(); for (Map.Entry entry : entries) { String key = entry.getKey(); if (cache.containsKey(key)) { continue; } Any element = Any.wrap(entry.getValue()); cache.put(key, element); } } private class WrapperIterator implements EntryIterator { private final Iterator> iter; private String key; private Any value; private WrapperIterator() { Set> entries = val.entrySet(); iter = entries.iterator(); } @Override public boolean next() { if (cache == null) { cache = new HashMap(); } if (!iter.hasNext()) { return false; } Map.Entry entry = iter.next(); key = entry.getKey(); value = cache.get(key); if (value == null) { value = Any.wrap(entry.getValue()); cache.put(key, value); } return true; } @Override public String key() { return key; } @Override public Any value() { return value; } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/NotFoundAny.java000066400000000000000000000035071304664171100261400ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.JsonException; import java.io.IOException; import java.util.Arrays; class NotFoundAny extends Any { private final JsonException exception; public NotFoundAny(Object[] keys, int idx, Object obj) { this.exception = new JsonException(String.format("Value not found: failed to get path %s, because #%s section of the path ( %s ) not found in %s", Arrays.toString(keys), idx, keys[idx], obj)); } public NotFoundAny(int index, Object obj) { this.exception = new JsonException(String.format("Value not found: failed to get index %s from %s", index, obj)); } public NotFoundAny(Object key, Object obj) { this.exception = new JsonException(String.format("Value not found: failed to get key %s from %s", key, obj)); } @Override public ValueType valueType() { return ValueType.INVALID; } @Override public Object object() { throw exception; } @Override public void writeTo(JsonStream stream) throws IOException { throw exception; } @Override public Any get(int index) { return this; } @Override public Any get(Object key) { return this; } @Override public Any get(Object[] keys, int idx) { return this; } @Override public boolean toBoolean() { return false; } @Override public int toInt() { return 0; } @Override public long toLong() { return 0; } @Override public float toFloat() { return 0; } @Override public double toDouble() { return 0; } @Override public String toString() { return ""; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/NullAny.java000066400000000000000000000016121304664171100253110ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import java.io.IOException; class NullAny extends Any { public final static NullAny INSTANCE = new NullAny(); @Override public ValueType valueType() { return ValueType.NULL; } @Override public Object object() { return null; } @Override public boolean toBoolean() { return false; } @Override public int toInt() { return 0; } @Override public long toLong() { return 0; } @Override public float toFloat() { return 0; } @Override public double toDouble() { return 0; } @Override public void writeTo(JsonStream stream) throws IOException { stream.writeNull(); } @Override public String toString() { return "null"; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/ObjectAny.java000066400000000000000000000062711304664171100256130ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import java.io.IOException; import java.util.HashMap; import java.util.Iterator; import java.util.Map; class ObjectAny extends Any { private final Map val; public ObjectAny(Map val) { this.val = val; } @Override public ValueType valueType() { return ValueType.OBJECT; } @Override public Object object() { return val; } @Override public void writeTo(JsonStream stream) throws IOException { stream.writeObjectStart(); boolean notFirst = false; for (Map.Entry entry : val.entrySet()) { if (notFirst) { stream.writeMore(); } else { notFirst = true; } stream.writeObjectField(entry.getKey()); entry.getValue().writeTo(stream); } stream.writeObjectEnd(); } @Override public boolean toBoolean() { return !val.isEmpty(); } @Override public int toInt() { return size(); } @Override public long toLong() { return size(); } @Override public float toFloat() { return size(); } @Override public double toDouble() { return size(); } @Override public String toString() { return JsonStream.serialize(this); } @Override public Any get(Object key) { Any element = val.get(key); if (element == null) { return new NotFoundAny(key, object()); } return element; } @Override public Any get(Object[] keys, int idx) { if (idx == keys.length) { return this; } Object key = keys[idx]; if (isWildcard(key)) { HashMap result = new HashMap(); for (Map.Entry entry : val.entrySet()) { Any mapped = entry.getValue().get(keys, idx + 1); if (mapped.valueType() != ValueType.INVALID) { result.put(entry.getKey(), mapped); } } return Any.rewrap(result); } Any element = val.get(key); if (element == null) { return new NotFoundAny(keys, idx, object()); } return element.get(keys, idx + 1); } @Override public EntryIterator entries() { return new IteratorAdapter(val.entrySet().iterator()); } public static class IteratorAdapter implements EntryIterator { private final Iterator> iter; private Map.Entry entry; public IteratorAdapter(Iterator> iter) { this.iter = iter; } @Override public boolean next() { if (iter.hasNext()) { entry = iter.next(); return true; } return false; } @Override public String key() { return entry.getKey(); } @Override public Any value() { return entry.getValue(); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/ObjectLazyAny.java000066400000000000000000000173771304664171100264640ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.*; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; class ObjectLazyAny extends LazyAny { private final static TypeLiteral> typeLiteral = new TypeLiteral>(){}; private Map cache; private int lastParsedPos; public ObjectLazyAny(byte[] data, int head, int tail) { super(data, head, tail); lastParsedPos = head; } @Override public ValueType valueType() { return ValueType.OBJECT; } @Override public Object object() { fillCache(); return cache; } @Override public boolean toBoolean() { try { return CodegenAccess.readObjectStart(parse()); } catch (IOException e) { throw new JsonException(e); } } @Override public int toInt() { return size(); } @Override public long toLong() { return size(); } @Override public float toFloat() { return size(); } @Override public double toDouble() { return size(); } @Override public int size() { fillCache(); return cache.size(); } @Override public Set keys() { fillCache(); return (Set) cache.keySet(); } @Override public Any get(Object key) { Any element = fillCacheUntil(key); if (element == null) { return new NotFoundAny(key, object()); } return element; } @Override public Any get(Object[] keys, int idx) { if (idx == keys.length) { return this; } Object key = keys[idx]; if (isWildcard(key)) { fillCache(); HashMap result = new HashMap(); for (Map.Entry entry : cache.entrySet()) { Any mapped = entry.getValue().get(keys, idx + 1); if (mapped.valueType() != ValueType.INVALID) { result.put(entry.getKey(), mapped); } } return Any.rewrap(result); } Any child = fillCacheUntil(key); if (child == null) { return new NotFoundAny(keys, idx, object()); } return child.get(keys, idx+1); } private Any fillCacheUntil(Object target) { if (lastParsedPos == tail) { return cache.get(target); } if (cache == null) { cache = new HashMap(4); } Any value = cache.get(target); if (value != null) { return value; } try { JsonIterator iter = JsonIterator.tlsIter.get(); iter.reset(data, lastParsedPos, tail); if (lastParsedPos == head) { if (!CodegenAccess.readObjectStart(iter)) { lastParsedPos = tail; return null; } String field = CodegenAccess.readObjectFieldAsString(iter); value = iter.readAny(); cache.put(field, value); if (field.hashCode() == target.hashCode() && field.equals(target)) { lastParsedPos = CodegenAccess.head(iter); return value; } } while (CodegenAccess.nextToken(iter) == ',') { String field = CodegenAccess.readObjectFieldAsString(iter); value = iter.readAny(); cache.put(field, value); if (field.hashCode() == target.hashCode() && field.equals(target)) { lastParsedPos = CodegenAccess.head(iter); return value; } } lastParsedPos = tail; return null; } catch (IOException e) { throw new JsonException(e); } } private void fillCache() { if (lastParsedPos == tail) { return; } if (cache == null) { cache = new HashMap(4); } try { JsonIterator iter = JsonIterator.tlsIter.get(); iter.reset(data, lastParsedPos, tail); if (lastParsedPos == head) { if (!CodegenAccess.readObjectStart(iter)) { lastParsedPos = tail; return; } String field = CodegenAccess.readObjectFieldAsString(iter); cache.put(field, iter.readAny()); } while (CodegenAccess.nextToken(iter) == ',') { String field = CodegenAccess.readObjectFieldAsString(iter); cache.put(field, iter.readAny()); } lastParsedPos = tail; } catch (IOException e) { throw new JsonException(e); } } @Override public EntryIterator entries() { return new LazyIterator(); } private class LazyIterator implements EntryIterator { private Iterator> mapIter; private String key; private Any value; public LazyIterator() { if (cache == null) { cache = new HashMap(); } mapIter = new HashMap(cache).entrySet().iterator(); try { if (lastParsedPos == head) { JsonIterator iter = JsonIterator.tlsIter.get(); iter.reset(data, lastParsedPos, tail); if (!CodegenAccess.readObjectStart(iter)) { lastParsedPos = tail; } else { lastParsedPos = CodegenAccess.head(iter); } } } catch (IOException e) { throw new JsonException(e); } } @Override public boolean next() { if (lastParsedPos == tail) { return false; } if (mapIter != null) { if (mapIter.hasNext()) { Map.Entry entry = mapIter.next(); key = entry.getKey(); value = entry.getValue(); return true; } else { mapIter = null; } } try { JsonIterator iter = JsonIterator.tlsIter.get(); iter.reset(data, lastParsedPos, tail); key = CodegenAccess.readObjectFieldAsString(iter); value = iter.readAny(); cache.put(key, value); if (CodegenAccess.nextToken(iter) == ',') { lastParsedPos = CodegenAccess.head(iter); } else { lastParsedPos = tail; } } catch (IOException e) { throw new JsonException(e); } return true; } @Override public String key() { return key; } @Override public Any value() { return value; } } @Override public void writeTo(JsonStream stream) throws IOException { if (lastParsedPos == head) { super.writeTo(stream); } else { // there might be modification fillCache(); stream.writeVal(typeLiteral, (Map) cache); } } @Override public String toString() { if (lastParsedPos == head) { return super.toString(); } else { fillCache(); return JsonStream.serialize(cache); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/StringAny.java000066400000000000000000000031171304664171100256470ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import java.io.IOException; class StringAny extends Any { private final static String FALSE = "false"; private String val; public StringAny(String val) { this.val = val; } @Override public ValueType valueType() { return ValueType.STRING; } @Override public Object object() { return val; } public Any set(String newVal) { val = newVal; return this; } @Override public void writeTo(JsonStream stream) throws IOException { stream.writeVal(val); } @Override public boolean toBoolean() { int len = val.length(); if (len == 0) { return false; } if (len == 5 && FALSE.equals(val)) { return false; } for (int i = 0; i < len; i++) { switch (val.charAt(i)) { case ' ': case '\t': case '\n': case '\r': continue; default: return true; } } return false; } @Override public int toInt() { return Integer.valueOf(val); } @Override public long toLong() { return Long.valueOf(val); } @Override public float toFloat() { return Float.valueOf(val); } @Override public double toDouble() { return Double.valueOf(val); } @Override public String toString() { return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/StringLazyAny.java000066400000000000000000000050061304664171100265060ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.CodegenAccess; import com.jsoniter.spi.JsonException; import com.jsoniter.JsonIterator; import com.jsoniter.ValueType; import java.io.IOException; class StringLazyAny extends LazyAny { private final static String FALSE = "false"; private String cache; public StringLazyAny(byte[] data, int head, int tail) { super(data, head, tail); } @Override public ValueType valueType() { return ValueType.STRING; } @Override public Object object() { fillCache(); return cache; } @Override public boolean toBoolean() { fillCache(); int len = cache.length(); if (len == 0) { return false; } if (len == 5 && FALSE.equals(cache)) { return false; } for (int i = 0; i < len; i++) { switch (cache.charAt(i)) { case ' ': case '\t': case '\n': case '\r': continue; default: return true; } } return false; } @Override public int toInt() { try { JsonIterator iter = parse(); CodegenAccess.nextToken(iter); return iter.readInt(); } catch (IOException e) { throw new JsonException(e); } } @Override public long toLong() { try { JsonIterator iter = parse(); CodegenAccess.nextToken(iter); return iter.readLong(); } catch (IOException e) { throw new JsonException(e); } } @Override public float toFloat() { try { JsonIterator iter = parse(); CodegenAccess.nextToken(iter); return iter.readFloat(); } catch (IOException e) { throw new JsonException(e); } } @Override public double toDouble() { try { JsonIterator iter = parse(); CodegenAccess.nextToken(iter); return iter.readDouble(); } catch (IOException e) { throw new JsonException(e); } } @Override public String toString() { fillCache(); return cache; } private void fillCache() { if (cache == null) { try { cache = parse().readString(); } catch (IOException e) { throw new JsonException(); } } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/any/TrueAny.java000066400000000000000000000016241304664171100253210ustar00rootroot00000000000000package com.jsoniter.any; import com.jsoniter.ValueType; import com.jsoniter.output.JsonStream; import java.io.IOException; class TrueAny extends Any { public final static TrueAny INSTANCE = new TrueAny(); @Override public ValueType valueType() { return ValueType.BOOLEAN; } @Override public Object object() { return Boolean.TRUE; } @Override public boolean toBoolean() { return true; } @Override public int toInt() { return 1; } @Override public long toLong() { return 1; } @Override public float toFloat() { return 1; } @Override public double toDouble() { return 1; } @Override public String toString() { return "true"; } @Override public void writeTo(JsonStream stream) throws IOException { stream.writeTrue(); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/extra/000077500000000000000000000000001304664171100234205ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/extra/Base64.java000066400000000000000000000253611304664171100253160ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.JsonIterator; import com.jsoniter.Slice; import com.jsoniter.output.JsonStream; import java.io.IOException; import java.util.Arrays; /** A very fast and memory efficient class to encode and decode to and from BASE64 in full accordance * with RFC 2045.

* On Windows XP sp1 with 1.4.2_04 and later ;), this encoder and decoder is about 10 times faster * on small arrays (10 - 1000 bytes) and 2-3 times as fast on larger arrays (10000 - 1000000 bytes) * compared to sun.misc.Encoder()/Decoder().

* * On byte arrays the encoder is about 20% faster than Jakarta Commons Base64 Codec for encode and * about 50% faster for decoding large arrays. This implementation is about twice as fast on very small * arrays (< 30 bytes). If source/destination is a String this * version is about three times as fast due to the fact that the Commons Codec result has to be recoded * to a String from byte[], which is very expensive.

* * This encode/decode algorithm doesn't create any temporary arrays as many other codecs do, it only * allocates the resulting array. This produces less garbage and it is possible to handle arrays twice * as large as algorithms that create a temporary array. (E.g. Jakarta Commons Codec). It is unknown * whether Sun's sun.misc.Encoder()/Decoder() produce temporary arrays but since performance * is quite low it probably does.

* * The encoder produces the same output as the Sun one except that the Sun's encoder appends * a trailing line separator if the last character isn't a pad. Unclear why but it only adds to the * length and is probably a side effect. Both are in conformance with RFC 2045 though.
* Commons codec seem to always att a trailing line separator.

* * Note! * The encode/decode method pairs (types) come in three versions with the exact same algorithm and * thus a lot of code redundancy. This is to not create any temporary arrays for transcoding to/from different * format types. The methods not used can simply be commented out.

* * There is also a "fast" version of all decode methods that works the same way as the normal ones, but * har a few demands on the decoded input. Normally though, these fast verions should be used if the source if * the input is known and it hasn't bee tampered with.

* * If you find the code useful or you find a bug, please send me a note at base64 @ miginfocom . com. * * Licence (BSD): * ============== * * Copyright (c) 2004, Mikael Grev, MiG InfoCom AB. (base64 @ miginfocom . com) * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list * of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this * list of conditions and the following disclaimer in the documentation and/or other * materials provided with the distribution. * Neither the name of the MiG InfoCom AB nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. * * @version 2.2 * @author Mikael Grev * Date: 2004-aug-02 * Time: 11:31:11 */ abstract class Base64 { private static final char[] CA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray(); static final byte[] BA; static final int[] IA = new int[256]; static { Arrays.fill(IA, -1); for (int i = 0, iS = CA.length; i < iS; i++) { IA[CA[i]] = i; } IA['='] = 0; BA = new byte[CA.length]; for (int i = 0; i < CA.length; i++) { BA[i] = (byte)CA[i]; } } static int encodeToChar(byte[] sArr, char[] dArr, final int start) { final int sLen = sArr.length; final int eLen = (sLen / 3) * 3; // Length of even 24-bits. final int dLen = ((sLen - 1) / 3 + 1) << 2; // Returned character count // Encode even 24-bits for (int s = 0, d = start; s < eLen;) { // Copy next three bytes into lower 24 bits of int, paying attension to sign. int i = (sArr[s++] & 0xff) << 16 | (sArr[s++] & 0xff) << 8 | (sArr[s++] & 0xff); // Encode the int into four chars dArr[d++] = CA[(i >>> 18) & 0x3f]; dArr[d++] = CA[(i >>> 12) & 0x3f]; dArr[d++] = CA[(i >>> 6) & 0x3f]; dArr[d++] = CA[i & 0x3f]; } // Pad and encode last bits if source isn't even 24 bits. int left = sLen - eLen; // 0 - 2. if (left > 0) { // Prepare the int int i = ((sArr[eLen] & 0xff) << 10) | (left == 2 ? ((sArr[sLen - 1] & 0xff) << 2) : 0); // Set last four chars dArr[start + dLen - 4] = CA[i >> 12]; dArr[start + dLen - 3] = CA[(i >>> 6) & 0x3f]; dArr[start + dLen - 2] = left == 2 ? CA[i & 0x3f] : '='; dArr[start + dLen - 1] = '='; } return dLen; } static int encodeToBytes(byte[] sArr, JsonStream stream) throws IOException { final int sLen = sArr.length; final int eLen = (sLen / 3) * 3; // Length of even 24-bits. final int dLen = ((sLen - 1) / 3 + 1) << 2; // Returned character count // Encode even 24-bits for (int s = 0; s < eLen;) { // Copy next three bytes into lower 24 bits of int, paying attension to sign. int i = (sArr[s++] & 0xff) << 16 | (sArr[s++] & 0xff) << 8 | (sArr[s++] & 0xff); // Encode the int into four chars stream.write(BA[(i >>> 18) & 0x3f], BA[(i >>> 12) & 0x3f], BA[(i >>> 6) & 0x3f], BA[i & 0x3f]); } // Pad and encode last bits if source isn't even 24 bits. int left = sLen - eLen; // 0 - 2. if (left > 0) { // Prepare the int int i = ((sArr[eLen] & 0xff) << 10) | (left == 2 ? ((sArr[sLen - 1] & 0xff) << 2) : 0); // Set last four chars stream.write(BA[i >> 12], BA[(i >>> 6) & 0x3f], left == 2 ? BA[i & 0x3f] : (byte)'=', (byte)'='); } return dLen; } static void encodeLongBits(long bits, JsonStream stream) throws IOException { int i = (int) bits; byte b1 = BA[(i >>> 18) & 0x3f]; byte b2 = BA[(i >>> 12) & 0x3f]; byte b3 = BA[(i >>> 6) & 0x3f]; byte b4 = BA[i & 0x3f]; stream.write((byte)'"', b1, b2, b3, b4); bits = bits >>> 24; i = (int) bits; b1 = BA[(i >>> 18) & 0x3f]; b2 = BA[(i >>> 12) & 0x3f]; b3 = BA[(i >>> 6) & 0x3f]; b4 = BA[i & 0x3f]; stream.write(b1, b2, b3, b4); bits = (bits >>> 24) << 2; i = (int) bits; b1 = BA[i >> 12]; b2 = BA[(i >>> 6) & 0x3f]; b3 = BA[i & 0x3f]; stream.write(b1, b2, b3, (byte)'"'); } static long decodeLongBits(JsonIterator iter) throws IOException { Slice slice = iter.readStringAsSlice(); if (slice.len() != 11) { throw iter.reportError("decodeLongBits", "must be 11 bytes for long bits encoded double"); } byte[] encoded = slice.data(); int sIx = slice.head(); long i = IA[encoded[sIx++]] << 18 | IA[encoded[sIx++]] << 12 | IA[encoded[sIx++]] << 6 | IA[encoded[sIx++]]; long bits = i; i = IA[encoded[sIx++]] << 18 | IA[encoded[sIx++]] << 12 | IA[encoded[sIx++]] << 6 | IA[encoded[sIx++]]; bits = i << 24 | bits; i = IA[encoded[sIx++]] << 12 | IA[encoded[sIx++]] << 6 | IA[encoded[sIx]]; bits = i << 46 | bits; return bits; } static int findEnd(final byte[] sArr, final int start) { for (int i = start; i < sArr.length; i++) if (IA[sArr[i] & 0xff] < 0) return i; return sArr.length; } private final static byte[] EMPTY_ARRAY = new byte[0]; static byte[] decodeFast(final byte[] sArr, final int start, final int end) { // Check special case int sLen = end - start; if (sLen == 0) return EMPTY_ARRAY; int sIx = start, eIx = end - 1; // Start and end index after trimming. // Trim illegal chars from start while (sIx < eIx && IA[sArr[sIx] & 0xff] < 0) sIx++; // Trim illegal chars from end while (eIx > 0 && IA[sArr[eIx] & 0xff] < 0) eIx--; // get the padding count (=) (0, 1 or 2) int pad = sArr[eIx] == '=' ? (sArr[eIx - 1] == '=' ? 2 : 1) : 0; // Count '=' at end. int cCnt = eIx - sIx + 1; // Content count including possible separators int sepCnt = sLen > 76 ? (sArr[76] == '\r' ? cCnt / 78 : 0) << 1 : 0; int len = ((cCnt - sepCnt) * 6 >> 3) - pad; // The number of decoded bytes byte[] dArr = new byte[len]; // Preallocate byte[] of exact length // Decode all but the last 0 - 2 bytes. int d = 0; for (int cc = 0, eLen = (len / 3) * 3; d < eLen;) { // Assemble three bytes into an int from four "valid" characters. int i = IA[sArr[sIx++]] << 18 | IA[sArr[sIx++]] << 12 | IA[sArr[sIx++]] << 6 | IA[sArr[sIx++]]; // Add the bytes dArr[d++] = (byte) (i >> 16); dArr[d++] = (byte) (i >> 8); dArr[d++] = (byte) i; // If line separator, jump over it. if (sepCnt > 0 && ++cc == 19) { sIx += 2; cc = 0; } } if (d < len) { // Decode last 1-3 bytes (incl '=') into 1-3 bytes int i = 0; for (int j = 0; sIx <= eIx - pad; j++) i |= IA[sArr[sIx++]] << (18 - j * 6); for (int r = 16; d < len; r -= 8) dArr[d++] = (byte) (i >> r); } return dArr; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/extra/Base64FloatSupport.java000066400000000000000000000176351304664171100277060ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.Slice; import com.jsoniter.any.Any; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.JsoniterSpi; import java.io.IOException; /** * encode float/double as base64, faster than PreciseFloatSupport */ public class Base64FloatSupport { final static int[] DIGITS = new int[256]; final static int[] HEX = new int[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; final static int[] DEC = new int[127]; static { for (int i = 0; i < 256; i++) { DIGITS[i] = HEX[i >> 4] << 8 | HEX[i & 0xf]; } DEC['0'] = 0; DEC['1'] = 1; DEC['2'] = 2; DEC['3'] = 3; DEC['4'] = 4; DEC['5'] = 5; DEC['6'] = 6; DEC['7'] = 7; DEC['8'] = 8; DEC['9'] = 9; DEC['a'] = 10; DEC['b'] = 11; DEC['c'] = 12; DEC['d'] = 13; DEC['e'] = 14; DEC['f'] = 15; } private static boolean enabled; public static synchronized void enableEncodersAndDecoders() { if (enabled) { throw new JsonException("BinaryFloatSupport.enable can only be called once"); } enabled = true; enableDecoders(); JsoniterSpi.registerTypeEncoder(Double.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { Double number = (Double) obj; long bits = Double.doubleToRawLongBits(number.doubleValue()); Base64.encodeLongBits(bits, stream); } @Override public Any wrap(Object obj) { Double number = (Double) obj; return Any.wrap(number.doubleValue()); } }); JsoniterSpi.registerTypeEncoder(double.class, new Encoder.DoubleEncoder() { @Override public void encodeDouble(double obj, JsonStream stream) throws IOException { long bits = Double.doubleToRawLongBits(obj); Base64.encodeLongBits(bits, stream); } }); JsoniterSpi.registerTypeEncoder(Float.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { Float number = (Float) obj; long bits = Double.doubleToRawLongBits(number.doubleValue()); Base64.encodeLongBits(bits, stream); } @Override public Any wrap(Object obj) { Float number = (Float) obj; return Any.wrap(number.floatValue()); } }); JsoniterSpi.registerTypeEncoder(float.class, new Encoder.FloatEncoder() { @Override public void encodeFloat(float obj, JsonStream stream) throws IOException { long bits = Double.doubleToRawLongBits(obj); Base64.encodeLongBits(bits, stream); } }); } public static void enableDecoders() { JsoniterSpi.registerTypeDecoder(Double.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { byte token = CodegenAccess.nextToken(iter); CodegenAccess.unreadByte(iter); if (token == '"') { return Double.longBitsToDouble(Base64.decodeLongBits(iter)); } else { return iter.readDouble(); } } }); JsoniterSpi.registerTypeDecoder(double.class, new Decoder.DoubleDecoder() { @Override public double decodeDouble(JsonIterator iter) throws IOException { byte token = CodegenAccess.nextToken(iter); CodegenAccess.unreadByte(iter); if (token == '"') { return Double.longBitsToDouble(Base64.decodeLongBits(iter)); }else { return iter.readDouble(); } } }); JsoniterSpi.registerTypeDecoder(Float.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { byte token = CodegenAccess.nextToken(iter); CodegenAccess.unreadByte(iter); if (token == '"') { return (float)Double.longBitsToDouble(Base64.decodeLongBits(iter)); }else { return (float)iter.readDouble(); } } }); JsoniterSpi.registerTypeDecoder(float.class, new Decoder.FloatDecoder() { @Override public float decodeFloat(JsonIterator iter) throws IOException { byte token = CodegenAccess.nextToken(iter); CodegenAccess.unreadByte(iter); if (token == '"') { return (float)Double.longBitsToDouble(Base64.decodeLongBits(iter)); }else { return (float)iter.readDouble(); } } }); } private static long readLongBits(JsonIterator iter) throws IOException { Slice slice = iter.readStringAsSlice(); byte[] data = slice.data(); long val = 0; for (int i = slice.head(); i < slice.tail(); i++) { byte b = data[i]; val = val << 4 | DEC[b]; } return val; } private static void writeLongBits(long bits, JsonStream stream) throws IOException { int digit = DIGITS[(int) (bits & 0xff)]; byte b2 = (byte) (digit >> 8); byte b1 = (byte) digit; bits = bits >> 8; if (bits == 0) { stream.write((byte) '"', b2, b1, (byte) '"'); } digit = DIGITS[(int) (bits & 0xff)]; byte b4 = (byte) (digit >> 8); byte b3 = (byte) digit; bits = bits >> 8; if (bits == 0) { stream.write((byte) '"', b4, b3, b2, b1, (byte) '"'); } digit = DIGITS[(int) (bits & 0xff)]; byte b6 = (byte) (digit >> 8); byte b5 = (byte) digit; bits = bits >> 8; if (bits == 0) { stream.write((byte) '"', b6, b5, b4, b3); stream.write(b2, b1, (byte) '"'); } digit = DIGITS[(int) (bits & 0xff)]; byte b8 = (byte) (digit >> 8); byte b7 = (byte) digit; bits = bits >> 8; if (bits == 0) { stream.write((byte) '"', b8, b7, b6, b5, b4); stream.write(b3, b2, b1, (byte) '"'); } digit = DIGITS[(int) (bits & 0xff)]; byte b10 = (byte) (digit >> 8); byte b9 = (byte) digit; bits = bits >> 8; if (bits == 0) { stream.write((byte) '"', b10, b9, b8, b7, b6); stream.write(b5, b4, b3, b2, b1, (byte) '"'); } digit = DIGITS[(int) (bits & 0xff)]; byte b12 = (byte) (digit >> 8); byte b11 = (byte) digit; bits = bits >> 8; if (bits == 0) { stream.write((byte) '"', b12, b11, b10, b9, b8); stream.write(b7, b6, b5, b4, b3, b2); stream.write(b1, (byte) '"'); } digit = DIGITS[(int) (bits & 0xff)]; byte b14 = (byte) (digit >> 8); byte b13 = (byte) digit; bits = bits >> 8; if (bits == 0) { stream.write((byte) '"', b14, b13, b12, b11, b10); stream.write(b9, b8, b7, b6, b5, b4); stream.write(b3, b2, b1, (byte) '"'); } digit = DIGITS[(int) (bits & 0xff)]; byte b16 = (byte) (digit >> 8); byte b15 = (byte) digit; stream.write((byte) '"', b16, b15, b14, b13, b12); stream.write(b11, b10, b9, b8, b7, b6); stream.write(b5, b4, b3, b2, b1, (byte) '"'); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/extra/Base64Support.java000066400000000000000000000026251304664171100267110ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.JsonIterator; import com.jsoniter.Slice; import com.jsoniter.any.Any; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.JsoniterSpi; import java.io.IOException; /** * byte[] <=> base64 */ public class Base64Support { private static boolean enabled; public static synchronized void enable() { if (enabled) { throw new JsonException("Base64Support.enable can only be called once"); } enabled = true; JsoniterSpi.registerTypeDecoder(byte[].class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { Slice slice = iter.readStringAsSlice(); return Base64.decodeFast(slice.data(), slice.head(), slice.tail()); } }); JsoniterSpi.registerTypeEncoder(byte[].class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { byte[] bytes = (byte[]) obj; stream.write('"'); Base64.encodeToBytes(bytes, stream); stream.write('"'); } @Override public Any wrap(Object obj) { return null; } }); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/extra/JdkDatetimeSupport.java000066400000000000000000000034531304664171100300520ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.spi.JsonException; import com.jsoniter.JsonIterator; import com.jsoniter.any.Any; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.JsoniterSpi; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; /** * there is no official way to encode/decode datetime, this is just an option for you */ public class JdkDatetimeSupport { private static String pattern; private final static ThreadLocal sdf = new ThreadLocal() { @Override protected SimpleDateFormat initialValue() { return new SimpleDateFormat(pattern); } }; public static synchronized void enable(String pattern) { if (JdkDatetimeSupport.pattern != null) { throw new JsonException("JdkDatetimeSupport.enable can only be called once"); } JdkDatetimeSupport.pattern = pattern; JsoniterSpi.registerTypeEncoder(Date.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal(sdf.get().format(obj)); } @Override public Any wrap(Object obj) { return Any.wrap(sdf.get().format(obj)); } }); JsoniterSpi.registerTypeDecoder(Date.class, new Decoder() { @Override public Object decode(JsonIterator iter) throws IOException { try { return sdf.get().parse(iter.readString()); } catch (ParseException e) { throw new JsonException(e); } } }); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/extra/NamingStrategySupport.java000066400000000000000000000103541304664171100306170ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.spi.*; public class NamingStrategySupport { public interface NamingStrategy { String translate(String input); } private static boolean enabled; public static synchronized void enable(final NamingStrategy namingStrategy) { if (enabled) { throw new JsonException("NamingStrategySupport.enable can only be called once"); } enabled = true; JsoniterSpi.registerExtension(new EmptyExtension() { @Override public void updateClassDescriptor(ClassDescriptor desc) { for (Binding binding : desc.allBindings()) { binding.name = namingStrategy.translate(binding.name); } } }); } public static NamingStrategy SNAKE_CASE = new NamingStrategy() { @Override public String translate(String input) { if (input == null) return input; // garbage in, garbage out int length = input.length(); StringBuilder result = new StringBuilder(length * 2); int resultLength = 0; boolean wasPrevTranslated = false; for (int i = 0; i < length; i++) { char c = input.charAt(i); if (i > 0 || c != '_') // skip first starting underscore { if (Character.isUpperCase(c)) { if (!wasPrevTranslated && resultLength > 0 && result.charAt(resultLength - 1) != '_') { result.append('_'); resultLength++; } c = Character.toLowerCase(c); wasPrevTranslated = true; } else { wasPrevTranslated = false; } result.append(c); resultLength++; } } return resultLength > 0 ? result.toString() : input; } }; public static NamingStrategy UPPER_CAMEL_CASE = new NamingStrategy() { @Override public String translate(String input) { if (input == null || input.length() == 0) { return input; // garbage in, garbage out } // Replace first lower-case letter with upper-case equivalent char c = input.charAt(0); char uc = Character.toUpperCase(c); if (c == uc) { return input; } StringBuilder sb = new StringBuilder(input); sb.setCharAt(0, uc); return sb.toString(); } }; public static NamingStrategy LOWER_CASE = new NamingStrategy() { @Override public String translate(String input) { return input.toLowerCase(); } }; public static NamingStrategy KEBAB_CASE = new NamingStrategy() { @Override public String translate(String input) { if (input == null) return input; // garbage in, garbage out int length = input.length(); if (length == 0) { return input; } StringBuilder result = new StringBuilder(length + (length >> 1)); int upperCount = 0; for (int i = 0; i < length; ++i) { char ch = input.charAt(i); char lc = Character.toLowerCase(ch); if (lc == ch) { // lower-case letter means we can get new word // but need to check for multi-letter upper-case (acronym), where assumption // is that the last upper-case char is start of a new word if (upperCount > 1) { // so insert hyphen before the last character now result.insert(result.length() - 1, '-'); } upperCount = 0; } else { // Otherwise starts new word, unless beginning of string if ((upperCount == 0) && (i > 0)) { result.append('-'); } ++upperCount; } result.append(lc); } return result.toString(); } }; } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/extra/PreciseFloatSupport.java000066400000000000000000000037751304664171100302540ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.spi.JsonException; import com.jsoniter.any.Any; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.JsoniterSpi; import java.io.IOException; /** * default float/double encoding will keep 6 decimal places * enable precise encoding will use JDK toString to be precise */ public class PreciseFloatSupport { private static boolean enabled; public static synchronized void enable() { if (enabled) { throw new JsonException("PreciseFloatSupport.enable can only be called once"); } enabled = true; JsoniterSpi.registerTypeEncoder(Double.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeRaw(obj.toString()); } @Override public Any wrap(Object obj) { Double number = (Double) obj; return Any.wrap(number.doubleValue()); } }); JsoniterSpi.registerTypeEncoder(double.class, new Encoder.DoubleEncoder() { @Override public void encodeDouble(double obj, JsonStream stream) throws IOException { stream.writeRaw(Double.toString(obj)); } }); JsoniterSpi.registerTypeEncoder(Float.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeRaw(obj.toString()); } @Override public Any wrap(Object obj) { Float number = (Float) obj; return Any.wrap(number.floatValue()); } }); JsoniterSpi.registerTypeEncoder(float.class, new Encoder.FloatEncoder() { @Override public void encodeFloat(float obj, JsonStream stream) throws IOException { stream.writeRaw(Float.toString(obj)); } }); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/000077500000000000000000000000001304664171100234645ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/MaybeEmptyArrayDecoder.java000066400000000000000000000012661304664171100306750ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.JsonIterator; import com.jsoniter.ValueType; import com.jsoniter.spi.Decoder; import java.io.IOException; public class MaybeEmptyArrayDecoder implements Decoder { @Override public Object decode(JsonIterator iter) throws IOException { if (iter.whatIsNext() == ValueType.ARRAY) { if (iter.readArray()) { throw iter.reportError("MaybeEmptyArrayDecoder", "this field is object. if input is array, it can only be empty"); } else { // empty array parsed as null return null; } } else { return iter.read(iter); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/MaybeStringDoubleDecoder.java000066400000000000000000000013221304664171100311720ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.spi.Decoder; import java.io.IOException; public class MaybeStringDoubleDecoder extends Decoder.DoubleDecoder { @Override public double decodeDouble(JsonIterator iter) throws IOException { byte c = CodegenAccess.nextToken(iter); if (c != '"') { CodegenAccess.unreadByte(iter); return iter.readDouble(); } double val = iter.readDouble(); c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringDoubleDecoder", "expect \", but found: " + (char) c); } return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/MaybeStringFloatDecoder.java000066400000000000000000000013121304664171100310240ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.spi.Decoder; import java.io.IOException; public class MaybeStringFloatDecoder extends Decoder.FloatDecoder { @Override public float decodeFloat(JsonIterator iter) throws IOException { byte c = CodegenAccess.nextToken(iter); if (c != '"') { CodegenAccess.unreadByte(iter); return iter.readFloat(); } float val = iter.readFloat(); c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringFloatDecoder", "expect \", but found: " + (char) c); } return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/MaybeStringIntDecoder.java000066400000000000000000000012721304664171100305160ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.spi.Decoder; import java.io.IOException; public class MaybeStringIntDecoder extends Decoder.IntDecoder { @Override public int decodeInt(JsonIterator iter) throws IOException { byte c = CodegenAccess.nextToken(iter); if (c != '"') { CodegenAccess.unreadByte(iter); return iter.readInt(); } int val = iter.readInt(); c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringIntDecoder", "expect \", but found: " + (char) c); } return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/MaybeStringLongDecoder.java000066400000000000000000000013021304664171100306550ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.spi.Decoder; import java.io.IOException; public class MaybeStringLongDecoder extends Decoder.LongDecoder { @Override public long decodeLong(JsonIterator iter) throws IOException { byte c = CodegenAccess.nextToken(iter); if (c != '"') { CodegenAccess.unreadByte(iter); return iter.readLong(); } long val = iter.readLong(); c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringLongDecoder", "expect \", but found: " + (char) c); } return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/MaybeStringShortDecoder.java000066400000000000000000000013121304664171100310560ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.spi.Decoder; import java.io.IOException; public class MaybeStringShortDecoder extends Decoder.ShortDecoder { @Override public short decodeShort(JsonIterator iter) throws IOException { byte c = CodegenAccess.nextToken(iter); if (c != '"') { CodegenAccess.unreadByte(iter); return iter.readShort(); } short val = iter.readShort(); c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringShortDecoder", "expect \", but found: " + (char) c); } return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/StringDoubleDecoder.java000066400000000000000000000013331304664171100302160ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.spi.Decoder; import java.io.IOException; public class StringDoubleDecoder extends Decoder.DoubleDecoder { @Override public double decodeDouble(JsonIterator iter) throws IOException { byte c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringDoubleDecoder", "expect \", but found: " + (char) c); } double val = iter.readDouble(); c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringDoubleDecoder", "expect \", but found: " + (char) c); } return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/StringFloatDecoder.java000066400000000000000000000013231304664171100300500ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.spi.Decoder; import java.io.IOException; public class StringFloatDecoder extends Decoder.FloatDecoder { @Override public float decodeFloat(JsonIterator iter) throws IOException { byte c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringFloatDecoder", "expect \", but found: " + (char) c); } float val = iter.readFloat(); c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringFloatDecoder", "expect \", but found: " + (char) c); } return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/StringIntDecoder.java000066400000000000000000000013031304664171100275330ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.spi.Decoder; import java.io.IOException; public class StringIntDecoder extends Decoder.IntDecoder { @Override public int decodeInt(JsonIterator iter) throws IOException { byte c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringIntDecoder", "expect \", but found: " + (char) c); } int val = iter.readInt(); c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringIntDecoder", "expect \", but found: " + (char) c); } return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/StringLongDecoder.java000066400000000000000000000013131304664171100277010ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.spi.Decoder; import java.io.IOException; public class StringLongDecoder extends Decoder.LongDecoder { @Override public long decodeLong(JsonIterator iter) throws IOException { byte c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringLongDecoder", "expect \", but found: " + (char) c); } long val = iter.readLong(); c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringLongDecoder", "expect \", but found: " + (char) c); } return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/fuzzy/StringShortDecoder.java000066400000000000000000000013231304664171100301020ustar00rootroot00000000000000package com.jsoniter.fuzzy; import com.jsoniter.CodegenAccess; import com.jsoniter.JsonIterator; import com.jsoniter.spi.Decoder; import java.io.IOException; public class StringShortDecoder extends Decoder.ShortDecoder { @Override public short decodeShort(JsonIterator iter) throws IOException { byte c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringShortDecoder", "expect \", but found: " + (char) c); } short val = iter.readShort(); c = CodegenAccess.nextToken(iter); if (c != '"') { throw iter.reportError("StringShortDecoder", "expect \", but found: " + (char) c); } return val; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/000077500000000000000000000000001304664171100236355ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/AsciiOutputStream.java000066400000000000000000000022041304664171100301230ustar00rootroot00000000000000package com.jsoniter.output; import java.io.IOException; import java.io.OutputStream; class AsciiOutputStream extends OutputStream { private char[] buf = new char[4096]; private int count = 0; @Override public void write(byte[] b, int off, int len) throws IOException { int i = off; for (; ; ) { for (; i < off + len && count < buf.length; i++) { buf[count++] = (char) b[i]; } if (count == buf.length) { char[] newBuf = new char[buf.length * 2]; System.arraycopy(buf, 0, newBuf, 0, buf.length); buf = newBuf; } else { break; } } } @Override public void write(int b) throws IOException { if (count == buf.length) { char[] newBuf = new char[buf.length * 2]; System.arraycopy(buf, 0, newBuf, 0, buf.length); buf = newBuf; } buf[count++] = (char) b; } @Override public String toString() { return new String(buf, 0, count); } public void reset() { count = 0; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/Codegen.java000066400000000000000000000171571304664171100260570ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.Extension; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.TypeLiteral; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; import java.lang.reflect.Modifier; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.*; class Codegen { static EncodingMode mode = EncodingMode.REFLECTION_MODE; static boolean isDoingStaticCodegen; // only read/write when generating code with synchronized protection private final static Map generatedSources = new HashMap(); private volatile static Map reflectionEncoders = new HashMap(); static { String envMode = System.getenv("JSONITER_ENCODING_MODE"); if (envMode != null) { mode = EncodingMode.valueOf(envMode); } } public static void setMode(EncodingMode mode) { Codegen.mode = mode; } public static Encoder getReflectionEncoder(String cacheKey, Type type) { Encoder encoder = CodegenImplNative.NATIVE_ENCODERS.get(type); if (encoder != null) { return encoder; } encoder = reflectionEncoders.get(cacheKey); if (encoder != null) { return encoder; } synchronized (Codegen.class) { encoder = reflectionEncoders.get(cacheKey); if (encoder != null) { return encoder; } Type[] typeArgs = new Type[0]; Class clazz; if (type instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) type; clazz = (Class) pType.getRawType(); typeArgs = pType.getActualTypeArguments(); } else { clazz = (Class) type; } encoder = ReflectionEncoderFactory.create(clazz, typeArgs); HashMap copy = new HashMap(reflectionEncoders); copy.put(cacheKey, encoder); reflectionEncoders = copy; return encoder; } } public static Encoder getEncoder(String cacheKey, Type type) { Encoder encoder = JsoniterSpi.getEncoder(cacheKey); if (encoder != null) { return encoder; } return gen(cacheKey, type); } private static synchronized Encoder gen(String cacheKey, Type type) { Encoder encoder = JsoniterSpi.getEncoder(cacheKey); if (encoder != null) { return encoder; } List extensions = JsoniterSpi.getExtensions(); for (Extension extension : extensions) { encoder = extension.createEncoder(cacheKey, type); if (encoder != null) { JsoniterSpi.addNewEncoder(cacheKey, encoder); return encoder; } } encoder = CodegenImplNative.NATIVE_ENCODERS.get(type); if (encoder != null) { JsoniterSpi.addNewEncoder(cacheKey, encoder); return encoder; } Type[] typeArgs = new Type[0]; Class clazz; if (type instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) type; clazz = (Class) pType.getRawType(); typeArgs = pType.getActualTypeArguments(); } else { clazz = (Class) type; } if (mode == EncodingMode.REFLECTION_MODE) { encoder = ReflectionEncoderFactory.create(clazz, typeArgs); JsoniterSpi.addNewEncoder(cacheKey, encoder); return encoder; } if (!isDoingStaticCodegen) { try { encoder = (Encoder) Class.forName(cacheKey).newInstance(); JsoniterSpi.addNewEncoder(cacheKey, encoder); return encoder; } catch (Exception e) { if (mode == EncodingMode.STATIC_MODE) { throw new JsonException("static gen should provide the encoder we need, but failed to create the encoder", e); } } } clazz = chooseAccessibleSuper(clazz); CodegenResult source = genSource(cacheKey, clazz, typeArgs); try { generatedSources.put(cacheKey, source); if (isDoingStaticCodegen) { staticGen(clazz, cacheKey, source); } else { encoder = DynamicCodegen.gen(clazz, cacheKey, source); } JsoniterSpi.addNewEncoder(cacheKey, encoder); return encoder; } catch (Exception e) { String msg = "failed to generate encoder for: " + type + " with " + Arrays.toString(typeArgs) + ", exception: " + e; msg = msg + "\n" + source; throw new JsonException(msg, e); } } private static Class chooseAccessibleSuper(Class clazz) { if (Modifier.isPublic(clazz.getModifiers())) { return clazz; } return chooseAccessibleSuper(clazz.getSuperclass()); } public static CodegenResult getGeneratedSource(String cacheKey) { return generatedSources.get(cacheKey); } private static void staticGen(Class clazz, String cacheKey, CodegenResult source) throws IOException { createDir(cacheKey); String fileName = cacheKey.replace('.', '/') + ".java"; FileOutputStream fileOutputStream = new FileOutputStream(fileName); try { OutputStreamWriter writer = new OutputStreamWriter(fileOutputStream); try { staticGen(clazz, cacheKey, writer, source); } finally { writer.close(); } } finally { fileOutputStream.close(); } } private static void staticGen(Class clazz, String cacheKey, OutputStreamWriter writer, CodegenResult source) throws IOException { String className = cacheKey.substring(cacheKey.lastIndexOf('.') + 1); String packageName = cacheKey.substring(0, cacheKey.lastIndexOf('.')); writer.write("package " + packageName + ";\n"); writer.write("public class " + className + " extends com.jsoniter.spi.EmptyEncoder {\n"); writer.write(source.generateWrapperCode(clazz)); writer.write(source.toString()); writer.write("}\n"); } private static void createDir(String cacheKey) { String[] parts = cacheKey.split("\\."); File parent = new File("."); for (int i = 0; i < parts.length - 1; i++) { String part = parts[i]; File current = new File(parent, part); current.mkdir(); parent = current; } } private static CodegenResult genSource(String cacheKey, Class clazz, Type[] typeArgs) { if (clazz.isArray()) { return CodegenImplArray.genArray(cacheKey, clazz); } if (Map.class.isAssignableFrom(clazz)) { return CodegenImplMap.genMap(cacheKey, clazz, typeArgs); } if (Collection.class.isAssignableFrom(clazz)) { return CodegenImplArray.genCollection(cacheKey, clazz, typeArgs); } if (clazz.isEnum()) { return CodegenImplNative.genEnum(clazz); } return CodegenImplObject.genObject(clazz); } public static void staticGenEncoders(TypeLiteral[] typeLiterals) { isDoingStaticCodegen = true; for (TypeLiteral typeLiteral : typeLiterals) { gen(typeLiteral.getEncoderCacheKey(), typeLiteral.getType()); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/CodegenAccess.java000066400000000000000000000056361304664171100272000ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.*; import com.jsoniter.any.Any; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; public class CodegenAccess { public static void writeVal(String cacheKey, Object obj, JsonStream stream) throws IOException { JsoniterSpi.getEncoder(cacheKey).encode(obj, stream); } public static void writeVal(String cacheKey, boolean obj, JsonStream stream) throws IOException { Encoder.BooleanEncoder encoder = (Encoder.BooleanEncoder) JsoniterSpi.getEncoder(cacheKey); encoder.encodeBoolean(obj, stream); } public static void writeVal(String cacheKey, byte obj, JsonStream stream) throws IOException { Encoder.ShortEncoder encoder = (Encoder.ShortEncoder) JsoniterSpi.getEncoder(cacheKey); encoder.encodeShort(obj, stream); } public static void writeVal(String cacheKey, short obj, JsonStream stream) throws IOException { Encoder.ShortEncoder encoder = (Encoder.ShortEncoder) JsoniterSpi.getEncoder(cacheKey); encoder.encodeShort(obj, stream); } public static void writeVal(String cacheKey, int obj, JsonStream stream) throws IOException { Encoder.IntEncoder encoder = (Encoder.IntEncoder) JsoniterSpi.getEncoder(cacheKey); encoder.encodeInt(obj, stream); } public static void writeVal(String cacheKey, char obj, JsonStream stream) throws IOException { Encoder.IntEncoder encoder = (Encoder.IntEncoder) JsoniterSpi.getEncoder(cacheKey); encoder.encodeInt(obj, stream); } public static void writeVal(String cacheKey, long obj, JsonStream stream) throws IOException { Encoder.LongEncoder encoder = (Encoder.LongEncoder) JsoniterSpi.getEncoder(cacheKey); encoder.encodeLong(obj, stream); } public static void writeVal(String cacheKey, float obj, JsonStream stream) throws IOException { Encoder.FloatEncoder encoder = (Encoder.FloatEncoder) JsoniterSpi.getEncoder(cacheKey); encoder.encodeFloat(obj, stream); } public static void writeVal(String cacheKey, double obj, JsonStream stream) throws IOException { Encoder.DoubleEncoder encoder = (Encoder.DoubleEncoder) JsoniterSpi.getEncoder(cacheKey); encoder.encodeDouble(obj, stream); } public static void writeStringWithoutQuote(String obj, JsonStream stream) throws IOException { StreamImplString.writeStringWithoutQuote(stream, obj); } public static void staticGenEncoders(TypeLiteral[] typeLiterals) { Codegen.staticGenEncoders(typeLiterals); } public static Any wrap(Object val) { if (val == null) { return Any.wrapNull(); } Class clazz = val.getClass(); String cacheKey = TypeLiteral.create(clazz).getEncoderCacheKey(); return Codegen.getReflectionEncoder(cacheKey, clazz).wrap(val); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/CodegenImplArray.java000066400000000000000000000134561304664171100276760ustar00rootroot00000000000000package com.jsoniter.output; import java.lang.reflect.Type; import java.util.*; class CodegenImplArray { public static CodegenResult genArray(String cacheKey, Class clazz) { Class compType = clazz.getComponentType(); if (compType.isArray()) { throw new IllegalArgumentException("nested array not supported: " + clazz.getCanonicalName()); } boolean isCollectionValueNullable = true; if (cacheKey.endsWith("__value_not_nullable")) { isCollectionValueNullable = false; } if (compType.isPrimitive()) { isCollectionValueNullable = false; } CodegenResult ctx = new CodegenResult(); ctx.append("public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException {"); ctx.append(String.format("%s[] arr = (%s[])obj;", compType.getCanonicalName(), compType.getCanonicalName())); ctx.append("if (arr.length == 0) { return; }"); ctx.buffer('['); ctx.append("int i = 0;"); ctx.append(String.format("%s e = arr[i++];", compType.getCanonicalName())); if (isCollectionValueNullable) { ctx.append("if (e == null) { stream.writeNull(); } else {"); CodegenImplNative.genWriteOp(ctx, "e", compType, true); ctx.append("}"); } else { CodegenImplNative.genWriteOp(ctx, "e", compType, false); } ctx.append("while (i < arr.length) {"); ctx.append("stream.write(',');"); ctx.append("e = arr[i++];"); if (isCollectionValueNullable) { ctx.append("if (e == null) { stream.writeNull(); } else {"); CodegenImplNative.genWriteOp(ctx, "e", compType, true); ctx.append("}"); } else { CodegenImplNative.genWriteOp(ctx, "e", compType, false); } ctx.append("}"); ctx.buffer(']'); ctx.append("}"); return ctx; } public static CodegenResult genCollection(String cacheKey, Class clazz, Type[] typeArgs) { Type compType = Object.class; if (typeArgs.length == 0) { // default to List } else if (typeArgs.length == 1) { compType = typeArgs[0]; } else { throw new IllegalArgumentException( "can not bind to generic collection without argument types, " + "try syntax like TypeLiteral>{}"); } if (clazz == List.class) { clazz = ArrayList.class; } else if (clazz == Set.class) { clazz = HashSet.class; } if (List.class.isAssignableFrom(clazz)) { return genList(cacheKey, clazz, compType); } else { return genCollection(cacheKey, clazz, compType); } } private static CodegenResult genList(String cacheKey, Class clazz, Type compType) { boolean isCollectionValueNullable = true; if (cacheKey.endsWith("__value_not_nullable")) { isCollectionValueNullable = false; } CodegenResult ctx = new CodegenResult(); ctx.append("public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException {"); ctx.append("java.util.List list = (java.util.List)obj;"); ctx.append("int size = list.size();"); ctx.append("if (size == 0) { return; }"); ctx.buffer('['); ctx.append("java.lang.Object e = list.get(0);"); if (isCollectionValueNullable) { ctx.append("if (e == null) { stream.writeNull(); } else {"); CodegenImplNative.genWriteOp(ctx, "e", compType, true); ctx.append("}"); } else { CodegenImplNative.genWriteOp(ctx, "e", compType, false); } ctx.append("for (int i = 1; i < size; i++) {"); ctx.append("stream.write(',');"); ctx.append("e = list.get(i);"); if (isCollectionValueNullable) { ctx.append("if (e == null) { stream.writeNull(); } else {"); CodegenImplNative.genWriteOp(ctx, "e", compType, true); ctx.append("}"); } else { CodegenImplNative.genWriteOp(ctx, "e", compType, false); } ctx.append("}"); ctx.buffer(']'); ctx.append("}"); return ctx; } private static CodegenResult genCollection(String cacheKey, Class clazz, Type compType) { boolean isCollectionValueNullable = true; if (cacheKey.endsWith("__value_not_nullable")) { isCollectionValueNullable = false; } CodegenResult ctx = new CodegenResult(); ctx.append("public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException {"); ctx.append("java.util.Iterator iter = ((java.util.Collection)obj).iterator();"); ctx.append("if (!iter.hasNext()) { return; }"); ctx.buffer('['); ctx.append("java.lang.Object e = iter.next();"); if (isCollectionValueNullable) { ctx.append("if (e == null) { stream.writeNull(); } else {"); CodegenImplNative.genWriteOp(ctx, "e", compType, true); ctx.append("}"); } else { CodegenImplNative.genWriteOp(ctx, "e", compType, false); } ctx.append("while (iter.hasNext()) {"); ctx.append("stream.write(',');"); ctx.append("e = iter.next();"); if (isCollectionValueNullable) { ctx.append("if (e == null) { stream.writeNull(); } else {"); CodegenImplNative.genWriteOp(ctx, "e", compType, true); ctx.append("}"); } else { CodegenImplNative.genWriteOp(ctx, "e", compType, false); } ctx.append("}"); ctx.buffer(']'); ctx.append("}"); return ctx; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/CodegenImplMap.java000066400000000000000000000051661304664171100273340ustar00rootroot00000000000000package com.jsoniter.output; import java.lang.reflect.Type; import java.util.Collection; class CodegenImplMap { public static CodegenResult genMap(String cacheKey, Class clazz, Type[] typeArgs) { boolean isCollectionValueNullable = true; if (cacheKey.endsWith("__value_not_nullable")) { isCollectionValueNullable = false; } Type keyType = String.class; Type valueType = Object.class; if (typeArgs.length == 0) { // default to Map } else if (typeArgs.length == 2) { keyType = typeArgs[0]; valueType = typeArgs[1]; } else { throw new IllegalArgumentException( "can not bind to generic collection without argument types, " + "try syntax like TypeLiteral>{}"); } if (keyType != String.class) { throw new IllegalArgumentException("map key must be String"); } CodegenResult ctx = new CodegenResult(); ctx.append("public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException {"); ctx.append("if (obj == null) { stream.writeNull(); return; }"); ctx.append("java.util.Map map = (java.util.Map)obj;"); ctx.append("java.util.Iterator iter = map.entrySet().iterator();"); ctx.append("if(!iter.hasNext()) { return; }"); ctx.append("java.util.Map.Entry entry = (java.util.Map.Entry)iter.next();"); ctx.buffer('{'); ctx.append("stream.writeVal((String)entry.getKey());"); ctx.buffer(':'); if (isCollectionValueNullable) { ctx.append("if (entry.getValue() == null) { stream.writeNull(); } else {"); CodegenImplNative.genWriteOp(ctx, "entry.getValue()", valueType, true); ctx.append("}"); } else { CodegenImplNative.genWriteOp(ctx, "entry.getValue()", valueType, false); } ctx.append("while(iter.hasNext()) {"); ctx.append("entry = (java.util.Map.Entry)iter.next();"); ctx.buffer(','); ctx.append("stream.writeObjectField((String)entry.getKey());"); if (isCollectionValueNullable) { ctx.append("if (entry.getValue() == null) { stream.writeNull(); } else {"); CodegenImplNative.genWriteOp(ctx, "entry.getValue()", valueType, true); ctx.append("}"); } else { CodegenImplNative.genWriteOp(ctx, "entry.getValue()", valueType, false); } ctx.append("}"); ctx.buffer('}'); ctx.append("}"); return ctx; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/CodegenImplNative.java000066400000000000000000000265761304664171100300550ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.spi.JsonException; import com.jsoniter.any.Any; import com.jsoniter.spi.*; import java.io.IOException; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.math.BigDecimal; import java.math.BigInteger; import java.util.HashMap; import java.util.IdentityHashMap; import java.util.Map; class CodegenImplNative { public static final Map NATIVE_ENCODERS = new IdentityHashMap() {{ put(boolean.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Boolean) obj); } @Override public Any wrap(Object obj) { Boolean val = (Boolean) obj; return Any.wrap((boolean) val); } }); put(Boolean.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Boolean) obj); } @Override public Any wrap(Object obj) { Boolean val = (Boolean) obj; return Any.wrap((boolean) val); } }); put(byte.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal(((Byte) obj).shortValue()); } @Override public Any wrap(Object obj) { Byte val = (Byte) obj; return Any.wrap((int) val); } }); put(Byte.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal(((Byte) obj).shortValue()); } @Override public Any wrap(Object obj) { Byte val = (Byte) obj; return Any.wrap((int) val); } }); put(short.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Short) obj); } @Override public Any wrap(Object obj) { Short val = (Short) obj; return Any.wrap((int) val); } }); put(Short.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Short) obj); } @Override public Any wrap(Object obj) { Short val = (Short) obj; return Any.wrap((int) val); } }); put(int.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Integer) obj); } @Override public Any wrap(Object obj) { Integer val = (Integer) obj; return Any.wrap((int) val); } }); put(Integer.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Integer) obj); } @Override public Any wrap(Object obj) { Integer val = (Integer) obj; return Any.wrap((int) val); } }); put(char.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal(((Character) obj).charValue()); } @Override public Any wrap(Object obj) { Character val = (Character) obj; return Any.wrap((int) val); } }); put(Character.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal(((Character) obj).charValue()); } @Override public Any wrap(Object obj) { Character val = (Character) obj; return Any.wrap((int) val); } }); put(long.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Long) obj); } @Override public Any wrap(Object obj) { Long val = (Long) obj; return Any.wrap((long) val); } }); put(Long.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Long) obj); } @Override public Any wrap(Object obj) { Long val = (Long) obj; return Any.wrap((long) val); } }); put(float.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Float) obj); } @Override public Any wrap(Object obj) { Float val = (Float) obj; return Any.wrap((float) val); } }); put(Float.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Float) obj); } @Override public Any wrap(Object obj) { Float val = (Float) obj; return Any.wrap((float) val); } }); put(double.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Double) obj); } @Override public Any wrap(Object obj) { Double val = (Double) obj; return Any.wrap((double) val); } }); put(Double.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((Double) obj); } @Override public Any wrap(Object obj) { Double val = (Double) obj; return Any.wrap((double) val); } }); put(String.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.writeVal((String) obj); } @Override public Any wrap(Object obj) { String val = (String) obj; return Any.wrap(val); } }); put(Object.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { if (obj != null && obj.getClass() == Object.class) { stream.writeEmptyObject(); return; } stream.writeVal(obj); } @Override public Any wrap(Object obj) { if (obj != null && obj.getClass() == Object.class) { return Any.rewrap(new HashMap()); } return CodegenAccess.wrap(obj); } }); put(BigDecimal.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { BigDecimal val = (BigDecimal) obj; stream.writeRaw(val.toString()); } @Override public Any wrap(Object obj) { return Any.wrap(obj.toString()); } }); put(BigInteger.class, new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { BigInteger val = (BigInteger) obj; stream.writeRaw(val.toString()); } @Override public Any wrap(Object obj) { return Any.wrap(obj.toString()); } }); }}; public static void genWriteOp(CodegenResult ctx, String code, Type valueType, boolean isNullable) { genWriteOp(ctx, code, valueType, isNullable, true); } public static void genWriteOp(CodegenResult ctx, String code, Type valueType, boolean isNullable, boolean isCollectionValueNullable) { String cacheKey = TypeLiteral.create(valueType).getEncoderCacheKey(); if (JsoniterSpi.getEncoder(cacheKey) == null) { if (!isNullable && String.class == valueType) { ctx.buffer('"'); ctx.append(String.format("com.jsoniter.output.CodegenAccess.writeStringWithoutQuote((java.lang.String)%s, stream);", code)); ctx.buffer('"'); return; } if (NATIVE_ENCODERS.containsKey(valueType)) { ctx.append(String.format("stream.writeVal((%s)%s);", getTypeName(valueType), code)); return; } } if (!isCollectionValueNullable) { cacheKey = cacheKey + "__value_not_nullable"; } Codegen.getEncoder(cacheKey, valueType); CodegenResult generatedSource = Codegen.getGeneratedSource(cacheKey); if (generatedSource != null) { if (isNullable) { ctx.appendBuffer(); ctx.append(CodegenResult.bufferToWriteOp(generatedSource.prelude)); ctx.append(String.format("%s.encode_((%s)%s, stream);", cacheKey, getTypeName(valueType), code)); ctx.append(CodegenResult.bufferToWriteOp(generatedSource.epilogue)); } else { ctx.buffer(generatedSource.prelude); ctx.append(String.format("%s.encode_((%s)%s, stream);", cacheKey, getTypeName(valueType), code)); ctx.buffer(generatedSource.epilogue); } } else { ctx.append(String.format("com.jsoniter.output.CodegenAccess.writeVal(\"%s\", (%s)%s, stream);", cacheKey, getTypeName(valueType), code)); } } public static String getTypeName(Type fieldType) { if (fieldType instanceof Class) { Class clazz = (Class) fieldType; return clazz.getCanonicalName(); } else if (fieldType instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) fieldType; Class clazz = (Class) pType.getRawType(); return clazz.getCanonicalName(); } else { throw new JsonException("unsupported type: " + fieldType); } } public static CodegenResult genEnum(Class clazz) { CodegenResult ctx = new CodegenResult(); ctx.append(String.format("public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException {", clazz.getCanonicalName())); ctx.append("if (obj == null) { stream.writeNull(); return; }"); ctx.buffer('"'); ctx.append("stream.writeRaw(obj.toString());"); ctx.buffer('"'); ctx.append("}"); return ctx; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/CodegenImplObject.java000066400000000000000000000122011304664171100300110ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.*; import com.jsoniter.CodegenAccess; import com.jsoniter.spi.*; import java.lang.reflect.Method; import java.util.*; class CodegenImplObject { public static CodegenResult genObject(Class clazz) { CodegenResult ctx = new CodegenResult(); ClassDescriptor desc = JsoniterSpi.getEncodingClassDescriptor(clazz, false); HashMap bindings = new HashMap(); for (Binding binding : desc.allEncoderBindings()) { for (String toName : binding.toNames) { bindings.put(toName, binding); } } ArrayList toNames = new ArrayList(bindings.keySet()); Collections.sort(toNames, new Comparator() { @Override public int compare(String o1, String o2) { int x = CodegenAccess.calcHash(o1); int y = CodegenAccess.calcHash(o2); return (x < y) ? -1 : ((x == y) ? 0 : 1); } }); ctx.append(String.format("public static void encode_(%s obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException {", clazz.getCanonicalName())); if (hasFieldOutput(desc)) { int notFirst = 0; ctx.buffer('{'); for (String toName : toNames) { notFirst = genField(ctx, bindings.get(toName), toName, notFirst); } for (Method unwrapper : desc.unWrappers) { notFirst = appendComma(ctx, notFirst); ctx.append(String.format("obj.%s(stream);", unwrapper.getName())); } ctx.buffer('}'); } else { ctx.buffer("{}"); } ctx.append("}"); return ctx; } private static boolean hasFieldOutput(ClassDescriptor desc) { if (!desc.unWrappers.isEmpty()) { return true; } for (Binding binding : desc.allEncoderBindings()) { if (binding.toNames.length > 0) { return true; } } return false; } private static int genField(CodegenResult ctx, Binding binding, String toName, int notFirst) { String fieldCacheKey = binding.encoderCacheKey(); Encoder encoder = JsoniterSpi.getEncoder(fieldCacheKey); boolean isCollectionValueNullable = binding.isCollectionValueNullable; Class valueClazz; String valueAccessor; if (binding.field != null) { valueClazz = binding.field.getType(); valueAccessor = "obj." + binding.field.getName(); } else { valueClazz = binding.method.getReturnType(); valueAccessor = "obj." + binding.method.getName() + "()"; } if (!supportCollectionValueNullable(valueClazz)) { isCollectionValueNullable = true; } boolean nullable = !valueClazz.isPrimitive(); if (!binding.isNullable) { nullable = false; } if (nullable) { if (binding.shouldOmitNull) { if (notFirst == 0) { // no previous field notFirst = 2; // maybe ctx.append("boolean notFirst = false;"); } ctx.append(String.format("if (%s != null) {", valueAccessor)); notFirst = appendComma(ctx, notFirst); ctx.append(CodegenResult.bufferToWriteOp("\"" + toName + "\":")); } else { notFirst = appendComma(ctx, notFirst); ctx.buffer('"'); ctx.buffer(toName); ctx.buffer('"'); ctx.buffer(':'); ctx.append(String.format("if (%s == null) { stream.writeNull(); } else {", valueAccessor)); } } else { notFirst = appendComma(ctx, notFirst); ctx.buffer('"'); ctx.buffer(toName); ctx.buffer('"'); ctx.buffer(':'); } if (encoder == null) { CodegenImplNative.genWriteOp(ctx, valueAccessor, binding.valueType, nullable, isCollectionValueNullable); } else { ctx.append(String.format("com.jsoniter.output.CodegenAccess.writeVal(\"%s\", %s, stream);", fieldCacheKey, valueAccessor)); } if (nullable) { ctx.append("}"); } return notFirst; } private static int appendComma(CodegenResult ctx, int notFirst) { if (notFirst == 1) { // definitely not first ctx.buffer(','); } else if (notFirst == 2) { // maybe not first, previous field is omitNull ctx.append("if (notFirst) { stream.write(','); } else { notFirst = true; }"); } else { // this is the first, do not write comma notFirst = 1; } return notFirst; } private static boolean supportCollectionValueNullable(Class clazz) { if (clazz.isArray()) { return true; } if (Map.class.isAssignableFrom(clazz)) { return true; } if (Collection.class.isAssignableFrom(clazz)) { return true; } return false; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/CodegenResult.java000066400000000000000000000071661304664171100272550ustar00rootroot00000000000000package com.jsoniter.output; class CodegenResult { String prelude = null; // first String epilogue = null; // last private StringBuilder lines = new StringBuilder(); private StringBuilder buffered = new StringBuilder(); public static String bufferToWriteOp(String buffered) { if (buffered == null) { return ""; } if (buffered.length() == 1) { return String.format("stream.write((byte)'%s');", escape(buffered.charAt(0))); } else if (buffered.length() == 2) { return String.format("stream.write((byte)'%s', (byte)'%s');", escape(buffered.charAt(0)), escape(buffered.charAt(1))); } else if (buffered.length() == 3) { return String.format("stream.write((byte)'%s', (byte)'%s', (byte)'%s');", escape(buffered.charAt(0)), escape(buffered.charAt(1)), escape(buffered.charAt(2))); } else if (buffered.length() == 4) { return String.format("stream.write((byte)'%s', (byte)'%s', (byte)'%s', (byte)'%s');", escape(buffered.charAt(0)), escape(buffered.charAt(1)), escape(buffered.charAt(2)), escape(buffered.charAt(3))); } else { StringBuilder escaped = new StringBuilder(); for (int i = 0; i < buffered.length(); i++) { char c = buffered.charAt(i); if (c == '"') { escaped.append('\\'); } escaped.append(c); } return String.format("stream.writeRaw(\"%s\", %s);", escaped.toString(), buffered.length()); } } private static String escape(char c) { if (c == '"') { return "\\\""; } if (c == '\\') { return "\\\\"; } return String.valueOf(c); } public void append(String str) { if (str.contains("stream")) { // maintain the order of write op // must flush now appendBuffer(); } lines.append(str); lines.append("\n"); } public void buffer(char c) { buffered.append(c); } public void buffer(String s) { if (s == null) { return; } buffered.append(s); } public void flushBuffer() { if (buffered.length() == 0) { return; } if (prelude == null) { prelude = buffered.toString(); } else { epilogue = buffered.toString(); } buffered.setLength(0); } public String toString() { return lines.toString(); } public void appendBuffer() { flushBuffer(); if (epilogue != null) { lines.append(bufferToWriteOp(epilogue)); lines.append("\n"); epilogue = null; } } public String generateWrapperCode(Class clazz) { flushBuffer(); StringBuilder lines = new StringBuilder(); append(lines, "public void encode(Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException {"); append(lines, "if (obj == null) { stream.writeNull(); return; }"); if (prelude != null) { append(lines, CodegenResult.bufferToWriteOp(prelude)); } append(lines, String.format("encode_((%s)obj, stream);", clazz.getCanonicalName())); if (epilogue != null) { append(lines, CodegenResult.bufferToWriteOp(epilogue)); } append(lines, "}"); return lines.toString(); } private static void append(StringBuilder lines, String line) { lines.append(line); lines.append('\n'); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/DynamicCodegen.java000066400000000000000000000024671304664171100273620ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.EmptyEncoder; import com.jsoniter.spi.Encoder; import com.sun.org.apache.xml.internal.utils.StringBufferPool; import javassist.*; class DynamicCodegen { static ClassPool pool = ClassPool.getDefault(); static { pool.insertClassPath(new ClassClassPath(Encoder.class)); } public static Encoder gen(Class clazz, String cacheKey, CodegenResult source) throws Exception { source.flushBuffer(); CtClass ctClass = pool.makeClass(cacheKey); ctClass.setInterfaces(new CtClass[]{pool.get(Encoder.class.getName())}); ctClass.setSuperclass(pool.get(EmptyEncoder.class.getName())); String staticCode = source.toString(); CtMethod staticMethod = CtNewMethod.make(staticCode, ctClass); ctClass.addMethod(staticMethod); String wrapperCode = source.generateWrapperCode(clazz); if ("true".equals(System.getenv("JSONITER_DEBUG"))) { System.out.println(">>> " + cacheKey); System.out.println(wrapperCode); System.out.println(staticCode); } CtMethod interfaceMethod = CtNewMethod.make(wrapperCode, ctClass); ctClass.addMethod(interfaceMethod); return (Encoder) ctClass.toClass().newInstance(); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/EncodingMode.java000066400000000000000000000004321304664171100270320ustar00rootroot00000000000000package com.jsoniter.output; public enum EncodingMode { /** * dynamically codegen */ DYNAMIC_MODE, /** * statically codegen */ STATIC_MODE, /** * decoding only using reflection, do not need code generation */ REFLECTION_MODE } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/JsonStream.java000066400000000000000000000241231304664171100265670ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.spi.JsonException; import com.jsoniter.any.Any; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.io.OutputStream; public class JsonStream extends OutputStream { public static int defaultIndentionStep = 0; public int indentionStep = defaultIndentionStep; private int indention = 0; private OutputStream out; byte buf[]; int count; public JsonStream(OutputStream out, int bufSize) { if (bufSize < 32) { throw new JsonException("buffer size must be larger than 32: " + bufSize); } this.out = out; this.buf = new byte[bufSize]; } public void reset(OutputStream out) { this.out = out; this.count = 0; } public final void write(int b) throws IOException { if (count == buf.length) { flushBuffer(); } buf[count++] = (byte) b; } public final void write(byte b1, byte b2) throws IOException { if (count >= buf.length - 1) { flushBuffer(); } buf[count++] = b1; buf[count++] = b2; } public final void write(byte b1, byte b2, byte b3) throws IOException { if (count >= buf.length - 2) { flushBuffer(); } buf[count++] = b1; buf[count++] = b2; buf[count++] = b3; } public final void write(byte b1, byte b2, byte b3, byte b4) throws IOException { if (count >= buf.length - 3) { flushBuffer(); } buf[count++] = b1; buf[count++] = b2; buf[count++] = b3; buf[count++] = b4; } public final void write(byte b1, byte b2, byte b3, byte b4, byte b5) throws IOException { if (count >= buf.length - 4) { flushBuffer(); } buf[count++] = b1; buf[count++] = b2; buf[count++] = b3; buf[count++] = b4; buf[count++] = b5; } public final void write(byte b1, byte b2, byte b3, byte b4, byte b5, byte b6) throws IOException { if (count >= buf.length - 5) { flushBuffer(); } buf[count++] = b1; buf[count++] = b2; buf[count++] = b3; buf[count++] = b4; buf[count++] = b5; buf[count++] = b6; } public final void write(byte b[], int off, int len) throws IOException { if (len >= buf.length - count) { if (len >= buf.length) { /* If the request length exceeds the size of the output buffer, flush the output buffer and then write the data directly. In this way buffered streams will cascade harmlessly. */ flushBuffer(); out.write(b, off, len); return; } flushBuffer(); } System.arraycopy(b, off, buf, count, len); count += len; } public void flush() throws IOException { flushBuffer(); out.flush(); } @Override public void close() throws IOException { if (count > 0) { flushBuffer(); } out.close(); this.out = null; count = 0; } final void flushBuffer() throws IOException { out.write(buf, 0, count); count = 0; } public final void writeVal(String val) throws IOException { if (val == null) { writeNull(); } else { StreamImplString.writeString(this, val); } } public final void writeRaw(String val) throws IOException { writeRaw(val, val.length()); } public final void writeRaw(String val, int remaining) throws IOException { int i = 0; for (; ; ) { int available = buf.length - count; if (available < remaining) { remaining -= available; int j = i + available; val.getBytes(i, j, buf, count); count = buf.length; flushBuffer(); i = j; } else { int j = i + remaining; val.getBytes(i, j, buf, count); count += remaining; return; } } } public final void writeVal(Boolean val) throws IOException { if (val == null) { writeNull(); } else { if (val) { writeTrue(); } else { writeFalse(); } } } public final void writeVal(boolean val) throws IOException { if (val) { writeTrue(); } else { writeFalse(); } } public final void writeTrue() throws IOException { write((byte) 't', (byte) 'r', (byte) 'u', (byte) 'e'); } public final void writeFalse() throws IOException { write((byte) 'f', (byte) 'a', (byte) 'l', (byte) 's', (byte) 'e'); } public final void writeVal(Short val) throws IOException { if (val == null) { writeNull(); } else { writeVal(val.intValue()); } } public final void writeVal(short val) throws IOException { writeVal((int) val); } public final void writeVal(Integer val) throws IOException { if (val == null) { writeNull(); } else { writeVal(val.intValue()); } } public final void writeVal(int val) throws IOException { StreamImplNumber.writeInt(this, val); } public final void writeVal(Long val) throws IOException { if (val == null) { writeNull(); } else { writeVal(val.longValue()); } } public final void writeVal(long val) throws IOException { StreamImplNumber.writeLong(this, val); } public final void writeVal(Float val) throws IOException { if (val == null) { writeNull(); } else { writeVal(val.floatValue()); } } public final void writeVal(float val) throws IOException { StreamImplNumber.writeFloat(this, val); } public final void writeVal(Double val) throws IOException { if (val == null) { writeNull(); } else { writeVal(val.doubleValue()); } } public final void writeVal(double val) throws IOException { StreamImplNumber.writeDouble(this, val); } public final void writeVal(Any val) throws IOException { val.writeTo(this); } public final void writeNull() throws IOException { write((byte) 'n', (byte) 'u', (byte) 'l', (byte) 'l'); } public final void writeEmptyObject() throws IOException { write((byte) '{', (byte) '}'); } public final void writeEmptyArray() throws IOException { write((byte) '[', (byte) ']'); } public final void writeArrayStart() throws IOException { indention += indentionStep; write('['); writeIndention(); } public final void writeMore() throws IOException { write(','); writeIndention(); } private void writeIndention() throws IOException { writeIndention(0); } private void writeIndention(int delta) throws IOException { if (indention == 0) { return; } write('\n'); int toWrite = indention - delta; int i = 0; for (; ; ) { for (; i < toWrite && count < buf.length; i++) { buf[count++] = ' '; } if (i == toWrite) { break; } else { flushBuffer(); } } } public final void writeArrayEnd() throws IOException { writeIndention(indentionStep); indention -= indentionStep; write(']'); } public final void writeObjectStart() throws IOException { indention += indentionStep; write('{'); writeIndention(); } public final void writeObjectField(String field) throws IOException { writeVal(field); write(':'); } public final void writeObjectEnd() throws IOException { writeIndention(indentionStep); indention -= indentionStep; write('}'); } public final void writeVal(Object obj) throws IOException { if (obj == null) { writeNull(); return; } Class clazz = obj.getClass(); String cacheKey = TypeLiteral.create(clazz).getEncoderCacheKey(); Codegen.getEncoder(cacheKey, clazz).encode(obj, this); } public final void writeVal(TypeLiteral typeLiteral, T obj) throws IOException { if (null == obj) { writeNull(); } else { Codegen.getEncoder(typeLiteral.getEncoderCacheKey(), typeLiteral.getType()).encode(obj, this); } } private final static ThreadLocal tlsStream = new ThreadLocal() { @Override protected JsonStream initialValue() { return new JsonStream(null, 4096); } }; public static void serialize(Object obj, OutputStream out) { JsonStream stream = tlsStream.get(); try { try { stream.reset(out); stream.writeVal(obj); } finally { stream.close(); } } catch (IOException e) { throw new JsonException(e); } } private final static ThreadLocal tlsAsciiOutputStream = new ThreadLocal() { @Override protected AsciiOutputStream initialValue() { return new AsciiOutputStream(); } }; public static String serialize(Object obj) { AsciiOutputStream asciiOutputStream = tlsAsciiOutputStream.get(); asciiOutputStream.reset(); serialize(obj, asciiOutputStream); return asciiOutputStream.toString(); } public static void setMode(EncodingMode mode) { Codegen.setMode(mode); } public static void registerNativeEncoder(Class clazz, Encoder encoder) { CodegenImplNative.NATIVE_ENCODERS.put(clazz, encoder); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/ReflectionArrayEncoder.java000066400000000000000000000021741304664171100310750ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.any.Any; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.lang.reflect.Array; import java.lang.reflect.Type; class ReflectionArrayEncoder implements Encoder { private final TypeLiteral compTypeLiteral; public ReflectionArrayEncoder(Class clazz, Type[] typeArgs) { compTypeLiteral = TypeLiteral.create(clazz.getComponentType()); } @Override public void encode(Object obj, JsonStream stream) throws IOException { if (null == obj) { stream.writeNull(); return; } int len = Array.getLength(obj); if (len == 0) { stream.writeEmptyArray(); return; } stream.writeArrayStart(); stream.writeVal(compTypeLiteral, Array.get(obj, 0)); for (int i = 1; i < len; i++) { stream.writeMore(); stream.writeVal(compTypeLiteral, Array.get(obj, i)); } stream.writeArrayEnd(); } @Override public Any wrap(Object obj) { return Any.wrapArray(obj); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/ReflectionCollectionEncoder.java000066400000000000000000000025301304664171100321060ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.any.Any; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.lang.reflect.Type; import java.util.Collection; import java.util.Iterator; class ReflectionCollectionEncoder implements Encoder { private final TypeLiteral compTypeLiteral; public ReflectionCollectionEncoder(Class clazz, Type[] typeArgs) { if (typeArgs.length > 0) { compTypeLiteral = TypeLiteral.create(typeArgs[0]); } else { compTypeLiteral = TypeLiteral.create(Object.class); } } @Override public void encode(Object obj, JsonStream stream) throws IOException { if (null == obj) { stream.writeNull(); return; } Collection col = (Collection) obj; Iterator iter = col.iterator(); if (!iter.hasNext()) { stream.writeEmptyArray(); return; } stream.writeArrayStart(); stream.writeVal(compTypeLiteral, iter.next()); while (iter.hasNext()) { stream.writeMore(); stream.writeVal(compTypeLiteral, iter.next()); } stream.writeArrayEnd(); } @Override public Any wrap(Object obj) { Collection col = (Collection) obj; return Any.wrap(col); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/ReflectionEncoderFactory.java000066400000000000000000000016211304664171100314220ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.spi.Encoder; import java.lang.reflect.Type; import java.util.Collection; import java.util.List; import java.util.Map; public class ReflectionEncoderFactory { public static Encoder create(Class clazz, Type... typeArgs) { if (clazz.isArray()) { return new ReflectionArrayEncoder(clazz, typeArgs); } if (List.class.isAssignableFrom(clazz)) { return new ReflectionListEncoder(clazz, typeArgs); } if (Collection.class.isAssignableFrom(clazz)) { return new ReflectionCollectionEncoder(clazz, typeArgs); } if (Map.class.isAssignableFrom(clazz)) { return new ReflectionMapEncoder(clazz, typeArgs); } if (clazz.isEnum()) { return new ReflectionEnumEncoder(clazz); } return new ReflectionObjectEncoder(clazz); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/ReflectionEnumEncoder.java000066400000000000000000000010021304664171100307100ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.any.Any; import com.jsoniter.spi.Encoder; import java.io.IOException; class ReflectionEnumEncoder implements Encoder { public ReflectionEnumEncoder(Class clazz) { } @Override public void encode(Object obj, JsonStream stream) throws IOException { stream.write('"'); stream.writeRaw(obj.toString()); stream.write('"'); } @Override public Any wrap(Object obj) { return Any.wrap(obj.toString()); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/ReflectionListEncoder.java000066400000000000000000000023721304664171100307320ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.any.Any; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.lang.reflect.Type; import java.util.List; class ReflectionListEncoder implements Encoder { private final TypeLiteral compTypeLiteral; public ReflectionListEncoder(Class clazz, Type[] typeArgs) { if (typeArgs.length > 0) { compTypeLiteral = TypeLiteral.create(typeArgs[0]); } else { compTypeLiteral = TypeLiteral.create(Object.class); } } @Override public void encode(Object obj, JsonStream stream) throws IOException { if (null == obj) { stream.writeNull(); return; } List list = (List) obj; if (list.isEmpty()) { stream.writeEmptyArray(); return; } stream.writeArrayStart(); stream.writeVal(compTypeLiteral, list.get(0)); for (int i = 1; i < list.size(); i++) { stream.writeMore(); stream.writeVal(compTypeLiteral, list.get(i)); } stream.writeArrayEnd(); } @Override public Any wrap(Object obj) { List col = (List) obj; return Any.wrap(col); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/ReflectionMapEncoder.java000066400000000000000000000026121304664171100305310ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.any.Any; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.TypeLiteral; import java.io.IOException; import java.lang.reflect.Type; import java.util.HashMap; import java.util.Map; class ReflectionMapEncoder implements Encoder { private final TypeLiteral valueTypeLiteral; public ReflectionMapEncoder(Class clazz, Type[] typeArgs) { if (typeArgs.length > 1) { valueTypeLiteral = TypeLiteral.create(typeArgs[1]); } else { valueTypeLiteral = TypeLiteral.create(Object.class); } } @Override public void encode(Object obj, JsonStream stream) throws IOException { if (obj == null) { stream.writeNull(); return; } Map map = (Map) obj; stream.writeObjectStart(); boolean notFirst = false; for (Map.Entry entry : map.entrySet()) { if (notFirst) { stream.writeMore(); } else { notFirst = true; } stream.writeObjectField(entry.getKey()); stream.writeVal(valueTypeLiteral, entry.getValue()); } stream.writeObjectEnd(); } @Override public Any wrap(Object obj) { Map map = (Map) obj; return Any.wrap(map); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/ReflectionObjectEncoder.java000066400000000000000000000071001304664171100312170ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.spi.JsonException; import com.jsoniter.any.Any; import com.jsoniter.spi.Binding; import com.jsoniter.spi.ClassDescriptor; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.JsoniterSpi; import java.io.IOException; import java.lang.reflect.Method; import java.util.HashMap; class ReflectionObjectEncoder implements Encoder { private final ClassDescriptor desc; public ReflectionObjectEncoder(Class clazz) { desc = JsoniterSpi.getEncodingClassDescriptor(clazz, true); for (Binding binding : desc.allEncoderBindings()) { if (binding.encoder == null) { // the field encoder might be registered directly binding.encoder = JsoniterSpi.getEncoder(binding.encoderCacheKey()); } } } @Override public void encode(Object obj, JsonStream stream) throws IOException { try { enocde_(obj, stream); } catch (Exception e) { throw new JsonException(e); } } @Override public Any wrap(Object obj) { HashMap copied = new HashMap(); try { for (Binding field : desc.fields) { Object val = field.field.get(obj); for (String toName : field.toNames) { copied.put(toName, val); } } for (Binding getter : desc.getters) { Object val = getter.method.invoke(obj); for (String toName : getter.toNames) { copied.put(toName, val); } } } catch (Exception e) { throw new JsonException(e); } return Any.wrap(copied); } private void enocde_(Object obj, JsonStream stream) throws Exception { if (obj == null) { stream.writeNull(); return; } stream.writeObjectStart(); boolean notFirst = false; for (Binding field : desc.fields) { Object val = field.field.get(obj); for (String toName : field.toNames) { if (!(field.shouldOmitNull && val == null)) { if (notFirst) { stream.writeMore(); } else { notFirst = true; } stream.writeObjectField(toName); if (field.encoder != null) { field.encoder.encode(val, stream); } else { stream.writeVal(val); } } } } for (Binding getter : desc.getters) { Object val = getter.method.invoke(obj); for (String toName : getter.toNames) { if (!(getter.shouldOmitNull && val == null)) { if (notFirst) { stream.writeMore(); } else { notFirst = true; } stream.writeObjectField(toName); if (getter.encoder != null) { getter.encoder.encode(val, stream); } else { stream.writeVal(val); } } } } for (Method unwrapper : desc.unWrappers) { if (notFirst) { stream.writeMore(); } else { notFirst = true; } unwrapper.invoke(obj, stream); } stream.writeObjectEnd(); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/StreamImplNumber.java000066400000000000000000000226001304664171100277260ustar00rootroot00000000000000/* this implementations contains significant code from https://github.com/ngs-doo/dsl-json/blob/master/LICENSE Copyright (c) 2015, Nova Generacija Softvera d.o.o. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Nova Generacija Softvera d.o.o. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package com.jsoniter.output; import java.io.IOException; class StreamImplNumber { private final static int[] DIGITS = new int[1000]; static { for (int i = 0; i < 1000; i++) { DIGITS[i] = (i < 10 ? (2 << 24) : i < 100 ? (1 << 24) : 0) + (((i / 100) + '0') << 16) + ((((i / 10) % 10) + '0') << 8) + i % 10 + '0'; } } private static final byte[] MIN_INT = "-2147483648".getBytes(); public static final void writeInt(final JsonStream stream, int value) throws IOException { if (stream.buf.length - stream.count < 11) { stream.flushBuffer(); } byte[] buf = stream.buf; int pos = stream.count; if (value < 0) { if (value == Integer.MIN_VALUE) { System.arraycopy(MIN_INT, 0, buf, pos, MIN_INT.length); stream.count = pos + MIN_INT.length; return; } value = -value; buf[pos++] = '-'; } final int q1 = value / 1000; if (q1 == 0) { pos += writeFirstBuf(buf, DIGITS[value], pos); stream.count = pos; return; } final int r1 = value - q1 * 1000; final int q2 = q1 / 1000; if (q2 == 0) { final int v1 = DIGITS[r1]; final int v2 = DIGITS[q1]; int off = writeFirstBuf(buf, v2, pos); writeBuf(buf, v1, pos + off); stream.count = pos + 3 + off; return; } final int r2 = q1 - q2 * 1000; final long q3 = q2 / 1000; final int v1 = DIGITS[r1]; final int v2 = DIGITS[r2]; if (q3 == 0) { pos += writeFirstBuf(buf, DIGITS[q2], pos); } else { final int r3 = (int) (q2 - q3 * 1000); buf[pos++] = (byte) (q3 + '0'); writeBuf(buf, DIGITS[r3], pos); pos += 3; } writeBuf(buf, v2, pos); writeBuf(buf, v1, pos + 3); stream.count = pos + 6; } private static int writeFirstBuf(final byte[] buf, final int v, int pos) { final int start = v >> 24; if (start == 0) { buf[pos++] = (byte) (v >> 16); buf[pos++] = (byte) (v >> 8); } else if (start == 1) { buf[pos++] = (byte) (v >> 8); } buf[pos] = (byte) v; return 3 - start; } private static void writeBuf(final byte[] buf, final int v, int pos) { buf[pos] = (byte) (v >> 16); buf[pos + 1] = (byte) (v >> 8); buf[pos + 2] = (byte) v; } private static final byte[] MIN_LONG = "-9223372036854775808".getBytes(); public static final void writeLong(final JsonStream stream, long value) throws IOException { if (stream.buf.length - stream.count < 21) { stream.flushBuffer(); } byte[] buf = stream.buf; int pos = stream.count; if (value < 0) { if (value == Long.MIN_VALUE) { System.arraycopy(MIN_LONG, 0, buf, pos, MIN_LONG.length); stream.count = pos + MIN_LONG.length; return; } value = -value; buf[pos++] = '-'; } final long q1 = value / 1000; if (q1 == 0) { pos += writeFirstBuf(buf, DIGITS[(int) value], pos); stream.count = pos; return; } final int r1 = (int) (value - q1 * 1000); final long q2 = q1 / 1000; if (q2 == 0) { final int v1 = DIGITS[r1]; final int v2 = DIGITS[(int) q1]; int off = writeFirstBuf(buf, v2, pos); writeBuf(buf, v1, pos + off); stream.count = pos + 3 + off; return; } final int r2 = (int) (q1 - q2 * 1000); final long q3 = q2 / 1000; if (q3 == 0) { final int v1 = DIGITS[r1]; final int v2 = DIGITS[r2]; final int v3 = DIGITS[(int) q2]; pos += writeFirstBuf(buf, v3, pos); writeBuf(buf, v2, pos); writeBuf(buf, v1, pos + 3); stream.count = pos + 6; return; } final int r3 = (int) (q2 - q3 * 1000); final int q4 = (int) (q3 / 1000); if (q4 == 0) { final int v1 = DIGITS[r1]; final int v2 = DIGITS[r2]; final int v3 = DIGITS[r3]; final int v4 = DIGITS[(int) q3]; pos += writeFirstBuf(buf, v4, pos); writeBuf(buf, v3, pos); writeBuf(buf, v2, pos + 3); writeBuf(buf, v1, pos + 6); stream.count = pos + 9; return; } final int r4 = (int) (q3 - q4 * 1000); final int q5 = q4 / 1000; if (q5 == 0) { final int v1 = DIGITS[r1]; final int v2 = DIGITS[r2]; final int v3 = DIGITS[r3]; final int v4 = DIGITS[r4]; final int v5 = DIGITS[q4]; pos += writeFirstBuf(buf, v5, pos); writeBuf(buf, v4, pos); writeBuf(buf, v3, pos + 3); writeBuf(buf, v2, pos + 6); writeBuf(buf, v1, pos + 9); stream.count = pos + 12; return; } final int r5 = q4 - q5 * 1000; final int q6 = q5 / 1000; final int v1 = DIGITS[r1]; final int v2 = DIGITS[r2]; final int v3 = DIGITS[r3]; final int v4 = DIGITS[r4]; final int v5 = DIGITS[r5]; if (q6 == 0) { pos += writeFirstBuf(buf, DIGITS[q5], pos); } else { final int r6 = q5 - q6 * 1000; buf[pos++] = (byte) (q6 + '0'); writeBuf(buf, DIGITS[r6], pos); pos += 3; } writeBuf(buf, v5, pos); writeBuf(buf, v4, pos + 3); writeBuf(buf, v3, pos + 6); writeBuf(buf, v2, pos + 9); writeBuf(buf, v1, pos + 12); stream.count = pos + 15; } private static final int POW10[] = {1, 10, 100, 1000, 10000, 100000, 1000000}; public static final void writeFloat(JsonStream stream, float val) throws IOException { if (val < 0) { stream.write('-'); val = -val; } if (val > 0x4ffffff) { stream.writeRaw(Float.toString(val)); return; } int precision = 6; int exp = 1000000; // 6 long lval = (long)(val * exp + 0.5); stream.writeVal(lval / exp); long fval = lval % exp; if (fval == 0) { return; } stream.write('.'); if (stream.buf.length - stream.count < 10) { stream.flushBuffer(); } for (int p = precision - 1; p > 0 && fval < POW10[p]; p--) { stream.buf[stream.count++] = '0'; } stream.writeVal(fval); while(stream.buf[stream.count-1] == '0') { stream.count--; } } public static final void writeDouble(JsonStream stream, double val) throws IOException { if (val < 0) { val = -val; stream.write('-'); } if (val > 0x4ffffff) { stream.writeRaw(Double.toString(val)); return; } int precision = 6; int exp = 1000000; // 6 long lval = (long)(val * exp + 0.5); stream.writeVal(lval / exp); long fval = lval % exp; if (fval == 0) { return; } stream.write('.'); if (stream.buf.length - stream.count < 10) { stream.flushBuffer(); } for (int p = precision - 1; p > 0 && fval < POW10[p]; p--) { stream.buf[stream.count++] = '0'; } stream.writeVal(fval); while(stream.buf[stream.count-1] == '0') { stream.count--; } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/output/StreamImplString.java000066400000000000000000000142111304664171100277430ustar00rootroot00000000000000/* this implementations contains significant code from https://github.com/ngs-doo/dsl-json/blob/master/LICENSE Copyright (c) 2015, Nova Generacija Softvera d.o.o. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Nova Generacija Softvera d.o.o. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package com.jsoniter.output; import java.io.IOException; class StreamImplString { private static final byte[] ITOA = new byte[]{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; private static final boolean[] CAN_DIRECT_WRITE = new boolean[128]; static { for (int i = 0; i < CAN_DIRECT_WRITE.length; i++) { if (i > 31 && i < 126 && i != '"' && i != '\\') { CAN_DIRECT_WRITE[i] = true; } } } public static final void writeString(final JsonStream stream, final String val) throws IOException { int i = 0; int valLen = val.length(); int toWriteLen = valLen; int bufLengthMinusTwo = stream.buf.length - 2; // make room for the quotes if (stream.count + toWriteLen > bufLengthMinusTwo) { toWriteLen = bufLengthMinusTwo - stream.count; } if (toWriteLen < 0) { stream.flushBuffer(); if (stream.count + toWriteLen > bufLengthMinusTwo) { toWriteLen = bufLengthMinusTwo - stream.count; } } int n = stream.count; stream.buf[n++] = '"'; // write string, the fast path, without utf8 and escape support for (; i < toWriteLen; i++) { char c = val.charAt(i); try { if (CAN_DIRECT_WRITE[c]) { stream.buf[n++] = (byte) c; } else { break; } } catch (ArrayIndexOutOfBoundsException e) { break; } } if (i == valLen) { stream.buf[n++] = '"'; stream.count = n; return; } stream.count = n; // for the remaining parts, we process them char by char writeStringSlowPath(stream, val, i, valLen); stream.write('"'); } public static final void writeStringWithoutQuote(final JsonStream stream, final String val) throws IOException { int i = 0; int valLen = val.length(); int toWriteLen = valLen; int bufLen = stream.buf.length; if (stream.count + toWriteLen > bufLen) { toWriteLen = bufLen - stream.count; } if (toWriteLen < 0) { stream.flushBuffer(); if (stream.count + toWriteLen > bufLen) { toWriteLen = bufLen - stream.count; } } int n = stream.count; // write string, the fast path, without utf8 and escape support for (; i < toWriteLen; i++) { char c = val.charAt(i); if (c > 31 && c != '"' && c != '\\' && c < 126) { stream.buf[n++] = (byte) c; } else { break; } } if (i == valLen) { stream.count = n; return; } stream.count = n; // for the remaining parts, we process them char by char writeStringSlowPath(stream, val, i, valLen); } private static void writeStringSlowPath(JsonStream stream, String val, int i, int valLen) throws IOException { for (; i < valLen; i++) { int c = val.charAt(i); if (c > 125) { byte b4 = (byte) (c & 0xf); byte b3 = (byte) (c >> 4 & 0xf); byte b2 = (byte) (c >> 8 & 0xf); byte b1 = (byte) (c >> 12 & 0xf); stream.write((byte) '\\', (byte) 'u', ITOA[b1], ITOA[b2], ITOA[b3], ITOA[b4]); } else { switch (c) { case '"': stream.write((byte) '\\', (byte) '"'); break; case '\\': stream.write((byte) '\\', (byte) '\\'); break; case '\b': stream.write((byte) '\\', (byte) 'b'); break; case '\f': stream.write((byte) '\\', (byte) 'f'); break; case '\n': stream.write((byte) '\\', (byte) 'n'); break; case '\r': stream.write((byte) '\\', (byte) 'r'); break; case '\t': stream.write((byte) '\\', (byte) 't'); break; default: stream.write(c); } } } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/000077500000000000000000000000001304664171100230705ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/Binding.java000066400000000000000000000106441304664171100253120ustar00rootroot00000000000000package com.jsoniter.spi; import java.lang.annotation.Annotation; import java.lang.reflect.*; import java.util.Map; public class Binding { // input public final Class clazz; public final TypeLiteral clazzTypeLiteral; public Annotation[] annotations; public Field field; // obj.XXX public Method method; // obj.setXXX() or obj.getXXX() public boolean valueCanReuse; // input/output public String name; public Type valueType; public TypeLiteral valueTypeLiteral; // output public String[] fromNames; // for decoder public String[] toNames; // for encoder public Decoder decoder; public Encoder encoder; public boolean asMissingWhenNotPresent; public boolean asExtraWhenPresent; public boolean isNullable = true; public boolean isCollectionValueNullable = true; public boolean shouldOmitNull = true; // then this property will not be unknown // but we do not want to bind it anywhere public boolean shouldSkip; // attachment, used when generating code or reflection public int idx; public long mask; public Binding(Class clazz, Map lookup, Type valueType) { this.clazz = clazz; this.clazzTypeLiteral = TypeLiteral.create(clazz); this.valueType = substituteTypeVariables(lookup, valueType); this.valueTypeLiteral = TypeLiteral.create(this.valueType); } public String decoderCacheKey() { return this.name + "@" + this.clazzTypeLiteral.getDecoderCacheKey(); } public String encoderCacheKey() { return this.name + "@" + this.clazzTypeLiteral.getEncoderCacheKey(); } private static Type substituteTypeVariables(Map lookup, Type type) { if (type instanceof TypeVariable) { return translateTypeVariable(lookup, (TypeVariable) type); } if (type instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) type; Type[] args = pType.getActualTypeArguments(); for (int i = 0; i < args.length; i++) { args[i] = substituteTypeVariables(lookup, args[i]); } return new ParameterizedTypeImpl(args, pType.getOwnerType(), pType.getRawType()); } if (type instanceof GenericArrayType) { GenericArrayType gaType = (GenericArrayType) type; return new GenericArrayTypeImpl(substituteTypeVariables(lookup, gaType.getGenericComponentType())); } return type; } private static Type translateTypeVariable(Map lookup, TypeVariable var) { GenericDeclaration declaredBy = var.getGenericDeclaration(); if (!(declaredBy instanceof Class)) { // if the is not defined by class, there is no way to get the actual type return Object.class; } Class clazz = (Class) declaredBy; Type actualType = lookup.get(var.getName() + "@" + clazz.getCanonicalName()); if (actualType == null) { // should not happen return Object.class; } if (actualType instanceof TypeVariable) { // translate to another variable, try again return translateTypeVariable(lookup, (TypeVariable) actualType); } return actualType; } public T getAnnotation(Class annotationClass) { if (annotations == null) { return null; } for (Annotation annotation : annotations) { if (annotationClass.isAssignableFrom(annotation.getClass())) { return (T) annotation; } } return null; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Binding binding = (Binding) o; if (clazz != null ? !clazz.equals(binding.clazz) : binding.clazz != null) return false; return name != null ? name.equals(binding.name) : binding.name == null; } @Override public int hashCode() { int result = clazz != null ? clazz.hashCode() : 0; result = 31 * result + (name != null ? name.hashCode() : 0); return result; } @Override public String toString() { return "Binding{" + "clazz=" + clazz + ", name='" + name + '\'' + ", valueType=" + valueType + '}'; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/ClassDescriptor.java000066400000000000000000000034121304664171100270370ustar00rootroot00000000000000package com.jsoniter.spi; import java.lang.reflect.Method; import java.lang.reflect.Type; import java.util.ArrayList; import java.util.List; import java.util.Map; public class ClassDescriptor { public Class clazz; public Map lookup; public ConstructorDescriptor ctor; public List fields; public List setters; public List getters; public List wrappers; public List unWrappers; public boolean asExtraForUnknownProperties; public Binding onMissingProperties; public Binding onExtraProperties; public List allBindings() { ArrayList bindings = new ArrayList(8); bindings.addAll(fields); if (setters != null) { bindings.addAll(setters); } if (getters != null) { bindings.addAll(getters); } if (ctor != null) { bindings.addAll(ctor.parameters); } if (wrappers != null) { for (WrapperDescriptor setter : wrappers) { bindings.addAll(setter.parameters); } } return bindings; } public List allDecoderBindings() { ArrayList bindings = new ArrayList(8); bindings.addAll(fields); bindings.addAll(setters); if (ctor != null) { bindings.addAll(ctor.parameters); } for (WrapperDescriptor setter : wrappers) { bindings.addAll(setter.parameters); } return bindings; } public List allEncoderBindings() { ArrayList bindings = new ArrayList(8); bindings.addAll(fields); bindings.addAll(getters); return bindings; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/CodegenConfig.java000066400000000000000000000004711304664171100264270ustar00rootroot00000000000000package com.jsoniter.spi; public interface CodegenConfig { /** * register decoder/encoder before codegen * register extension before codegen */ void setup(); /** * what to codegen * @return generate encoder/decoder for the types */ TypeLiteral[] whatToCodegen(); } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/ConstructorDescriptor.java000066400000000000000000000017141304664171100303220ustar00rootroot00000000000000package com.jsoniter.spi; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.List; public class ConstructorDescriptor { /** * set to null if use constructor * otherwise use static method */ public String staticMethodName; // option 1: use constructor public Constructor ctor; // option 2: use static method public Method staticFactory; // option 3: create by extension public Extension objectFactory; /** * the parameters to call constructor or static method */ public List parameters = new ArrayList(); @Override public String toString() { return "ConstructorDescriptor{" + "staticMethodName='" + staticMethodName + '\'' + ", ctor=" + ctor + ", staticFactory=" + staticFactory + ", parameters=" + parameters + '}'; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/Decoder.java000066400000000000000000000041541304664171100253040ustar00rootroot00000000000000package com.jsoniter.spi; import com.jsoniter.JsonIterator; import java.io.IOException; public interface Decoder { /** * Customized decoder to read values from iterator * * @param iter the iterator instance * @return the value to set * @throws IOException when reading from iterator triggered error */ Object decode(JsonIterator iter) throws IOException; abstract class BooleanDecoder implements Decoder { @Override public Object decode(JsonIterator iter) throws IOException { return Boolean.valueOf(decodeBoolean(iter)); } public abstract boolean decodeBoolean(JsonIterator iter) throws IOException; } abstract class ShortDecoder implements Decoder { @Override public Object decode(JsonIterator iter) throws IOException { return Short.valueOf(decodeShort(iter)); } public abstract short decodeShort(JsonIterator iter) throws IOException; } abstract class IntDecoder implements Decoder { @Override public Object decode(JsonIterator iter) throws IOException { return Integer.valueOf(decodeInt(iter)); } public abstract int decodeInt(JsonIterator iter) throws IOException; } abstract class LongDecoder implements Decoder { @Override public Object decode(JsonIterator iter) throws IOException { return Long.valueOf(decodeLong(iter)); } public abstract long decodeLong(JsonIterator iter) throws IOException; } abstract class FloatDecoder implements Decoder { @Override public Object decode(JsonIterator iter) throws IOException { return Float.valueOf(decodeFloat(iter)); } public abstract float decodeFloat(JsonIterator iter) throws IOException; } abstract class DoubleDecoder implements Decoder { @Override public Object decode(JsonIterator iter) throws IOException { return Double.valueOf(decodeDouble(iter)); } public abstract double decodeDouble(JsonIterator iter) throws IOException; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/EmptyEncoder.java000066400000000000000000000006531304664171100263350ustar00rootroot00000000000000package com.jsoniter.spi; import com.jsoniter.any.Any; import com.jsoniter.output.JsonStream; import java.io.IOException; public class EmptyEncoder implements Encoder { @Override public void encode(Object obj, JsonStream stream) throws IOException { throw new UnsupportedOperationException(); } @Override public Any wrap(Object obj) { throw new UnsupportedOperationException(); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/EmptyExtension.java000066400000000000000000000012701304664171100267260ustar00rootroot00000000000000package com.jsoniter.spi; import java.lang.reflect.Type; public class EmptyExtension implements Extension { @Override public Type chooseImplementation(Type type) { return type; } @Override public boolean canCreate(Class clazz) { return false; } @Override public Object create(Class clazz) { throw new UnsupportedOperationException(); } @Override public Decoder createDecoder(String cacheKey, Type type) { return null; } @Override public Encoder createEncoder(String cacheKey, Type type) { return null; } @Override public void updateClassDescriptor(ClassDescriptor desc) { } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/Encoder.java000066400000000000000000000100511304664171100253070ustar00rootroot00000000000000package com.jsoniter.spi; import com.jsoniter.any.Any; import com.jsoniter.output.JsonStream; import java.io.IOException; public interface Encoder { void encode(Object obj, JsonStream stream) throws IOException; Any wrap(Object obj); abstract class BooleanEncoder implements Encoder { @Override public void encode(Object obj, JsonStream stream) throws IOException { encodeBoolean((Boolean) obj, stream); } public abstract void encodeBoolean(boolean obj, JsonStream stream) throws IOException; } abstract class ShortEncoder implements Encoder { @Override public void encode(Object obj, JsonStream stream) throws IOException { encodeShort((Short) obj, stream); } @Override public Any wrap(Object obj) { Short val = (Short) obj; return Any.wrap((int) val); } public abstract void encodeShort(short obj, JsonStream stream) throws IOException; } class StringShortEncoder extends ShortEncoder { @Override public void encodeShort(short obj, JsonStream stream) throws IOException { stream.write('"'); stream.writeVal(obj); stream.write('"'); } } abstract class IntEncoder implements Encoder { @Override public void encode(Object obj, JsonStream stream) throws IOException { encodeInt((Integer) obj, stream); } @Override public Any wrap(Object obj) { Integer val = (Integer) obj; return Any.wrap((int)val); } public abstract void encodeInt(int obj, JsonStream stream) throws IOException; } class StringIntEncoder extends IntEncoder { @Override public void encodeInt(int obj, JsonStream stream) throws IOException { stream.write('"'); stream.writeVal(obj); stream.write('"'); } } abstract class LongEncoder implements Encoder { @Override public void encode(Object obj, JsonStream stream) throws IOException { encodeLong((Long) obj, stream); } @Override public Any wrap(Object obj) { Long val = (Long) obj; return Any.wrap((long)val); } public abstract void encodeLong(long obj, JsonStream stream) throws IOException; } class StringLongEncoder extends LongEncoder { @Override public void encodeLong(long obj, JsonStream stream) throws IOException { stream.write('"'); stream.writeVal(obj); stream.write('"'); } } abstract class FloatEncoder implements Encoder { @Override public void encode(Object obj, JsonStream stream) throws IOException { encodeFloat((Float) obj, stream); } @Override public Any wrap(Object obj) { Float val = (Float) obj; return Any.wrap((float)val); } public abstract void encodeFloat(float obj, JsonStream stream) throws IOException; } class StringFloatEncoder extends FloatEncoder { @Override public void encodeFloat(float obj, JsonStream stream) throws IOException { stream.write('"'); stream.writeVal(obj); stream.write('"'); } } abstract class DoubleEncoder implements Encoder { @Override public void encode(Object obj, JsonStream stream) throws IOException { encodeDouble((Double) obj, stream); } @Override public Any wrap(Object obj) { Double val = (Double) obj; return Any.wrap((double)val); } public abstract void encodeDouble(double obj, JsonStream stream) throws IOException; } class StringDoubleEncoder extends DoubleEncoder { @Override public void encodeDouble(double obj, JsonStream stream) throws IOException { stream.write('"'); stream.writeVal(obj); stream.write('"'); } } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/Extension.java000066400000000000000000000026701304664171100257140ustar00rootroot00000000000000package com.jsoniter.spi; import java.lang.reflect.Type; public interface Extension { /** * Choose the implementation class for interface types * * @param type the type to decode to, could be class or parameterized type * @return the implementation type to use */ Type chooseImplementation(Type type); /** * Can this extension create object instance for given interface type * * @param clazz the interface * @return true if can create, false if can not */ boolean canCreate(Class clazz); /** * Create object instance for given interface type * * @param clazz the interface * @return the object instance, throw exception if can not create */ Object create(Class clazz); /** * Customize type decoding * * @param cacheKey name of the decoder * @param type change how to decode the type * @return null, if no special customization needed */ Decoder createDecoder(String cacheKey, Type type); /** * Customize type encoding * * @param cacheKey name of the encoder * @param type change how to encode the type * @return null, if not special customization needed */ Encoder createEncoder(String cacheKey, Type type); /** * Update how binding is done for the class * * @param desc binding information */ void updateClassDescriptor(ClassDescriptor desc); } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/GenericArrayTypeImpl.java000066400000000000000000000017741304664171100300030ustar00rootroot00000000000000package com.jsoniter.spi; import java.lang.reflect.GenericArrayType; import java.lang.reflect.Type; public class GenericArrayTypeImpl implements GenericArrayType { private final Type componentType; GenericArrayTypeImpl(Type componentType) { this.componentType = componentType; } @Override public Type getGenericComponentType() { return componentType; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; GenericArrayTypeImpl that = (GenericArrayTypeImpl) o; return componentType != null ? componentType.equals(that.componentType) : that.componentType == null; } @Override public int hashCode() { return componentType != null ? componentType.hashCode() : 0; } @Override public String toString() { return "GenericArrayTypeImpl{" + "componentType=" + componentType + '}'; } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/JsonException.java000066400000000000000000000005531304664171100265260ustar00rootroot00000000000000package com.jsoniter.spi; public class JsonException extends RuntimeException { public JsonException() { } public JsonException(String message) { super(message); } public JsonException(String message, Throwable cause) { super(message, cause); } public JsonException(Throwable cause) { super(cause); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/JsoniterSpi.java000066400000000000000000000417641304664171100262200ustar00rootroot00000000000000package com.jsoniter.spi; import java.lang.reflect.*; import java.util.*; public class JsoniterSpi { static List extensions = new ArrayList(); static Map typeImpls = new HashMap(); static volatile Map encoders = new HashMap(); static volatile Map decoders = new HashMap(); static volatile Map objectFactories = new HashMap(); public static void registerExtension(Extension extension) { extensions.add(extension); } public static List getExtensions() { return Collections.unmodifiableList(extensions); } public static void registerTypeImplementation(Class superClazz, Class implClazz) { typeImpls.put(superClazz, implClazz); } public static Class getTypeImplementation(Class superClazz) { return typeImpls.get(superClazz); } public static void registerTypeDecoder(Class clazz, Decoder decoder) { addNewDecoder(TypeLiteral.create(clazz).getDecoderCacheKey(), decoder); } public static void registerTypeDecoder(TypeLiteral typeLiteral, Decoder decoder) { addNewDecoder(typeLiteral.getDecoderCacheKey(), decoder); } public static void registerPropertyDecoder(Class clazz, String field, Decoder decoder) { addNewDecoder(field + "@" + TypeLiteral.create(clazz).getDecoderCacheKey(), decoder); } public static void registerPropertyDecoder(TypeLiteral typeLiteral, String field, Decoder decoder) { addNewDecoder(field + "@" + typeLiteral.getDecoderCacheKey(), decoder); } public static void registerTypeEncoder(Class clazz, Encoder encoder) { addNewEncoder(TypeLiteral.create(clazz).getEncoderCacheKey(), encoder); } public static void registerTypeEncoder(TypeLiteral typeLiteral, Encoder encoder) { addNewEncoder(typeLiteral.getDecoderCacheKey(), encoder); } public static void registerPropertyEncoder(Class clazz, String field, Encoder encoder) { addNewEncoder(field + "@" + TypeLiteral.create(clazz).getEncoderCacheKey(), encoder); } public static void registerPropertyEncoder(TypeLiteral typeLiteral, String field, Encoder encoder) { addNewEncoder(field + "@" + typeLiteral.getDecoderCacheKey(), encoder); } public static Decoder getDecoder(String cacheKey) { return decoders.get(cacheKey); } public synchronized static void addNewDecoder(String cacheKey, Decoder decoder) { HashMap newCache = new HashMap(decoders); newCache.put(cacheKey, decoder); decoders = newCache; } public static Encoder getEncoder(String cacheKey) { return encoders.get(cacheKey); } public synchronized static void addNewEncoder(String cacheKey, Encoder encoder) { HashMap newCache = new HashMap(encoders); newCache.put(cacheKey, encoder); encoders = newCache; } public static boolean canCreate(Class clazz) { if (objectFactories.containsKey(clazz)) { return true; } for (Extension extension : extensions) { if (extension.canCreate(clazz)) { addObjectFactory(clazz, extension); return true; } } return false; } public static Object create(Class clazz) { return objectFactories.get(clazz).create(clazz); } private synchronized static void addObjectFactory(Class clazz, Extension extension) { HashMap copy = new HashMap(objectFactories); copy.put(clazz, extension); objectFactories = copy; } public static ClassDescriptor getDecodingClassDescriptor(Class clazz, boolean includingPrivate) { Map lookup = collectTypeVariableLookup(clazz); ClassDescriptor desc = new ClassDescriptor(); desc.clazz = clazz; desc.lookup = lookup; desc.ctor = getCtor(clazz); desc.fields = getFields(lookup, clazz, includingPrivate); desc.setters = getSetters(lookup, clazz, includingPrivate); desc.wrappers = new ArrayList(); desc.unWrappers = new ArrayList(); for (Extension extension : extensions) { extension.updateClassDescriptor(desc); } for (Binding field : desc.fields) { if (field.valueType instanceof Class) { Class valueClazz = (Class) field.valueType; if (valueClazz.isArray()) { field.valueCanReuse = false; continue; } } field.valueCanReuse = field.valueTypeLiteral.nativeType == null; } decodingDeduplicate(desc); if (includingPrivate) { if (desc.ctor.ctor != null) { desc.ctor.ctor.setAccessible(true); } if (desc.ctor.staticFactory != null) { desc.ctor.staticFactory.setAccessible(true); } for (WrapperDescriptor setter : desc.wrappers) { setter.method.setAccessible(true); } } for (Binding binding : desc.allDecoderBindings()) { if (binding.fromNames == null) { binding.fromNames = new String[]{binding.name}; } if (binding.field != null && includingPrivate) { binding.field.setAccessible(true); } if (binding.method != null && includingPrivate) { binding.method.setAccessible(true); } if (binding.decoder != null) { JsoniterSpi.addNewDecoder(binding.decoderCacheKey(), binding.decoder); } } return desc; } public static ClassDescriptor getEncodingClassDescriptor(Class clazz, boolean includingPrivate) { Map lookup = collectTypeVariableLookup(clazz); ClassDescriptor desc = new ClassDescriptor(); desc.clazz = clazz; desc.lookup = lookup; desc.fields = getFields(lookup, clazz, includingPrivate); desc.getters = getGetters(lookup, clazz, includingPrivate); desc.wrappers = new ArrayList(); desc.unWrappers = new ArrayList(); for (Extension extension : extensions) { extension.updateClassDescriptor(desc); } encodingDeduplicate(desc); for (Binding binding : desc.allEncoderBindings()) { if (binding.toNames == null) { binding.toNames = new String[]{binding.name}; } if (binding.field != null && includingPrivate) { binding.field.setAccessible(true); } if (binding.method != null && includingPrivate) { binding.method.setAccessible(true); } if (binding.encoder != null) { JsoniterSpi.addNewEncoder(binding.encoderCacheKey(), binding.encoder); } } return desc; } private static void decodingDeduplicate(ClassDescriptor desc) { HashMap byName = new HashMap(); for (Binding field : desc.fields) { if (byName.containsKey(field.name)) { throw new JsonException("field name conflict: " + field.name); } byName.put(field.name, field); } for (Binding setter : desc.setters) { Binding existing = byName.get(setter.name); if (existing == null) { byName.put(setter.name, setter); continue; } if (desc.fields.remove(existing)) { continue; } throw new JsonException("setter name conflict: " + setter.name); } for (WrapperDescriptor wrapper : desc.wrappers) { for (Binding param : wrapper.parameters) { Binding existing = byName.get(param.name); if (existing == null) { byName.put(param.name, param); continue; } if (desc.fields.remove(existing)) { continue; } if (desc.setters.remove(existing)) { continue; } throw new JsonException("wrapper parameter name conflict: " + param.name); } } for (Binding param : desc.ctor.parameters) { Binding existing = byName.get(param.name); if (existing == null) { byName.put(param.name, param); continue; } if (desc.fields.remove(existing)) { continue; } if (desc.setters.remove(existing)) { continue; } throw new JsonException("ctor parameter name conflict: " + param.name); } } private static void encodingDeduplicate(ClassDescriptor desc) { HashMap byName = new HashMap(); for (Binding field : desc.fields) { if (byName.containsKey(field.name)) { throw new JsonException("field name conflict: " + field.name); } byName.put(field.name, field); } for (Binding getter : desc.getters) { Binding existing = byName.get(getter.name); if (existing == null) { byName.put(getter.name, getter); continue; } if (desc.fields.remove(existing)) { continue; } throw new JsonException("getter name conflict: " + getter.name); } } private static ConstructorDescriptor getCtor(Class clazz) { ConstructorDescriptor cctor = new ConstructorDescriptor(); if (canCreate(clazz)) { cctor.objectFactory = objectFactories.get(clazz); return cctor; } try { cctor.ctor = clazz.getDeclaredConstructor(); } catch (Exception e) { cctor.ctor = null; } return cctor; } private static List getFields(Map lookup, Class clazz, boolean includingPrivate) { ArrayList bindings = new ArrayList(); for (Field field : getAllFields(clazz, includingPrivate)) { if (Modifier.isStatic(field.getModifiers())) { continue; } if (Modifier.isTransient(field.getModifiers())) { continue; } if (!includingPrivate && !Modifier.isPublic(field.getType().getModifiers())) { continue; } if (includingPrivate) { field.setAccessible(true); } Binding binding = createBindingFromField(lookup, clazz, field); bindings.add(binding); } return bindings; } private static Binding createBindingFromField(Map lookup, Class clazz, Field field) { try { Binding binding = new Binding(clazz, lookup, field.getGenericType()); binding.fromNames = new String[]{field.getName()}; binding.name = field.getName(); binding.annotations = field.getAnnotations(); binding.field = field; return binding; } catch (Exception e) { throw new JsonException("failed to create binding for field: " + field, e); } } private static List getAllFields(Class clazz, boolean includingPrivate) { List allFields = Arrays.asList(clazz.getFields()); if (includingPrivate) { allFields = new ArrayList(); Class current = clazz; while (current != null) { allFields.addAll(Arrays.asList(current.getDeclaredFields())); current = current.getSuperclass(); } } return allFields; } private static List getSetters(Map lookup, Class clazz, boolean includingPrivate) { ArrayList setters = new ArrayList(); for (Method method : getAllMethods(clazz, includingPrivate)) { if (Modifier.isStatic(method.getModifiers())) { continue; } String methodName = method.getName(); if (methodName.length() < 4) { continue; } if (!methodName.startsWith("set")) { continue; } Type[] paramTypes = method.getGenericParameterTypes(); if (paramTypes.length != 1) { continue; } if (!includingPrivate && !Modifier.isPublic(method.getParameterTypes()[0].getModifiers())) { continue; } if (includingPrivate) { method.setAccessible(true); } try { String fromName = translateSetterName(methodName); Binding binding = new Binding(clazz, lookup, paramTypes[0]); binding.fromNames = new String[]{fromName}; binding.name = fromName; binding.method = method; binding.annotations = method.getAnnotations(); setters.add(binding); } catch (Exception e) { throw new JsonException("failed to create binding from setter: " + method, e); } } return setters; } private static List getAllMethods(Class clazz, boolean includingPrivate) { List allMethods = Arrays.asList(clazz.getMethods()); if (includingPrivate) { allMethods = new ArrayList(); Class current = clazz; while (current != null) { allMethods.addAll(Arrays.asList(current.getDeclaredMethods())); current = current.getSuperclass(); } } return allMethods; } private static String translateSetterName(String methodName) { if (!methodName.startsWith("set")) { return null; } String fromName = methodName.substring("set".length()); char[] fromNameChars = fromName.toCharArray(); fromNameChars[0] = Character.toLowerCase(fromNameChars[0]); fromName = new String(fromNameChars); return fromName; } private static List getGetters(Map lookup, Class clazz, boolean includingPrivate) { ArrayList getters = new ArrayList(); for (Method method : getAllMethods(clazz, includingPrivate)) { if (Modifier.isStatic(method.getModifiers())) { continue; } String methodName = method.getName(); if ("getClass".equals(methodName)) { continue; } if (methodName.length() < 4) { continue; } if (!methodName.startsWith("get")) { continue; } if (method.getGenericParameterTypes().length != 0) { continue; } String toName = methodName.substring("get".length()); char[] fromNameChars = toName.toCharArray(); fromNameChars[0] = Character.toLowerCase(fromNameChars[0]); toName = new String(fromNameChars); Binding getter = new Binding(clazz, lookup, method.getGenericReturnType()); getter.toNames = new String[]{toName}; getter.name = toName; getter.method = method; getter.annotations = method.getAnnotations(); getters.add(getter); } return getters; } public static void dump() { for (String cacheKey : decoders.keySet()) { System.err.println(cacheKey); } for (String cacheKey : encoders.keySet()) { System.err.println(cacheKey); } } private static Map collectTypeVariableLookup(Type type) { HashMap vars = new HashMap(); if (null == type) { return vars; } if (type instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) type; Type[] actualTypeArguments = pType.getActualTypeArguments(); Class clazz = (Class) pType.getRawType(); for (int i = 0; i < clazz.getTypeParameters().length; i++) { TypeVariable variable = clazz.getTypeParameters()[i]; vars.put(variable.getName() + "@" + clazz.getCanonicalName(), actualTypeArguments[i]); } vars.putAll(collectTypeVariableLookup(clazz.getGenericSuperclass())); return vars; } if (type instanceof Class) { Class clazz = (Class) type; vars.putAll(collectTypeVariableLookup(clazz.getGenericSuperclass())); return vars; } throw new JsonException("unexpected type: " + type); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/ParameterizedTypeImpl.java000066400000000000000000000054511304664171100302200ustar00rootroot00000000000000package com.jsoniter.spi; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.Arrays; public class ParameterizedTypeImpl implements ParameterizedType { private final Type[] actualTypeArguments; private final Type ownerType; private final Type rawType; public ParameterizedTypeImpl(Type[] actualTypeArguments, Type ownerType, Type rawType){ this.actualTypeArguments = actualTypeArguments; this.ownerType = ownerType; this.rawType = rawType; } public Type[] getActualTypeArguments() { return actualTypeArguments; } public Type getOwnerType() { return ownerType; } public Type getRawType() { return rawType; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ParameterizedTypeImpl that = (ParameterizedTypeImpl) o; // Probably incorrect - comparing Object[] arrays with Arrays.equals if (!Arrays.equals(actualTypeArguments, that.actualTypeArguments)) return false; if (ownerType != null ? !ownerType.equals(that.ownerType) : that.ownerType != null) return false; return rawType != null ? rawType.equals(that.rawType) : that.rawType == null; } @Override public int hashCode() { int result = Arrays.hashCode(actualTypeArguments); result = 31 * result + (ownerType != null ? ownerType.hashCode() : 0); result = 31 * result + (rawType != null ? rawType.hashCode() : 0); return result; } @Override public String toString() { String rawTypeName = rawType.toString(); if (rawType instanceof Class) { Class clazz = (Class) rawType; rawTypeName = clazz.getName(); } return "ParameterizedTypeImpl{" + "actualTypeArguments=" + Arrays.toString(actualTypeArguments) + ", ownerType=" + ownerType + ", rawType=" + rawTypeName + '}'; } public static boolean isSameClass(Type type, Class clazz) { if (type == clazz) { return true; } if (type instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) type; return pType.getRawType() == clazz; } return false; } public static Type useImpl(Type type, Class clazz) { if (type instanceof Class) { return clazz; } if (type instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) type; return new ParameterizedTypeImpl(pType.getActualTypeArguments(), pType.getOwnerType(), clazz); } throw new JsonException("can not change impl for: " + type); } } java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/TypeLiteral.java000066400000000000000000000165051304664171100262000ustar00rootroot00000000000000package com.jsoniter.spi; import com.jsoniter.any.Any; import java.lang.reflect.GenericArrayType; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.math.BigDecimal; import java.math.BigInteger; import java.util.HashMap; import java.util.Map; public class TypeLiteral { public enum NativeType { FLOAT, DOUBLE, BOOLEAN, BYTE, SHORT, INT, CHAR, LONG, BIG_DECIMAL, BIG_INTEGER, STRING, OBJECT, ANY, } public static Map nativeTypes = new HashMap() {{ put(float.class, NativeType.FLOAT); put(Float.class, NativeType.FLOAT); put(double.class, NativeType.DOUBLE); put(Double.class, NativeType.DOUBLE); put(boolean.class, NativeType.BOOLEAN); put(Boolean.class, NativeType.BOOLEAN); put(byte.class, NativeType.BYTE); put(Byte.class, NativeType.BYTE); put(short.class, NativeType.SHORT); put(Short.class, NativeType.SHORT); put(int.class, NativeType.INT); put(Integer.class, NativeType.INT); put(char.class, NativeType.CHAR); put(Character.class, NativeType.CHAR); put(long.class, NativeType.LONG); put(Long.class, NativeType.LONG); put(BigDecimal.class, NativeType.BIG_DECIMAL); put(BigInteger.class, NativeType.BIG_INTEGER); put(String.class, NativeType.STRING); put(Object.class, NativeType.OBJECT); put(Any.class, NativeType.ANY); }}; private volatile static Map typeLiteralCache = new HashMap(); final Type type; final String decoderCacheKey; final String encoderCacheKey; final NativeType nativeType; /** * Constructs a new type literal. Derives represented class from type parameter. * Clients create an empty anonymous subclass. Doing so embeds the type parameter in the * anonymous class's type hierarchy so we can reconstitute it at runtime despite erasure. */ @SuppressWarnings("unchecked") protected TypeLiteral() { this.type = getSuperclassTypeParameter(getClass()); nativeType = nativeTypes.get(this.type); decoderCacheKey = generateDecoderCacheKey(type); encoderCacheKey = generateEncoderCacheKey(type); } public TypeLiteral(Type type, String decoderCacheKey, String encoderCacheKey) { this.type = type; nativeType = nativeTypes.get(this.type); this.decoderCacheKey = decoderCacheKey; this.encoderCacheKey = encoderCacheKey; } private static String generateDecoderCacheKey(Type type) { return generateCacheKey(type, "decoder."); } private static String generateEncoderCacheKey(Type type) { return generateCacheKey(type, "encoder."); } private static String generateCacheKey(Type type, String prefix) { StringBuilder decoderClassName = new StringBuilder(prefix); if (type instanceof Class) { Class clazz = (Class) type; if (clazz.isAnonymousClass()) { throw new JsonException("anonymous class not supported: " + clazz); } if (clazz.isArray()) { decoderClassName.append(clazz.getCanonicalName().replace("[]", "_array")); } else { // for nested class $ decoderClassName.append(clazz.getName().replace("[]", "_array")); } } else if (type instanceof ParameterizedType) { try { ParameterizedType pType = (ParameterizedType) type; Class clazz = (Class) pType.getRawType(); decoderClassName.append(clazz.getCanonicalName().replace("[]", "_array")); for (int i = 0; i < pType.getActualTypeArguments().length; i++) { String typeName = formatTypeWithoutSpecialCharacter(pType.getActualTypeArguments()[i]); decoderClassName.append('_'); decoderClassName.append(typeName); } } catch (Exception e) { throw new JsonException("failed to generate cache key for: " + type, e); } } else if (type instanceof GenericArrayType) { GenericArrayType gaType = (GenericArrayType) type; Type compType = gaType.getGenericComponentType(); decoderClassName.append(formatTypeWithoutSpecialCharacter(compType)); decoderClassName.append("_array"); } else { throw new UnsupportedOperationException("do not know how to handle: " + type); } return decoderClassName.toString().replace("$", "_"); } private static String formatTypeWithoutSpecialCharacter(Type type) { if (type instanceof Class) { Class clazz = (Class) type; return clazz.getCanonicalName(); } if (type instanceof ParameterizedType) { ParameterizedType pType = (ParameterizedType) type; String typeName = formatTypeWithoutSpecialCharacter(pType.getRawType()); for (Type typeArg : pType.getActualTypeArguments()) { typeName += "_"; typeName += formatTypeWithoutSpecialCharacter(typeArg); } return typeName; } if (type instanceof GenericArrayType) { GenericArrayType gaType = (GenericArrayType) type; return formatTypeWithoutSpecialCharacter(gaType.getGenericComponentType()) + "_array"; } throw new JsonException("unsupported type: " + type + ", of class " + type.getClass()); } static Type getSuperclassTypeParameter(Class subclass) { Type superclass = subclass.getGenericSuperclass(); if (superclass instanceof Class) { throw new JsonException("Missing type parameter."); } ParameterizedType parameterized = (ParameterizedType) superclass; return parameterized.getActualTypeArguments()[0]; } public static TypeLiteral create(Type valueType) { TypeLiteral typeLiteral = typeLiteralCache.get(valueType); if (typeLiteral != null) { return typeLiteral; } return createNew(valueType); } private synchronized static TypeLiteral createNew(Type valueType) { TypeLiteral typeLiteral = typeLiteralCache.get(valueType); if (typeLiteral != null) { return typeLiteral; } HashMap copy = new HashMap(typeLiteralCache); typeLiteral = new TypeLiteral(valueType, generateDecoderCacheKey(valueType), generateEncoderCacheKey(valueType)); copy.put(valueType, typeLiteral); typeLiteralCache = copy; return typeLiteral; } public Type getType() { return type; } public String getDecoderCacheKey() { return decoderCacheKey; } public String getEncoderCacheKey() { return encoderCacheKey; } public NativeType getNativeType() { return nativeType; } @Override public String toString() { return "TypeLiteral{" + "type=" + type + ", decoderCacheKey='" + decoderCacheKey + '\'' + ", encoderCacheKey='" + encoderCacheKey + '\'' + '}'; } }java-jsoniter-java-0.9.8/src/main/java/com/jsoniter/spi/WrapperDescriptor.java000066400000000000000000000004351304664171100274140ustar00rootroot00000000000000package com.jsoniter.spi; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.List; public class WrapperDescriptor { /** * the parameters to bind */ public List parameters = new ArrayList(); public Method method; } java-jsoniter-java-0.9.8/src/test/000077500000000000000000000000001304664171100167745ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/test/java/000077500000000000000000000000001304664171100177155ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/test/java/com/000077500000000000000000000000001304664171100204735ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/000077500000000000000000000000001304664171100223305ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/ComplexObject.java000066400000000000000000000003011304664171100257230ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.any.Any; import java.util.List; public class ComplexObject { public int field1; public List> field2; public Any field3; } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/SimpleObject.java000066400000000000000000000011671304664171100255600ustar00rootroot00000000000000package com.jsoniter; public class SimpleObject { public String field2; public String field1; @Override public boolean equals(Object o) { if (this == o) return true; SimpleObject that = (SimpleObject) o; if (field2 != null ? !field2.equals(that.field2) : that.field2 != null) return false; return field1 != null ? field1.equals(that.field1) : that.field1 == null; } @Override public int hashCode() { int result = field2 != null ? field2.hashCode() : 0; result = 31 * result + (field1 != null ? field1.hashCode() : 0); return result; } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/StreamingCategory.java000066400000000000000000000000761304664171100266250ustar00rootroot00000000000000package com.jsoniter; public interface StreamingCategory { } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestAnnotation.java000066400000000000000000000202051304664171100261440ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.annotation.*; import com.jsoniter.any.Any; import com.jsoniter.fuzzy.StringIntDecoder; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.JsoniterSpi; import junit.framework.TestCase; import java.io.IOException; import java.util.Arrays; import java.util.LinkedList; import java.util.List; import java.util.Map; public class TestAnnotation extends TestCase { static { JsoniterAnnotationSupport.enable(); // JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); // JsonIterator.setMode(DecodingMode.REFLECTION_MODE); } public static class TestObject1 { @JsonProperty(from = {"field-1"}) public int field1; @JsonIgnore public int field2; } public void test_rename() throws IOException { JsonIterator iter = JsonIterator.parse("{'field-1': 100}".replace('\'', '"')); TestObject1 obj = iter.read(TestObject1.class); assertEquals(100, obj.field1); } public void test_ignore() throws IOException { JsonIterator iter = JsonIterator.parse("{'field2': 100}".replace('\'', '"')); TestObject1 obj = iter.read(TestObject1.class); assertEquals(0, obj.field2); } public static class TestObject2 { private int field1; @JsonCreator public TestObject2(@JsonProperty("field1") int field1) { this.field1 = field1; } } public void test_ctor() throws IOException { JsonIterator iter = JsonIterator.parse("{'field1': 100}".replace('\'', '"')); TestObject2 obj = iter.read(TestObject2.class); assertEquals(100, obj.field1); } public static class TestObject3 { public int field1; @JsonCreator private TestObject3() { } } public void test_private_ctor() throws IOException { JsoniterSpi.registerTypeDecoder(TestObject3.class, ReflectionDecoderFactory.create(TestObject3.class)); JsonIterator iter = JsonIterator.parse("{'field1': 100}".replace('\'', '"')); TestObject3 obj = iter.read(TestObject3.class); assertEquals(100, obj.field1); } public static class TestObject4 { private int field1; private TestObject4() { } @JsonCreator public static TestObject4 createObject(@JsonProperty(value = "field1") int field1) { TestObject4 obj = new TestObject4(); obj.field1 = field1; return obj; } } public void test_static_factory() throws IOException { JsonIterator iter = JsonIterator.parse("{'field1': 100}".replace('\'', '"')); TestObject4 obj = iter.read(TestObject4.class); assertEquals(100, obj.field1); } public static class TestObject5 { private int field1; public void setField1(int field1) { this.field1 = field1; } } public void test_single_param_setter() throws IOException { JsonIterator iter = JsonIterator.parse("{'field1': 100}".replace('\'', '"')); TestObject5 obj = iter.read(TestObject5.class); assertEquals(100, obj.field1); } public static class TestObject6 { private int field1; @JsonWrapper public void initialize(@JsonProperty("field1") int field1) { this.field1 = field1; } } public void test_multi_param_setter() throws IOException { JsonIterator iter = JsonIterator.parse("{'field1': 100}".replace('\'', '"')); TestObject6 obj = iter.read(TestObject6.class); assertEquals(100, obj.field1); } public static class TestObject7 { @JsonProperty(required = true) public int field1; @JsonMissingProperties public List missingProperties; } public void test_required_properties() throws IOException { JsonIterator iter = JsonIterator.parse("{}"); TestObject7 obj = iter.read(TestObject7.class); assertEquals(Arrays.asList("field1"), obj.missingProperties); } public static class TestObject8 { @JsonCreator public TestObject8(@JsonProperty(required = true) int param1) { } } public void test_missing_ctor_arg() throws IOException { JsonIterator iter = JsonIterator.parse("{}"); try { iter.read(TestObject8.class); fail(); } catch (JsonException e) { System.out.println(e); } } @JsonObject(asExtraForUnknownProperties = true) public static class TestObject9 { @JsonExtraProperties public Map extraProperties; } public void test_extra_properties() throws IOException { JsonIterator iter = JsonIterator.parse("{\"field1\": 100}"); TestObject9 obj = iter.read(TestObject9.class); assertEquals(100, obj.extraProperties.get("field1").toInt()); } public static class TestObject10 { @JsonProperty(decoder = StringIntDecoder.class) public int field1; } public void test_property_decoder() throws IOException { JsonIterator iter = JsonIterator.parse("{\"field1\": \"100\"}"); TestObject10 obj = iter.read(TestObject10.class); assertEquals(100, obj.field1); } public static class TestObject11 { @JsonProperty(decoder = StringIntDecoder.class) public Integer field1; } public void test_integer_property_decoder() throws IOException { JsonIterator iter = JsonIterator.parse("{\"field1\": \"100\"}"); TestObject11 obj = iter.read(TestObject11.class); assertEquals(Integer.valueOf(100), obj.field1); } public static class TestObject12 { @JsonProperty(from = {"field_1", "field-1"}) public int field1; } public void test_bind_from_multiple_names() throws IOException { JsonIterator iter = JsonIterator.parse("{\"field-1\": 100, \"field-1\": 101}"); TestObject12 obj = iter.read(TestObject12.class); assertEquals(101, obj.field1); } @JsonObject(asExtraForUnknownProperties = true) public static class TestObject13 { } public void test_unknown_properties() throws IOException { JsonIterator iter = JsonIterator.parse("{\"field-1\": 100, \"field-1\": 101}"); try { iter.read(TestObject13.class); fail(); } catch (JsonException e) { System.out.println(e); } } public static class TestObject14 { @JsonProperty(required = true) public int field1; @JsonMissingProperties public List missingProperties; } public void test_required_properties_not_missing() throws IOException { JsonIterator iter = JsonIterator.parse("{\"field1\": 100}"); TestObject14 obj = iter.read(TestObject14.class); assertNull(obj.missingProperties); assertEquals(100, obj.field1); } @JsonObject(unknownPropertiesBlacklist = {"field1"}) public static class TestObject15 { } public void test_unknown_properties_blacklist() throws IOException { JsonIterator iter = JsonIterator.parse("{\"field1\": 100}"); try { iter.read(TestObject15.class); fail(); } catch (JsonException e) { System.out.println(e); } } public static class TestObject16 { @JsonProperty(implementation = LinkedList.class) public List values; } public void test_specify_property() throws IOException { JsonIterator iter = JsonIterator.parse("{\"values\": [100]}"); TestObject16 obj = iter.read(TestObject16.class); assertEquals(Arrays.asList(100), obj.values); assertEquals(LinkedList.class, obj.values.getClass()); } public static class TestObject17 { public int field1; public void setField1(int field1) { this.field1 = field1; } @JsonCreator public void initialize(@JsonProperty("field1") int field1) { } } public void test_name_conflict() throws IOException { JsonIterator iter = JsonIterator.parse("{}"); assertNotNull(iter.read(TestObject17.class)); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestArray.java000066400000000000000000000171411304664171100251150ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.any.Any; import com.jsoniter.spi.TypeLiteral; import junit.framework.TestCase; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.List; import static org.junit.Assert.assertArrayEquals; public class TestArray extends TestCase { static { // JsonIterator.setMode(DecodingMode.REFLECTION_MODE); } public void test_empty_array() throws IOException { JsonIterator iter = JsonIterator.parse("[]"); assertFalse(iter.readArray()); iter.reset(iter.buf); int[] array = iter.read(int[].class); assertEquals(0, array.length); iter.reset(iter.buf); List list = iter.read(new TypeLiteral>() { }); assertEquals(0, list.size()); iter.reset(iter.buf); Any any = iter.readAny(); assertEquals(0, any.size()); } public void test_one_element() throws IOException { JsonIterator iter = JsonIterator.parse("[1]"); assertTrue(iter.readArray()); assertEquals(1, iter.readInt()); assertFalse(iter.readArray()); iter.reset(iter.buf); int[] array = iter.read(int[].class); assertArrayEquals(new int[]{1}, array); iter.reset(iter.buf); List list = iter.read(new TypeLiteral>() { }); assertEquals(Arrays.asList(1), list); iter.reset(iter.buf); assertArrayEquals(new Object[]{1.0}, iter.read(Object[].class)); iter.reset(iter.buf); assertEquals(1, iter.read(Any[].class)[0].toInt()); iter.reset(iter.buf); assertEquals(1, iter.readAny().toInt(0)); iter.reset(iter.buf); final List values = new ArrayList(); iter.readArrayCB(new JsonIterator.ReadArrayCallback() { @Override public boolean handle(JsonIterator iter, Object attachment) throws IOException { values.add(iter.readInt()); return true; } }, null); assertEquals(Arrays.asList(1), values); } public void test_two_elements() throws IOException { JsonIterator iter = JsonIterator.parse(" [ 1 , 2 ] "); assertTrue(iter.readArray()); assertEquals(1, iter.readInt()); assertTrue(iter.readArray()); assertEquals(2, iter.readInt()); assertFalse(iter.readArray()); iter.reset(iter.buf); int[] array = iter.read(int[].class); assertArrayEquals(new int[]{1, 2}, array); iter.reset(iter.buf); List list = iter.read(new TypeLiteral>() { }); assertEquals(Arrays.asList(1, 2), list); iter.reset(iter.buf); assertArrayEquals(new Object[]{1.0, 2.0}, iter.read(Object[].class)); iter.reset(iter.buf); assertEquals(1, iter.read(Any[].class)[0].toInt()); iter.reset(iter.buf); assertEquals(1, iter.readAny().toInt(0)); iter = JsonIterator.parse(" [ 1 , null, 2 ] "); assertEquals(Arrays.asList(1.0D, null, 2.0D), iter.read()); } public void test_three_elements() throws IOException { JsonIterator iter = JsonIterator.parse(" [ 1 , 2, 3 ] "); assertTrue(iter.readArray()); assertEquals(1, iter.readInt()); assertTrue(iter.readArray()); assertEquals(2, iter.readInt()); assertTrue(iter.readArray()); assertEquals(3, iter.readInt()); assertFalse(iter.readArray()); iter.reset(iter.buf); int[] array = iter.read(int[].class); assertArrayEquals(new int[]{1, 2, 3}, array); iter.reset(iter.buf); List list = iter.read(new TypeLiteral>() { }); assertEquals(Arrays.asList(1, 2, 3), list); iter.reset(iter.buf); assertArrayEquals(new Object[]{1.0, 2.0, 3.0}, iter.read(Object[].class)); iter.reset(iter.buf); assertEquals(1, iter.read(Any[].class)[0].toInt()); iter.reset(iter.buf); assertEquals(1, iter.readAny().toInt(0)); } public void test_four_elements() throws IOException { JsonIterator iter = JsonIterator.parse(" [ 1 , 2, 3, 4 ] "); assertTrue(iter.readArray()); assertEquals(1, iter.readInt()); assertTrue(iter.readArray()); assertEquals(2, iter.readInt()); assertTrue(iter.readArray()); assertEquals(3, iter.readInt()); assertTrue(iter.readArray()); assertEquals(4, iter.readInt()); assertFalse(iter.readArray()); iter.reset(iter.buf); int[] array = iter.read(int[].class); assertArrayEquals(new int[]{1, 2, 3, 4}, array); iter.reset(iter.buf); List list = iter.read(new TypeLiteral>() { }); assertEquals(Arrays.asList(1, 2, 3, 4), list); iter.reset(iter.buf); assertArrayEquals(new Object[]{1.0, 2.0, 3.0, 4.0}, iter.read(Object[].class)); iter.reset(iter.buf); assertEquals(1, iter.read(Any[].class)[0].toInt()); iter.reset(iter.buf); assertEquals(1, iter.readAny().toInt(0)); } public void test_five_elements() throws IOException { JsonIterator iter = JsonIterator.parse(" [ 1 , 2, 3, 4, 5 ] "); assertTrue(iter.readArray()); assertEquals(1, iter.readInt()); assertTrue(iter.readArray()); assertEquals(2, iter.readInt()); assertTrue(iter.readArray()); assertEquals(3, iter.readInt()); assertTrue(iter.readArray()); assertEquals(4, iter.readInt()); assertTrue(iter.readArray()); assertEquals(5, iter.readInt()); assertFalse(iter.readArray()); iter.reset(iter.buf); int[] array = iter.read(int[].class); assertArrayEquals(new int[]{1, 2, 3, 4, 5}, array); iter.reset(iter.buf); List list = iter.read(new TypeLiteral>() { }); assertEquals(Arrays.asList(1, 2, 3, 4, 5), list); iter.reset(iter.buf); assertArrayEquals(new Object[]{1.0, 2.0, 3.0, 4.0, 5.0}, iter.read(Object[].class)); iter.reset(iter.buf); assertEquals(1, iter.read(Any[].class)[0].toInt()); iter.reset(iter.buf); assertEquals(1, iter.readAny().toInt(0)); } public void test_null() throws IOException { JsonIterator iter = JsonIterator.parse("null"); assertNull(iter.read(double[].class)); } public void test_boolean_array() throws IOException { JsonIterator iter = JsonIterator.parse("[true, false, true]"); assertArrayEquals(new boolean[]{true, false, true}, iter.read(boolean[].class)); } public void test_iterator() throws IOException { Any any = JsonIterator.deserialize("[1,2,3,4]"); Iterator iter = any.iterator(); assertEquals(1, iter.next().toInt()); iter = any.iterator(); assertEquals(1, iter.next().toInt()); assertEquals(2, iter.next().toInt()); iter = any.iterator(); assertEquals(1, iter.next().toInt()); assertEquals(2, iter.next().toInt()); assertEquals(3, iter.next().toInt()); iter = any.iterator(); assertEquals(1, iter.next().toInt()); assertEquals(2, iter.next().toInt()); assertEquals(3, iter.next().toInt()); assertEquals(4, iter.next().toInt()); assertFalse(iter.hasNext()); } public void test_array_lazy_any_to_string() { Any any = JsonIterator.deserialize("[1,2,3]"); any.asList().add(Any.wrap(4)); assertEquals("[1,2,3,4]", any.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestBoolean.java000066400000000000000000000017351304664171100254200ustar00rootroot00000000000000package com.jsoniter; import junit.framework.TestCase; import java.io.ByteArrayInputStream; import java.io.IOException; public class TestBoolean extends TestCase { @org.junit.experimental.categories.Category(StreamingCategory.class) public void test_streaming() throws IOException { JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream("[true,false,null,true]".getBytes()), 3); iter.readArray(); assertTrue(iter.readBoolean()); iter.readArray(); assertFalse(iter.readBoolean()); iter.readArray(); assertTrue(iter.readNull()); iter.readArray(); assertTrue(iter.readBoolean()); } public void test_non_streaming() throws IOException { assertTrue(JsonIterator.parse("true").readBoolean()); assertFalse(JsonIterator.parse("false").readBoolean()); assertTrue(JsonIterator.parse("null").readNull()); assertFalse(JsonIterator.parse("false").readNull()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestCustomizeType.java000066400000000000000000000063051304664171100266630ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.EmptyExtension; import com.jsoniter.spi.JsoniterSpi; import junit.framework.TestCase; import java.io.IOException; import java.lang.reflect.Type; import java.util.Date; public class TestCustomizeType extends TestCase { public static class MyDate { Date date; } static { JsoniterSpi.registerTypeDecoder(MyDate.class, new Decoder() { @Override public Object decode(final JsonIterator iter) throws IOException { return new MyDate() {{ date = new Date(iter.readLong()); }}; } }); // JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_STRICTLY); // JsonIterator.setMode(DecodingMode.REFLECTION_MODE); } public void test_direct() throws IOException { JsonIterator iter = JsonIterator.parse("1481365190000"); MyDate date = iter.read(MyDate.class); assertEquals(1481365190000L, date.date.getTime()); } public static class FieldWithMyDate { public MyDate field; } public void test_as_field_type() throws IOException { JsonIterator iter = JsonIterator.parse("{'field': 1481365190000}".replace('\'', '"')); FieldWithMyDate obj = iter.read(FieldWithMyDate.class); assertEquals(1481365190000L, obj.field.date.getTime()); } public void test_as_array_element() throws IOException { JsonIterator iter = JsonIterator.parse("[1481365190000]"); MyDate[] dates = iter.read(MyDate[].class); assertEquals(1481365190000L, dates[0].date.getTime()); } public static class MyDate2 { Date date; } public static class FieldWithMyDate2 { public MyDate2 field; } public void test_customize_through_extension() throws IOException { JsoniterSpi.registerExtension(new EmptyExtension() { @Override public Decoder createDecoder(String cacheKey, Type type) { if (type == MyDate2.class) { return new Decoder() { @Override public Object decode(final JsonIterator iter1) throws IOException { return new MyDate2() {{ date = new Date(iter1.readLong()); }}; } }; } return null; } }); JsonIterator iter = JsonIterator.parse("{'field': 1481365190000}".replace('\'', '"')); FieldWithMyDate2 obj = iter.read(FieldWithMyDate2.class); assertEquals(1481365190000L, obj.field.date.getTime()); } public static interface MyInterface { } public static class MyObject implements MyInterface { public long field1; } public void test_customize_impl() throws IOException { JsoniterSpi.registerTypeImplementation(MyInterface.class, MyObject.class); JsonIterator iter = JsonIterator.parse("{'field1': 1481365190000}".replace('\'', '"')); MyObject obj = (MyObject) iter.read(MyInterface.class); assertEquals(1481365190000L, obj.field1); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestDemo.java000066400000000000000000000146151304664171100247260ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.annotation.JsonProperty; import com.jsoniter.any.Any; import com.jsoniter.fuzzy.MaybeEmptyArrayDecoder; import com.jsoniter.fuzzy.MaybeStringLongDecoder; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; import com.jsoniter.spi.Decoder; import com.jsoniter.spi.EmptyExtension; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.TypeLiteral; import junit.framework.TestCase; import java.io.IOException; import java.lang.reflect.Type; import java.util.Date; import java.util.List; public class TestDemo extends TestCase { public void test_bind_api() throws IOException { JsonIterator iter = JsonIterator.parse("[0,1,2,3]"); int[] val = iter.read(int[].class); System.out.println(val[3]); } public void test_any_api() throws IOException { JsonIterator iter = JsonIterator.parse("[0,1,2,3]"); System.out.println(iter.readAny().toInt(3)); } public void test_iterator_api() throws IOException { JsonIterator iter = JsonIterator.parse("[0,1,2,3]"); int total = 0; while (iter.readArray()) { total += iter.readInt(); } System.out.println(total); } public static class ABC { public Any a; } public void test_abc() throws IOException { JsonIterator iter = JsonIterator.parse("{'a': {'b': {'c': 'd'}}}".replace('\'', '"')); ABC abc = iter.read(ABC.class); assertEquals("d", abc.a.get("b", "c").object()); } public void test_iterator_api_and_bind() throws IOException { JsonIterator iter = JsonIterator.parse("[123, {'name': 'taowen', 'tags': ['crazy', 'hacker']}]".replace('\'', '"')); iter.readArray(); int userId = iter.readInt(); iter.readArray(); User user = iter.read(User.class); user.userId = userId; iter.readArray(); // end of array System.out.println(user); } public void test_empty_array_as_null() throws IOException { JsoniterSpi.registerExtension(new EmptyExtension() { @Override public Decoder createDecoder(final String cacheKey, final Type type) { if (cacheKey.endsWith(".original")) { // avoid infinite loop return null; } if (type != Date.class) { return null; } return new Decoder() { @Override public Object decode(JsonIterator iter1) throws IOException { if (iter1.whatIsNext() == ValueType.ARRAY) { if (iter1.readArray()) { // none empty array throw iter1.reportError("decode [] as null", "only empty array is expected"); } else { return null; } } else { // just use original decoder TypeLiteral typeLiteral = new TypeLiteral(type, cacheKey + ".original", TypeLiteral.create(type).getDecoderCacheKey()); return iter1.read(typeLiteral); } } }; } }); JsonIterator iter = JsonIterator.parse("[]"); assertNull(iter.read(Date.class)); } public static class Order { @JsonProperty(decoder = MaybeStringLongDecoder.class) public long order_id; @JsonProperty(decoder = MaybeEmptyArrayDecoder.class) public OrderDetails order_details; } public static class OrderDetails { public String pay_type; } public void test_iterator() throws IOException { JsonIterator iter = JsonIterator.parse("{'numbers': ['1', '2', ['3', '4']]}".replace('\'', '"')); assertEquals("numbers", iter.readObject()); assertTrue(iter.readArray()); assertEquals("1", iter.readString()); assertTrue(iter.readArray()); assertEquals("2", iter.readString()); assertTrue(iter.readArray()); assertEquals(ValueType.ARRAY, iter.whatIsNext()); assertTrue(iter.readArray()); // start inner array assertEquals(ValueType.STRING, iter.whatIsNext()); assertEquals("3", iter.readString()); assertTrue(iter.readArray()); assertEquals("4", iter.readString()); assertFalse(iter.readArray()); // end inner array assertFalse(iter.readArray()); // end outer array assertNull(iter.readObject()); // end object } public void test_any_is_fun() throws IOException { Any any = JsonIterator.deserialize("{'numbers': ['1', '2', ['3', '4']]}".replace('\'', '"')); any.get("numbers").asList().add(Any.wrap("hello")); assertEquals("{'numbers':['1', '2', ['3', '4'],'hello']}".replace('\'', '"'), JsonStream.serialize(any)); any = JsonIterator.deserialize("{'error': 'failed'}".replace('\'', '"')); assertFalse(any.toBoolean("success")); any = JsonIterator.deserialize("{'success': true}".replace('\'', '"')); assertTrue(any.toBoolean("success")); any = JsonIterator.deserialize("{'success': 'false'}".replace('\'', '"')); assertFalse(any.toBoolean("success")); any = JsonIterator.deserialize("[{'score':100}, {'score':102}]".replace('\'', '"')); assertEquals("[100,102]", JsonStream.serialize(any.get('*', "score"))); any = JsonIterator.deserialize("[{'score':100}, {'score':[102]}]".replace('\'', '"')); assertEquals("[{},{'score':102}]".replace('\'', '"'), JsonStream.serialize(any.get('*', '*', 0))); any = JsonIterator.deserialize("[{'score':100}, {'score':102}]".replace('\'', '"')); assertEquals(Long.class, any.get(0, "score").object().getClass()); any = JsonIterator.deserialize("[{'score':100}, {'score':102}]".replace('\'', '"')); assertEquals(ValueType.INVALID, any.get(0, "score", "number").valueType()); any = JsonIterator.deserialize("[{'score':100}, {'score':102}]".replace('\'', '"')); for (Any record : any) { Any.EntryIterator entries = record.entries(); while (entries.next()) { System.out.println(entries.key()); System.out.println(entries.value()); } } } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestExisting.java000066400000000000000000000050311304664171100256240ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.TypeLiteral; import junit.framework.TestCase; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedList; import java.util.List; public class TestExisting extends TestCase { static { // JsonIterator.setMode(DecodingMode.REFLECTION_MODE); } public static class TestObj1 { public String field1; public String field2; } public void test_direct_reuse() throws IOException { TestObj1 testObj = new TestObj1(); testObj.field2 = "world"; JsonIterator iter = JsonIterator.parse("{ 'field1' : 'hello' }".replace('\'', '"')); TestObj1 oldObj = testObj; testObj = iter.read(testObj); assertEquals("hello", testObj.field1); assertEquals(System.identityHashCode(oldObj), System.identityHashCode(testObj)); } public static class TestObj2 { public String field3; public TestObj1 field4; } public void test_indirect_reuse() throws IOException { TestObj2 testObj = new TestObj2(); testObj.field4 = new TestObj1(); testObj.field4.field1 = "world"; JsonIterator iter = JsonIterator.parse("{ 'field3' : 'hello', 'field4': {'field2': 'hello'} }".replace('\'', '"')); TestObj2 oldObj = testObj; testObj = iter.read(testObj); assertEquals("hello", testObj.field3); assertEquals("hello", testObj.field4.field2); assertEquals(System.identityHashCode(oldObj), System.identityHashCode(testObj)); } public void test_reuse_list() throws IOException { List list1 = new ArrayList(); JsonIterator iter = JsonIterator.parse("[1]"); List list2= iter.read(new TypeLiteral>(){}, list1); assertEquals(System.identityHashCode(list2), System.identityHashCode(list1)); } public void test_reuse_linked_list() throws IOException { LinkedList list1 = new LinkedList(); JsonIterator iter = JsonIterator.parse("[1]"); List list2= iter.read(new TypeLiteral>(){}, list1); assertEquals(System.identityHashCode(list2), System.identityHashCode(list1)); } public void test_reuse_map() throws IOException { JsonIterator iter = JsonIterator.parse("{ 'field1' : 'hello' }".replace('\'', '"')); HashMap map1 = new HashMap(); map1.put("a", "b"); HashMap map2 = iter.read(map1); assertEquals("b", map2.get("a")); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestFloat.java000066400000000000000000000050211304664171100250760ustar00rootroot00000000000000package com.jsoniter; import junit.framework.TestCase; import org.junit.experimental.categories.Category; import java.io.ByteArrayInputStream; import java.io.IOException; public class TestFloat extends TestCase { private boolean isStreaming; public void test_positive_negative() throws IOException { // positive assertEquals(12.3f, parseFloat("12.3,")); assertEquals(12.3d, parseDouble("12.3,")); // negative assertEquals(-12.3f, parseFloat("-12.3,")); assertEquals(-12.3d, parseDouble("-12.3,")); } public void test_long_double() throws IOException { double d = JsonIterator.deserialize("4593560419846153055", double.class); assertEquals(4593560419846153055d, d, 0.1); } public void test_ieee_754() throws IOException { assertEquals(0.00123f, parseFloat("123e-5,")); assertEquals(0.00123d, parseDouble("123e-5,")); } public void test_decimal_places() throws IOException { assertEquals(Long.MAX_VALUE, parseFloat("9223372036854775807,"), 0.01f); assertEquals(Long.MAX_VALUE, parseDouble("9223372036854775807,"), 0.01f); assertEquals(9923372036854775807f, parseFloat("9923372036854775807,"), 0.01f); assertEquals(9923372036854775807d, parseDouble("9923372036854775807,"), 0.01f); assertEquals(720368.54775807f, parseFloat("720368.54775807,"), 0.01f); assertEquals(720368.54775807d, parseDouble("720368.54775807,"), 0.01f); assertEquals(72036.854775807f, parseFloat("72036.854775807,"), 0.01f); assertEquals(72036.854775807d, parseDouble("72036.854775807,"), 0.01f); assertEquals(720368.54775807f, parseFloat("720368.547758075,"), 0.01f); assertEquals(720368.54775807d, parseDouble("720368.547758075,"), 0.01f); } @Category(StreamingCategory.class) public void test_streaming() throws IOException { isStreaming = true; test_positive_negative(); test_decimal_places(); } private float parseFloat(String input) throws IOException { if (isStreaming) { return JsonIterator.parse(new ByteArrayInputStream(input.getBytes()), 2).readFloat(); } else { return JsonIterator.parse(input).readFloat(); } } private double parseDouble(String input) throws IOException { if (isStreaming) { return JsonIterator.parse(new ByteArrayInputStream(input.getBytes()), 2).readDouble(); } else { return JsonIterator.parse(input).readDouble(); } } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestGenerics.java000066400000000000000000000105441304664171100255760ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.Binding; import com.jsoniter.spi.ClassDescriptor; import com.jsoniter.spi.JsoniterSpi; import com.jsoniter.spi.TypeLiteral; import junit.framework.TestCase; import java.io.IOException; import java.util.*; import static org.junit.Assert.assertArrayEquals; public class TestGenerics extends TestCase { static { // JsonIterator.setMode(DecodingMode.REFLECTION_MODE); } public void test_int_list() throws IOException { JsonIterator iter = JsonIterator.parse("[1,2,3]"); List val = iter.read(new TypeLiteral>() { }); assertArrayEquals(new Integer[]{1, 2, 3}, val.toArray(new Integer[0])); } public void test_string_list() throws IOException { JsonIterator iter = JsonIterator.parse("['hello', 'world']".replace('\'', '"')); List val = iter.read(new TypeLiteral>() { }); assertArrayEquals(new String[]{"hello", "world"}, val.toArray(new String[0])); } public void test_linked_list() throws IOException { JsonIterator iter = JsonIterator.parse("['hello', 'world']".replace('\'', '"')); List val = iter.read(new TypeLiteral>() { }); assertArrayEquals(new String[]{"hello", "world"}, val.toArray(new String[0])); } public void test_string_set() throws IOException { JsonIterator iter = JsonIterator.parse("['hello']".replace('\'', '"')); Set val = iter.read(new TypeLiteral>() { }); assertArrayEquals(new String[]{"hello"}, val.toArray(new String[0])); } public void test_string_map() throws IOException { JsonIterator iter = JsonIterator.parse("{'hello': 'world'}".replace('\'', '"')); Map val = iter.read(new TypeLiteral>() { }); assertEquals("world", val.get("hello")); } public void test_list_of_list() throws Exception { JsonIterator iter = JsonIterator.parse("[[1,2],[3,4]]"); List> listOfList = iter.read(new TypeLiteral>>() { }); assertEquals(Integer.valueOf(4), listOfList.get(1).get(1)); } public void test_complex_object() throws IOException { JsonIterator iter = JsonIterator.parse("{'field1': 100, 'field2': [[1,2],[3,4]]}".replace('\'', '"')); ComplexObject val = iter.read(ComplexObject.class); assertEquals(100, val.field1); assertEquals(Integer.valueOf(4), val.field2.get(1).get(1)); } public static class Class1 { public List field1; public B[] field2; public List[] field3; public List field4; public List>> getField6() { return null; } public T getField7() { return null; } public void setField8(List a) { } } public static class Class2 extends Class1 { public E field5; } public static class Class3 extends Class2 { } public void test_generic_super_class() throws IOException { ClassDescriptor desc = JsoniterSpi.getDecodingClassDescriptor(Class3.class, true); Map fieldDecoderCacheKeys = new HashMap(); for (Binding field : desc.allDecoderBindings()) { fieldDecoderCacheKeys.put(field.name, field.valueTypeLiteral.getDecoderCacheKey()); } for (Binding field : JsoniterSpi.getEncodingClassDescriptor(Class3.class, true).getters) { fieldDecoderCacheKeys.put(field.name, field.valueTypeLiteral.getDecoderCacheKey()); } assertEquals(new HashMap() {{ put("field1", "decoder.java.util.List_java.lang.String"); put("field2", "decoder.java.lang.Integer_array"); put("field3", "decoder.java.util.List_java.lang.Integer_array"); put("field4", "decoder.java.util.List_java.lang.String_array"); put("field5", "decoder.java.lang.Float"); put("field6", "decoder.java.util.List_java.util.Map_java.lang.String_java.util.List_java.lang.Integer"); put("field7", "decoder.java.lang.Object"); put("field8", "decoder.java.util.List_java.lang.String"); }}, fieldDecoderCacheKeys); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestIO.java000066400000000000000000000026241304664171100243460ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.JsonException; import junit.framework.TestCase; import java.io.ByteArrayInputStream; import java.io.IOException; @org.junit.experimental.categories.Category(StreamingCategory.class) public class TestIO extends TestCase { public void test_read_byte() throws IOException { JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream("1".getBytes()), 4096); assertEquals('1', IterImpl.readByte(iter)); try { IterImpl.readByte(iter); fail(); } catch (JsonException e) { } } public void test_read_bytes() throws IOException { JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream("12".getBytes()), 4096); assertEquals('1', IterImpl.readByte(iter)); assertEquals('2', IterImpl.readByte(iter)); try { IterImpl.readByte(iter); fail(); } catch (JsonException e) { } } public void test_unread_byte() throws IOException { JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream("12".getBytes()), 4096); assertEquals('1', IterImpl.readByte(iter)); assertEquals('2', IterImpl.readByte(iter)); iter.unreadByte(); assertEquals('2', IterImpl.readByte(iter)); iter.unreadByte(); iter.unreadByte(); assertEquals('1', IterImpl.readByte(iter)); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestInteger.java000066400000000000000000000065011304664171100254320ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.JsonException; import junit.framework.TestCase; import org.junit.experimental.categories.Category; import java.io.ByteArrayInputStream; import java.io.IOException; public class TestInteger extends TestCase { private boolean isStreaming; public void test_positive_negative_int() throws IOException { assertEquals(4321, parseInt("4321")); assertEquals(54321, parseInt("54321")); assertEquals(654321, parseInt("654321")); assertEquals(7654321, parseInt("7654321")); assertEquals(87654321, parseInt("87654321")); assertEquals(987654321, parseInt("987654321")); assertEquals(-4321, parseInt("-4321")); } public void test_positive_negative_long() throws IOException { assertEquals(4321L, parseLong("4321")); assertEquals(54321L, parseLong("54321")); assertEquals(654321L, parseLong("654321")); assertEquals(7654321L, parseLong("7654321")); assertEquals(87654321L, parseLong("87654321")); assertEquals(987654321L, parseLong("987654321")); assertEquals(-4321L, parseLong("-4321")); } public void test_max_min_int() throws IOException { assertEquals(Integer.MAX_VALUE, parseInt(Integer.toString(Integer.MAX_VALUE))); assertEquals(Integer.MAX_VALUE - 1, parseInt(Integer.toString(Integer.MAX_VALUE - 1))); assertEquals(Integer.MIN_VALUE + 1, parseInt(Integer.toString(Integer.MIN_VALUE + 1))); assertEquals(Integer.MIN_VALUE, parseInt(Integer.toString(Integer.MIN_VALUE))); } public void test_max_min_long() throws IOException { assertEquals(Long.MAX_VALUE, parseLong(Long.toString(Long.MAX_VALUE))); assertEquals(Long.MAX_VALUE - 1, parseLong(Long.toString(Long.MAX_VALUE - 1))); assertEquals(Long.MIN_VALUE + 1, parseLong(Long.toString(Long.MIN_VALUE + 1))); assertEquals(Long.MIN_VALUE, parseLong(Long.toString(Long.MIN_VALUE))); } public void test_large_number() throws IOException { try { JsonIterator.deserialize(Integer.toString(Integer.MIN_VALUE) + "1", Integer.class); fail(); } catch (JsonException e) { } try { JsonIterator.deserialize(Long.toString(Long.MAX_VALUE) + "1", Long.class); fail(); } catch (JsonException e) { } } @Category(StreamingCategory.class) public void test_streaming() throws IOException { isStreaming = true; test_positive_negative_int(); test_positive_negative_long(); test_max_min_int(); test_max_min_long(); test_large_number(); } private int parseInt(String input) throws IOException { if (isStreaming) { JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream(input.getBytes()), 2); return iter.readInt(); } else { JsonIterator iter = JsonIterator.parse(input); return iter.readInt(); } } private long parseLong(String input) throws IOException { if (isStreaming) { JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream(input.getBytes()), 2); return iter.readLong(); } else { JsonIterator iter = JsonIterator.parse(input); return iter.readLong(); } } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestNested.java000066400000000000000000000046641304664171100252670ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.any.Any; import junit.framework.TestCase; import org.junit.Assert; import java.io.IOException; public class TestNested extends TestCase { public void test_array_of_objects() throws IOException { JsonIterator iter = JsonIterator.parse( "[{'field1':'11','field2':'12'},{'field1':'21','field2':'22'}]".replace('\'', '"')); SimpleObject[] objects = iter.read(SimpleObject[].class); Assert.assertArrayEquals(new SimpleObject[]{ new SimpleObject() {{ field1 = "11"; field2 = "12"; }}, new SimpleObject() {{ field1 = "21"; field2 = "22"; }} }, objects); iter.reset(iter.buf); Any any = iter.readAny(); assertEquals("22", any.toString(1, "field2")); } public void test_get_all_array_elements_via_any() throws IOException { Any any = JsonIterator.deserialize(" [ { \"bar\": 1 }, {\"bar\": 3} ]"); Any result = any.get('*', "bar"); assertEquals("[ 1, 3]", result.toString()); any = Any.rewrap(any.asList()); // make it not lazy result = any.get('*', "bar"); assertEquals("[ 1, 3]", result.toString()); } public void test_get_all_object_values_via_any() throws IOException { Any any = JsonIterator.deserialize("{\"field1\":[1,2],\"field2\":[3,4]}"); Any result = any.get('*', 1); assertEquals("{\"field1\":2,\"field2\":4}", result.toString()); any = Any.rewrap(any.asMap()); // make it not lazy result = any.get('*', 1); assertEquals("{\"field1\":2,\"field2\":4}", result.toString()); } public void test_get_all_with_some_invalid_path() throws IOException { Any any = JsonIterator.deserialize(" [ { \"bar\": 1 }, {\"foo\": 3} ]"); Any result = any.get('*', "bar"); assertEquals("[ 1]", result.toString()); any = Any.rewrap(any.asList()); // make it not lazy result = any.get('*', "bar"); assertEquals("[ 1]", result.toString()); any = JsonIterator.deserialize("{\"field1\":[1,2],\"field2\":[3]}"); result = any.get('*', 1); assertEquals("{\"field1\":2}", result.toString()); any = Any.rewrap(any.asMap()); // make it not lazy result = any.get('*', 1); assertEquals("{\"field1\":2}", result.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestObject.java000066400000000000000000000210221304664171100252360ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.annotation.JsonProperty; import com.jsoniter.annotation.JsoniterAnnotationSupport; import com.jsoniter.any.Any; import com.jsoniter.fuzzy.MaybeEmptyArrayDecoder; import com.jsoniter.spi.EmptyExtension; import com.jsoniter.spi.JsonException; import com.jsoniter.spi.JsoniterSpi; import junit.framework.TestCase; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.Map; public class TestObject extends TestCase { static { // JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_STRICTLY); } public static class EmptyClass { } public void test_empty_class() throws IOException { JsonIterator iter = JsonIterator.parse("{}"); assertNotNull(iter.read(EmptyClass.class)); } public void test_empty_object() throws IOException { JsonIterator iter = JsonIterator.parse("{}"); assertNull(iter.readObject()); iter.reset(iter.buf); SimpleObject simpleObj = iter.read(SimpleObject.class); assertNull(simpleObj.field1); iter.reset(iter.buf); Object obj = iter.read(Object.class); assertEquals(0, ((Map)obj).size()); iter.reset(iter.buf); Any any = iter.readAny(); assertEquals(0, any.size()); } public void test_one_field() throws IOException { JsonIterator iter = JsonIterator.parse("{ 'field1'\r:\n\t'hello' }".replace('\'', '"')); assertEquals("field1", iter.readObject()); assertEquals("hello", iter.readString()); assertNull(iter.readObject()); iter.reset(iter.buf); SimpleObject simpleObj = iter.read(SimpleObject.class); assertEquals("hello", simpleObj.field1); assertNull(simpleObj.field2); iter.reset(iter.buf); Any any = iter.readAny(); assertEquals("hello", any.toString("field1")); assertEquals(ValueType.INVALID, any.get("field2").valueType()); iter.reset(iter.buf); assertEquals("hello", ((Map)iter.read()).get("field1")); } public void test_two_fields() throws IOException { // JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); JsonIterator iter = JsonIterator.parse("{ 'field1' : 'hello' , 'field2': 'world' }".replace('\'', '"')); assertEquals("field1", iter.readObject()); assertEquals("hello", iter.readString()); assertEquals("field2", iter.readObject()); assertEquals("world", iter.readString()); assertNull(iter.readObject()); iter.reset(iter.buf); SimpleObject simpleObj = iter.read(SimpleObject.class); assertEquals("hello", simpleObj.field1); assertEquals("world", simpleObj.field2); iter.reset(iter.buf); Any any = iter.readAny(); assertEquals("hello", any.toString("field1")); assertEquals("world", any.toString("field2")); iter.reset(iter.buf); final ArrayList fields = new ArrayList(); iter.readObjectCB(new JsonIterator.ReadObjectCallback() { @Override public boolean handle(JsonIterator iter, String field, Object attachment) throws IOException { fields.add(field); iter.skip(); return true; } }, null); assertEquals(Arrays.asList("field1", "field2"), fields); } public void test_read_null() throws IOException { JsonIterator iter = JsonIterator.parse("null".replace('\'', '"')); assertTrue(iter.readNull()); iter.reset(iter.buf); SimpleObject simpleObj = iter.read(SimpleObject.class); assertNull(simpleObj); iter.reset(iter.buf); Any any = iter.readAny(); assertEquals(ValueType.NULL, any.get().valueType()); } public void test_native_field() throws IOException { JsonIterator iter = JsonIterator.parse("{ 'field1' : 100 }".replace('\'', '"')); ComplexObject complexObject = iter.read(ComplexObject.class); assertEquals(100, complexObject.field1); iter.reset(iter.buf); Any any = iter.readAny(); assertEquals(100, any.toInt("field1")); } public static class InheritedObject extends SimpleObject { public String inheritedField; } public void test_inheritance() throws IOException { JsonIterator iter = JsonIterator.parse("{'inheritedField': 'hello'}".replace('\'', '"')); InheritedObject inheritedObject = iter.read(InheritedObject.class); assertEquals("hello", inheritedObject.inheritedField); } public void test_incomplete_field_name() throws IOException { try { JsonIterator.parse("{\"abc").read(InheritedObject.class); fail(); } catch (JsonException e) { } } public static interface IDependenceInjectedObject { String getSomeService(); } public static class DependenceInjectedObject implements IDependenceInjectedObject { private String someService; public DependenceInjectedObject(String someService) { this.someService = someService; } public String getSomeService() { return someService; } } public void test_object_creation() throws IOException { JsoniterSpi.registerExtension(new EmptyExtension() { @Override public boolean canCreate(Class clazz) { return clazz.equals(DependenceInjectedObject.class) || clazz.equals(IDependenceInjectedObject.class); } @Override public Object create(Class clazz) { return new DependenceInjectedObject("hello"); } }); IDependenceInjectedObject obj = JsonIterator.deserialize("{}", IDependenceInjectedObject.class); assertEquals("hello", obj.getSomeService()); } public static class TestObject5 { public enum MyEnum { HELLO, WORLD, WOW } public MyEnum field1; } public void test_enum() throws IOException { // JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); TestObject5 obj = JsonIterator.deserialize("{\"field1\":\"HELLO\"}", TestObject5.class); assertEquals(TestObject5.MyEnum.HELLO, obj.field1); try { JsonIterator.deserialize("{\"field1\":\"HELLO1\"}", TestObject5.class); fail(); } catch (JsonException e) { } obj = JsonIterator.deserialize("{\"field1\":null}", TestObject5.class); assertNull(obj.field1); obj = JsonIterator.deserialize("{\"field1\":\"WOW\"}", TestObject5.class); assertEquals(TestObject5.MyEnum.WOW, obj.field1); } public static class TestObject6 { @JsonProperty(decoder = MaybeEmptyArrayDecoder.class) public Map field1; } public void test_maybe_empty_array_field() { JsoniterAnnotationSupport.enable(); TestObject6 obj = JsonIterator.deserialize("{\"field1\":[]}", TestObject6.class); assertNull(obj.field1); } public void test_iterator() { Any any = JsonIterator.deserialize("{\"field1\":1,\"field2\":2,\"field3\":3}"); Any.EntryIterator iter = any.entries(); assertTrue(iter.next()); assertEquals("field1", iter.key()); assertEquals(1, iter.value().toInt()); iter = any.entries(); assertTrue(iter.next()); assertEquals("field1", iter.key()); assertEquals(1, iter.value().toInt()); assertTrue(iter.next()); assertEquals("field2", iter.key()); assertEquals(2, iter.value().toInt()); assertTrue(iter.next()); assertEquals("field3", iter.key()); assertEquals(3, iter.value().toInt()); assertFalse(iter.next()); } public static class PublicSuper { public String field1; } private static class PrivateSub extends PublicSuper { } public static class TestObject7 { public PrivateSub field1; public void setFieldXXX(PrivateSub obj) { } } public void test_private_ref() throws IOException { TestObject7 obj = JsonIterator.deserialize("{}", TestObject7.class); assertNull(obj.field1); } public void test_object_lazy_any_to_string() { Any any = JsonIterator.deserialize("{\"field1\":1,\"field2\":2,\"field3\":3}"); any.asMap().put("field4", Any.wrap(4)); assertEquals("{\"field1\":1,\"field3\":3,\"field2\":2,\"field4\":4}", any.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestReadAny.java000066400000000000000000000202051304664171100253550ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.any.Any; import com.jsoniter.spi.JsonException; import junit.framework.TestCase; import org.junit.experimental.categories.Category; import java.io.ByteArrayInputStream; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; public class TestReadAny extends TestCase { static { // JsonIterator.enableStreamingSupport(); } public void test_read_any() throws IOException { JsonIterator iter = JsonIterator.parse("[0,1,2,3]"); assertEquals(3, iter.readAny().toInt(3)); } public void test_bind_to_any() throws IOException { JsonIterator iter = JsonIterator.parse("{'field3': 100}".replace('\'', '"')); ComplexObject obj = iter.read(ComplexObject.class); System.out.println(obj.field3); } public void test_read_any_from_string() throws IOException { JsonIterator iter = JsonIterator.parse("{'numbers': ['1', '2', ['3', '4']]}".replace('\'', '"')); assertEquals(3, iter.readAny().toInt("numbers", 2, 0)); } public void test_read_int() throws IOException { assertEquals(100, JsonIterator.deserialize("100").toInt()); assertEquals(0, JsonIterator.deserialize("null").toInt()); assertEquals(100, JsonIterator.deserialize("\"100\"").toInt()); assertEquals(1, JsonIterator.deserialize("true").toInt()); Any any = JsonIterator.deserialize("100"); assertEquals(Long.valueOf(100), any.object()); assertEquals(100, any.toInt()); assertEquals(100L, any.toLong()); assertEquals(100F, any.toFloat()); assertEquals(100D, any.toDouble()); assertEquals("100", any.toString()); } public void test_read_boolean() throws IOException { assertEquals(true, JsonIterator.deserialize("100").toBoolean()); assertEquals(false, JsonIterator.deserialize("{}").toBoolean()); assertEquals(true, JsonIterator.deserialize("{\"field1\":100}").toBoolean()); assertEquals(false, JsonIterator.deserialize("null").toBoolean()); assertEquals(true, JsonIterator.deserialize("\"100\"").toBoolean()); assertEquals(true, JsonIterator.deserialize("true").toBoolean()); assertEquals(1, JsonIterator.deserialize("true").toInt()); assertEquals(0, JsonIterator.deserialize("false").toInt()); assertEquals("false", JsonIterator.deserialize("false").toString()); assertEquals(Boolean.FALSE, JsonIterator.deserialize("false").object()); } public void test_read_int_array() throws IOException { JsonIterator iter = JsonIterator.parse("[100,101]"); Any any = iter.readAny(); assertEquals(100, any.toInt(0)); assertEquals(101, any.toInt(1)); } public void test_read_int_object() throws IOException { JsonIterator iter = JsonIterator.parse("{\"field1\":100}"); Any any = iter.readAny(); assertEquals(100, any.toInt("field1")); } public void test_read_float_as_int() throws IOException { JsonIterator iter = JsonIterator.parse("[\"100.1\",\"101.1\"]"); Any any = iter.readAny(); assertEquals(100, any.toInt(0)); assertEquals(101, any.toInt(1)); } public void test_read_string() throws IOException { assertEquals("hello", JsonIterator.deserialize("\"hello\"").toString()); assertEquals("true", JsonIterator.deserialize("true").toString()); assertEquals("null", JsonIterator.deserialize("null").toString()); assertEquals("100", JsonIterator.deserialize("100").toString()); assertEquals(100, JsonIterator.deserialize("\"100\"").toInt()); assertEquals(true, JsonIterator.deserialize("\"hello\"").toBoolean()); } public void test_read_int_as_string() throws IOException { JsonIterator iter = JsonIterator.parse("100.5"); Any any = iter.readAny(); assertEquals("100.5", any.toString()); } public void test_get() throws IOException { assertEquals("100.5", JsonIterator.deserialize("100.5").get().toString()); assertEquals("100.5", JsonIterator.deserialize("[100.5]").get(0).toString()); assertEquals(ValueType.INVALID, JsonIterator.deserialize("null").get(0).valueType()); assertEquals(ValueType.INVALID, JsonIterator.deserialize("[]").get(0).valueType()); assertEquals(ValueType.INVALID, JsonIterator.deserialize("[]").get("hello").valueType()); assertEquals(ValueType.INVALID, JsonIterator.deserialize("{}").get(0).valueType()); } public void test_read_long() throws IOException { assertEquals(100L, JsonIterator.deserialize("100").toLong()); assertEquals(100L, JsonIterator.deserialize("100.1").toLong()); Any any = JsonIterator.deserialize("\"100.1\""); assertEquals(100L, any.toLong()); assertEquals(100L, any.toLong()); } public void test_read_float() throws IOException { assertEquals(100.0F, JsonIterator.deserialize("100").toFloat()); assertEquals(100.1F, JsonIterator.deserialize("100.1").toFloat()); assertEquals(100.1F, JsonIterator.deserialize("\"100.1\"").toFloat()); } public void test_size() throws IOException { assertEquals(0, JsonIterator.deserialize("[]").size()); assertEquals(1, JsonIterator.deserialize("[1]").size()); assertEquals(2, JsonIterator.deserialize("[1,2]").size()); assertEquals(1, JsonIterator.deserialize("{\"field1\":1}").size()); } public void test_keys() throws IOException { assertEquals(new HashSet(Arrays.asList("field1")), JsonIterator.deserialize("{\"field1\":1}").keys()); assertEquals(new HashSet(Arrays.asList()), JsonIterator.deserialize("[3,5]").keys()); } public void test_read_double() throws IOException { assertEquals(100.0D, JsonIterator.deserialize("100").toDouble()); assertEquals(100.1D, JsonIterator.deserialize("100.1").toDouble()); assertEquals(100.1D, JsonIterator.deserialize("\"100.1\"").toDouble()); } public static class TestObject1 { public int field1; } public void test_read_class() throws IOException { TestObject1 obj = JsonIterator.deserialize("{\"field1\": 100}").as(TestObject1.class); assertEquals(100, obj.field1); } public void test_read_multiple_field() throws IOException { Any any = JsonIterator.deserialize("{\"a\":1,\"b\":2,\"c\":3}"); assertEquals(2, any.toInt("b")); assertEquals(1, any.toInt("a")); assertEquals(3, any.toInt("c")); any = JsonIterator.deserialize("{\"a\":1,\"b\":2,\"c\":3}"); assertEquals(3, any.toInt("c")); assertEquals(2, any.toInt("b")); assertEquals(1, any.toInt("a")); } public void test_require_path() throws IOException { assertNotNull(JsonIterator.deserialize("null").get()); try { JsonIterator.deserialize("[]").get(0).object(); } catch (JsonException e) { System.out.println(e); } try { Any.rewrap(new ArrayList()).get(0).object(); } catch (JsonException e) { System.out.println(e); } try { JsonIterator.deserialize("{}").get("hello").object(); } catch (JsonException e) { System.out.println(e); } try { Any.rewrap(new HashMap()).get("hello").object(); } catch (JsonException e) { System.out.println(e); } } @Category(StreamingCategory.class) public void test_read_any_in_streaming() throws IOException { assertEquals(2, JsonIterator.parse(new ByteArrayInputStream("[1,2,3,4,5]".getBytes()), 2).readAny().toInt(1)); assertEquals(1, JsonIterator.parse(new ByteArrayInputStream("{\"field1\": 1}".getBytes()), 2).readAny().size()); JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream("[1,2,[3, 4],5]".getBytes()), 2); ArrayList elements = new ArrayList(); while (iter.readArray()) { elements.add(iter.readAny()); } assertEquals("[3, 4]", elements.get(2).toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestReflection.java000066400000000000000000000026621304664171100261330ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.JsoniterSpi; import junit.framework.TestCase; import java.io.IOException; public class TestReflection extends TestCase { public static class PackageLocal { String field; } public void test_package_local() throws IOException { JsoniterSpi.registerTypeDecoder(PackageLocal.class, ReflectionDecoderFactory.create(PackageLocal.class)); JsonIterator iter = JsonIterator.parse("{'field': 'hello'}".replace('\'', '"')); PackageLocal obj = iter.read(PackageLocal.class); assertEquals("hello", obj.field); } public static class Inherited extends PackageLocal { } public void test_inherited() throws IOException { JsoniterSpi.registerTypeDecoder(Inherited.class, ReflectionDecoderFactory.create(Inherited.class)); JsonIterator iter = JsonIterator.parse("{'field': 'hello'}".replace('\'', '"')); Inherited obj = iter.read(Inherited.class); assertEquals("hello", obj.field); } public static class ObjectWithInt { private int field; } public void test_int_field() throws IOException { JsoniterSpi.registerTypeDecoder(ObjectWithInt.class, ReflectionDecoderFactory.create(ObjectWithInt.class)); JsonIterator iter = JsonIterator.parse("{'field': 100}".replace('\'', '"')); ObjectWithInt obj = iter.read(ObjectWithInt.class); assertEquals(100, obj.field); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestSkip.java000066400000000000000000000053061304664171100247450ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.JsonException; import junit.framework.TestCase; import org.junit.experimental.categories.Category; import java.io.ByteArrayInputStream; import java.io.IOException; public class TestSkip extends TestCase { public void test_skip_number() throws IOException { JsonIterator iter = JsonIterator.parse("[1,2]"); assertTrue(iter.readArray()); iter.skip(); assertTrue(iter.readArray()); assertEquals(2, iter.readInt()); assertFalse(iter.readArray()); } public void test_skip_string() throws IOException { JsonIterator iter = JsonIterator.parse("['hello',2]".replace('\'', '"')); assertTrue(iter.readArray()); iter.skip(); assertTrue(iter.readArray()); assertEquals(2, iter.readInt()); assertFalse(iter.readArray()); } @Category(StreamingCategory.class) public void test_skip_string_streaming() throws IOException { JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream("\"hello".getBytes()), 2); try { iter.skip(); fail(); } catch (JsonException e) { } iter = JsonIterator.parse(new ByteArrayInputStream("\"hello\"".getBytes()), 2); iter.skip(); iter = JsonIterator.parse(new ByteArrayInputStream("\"hello\"1".getBytes()), 2); iter.skip(); assertEquals(1, iter.readInt()); iter = JsonIterator.parse(new ByteArrayInputStream("\"h\\\"ello\"1".getBytes()), 3); iter.skip(); assertEquals(1, iter.readInt()); iter = JsonIterator.parse(new ByteArrayInputStream("\"\\\\\"1".getBytes()), 3); iter.skip(); assertEquals(1, iter.readInt()); } public void test_skip_object() throws IOException { JsonIterator iter = JsonIterator.parse("[{'hello': {'world': 'a'}},2]".replace('\'', '"')); assertTrue(iter.readArray()); iter.skip(); assertTrue(iter.readArray()); assertEquals(2, iter.readInt()); assertFalse(iter.readArray()); } public void test_skip_array() throws IOException { JsonIterator iter = JsonIterator.parse("[ [1, 3] ,2]".replace('\'', '"')); assertTrue(iter.readArray()); iter.skip(); assertTrue(iter.readArray()); assertEquals(2, iter.readInt()); assertFalse(iter.readArray()); } public void test_skip_nested() throws IOException { JsonIterator iter = JsonIterator.parse("[ [1, {'a': ['b'] }, 3] ,2]".replace('\'', '"')); assertTrue(iter.readArray()); iter.skip(); assertTrue(iter.readArray()); assertEquals(2, iter.readInt()); assertFalse(iter.readArray()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestSlice.java000066400000000000000000000011501304664171100250670ustar00rootroot00000000000000package com.jsoniter; import junit.framework.TestCase; import java.util.HashMap; public class TestSlice extends TestCase { public void test_equals() { assertTrue(Slice.make("hello").equals(Slice.make("hello"))); assertTrue(Slice.make("hello").equals(new Slice("ahello".getBytes(), 1, 6))); } public void test_hashcode() { HashMap map = new HashMap(); map.put(Slice.make("hello"), "hello"); map.put(Slice.make("world"), "world"); assertEquals("hello", map.get(Slice.make("hello"))); assertEquals("world", map.get(Slice.make("world"))); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestString.java000066400000000000000000000111261304664171100253020ustar00rootroot00000000000000package com.jsoniter; import com.jsoniter.spi.JsonException; import junit.framework.TestCase; import org.junit.experimental.categories.Category; import java.io.ByteArrayInputStream; import java.io.IOException; public class TestString extends TestCase { static { // JsonIterator.enableStreamingSupport(); } public void test_ascii_string() throws IOException { JsonIterator iter = JsonIterator.parse("'hello''world'".replace('\'', '"')); assertEquals("hello", iter.readString()); assertEquals("world", iter.readString()); iter = JsonIterator.parse("'hello''world'".replace('\'', '"')); assertEquals("hello", iter.readStringAsSlice().toString()); assertEquals("world", iter.readStringAsSlice().toString()); } public void test_ascii_string_with_escape() throws IOException { JsonIterator iter = JsonIterator.parse("'he\\tllo'".replace('\'', '"')); assertEquals("he\tllo", iter.readString()); } public void test_utf8_string() throws IOException { JsonIterator iter = JsonIterator.parse("'中文'".replace('\'', '"')); assertEquals("中文", iter.readString()); } public void test_incomplete_escape() throws IOException { JsonIterator iter = JsonIterator.parse("\"\\"); try { iter.readString(); fail(); } catch (JsonException e) { } } public void test_surrogate() throws IOException { JsonIterator iter = JsonIterator.parse("\"\ud83d\udc4a\""); assertEquals("\ud83d\udc4a", iter.readString()); } public void test_larger_than_buffer() throws IOException { JsonIterator iter = JsonIterator.parse("'0123456789012345678901234567890123'".replace('\'', '"')); assertEquals("0123456789012345678901234567890123", iter.readString()); } @org.junit.experimental.categories.Category(StreamingCategory.class) public void test_string_across_buffer() throws IOException { JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream("'hello''world'".replace('\'', '"').getBytes()), 2); assertEquals("hello", iter.readString()); assertEquals("world", iter.readString()); iter = JsonIterator.parse(new ByteArrayInputStream("'hello''world'".replace('\'', '"').getBytes()), 2); assertEquals("hello", iter.readStringAsSlice().toString()); assertEquals("world", iter.readStringAsSlice().toString()); } @org.junit.experimental.categories.Category(StreamingCategory.class) public void test_utf8() throws IOException { byte[] bytes = {'"', (byte) 0xe4, (byte) 0xb8, (byte) 0xad, (byte) 0xe6, (byte) 0x96, (byte) 0x87, '"'}; JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream(bytes), 2); assertEquals("中文", iter.readString()); } @org.junit.experimental.categories.Category(StreamingCategory.class) public void test_normal_escape() throws IOException { byte[] bytes = {'"', (byte) '\\', (byte) 't', '"'}; JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream(bytes), 2); assertEquals("\t", iter.readString()); } @org.junit.experimental.categories.Category(StreamingCategory.class) public void test_unicode_escape() throws IOException { byte[] bytes = {'"', (byte) '\\', (byte) 'u', (byte) '4', (byte) 'e', (byte) '2', (byte) 'd', '"'}; JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream(bytes), 2); assertEquals("中", iter.readString()); } public void test_null_string() throws IOException { JsonIterator iter = JsonIterator.parse("null".replace('\'', '"')); assertEquals(null, iter.readString()); } public void test_incomplete_string() throws IOException { try { JsonIterator.deserialize("\"abc", String.class); fail(); } catch (JsonException e) { } } public void test_long_string() throws IOException { JsonIterator iter = JsonIterator.parse("\"[\\\"LL\\\",\\\"MM\\\\\\/LW\\\",\\\"JY\\\",\\\"S\\\",\\\"C\\\",\\\"IN\\\",\\\"ME \\\\\\/ LE\\\"]\""); assertEquals("[\"LL\",\"MM\\/LW\",\"JY\",\"S\",\"C\",\"IN\",\"ME \\/ LE\"]", iter.readString()); } @Category(StreamingCategory.class) public void test_long_string_in_streaming() throws IOException { JsonIterator iter = JsonIterator.parse(new ByteArrayInputStream("\"[\\\"LL\\\",\\\"MM\\\\\\/LW\\\",\\\"JY\\\",\\\"S\\\",\\\"C\\\",\\\"IN\\\",\\\"ME \\\\\\/ LE\\\"]\"".getBytes()), 2); assertEquals("[\"LL\",\"MM\\/LW\",\"JY\",\"S\",\"C\",\"IN\",\"ME \\/ LE\"]", iter.readString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/TestWhatIsNext.java000066400000000000000000000004561304664171100260760ustar00rootroot00000000000000package com.jsoniter; import junit.framework.TestCase; import java.io.IOException; public class TestWhatIsNext extends TestCase { public void test() throws IOException { JsonIterator parser = JsonIterator.parse("{}"); assertEquals(ValueType.OBJECT, parser.whatIsNext()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/User.java000066400000000000000000000001661304664171100241140ustar00rootroot00000000000000package com.jsoniter; public class User { public int userId; public String name; public String[] tags; } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/any/000077500000000000000000000000001304664171100231175ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/any/TestArray.java000066400000000000000000000031561304664171100257050ustar00rootroot00000000000000package com.jsoniter.any; import junit.framework.TestCase; import java.util.ArrayList; import java.util.Arrays; public class TestArray extends TestCase { public void test_size() { Any any = Any.wrap(new int[]{1, 2, 3}); assertEquals(3, any.size()); } public void test_to_boolean() { Any any = Any.wrap(new int[0]); assertFalse(any.toBoolean()); any = Any.wrap(new Object[]{"hello", 1}); assertTrue(any.toBoolean()); } public void test_to_int() { Any any = Any.wrap(new int[0]); assertEquals(0, any.toInt()); any = Any.wrap(new Object[]{"hello", 1}); assertEquals(2, any.toInt()); } public void test_get() { Any any = Any.wrap(new Object[]{"hello", 1}); assertEquals("hello", any.get(0).toString()); } public void test_get_from_nested() { Any any = Any.wrap(new Object[]{new String[]{"hello"}, new String[]{"world"}}); assertEquals("hello", any.get(0, 0).toString()); assertEquals("[\"hello\",\"world\"]", any.get('*', 0).toString()); } public void test_iterator() { Any any = Any.wrap(new long[]{1, 2, 3}); ArrayList list = new ArrayList(); for (Any element : any) { list.add(element.toInt()); } assertEquals(Arrays.asList(1, 2, 3), list); } public void test_to_string() { assertEquals("[1,2,3]", Any.wrap(new long[]{1, 2, 3}).toString()); Any any = Any.wrap(new long[]{1, 2, 3}); any.asList().add(Any.wrap(4)); assertEquals("[1,2,3,4]", any.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/any/TestList.java000066400000000000000000000032121304664171100255330ustar00rootroot00000000000000package com.jsoniter.any; import junit.framework.TestCase; import java.util.ArrayList; import java.util.Arrays; public class TestList extends TestCase { public void test_size() { Any any = Any.wrap(Arrays.asList(1, 2, 3)); assertEquals(3, any.size()); } public void test_to_boolean() { Any any = Any.wrap(Arrays.asList()); assertFalse(any.toBoolean()); any = Any.wrap(Arrays.asList("hello", 1)); assertTrue(any.toBoolean()); } public void test_to_int() { Any any = Any.wrap(Arrays.asList()); assertEquals(0, any.toInt()); any = Any.wrap(Arrays.asList("hello", 1)); assertEquals(2, any.toInt()); } public void test_get() { Any any = Any.wrap(Arrays.asList("hello", 1)); assertEquals("hello", any.get(0).toString()); } public void test_get_from_nested() { Any any = Any.wrap(Arrays.asList(Arrays.asList("hello"), Arrays.asList("world"))); assertEquals("hello", any.get(0, 0).toString()); assertEquals("[\"hello\",\"world\"]", any.get('*', 0).toString()); } public void test_iterator() { Any any = Any.wrap(Arrays.asList(1, 2, 3)); ArrayList list = new ArrayList(); for (Any element : any) { list.add(element.toInt()); } assertEquals(Arrays.asList(1, 2, 3), list); } public void test_to_string() { assertEquals("[1,2,3]", Any.wrap(Arrays.asList(1, 2, 3)).toString()); Any any = Any.wrap(Arrays.asList(1, 2, 3)); any.asList().add(Any.wrap(4)); assertEquals("[1,2,3,4]", any.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/any/TestMap.java000066400000000000000000000040261304664171100253410ustar00rootroot00000000000000package com.jsoniter.any; import junit.framework.TestCase; import java.util.Arrays; import java.util.HashMap; import java.util.Map; public class TestMap extends TestCase { public void test_size() { Any any = Any.wrap(mapOf("hello", 1, "world", 2)); assertEquals(2, any.size()); } public void test_to_boolean() { Any any = Any.wrap(mapOf()); assertFalse(any.toBoolean()); any = Any.wrap(mapOf("hello", 1)); assertTrue(any.toBoolean()); } public void test_to_int() { Any any = Any.wrap(mapOf()); assertEquals(0, any.toInt()); any = Any.wrap(mapOf("hello", 1)); assertEquals(1, any.toInt()); } public void test_get() { Any any = Any.wrap(mapOf("hello", 1, "world", 2)); assertEquals(2, any.get("world").toInt()); } public void test_get_from_nested() { Any any = Any.wrap(mapOf("a", mapOf("b", "c"), "d", mapOf("e", "f"))); assertEquals("c", any.get("a", "b").toString()); assertEquals("{\"a\":\"c\"}", any.get('*', "b").toString()); } public void test_iterator() { Any any = Any.wrap(mapOf("hello", 1, "world", 2)); Any.EntryIterator iter = any.entries(); HashMap map = new HashMap(); while (iter.next()) { map.put(iter.key(), iter.value().toInt()); } assertEquals(mapOf("hello", 1, "world", 2), map); } public void test_to_string() { assertEquals("{\"world\":2,\"hello\":1}", Any.wrap(mapOf("hello", 1, "world", 2)).toString()); Any any = Any.wrap(mapOf("hello", 1, "world", 2)); any.asMap().put("abc", Any.wrap(3)); assertEquals("{\"world\":2,\"abc\":3,\"hello\":1}", any.toString()); } private static Map mapOf(Object... args) { HashMap map = new HashMap(); for (int i = 0; i < args.length; i += 2) { map.put((String) args[i], args[i + 1]); } return map; } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/extra/000077500000000000000000000000001304664171100234535ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/extra/TestBase64.java000066400000000000000000000007351304664171100262070ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.JsonIterator; import com.jsoniter.output.JsonStream; import junit.framework.TestCase; public class TestBase64 extends TestCase { static { Base64Support.enable(); } public void test_encode() { assertEquals("\"YWJj\"", JsonStream.serialize("abc".getBytes())); } public void test_decode() { assertEquals("abc", new String(JsonIterator.deserialize("\"YWJj\"", byte[].class))); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/extra/TestBase64Float.java000066400000000000000000000017571304664171100272020ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.JsonIterator; import com.jsoniter.output.JsonStream; import junit.framework.TestCase; public class TestBase64Float extends TestCase { static { Base64FloatSupport.enableEncodersAndDecoders(); } public void test_Double() { String json = JsonStream.serialize(0.123456789d); assertEquals(0.123456789d, JsonIterator.deserialize(json, Double.class)); } public void test_double() { String json = JsonStream.serialize(new double[]{0.123456789d}); assertEquals(0.123456789d, JsonIterator.deserialize(json, double[].class)[0]); } public void test_Float() { String json = JsonStream.serialize(0.12345678f); assertEquals(0.12345678f, JsonIterator.deserialize(json, Float.class)); } public void test_float() { String json = JsonStream.serialize(new float[]{0.12345678f}); assertEquals(0.12345678f, JsonIterator.deserialize(json, float[].class)[0]); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/extra/TestJdkDatetime.java000066400000000000000000000011041304664171100273370ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.JsonIterator; import com.jsoniter.extra.JdkDatetimeSupport; import com.jsoniter.output.JsonStream; import junit.framework.TestCase; import java.util.Date; public class TestJdkDatetime extends TestCase { public void test() { JdkDatetimeSupport.enable("yyyy-MM-dd'T'HH:mm:ss.SSSZ"); assertEquals("\"1970-01-01T08:00:00.000+0800\"", JsonStream.serialize(new Date(0))); Date obj = JsonIterator.deserialize("\"1970-01-01T08:00:00.000+0800\"", Date.class); assertEquals(0, obj.getTime()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/extra/TestNamingStrategy.java000066400000000000000000000007531304664171100301170ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.output.JsonStream; import junit.framework.TestCase; public class TestNamingStrategy extends TestCase { public static class TestObject1 { public String helloWorld; } public void test() { NamingStrategySupport.enable(NamingStrategySupport.SNAKE_CASE); TestObject1 obj = new TestObject1(); obj.helloWorld = "!!!"; assertEquals("{\"hello_world\":\"!!!\"}", JsonStream.serialize(obj)); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/extra/TestPreciseFloat.java000066400000000000000000000016461304664171100275450ustar00rootroot00000000000000package com.jsoniter.extra; import com.jsoniter.output.JsonStream; import junit.framework.TestCase; public class TestPreciseFloat extends TestCase { static { PreciseFloatSupport.enable(); } public void test_direct_encode() { assertEquals("0.123456789", JsonStream.serialize(0.123456789d)); assertEquals("0.12345678", JsonStream.serialize(0.12345678f)); } public static class TestObject1 { public Double field1; public double field2; public Float field3; public float field4; } public void test_indirect_encode() { TestObject1 obj = new TestObject1(); obj.field1 = 0.12345678d; obj.field2 = 0.12345678d; obj.field3 = 0.12345678f; obj.field4 = 0.12345678f; assertEquals("{\"field1\":0.12345678,\"field2\":0.12345678,\"field3\":0.12345678,\"field4\":0.12345678}", JsonStream.serialize(obj)); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/output/000077500000000000000000000000001304664171100236705ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/output/TestAnnotation.java000066400000000000000000000050611304664171100275070ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.annotation.JsonIgnore; import com.jsoniter.annotation.JsonProperty; import com.jsoniter.annotation.JsonUnwrapper; import com.jsoniter.annotation.JsoniterAnnotationSupport; import com.jsoniter.spi.Encoder; import junit.framework.TestCase; import java.io.ByteArrayOutputStream; import java.io.IOException; public class TestAnnotation extends TestCase { static { JsoniterAnnotationSupport.enable(); // JsonStream.setMode(EncodingMode.DYNAMIC_MODE); } private ByteArrayOutputStream baos; private JsonStream stream; public void setUp() { baos = new ByteArrayOutputStream(); stream = new JsonStream(baos, 4096); } public static class TestObject1 { @JsonProperty(to = {"field-1"}) public String field1; } public void test_property() throws IOException { TestObject1 obj = new TestObject1(); obj.field1 = "hello"; stream.writeVal(obj); stream.close(); assertEquals("{\"field-1\":\"hello\"}", baos.toString()); } public static class TestObject2 { @JsonProperty(encoder = Encoder.StringIntEncoder.class) public int field1; } public void test_encoder() throws IOException { TestObject2 obj = new TestObject2(); obj.field1 = 100; stream.writeVal(obj); stream.close(); assertEquals("{\"field1\":\"100\"}", baos.toString()); } public static class TestObject3 { @JsonIgnore public int field1; } public void test_ignore() throws IOException { TestObject3 obj = new TestObject3(); obj.field1 = 100; stream.writeVal(obj); stream.close(); assertEquals("{}", baos.toString()); } public static class TestObject4 { public int field1; public int getField1() { return field1; } } public void test_name_conflict() throws IOException { TestObject4 obj = new TestObject4(); stream.writeVal(obj); stream.close(); assertEquals("{\"field1\":0}", baos.toString()); } public static class TestObject5 { @JsonUnwrapper public void unwrap(JsonStream stream) throws IOException { stream.writeObjectField("hello"); stream.writeVal("world"); } } public void test_unwrapper() throws IOException { TestObject5 obj = new TestObject5(); stream.writeVal(obj); stream.close(); assertEquals("{\"hello\":\"world\"}", baos.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/output/TestAny.java000066400000000000000000000123711304664171100261260ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.ValueType; import com.jsoniter.any.*; import junit.framework.TestCase; import java.util.Arrays; import java.util.HashMap; public class TestAny extends TestCase { public void test_int() { Any any = Any.wrap(100); assertEquals(ValueType.NUMBER, any.valueType()); assertEquals("100", JsonStream.serialize(any)); assertEquals(Integer.valueOf(100), any.object()); assertEquals(100, any.toInt()); assertEquals(100L, any.toLong()); assertEquals(100D, any.toDouble()); assertEquals(100F, any.toFloat()); assertEquals("100", any.toString()); assertEquals(true, any.toBoolean()); any.set(101); assertEquals("101", any.toString()); } public void test_long() { Any any = Any.wrap(100L); assertEquals(ValueType.NUMBER, any.valueType()); assertEquals("100", JsonStream.serialize(any)); assertEquals(100, any.toInt()); assertEquals(100L, any.toLong()); assertEquals(100D, any.toDouble()); assertEquals(100F, any.toFloat()); assertEquals("100", any.toString()); assertEquals(true, any.toBoolean()); any.set(101L); assertEquals("101", any.toString()); } public void test_float() { Any any = Any.wrap(100F); assertEquals(ValueType.NUMBER, any.valueType()); assertEquals("100", JsonStream.serialize(any)); assertEquals(100, any.toInt()); assertEquals(100L, any.toLong()); assertEquals(100D, any.toDouble()); assertEquals(100F, any.toFloat()); assertEquals("100.0", any.toString()); assertEquals(true, any.toBoolean()); any.set(101F); assertEquals("101.0", any.toString()); } public void test_double() { Any any = Any.wrap(100D); assertEquals(ValueType.NUMBER, any.valueType()); assertEquals("100", JsonStream.serialize(any)); assertEquals(100, any.toInt()); assertEquals(100L, any.toLong()); assertEquals(100D, any.toDouble()); assertEquals(100F, any.toFloat()); assertEquals("100.0", any.toString()); assertEquals(true, any.toBoolean()); any.set(101D); assertEquals("101.0", any.toString()); } public void test_null() { Any any = Any.wrap((Object) null); assertEquals(ValueType.NULL, any.valueType()); assertEquals("null", JsonStream.serialize(any)); assertEquals(false, any.toBoolean()); assertEquals("null", any.toString()); } public void test_boolean() { Any any = Any.wrap(true); assertEquals(ValueType.BOOLEAN, any.valueType()); assertEquals("true", JsonStream.serialize(any)); assertEquals(1, any.toInt()); assertEquals(1L, any.toLong()); assertEquals(1F, any.toFloat()); assertEquals(1D, any.toDouble()); assertEquals("true", any.toString()); } public void test_string() { Any any = Any.wrap("hello"); assertEquals(ValueType.STRING, any.valueType()); assertEquals("\"hello\"", JsonStream.serialize(any)); any.set("100"); assertEquals(100, any.toInt()); assertEquals(100L, any.toLong()); assertEquals(100F, any.toFloat()); assertEquals(100D, any.toDouble()); assertEquals(true, any.toBoolean()); assertEquals("100", any.toString()); } public void test_list() { Any any = Any.wrap(Arrays.asList(1, 2, 3)); assertEquals(ValueType.ARRAY, any.valueType()); assertEquals("[1,2,3]", JsonStream.serialize(any)); assertEquals(Integer.valueOf(1), any.get(0).object()); assertEquals(true, any.toBoolean()); assertEquals("[1,2,3]", any.toString()); } public void test_array() { Any any = Any.wrap(new int[]{1, 2, 3}); assertEquals(ValueType.ARRAY, any.valueType()); assertEquals("[1,2,3]", JsonStream.serialize(any)); assertEquals(Integer.valueOf(1), any.get(0).object()); assertEquals(true, any.toBoolean()); assertEquals("[1,2,3]", any.toString()); } public void test_map() { HashMap val = new HashMap(); val.put("hello", 1); val.put("world", "!!"); Any any = Any.wrap(val); assertEquals(ValueType.OBJECT, any.valueType()); assertEquals("{\"world\":\"!!\",\"hello\":1}", JsonStream.serialize(any)); assertEquals(Integer.valueOf(1), any.get("hello").object()); assertEquals(true, any.toBoolean()); assertEquals("{\"world\":\"!!\",\"hello\":1}", any.toString()); } public static class MyClass { public Object field1; public Any field2; } public void test_my_class() { MyClass val = new MyClass(); val.field1 = "hello"; val.field2 = Any.wrap(new long[]{1, 2}); Any any = Any.wrap(val); assertEquals(ValueType.OBJECT, any.valueType()); assertEquals("{\"field1\":\"hello\",\"field2\":[1,2]}", JsonStream.serialize(any)); } public void test_object() { Any any = Any.wrap(new Object()); assertEquals(ValueType.OBJECT, any.valueType()); assertEquals("{}", JsonStream.serialize(new Object())); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/output/TestArray.java000066400000000000000000000073061304664171100264570ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.spi.TypeLiteral; import junit.framework.TestCase; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.util.*; public class TestArray extends TestCase { static { // JsonStream.setMode(EncodingMode.DYNAMIC_MODE); } private ByteArrayOutputStream baos; private JsonStream stream; public void setUp() { baos = new ByteArrayOutputStream(); stream = new JsonStream(baos, 4096); } public void test_gen_array() throws IOException { stream.writeVal(new String[]{"hello", "world"}); stream.close(); assertEquals("['hello','world']".replace('\'', '"'), baos.toString()); } public void test_collection() throws IOException { ArrayList list = new ArrayList(); list.add("hello"); list.add("world"); stream.writeVal(new TypeLiteral>() { }, list); stream.close(); assertEquals("['hello','world']".replace('\'', '"'), baos.toString()); } public void test_collection_without_type() throws IOException { ArrayList list = new ArrayList(); list.add("hello"); list.add("world"); stream.writeVal(list); stream.close(); assertEquals("['hello','world']".replace('\'', '"'), baos.toString()); } public void test_empty_array() throws IOException { stream.writeVal(new String[0]); stream.close(); assertEquals("[]".replace('\'', '"'), baos.toString()); } public void test_null_array() throws IOException { stream.writeVal(new TypeLiteral() { }, null); stream.close(); assertEquals("null".replace('\'', '"'), baos.toString()); } public void test_empty_collection() throws IOException { stream.writeVal(new ArrayList()); stream.close(); assertEquals("[]".replace('\'', '"'), baos.toString()); } public void test_null_collection() throws IOException { stream.writeVal(new TypeLiteral() { }, null); stream.close(); assertEquals("null".replace('\'', '"'), baos.toString()); } public static class TestObject1 { public List field1; } public void test_list_of_objects() throws IOException { TestObject1 obj = new TestObject1(); obj.field1 = Arrays.asList("a", "b"); stream.writeVal(new TypeLiteral>() { }, Arrays.asList(obj)); stream.close(); assertEquals("[{\"field1\":[\"a\",\"b\"]}]", baos.toString()); } public void test_array_of_null() throws IOException { stream.writeVal(new TestObject1[1]); stream.close(); assertEquals("[null]", baos.toString()); } public void test_list_of_null() throws IOException { TestObject1 obj = new TestObject1(); obj.field1 = Arrays.asList("a", "b"); ArrayList list = new ArrayList(); list.add(null); stream.writeVal(new TypeLiteral>() { }, list); stream.close(); assertEquals("[null]", baos.toString()); } public void test_hash_set() throws IOException { assertEquals("[]", JsonStream.serialize(new HashSet())); HashSet set = new HashSet(); set.add(1); assertEquals("[1]", JsonStream.serialize(set)); } public void test_arrays_as_list() throws IOException { assertEquals("[1,2,3]", JsonStream.serialize(Arrays.asList(1, 2, 3))); } public void test_default_empty_collection() throws IOException { assertEquals("[]", JsonStream.serialize(Collections.emptySet())); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/output/TestCustomizeField.java000066400000000000000000000024061304664171100303230ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.any.Any; import com.jsoniter.spi.Encoder; import com.jsoniter.spi.JsoniterSpi; import junit.framework.TestCase; import java.io.ByteArrayOutputStream; import java.io.IOException; public class TestCustomizeField extends TestCase { private ByteArrayOutputStream baos; private JsonStream stream; public void setUp() { baos = new ByteArrayOutputStream(); stream = new JsonStream(baos, 4096); } public static class TestObject1 { public String field1; } public void test_customize_field_decoder() throws IOException { JsoniterSpi.registerPropertyEncoder(TestObject1.class, "field1", new Encoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { String str = (String) obj; stream.writeVal(Integer.valueOf(str)); } @Override public Any wrap(Object obj) { throw new UnsupportedOperationException(); } }); TestObject1 obj = new TestObject1(); obj.field1 = "100"; stream.writeVal(obj); stream.close(); assertEquals("{'field1':100}".replace('\'', '"'), baos.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/output/TestCustomizeType.java000066400000000000000000000021001304664171100302100ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.spi.EmptyEncoder; import com.jsoniter.spi.JsoniterSpi; import junit.framework.TestCase; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.util.Date; public class TestCustomizeType extends TestCase { private ByteArrayOutputStream baos; private JsonStream stream; public void setUp() { baos = new ByteArrayOutputStream(); stream = new JsonStream(baos, 4096); } public static class MyDate { Date date; } public void test() throws IOException { JsoniterSpi.registerTypeEncoder(MyDate.class, new EmptyEncoder() { @Override public void encode(Object obj, JsonStream stream) throws IOException { MyDate date = (MyDate) obj; stream.writeVal(date.date.getTime()); } }); MyDate myDate = new MyDate(); myDate.date = new Date(1481365190000L); stream.writeVal(myDate); stream.close(); assertEquals("1481365190000", baos.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/output/TestMap.java000066400000000000000000000030621304664171100261110ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.spi.TypeLiteral; import junit.framework.TestCase; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.util.HashMap; import java.util.Map; public class TestMap extends TestCase { static { // JsonStream.setMode(EncodingMode.DYNAMIC_MODE); } private ByteArrayOutputStream baos; private JsonStream stream; public void setUp() { baos = new ByteArrayOutputStream(); stream = new JsonStream(baos, 4096); } public void test() throws IOException { HashMap map = new HashMap(); map.put("hello", "world"); stream.writeVal(map); stream.close(); assertEquals("{'hello':'world'}".replace('\'', '"'), baos.toString()); } public void test_empty() throws IOException { HashMap map = new HashMap(); stream.writeVal(map); stream.close(); assertEquals("{}".replace('\'', '"'), baos.toString()); } public void test_null() throws IOException { stream.writeVal(new TypeLiteral(){}, null); stream.close(); assertEquals("null".replace('\'', '"'), baos.toString()); } public void test_value_is_null() throws IOException { HashMap obj = new HashMap(); obj.put("hello", null); stream.writeVal(new TypeLiteral>(){}, obj); stream.close(); assertEquals("{\"hello\":null}", baos.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/output/TestNative.java000066400000000000000000000111531304664171100266220ustar00rootroot00000000000000package com.jsoniter.output; import junit.framework.TestCase; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.math.BigDecimal; import java.math.BigInteger; public class TestNative extends TestCase { static { // JsonStream.setMode(EncodingMode.REFLECTION_MODE); } private ByteArrayOutputStream baos; private JsonStream stream; public void setUp() { baos = new ByteArrayOutputStream(); stream = new JsonStream(baos, 4096); } public void test_string() throws IOException { stream = new JsonStream(baos, 32); stream.writeVal("1234567890123456789012345678901234567890"); stream.close(); assertEquals("'1234567890123456789012345678901234567890'".replace('\'', '"'), baos.toString()); } public void test_slash() throws IOException { stream.writeVal("/\\"); stream.close(); assertEquals("\"/\\\\\"", baos.toString()); } public void test_escape() throws IOException { stream.writeVal("hel\nlo"); stream.close(); assertEquals("'hel\\nlo'".replace('\'', '"'), baos.toString()); } public void test_utf8() throws IOException { stream.writeVal("中文"); stream.close(); assertEquals("\"\\u4e2d\\u6587\"", baos.toString()); } public void test_int() throws IOException { stream.writeVal(100); stream.close(); assertEquals("100", baos.toString()); } public void test_boxed_int() throws IOException { Object val = Integer.valueOf(100); stream.writeVal(val); stream.close(); assertEquals("100", baos.toString()); } public void test_negative_int() throws IOException { stream.writeVal(-100); stream.close(); assertEquals("-100", baos.toString()); } public void test_small_int() throws IOException { stream.writeVal(3); stream.close(); assertEquals("3", baos.toString()); } public void test_large_int() throws IOException { stream.writeVal(31415926); stream.close(); assertEquals("31415926", baos.toString()); } public void test_long() throws IOException { stream.writeVal(100L); stream.close(); assertEquals("100", baos.toString()); } public void test_negative_long() throws IOException { stream.writeVal(-100L); stream.close(); assertEquals("-100", baos.toString()); } public void test_short() throws IOException { stream.writeVal(((short)555)); stream.close(); assertEquals("555", baos.toString()); assertEquals("555", JsonStream.serialize(new Short((short)555))); } public void test_no_decimal_float() throws IOException { stream.writeVal(100f); stream.close(); assertEquals("100", baos.toString()); } public void test_float2() throws IOException { stream.writeVal(0.000001f); stream.close(); assertEquals("0.000001", baos.toString()); } public void test_float3() throws IOException { stream.writeVal(0.00001f); stream.close(); assertEquals("0.00001", baos.toString()); } public void test_big_float() throws IOException { stream.writeVal((float)0x4ffffff); stream.close(); assertEquals("83886080", baos.toString()); } public void test_double() throws IOException { stream.writeVal(1.001d); stream.close(); assertEquals("1.001", baos.toString()); } public void test_large_double() throws IOException { stream.writeVal(Double.MAX_VALUE); stream.close(); assertEquals("1.7976931348623157E308", baos.toString()); } public void test_boolean() throws IOException { stream.writeVal(true); stream.writeVal(false); stream.close(); assertEquals("truefalse".replace('\'', '"'), baos.toString()); } public void test_big_decimal() throws IOException { stream.writeVal(new BigDecimal("12.34")); stream.close(); assertEquals("12.34".replace('\'', '"'), baos.toString()); } public void test_big_integer() throws IOException { stream.writeVal(new BigInteger("1234")); stream.close(); assertEquals("1234".replace('\'', '"'), baos.toString()); } public void test_raw() throws IOException { stream = new JsonStream(baos, 32); String val = "1234567890123456789012345678901234567890"; stream.writeRaw(val, val.length()); stream.close(); assertEquals(val.replace('\'', '"'), baos.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/output/TestNested.java000066400000000000000000000052131304664171100266160ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.spi.TypeLiteral; import junit.framework.TestCase; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class TestNested extends TestCase { private ByteArrayOutputStream baos; private JsonStream stream; public void setUp() { baos = new ByteArrayOutputStream(); stream = new JsonStream(baos, 4096); } public static class TestObject1 { public String field1; public String field2; } public void test_array_of_objects() throws IOException { TestObject1 obj1 = new TestObject1(); obj1.field1 = "1"; obj1.field2 = "2"; stream.writeVal(new TestObject1[]{obj1}); stream.close(); assertEquals("[{'field1':'1','field2':'2'}]".replace('\'', '"'), baos.toString()); } public void test_collection_of_objects() throws IOException { final TestObject1 obj1 = new TestObject1(); obj1.field1 = "1"; obj1.field2 = "2"; stream.writeVal(new TypeLiteral>() { }, new ArrayList() {{ add(obj1); }}); stream.close(); assertEquals("[{'field1':'1','field2':'2'}]".replace('\'', '"'), baos.toString()); } public static class TestObject2 { public TestObject1[] objs; } public void test_object_of_array() throws IOException { stream.indentionStep = 2; TestObject2 obj = new TestObject2(); obj.objs = new TestObject1[1]; obj.objs[0] = new TestObject1(); obj.objs[0].field1 = "1"; obj.objs[0].field2 = "2"; stream.writeVal(obj); stream.close(); assertEquals("{\n" + " \"objs\":[\n" + " {\n" + " \"field1\":\"1\",\n" + " \"field2\":\"2\"\n" + " }\n" + " ]\n" + "}".replace('\'', '"'), baos.toString()); } public void test_map_of_objects() throws IOException { stream.indentionStep = 2; final TestObject1 obj1 = new TestObject1(); obj1.field1 = "1"; obj1.field2 = "2"; stream.writeVal(new TypeLiteral>() { }, new HashMap() {{ put("hello", obj1); }}); stream.close(); assertEquals("{\n" + " \"hello\":{\n" + " \"field1\":\"1\",\n" + " \"field2\":\"2\"\n" + " }\n" + "}".replace('\'', '"'), baos.toString()); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/output/TestObject.java000066400000000000000000000155651304664171100266150ustar00rootroot00000000000000package com.jsoniter.output; import com.jsoniter.annotation.JsonIgnore; import com.jsoniter.annotation.JsonProperty; import com.jsoniter.annotation.JsoniterAnnotationSupport; import com.jsoniter.spi.TypeLiteral; import junit.framework.TestCase; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.util.*; public class TestObject extends TestCase { static { JsoniterAnnotationSupport.enable(); // JsonStream.setMode(EncodingMode.DYNAMIC_MODE); } private ByteArrayOutputStream baos; private JsonStream stream; public void setUp() { baos = new ByteArrayOutputStream(); stream = new JsonStream(baos, 4096); } public static class TestObject1 { public String field1; } public void test_field() throws IOException { TestObject1 obj = new TestObject1(); obj.field1 = "hello"; stream.writeVal(obj); stream.close(); assertEquals("{'field1':'hello'}".replace('\'', '"'), baos.toString()); } public static class TestObject2 { @JsonIgnore private String field1; public String getField1() { return field1; } } public void test_getter() throws IOException { TestObject2 obj = new TestObject2(); obj.field1 = "hello"; stream.writeVal(obj); stream.close(); assertEquals("{'field1':'hello'}".replace('\'', '"'), baos.toString()); } public void test_null() throws IOException { stream.writeVal(new TypeLiteral() { }, null); stream.close(); assertEquals("null".replace('\'', '"'), baos.toString()); } public static class TestObject3 { } public void test_empty_object() throws IOException { stream.writeVal(new TestObject3()); stream.close(); assertEquals("{}".replace('\'', '"'), baos.toString()); } public static class TestObject4 { public String field1; } public void test_null_field() throws IOException { TestObject4 obj = new TestObject4(); stream.writeVal(obj); stream.close(); assertEquals("{}".replace('\'', '"'), baos.toString()); } public static enum MyEnum { HELLO } public static class TestObject5 { public MyEnum field1; } public void test_enum() throws IOException { TestObject5 obj = new TestObject5(); obj.field1 = MyEnum.HELLO; stream.writeVal(obj); stream.close(); assertEquals("{'field1':'HELLO'}".replace('\'', '"'), baos.toString()); } public static class TestObject6 { public int[] field1; } public void test_array_field() throws IOException { TestObject6 obj = new TestObject6(); obj.field1 = new int[]{1, 2, 3}; stream.writeVal(obj); stream.close(); assertEquals("{\"field1\":[1,2,3]}", baos.toString()); } public void test_array_field_is_null() throws IOException { TestObject6 obj = new TestObject6(); stream.writeVal(obj); stream.close(); assertEquals("{}", baos.toString()); } public static class TestObject7 { private int[] field1; @JsonProperty(omitNull = false) public int[] getField1() { return field1; } } public void test_array_field_is_null_via_getter() throws IOException { JsoniterAnnotationSupport.enable(); TestObject7 obj = new TestObject7(); stream.writeVal(obj); stream.close(); assertEquals("{\"field1\":null}", baos.toString()); } public static class TestObject8 { @JsonProperty(nullable = false) public String[] field1; } public void test_not_nullable() { JsoniterAnnotationSupport.enable(); TestObject8 obj = new TestObject8(); obj.field1 = new String[]{"hello"}; assertEquals("{\"field1\":[\"hello\"]}", JsonStream.serialize(obj)); if (Codegen.mode == EncodingMode.DYNAMIC_MODE) { try { JsonStream.serialize(new TestObject8()); fail(); } catch (NullPointerException e) { } } } public static class TestObject9 { @JsonProperty(collectionValueNullable = false) public String[] field1; @JsonProperty(collectionValueNullable = false) public List field2; @JsonProperty(collectionValueNullable = false) public Set field3; @JsonProperty(collectionValueNullable = false) public Map field4; } public void test_collection_value_not_nullable() { JsoniterAnnotationSupport.enable(); TestObject9 obj = new TestObject9(); obj.field1 = new String[]{"hello"}; assertEquals("{\"field1\":[\"hello\"]}", JsonStream.serialize(obj)); if (Codegen.mode == EncodingMode.DYNAMIC_MODE) { obj = new TestObject9(); obj.field1 = new String[]{null}; try { JsonStream.serialize(obj); fail(); } catch (NullPointerException e) { } obj = new TestObject9(); obj.field2 = new ArrayList(); obj.field2.add(null); try { JsonStream.serialize(obj); fail(); } catch (NullPointerException e) { } obj = new TestObject9(); obj.field3 = new HashSet(); obj.field3.add(null); try { JsonStream.serialize(obj); fail(); } catch (NullPointerException e) { } obj = new TestObject9(); obj.field4 = new HashMap(); obj.field4.put("hello", null); try { JsonStream.serialize(obj); fail(); } catch (NullPointerException e) { } } } public static class TestObject10 { @JsonProperty(omitNull = false) public String field1; } public void test_not_omit_null() { assertEquals("{\"field1\":null}", JsonStream.serialize(new TestObject10())); } public static class TestObject11 { public String field1; public String field2; public String field3; } public void test_omit_null() { // JsonStream.setMode(EncodingMode.DYNAMIC_MODE); assertEquals("{}", JsonStream.serialize(new TestObject11())); TestObject11 obj = new TestObject11(); obj.field1 = "hello"; assertEquals("{\"field1\":\"hello\"}", JsonStream.serialize(obj)); obj = new TestObject11(); obj.field2 = "hello"; assertEquals("{\"field2\":\"hello\"}", JsonStream.serialize(obj)); obj = new TestObject11(); obj.field3 = "hello"; assertEquals("{\"field3\":\"hello\"}", JsonStream.serialize(obj)); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/suite/000077500000000000000000000000001304664171100234615ustar00rootroot00000000000000java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/suite/AllTestCases.java000066400000000000000000000021011304664171100266450ustar00rootroot00000000000000package com.jsoniter.suite; import com.jsoniter.*; import com.jsoniter.TestArray; import com.jsoniter.any.*; import com.jsoniter.output.TestAny; import com.jsoniter.output.TestCustomizeField; import com.jsoniter.output.TestMap; import com.jsoniter.output.TestNative; import org.junit.runner.RunWith; import org.junit.runners.Suite; @RunWith(Suite.class) @Suite.SuiteClasses({TestAnnotation.class, TestArray.class, TestCustomizeType.class, TestDemo.class, TestExisting.class, TestGenerics.class, TestGenerics.class, TestIO.class, TestNested.class, TestObject.class, TestReadAny.class, TestReflection.class, TestSkip.class, TestSlice.class, TestString.class, TestWhatIsNext.class, com.jsoniter.output.TestAnnotation.class, TestAny.class, com.jsoniter.output.TestArray.class, TestCustomizeField.class, com.jsoniter.output.TestCustomizeType.class, TestMap.class, TestNative.class, TestNested.class, TestObject.class, TestBoolean.class, TestFloat.class, TestList.class, com.jsoniter.any.TestArray.class}) public abstract class AllTestCases { } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/suite/ExtraTests.java000066400000000000000000000004401304664171100264300ustar00rootroot00000000000000package com.jsoniter.suite; import com.jsoniter.extra.*; import org.junit.runner.RunWith; import org.junit.runners.Suite; @RunWith(Suite.class) @Suite.SuiteClasses({TestBase64.class, TestJdkDatetime.class, TestNamingStrategy.class, TestPreciseFloat.class}) public class ExtraTests { } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/suite/NonStreamingTests.java000066400000000000000000000005311304664171100277520ustar00rootroot00000000000000package com.jsoniter.suite; import com.jsoniter.StreamingCategory; import org.junit.experimental.categories.Categories; import org.junit.runner.RunWith; import org.junit.runners.Suite; @RunWith(Categories.class) @Categories.ExcludeCategory(StreamingCategory.class) @Suite.SuiteClasses({AllTestCases.class}) public class NonStreamingTests { } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/suite/NonStreamingTests4Hash.java000066400000000000000000000013211304664171100306400ustar00rootroot00000000000000package com.jsoniter.suite; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.StreamingCategory; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; import org.junit.BeforeClass; import org.junit.experimental.categories.Categories; import org.junit.runner.RunWith; import org.junit.runners.Suite; @RunWith(Categories.class) @Categories.ExcludeCategory(StreamingCategory.class) @Suite.SuiteClasses({AllTestCases.class}) public class NonStreamingTests4Hash { @BeforeClass public static void setup() { JsonStream.setMode(EncodingMode.DYNAMIC_MODE); JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_WITH_HASH); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/suite/NonStreamingTests4Strict.java000066400000000000000000000013231304664171100312270ustar00rootroot00000000000000package com.jsoniter.suite; import com.jsoniter.DecodingMode; import com.jsoniter.JsonIterator; import com.jsoniter.StreamingCategory; import com.jsoniter.output.EncodingMode; import com.jsoniter.output.JsonStream; import org.junit.BeforeClass; import org.junit.experimental.categories.Categories; import org.junit.runner.RunWith; import org.junit.runners.Suite; @RunWith(Categories.class) @Categories.ExcludeCategory(StreamingCategory.class) @Suite.SuiteClasses({AllTestCases.class}) public class NonStreamingTests4Strict { @BeforeClass public static void setup() { JsonStream.setMode(EncodingMode.DYNAMIC_MODE); JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_STRICTLY); } } java-jsoniter-java-0.9.8/src/test/java/com/jsoniter/suite/StreamingTests.java000066400000000000000000000006411304664171100273010ustar00rootroot00000000000000package com.jsoniter.suite; import com.jsoniter.JsonIterator; import org.junit.BeforeClass; import org.junit.experimental.categories.Categories; import org.junit.runner.RunWith; import org.junit.runners.Suite; @RunWith(Categories.class) @Suite.SuiteClasses({AllTestCases.class}) public class StreamingTests { @BeforeClass public static void setup() { JsonIterator.enableStreamingSupport(); } }