zzz/i2p.i2p
1
0
Fork 0
forked from I2P_Developers/i2p.i2p
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

json-smart-v1 lib for DoH and i2pcontrol

Browse Source 
Copied from i2p.plugins.i2pcontrol.
Does not include JSON-RPC2, that stays in the plugin.
i2pcontrol checkin notes:
Smart Mini files (net.minidev.json) from:
https://github.com/netplex/json-smart-v1
commit 51e1641 on Oct 23, 2015
Essentially version 1.3.2 (1.3.1+)
Licensed Apache 2.0.
Removed as unneeded: JSONNavi.java, JSONStyleIdent.java
Not in Debian/Ubuntu
Version in Maven Central (1.0.8) is too old
This commit is contained in:
zzz
2018-04-17 17:01:24 +00:00
parent 1ba7fb9621
commit d621e19349
30 changed files with 4319 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
LICENSE.txt
View File

@@ -88,6 +88,10 @@ Public domain except as listed below:
From Apache HttpClient 4.4.1 and HttpCore 4.4.1
See licenses/LICENSE-Apache2.0.txt
json-smart-v1 1.3.1+
Copyright 2011 JSON-SMART authors
See licenses/LICENSE-Apache2.0.txt
Router (router.jar):
Public domain except as listed below:

2
build.xml
View File

@@ -784,7 +784,7 @@
failonerror="true"
doctitle="I2P Javadocs for Release ${release.number} Build ${i2p.build.number}${build.extra}"
windowtitle="I2P Anonymous Network - Java Documentation - Version ${release.number}">
<group title="Core SDK (i2p.jar)" packages="net.i2p:net.i2p.*:net.i2p.client:net.i2p.client.*:net.i2p.internal:net.i2p.internal.*:freenet.support.CPUInformation:org.bouncycastle.oldcrypto:org.bouncycastle.oldcrypto.*:gnu.crypto.*:gnu.getopt:gnu.gettext:com.nettgryppa.security:org.apache.http.conn.ssl:org.apache.http.conn.util:org.apache.http.util" />
<group title="Core SDK (i2p.jar)" packages="net.i2p:net.i2p.*:net.i2p.client:net.i2p.client.*:net.i2p.internal:net.i2p.internal.*:freenet.support.CPUInformation:org.bouncycastle.oldcrypto:org.bouncycastle.oldcrypto.*:gnu.crypto.*:gnu.getopt:gnu.gettext:com.nettgryppa.security:org.apache.http.conn.ssl:org.apache.http.conn.util:org.apache.http.util:net.minidev.json:net.minidev.json.*" />
<group title="Streaming Library" packages="net.i2p.client.streaming:net.i2p.client.streaming.impl" />
<group title="Router" packages="net.i2p.router:net.i2p.router.*:net.i2p.data.i2np:net.i2p.data.router:org.cybergarage:org.cybergarage.*:org.freenetproject:org.xlattice.crypto.filters:com.maxmind.geoip" />
<group title="Router Console" packages="net.i2p.router.web:net.i2p.router.web.*:net.i2p.router.update:net.i2p.router.news" />

121
core/java/src/net/minidev/json/JSONArray.java Normal file
View File

@@ -0,0 +1,121 @@
package net.minidev.json;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import net.minidev.json.reader.JsonWriter;
/**
* A JSON array. JSONObject supports java.util.List interface.
*
* @author FangYidong<fangyidong@yahoo.com.cn>
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
public class JSONArray extends ArrayList<Object> implements List<Object>, JSONAwareEx, JSONStreamAwareEx {
private static final long serialVersionUID = 9106884089231309568L;
public static String toJSONString(List<? extends Object> list) {
return toJSONString(list, JSONValue.COMPRESSION);
}
/**
* Convert a list to JSON text. The result is a JSON array. If this list is
* also a JSONAware, JSONAware specific behaviours will be omitted at this
* top level.
*
* @see net.minidev.json.JSONValue#toJSONString(Object)
*
* @param list
* @param compression
* Indicate compression level
* @return JSON text, or "null" if list is null.
*/
public static String toJSONString(List<? extends Object> list, JSONStyle compression) {
StringBuilder sb = new StringBuilder();
try {
writeJSONString(list, sb, compression);
} catch (IOException e) {
// Can not append on a string builder
}
return sb.toString();
}
/**
* Encode a list into JSON text and write it to out. If this list is also a
* JSONStreamAware or a JSONAware, JSONStreamAware and JSONAware specific
* behaviours will be ignored at this top level.
*
* @see JSONValue#writeJSONString(Object, Appendable)
*
* @param list
* @param out
*/
public static void writeJSONString(Iterable<? extends Object> list, Appendable out, JSONStyle compression)
throws IOException {
if (list == null) {
out.append("null");
return;
}
JsonWriter.JSONIterableWriter.writeJSONString(list, out, compression);
}
public static void writeJSONString(List<? extends Object> list, Appendable out) throws IOException {
writeJSONString(list, out, JSONValue.COMPRESSION);
}
public void merge(Object o2) {
JSONObject.merge(this, o2);
}
/**
* Explicitely Serialize Object as JSon String
*/
public String toJSONString() {
return toJSONString(this, JSONValue.COMPRESSION);
}
public String toJSONString(JSONStyle compression) {
return toJSONString(this, compression);
}
/**
* Override natif toStirng()
*/
public String toString() {
return toJSONString();
}
/**
* JSONAwareEx inferface
*
* @param compression
* compression param
*/
public String toString(JSONStyle compression) {
return toJSONString(compression);
}
public void writeJSONString(Appendable out) throws IOException {
writeJSONString(this, out, JSONValue.COMPRESSION);
}
public void writeJSONString(Appendable out, JSONStyle compression) throws IOException {
writeJSONString(this, out, compression);
}
}

29
core/java/src/net/minidev/json/JSONAware.java Normal file
View File

@@ -0,0 +1,29 @@
package net.minidev.json;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
/**
* Beans that support customized output of JSON text shall implement this
* interface.
*
* @author FangYidong<fangyidong@yahoo.com.cn>
*/
public interface JSONAware {
/**
* @return JSON text
*/
String toJSONString();
}

32
core/java/src/net/minidev/json/JSONAwareEx.java Normal file
View File

@@ -0,0 +1,32 @@
package net.minidev.json;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
/**
* Beans that support advanced output of JSON text shall implement this
* interface.
*
* Adding compressions and formating features
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
public interface JSONAwareEx extends JSONAware {
/**
* @return JSON text
*/
String toJSONString(JSONStyle compression);
}

217
core/java/src/net/minidev/json/JSONObject.java Normal file
View File

@@ -0,0 +1,217 @@
package net.minidev.json;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import net.minidev.json.reader.JsonWriter;
/**
* A JSON object. Key value pairs are unordered. JSONObject supports
* java.util.Map interface.
*
* @author FangYidong<fangyidong@yahoo.com.cn>
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
public class JSONObject extends HashMap<String, Object> implements JSONAware, JSONAwareEx, JSONStreamAwareEx {
private static final long serialVersionUID = -503443796854799292L;
public JSONObject() {
super();
}
// /**
// * Allow simply casting to Map<String, XXX>
// */
// @SuppressWarnings("unchecked")
// public <T> T cast() {
// return (T) this;
// }
/**
* Escape quotes, \, /, \r, \n, \b, \f, \t and other control characters
* (U+0000 through U+001F). It's the same as JSONValue.escape() only for
* compatibility here.
*
* @see JSONValue#escape(String)
*/
public static String escape(String s) {
return JSONValue.escape(s);
}
public static String toJSONString(Map<String, ? extends Object> map) {
return toJSONString(map, JSONValue.COMPRESSION);
}
/**
* Convert a map to JSON text. The result is a JSON object. If this map is
* also a JSONAware, JSONAware specific behaviours will be omitted at this
* top level.
*
* @see net.minidev.json.JSONValue#toJSONString(Object)
*
* @param map
* @return JSON text, or "null" if map is null.
*/
public static String toJSONString(Map<String, ? extends Object> map, JSONStyle compression) {
StringBuilder sb = new StringBuilder();
try {
writeJSON(map, sb, compression);
} catch (IOException e) {
// can not append on a StringBuilder
}
return sb.toString();
}
// /**
// * return a Key:value entry as stream
// */
// public static String toString(String key, Object value) {
// return toString(key, value, JSONValue.COMPRESSION);
// }
// /**
// * return a Key:value entry as stream
// */
// public static String toString(String key, Object value, JSONStyle
// compression) {
// StringBuilder sb = new StringBuilder();
// try {
// writeJSONKV(key, value, sb, compression);
// } catch (IOException e) {
// // can not append on a StringBuilder
// }
// return sb.toString();
// }
/**
* Allows creation of a JSONObject from a Map. After that, both the
* generated JSONObject and the Map can be modified independently.
*/
public JSONObject(Map<String, ?> map) {
super(map);
}
public static void writeJSON(Map<String, Object> map, Appendable out) throws IOException {
writeJSON(map, out, JSONValue.COMPRESSION);
}
/**
* Encode a map into JSON text and write it to out. If this map is also a
* JSONAware or JSONStreamAware, JSONAware or JSONStreamAware specific
* behaviours will be ignored at this top level.
*
* @see JSONValue#writeJSONString(Object, Appendable)
*/
public static void writeJSON(Map<String, ? extends Object> map, Appendable out, JSONStyle compression)
throws IOException {
if (map == null) {
out.append("null");
return;
}
JsonWriter.JSONMapWriter.writeJSONString(map, out, compression);
}
/**
* serialize Object as json to an stream
*/
public void writeJSONString(Appendable out) throws IOException {
writeJSON(this, out, JSONValue.COMPRESSION);
}
/**
* serialize Object as json to an stream
*/
public void writeJSONString(Appendable out, JSONStyle compression) throws IOException {
writeJSON(this, out, compression);
}
public void merge(Object o2) {
merge(this, o2);
}
protected static JSONObject merge(JSONObject o1, Object o2) {
if (o2 == null)
return o1;
if (o2 instanceof JSONObject)
return merge(o1, (JSONObject) o2);
throw new RuntimeException("JSON megre can not merge JSONObject with " + o2.getClass());
}
private static JSONObject merge(JSONObject o1, JSONObject o2) {
if (o2 == null)
return o1;
for (String key : o1.keySet()) {
Object value1 = o1.get(key);
Object value2 = o2.get(key);
if (value2 == null)
continue;
if (value1 instanceof JSONArray) {
o1.put(key, merge((JSONArray) value1, value2));
continue;
}
if (value1 instanceof JSONObject) {
o1.put(key, merge((JSONObject) value1, value2));
continue;
}
if (value1.equals(value2))
continue;
if (value1.getClass().equals(value2.getClass()))
throw new RuntimeException("JSON merge can not merge two " + value1.getClass().getName()
+ " Object together");
throw new RuntimeException("JSON merge can not merge " + value1.getClass().getName() + " with "
+ value2.getClass().getName());
}
for (String key : o2.keySet()) {
if (o1.containsKey(key))
continue;
o1.put(key, o2.get(key));
}
return o1;
}
protected static JSONArray merge(JSONArray o1, Object o2) {
if (o2 == null)
return o1;
if (o1 instanceof JSONArray)
return merge(o1, (JSONArray) o2);
o1.add(o2);
return o1;
}
private static JSONArray merge(JSONArray o1, JSONArray o2) {
o1.addAll(o2);
return o1;
}
public String toJSONString() {
return toJSONString(this, JSONValue.COMPRESSION);
}
public String toJSONString(JSONStyle compression) {
return toJSONString(this, compression);
}
public String toString(JSONStyle compression) {
return toJSONString(this, compression);
}
public String toString() {
return toJSONString(this, JSONValue.COMPRESSION);
}
}

31
core/java/src/net/minidev/json/JSONStreamAware.java Normal file
View File

@@ -0,0 +1,31 @@
package net.minidev.json;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.IOException;
/**
* Beans that support customized output of JSON text to a writer shall implement
* this interface.
*
* @author FangYidong<fangyidong@yahoo.com.cn>
*/
public interface JSONStreamAware {
/**
* write JSON string to out.
*/
void writeJSONString(Appendable out) throws IOException;
}

31
core/java/src/net/minidev/json/JSONStreamAwareEx.java Normal file
View File

@@ -0,0 +1,31 @@
package net.minidev.json;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.IOException;
/**
* Beans that support customized output of JSON text to a writer shall implement
* this interface.
*
* @author FangYidong<fangyidong@yahoo.com.cn>
*/
public interface JSONStreamAwareEx extends JSONStreamAware {
/**
* write JSON string to out.
*/
void writeJSONString(Appendable out, JSONStyle compression) throws IOException;
}

212
core/java/src/net/minidev/json/JSONStyle.java Normal file
View File

@@ -0,0 +1,212 @@
package net.minidev.json;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.IOException;
import net.minidev.json.JStylerObj.MustProtect;
import net.minidev.json.JStylerObj.StringProtector;
/**
* JSONStyle object configure JSonSerializer reducing output size
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
public class JSONStyle {
/**
* for advanced usage sample see
*
* @see net.minidev.json.test.TestCompressorFlags
*/
public final static int FLAG_PROTECT_KEYS = 1;
public final static int FLAG_PROTECT_4WEB = 2;
public final static int FLAG_PROTECT_VALUES = 4;
/**
* AGRESSIVE have no effect without PROTECT_KEYS or PROTECT_VALUE
*
* AGRESSIVE mode allows Json-smart to not protect String containing special
* chars
*/
public final static int FLAG_AGRESSIVE = 8;
/**
* @since 1.3.1
*/
public final static int FLAG_IGNORE_NULL = 16;
public final static JSONStyle NO_COMPRESS = new JSONStyle();
public final static JSONStyle MAX_COMPRESS = new JSONStyle(-1);
/**
* @since 1.0.9.1
*/
public final static JSONStyle LT_COMPRESS = new JSONStyle(FLAG_PROTECT_4WEB);
private boolean _protectKeys;
private boolean _protect4Web;
private boolean _protectValues;
private boolean _ignore_null;
private MustProtect mpKey;
private MustProtect mpValue;
private StringProtector esc;
public JSONStyle(int FLAG) {
_protectKeys = (FLAG & FLAG_PROTECT_KEYS) == 0;
_protectValues = (FLAG & FLAG_PROTECT_VALUES) == 0;
_protect4Web = (FLAG & FLAG_PROTECT_4WEB) == 0;
_ignore_null = (FLAG & FLAG_IGNORE_NULL) > 0;
MustProtect mp;
if ((FLAG & FLAG_AGRESSIVE) > 0)
mp = JStylerObj.MP_AGGRESIVE;
else
mp = JStylerObj.MP_SIMPLE;
if (_protectValues)
mpValue = JStylerObj.MP_TRUE;
else
mpValue = mp;
if (_protectKeys)
mpKey = JStylerObj.MP_TRUE;
else
mpKey = mp;
if (_protect4Web)
esc = JStylerObj.ESCAPE4Web;
else
esc = JStylerObj.ESCAPE_LT;
}
public JSONStyle() {
this(0);
}
public boolean protectKeys() {
return _protectKeys;
}
public boolean protectValues() {
return _protectValues;
}
public boolean protect4Web() {
return _protect4Web;
}
public boolean ignoreNull() {
return _ignore_null;
}
public boolean indent() {
return false;
}
public boolean mustProtectKey(String s) {
return mpKey.mustBeProtect(s);
}
public boolean mustProtectValue(String s) {
return mpValue.mustBeProtect(s);
}
public void writeString(Appendable out, String value) throws IOException {
if (!this.mustProtectValue(value))
out.append(value);
else {
out.append('"');
JSONValue.escape(value, out, this);
out.append('"');
}
}
public void escape(String s, Appendable out) {
esc.escape(s, out);
}
/**
* begin Object
*/
public void objectStart(Appendable out) throws IOException {
out.append('{');
}
/**
* terminate Object
*/
public void objectStop(Appendable out) throws IOException {
out.append('}');
}
/**
* Start the first Obeject element
*/
public void objectFirstStart(Appendable out) throws IOException {
}
/**
* Start a new Object element
*/
public void objectNext(Appendable out) throws IOException {
out.append(',');
}
/**
* End Of Object element
*/
public void objectElmStop(Appendable out) throws IOException {
}
/**
* end of Key in json Object
*/
public void objectEndOfKey(Appendable out) throws IOException {
out.append(':');
}
/**
* Array start
*/
public void arrayStart(Appendable out) throws IOException {
out.append('[');
}
/**
* Array Done
*/
public void arrayStop(Appendable out) throws IOException {
out.append(']');
}
/**
* Start the first Array element
*/
public void arrayfirstObject(Appendable out) throws IOException {
}
/**
* Start a new Array element
*/
public void arrayNextElm(Appendable out) throws IOException {
out.append(',');
}
/**
* End of an Array element
*/
public void arrayObjectEnd(Appendable out) throws IOException {
}
}

69
core/java/src/net/minidev/json/JSONUtil.java Normal file
View File

@@ -0,0 +1,69 @@
package net.minidev.json;
/*
* Copyright 2011 JSON-SMART authors
*
*
* 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.
*/
/**
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
public class JSONUtil {
public static String getSetterName(String key) {
int len = key.length();
char[] b = new char[len + 3];
b[0] = 's';
b[1] = 'e';
b[2] = 't';
char c = key.charAt(0);
if (c >= 'a' && c <= 'z')
c += 'A' - 'a';
b[3] = c;
for (int i = 1; i < len; i++) {
b[i + 3] = key.charAt(i);
}
return new String(b);
}
public static String getGetterName(String key) {
int len = key.length();
char[] b = new char[len + 3];
b[0] = 'g';
b[1] = 'e';
b[2] = 't';
char c = key.charAt(0);
if (c >= 'a' && c <= 'z')
c += 'A' - 'a';
b[3] = c;
for (int i = 1; i < len; i++) {
b[i + 3] = key.charAt(i);
}
return new String(b);
}
public static String getIsName(String key) {
int len = key.length();
char[] b = new char[len + 2];
b[0] = 'i';
b[1] = 's';
char c = key.charAt(0);
if (c >= 'a' && c <= 'z')
c += 'A' - 'a';
b[2] = c;
for (int i = 1; i < len; i++) {
b[i + 2] = key.charAt(i);
}
return new String(b);
}
}

595
core/java/src/net/minidev/json/JSONValue.java Normal file
View File

@@ -0,0 +1,595 @@
package net.minidev.json;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import static net.minidev.json.parser.ContainerFactory.FACTORY_ORDERED;
import static net.minidev.json.parser.ContainerFactory.FACTORY_SIMPLE;
import static net.minidev.json.parser.JSONParser.DEFAULT_PERMISSIVE_MODE;
import static net.minidev.json.parser.JSONParser.MODE_RFC4627;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.List;
import java.util.Map;
import net.minidev.json.parser.ContentHandler;
import net.minidev.json.parser.ContentHandlerCompressor;
import net.minidev.json.parser.FakeContainerFactory;
import net.minidev.json.parser.JSONParser;
import net.minidev.json.parser.ParseException;
import net.minidev.json.reader.JsonWriter;
import net.minidev.json.reader.JsonWriterI;
/**
* JSONValue is the helper class In most of case you should use those static
* methode to user JSON-smart
*
*
* The most commonly use methode are {@link #parse(String)}
* {@link #toJSONString(Object)}
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
public class JSONValue {
/**
* Global default compression type
*/
public static JSONStyle COMPRESSION = JSONStyle.NO_COMPRESS;
/**
* Used for validating Json inputs
*/
private final static FakeContainerFactory FACTORY_FAKE_COINTAINER = new FakeContainerFactory();
/**
* Parse JSON text into java object from the input source. Please use
* parseWithException() if you don't want to ignore the exception. if you
* want strict input check use parseStrict()
*
* @see JSONParser#parse(Reader)
* @see #parseWithException(Reader)
*
* @since 1.0.9-2
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*
*/
public static Object parse(byte[] in) {
try {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in);
} catch (Exception e) {
return null;
}
}
/**
* Parse JSON text into java object from the input source. Please use
* parseWithException() if you don't want to ignore the exception. if you
* want strict input check use parseStrict()
*
* @see JSONParser#parse(Reader)
* @see #parseWithException(Reader)
*
* @since 1.1.2
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*
*/
public static Object parse(byte[] in, int offset, int length) {
try {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, offset, length);
} catch (Exception e) {
return null;
}
}
/**
* Parse JSON text into java object from the input source. Please use
* parseWithException() if you don't want to ignore the exception. if you
* want strict input check use parseStrict()
*
* @see JSONParser#parse(Reader)
* @see #parseWithException(Reader)
*
* @since 1.0.9-2
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*
*/
public static Object parse(InputStream in) {
try {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in);
} catch (Exception e) {
return null;
}
}
/**
* Parse JSON text into java object from the input source. Please use
* parseWithException() if you don't want to ignore the exception. if you
* want strict input check use parseStrict()
*
* @see JSONParser#parse(Reader)
* @see #parseWithException(Reader)
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*
*/
public static Object parse(Reader in) {
try {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in);
} catch (Exception e) {
return null;
}
}
/**
* Parse JSON text into java object from the input source. Please use
* parseWithException() if you don't want to ignore the exception. if you
* want strict input check use parseStrict()
*
* @see JSONParser#parse(String)
* @see #parseWithException(String)
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*
*/
public static Object parse(String s) {
try {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(s);
} catch (Exception e) {
return null;
}
}
/**
* Parse Json input to a java Object keeping element order
*
* @since 1.0.9-2
*/
public static Object parseKeepingOrder(byte[] in) {
try {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, FACTORY_ORDERED);
} catch (Exception e) {
return null;
}
}
/**
* Parse Json input to a java Object keeping element order
*
* @since 1.1.2
*/
public static Object parseKeepingOrder(byte[] in, int offset, int length) {
try {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, offset, length, FACTORY_ORDERED);
} catch (Exception e) {
return null;
}
}
/**
* Parse Json input to a java Object keeping element order
*
* @since 1.0.9-2
*/
public static Object parseKeepingOrder(InputStream in) {
try {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, FACTORY_ORDERED);
} catch (Exception e) {
return null;
}
}
/**
* Parse Json input to a java Object keeping element order
*
* @since 1.0.6.1
*/
public static Object parseKeepingOrder(Reader in) {
try {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, FACTORY_ORDERED);
} catch (Exception e) {
return null;
}
}
/**
* Parse Json input to a java Object keeping element order
*
* @since 1.0.6.1
*/
public static Object parseKeepingOrder(String in) {
try {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, FACTORY_ORDERED);
} catch (Exception e) {
return null;
}
}
/**
* Parse Json Using SAX event handler
*
* @since 1.0.9-2
*/
public static void SAXParse(InputStream input, ContentHandler handler) throws ParseException, IOException {
JSONParser p = new JSONParser(DEFAULT_PERMISSIVE_MODE);
p.parse(input, FACTORY_FAKE_COINTAINER, handler);
}
/**
* Parse Json Using SAX event handler
*
* @since 1.0.6.2
*/
public static void SAXParse(Reader input, ContentHandler handler) throws ParseException, IOException {
JSONParser p = new JSONParser(DEFAULT_PERMISSIVE_MODE);
p.parse(input, FACTORY_FAKE_COINTAINER, handler);
}
/**
* Parse Json Using SAX event handler
*
* @since 1.0.6.2
*/
public static void SAXParse(String input, ContentHandler handler) throws ParseException {
JSONParser p = new JSONParser(DEFAULT_PERMISSIVE_MODE);
p.parse(input, FACTORY_FAKE_COINTAINER, handler);
}
/**
* Reformat Json input keeping element order
*
* @since 1.0.6.2
*/
public static String compress(String input, JSONStyle style) {
try {
StringBuilder sb = new StringBuilder();
ContentHandlerCompressor comp = new ContentHandlerCompressor(sb, style);
JSONParser p = new JSONParser(DEFAULT_PERMISSIVE_MODE);
p.parse(input, FACTORY_FAKE_COINTAINER, comp);
return sb.toString();
} catch (Exception e) {
return input;
}
}
/**
* Compress Json input keeping element order
*
* @since 1.0.6.1
*/
public static String compress(String s) {
return compress(s, JSONStyle.MAX_COMPRESS);
}
/**
* Compress Json input keeping element order
*
* @since 1.0.6.1
*/
public static String uncompress(String s) {
return compress(s, JSONStyle.NO_COMPRESS);
}
/**
* Parse JSON text into java object from the input source.
*
* @see JSONParser
*
* @since 1.0.9-2
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*/
public static Object parseWithException(byte[] in) throws IOException, ParseException {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, FACTORY_SIMPLE);
}
/**
* Parse JSON text into java object from the input source.
*
* @see JSONParser
*
* @since 1.1.2
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*/
public static Object parseWithException(byte[] in, int offset, int length) throws IOException, ParseException {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, offset, length, FACTORY_SIMPLE);
}
/**
* Parse JSON text into java object from the input source.
*
* @see JSONParser
*
* @since 1.0.9-2
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*/
public static Object parseWithException(InputStream in) throws IOException, ParseException {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, FACTORY_SIMPLE);
}
/**
* Parse JSON text into java object from the input source.
*
* @see JSONParser
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*/
public static Object parseWithException(Reader in) throws IOException, ParseException {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, FACTORY_SIMPLE);
}
/**
* Parse JSON text into java object from the input source.
*
* @see JSONParser
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*/
public static Object parseWithException(String s) throws ParseException {
return new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(s, FACTORY_SIMPLE);
}
/**
* Parse valid RFC4627 JSON text into java object from the input source.
*
* @see JSONParser
*
* @since 1.0.9-2
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*/
public static Object parseStrict(InputStream in) throws IOException, ParseException {
return new JSONParser(MODE_RFC4627).parse(in, FACTORY_SIMPLE);
}
/**
* Parse valid RFC4627 JSON text into java object from the input source.
*
* @see JSONParser
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*/
public static Object parseStrict(Reader in) throws IOException, ParseException {
return new JSONParser(MODE_RFC4627).parse(in, FACTORY_SIMPLE);
}
/**
* Parse valid RFC4627 JSON text into java object from the input source.
*
* @see JSONParser
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*/
public static Object parseStrict(String s) throws ParseException {
return new JSONParser(MODE_RFC4627).parse(s, FACTORY_SIMPLE);
}
/**
* Parse valid RFC4627 JSON text into java object from the input source.
*
* @see JSONParser
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*/
public static Object parseStrict(byte[] s) throws ParseException {
return new JSONParser(MODE_RFC4627).parse(s, FACTORY_SIMPLE);
}
/**
* Parse valid RFC4627 JSON text into java object from the input source.
*
* @see JSONParser
*
* @since 1.1.2
*
* @return Instance of the following: JSONObject, JSONArray, String,
* java.lang.Number, java.lang.Boolean, null
*/
public static Object parseStrict(byte[] s, int offset, int length) throws ParseException {
return new JSONParser(MODE_RFC4627).parse(s, offset, length, FACTORY_SIMPLE);
}
/**
* Check RFC4627 Json Syntax from input Reader
*
* @return if the input is valid
*/
public static boolean isValidJsonStrict(Reader in) throws IOException {
try {
new JSONParser(MODE_RFC4627).parse(in, FACTORY_FAKE_COINTAINER);
return true;
} catch (ParseException e) {
return false;
}
}
/**
* check RFC4627 Json Syntax from input String
*
* @return if the input is valid
*/
public static boolean isValidJsonStrict(String s) {
try {
new JSONParser(MODE_RFC4627).parse(s, FACTORY_FAKE_COINTAINER);
return true;
} catch (ParseException e) {
return false;
}
}
/**
* Check Json Syntax from input Reader
*
* @return if the input is valid
*/
public static boolean isValidJson(Reader in) throws IOException {
try {
new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(in, FACTORY_FAKE_COINTAINER);
return true;
} catch (ParseException e) {
return false;
}
}
/**
* Check Json Syntax from input String
*
* @return if the input is valid
*/
public static boolean isValidJson(String s) {
try {
new JSONParser(DEFAULT_PERMISSIVE_MODE).parse(s, FACTORY_FAKE_COINTAINER);
return true;
} catch (ParseException e) {
return false;
}
}
/**
* Encode an object into JSON text and write it to out.
* <p>
* If this object is a Map or a List, and it's also a JSONStreamAware or a
* JSONAware, JSONStreamAware or JSONAware will be considered firstly.
* <p>
*
* @see JSONObject#writeJSON(Map, Appendable)
* @see JSONArray#writeJSONString(List, Appendable)
*/
public static void writeJSONString(Object value, Appendable out) throws IOException {
writeJSONString(value, out, COMPRESSION);
}
public static JsonWriter defaultWriter = new JsonWriter();
/**
* Encode an object into JSON text and write it to out.
* <p>
* If this object is a Map or a List, and it's also a JSONStreamAware or a
* JSONAware, JSONStreamAware or JSONAware will be considered firstly.
* <p>
*
* @see JSONObject#writeJSON(Map, Appendable)
* @see JSONArray#writeJSONString(List, Appendable)
*/
@SuppressWarnings("unchecked")
public static void writeJSONString(Object value, Appendable out, JSONStyle compression) throws IOException {
if (value == null) {
out.append("null");
return;
}
Class<?> clz = value.getClass();
@SuppressWarnings("rawtypes")
JsonWriterI w = defaultWriter.getWrite(clz);
if (w == null) {
if (clz.isArray())
w = JsonWriter.arrayWriter;
else {
w = defaultWriter.getWriterByInterface(value.getClass());
if (w == null)
w = JsonWriter.beansWriter;
// w = JsonWriter.beansWriterASM;
}
defaultWriter.registerWriter(w, clz);
}
w.writeJSONString(value, out, compression);
}
/**
* Encode an object into JSON text and write it to out.
* <p>
* If this object is a Map or a List, and it's also a JSONStreamAware or a
* JSONAware, JSONStreamAware or JSONAware will be considered firstly.
* <p>
*
* @see JSONObject#writeJSON(Map, Appendable)
* @see JSONArray#writeJSONString(List, Appendable)
*/
public static String toJSONString(Object value) {
return toJSONString(value, COMPRESSION);
}
/**
* Convert an object to JSON text.
* <p>
* If this object is a Map or a List, and it's also a JSONAware, JSONAware
* will be considered firstly.
* <p>
* DO NOT call this method from toJSONString() of a class that implements
* both JSONAware and Map or List with "this" as the parameter, use
* JSONObject.toJSONString(Map) or JSONArray.toJSONString(List) instead.
*
* @see JSONObject#toJSONString(Map)
* @see JSONArray#toJSONString(List)
*
* @return JSON text, or "null" if value is null or it's an NaN or an INF
* number.
*/
public static String toJSONString(Object value, JSONStyle compression) {
StringBuilder sb = new StringBuilder();
try {
writeJSONString(value, sb, compression);
} catch (IOException e) {
// can not append on a StringBuilder
}
return sb.toString();
}
public static String escape(String s) {
return escape(s, COMPRESSION);
}
/**
* Escape quotes, \, /, \r, \n, \b, \f, \t and other control characters
* (U+0000 through U+001F).
*/
public static String escape(String s, JSONStyle compression) {
if (s == null)
return null;
StringBuilder sb = new StringBuilder();
compression.escape(s, sb);
return sb.toString();
}
public static void escape(String s, Appendable ap) {
escape(s, ap, COMPRESSION);
}
public static void escape(String s, Appendable ap, JSONStyle compression) {
if (s == null)
return;
compression.escape(s, ap);
}
}

323
core/java/src/net/minidev/json/JStylerObj.java Normal file
View File

@@ -0,0 +1,323 @@
package net.minidev.json;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.IOException;
/**
* protected class used to stored Internal methods
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
class JStylerObj {
public final static MPSimple MP_SIMPLE = new MPSimple();
public final static MPTrue MP_TRUE = new MPTrue();
public final static MPAgressive MP_AGGRESIVE = new MPAgressive();
public final static EscapeLT ESCAPE_LT = new EscapeLT();
public final static Escape4Web ESCAPE4Web = new Escape4Web();
public static interface MustProtect {
public boolean mustBeProtect(String s);
}
private static class MPTrue implements MustProtect {
public boolean mustBeProtect(String s) {
return true;
}
}
private static class MPSimple implements MustProtect {
/**
* can a String can be store without enclosing quotes. ie: should not
* contain any special json char
*
* @param s
* @return
*/
public boolean mustBeProtect(String s) {
if (s == null)
return false;
int len = s.length();
if (len == 0)
return true;
if (s.trim() != s)
return true;
char ch = s.charAt(0);
if (ch >= '0' && ch <= '9' || ch == '-')
return true;
for (int i = 0; i < len; i++) {
ch = s.charAt(i);
if (isSpace(ch))
return true;
if (isSpecial(ch))
return true;
if (isSpecialChar(ch))
return true;
if (isUnicode(ch))
return true;
}
// keyword check
if (isKeyword(s))
return true;
return false;
}
}
private static class MPAgressive implements MustProtect {
public boolean mustBeProtect(final String s) {
if (s == null)
return false;
int len = s.length();
// protect empty String
if (len == 0)
return true;
// protect trimable String
if (s.trim() != s)
return true;
// json special char
char ch = s.charAt(0);
if (isSpecial(ch) || isUnicode(ch))
return true;
for (int i = 1; i < len; i++) {
ch = s.charAt(i);
if (isSpecialClose(ch) || isUnicode(ch))
return true;
}
// keyWord must be protect
if (isKeyword(s))
return true;
// Digit like text must be protect
ch = s.charAt(0);
// only test String if First Ch is a digit
if (ch >= '0' && ch <= '9' || ch == '-') {
int p = 1;
// skip first digits
for (; p < len; p++) {
ch = s.charAt(p);
if (ch < '0' || ch > '9')
break;
}
// int/long
if (p == len)
return true;
// Floating point
if (ch == '.') {
p++;
}
// Skip digits
for (; p < len; p++) {
ch = s.charAt(p);
if (ch < '0' || ch > '9')
break;
}
if (p == len)
return true; // can be read as an floating number
// Double
if (ch == 'E' || ch == 'e') {
p++;
if (p == len) // no power data not a digits
return false;
ch = s.charAt(p);
if (ch == '+' || ch == '-') {
p++;
ch = s.charAt(p);
}
}
if (p == len) // no power data => not a digit
return false;
for (; p < len; p++) {
ch = s.charAt(p);
if (ch < '0' || ch > '9')
break;
}
// floating point With power of data.
if (p == len)
return true;
return false;
}
return false;
}
}
public static boolean isSpace(char c) {
return (c == '\r' || c == '\n' || c == '\t' || c == ' ');
}
public static boolean isSpecialChar(char c) {
return (c == '\b' || c == '\f' || c == '\n');
}
public static boolean isSpecialOpen(char c) {
return (c == '{' || c == '[' || c == ',' || c == ':');
}
public static boolean isSpecialClose(char c) {
return (c == '}' || c == ']' || c == ',' || c == ':');
}
public static boolean isSpecial(char c) {
return (c == '{' || c == '[' || c == ',' || c == '}' || c == ']' || c == ':' || c == '\'' || c == '"');
}
public static boolean isUnicode(char c) {
return ((c >= '\u0000' && c <= '\u001F') || (c >= '\u007F' && c <= '\u009F') || (c >= '\u2000' && c <= '\u20FF'));
}
public static boolean isKeyword(String s) {
if (s.length() < 3)
return false;
char c = s.charAt(0);
if (c == 'n')
return s.equals("null");
if (c == 't')
return s.equals("true");
if (c == 'f')
return s.equals("false");
if (c == 'N')
return s.equals("NaN");
return false;
}
public static interface StringProtector {
public void escape(String s, Appendable out);
}
private static class EscapeLT implements StringProtector {
/**
* Escape special chars form String except /
*
* @param s
* - Must not be null.
* @param out
*/
public void escape(String s, Appendable out) {
try {
int len = s.length();
for (int i = 0; i < len; i++) {
char ch = s.charAt(i);
switch (ch) {
case '"':
out.append("\\\"");
break;
case '\\':
out.append("\\\\");
break;
case '\b':
out.append("\\b");
break;
case '\f':
out.append("\\f");
break;
case '\n':
out.append("\\n");
break;
case '\r':
out.append("\\r");
break;
case '\t':
out.append("\\t");
break;
default:
// Reference:
// http://www.unicode.org/versions/Unicode5.1.0/
if ((ch >= '\u0000' && ch <= '\u001F') || (ch >= '\u007F' && ch <= '\u009F')
|| (ch >= '\u2000' && ch <= '\u20FF')) {
out.append("\\u");
String hex = "0123456789ABCDEF";
out.append(hex.charAt(ch >> 12 & 0x000F));
out.append(hex.charAt(ch >> 8 & 0x000F));
out.append(hex.charAt(ch >> 4 & 0x000F));
out.append(hex.charAt(ch >> 0 & 0x000F));
} else {
out.append(ch);
}
}
}
} catch (IOException e) {
throw new RuntimeException("Impossible Exeption");
}
}
}
private static class Escape4Web implements StringProtector {
/**
* Escape special chars form String including /
*
* @param s
* - Must not be null.
* @param sb
*/
public void escape(String s, Appendable sb) {
try {
int len = s.length();
for (int i = 0; i < len; i++) {
char ch = s.charAt(i);
switch (ch) {
case '"':
sb.append("\\\"");
break;
case '\\':
sb.append("\\\\");
break;
case '\b':
sb.append("\\b");
break;
case '\f':
sb.append("\\f");
break;
case '\n':
sb.append("\\n");
break;
case '\r':
sb.append("\\r");
break;
case '\t':
sb.append("\\t");
break;
case '/':
sb.append("\\/");
break;
default:
// Reference:
// http://www.unicode.org/versions/Unicode5.1.0/
if ((ch >= '\u0000' && ch <= '\u001F') || (ch >= '\u007F' && ch <= '\u009F')
|| (ch >= '\u2000' && ch <= '\u20FF')) {
sb.append("\\u");
String hex = "0123456789ABCDEF";
sb.append(hex.charAt(ch >> 12 & 0x0F));
sb.append(hex.charAt(ch >> 8 & 0x0F));
sb.append(hex.charAt(ch >> 4 & 0x0F));
sb.append(hex.charAt(ch >> 0 & 0x0F));
} else {
sb.append(ch);
}
}
}
} catch (IOException e) {
throw new RuntimeException("Impossible Error");
}
}
}
}

70
core/java/src/net/minidev/json/parser/ContainerFactory.java Normal file
View File

@@ -0,0 +1,70 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import net.minidev.json.JSONArray;
import net.minidev.json.JSONObject;
/**
* Container factory for creating containers for JSON object and JSON array.
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
public interface ContainerFactory {
/**
* @return A Map instance to build JSON object.
*/
public Map<String, Object> createObjectContainer();
/**
* @return A List instance to store JSON array.
*/
public List<Object> createArrayContainer();
/**
* Default factory
*/
public final static ContainerFactory FACTORY_SIMPLE = new ContainerFactory() {
// @Override JDK 1.5 compatibility change
public Map<String, Object> createObjectContainer() {
return new JSONObject();
}
// @Override JDK 1.5 compatibility change
public List<Object> createArrayContainer() {
return new JSONArray();
}
};
public final static ContainerFactory FACTORY_ORDERED = new ContainerFactory() {
// @Override JDK 1.5 compatibility change
public Map<String, Object> createObjectContainer() {
return new LinkedHashMap<String, Object>();
}
// @Override JDK 1.5 compatibility change
public List<Object> createArrayContainer() {
return new JSONArray();
}
};
}

123
core/java/src/net/minidev/json/parser/ContentHandler.java Normal file
View File

@@ -0,0 +1,123 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.IOException;
/**
* A simplified and stoppable SAX-like content handler for stream processing of
* JSON text.
*
* @see org.xml.sax.ContentHandler
*
* @author FangYidong<fangyidong@yahoo.com.cn>
*/
public interface ContentHandler {
/**
* Receive notification of the beginning of JSON processing. The parser will
* invoke this method only once.
*
* @throws ParseException
* - JSONParser will stop and throw the same exception to the
* caller when receiving this exception.
*/
void startJSON() throws ParseException, IOException;
/**
* Receive notification of the end of JSON processing.
*
* @throws ParseException
*/
void endJSON() throws ParseException, IOException;
/**
* Receive notification of the beginning of a JSON object.
*
* @return false if the handler wants to stop parsing after return.
* @throws ParseException
* - JSONParser will stop and throw the same exception to the
* caller when receiving this exception.
* @see #endJSON
*/
boolean startObject() throws ParseException, IOException;
/**
* Receive notification of the end of a JSON object.
*
* @return false if the handler wants to stop parsing after return.
* @throws ParseException
*
* @see #startObject
*/
boolean endObject() throws ParseException, IOException;
/**
* Receive notification of the beginning of a JSON object entry.
*
* @param key
* - Key of a JSON object entry.
*
* @return false if the handler wants to stop parsing after return.
* @throws ParseException
*
* @see #endObjectEntry
*/
boolean startObjectEntry(String key) throws ParseException, IOException;
/**
* Receive notification of the end of the value of previous object entry.
*
* @return false if the handler wants to stop parsing after return.
* @throws ParseException
*
* @see #startObjectEntry
*/
boolean endObjectEntry() throws ParseException, IOException;
/**
* Receive notification of the beginning of a JSON array.
*
* @return false if the handler wants to stop parsing after return.
* @throws ParseException
*
* @see #endArray
*/
boolean startArray() throws ParseException, IOException;
/**
* Receive notification of the end of a JSON array.
*
* @return false if the handler wants to stop parsing after return.
* @throws ParseException
*
* @see #startArray
*/
boolean endArray() throws ParseException, IOException;
/**
* Receive notification of the JSON primitive values: java.lang.String,
* java.lang.Number, java.lang.Boolean null
*
* @param value
* - Instance of the following: java.lang.String,
* java.lang.Number, java.lang.Boolean null
*
* @return false if the handler wants to stop parsing after return.
* @throws ParseException
*/
boolean primitive(Object value) throws ParseException, IOException;
}

131
core/java/src/net/minidev/json/parser/ContentHandlerCompressor.java Normal file
View File

@@ -0,0 +1,131 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.IOException;
import net.minidev.json.JSONStyle;
import net.minidev.json.JSONValue;
public class ContentHandlerCompressor implements ContentHandler {
Appendable out;
JSONStyle compression;
int[] stack = new int[10];
int pos;
// push 0 = < Object
// push 1 = < Array
private void push(int type) {
pos += 2;
if (pos >= stack.length) {
int[] tmp = new int[stack.length * 2];
System.arraycopy(stack, 0, tmp, 0, stack.length);
stack = tmp;
}
stack[pos] = type;
stack[pos + 1] = 0;
}
private boolean isInObject() {
return stack[pos] == 0;
}
private boolean isInArray() {
return stack[pos] == 1;
}
public ContentHandlerCompressor(Appendable out, JSONStyle compression) {
this.out = out;
this.compression = compression;
}
// @Override JDK 1.5 compatibility change
public void startJSON() throws ParseException, IOException {
}
// @Override JDK 1.5 compatibility change
public void endJSON() throws ParseException, IOException {
}
// @Override JDK 1.5 compatibility change
public boolean startObject() throws ParseException, IOException {
if (isInArray() && stack[pos + 1]++ > 0)
out.append(',');
out.append('{');
push(0);
// stack.add(JsonStructure.newObj());
return false;
}
// @Override JDK 1.5 compatibility change
public boolean endObject() throws ParseException, IOException {
out.append('}');
pos -= 2;
// stack.pop();
return false;
}
// @Override JDK 1.5 compatibility change
public boolean startObjectEntry(String key) throws ParseException, IOException {
if (stack[pos + 1]++ > 0)
out.append(',');
if (key == null)
out.append("null");
else if (!compression.mustProtectKey(key))
out.append(key);
else {
out.append('"');
JSONValue.escape(key, out, compression);
out.append('"');
}
out.append(':');
return false;
}
// @Override JDK 1.5 compatibility change
public boolean endObjectEntry() throws ParseException, IOException {
return false;
}
// @Override JDK 1.5 compatibility change
public boolean startArray() throws ParseException, IOException {
if (isInArray() && stack[pos + 1]++ > 0)
out.append(',');
out.append('[');
push(1);
return false;
}
// @Override JDK 1.5 compatibility change
public boolean endArray() throws ParseException, IOException {
out.append(']');
pos -= 2;
return false;
}
// @Override JDK 1.5 compatibility change
public boolean primitive(Object value) throws ParseException, IOException {
if (!isInObject() && stack[pos + 1]++ > 0)
out.append(',');
if (value instanceof String) {
compression.writeString(out, (String) value);
} else
JSONValue.writeJSONString(value, out, compression);
return false;
}
}

65
core/java/src/net/minidev/json/parser/ContentHandlerDumy.java Normal file
View File

@@ -0,0 +1,65 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.IOException;
public class ContentHandlerDumy implements ContentHandler {
public static ContentHandlerDumy HANDLER = new ContentHandlerDumy();
// @Override JDK 1.5 compatibility change
public void startJSON() throws ParseException {
}
// @Override JDK 1.5 compatibility change
public void endJSON() throws ParseException {
}
// @Override JDK 1.5 compatibility change
public boolean startObject() throws ParseException, IOException {
return false;
}
// @Override JDK 1.5 compatibility change
public boolean endObject() throws ParseException {
return false;
}
// @Override JDK 1.5 compatibility change
public boolean startObjectEntry(String key) throws ParseException {
return false;
}
// @Override JDK 1.5 compatibility change
public boolean endObjectEntry() throws ParseException {
return false;
}
// @Override JDK 1.5 compatibility change
public boolean startArray() throws ParseException {
return false;
}
// @Override JDK 1.5 compatibility change
public boolean endArray() throws ParseException {
return false;
}
// @Override JDK 1.5 compatibility change
public boolean primitive(Object value) throws ParseException {
return false;
}
}

81
core/java/src/net/minidev/json/parser/FakeContainerFactory.java Normal file
View File

@@ -0,0 +1,81 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Fake Container factory used for JSon check and SaX parsing
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
public class FakeContainerFactory implements ContainerFactory {
public FackList list;
public FackMap map;
// @Override JDK 1.5 compatibility change
public List<Object> createArrayContainer() {
if (list == null)
list = new FackList();
return list;
}
// @Override JDK 1.5 compatibility change
public Map<String, Object> createObjectContainer() {
if (map == null)
map = new FackMap();
return map;
}
/**
* dummy AbstractMap
*/
static class FackMap extends AbstractMap<String, Object> {
public Object put(String key, Object value) {
return null;
}
@Override
public Set<java.util.Map.Entry<String, Object>> entrySet() {
return null;
}
}
/**
* dummy AbstractList
* replace AbsractList by list to make it compile on jdk 1.7
*/
@SuppressWarnings("serial")
static class FackList extends ArrayList<Object> {
public boolean add(Object e) {
return false;
}
@Override
public Object get(int index) {
return null;
}
@Override
public int size() {
return 0;
}
}
}

266
core/java/src/net/minidev/json/parser/JSONParser.java Normal file
View File

@@ -0,0 +1,266 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.InputStream;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
public class JSONParser {
/**
* allow simple quote as String quoting char
*/
public final static int ACCEPT_SIMPLE_QUOTE = 1;
/**
* allow non quoted test
*/
public final static int ACCEPT_NON_QUOTE = 2;
/**
* Parse NaN as Float.NaN
*/
public final static int ACCEPT_NAN = 4;
/**
* Ignore control char in input text.
*/
public final static int IGNORE_CONTROL_CHAR = 8;
/**
* Use int datatype to store number when it's possible.
*
* @since 1.0.7
*/
public final static int USE_INTEGER_STORAGE = 16;
/**
* Throws exception on excessive 0 leading in digits
*
* @since 1.0.7
*/
public final static int ACCEPT_LEADING_ZERO = 32;
/**
* Throws exception on useless comma in object and array
*
* @since 1.0.8
*/
public final static int ACCEPT_USELESS_COMMA = 64;
/**
* Allow Json-smart to use Double or BigDecimal to store floating point
* value
*
* You may need to disable HI_PRECISION_FLOAT feature on 32bit to improve
* parsing performances.
*
* @since 1.0.9
*/
public final static int USE_HI_PRECISION_FLOAT = 128;
/**
* If enabled json-smart will throws exception if datas are present after
* the end of the Json data.
*
* @since 1.0.9-2
*/
public final static int ACCEPT_TAILLING_DATA = 256;
/**
* smart mode, fastest parsing mode. accept lots of non standard json syntax
*
* @since 1.3.1
*/
public final static int ACCEPT_TAILLING_SPACE = 512;
/**
* smart mode, fastest parsing mode. accept lots of non standard json syntax
*
* @since 1.0.6
*/
public final static int MODE_PERMISSIVE = -1;
/**
* strict RFC4627 mode.
*
* slower than PERMISIF MODE.
*
* @since 1.0.6
*/
public final static int MODE_RFC4627 = USE_INTEGER_STORAGE | USE_HI_PRECISION_FLOAT | ACCEPT_TAILLING_DATA;
/**
* Parse Object like json-simple
*
* Best for an iso-bug json-simple API port.
*
* @since 1.0.7
*/
public final static int MODE_JSON_SIMPLE = ACCEPT_USELESS_COMMA | USE_HI_PRECISION_FLOAT | ACCEPT_TAILLING_DATA | ACCEPT_TAILLING_SPACE;
/**
* Strictest parsing mode
*
* @since 1.0.9-2
*/
public final static int MODE_STRICTEST = USE_INTEGER_STORAGE | USE_HI_PRECISION_FLOAT;
/**
* Default json-smart processing mode
*/
public static int DEFAULT_PERMISSIVE_MODE = (System.getProperty("JSON_SMART_SIMPLE") != null) ? MODE_JSON_SIMPLE
: MODE_PERMISSIVE;
/*
* internal fields
*/
private int mode;
private JSONParserReader pStream;
private JSONParserInputStream pSBintream;
private JSONParserString pString;
private JSONParserByteArray pBytes;
/**
* @deprecated prefer usage of new JSONParser(JSONParser.MODE_*)
*/
public JSONParser() {
this.mode = DEFAULT_PERMISSIVE_MODE;
}
public JSONParser(int permissifMode) {
this.mode = permissifMode;
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(String in) throws ParseException {
if (pString == null)
pString = new JSONParserString(mode);
return pString.parse(in);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(String in, ContainerFactory containerFactory) throws ParseException {
if (pString == null)
pString = new JSONParserString(mode);
return pString.parse(in, containerFactory);
}
public Object parse(String in, ContainerFactory containerFactory, ContentHandler handler) throws ParseException {
if (pString == null)
pString = new JSONParserString(mode);
return pString.parse(in, containerFactory, handler);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(byte[] in) throws ParseException {
if (pBytes == null)
pBytes = new JSONParserByteArray(mode);
return pBytes.parse(in);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(byte[] in, ContainerFactory containerFactory) throws ParseException {
if (pBytes == null)
pBytes = new JSONParserByteArray(mode);
return pBytes.parse(in, containerFactory);
}
public Object parse(byte[] in, ContainerFactory containerFactory, ContentHandler handler) throws ParseException {
if (pBytes == null)
pBytes = new JSONParserByteArray(mode);
return pBytes.parse(in, containerFactory, handler);
}
public Object parse(byte[] in, int offset, int length) throws ParseException {
if (pBytes == null)
pBytes = new JSONParserByteArray(mode);
return pBytes.parse(in, offset, length, ContainerFactory.FACTORY_SIMPLE, ContentHandlerDumy.HANDLER);
}
public Object parse(byte[] in, int offset, int length, ContainerFactory containerFactory) throws ParseException {
if (pBytes == null)
pBytes = new JSONParserByteArray(mode);
return pBytes.parse(in, offset, length, containerFactory, ContentHandlerDumy.HANDLER);
}
public Object parse(byte[] in, int offset, int length, ContainerFactory containerFactory, ContentHandler handler)
throws ParseException {
if (pBytes == null)
pBytes = new JSONParserByteArray(mode);
return pBytes.parse(in, offset, length, containerFactory, handler);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(Reader in) throws ParseException {
if (pStream == null)
pStream = new JSONParserReader(mode);
return pStream.parse(in);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(Reader in, ContainerFactory containerFactory) throws ParseException {
if (pStream == null)
pStream = new JSONParserReader(mode);
return pStream.parse(in, containerFactory);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(Reader in, ContainerFactory containerFactory, ContentHandler handler) throws ParseException {
if (pStream == null)
pStream = new JSONParserReader(mode);
return pStream.parse(in, containerFactory, handler);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(InputStream in) throws ParseException, UnsupportedEncodingException {
if (pSBintream == null)
pSBintream = new JSONParserInputStream(mode);
return pSBintream.parse(in);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(InputStream in, ContainerFactory containerFactory) throws ParseException, UnsupportedEncodingException {
if (pSBintream == null)
pSBintream = new JSONParserInputStream(mode);
return pSBintream.parse(in, containerFactory);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(InputStream in, ContainerFactory containerFactory, ContentHandler handler)
throws ParseException, UnsupportedEncodingException {
if (pSBintream == null)
pSBintream = new JSONParserInputStream(mode);
return pSBintream.parse(in, containerFactory, handler);
}
}

666
core/java/src/net/minidev/json/parser/JSONParserBase.java Normal file
View File

@@ -0,0 +1,666 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_CHAR;
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_DUPLICATE_KEY;
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_EOF;
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_LEADING_0;
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_TOKEN;
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_UNICODE;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;
import java.util.Map;
/**
* JSONParserBase is the common code between {@link JSONParserString} and
* {@link JSONParserReader}
*
* @see JSONParserMemory
* @see JSONParserStream
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
abstract class JSONParserBase {
protected char c;
public final static byte EOI = 0x1A;
protected static final char MAX_STOP = 126; // '}' -> 125
//
protected static boolean[] stopAll = new boolean[MAX_STOP];
protected static boolean[] stopArray = new boolean[MAX_STOP];
protected static boolean[] stopKey = new boolean[MAX_STOP];
protected static boolean[] stopValue = new boolean[MAX_STOP];
protected static boolean[] stopX = new boolean[MAX_STOP];
static {
stopKey[':'] = stopKey[EOI] = true;
stopValue[','] = stopValue['}'] = stopValue[EOI] = true;
stopArray[','] = stopArray[']'] = stopArray[EOI] = true;
stopX[EOI] = true;
stopAll[','] = stopAll[':'] = true;
stopAll[']'] = stopAll['}'] = stopAll[EOI] = true;
}
/*
* End of static declaration
*/
protected ContainerFactory containerFactory;
protected ContentHandler handler;
protected final MSB sb = new MSB(15);
protected Object xo;
protected String xs;
protected int pos;
/*
* Parsing flags
*/
protected final boolean acceptLeadinZero;
protected final boolean acceptNaN;
protected final boolean acceptNonQuote;
protected final boolean acceptSimpleQuote;
protected final boolean acceptUselessComma;
protected final boolean checkTaillingData;
protected final boolean checkTaillingSpace;
protected final boolean ignoreControlChar;
protected final boolean useHiPrecisionFloat;
protected final boolean useIntegerStorage;
public JSONParserBase(int permissiveMode) {
this.acceptNaN = (permissiveMode & JSONParser.ACCEPT_NAN) > 0;
this.acceptNonQuote = (permissiveMode & JSONParser.ACCEPT_NON_QUOTE) > 0;
this.acceptSimpleQuote = (permissiveMode & JSONParser.ACCEPT_SIMPLE_QUOTE) > 0;
this.ignoreControlChar = (permissiveMode & JSONParser.IGNORE_CONTROL_CHAR) > 0;
this.useIntegerStorage = (permissiveMode & JSONParser.USE_INTEGER_STORAGE) > 0;
this.acceptLeadinZero = (permissiveMode & JSONParser.ACCEPT_LEADING_ZERO) > 0;
this.acceptUselessComma = (permissiveMode & JSONParser.ACCEPT_USELESS_COMMA) > 0;
this.useHiPrecisionFloat = (permissiveMode & JSONParser.USE_HI_PRECISION_FLOAT) > 0;
this.checkTaillingData = (permissiveMode & (JSONParser.ACCEPT_TAILLING_DATA | JSONParser.ACCEPT_TAILLING_SPACE)) != (JSONParser.ACCEPT_TAILLING_DATA | JSONParser.ACCEPT_TAILLING_SPACE);
this.checkTaillingSpace = (permissiveMode & JSONParser.ACCEPT_TAILLING_SPACE) == 0;
}
public void checkControleChar() throws ParseException {
if (ignoreControlChar)
return;
int l = xs.length();
for (int i = 0; i < l; i++) {
char c = xs.charAt(i);
if (c < 0)
continue;
if (c <= 31)
throw new ParseException(pos + i, ParseException.ERROR_UNEXPECTED_CHAR, c);
if (c == 127)
throw new ParseException(pos + i, ParseException.ERROR_UNEXPECTED_CHAR, c);
}
}
public void checkLeadinZero() throws ParseException {
int len = xs.length();
if (len == 1)
return;
if (len == 2) {
if (xs.equals("00"))
throw new ParseException(pos, ERROR_UNEXPECTED_LEADING_0, xs);
return;
}
char c1 = xs.charAt(0);
char c2 = xs.charAt(1);
if (c1 == '-') {
char c3 = xs.charAt(2);
if (c2 == '0' && c3 >= '0' && c3 <= '9')
throw new ParseException(pos, ERROR_UNEXPECTED_LEADING_0, xs);
return;
}
if (c1 == '0' && c2 >= '0' && c2 <= '9')
throw new ParseException(pos, ERROR_UNEXPECTED_LEADING_0, xs);
}
protected Number extractFloat() throws ParseException {
if (!acceptLeadinZero)
checkLeadinZero();
if (!useHiPrecisionFloat)
return Float.parseFloat(xs);
if (xs.length() > 18) // follow JSonIJ parsing method
return new BigDecimal(xs);
return Double.parseDouble(xs);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
protected Object parse(ContainerFactory containerFactory, ContentHandler handler) throws ParseException {
this.containerFactory = containerFactory;
this.handler = handler;
// this.pos = -1;
Object result;
try {
read();
handler.startJSON();
result = readMain(stopX);
handler.endJSON();
if (checkTaillingData) {
if (!checkTaillingSpace)
skipSpace();
if (c != EOI)
throw new ParseException(pos - 1, ERROR_UNEXPECTED_TOKEN, c);
}
} catch (IOException e) {
throw new ParseException(pos, e);
}
xs = null;
xo = null;
return result;
}
protected Number parseNumber(String s) throws ParseException {
// pos
int p = 0;
// len
int l = s.length();
// max pos long base 10 len
int max = 19;
boolean neg;
if (s.charAt(0) == '-') {
p++;
max++;
neg = true;
if (!acceptLeadinZero && l >= 3 && s.charAt(1) == '0')
throw new ParseException(pos, ERROR_UNEXPECTED_LEADING_0, s);
} else {
neg = false;
if (!acceptLeadinZero && l >= 2 && s.charAt(0) == '0')
throw new ParseException(pos, ERROR_UNEXPECTED_LEADING_0, s);
}
boolean mustCheck;
if (l < max) {
max = l;
mustCheck = false;
} else if (l > max) {
return new BigInteger(s, 10);
} else {
max = l - 1;
mustCheck = true;
}
long r = 0;
while (p < max) {
r = (r * 10L) + ('0' - s.charAt(p++));
}
if (mustCheck) {
boolean isBig;
if (r > -922337203685477580L) {
isBig = false;
} else if (r < -922337203685477580L) {
isBig = true;
} else {
if (neg)
isBig = (s.charAt(p) > '8');
else
isBig = (s.charAt(p) > '7');
}
if (isBig)
return new BigInteger(s, 10);
r = r * 10L + ('0' - s.charAt(p));
}
if (neg) {
if (this.useIntegerStorage && r >= Integer.MIN_VALUE)
return (int) r;
return r;
}
r = -r;
if (this.useIntegerStorage && r <= Integer.MAX_VALUE)
return (int) r;
return r;
}
/**
* Read one char in this.c
*
* @throws IOException
*/
abstract protected void read() throws IOException;
protected List<Object> readArray() throws ParseException, IOException {
List<Object> obj = containerFactory.createArrayContainer();
if (c != '[')
throw new RuntimeException("Internal Error");
read();
boolean needData = false;
handler.startArray();
for (;;) {
switch (c) {
case ' ':
case '\r':
case '\n':
case '\t':
read();
continue;
case ']':
if (needData && !acceptUselessComma)
throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, (char) c);
read(); /* unstack */
handler.endArray();
return obj;
case ':':
case '}':
throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, (char) c);
case ',':
if (needData && !acceptUselessComma)
throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, (char) c);
read();
needData = true;
continue;
case EOI:
throw new ParseException(pos - 1, ERROR_UNEXPECTED_EOF, "EOF");
default:
obj.add(readMain(stopArray));
needData = false;
continue;
}
}
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
// protected <T> T readFirst(AMapper<T> mapper) throws ParseException,
// IOException {
// }
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
protected Object readMain(boolean stop[]) throws ParseException, IOException {
for (;;) {
switch (c) {
// skip spaces
case ' ':
case '\r':
case '\n':
case '\t':
read();
continue;
// invalid stats
case ':':
case '}':
case ']':
throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, c);
// start object
case '{':
return readObject();
// start Array
case '[':
return readArray();
// start string
case '"':
case '\'':
readString();
handler.primitive(xs);
return xs;
// string or null
case 'n':
readNQString(stop);
if ("null".equals(xs)) {
handler.primitive(null);
return null;
}
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
handler.primitive(xs);
return xs;
// string or false
case 'f':
readNQString(stop);
if ("false".equals(xs)) {
handler.primitive(Boolean.FALSE);
return Boolean.FALSE;
}
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
handler.primitive(xs);
return xs;
// string or true
case 't':
readNQString(stop);
if ("true".equals(xs)) {
handler.primitive(Boolean.TRUE);
return Boolean.TRUE;
}
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
handler.primitive(xs);
return xs;
// string or NaN
case 'N':
readNQString(stop);
if (!acceptNaN)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
if ("NaN".equals(xs)) {
handler.primitive(Float.NaN);
return Float.valueOf(Float.NaN);
}
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
handler.primitive(xs);
return xs;
// digits
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '-':
xo = readNumber(stop);
handler.primitive(xo);
return xo;
default:
readNQString(stop);
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
handler.primitive(xs);
return xs;
}
}
}
abstract protected void readNoEnd() throws ParseException, IOException;
abstract protected void readNQString(boolean[] stop) throws IOException;
abstract protected Object readNumber(boolean[] stop) throws ParseException, IOException;
protected Map<String, Object> readObject() throws ParseException, IOException {
Map<String, Object> obj = this.containerFactory.createObjectContainer();
if (c != '{')
throw new RuntimeException("Internal Error");
handler.startObject();
boolean needData = false;
boolean acceptData = true;
for (;;) {
read();
switch (c) {
case ' ':
case '\r':
case '\t':
case '\n':
continue;
case ':':
case ']':
case '[':
case '{':
throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, c);
case '}':
if (needData && !acceptUselessComma)
throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, (char) c);
read(); /* unstack */
handler.endObject();
return obj;
case ',':
if (needData && !acceptUselessComma)
throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, (char) c);
acceptData = needData = true;
continue;
case '"':
case '\'':
default:
int keyStart = pos;
if (c == '\"' || c == '\'') {
readString();
} else {
readNQString(stopKey);
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
}
String key = xs;
if (!acceptData)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, key);
handler.startObjectEntry(key);
//Skip spaces
skipSpace();
if (c != ':') {
if (c == EOI)
throw new ParseException(pos - 1, ERROR_UNEXPECTED_EOF, null);
throw new ParseException(pos - 1, ERROR_UNEXPECTED_CHAR, c);
}
readNoEnd(); /* skip : */
Object duplicate = obj.put(key, readMain(stopValue));
if (duplicate != null)
throw new ParseException(keyStart, ERROR_UNEXPECTED_DUPLICATE_KEY, key);
handler.endObjectEntry();
// should loop skipping read step
//
//
//
//
skipSpace();
if (c == '}') {
read(); /* unstack */
handler.endObject();
return obj;
}
if (c == EOI) // Fixed on 18/10/2011 reported by vladimir
throw new ParseException(pos - 1, ERROR_UNEXPECTED_EOF, null);
// if c==, continue
if (c == ',')
acceptData = needData = true;
else
throw new ParseException(pos - 1, ERROR_UNEXPECTED_TOKEN, c);
// acceptData = needData = false;
}
}
}
/**
* store and read
*/
abstract void readS() throws IOException;
abstract protected void readString() throws ParseException, IOException;
protected void readString2() throws ParseException, IOException {
/* assert (c == '\"' || c == '\'') */
char sep = c;
for (;;) {
read();
switch (c) {
case EOI:
throw new ParseException(pos - 1, ERROR_UNEXPECTED_EOF, null);
case '"':
case '\'':
if (sep == c) {
read();
xs = sb.toString();
return;
}
sb.append(c);
break;
case '\\':
read();
switch (c) {
case 't':
sb.append('\t');
break;
case 'n':
sb.append('\n');
break;
case 'r':
sb.append('\r');
break;
case 'f':
sb.append('\f');
break;
case 'b':
sb.append('\b');
break;
case '\\':
sb.append('\\');
break;
case '/':
sb.append('/');
break;
case '\'':
sb.append('\'');
break;
case '"':
sb.append('"');
break;
case 'u':
sb.append(readUnicode(4));
break;
case 'x': // issue 39
sb.append(readUnicode(2));
default:
break;
}
break;
case '\0': // end of string
case (char) 1: // Start of heading
case (char) 2: // Start of text
case (char) 3: // End of text
case (char) 4: // End of transmission
case (char) 5: // Enquiry
case (char) 6: // Acknowledge
case (char) 7: // Bell
case '\b': // 8: backSpase
case '\t': // 9: horizontal tab
case '\n': // 10: new line
case (char) 11: // Vertical tab
case '\f': // 12: form feed
case '\r': // 13: return carriage
case (char) 14: // Shift Out, alternate character set
case (char) 15: // Shift In, resume defaultn character set
case (char) 16: // Data link escape
case (char) 17: // XON, with XOFF to pause listings;
case (char) 18: // Device control 2, block-mode flow control
case (char) 19: // XOFF, with XON is TERM=18 flow control
case (char) 20: // Device control 4
case (char) 21: // Negative acknowledge
case (char) 22: // Synchronous idle
case (char) 23: // End transmission block, not the same as EOT
case (char) 24: // Cancel line, MPE echoes !!!
case (char) 25: // End of medium, Control-Y interrupt
// case (char) 26: // Substitute
case (char) 27: // escape
case (char) 28: // File Separator
case (char) 29: // Group Separator
case (char) 30: // Record Separator
case (char) 31: // Unit Separator
case (char) 127: // del
if (ignoreControlChar)
continue;
throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, c);
default:
sb.append(c);
}
}
}
protected char readUnicode(int totalChars) throws ParseException, IOException {
int value = 0;
for (int i = 0; i < totalChars; i++) {
value = value * 16;
read();
if (c <= '9' && c >= '0')
value += c - '0';
else if (c <= 'F' && c >= 'A')
value += (c - 'A') + 10;
else if (c >= 'a' && c <= 'f')
value += (c - 'a') + 10;
else if (c == EOI)
throw new ParseException(pos, ERROR_UNEXPECTED_EOF, "EOF");
else
throw new ParseException(pos, ERROR_UNEXPECTED_UNICODE, c);
}
return (char) value;
}
protected void skipDigits() throws IOException {
for (;;) {
if (c < '0' || c > '9')
return;
readS();
}
}
protected void skipNQString(boolean[] stop) throws IOException {
for (;;) {
if ((c == EOI) || (c >= 0 && c < MAX_STOP && stop[c]))
return;
readS();
}
}
protected void skipSpace() throws IOException {
for (;;) {
if (c > ' ' || c == EOI)
return;
readS();
}
}
public static class MSB {
char b[];
int p;
public MSB(int size) {
b = new char[size];
p = -1;
}
public void append(char c) {
p++;
if (b.length <= p) {
char[] t = new char[b.length * 2 + 1];
System.arraycopy(b, 0, t, 0, b.length);
b = t;
}
b[p] = c;
}
public void append(int c) {
p++;
if (b.length <= p) {
char[] t = new char[b.length * 2 + 1];
System.arraycopy(b, 0, t, 0, b.length);
b = t;
}
b[p] = (char) c;
}
public String toString() {
return new String(b, 0, p + 1);
}
public void clear() {
p = -1;
}
}
}

110
core/java/src/net/minidev/json/parser/JSONParserByteArray.java Normal file
View File

@@ -0,0 +1,110 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_EOF;
/**
* Parser for JSON text. Please note that JSONParser is NOT thread-safe.
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
class JSONParserByteArray extends JSONParserMemory {
private byte[] in;
public JSONParserByteArray(int permissiveMode) {
super(permissiveMode);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(byte[] in) throws ParseException {
return parse(in, ContainerFactory.FACTORY_SIMPLE, ContentHandlerDumy.HANDLER);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(byte[] in, ContainerFactory containerFactory) throws ParseException {
return parse(in, containerFactory, ContentHandlerDumy.HANDLER);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(byte[] in, ContainerFactory containerFactory, ContentHandler handler) throws ParseException {
this.in = in;
this.len = in.length;
this.pos = -1;
return parse(containerFactory, handler);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*
*
* Processing from offset position until length
*/
public Object parse(byte[] in, int offset, int length, ContainerFactory containerFactory, ContentHandler handler)
throws ParseException {
this.in = in;
this.len = length;
this.pos = offset - 1;
return parse(containerFactory, handler);
}
protected void extractString(int beginIndex, int endIndex) {
xs = new String(in, beginIndex, endIndex - beginIndex);
}
protected int indexOf(char c, int pos) {
for (int i = pos; pos < len; i++)
if (in[i] == (byte) c)
return i;
return -1;
}
protected void read() {
if (++pos >= len)
this.c = EOI;
else
this.c = (char) in[pos];
}
/**
* Same as read() in memory parsing
*/
protected void readS() {
if (++pos >= len)
this.c = EOI;
else
this.c = (char) in[pos];
}
protected void readNoEnd() throws ParseException {
if (++pos >= len) {
this.c = EOI;
throw new ParseException(pos - 1, ERROR_UNEXPECTED_EOF, "EOF");
} else
this.c = (char) in[pos];
}
}

61
core/java/src/net/minidev/json/parser/JSONParserInputStream.java Normal file
View File

@@ -0,0 +1,61 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
/**
* Parser for JSON text. Please note that JSONParser is NOT thread-safe.
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
class JSONParserInputStream extends JSONParserReader {
// len
public JSONParserInputStream(int permissiveMode) {
super(permissiveMode);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(InputStream in) throws ParseException, UnsupportedEncodingException {
return parse(in, ContainerFactory.FACTORY_SIMPLE, ContentHandlerDumy.HANDLER);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(InputStream in, ContainerFactory containerFactory) throws ParseException, UnsupportedEncodingException {
return parse(in, containerFactory, ContentHandlerDumy.HANDLER);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
* @throws UnsupportedEncodingException
*/
public Object parse(InputStream in, ContainerFactory containerFactory, ContentHandler handler)
throws ParseException, UnsupportedEncodingException {
InputStreamReader i2 = new InputStreamReader(in, "utf8");
this.pos = -1;
return super.parse(i2, containerFactory, handler);
}
}

143
core/java/src/net/minidev/json/parser/JSONParserMemory.java Normal file
View File

@@ -0,0 +1,143 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_CHAR;
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_EOF;
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_TOKEN;
import java.io.IOException;
/**
* Parser for JSON text. Please note that JSONParser is NOT thread-safe.
*
* @author Uriel Chemouni <uchemouni@gmail.com>
* @see JSONParserString
* @see JSONParserByteArray
*/
abstract class JSONParserMemory extends JSONParserBase {
protected int len;
public JSONParserMemory(int permissiveMode) {
super(permissiveMode);
}
protected void readNQString(boolean[] stop) throws IOException {
int start = pos;
skipNQString(stop);
extractStringTrim(start, pos);
}
protected Object readNumber(boolean[] stop) throws ParseException, IOException {
int start = pos;
// accept first char digit or -
read();
skipDigits();
// Integer digit
if (c != '.' && c != 'E' && c != 'e') {
skipSpace();
if (c >= 0 && c < MAX_STOP && !stop[c] && c != EOI) {
// convert string
skipNQString(stop);
extractStringTrim(start, pos);
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
return xs;
}
extractStringTrim(start, pos);
return parseNumber(xs);
}
// floating point
if (c == '.') {
//
read();
skipDigits();
}
if (c != 'E' && c != 'e') {
skipSpace();
if (c >= 0 && c < MAX_STOP && !stop[c] && c != EOI) {
// convert string
skipNQString(stop);
extractStringTrim(start, pos);
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
return xs;
}
extractStringTrim(start, pos);
return extractFloat();
}
sb.append('E');
read();
if (c == '+' || c == '-' || c >= '0' && c <= '9') {
sb.append(c);
read(); // skip first char
skipDigits();
skipSpace();
if (c >= 0 && c < MAX_STOP && !stop[c] && c != EOI) {
// convert string
skipNQString(stop);
extractStringTrim(start, pos);
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
return xs;
}
extractStringTrim(start, pos);
return extractFloat();
} else {
skipNQString(stop);
extractStringTrim(start, pos);
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
if (!acceptLeadinZero)
checkLeadinZero();
return xs;
}
// throw new ParseException(pos - 1, ERROR_UNEXPECTED_CHAR, null);
}
protected void readString() throws ParseException, IOException {
if (!acceptSimpleQuote && c == '\'') {
if (acceptNonQuote) {
readNQString(stopAll);
return;
}
throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, c);
}
int tmpP = indexOf(c, pos + 1);
if (tmpP == -1)
throw new ParseException(len, ERROR_UNEXPECTED_EOF, null);
extractString(pos + 1, tmpP);
if (xs.indexOf('\\') == -1) {
checkControleChar();
pos = tmpP;
read();
// handler.primitive(tmp);
return;
}
sb.clear();
readString2();
}
abstract protected void extractString(int start, int stop);
abstract protected int indexOf(char c, int pos);
protected void extractStringTrim(int start, int stop) {
extractString(start, stop);
xs = xs.trim();
}
}

88
core/java/src/net/minidev/json/parser/JSONParserReader.java Normal file
View File

@@ -0,0 +1,88 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_EOF;
import java.io.IOException;
import java.io.Reader;
/**
* Parser for JSON text. Please note that JSONParser is NOT thread-safe.
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
class JSONParserReader extends JSONParserStream {
private Reader in;
// len
public JSONParserReader(int permissiveMode) {
super(permissiveMode);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(Reader in) throws ParseException {
return parse(in, ContainerFactory.FACTORY_SIMPLE, ContentHandlerDumy.HANDLER);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(Reader in, ContainerFactory containerFactory) throws ParseException {
return parse(in, containerFactory, ContentHandlerDumy.HANDLER);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(Reader in, ContainerFactory containerFactory, ContentHandler handler) throws ParseException {
//
this.in = in;
this.pos = -1;
return super.parse(containerFactory, handler);
}
protected void read() throws IOException {
int i = in.read();
c = (i == -1) ? (char) EOI : (char) i;
pos++;
//
}
protected void readS() throws IOException {
sb.append(c);
int i = in.read();
if (i == -1) {
c = EOI;
} else {
c = (char) i;
pos++;
}
}
protected void readNoEnd() throws ParseException, IOException {
int i = in.read();
if (i == -1)
throw new ParseException(pos - 1, ERROR_UNEXPECTED_EOF, "EOF");
c = (char) i;
//
}
}

142
core/java/src/net/minidev/json/parser/JSONParserStream.java Normal file
View File

@@ -0,0 +1,142 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_CHAR;
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_TOKEN;
import java.io.IOException;
/**
* Parser for JSON text. Please note that JSONParser is NOT thread-safe.
*
* @author Uriel Chemouni <uchemouni@gmail.com>
* @see JSONParserInputStream
* @see JSONParserReader
*/
abstract class JSONParserStream extends JSONParserBase {
// len
//
public JSONParserStream(int permissiveMode) {
super(permissiveMode);
}
protected void readNQString(boolean[] stop) throws IOException {
sb.clear();
skipNQString(stop);
xs = sb.toString().trim();
}
protected Object readNumber(boolean[] stop) throws ParseException, IOException {
sb.clear();
sb.append(c);// accept first char digit or -
read();
skipDigits();
// Integer digit
if (c != '.' && c != 'E' && c != 'e') {
skipSpace();
if (c >= 0 && c < MAX_STOP && !stop[c] && c != EOI) {
// convert string
skipNQString(stop);
xs = sb.toString().trim();
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
return xs;
}
xs = sb.toString().trim();
return parseNumber(xs);
}
// floating point
if (c == '.') {
sb.append(c);
read();
skipDigits();
}
if (c != 'E' && c != 'e') {
skipSpace();
if (c >= 0 && c < MAX_STOP && !stop[c] && c != EOI) {
// convert string
skipNQString(stop);
xs = sb.toString().trim();
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
return xs;
}
xs = sb.toString().trim();
return extractFloat();
}
sb.append('E');
read();
if (c == '+' || c == '-' || c >= '0' && c <= '9') {
sb.append(c);
read(); // skip first char
skipDigits();
skipSpace();
if (c >= 0 && c < MAX_STOP && !stop[c] && c != EOI) {
// convert string
skipNQString(stop);
xs = sb.toString().trim();
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
return xs;
}
xs = sb.toString().trim();
return extractFloat();
} else {
skipNQString(stop);
xs = sb.toString().trim();
if (!acceptNonQuote)
throw new ParseException(pos, ERROR_UNEXPECTED_TOKEN, xs);
if (!acceptLeadinZero)
checkLeadinZero();
return xs;
}
// throw new ParseException(pos - 1, ERROR_UNEXPECTED_CHAR, null);
}
protected void readString() throws ParseException, IOException {
if (!acceptSimpleQuote && c == '\'') {
if (acceptNonQuote) {
readNQString(stopAll);
return;
}
throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, c);
}
sb.clear();
//
//
//
//
//
//
//
//
//
//
/* assert (c == '\"' || c == '\'') */
readString2();
}
//
//
//
//
//
//
//
//
}

95
core/java/src/net/minidev/json/parser/JSONParserString.java Normal file
View File

@@ -0,0 +1,95 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_EOF;
/**
* Parser for JSON text. Please note that JSONParser is NOT thread-safe.
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
class JSONParserString extends JSONParserMemory {
private String in;
public JSONParserString(int permissiveMode) {
super(permissiveMode);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(String in) throws ParseException {
return parse(in, ContainerFactory.FACTORY_SIMPLE, ContentHandlerDumy.HANDLER);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(String in, ContainerFactory containerFactory) throws ParseException {
return parse(in, containerFactory, ContentHandlerDumy.HANDLER);
}
/**
* use to return Primitive Type, or String, Or JsonObject or JsonArray
* generated by a ContainerFactory
*/
public Object parse(String in, ContainerFactory containerFactory, ContentHandler handler) throws ParseException {
this.in = in;
this.len = in.length();
this.pos = -1;
return parse(containerFactory, handler);
}
protected void extractString(int beginIndex, int endIndex) {
xs = in.substring(beginIndex, endIndex);
}
protected int indexOf(char c, int pos) {
return in.indexOf(c, pos);
}
/**
* Read next char or END OF INPUT
*/
protected void read() {
if (++pos >= len)
this.c = EOI;
else
this.c = in.charAt(pos);
}
/**
* Same as read() in memory parsing
*/
protected void readS() {
if (++pos >= len)
this.c = EOI;
else
this.c = in.charAt(pos);
}
/**
* read data can not be EOI
*/
protected void readNoEnd() throws ParseException {
if (++pos >= len) {
this.c = EOI;
throw new ParseException(pos - 1, ERROR_UNEXPECTED_EOF, "EOF");
} else
this.c = in.charAt(pos);
}
}

125
core/java/src/net/minidev/json/parser/ParseException.java Normal file
View File

@@ -0,0 +1,125 @@
package net.minidev.json.parser;
/*
* Copyright 2011 JSON-SMART authors
*
* 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.
*/
/**
* ParseException explains why and where the error occurs in source JSON text.
*
* @author Uriel Chemouni <uchemouni@gmail.com>
*/
public class ParseException extends Exception {
private static final long serialVersionUID = 8879024178584091857L;
public static final int ERROR_UNEXPECTED_CHAR = 0;
public static final int ERROR_UNEXPECTED_TOKEN = 1;
public static final int ERROR_UNEXPECTED_EXCEPTION = 2;
public static final int ERROR_UNEXPECTED_EOF = 3;
public static final int ERROR_UNEXPECTED_UNICODE = 4;
public static final int ERROR_UNEXPECTED_DUPLICATE_KEY = 5;
public static final int ERROR_UNEXPECTED_LEADING_0 = 6;
private int errorType;
private Object unexpectedObject;
private int position;
public ParseException(int position, int errorType, Object unexpectedObject) {
super(toMessage(position, errorType, unexpectedObject));
this.position = position;
this.errorType = errorType;
this.unexpectedObject = unexpectedObject;
}
public ParseException(int position, Throwable cause) {
super(toMessage(position, ERROR_UNEXPECTED_EXCEPTION, cause), cause);
this.position = position;
this.errorType = ERROR_UNEXPECTED_EXCEPTION;
this.unexpectedObject = cause;
}
public int getErrorType() {
return errorType;
}
/**
* @return The character position (starting with 0) of the input where the
* error occurs.
*/
public int getPosition() {
return position;
}
/**
* @return One of the following base on the value of errorType:
* ERROR_UNEXPECTED_CHAR java.lang.Character ERROR_UNEXPECTED_TOKEN
* ERROR_UNEXPECTED_EXCEPTION java.lang.Exception
*/
public Object getUnexpectedObject() {
return unexpectedObject;
}
private static String toMessage(int position, int errorType, Object unexpectedObject) {
StringBuilder sb = new StringBuilder();
if (errorType == ERROR_UNEXPECTED_CHAR) {
sb.append("Unexpected character (");
sb.append(unexpectedObject);
sb.append(") at position ");
sb.append(position);
sb.append(".");
} else if (errorType == ERROR_UNEXPECTED_TOKEN) {
sb.append("Unexpected token ");
sb.append(unexpectedObject);
sb.append(" at position ");
sb.append(position);
sb.append(".");
} else if (errorType == ERROR_UNEXPECTED_EXCEPTION) {
sb.append("Unexpected exception ");
sb.append(unexpectedObject);
sb.append(" occur at position ");
sb.append(position);
sb.append(".");
} else if (errorType == ERROR_UNEXPECTED_EOF) {
sb.append("Unexpected End Of File position ");
sb.append(position);
sb.append(": ");
sb.append(unexpectedObject);
} else if (errorType == ERROR_UNEXPECTED_UNICODE) {
sb.append("Unexpected unicode escape sequence ");
sb.append(unexpectedObject);
sb.append(" at position ");
sb.append(position);
sb.append(".");
} else if (errorType == ERROR_UNEXPECTED_DUPLICATE_KEY) {
sb.append("Unexpected duplicate key:");
sb.append(unexpectedObject);
sb.append(" at position ");
sb.append(position);
sb.append(".");
} else if (errorType == ERROR_UNEXPECTED_LEADING_0) {
sb.append("Unexpected leading 0 in digit for token:");
sb.append(unexpectedObject);
sb.append(" at position ");
sb.append(position);
sb.append(".");
} else {
sb.append("Unkown error at position ");
sb.append(position);
sb.append(".");
}
return sb.toString();
}
}

21
core/java/src/net/minidev/json/reader/ArrayWriter.java Normal file
View File

@@ -0,0 +1,21 @@
package net.minidev.json.reader;
import java.io.IOException;
import net.minidev.json.JSONStyle;
import net.minidev.json.JSONValue;
public class ArrayWriter implements JsonWriterI<Object> {
public <E> void writeJSONString(E value, Appendable out, JSONStyle compression) throws IOException {
compression.arrayStart(out);
boolean needSep = false;
for (Object o : ((Object[]) value)) {
if (needSep)
compression.objectNext(out);
else
needSep = true;
JSONValue.writeJSONString(o, out, compression);
}
compression.arrayStop(out);
}
}

63
core/java/src/net/minidev/json/reader/BeansWriter.java Normal file
View File

@@ -0,0 +1,63 @@
package net.minidev.json.reader;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import net.minidev.json.JSONStyle;
import net.minidev.json.JSONUtil;
public class BeansWriter implements JsonWriterI<Object> {
public <E> void writeJSONString(E value, Appendable out, JSONStyle compression) throws IOException {
try {
Class<?> nextClass = value.getClass();
boolean needSep = false;
compression.objectStart(out);
while (nextClass != Object.class) {
Field[] fields = nextClass.getDeclaredFields();
for (Field field : fields) {
int m = field.getModifiers();
if ((m & (Modifier.STATIC | Modifier.TRANSIENT | Modifier.FINAL)) > 0)
continue;
Object v = null;
if ((m & Modifier.PUBLIC) > 0) {
v = field.get(value);
} else {
String g = JSONUtil.getGetterName(field.getName());
Method mtd = null;
try {
mtd = nextClass.getDeclaredMethod(g);
} catch (Exception e) {
}
if (mtd == null) {
Class<?> c2 = field.getType();
if (c2 == Boolean.TYPE || c2 == Boolean.class) {
g = JSONUtil.getIsName(field.getName());
mtd = nextClass.getDeclaredMethod(g);
}
}
if (mtd == null)
continue;
v = mtd.invoke(value);
}
if (v == null && compression.ignoreNull())
continue;
if (needSep)
compression.objectNext(out);
else
needSep = true;
String key = field.getName();
JsonWriter.writeJSONKV(key, v, out, compression);
// compression.objectElmStop(out);
}
nextClass = nextClass.getSuperclass();
}
compression.objectStop(out);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}

395
core/java/src/net/minidev/json/reader/JsonWriter.java Normal file
View File

@@ -0,0 +1,395 @@
package net.minidev.json.reader;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Date;
import java.util.LinkedList;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import net.minidev.json.JSONAware;
import net.minidev.json.JSONAwareEx;
import net.minidev.json.JSONStreamAware;
import net.minidev.json.JSONStreamAwareEx;
import net.minidev.json.JSONStyle;
import net.minidev.json.JSONValue;
public class JsonWriter {
private ConcurrentHashMap<Class<?>, JsonWriterI<?>> data;
private LinkedList<WriterByInterface> writerInterfaces;
public JsonWriter() {
data = new ConcurrentHashMap<Class<?>, JsonWriterI<?>>();
writerInterfaces = new LinkedList<WriterByInterface>();
init();
}
static class WriterByInterface {
public Class<?> _interface;
public JsonWriterI<?> _writer;
public WriterByInterface(Class<?> _interface, JsonWriterI<?> _writer) {
this._interface = _interface;
this._writer = _writer;
}
}
/**
* try to find a Writer by Cheking implemented interface
* @param clazz class to serialize
* @return a Writer or null
*/
@SuppressWarnings("rawtypes")
public JsonWriterI getWriterByInterface(Class<?> clazz) {
for (WriterByInterface w : writerInterfaces) {
if (w._interface.isAssignableFrom(clazz))
return w._writer;
}
return null;
}
@SuppressWarnings("rawtypes")
public JsonWriterI getWrite(Class cls) {
return data.get(cls);
}
final static public JsonWriterI<JSONStreamAwareEx> JSONStreamAwareWriter = new JsonWriterI<JSONStreamAwareEx>() {
public <E extends JSONStreamAwareEx> void writeJSONString(E value, Appendable out, JSONStyle compression) throws IOException {
value.writeJSONString(out);
}
};
final static public JsonWriterI<JSONStreamAwareEx> JSONStreamAwareExWriter = new JsonWriterI<JSONStreamAwareEx>() {
public <E extends JSONStreamAwareEx> void writeJSONString(E value, Appendable out, JSONStyle compression) throws IOException {
value.writeJSONString(out, compression);
}
};
final static public JsonWriterI<JSONAwareEx> JSONJSONAwareExWriter = new JsonWriterI<JSONAwareEx>() {
public <E extends JSONAwareEx> void writeJSONString(E value, Appendable out, JSONStyle compression) throws IOException {
out.append(value.toJSONString(compression));
}
};
final static public JsonWriterI<JSONAware> JSONJSONAwareWriter = new JsonWriterI<JSONAware>() {
public <E extends JSONAware> void writeJSONString(E value, Appendable out, JSONStyle compression) throws IOException {
out.append(value.toJSONString());
}
};
final static public JsonWriterI<Iterable<? extends Object>> JSONIterableWriter = new JsonWriterI<Iterable<? extends Object>>() {
public <E extends Iterable<? extends Object>> void writeJSONString(E list, Appendable out, JSONStyle compression) throws IOException {
boolean first = true;
compression.arrayStart(out);
for (Object value : list) {
if (first) {
first = false;
compression.arrayfirstObject(out);
} else {
compression.arrayNextElm(out);
}
if (value == null)
out.append("null");
else
JSONValue.writeJSONString(value, out, compression);
compression.arrayObjectEnd(out);
}
compression.arrayStop(out);
}
};
final static public JsonWriterI<Enum<?>> EnumWriter = new JsonWriterI<Enum<?>>() {
public <E extends Enum<?>> void writeJSONString(E value, Appendable out, JSONStyle compression) throws IOException {
@SuppressWarnings("rawtypes")
String s = ((Enum) value).name();
compression.writeString(out, s);
}
};
final static public JsonWriterI<Map<String, ? extends Object>> JSONMapWriter = new JsonWriterI<Map<String, ? extends Object>>() {
public <E extends Map<String, ? extends Object>> void writeJSONString(E map, Appendable out, JSONStyle compression) throws IOException {
boolean first = true;
compression.objectStart(out);
/**
* do not use <String, Object> to handle non String key maps
*/
for (Map.Entry<?, ?> entry : map.entrySet()) {
Object v = entry.getValue();
if (v == null && compression.ignoreNull())
continue;
if (first) {
compression.objectFirstStart(out);
first = false;
} else {
compression.objectNext(out);
}
JsonWriter.writeJSONKV(entry.getKey().toString(), v, out, compression);
// compression.objectElmStop(out);
}
compression.objectStop(out);
}
};
/**
* Json-Smart V2 Beans serialiser
*
* Based on ASM
*/
// final static public JsonWriterI<Object> beansWriterASM = new BeansWriterASM();
/**
* Json-Smart V1 Beans serialiser
*/
final static public JsonWriterI<Object> beansWriter = new BeansWriter();
/**
* Json-Smart ArrayWriterClass
*/
final static public JsonWriterI<Object> arrayWriter = new ArrayWriter();
/**
* ToString Writer
*/
final static public JsonWriterI<Object> toStringWriter = new JsonWriterI<Object>() {
public void writeJSONString(Object value, Appendable out, JSONStyle compression) throws IOException {
out.append(value.toString());
}
};
public void init() {
registerWriter(new JsonWriterI<String>() {
public void writeJSONString(String value, Appendable out, JSONStyle compression) throws IOException {
compression.writeString(out, (String) value);
}
}, String.class);
registerWriter(new JsonWriterI<Double>() {
public void writeJSONString(Double value, Appendable out, JSONStyle compression) throws IOException {
if (value.isInfinite())
out.append("null");
else
out.append(value.toString());
}
}, Double.class);
registerWriter(new JsonWriterI<Date>() {
public void writeJSONString(Date value, Appendable out, JSONStyle compression) throws IOException {
out.append('"');
JSONValue.escape(value.toString(), out, compression);
out.append('"');
}
}, Date.class);
registerWriter(new JsonWriterI<Float>() {
public void writeJSONString(Float value, Appendable out, JSONStyle compression) throws IOException {
if (value.isInfinite())
out.append("null");
else
out.append(value.toString());
}
}, Float.class);
registerWriter(toStringWriter, Integer.class, Long.class, Byte.class, Short.class, BigInteger.class, BigDecimal.class);
registerWriter(toStringWriter, Boolean.class);
/**
* Array
*/
registerWriter(new JsonWriterI<int[]>() {
public void writeJSONString(int[] value, Appendable out, JSONStyle compression) throws IOException {
boolean needSep = false;
compression.arrayStart(out);
for (int b : value) {
if (needSep)
compression.objectNext(out);
else
needSep = true;
out.append(Integer.toString(b));
}
compression.arrayStop(out);
}
}, int[].class);
registerWriter(new JsonWriterI<short[]>() {
public void writeJSONString(short[] value, Appendable out, JSONStyle compression) throws IOException {
boolean needSep = false;
compression.arrayStart(out);
for (short b : value) {
if (needSep)
compression.objectNext(out);
else
needSep = true;
out.append(Short.toString(b));
}
compression.arrayStop(out);
}
}, short[].class);
registerWriter(new JsonWriterI<long[]>() {
public void writeJSONString(long[] value, Appendable out, JSONStyle compression) throws IOException {
boolean needSep = false;
compression.arrayStart(out);
for (long b : value) {
if (needSep)
compression.objectNext(out);
else
needSep = true;
out.append(Long.toString(b));
}
compression.arrayStop(out);
}
}, long[].class);
registerWriter(new JsonWriterI<float[]>() {
public void writeJSONString(float[] value, Appendable out, JSONStyle compression) throws IOException {
boolean needSep = false;
compression.arrayStart(out);
for (float b : value) {
if (needSep)
compression.objectNext(out);
else
needSep = true;
out.append(Float.toString(b));
}
compression.arrayStop(out);
}
}, float[].class);
registerWriter(new JsonWriterI<double[]>() {
public void writeJSONString(double[] value, Appendable out, JSONStyle compression) throws IOException {
boolean needSep = false;
compression.arrayStart(out);
for (double b : value) {
if (needSep)
compression.objectNext(out);
else
needSep = true;
out.append(Double.toString(b));
}
compression.arrayStop(out);
}
}, double[].class);
registerWriter(new JsonWriterI<boolean[]>() {
public void writeJSONString(boolean[] value, Appendable out, JSONStyle compression) throws IOException {
boolean needSep = false;
compression.arrayStart(out);
for (boolean b : value) {
if (needSep)
compression.objectNext(out);
else
needSep = true;
out.append(Boolean.toString(b));
}
compression.arrayStop(out);
}
}, boolean[].class);
registerWriterInterface(JSONStreamAwareEx.class, JsonWriter.JSONStreamAwareExWriter);
registerWriterInterface(JSONStreamAware.class, JsonWriter.JSONStreamAwareWriter);
registerWriterInterface(JSONAwareEx.class, JsonWriter.JSONJSONAwareExWriter);
registerWriterInterface(JSONAware.class, JsonWriter.JSONJSONAwareWriter);
registerWriterInterface(Map.class, JsonWriter.JSONMapWriter);
registerWriterInterface(Iterable.class, JsonWriter.JSONIterableWriter);
registerWriterInterface(Enum.class, JsonWriter.EnumWriter);
registerWriterInterface(Number.class, JsonWriter.toStringWriter);
}
/**
* associate an Writer to a interface With Hi priority
* @param interFace interface to map
* @param writer writer Object
* @deprecated use registerWriterInterfaceFirst
*/
public void addInterfaceWriterFirst(Class<?> interFace, JsonWriterI<?> writer) {
registerWriterInterfaceFirst(interFace, writer);
}
/**
* associate an Writer to a interface With Low priority
* @param interFace interface to map
* @param writer writer Object
* @deprecated use registerWriterInterfaceLast
*/
public void addInterfaceWriterLast(Class<?> interFace, JsonWriterI<?> writer) {
registerWriterInterfaceLast(interFace, writer);
}
/**
* associate an Writer to a interface With Low priority
* @param interFace interface to map
* @param writer writer Object
*/
public void registerWriterInterfaceLast(Class<?> interFace, JsonWriterI<?> writer) {
writerInterfaces.addLast(new WriterByInterface(interFace, writer));
}
/**
* associate an Writer to a interface With Hi priority
* @param interFace interface to map
* @param writer writer Object
*/
public void registerWriterInterfaceFirst(Class<?> interFace, JsonWriterI<?> writer) {
writerInterfaces.addFirst(new WriterByInterface(interFace, writer));
}
/**
* an alias for registerWriterInterfaceLast
* @param interFace interface to map
* @param writer writer Object
*/
public void registerWriterInterface(Class<?> interFace, JsonWriterI<?> writer) {
registerWriterInterfaceLast(interFace, writer);
}
/**
* associate an Writer to a Class
* @param writer
* @param cls
*/
public <T> void registerWriter(JsonWriterI<T> writer, Class<?>... cls) {
for (Class<?> c : cls)
data.put(c, writer);
}
/**
* Write a Key : value entry to a stream
*/
public static void writeJSONKV(String key, Object value, Appendable out, JSONStyle compression) throws IOException {
if (key == null)
out.append("null");
else if (!compression.mustProtectKey(key))
out.append(key);
else {
out.append('"');
JSONValue.escape(key, out, compression);
out.append('"');
}
compression.objectEndOfKey(out);
if (value instanceof String) {
compression.writeString(out, (String) value);
} else
JSONValue.writeJSONString(value, out, compression);
compression.objectElmStop(out);
}
}

9
core/java/src/net/minidev/json/reader/JsonWriterI.java Normal file
View File

@@ -0,0 +1,9 @@
package net.minidev.json.reader;
import java.io.IOException;
import net.minidev.json.JSONStyle;
public interface JsonWriterI<T> {
public <E extends T> void writeJSONString(E value, Appendable out, JSONStyle compression) throws IOException;
}