/*
* Copyright 2007-2011 Hidekatsu Izuno
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*/
package net.arnx.jsonic;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Serializable;
import java.io.Writer;
import java.lang.reflect.Constructor;
import java.lang.reflect.Member;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URI;
import java.net.URL;
import java.nio.charset.Charset;
import java.sql.Struct;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.MessageFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import java.util.RandomAccess;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TimeZone;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.UUID;
import java.util.regex.Pattern;
import net.arnx.jsonic.io.AppendableOutputSource;
import net.arnx.jsonic.io.CharSequenceInputSource;
import net.arnx.jsonic.io.InputSource;
import net.arnx.jsonic.io.OutputSource;
import net.arnx.jsonic.io.ReaderInputSource;
import net.arnx.jsonic.io.StringBuilderOutputSource;
import net.arnx.jsonic.io.WriterOutputSource;
import net.arnx.jsonic.util.BeanInfo;
import net.arnx.jsonic.util.ClassUtil;
import net.arnx.jsonic.util.ExtendedDateFormat;
import net.arnx.jsonic.util.PropertyInfo;
import org.w3c.dom.CharacterData;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
/**
* <p>The JSONIC JSON class provides JSON encoding and decoding as
* defined by RFC 4627.</p>
*
* <p>The following example illustrates how to encode and decode. The code:</p>
* <pre>
* // encodes a object into a json string.
* String s = JSON.encode(o);
*
* // decodes a json string into a object.
* Object o = JSON.decode(s);
*
* // decodes a json string into a typed object.
* Foo foo = JSON.decode(s, Foo.class);
* </pre>
*
* <p>Advanced topic:</p>
* <pre>
* // formats a object into a json string with indents for debug.
* JSON json = new JSON();
* json.setPrettyPrint(true);
* String pretty = json.format(o);
*
* //uses Reader/InputStream
* Bar bar = JSON.decode(new FileInputStream("bar.json"), Bar.class);
* Bar bar = JSON.decode(new FileReader("bar.json"), Bar.class);
* </pre>
*
* <h4>Summary of encoding rules for java type into json type</h4>
* <table border="1" cellpadding="1" cellspacing="0">
* <tr>
* <th bgcolor="#CCCCFF" align="left">java type</th>
* <th bgcolor="#CCCCFF" align="left">json type</th>
* </tr>
* <tr><td>java.util.Map</td><td rowspan="2">object</td></tr>
* <tr><td>java.lang.Object (public property or field)</td></tr>
* <tr><td>java.lang.Object[]</td><td rowspan="3">array</td></tr>
* <tr><td>java.util.Collection</td></tr>
* <tr><td>boolean[], short[], int[], long[], float[], double[]</td></tr>
* <tr><td>java.lang.CharSequence</td><td rowspan="10">string</td></tr>
* <tr><td>char[]</td></tr>
* <tr><td>java.lang.Character</td></tr>
* <tr><td>char</td></tr>
* <tr><td>java.util.TimeZone</td></tr>
* <tr><td>java.util.regex.Pattern</td></tr>
* <tr><td>java.lang.reflect.Type</td></tr>
* <tr><td>java.lang.reflect.Member</td></tr>
* <tr><td>java.net.URI</td></tr>
* <tr><td>java.net.URL</td></tr>
* <tr><td>byte[]</td><td>string (base64)</td></tr>
* <tr><td>java.util.Locale</td><td>string (language-country)</td></tr>
* <tr><td>java.lang.Number</td><td rowspan="2">number</td></tr>
* <tr><td>byte, short, int, long, float, double</td></tr>
* <tr><td>java.util.Date</td><td rowspan="2">number (milliseconds since 1970)</td></tr>
* <tr><td>java.util.Calendar</td></tr>
* <tr><td>java.lang.Boolean</td><td rowspan="2">true/false</td></tr>
* <tr><td>boolean</td></tr>
* <tr><td>null</td><td>null</td></tr>
* </table>
*
* <h4>Summary of decoding rules for json type into java type</h4>
* <table border="1" cellpadding="1" cellspacing="0">
* <tr>
* <th bgcolor="#CCCCFF" align="left">json type</th>
* <th bgcolor="#CCCCFF" align="left">java type</th>
* </tr>
* <tr><td>object</td><td>java.util.LinkedHashMap</td></tr>
* <tr><td>array</td><td>java.util.ArrayList</td></tr>
* <tr><td>string</td><td>java.lang.String</td></tr>
* <tr><td>number</td><td>java.math.BigDecimal</td></tr>
* <tr><td>true/false</td><td>java.lang.Boolean</td></tr>
* <tr><td>null</td><td>null</td></tr>
* </table>
*
* @author Hidekatsu Izuno
* @version 1.2.8
* @see <a href="http://www.rfc-editor.org/rfc/rfc4627.txt">RFC 4627</a>
* @see <a href="http://www.apache.org/licenses/LICENSE-2.0">the Apache License, Version 2.0</a>
*/
public class JSON {
/**
* JSON processing mode
*/
public enum Mode {
/**
* Traditional Mode
*/
TRADITIONAL,
/**
* Strict Mode
*/
STRICT,
/**
* Script(=JavaScript) Mode
*/
SCRIPT
}
/**
* Setup your custom class for using static method. default: net.arnx.jsonic.JSON
*/
public static volatile Class<? extends JSON> prototype = JSON.class;
private static final Map<Class<?>, Formatter> FORMAT_MAP = new HashMap<Class<?>, Formatter>(50);
private static final Map<Class<?>, Converter> CONVERT_MAP = new HashMap<Class<?>, Converter>(50);
static {
FORMAT_MAP.put(boolean.class, PlainFormatter.INSTANCE);
FORMAT_MAP.put(char.class, StringFormatter.INSTANCE);
FORMAT_MAP.put(byte.class, ByteFormatter.INSTANCE);
FORMAT_MAP.put(short.class, NumberFormatter.INSTANCE);
FORMAT_MAP.put(int.class, NumberFormatter.INSTANCE);
FORMAT_MAP.put(long.class, NumberFormatter.INSTANCE);
FORMAT_MAP.put(float.class, FloatFormatter.INSTANCE);
FORMAT_MAP.put(double.class, FloatFormatter.INSTANCE);
FORMAT_MAP.put(boolean[].class, BooleanArrayFormatter.INSTANCE);
FORMAT_MAP.put(char[].class, CharArrayFormatter.INSTANCE);
FORMAT_MAP.put(byte[].class, ByteArrayFormatter.INSTANCE);
FORMAT_MAP.put(short[].class, ShortArrayFormatter.INSTANCE);
FORMAT_MAP.put(int[].class, IntArrayFormatter.INSTANCE);
FORMAT_MAP.put(long[].class, LongArrayFormatter.INSTANCE);
FORMAT_MAP.put(float[].class, FloatArrayFormatter.INSTANCE);
FORMAT_MAP.put(double[].class, DoubleArrayFormatter.INSTANCE);
FORMAT_MAP.put(Object[].class, ObjectArrayFormatter.INSTANCE);
FORMAT_MAP.put(Boolean.class, PlainFormatter.INSTANCE);
FORMAT_MAP.put(Character.class, StringFormatter.INSTANCE);
FORMAT_MAP.put(Byte.class, ByteFormatter.INSTANCE);
FORMAT_MAP.put(Short.class, NumberFormatter.INSTANCE);
FORMAT_MAP.put(Integer.class, NumberFormatter.INSTANCE);
FORMAT_MAP.put(Long.class, NumberFormatter.INSTANCE);
FORMAT_MAP.put(Float.class, FloatFormatter.INSTANCE);
FORMAT_MAP.put(Double.class, FloatFormatter.INSTANCE);
FORMAT_MAP.put(BigInteger.class, NumberFormatter.INSTANCE);
FORMAT_MAP.put(BigDecimal.class, NumberFormatter.INSTANCE);
FORMAT_MAP.put(String.class, StringFormatter.INSTANCE);
FORMAT_MAP.put(Date.class, DateFormatter.INSTANCE);
FORMAT_MAP.put(java.sql.Date.class, DateFormatter.INSTANCE);
FORMAT_MAP.put(java.sql.Time.class, DateFormatter.INSTANCE);
FORMAT_MAP.put(java.sql.Timestamp.class, DateFormatter.INSTANCE);
FORMAT_MAP.put(URI.class, StringFormatter.INSTANCE);
FORMAT_MAP.put(URL.class, StringFormatter.INSTANCE);
FORMAT_MAP.put(UUID.class, StringFormatter.INSTANCE);
FORMAT_MAP.put(Pattern.class, StringFormatter.INSTANCE);
FORMAT_MAP.put(Class.class, ClassFormatter.INSTANCE);
FORMAT_MAP.put(Locale.class, LocaleFormatter.INSTANCE);
FORMAT_MAP.put(ArrayList.class, ListFormatter.INSTANCE);
FORMAT_MAP.put(LinkedList.class, IterableFormatter.INSTANCE);
FORMAT_MAP.put(HashSet.class, IterableFormatter.INSTANCE);
FORMAT_MAP.put(TreeSet.class, IterableFormatter.INSTANCE);
FORMAT_MAP.put(LinkedHashSet.class, IterableFormatter.INSTANCE);
FORMAT_MAP.put(HashMap.class, MapFormatter.INSTANCE);
FORMAT_MAP.put(IdentityHashMap.class, MapFormatter.INSTANCE);
FORMAT_MAP.put(Properties.class, MapFormatter.INSTANCE);
FORMAT_MAP.put(TreeMap.class, MapFormatter.INSTANCE);
FORMAT_MAP.put(LinkedHashMap.class, MapFormatter.INSTANCE);
CONVERT_MAP.put(boolean.class, BooleanConverter.INSTANCE);
CONVERT_MAP.put(char.class, CharacterConverter.INSTANCE);
CONVERT_MAP.put(byte.class, ByteConverter.INSTANCE);
CONVERT_MAP.put(short.class, ShortConverter.INSTANCE);
CONVERT_MAP.put(int.class, IntegerConverter.INSTANCE);
CONVERT_MAP.put(long.class, LongConverter.INSTANCE);
CONVERT_MAP.put(float.class, FloatConverter.INSTANCE);
CONVERT_MAP.put(double.class, DoubleConverter.INSTANCE);
CONVERT_MAP.put(boolean[].class, ArrayConverter.INSTANCE);
CONVERT_MAP.put(char[].class, ArrayConverter.INSTANCE);
CONVERT_MAP.put(byte[].class, ArrayConverter.INSTANCE);
CONVERT_MAP.put(short[].class, ArrayConverter.INSTANCE);
CONVERT_MAP.put(int[].class, ArrayConverter.INSTANCE);
CONVERT_MAP.put(long[].class, ArrayConverter.INSTANCE);
CONVERT_MAP.put(float[].class, ArrayConverter.INSTANCE);
CONVERT_MAP.put(double[].class, ArrayConverter.INSTANCE);
CONVERT_MAP.put(Object[].class, ArrayConverter.INSTANCE);
CONVERT_MAP.put(Boolean.class, BooleanConverter.INSTANCE);
CONVERT_MAP.put(Character.class, CharacterConverter.INSTANCE);
CONVERT_MAP.put(Byte.class, ByteConverter.INSTANCE);
CONVERT_MAP.put(Short.class, ShortConverter.INSTANCE);
CONVERT_MAP.put(Integer.class, IntegerConverter.INSTANCE);
CONVERT_MAP.put(Long.class, LongConverter.INSTANCE);
CONVERT_MAP.put(Float.class, FloatConverter.INSTANCE);
CONVERT_MAP.put(Double.class, DoubleConverter.INSTANCE);
CONVERT_MAP.put(BigInteger.class, BigIntegerConverter.INSTANCE);
CONVERT_MAP.put(BigDecimal.class, BigDecimalConverter.INSTANCE);
CONVERT_MAP.put(Number.class, BigDecimalConverter.INSTANCE);
CONVERT_MAP.put(Pattern.class, PatternConverter.INSTANCE);
CONVERT_MAP.put(TimeZone.class, TimeZoneConverter.INSTANCE);
CONVERT_MAP.put(Locale.class, LocaleConverter.INSTANCE);
CONVERT_MAP.put(File.class, FileConverter.INSTANCE);
CONVERT_MAP.put(URL.class, URLConverter.INSTANCE);
CONVERT_MAP.put(URI.class, URIConverter.INSTANCE);
CONVERT_MAP.put(UUID.class, UUIDConverter.INSTANCE);
CONVERT_MAP.put(Charset.class, CharsetConverter.INSTANCE);
CONVERT_MAP.put(Class.class, ClassConverter.INSTANCE);
CONVERT_MAP.put(Date.class, DateConverter.INSTANCE);
CONVERT_MAP.put(java.sql.Date.class, DateConverter.INSTANCE);
CONVERT_MAP.put(java.sql.Time.class, DateConverter.INSTANCE);
CONVERT_MAP.put(java.sql.Timestamp.class, DateConverter.INSTANCE);
CONVERT_MAP.put(Calendar.class, CalendarConverter.INSTANCE);
CONVERT_MAP.put(Collection.class, CollectionConverter.INSTANCE);
CONVERT_MAP.put(Set.class, CollectionConverter.INSTANCE);
CONVERT_MAP.put(List.class, CollectionConverter.INSTANCE);
CONVERT_MAP.put(SortedSet.class, CollectionConverter.INSTANCE);
CONVERT_MAP.put(LinkedList.class, CollectionConverter.INSTANCE);
CONVERT_MAP.put(HashSet.class, CollectionConverter.INSTANCE);
CONVERT_MAP.put(TreeSet.class, CollectionConverter.INSTANCE);
CONVERT_MAP.put(LinkedHashSet.class, CollectionConverter.INSTANCE);
CONVERT_MAP.put(Map.class, MapConverter.INSTANCE);
CONVERT_MAP.put(SortedMap.class, MapConverter.INSTANCE);
CONVERT_MAP.put(HashMap.class, MapConverter.INSTANCE);
CONVERT_MAP.put(IdentityHashMap.class, MapConverter.INSTANCE);
CONVERT_MAP.put(TreeMap.class, MapConverter.INSTANCE);
CONVERT_MAP.put(LinkedHashMap.class, MapConverter.INSTANCE);
CONVERT_MAP.put(Properties.class, PropertiesConverter.INSTANCE);
}
static JSON newInstance() {
JSON instance = null;
try {
instance = prototype.newInstance();
} catch (Exception e) {
throw new IllegalStateException(e);
}
return instance;
}
/**
* Encodes a object into a json string.
*
* @param source a object to encode.
* @return a json string
* @throws JSONException if error occurred when formating.
*/
public static String encode(Object source) throws JSONException {
return encode(source, false);
}
/**
* Encodes a object into a json string.
*
* @param source a object to encode.
* @param prettyPrint output a json string with indent, space or break.
* @return a json string
* @throws JSONException if error occurred when formating.
*/
public static String encode(Object source, boolean prettyPrint) throws JSONException {
JSON json = newInstance();
json.setPrettyPrint(prettyPrint);
return json.format(source);
}
/**
* Encodes a object into a json string.
*
* @param source a object to encode.
* @param out a destination to output a json string.
* @throws IOException if I/O Error occurred.
* @throws JSONException if error occurred when formating.
*/
public static void encode(Object source, OutputStream out) throws IOException, JSONException {
newInstance().format(source, new OutputStreamWriter(out, "UTF-8"));
}
/**
* Encodes a object into a json string.
*
* @param source a object to encode.
* @param out a destination to output a json string.
* @param prettyPrint output a json string with indent, space or break.
* @throws IOException if I/O Error occurred.
* @throws JSONException if error occurred when formating.
*/
public static void encode(Object source, OutputStream out, boolean prettyPrint) throws IOException, JSONException {
JSON json = newInstance();
json.setPrettyPrint(prettyPrint);
json.format(source, new OutputStreamWriter(out, "UTF-8"));
}
/**
* Encodes a object into a json string.
*
* @param source a object to encode.
* @param appendable a destination to output a json string.
* @throws IOException if I/O Error occurred.
* @throws JSONException if error occurred when formating.
*/
public static void encode(Object source, Appendable appendable) throws IOException, JSONException {
newInstance().format(source, appendable);
}
/**
* Encodes a object into a json string.
*
* @param source a object to encode.
* @param appendable a destination to output a json string.
* @param prettyPrint output a json string with indent, space or break.
* @throws IOException if I/O Error occurred.
* @throws JSONException if error occurred when formating.
*/
public static void encode(Object source, Appendable appendable, boolean prettyPrint) throws IOException, JSONException {
JSON json = newInstance();
json.setPrettyPrint(prettyPrint);
json.format(source, appendable);
}
/**
* Escapes a object into JavaScript format.
*
* @param source a object to encode.
* @return a escaped object
* @throws JSONException if error occurred when formating.
*/
public static String escapeScript(Object source) throws JSONException {
JSON json = newInstance();
json.setMode(Mode.SCRIPT);
return json.format(source);
}
/**
* Escapes a object into JavaScript format.
*
* @param source a object to encode.
* @param out a destination to output a json string.
* @throws IOException if I/O Error occurred.
* @throws JSONException if error occurred when formating.
*/
public static void escapeScript(Object source, OutputStream out) throws IOException, JSONException {
JSON json = newInstance();
json.setMode(Mode.SCRIPT);
json.format(source, out);
}
/**
* Escapes a object into JavaScript format.
*
* @param source a object to encode.
* @param appendable a destination to output a json string.
* @throws IOException if I/O Error occurred.
* @throws JSONException if error occurred when formating.
*/
public static void escapeScript(Object source, Appendable appendable) throws IOException, JSONException {
JSON json = newInstance();
json.setMode(Mode.SCRIPT);
json.format(source, appendable);
}
/**
* Decodes a json string into a object.
*
* @param source a json string to decode
* @return a decoded object
* @throws JSONException if error occurred when parsing.
*/
@SuppressWarnings("unchecked")
public static <T> T decode(String source) throws JSONException {
return (T)newInstance().parse(source);
}
/**
* Decodes a json string into a typed object.
*
* @param source a json string to decode
* @param cls class for converting
* @return a decoded object
* @throws JSONException if error occurred when parsing.
*/
public static <T> T decode(String source, Class<? extends T> cls) throws JSONException {
return newInstance().parse(source, cls);
}
/**
* Decodes a json string into a typed object.
*
* @param source a json string to decode
* @param type type for converting
* @return a decoded object
* @throws JSONException if error occurred when parsing.
*/
@SuppressWarnings("unchecked")
public static <T> T decode(String source, Type type) throws JSONException {
return (T)newInstance().parse(source, type);
}
/**
* Decodes a json stream into a object. (character encoding should be Unicode)
*
* @param in a json stream to decode
* @return a decoded object
* @throws IOException if I/O error occurred.
* @throws JSONException if error occurred when parsing.
*/
@SuppressWarnings("unchecked")
public static <T> T decode(InputStream in) throws IOException, JSONException {
return (T)newInstance().parse(in);
}
/**
* Decodes a json stream into a object. (character encoding should be Unicode)
*
* @param in a json stream to decode
* @param cls class for converting
* @return a decoded object
* @throws IOException if I/O error occurred.
* @throws JSONException if error occurred when parsing.
*/
public static <T> T decode(InputStream in, Class<? extends T> cls) throws IOException, JSONException {
return newInstance().parse(in, cls);
}
/**
* Decodes a json stream into a object. (character encoding should be Unicode)
*
* @param in a json stream to decode
* @param type type for converting
* @return a decoded object
* @throws IOException if I/O error occurred.
* @throws JSONException if error occurred when parsing.
*/
@SuppressWarnings("unchecked")
public static <T> T decode(InputStream in, Type type) throws IOException, JSONException {
return (T)newInstance().parse(in, type);
}
/**
* Decodes a json stream into a object.
*
* @param reader a json stream to decode
* @return a decoded object
* @throws IOException if I/O error occurred.
* @throws JSONException if error occurred when parsing.
*/
@SuppressWarnings("unchecked")
public static <T> T decode(Reader reader) throws IOException, JSONException {
return (T)newInstance().parse(reader);
}
/**
* Decodes a json stream into a object.
*
* @param reader a json stream to decode
* @param cls class for converting
* @return a decoded object
* @throws IOException if I/O error occurred.
* @throws JSONException if error occurred when parsing.
*/
public static <T> T decode(Reader reader, Class<? extends T> cls) throws IOException, JSONException {
return newInstance().parse(reader, cls);
}
/**
* Decodes a json stream into a object.
*
* @param reader a json stream to decode
* @param type type for converting
* @return a decoded object
* @throws IOException if I/O error occurred.
* @throws JSONException if error occurred when parsing.
*/
@SuppressWarnings("unchecked")
public static <T> T decode(Reader reader, Type type) throws IOException, JSONException {
return (T)newInstance().parse(reader, type);
}
/**
* Validates a json text
*
* @param cs source a json string to decode
* @throws JSONException if error occurred when parsing.
*/
public static void validate(CharSequence cs) throws JSONException {
JSON json = newInstance();
json.setMode(Mode.STRICT);
json.setMaxDepth(0);
json.parse(cs);
}
/**
* Validates a json stream
*
* @param in source a json string to decode
* @throws IOException if I/O error occurred.
* @throws JSONException if error occurred when parsing.
*/
public static void validate(InputStream in) throws IOException, JSONException {
JSON json = newInstance();
json.setMode(Mode.STRICT);
json.setMaxDepth(0);
json.parse(in);
}
/**
* Validates a json stream
*
* @param reader source a json string to decode
* @throws IOException if I/O error occurred.
* @throws JSONException if error occurred when parsing.
*/
public static void validate(Reader reader) throws IOException, JSONException {
JSON json = newInstance();
json.setMode(Mode.STRICT);
json.setMaxDepth(0);
json.parse(reader);
}
private Object contextObject;
private Locale locale = Locale.getDefault();
private TimeZone timeZone = TimeZone.getDefault();
private boolean prettyPrint = false;
private int maxDepth = 32;
private boolean suppressNull = false;
private Mode mode = Mode.TRADITIONAL;
private String dateFormat;
private String numberFormat;
private NamingStyle propertyStyle;
private NamingStyle enumStyle;
public JSON() {
}
public JSON(int maxDepth) {
setMaxDepth(maxDepth);
}
public JSON(Mode mode) {
setMode(mode);
}
/**
* Sets context for inner class.
*
* @param value context object
*/
public void setContext(Object value) {
this.contextObject = value;
}
/**
* Sets locale for formatting, converting and selecting message.
*
* @param locale locale for formatting, converting and selecting message
*/
public void setLocale(Locale locale) {
if (locale == null) {
throw new NullPointerException();
}
this.locale = locale;
}
/**
* Sets timeZone for formatting and converting.
*
* @param timeZone timeZone for formatting and converting.
*/
public void setTimeZone(TimeZone timeZone) {
if (timeZone == null) {
throw new NullPointerException();
}
this.timeZone = timeZone;
}
/**
* Output json string is to human-readable format.
*
* @param value true to format human-readable, false to shorten.
*/
public void setPrettyPrint(boolean value) {
this.prettyPrint = value;
}
/**
* Sets maximum depth for the nest level.
* default value is 32.
*
* @param value maximum depth for the nest level.
*/
public void setMaxDepth(int value) {
if (value < 0) {
throw new IllegalArgumentException(getMessage("json.TooSmallArgumentError", "maxDepth", 0));
}
this.maxDepth = value;
}
/**
* Gets maximum depth for the nest level.
*
* @return a maximum depth
*/
public int getMaxDepth() {
return this.maxDepth;
}
/**
* If this property is true, the member of null value in JSON object is ignored.
* default value is false.
*
* @param value true to ignore the member of null value in JSON object.
*/
public void setSuppressNull(boolean value) {
this.suppressNull = value;
}
/**
* Sets JSON interpreter mode.
*
* @param mode JSON interpreter mode
*/
public void setMode(Mode mode) {
if (mode == null) {
throw new NullPointerException();
}
this.mode = mode;
}
/**
* Gets JSON interpreter mode.
*
* @return JSON interpreter mode
*/
public Mode getMode() {
return mode;
}
/**
* Sets default Date format.
* When format is null, Date is formated to JSON number.
*
* @param format default Date format
*/
public void setDateFormat(String format) {
this.dateFormat = format;
}
/**
* Sets default Number format.
* When format is null, Number is formated to JSON number.
*
* @param format default Number format
*/
public void setNumberFormat(String format) {
this.numberFormat = format;
}
/**
* Sets default Case style for the property name of JSON object.
*
* @param style default Case style for keys of JSON object.
*/
public void setPropertyStyle(NamingStyle style) {
this.propertyStyle = style;
}
/**
* Sets default Case style for Enum.
*
* @param style default Case style for Enum.
*/
public void setEnumStyle(NamingStyle style) {
this.enumStyle = style;
}
/**
* Format a object into a json string.
*
* @param source a object to encode.
* @return a json string
*/
public String format(Object source) {
String text = null;
try {
text = format(source, new StringBuilder(1000)).toString();
} catch (IOException e) {
// no handle;
}
return text;
}
/**
* Format a object into a json string.
*
* @param source a object to encode.
* @param out a destination to output a json string.
* @return a reference to 'out' object in parameters
*/
public OutputStream format(Object source, OutputStream out) throws IOException {
format(source, new BufferedWriter(new OutputStreamWriter(out, "UTF-8")));
return out;
}
/**
* Format a object into a json string.
*
* @param source a object to encode.
* @param ap a destination. example: StringBuilder, Writer, ...
* @return a json string
*/
public Appendable format(Object source, Appendable ap) throws IOException {
Context context = new Context();
OutputSource fs;
if (ap instanceof Writer) {
fs = new WriterOutputSource((Writer)ap);
} else if (ap instanceof StringBuilder) {
fs = new StringBuilderOutputSource((StringBuilder)ap);
} else {
fs = new AppendableOutputSource(ap);
}
context.enter('$');
source = preformatInternal(context, source);
formatInternal(context, source, fs);
context.exit();
fs.flush();
return ap;
}
/**
* Converts Any Java Object to JSON recognizable Java object before format.
*
* @param context current context.
* @param value source a object to format.
* @return null or the instance of Map, Iterator(or Array, Enumerator), Number, CharSequence or Boolean.
* @throws Exception if conversion failed.
*/
protected Object preformat(Context context, Object value) throws Exception {
return value;
}
final Object preformatInternal(Context context, Object value) {
if (value == null) {
return null;
} else if (context.getLevel() > context.getMaxDepth()) {
return null;
} else if (getClass() != JSON.class) {
try {
return preformat(context, value);
} catch (Exception e) {
throw new JSONException(getMessage("json.format.ConversionError", value, context),
JSONException.PREFORMAT_ERROR, e);
}
}
return value;
}
final Formatter formatInternal(final Context context, final Object src, final OutputSource ap) throws IOException {
Object o = src;
Formatter f = null;
if (o == null) {
f = NullFormatter.INSTANCE;
} else {
JSONHint hint = context.getHint();
if (hint == null) {
// no handle
} else if (context.skipHint) {
context.skipHint = false;
} else if (hint.serialized()) {
f = PlainFormatter.INSTANCE;
} else if (String.class.equals(hint.type())) {
f = StringFormatter.INSTANCE;
} else if (Serializable.class.equals(hint.type())) {
f = SerializableFormatter.INSTANCE;
}
}
if (f == null) f = FORMAT_MAP.get(o.getClass());
if (f == null) {
if (context.hasMemberCache(o.getClass())) {
f = ObjectFormatter.INSTANCE;
} else if (o instanceof Map<?, ?>) {
f = MapFormatter.INSTANCE;
} else if (o instanceof Iterable<?>) {
if (o instanceof RandomAccess && o instanceof List<?>) {
f = ListFormatter.INSTANCE;
} else {
f = IterableFormatter.INSTANCE;
}
} else if (o instanceof Object[]) {
f = ObjectArrayFormatter.INSTANCE;
} else if (o instanceof Enum<?>) {
f = EnumFormatter.INSTANCE;
} else if (o instanceof CharSequence) {
f = StringFormatter.INSTANCE;
} else if (o instanceof Date) {
f = DateFormatter.INSTANCE;
} else if (o instanceof Calendar) {
f = CalendarFormatter.INSTANCE;
} else if (o instanceof Number) {
f = NumberFormatter.INSTANCE;
} else if (o instanceof Iterator<?>) {
f = IteratorFormatter.INSTANCE;
} else if (o instanceof Enumeration) {
f = EnumerationFormatter.INSTANCE;
} else if (o instanceof Type || o instanceof Member || o instanceof File) {
f = StringFormatter.INSTANCE;
} else if (o instanceof TimeZone) {
f = TimeZoneFormatter.INSTANCE;
} else if (o instanceof Charset) {
f = CharsetFormatter.INSTANCE;
} else if (o instanceof java.sql.Array) {
f = SQLArrayFormatter.INSTANCE;
} else if (o instanceof Struct) {
f = StructFormmatter.INSTANCE;
} else if (o instanceof Node) {
if (o instanceof CharacterData && !(o instanceof Comment)) {
f = CharacterDataFormatter.INSTANCE;
} else if (o instanceof Document) {
f = DOMDocumentFormatter.INSTANCE;
} else if (o instanceof Element) {
f = DOMElementFormatter.INSTANCE;
}
} else if (isAssignableFrom(ClassUtil.findClass("java.sql.RowId"), o.getClass())) {
f = SerializableFormatter.INSTANCE;
} else if (isAssignableFrom(ClassUtil.findClass("java.net.InetAddress"), o.getClass())) {
f = InetAddressFormatter.INSTANCE;
} else if (isAssignableFrom(ClassUtil.findClass("org.apache.commons.beanutils.DynaBean"), o.getClass())) {
f = DynaBeanFormatter.INSTANCE;
} else {
f = ObjectFormatter.INSTANCE;
}
}
boolean isStruct;
try {
isStruct = f.format(this, context, src, o, ap);
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw new JSONException(getMessage("json.format.ConversionError",
(src instanceof CharSequence) ? "\"" + src + "\"" : src, context),
JSONException.FORMAT_ERROR, e);
}
if (!isStruct && context.getLevel() == 0 && context.getMode() != Mode.SCRIPT) {
throw new JSONException(getMessage("json.format.IllegalRootTypeError"),
JSONException.FORMAT_ERROR);
}
return f;
}
@SuppressWarnings("unchecked")
public <T> T parse(CharSequence cs) throws JSONException {
Object value = null;
try {
value = parseInternal(new Context(), new CharSequenceInputSource(cs));
} catch (IOException e) {
// never occur
}
return (T)value;
}
@SuppressWarnings("unchecked")
public <T> T parse(CharSequence s, Class<? extends T> cls) throws JSONException {
return (T)parse(s, (Type)cls);
}
@SuppressWarnings("unchecked")
public <T> T parse(CharSequence s, Type type) throws JSONException {
T value = null;
try {
Context context = new Context();
value = (T)convert(context, parseInternal(context, new CharSequenceInputSource(s)), type);
} catch (IOException e) {
// never occur
}
return value;
}
@SuppressWarnings("unchecked")
public <T> T parse(InputStream in) throws IOException, JSONException {
return (T)parseInternal(new Context(), new ReaderInputSource(in));
}
@SuppressWarnings("unchecked")
public <T> T parse(InputStream in, Class<? extends T> cls) throws IOException, JSONException {
return (T)parse(in, (Type)cls);
}
@SuppressWarnings("unchecked")
public <T> T parse(InputStream in, Type type) throws IOException, JSONException {
Context context = new Context();
return (T)convert(context, parseInternal(context, new ReaderInputSource(in)), type);
}
@SuppressWarnings("unchecked")
public <T> T parse(Reader reader) throws IOException, JSONException {
return (T)parseInternal(new Context(), new ReaderInputSource(reader));
}
@SuppressWarnings("unchecked")
public <T> T parse(Reader reader, Class<? extends T> cls) throws IOException, JSONException {
return (T)parse(reader, (Type)cls);
}
@SuppressWarnings("unchecked")
public <T> T parse(Reader reader, Type type) throws IOException, JSONException {
Context context = new Context();
return (T)convert(context, parseInternal(context, new ReaderInputSource(reader)), type);
}
private Object parseInternal(Context context, InputSource s) throws IOException, JSONException {
boolean isEmpty = true;
Object o = null;
int n = -1;
while ((n = s.next()) != -1) {
char c = (char)n;
switch(c) {
case '\r':
case '\n':
case ' ':
case '\t':
case 0xFEFF: // BOM
continue;
case '{':
if (isEmpty) {
s.back();
o = parseObject(context, s, 1);
isEmpty = false;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case '[':
if (isEmpty) {
s.back();
o = parseArray(context, s, 1);
isEmpty = false;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case '/':
case '#':
if (context.getMode() == Mode.TRADITIONAL || (context.getMode() == Mode.SCRIPT && c == '/')) {
s.back();
skipComment(context, s);
continue;
}
case '\'':
case '"':
if (context.getMode() == Mode.SCRIPT) {
if (isEmpty) {
s.back();
o = parseString(context, s, 1);
isEmpty = false;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
}
default:
if (context.getMode() == Mode.SCRIPT) {
if (isEmpty) {
s.back();
o = ((c == '-') || (c >= '0' && c <= '9')) ? parseNumber(context, s, 1) : parseLiteral(context, s, 1, false);
isEmpty = false;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
}
}
if (context.getMode() == Mode.TRADITIONAL && isEmpty) {
s.back();
o = parseObject(context, s, 1);
isEmpty = false;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
}
if (isEmpty) {
if (context.getMode() == Mode.TRADITIONAL) {
o = new LinkedHashMap<String, Object>();
} else {
throw createParseException(getMessage("json.parse.EmptyInputError"), s);
}
}
return o;
}
private Map<Object, Object> parseObject(Context context, InputSource s, int level) throws IOException, JSONException {
int point = 0; // 0 '{' 1 'key' 2 ':' 3 '\n'? 4 'value' 5 '\n'? 6 ',' ... '}' E
Map<Object, Object> map = (level <= context.getMaxDepth()) ? new LinkedHashMap<Object, Object>() : null;
Object key = null;
char start = '\0';
int n = -1;
loop:while ((n = s.next()) != -1) {
char c = (char)n;
switch(c) {
case '\r':
case '\n':
if (context.getMode() == Mode.TRADITIONAL && point == 5) {
point = 6;
}
continue;
case ' ':
case '\t':
case 0xFEFF: // BOM
continue;
case '{':
if (point == 0) {
start = '{';
point = 1;
} else if (point == 2 || point == 3){
s.back();
Object value = parseObject(context, s, level+1);
if (level < context.getMaxDepth()) map.put(key, value);
point = 5;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case ':':
if (point == 2) {
point = 3;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case ',':
if (point == 5 || point == 6 || (context.getMode() == Mode.TRADITIONAL && point == 3)) {
if (point == 3 && level < context.getMaxDepth() && !context.isSuppressNull()) {
map.put(key, null);
}
point = 1;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case '}':
if (start == '{' && (point == 1 || point == 5 || point == 6 || (context.getMode() == Mode.TRADITIONAL && point == 3))) {
if (point == 3 && level < context.getMaxDepth() && !context.isSuppressNull()) {
map.put(key, null);
}
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
break loop;
case '[':
if (point == 3) {
s.back();
List<Object> value = parseArray(context, s, level+1);
if (level < context.getMaxDepth()) map.put(key, value);
point = 5;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case '\'':
if (context.getMode() == Mode.STRICT) {
break;
}
case '"':
if (point == 0) {
s.back();
point = 1;
} else if (point == 1 || point == 6) {
s.back();
key = parseString(context, s, level+1);
point = 2;
} else if (point == 3) {
s.back();
String value = parseString(context, s, level+1);
if (level < context.getMaxDepth()) map.put(key, value);
point = 5;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case '/':
case '#':
if (context.getMode() == Mode.TRADITIONAL || (context.getMode() == Mode.SCRIPT && c == '/')) {
s.back();
skipComment(context, s);
if (point == 5) {
point = 6;
}
continue;
}
}
if (point == 0) {
s.back();
point = 1;
} else if (point == 1 || point == 6) {
s.back();
key = ((c == '-') || (c >= '0' && c <= '9')) ? parseNumber(context, s, level+1) : parseLiteral(context, s, level+1, context.getMode() != Mode.STRICT);
point = 2;
} else if (point == 3) {
s.back();
Object value = ((c == '-') || (c >= '0' && c <= '9')) ? parseNumber(context, s, level+1) : parseLiteral(context, s, level+1, context.getMode() == Mode.TRADITIONAL);
if (level < context.getMaxDepth() && (value != null || !context.isSuppressNull())) {
map.put(key, value);
}
point = 5;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
}
if (n == -1) {
if (point == 3 || point == 4) {
if (level < context.getMaxDepth() && !context.isSuppressNull()) map.put(key, null);
} else if (point == 2) {
throw createParseException(getMessage("json.parse.ObjectNotClosedError"), s);
}
}
if ((n == -1) ? (start != '\0') : (n != '}')) {
throw createParseException(getMessage("json.parse.ObjectNotClosedError"), s);
}
return map;
}
private List<Object> parseArray(Context context, InputSource s, int level) throws IOException, JSONException {
int point = 0; // 0 '[' 1 'value' 2 '\n'? 3 ',' 4 ... ']' E
List<Object> list = (level <= context.getMaxDepth()) ? new ArrayList<Object>() : null;
int n = -1;
loop:while ((n = s.next()) != -1) {
char c = (char)n;
switch(c) {
case '\r':
case '\n':
if (context.getMode() == Mode.TRADITIONAL && point == 2) {
point = 3;
}
continue;
case ' ':
case '\t':
case 0xFEFF: // BOM
continue;
case '[':
if (point == 0) {
point = 1;
} else if (point == 1 || point == 3 || point == 4) {
s.back();
List<Object> value = parseArray(context, s, level+1);
if (level < context.getMaxDepth()) list.add(value);
point = 2;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case ',':
if (context.getMode() == Mode.TRADITIONAL && (point == 1 || point == 4)) {
if (level < context.getMaxDepth()) list.add(null);
} else if (point == 2 || point == 3) {
point = 4;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case ']':
if (point == 1 || point == 2 || point == 3) {
// nothing
} else if (context.getMode() == Mode.TRADITIONAL && point == 4) {
if (level < context.getMaxDepth()) list.add(null);
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
break loop;
case '{':
if (point == 1 || point == 3 || point == 4){
s.back();
Map<Object, Object> value = parseObject(context, s, level+1);
if (level < context.getMaxDepth()) list.add(value);
point = 2;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case '\'':
if (context.getMode() == Mode.STRICT) {
break;
}
case '"':
if (point == 1 || point == 3 || point == 4) {
s.back();
String value = parseString(context, s, level+1);
if (level < context.getMaxDepth()) list.add(value);
point = 2;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case '/':
case '#':
if (context.getMode() == Mode.TRADITIONAL || (context.getMode() == Mode.SCRIPT && c == '/')) {
s.back();
skipComment(context, s);
if (point == 2) {
point = 3;
}
continue;
}
}
if (point == 1 || point == 3 || point == 4) {
s.back();
Object value = ((c == '-') || (c >= '0' && c <= '9')) ? parseNumber(context, s, level+1) : parseLiteral(context, s, level+1, context.getMode() == Mode.TRADITIONAL);
if (level < context.getMaxDepth()) list.add(value);
point = 2;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
}
if (n != ']') {
throw createParseException(getMessage("json.parse.ArrayNotClosedError"), s);
}
return list;
}
private String parseString(Context context, InputSource s, int level) throws IOException, JSONException {
int point = 0; // 0 '"|'' 1 'c' ... '"|'' E
StringBuilder sb = (level <= context.getMaxDepth()) ? context.getCachedBuffer() : null;
char start = '\0';
int n = -1;
loop:while ((n = s.next()) != -1) {
char c = (char)n;
switch(c) {
case 0xFEFF: // BOM
continue;
case '\\':
if (point == 1) {
if (context.getMode() != Mode.TRADITIONAL || start == '"') {
s.back();
c = parseEscape(s);
if (sb != null) sb.append(c);
} else {
if (sb != null) sb.append(c);
}
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
case '\'':
if (context.getMode() == Mode.STRICT) {
break;
}
case '"':
if (point == 0) {
start = c;
point = 1;
continue;
} else if (point == 1) {
if (start == c) {
break loop;
} else {
if (sb != null) sb.append(c);
}
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
continue;
}
if (point == 1 && (context.getMode() != Mode.STRICT || c >= 0x20)) {
if (sb != null) sb.append(c);
continue;
}
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
if (n != start) {
throw createParseException(getMessage("json.parse.StringNotClosedError"), s);
}
return (sb != null) ? sb.toString() : null;
}
private Object parseLiteral(Context context, InputSource s, int level, boolean any) throws IOException, JSONException {
int point = 0; // 0 'IdStart' 1 'IdPart' ... !'IdPart' E
StringBuilder sb = context.getCachedBuffer();
int n = -1;
loop:while ((n = s.next()) != -1) {
char c = (char)n;
if (c == 0xFEFF) continue;
if (c == '\\') {
s.back();
c = parseEscape(s);
}
if (point == 0 && Character.isJavaIdentifierStart(c)) {
sb.append(c);
point = 1;
} else if (point == 1 && (Character.isJavaIdentifierPart(c) || c == '.')) {
sb.append(c);
} else {
s.back();
break loop;
}
}
String str = sb.toString();
if ("null".equals(str)) return null;
if ("true".equals(str)) return true;
if ("false".equals(str)) return false;
if (!any) {
throw createParseException(getMessage("json.parse.UnrecognizedLiteral", str), s);
}
return str;
}
private Number parseNumber(Context context, InputSource s, int level) throws IOException, JSONException {
int point = 0; // 0 '(-)' 1 '0' | ('[1-9]' 2 '[0-9]*') 3 '(.)' 4 '[0-9]' 5 '[0-9]*' 6 'e|E' 7 '[+|-]' 8 '[0-9]' 9 '[0-9]*' E
StringBuilder sb = (level <= context.getMaxDepth()) ? context.getCachedBuffer() : null;
int n = -1;
loop:while ((n = s.next()) != -1) {
char c = (char)n;
switch(c) {
case 0xFEFF: // BOM
break;
case '+':
if (point == 7) {
if (sb != null) sb.append(c);
point = 8;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
break;
case '-':
if (point == 0) {
if (sb != null) sb.append(c);
point = 1;
} else if (point == 7) {
if (sb != null) sb.append(c);
point = 8;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
break;
case '.':
if (point == 2 || point == 3) {
if (sb != null) sb.append(c);
point = 4;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
break;
case 'e':
case 'E':
if (point == 2 || point == 3 || point == 5 || point == 6) {
if (sb != null) sb.append(c);
point = 7;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
break;
default:
if (c >= '0' && c <= '9') {
if (point == 0 || point == 1) {
if (sb != null) sb.append(c);
point = (c == '0') ? 3 : 2;
} else if (point == 2 || point == 5 || point == 9) {
if (sb != null) sb.append(c);
} else if (point == 4) {
if (sb != null) sb.append(c);
point = 5;
} else if (point == 7 || point == 8) {
if (sb != null) sb.append(c);
point = 9;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
} else if (point == 2 || point == 3 || point == 5 || point == 6 || point == 9) {
s.back();
break loop;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
}
}
return (sb != null) ? new BigDecimal(sb.toString()) : null;
}
private char parseEscape(InputSource s) throws IOException, JSONException {
int point = 0; // 0 '\' 1 'u' 2 'x' 3 'x' 4 'x' 5 'x' E
char escape = '\0';
int n = -1;
loop:while ((n = s.next()) != -1) {
char c = (char)n;
if (c == 0xFEFF) continue; // BOM
if (point == 0) {
if (c == '\\') {
point = 1;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
} else if (point == 1) {
switch(c) {
case 'b':
escape = '\b';
break loop;
case 'f':
escape = '\f';
break loop;
case 'n':
escape = '\n';
break loop;
case 'r':
escape = '\r';
break loop;
case 't':
escape = '\t';
break loop;
case 'u':
point = 2;
break;
default:
escape = c;
break loop;
}
} else {
int hex = (c >= '0' && c <= '9') ? c-48 :
(c >= 'A' && c <= 'F') ? c-65+10 :
(c >= 'a' && c <= 'f') ? c-97+10 : -1;
if (hex != -1) {
escape |= (hex << ((5-point)*4));
if (point != 5) {
point++;
} else {
break loop;
}
} else {
throw createParseException(getMessage("json.parse.IllegalUnicodeEscape", c), s);
}
}
}
return escape;
}
private void skipComment(Context context, InputSource s) throws IOException, JSONException {
int point = 0; // 0 '/' 1 '*' 2 '*' 3 '/' E or 0 '/' 1 '/' 4 '\r|\n|\r\n' E
int n = -1;
loop:while ((n = s.next()) != -1) {
char c = (char)n;
switch(c) {
case 0xFEFF:
break;
case '/':
if (point == 0) {
point = 1;
} else if (point == 1) {
point = 4;
} else if (point == 3) {
break loop;
} else if (!(point == 2 || point == 4)) {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
break;
case '*':
if (point == 1) {
point = 2;
} else if (point == 2) {
point = 3;
} else if (!(point == 3 || point == 4)) {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
break;
case '\n':
case '\r':
if (point == 2 || point == 3) {
point = 2;
} else if (point == 4) {
break loop;
} else {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
break;
case '#':
if (context.getMode() == Mode.TRADITIONAL) {
if (point == 0) {
point = 4;
} else if (point == 3) {
point = 2;
} else if (!(point == 2 || point == 4)) {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
break;
}
default:
if (point == 3) {
point = 2;
} else if (!(point == 2 || point == 4)) {
throw createParseException(getMessage("json.parse.UnexpectedChar", c), s);
}
}
}
}
JSONException createParseException(String message, InputSource s) {
return new JSONException("" + s.getLineNumber() + ": " + message + "\n" + s.toString() + " <- ?",
JSONException.PARSE_ERROR, s.getLineNumber(), s.getColumnNumber(), s.getOffset());
}
String getMessage(String id, Object... args) {
ResourceBundle bundle = ResourceBundle.getBundle("net.arnx.jsonic.Messages", locale);
return MessageFormat.format(bundle.getString(id), args);
}
public Object convert(Object value, Type type) throws JSONException {
return convert(new Context(), value, type);
}
@SuppressWarnings("unchecked")
private <T> T convert(Context context, Object value, Type type) throws JSONException {
Class<?> cls = ClassUtil.getRawType(type);
T result = null;
try {
context.enter('$');
result = (T)postparse(context, value, cls, type);
context.exit();
} catch (Exception e) {
String text;
if (value instanceof CharSequence) {
text = "\"" + value + "\"";
} else {
try {
text = value.toString();
} catch (Exception e2) {
text = value.getClass().toString();
}
}
throw new JSONException(getMessage("json.parse.ConversionError", text, type, context),
JSONException.POSTPARSE_ERROR, e);
}
return result;
}
/**
* Converts Map, List, Number, String, Boolean or null to other Java Objects after parsing.
*
* @param context current context.
* @param value null or the instance of Map, List, Number, String or Boolean.
* @param cls class for converting
* @param type generics type for converting. type equals to c if not generics.
* @return a converted object
* @throws Exception if conversion failed.
*/
@SuppressWarnings("unchecked")
protected <T> T postparse(Context context, Object value, Class<? extends T> cls, Type type) throws Exception {
Converter c = null;
if (value == null) {
if (!cls.isPrimitive()) {
c = NullConverter.INSTANCE;
}
} else {
JSONHint hint = context.getHint();
if (hint == null) {
// no handle
} else if (context.skipHint) {
context.skipHint = false;
} else if (hint.serialized()) {
c = FormatConverter.INSTANCE;
} else if (Serializable.class.equals(hint.type())) {
c = SerializableConverter.INSTANCE;
} else if (String.class.equals(hint.type())) {
c = StringSerializableConverter.INSTANCE;
}
}
if (c == null) {
if (value != null && cls.equals(type) && cls.isAssignableFrom(value.getClass())) {
c = PlainConverter.INSTANCE;
} else {
c = CONVERT_MAP.get(cls);
}
}
if (c == null) {
if (context.hasMemberCache(cls)) {
c = ObjectConverter.INSTANCE;
} else if (Properties.class.isAssignableFrom(cls)) {
c = PropertiesConverter.INSTANCE;
} else if (Map.class.isAssignableFrom(cls)) {
c = MapConverter.INSTANCE;
} else if (Collection.class.isAssignableFrom(cls)) {
c = CollectionConverter.INSTANCE;
} else if (cls.isArray()) {
c = ArrayConverter.INSTANCE;
} else if (cls.isEnum()) {
c = EnumConverter.INSTANCE;
} else if (Date.class.isAssignableFrom(cls)) {
c = DateConverter.INSTANCE;
} else if (Calendar.class.isAssignableFrom(cls)) {
c = CalendarConverter.INSTANCE;
} else if (CharSequence.class.isAssignableFrom(cls)) {
c = CharSequenceConverter.INSTANCE;
} else if (Appendable.class.isAssignableFrom(cls)) {
c = AppendableConverter.INSTANCE;
} else if (cls.equals(ClassUtil.findClass("java.net.InetAddress"))) {
c = InetAddressConverter.INSTANCE;
} else if (java.sql.Array.class.isAssignableFrom(cls)
|| Struct.class.isAssignableFrom(cls)) {
c = NullConverter.INSTANCE;
} else {
c = ObjectConverter.INSTANCE;
}
}
if (c != null) {
return (T)c.convert(this, context, value, cls, type);
} else {
throw new UnsupportedOperationException();
}
}
protected String normalize(String name) {
return name;
}
/**
* Ignore this property. A default behavior is to ignore transient or declaring method in java.lang.Object.
* You can override this method if you have to change default behavior.
*
* @param context current context
* @param target target class
* @param member target member
* @return true if this member must be ignored.
*/
protected boolean ignore(Context context, Class<?> target, Member member) {
if (Modifier.isTransient(member.getModifiers())) return true;
if (member.getDeclaringClass().equals(Object.class)) return true;
return false;
}
protected <T> T create(Context context, Class<? extends T> c) throws Exception {
Object instance = null;
JSONHint hint = context.getHint();
if (hint != null && hint.type() != Object.class) c = hint.type().asSubclass(c);
if (c.isInterface()) {
if (SortedMap.class.equals(c)) {
instance = new TreeMap<Object, Object>();
} else if (Map.class.equals(c)) {
instance = new LinkedHashMap<Object, Object>();
} else if (SortedSet.class.equals(c)) {
instance = new TreeSet<Object>();
} else if (Set.class.equals(c)) {
instance = new LinkedHashSet<Object>();
} else if (List.class.equals(c)) {
instance = new ArrayList<Object>();
} else if (Collection.class.equals(c)) {
instance = new ArrayList<Object>();
} else if (Appendable.class.equals(c)) {
instance = new StringBuilder();
}
} else if (Modifier.isAbstract(c.getModifiers())) {
if (Calendar.class.equals(c)) {
instance = Calendar.getInstance();
}
} else if ((c.isMemberClass() || c.isAnonymousClass()) && !Modifier.isStatic(c.getModifiers())) {
Class<?> eClass = c.getEnclosingClass();
Constructor<?> con = c.getDeclaredConstructor(eClass);
con.setAccessible(true);
if (context.contextObject != null && eClass.isAssignableFrom(context.contextObject.getClass())) {
instance = con.newInstance(context.contextObject);
} else {
instance = con.newInstance((Object)null);
}
} else {
if (Date.class.isAssignableFrom(c)) {
try {
Constructor<?> con = c.getDeclaredConstructor(long.class);
con.setAccessible(true);
instance = con.newInstance(0l);
} catch (NoSuchMethodException e) {
// no handle
}
}
if (instance == null) {
Constructor<?> con = c.getDeclaredConstructor();
con.setAccessible(true);
instance = con.newInstance();
}
}
return c.cast(instance);
}
private static boolean isAssignableFrom(Class<?> target, Class<?> cls) {
return (target != null) && target.isAssignableFrom(cls);
}
public final class Context {
private final Locale locale;
private final TimeZone timeZone;
private final Object contextObject;
private final int maxDepth;
private final boolean prettyPrint;
private final boolean suppressNull;
private final Mode mode;
private final String numberFormat;
private final String dateFormat;
private final NamingStyle propertyStyle;
private final NamingStyle enumStyle;
private Object[] path;
private int level = -1;
private Map<Class<?>, Object> memberCache;
private Map<String, DateFormat> dateFormatCache;
private Map<String, NumberFormat> numberFormatCache;
private StringBuilder builderCache;
boolean skipHint = false;
public Context() {
synchronized (JSON.this) {
locale = JSON.this.locale;
timeZone = JSON.this.timeZone;
contextObject = JSON.this.contextObject;
maxDepth = JSON.this.maxDepth;
prettyPrint = JSON.this.prettyPrint;
suppressNull = JSON.this.suppressNull;
mode = JSON.this.mode;
numberFormat = JSON.this.numberFormat;
dateFormat = JSON.this.dateFormat;
propertyStyle = JSON.this.propertyStyle;
enumStyle = JSON.this.enumStyle;
}
}
Context(Context context) {
synchronized (context) {
locale = context.locale;
timeZone = context.timeZone;
contextObject = context.contextObject;
maxDepth = context.maxDepth;
prettyPrint = context.prettyPrint;
suppressNull = context.suppressNull;
mode = context.mode;
numberFormat = context.numberFormat;
dateFormat = context.dateFormat;
propertyStyle = context.propertyStyle;
enumStyle = context.enumStyle;
level = context.level;
path = context.path.clone();
}
}
public StringBuilder getCachedBuffer() {
if (builderCache == null) {
builderCache = new StringBuilder();
} else {
builderCache.setLength(0);
}
return builderCache;
}
public Locale getLocale() {
return locale;
}
public TimeZone getTimeZone() {
return timeZone;
}
public int getMaxDepth() {
return maxDepth;
}
public boolean isPrettyPrint() {
return prettyPrint;
}
public boolean isSuppressNull() {
return suppressNull;
}
public Mode getMode() {
return mode;
}
public NamingStyle getPropertyCaseStyle() {
return propertyStyle;
}
public NamingStyle getEnumCaseStyle() {
return enumStyle;
}
/**
* Returns the current level.
*
* @return level number. 0 is root node.
*/
public int getLevel() {
return level;
}
/**
* Returns the current key object.
*
* @return Root node is '$'. When the parent is a array, the key is Integer, otherwise String.
*/
public Object getKey() {
return path[level*2];
}
/**
* Returns the key object in any level. the negative value means relative to current level.
*
* @return Root node is '$'. When the parent is a array, the key is Integer, otherwise String.
*/
public Object getKey(int level) {
if (level < 0) level = getLevel()+level;
return path[level*2];
}
/**
* Returns the current hint annotation.
*
* @return the current annotation if present on this context, else null.
*/
public JSONHint getHint() {
return (JSONHint)path[level*2+1];
}
@SuppressWarnings("unchecked")
public <T> T convert(Object key, Object value, Class<? extends T> c) throws Exception {
enter(key);
T o = JSON.this.postparse(this, value, c, c);
exit();
return (T)((c.isPrimitive()) ? PlainConverter.getDefaultValue(c).getClass() : c).cast(o);
}
public Object convert(Object key, Object value, Type t) throws Exception {
Class<?> c = ClassUtil.getRawType(t);
enter(key);
Object o = JSON.this.postparse(this, value, c, t);
exit();
return ((c.isPrimitive()) ? PlainConverter.getDefaultValue(c).getClass() : c).cast(o);
}
void enter(Object key, JSONHint hint) {
level++;
if (path == null) path = new Object[8];
if (path.length < level*2+2) {
Object[] newPath = new Object[Math.max(path.length*2, level*2+2)];
System.arraycopy(path, 0, newPath, 0, path.length);
path = newPath;
}
path[level*2] = key;
path[level*2+1] = hint;
}
void enter(Object key) {
enter(key, (JSONHint)((level != -1) ? path[level*2+1] : null));
}
void exit() {
level--;
}
boolean hasMemberCache(Class<?> c) {
return memberCache != null && memberCache.containsKey(c);
}
@SuppressWarnings("unchecked")
List<PropertyInfo> getGetProperties(Class<?> c) {
if (memberCache == null) memberCache = new HashMap<Class<?>, Object>();
List<PropertyInfo> props = (List<PropertyInfo>)memberCache.get(c);
if (props == null) {
props = new ArrayList<PropertyInfo>();
for (PropertyInfo prop : BeanInfo.get(c).getProperties()) {
if (prop.isStatic() || !prop.isReadable()) continue;
String mName = null;
if (prop.getReadMethod() != null && !ignore(this, c, prop.getReadMethod())) {
JSONHint hint = prop.getReadMethod().getAnnotation(JSONHint.class);
if (hint != null) {
if (!hint.ignore()) {
mName = prop.getName();
if (!hint.name().isEmpty()) {
mName = hint.name();
} else if (getPropertyCaseStyle() != null) {
mName = getPropertyCaseStyle().to(mName);
}
props.add(new PropertyInfo(prop.getBeanClass(), mName,
null, prop.getReadMethod(), prop.getWriteMethod(), prop.isStatic(), hint.ordinal()));
}
} else if (getPropertyCaseStyle() != null) {
mName = getPropertyCaseStyle().to(prop.getName());
props.add(new PropertyInfo(prop.getBeanClass(), mName,
prop.getField(), prop.getReadMethod(), prop.getWriteMethod(), prop.isStatic(), prop.getOrdinal()));
} else {
mName = prop.getName();
props.add(prop);
}
}
if (prop.getField() != null && !ignore(this, c, prop.getField())) {
JSONHint hint = prop.getField().getAnnotation(JSONHint.class);
if (hint != null) {
String name = prop.getName();
if (!hint.name().isEmpty()) {
name = hint.name();
} else if (getPropertyCaseStyle() != null) {
name = getPropertyCaseStyle().to(name);
}
if (!name.equals(mName) && !hint.ignore()) {
props.add(new PropertyInfo(prop.getBeanClass(), name,
prop.getField(), null, null, prop.isStatic(), hint.ordinal()));
}
} else if (mName != null) {
String name = prop.getName();
if (getPropertyCaseStyle() != null) {
name = getPropertyCaseStyle().to(name);
}
if (!name.equals(mName)) {
props.add(new PropertyInfo(prop.getBeanClass(), name,
prop.getField(), null, null, prop.isStatic(), prop.getOrdinal()));
}
} else if (getPropertyCaseStyle() != null) {
props.add(new PropertyInfo(prop.getBeanClass(), getPropertyCaseStyle().to(prop.getName()),
prop.getField(), prop.getReadMethod(), prop.getWriteMethod(), prop.isStatic(), prop.getOrdinal()));
} else {
props.add(prop);
}
}
}
Collections.sort(props);
memberCache.put(c, props);
}
return props;
}
@SuppressWarnings("unchecked")
Map<String, PropertyInfo> getSetProperties(Class<?> c) {
if (memberCache == null) memberCache = new HashMap<Class<?>, Object>();
Map<String, PropertyInfo> props = (Map<String, PropertyInfo>)memberCache.get(c);
if (props == null) {
props = new HashMap<String, PropertyInfo>();
for (PropertyInfo prop : BeanInfo.get(c).getProperties()) {
if (prop.isStatic() || !prop.isWritable() || ignore(this, c, prop.getWriteMember())) {
continue;
}
String name = null;
int order = -1;
JSONHint hint = prop.getWriteAnnotation(JSONHint.class);
if (hint != null) {
if (hint.ignore()) continue;
if (hint.name().length() > 0) name = hint.name();
order = hint.ordinal();
}
if (name != null) {
if (prop.getWriteMethod() != null && prop.getField() != null && !Modifier.isFinal(prop.getField().getModifiers())) {
props.put(name, new PropertyInfo(prop.getBeanClass(), name,
null, prop.getReadMethod(), prop.getWriteMethod(), prop.isStatic(), order));
prop = new PropertyInfo(prop.getBeanClass(), prop.getName(),
prop.getField(), null, null, prop.isStatic(), order);
} else {
props.put(name, new PropertyInfo(prop.getBeanClass(), name,
prop.getField(), prop.getReadMethod(), prop.getWriteMethod(), prop.isStatic(), order));
continue;
}
} else if (order >= 0) {
prop = new PropertyInfo(prop.getBeanClass(), prop.getName(),
prop.getField(), prop.getReadMethod(), prop.getWriteMethod(), prop.isStatic(), order);
}
props.put(prop.getName(), prop);
if (getPropertyCaseStyle() != null) {
name = getPropertyCaseStyle().to(prop.getName());
if (!prop.getName().equals(name)) {
props.put(name, prop);
}
}
}
memberCache.put(c, props);
}
return props;
}
NumberFormat getNumberFormat() {
JSONHint hint = getHint();
String format = (hint != null && hint.format().length() > 0) ? hint.format() : numberFormat;
if (format != null) {
NumberFormat nformat = null;
if (numberFormatCache == null) {
numberFormatCache = new HashMap<String, NumberFormat>();
} else {
nformat = numberFormatCache.get(format);
}
if (nformat == null) {
nformat = new DecimalFormat(format, new DecimalFormatSymbols(locale));
numberFormatCache.put(format, nformat);
}
return nformat;
} else {
return null;
}
}
DateFormat getDateFormat() {
JSONHint hint = getHint();
String format = (hint != null && hint.format().length() > 0) ? hint.format() : dateFormat;
if (format != null) {
DateFormat dformat = null;
if (dateFormatCache == null) {
dateFormatCache = new HashMap<String, DateFormat>();
} else {
dformat = dateFormatCache.get(format);
}
if (dformat == null) {
dformat = new ExtendedDateFormat(format, locale);
dformat.setTimeZone(timeZone);
dateFormatCache.put(format, dformat);
}
return dformat;
} else {
return null;
}
}
public String toString() {
StringBuilderOutputSource sb = new StringBuilderOutputSource(getCachedBuffer());
for (int i = 0; i < path.length; i+=2) {
Object key = path[i];
if (key == null) {
sb.append("[null]");
} else if (key instanceof Number) {
sb.append('[');
sb.append(key.toString());
sb.append(']');
} else if (key instanceof Character) {
sb.append(key.toString());
} else {
String str = key.toString();
boolean escape = false;
for (int j = 0; j < str.length(); j++) {
if (j == 0) {
escape = !Character.isJavaIdentifierStart(str.charAt(j));
} else {
escape = !Character.isJavaIdentifierPart(str.charAt(j));
}
if (escape) break;
}
if (escape) {
sb.append('[');
try {
StringFormatter.serialize(this, str, sb);
} catch (Exception e) {
// no handle
}
sb.append(']');
} else {
sb.append('.');
sb.append(str);
}
}
}
return sb.toString();
}
}
}