package org.json;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.StringWriter;

import java.io.Writer;

import java.lang.reflect.Array;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

/**

* This is a "mashup" test for combining the two JSON types, the goal is to make

* it work similarly to how the processing XML library works.

*

* loadJSON(); should be able of returning both types of objects, and to do that

* without having the typecast you need to combine the two classes somehow.

*

* The way you use this is calling JSON.loadJSON("filename"); (or similar) and

* then the class will maintain the type of object it is (either array or

* object) and simply forward the requests the user does to the correct class...

* of course making sure that the type is of correct class! You shouldn't be

* able of calling ".get(index)" on an JSONObject for example... it should then

* notify the user by a simple text message to the console.

*

* @author ksango

*

*/

public class JSON {

/*

* Defines the type of object

*/

protected enum JSONType {

OBJECT, ARRAY, NULL

};

protected JSONType type;

protected JSONObject obj;

protected JSONArray arr;

protected JSON(){

// Empty, used for inner classes

}

protected JSON(Object array){

this();

if (array.getClass().isArray()) {

int length = Array.getLength(array);

for (int i = 0; i < length; i += 1) {

arr.innerAppend(JSONObject.wrap(Array.get(array, i)));

}

} else {

// throw new JSONException(

// "JSONArray initial value should be a string or collection or array.");

System.out

.println("JSONArray initial value should be a string or collection or array.");

}

}

/**

* Constructor for JSONTokeners.

*

* @param tokener

*/

protected JSON(JSONTokener tokener) {

char nextChar = tokener.nextClean();

tokener.back();

if (nextChar == '{') {

try {

obj = new JSONObject(tokener);

this.type = JSONType.OBJECT;

return;

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException("Failed to create JSONObject");

}

}else if (nextChar == '[') {

try {

arr = new JSONArray(tokener);

this.type = JSONType.ARRAY;

return;

} catch (Exception e) {

throw new RuntimeException("Failed to create JSONArray");

}

}else{

throw new RuntimeException("Text is not JSON formatted");

}

}

public JSONType getType(){

return type;

}

public JSON accumulate( String key, Object value ) {

if( type == JSONType.OBJECT ){

return obj.accumulate(key, value );

}else{

throw new RuntimeException("Not a JSONObject");

}

}

public JSON accumulate( Object value ) {

if( type == JSONType.ARRAY ){

return arr.accumulate( value );

}else{

throw new RuntimeException("Not a JSONArray");

}

}

protected Object opt(String key) {

if( type == JSONType.OBJECT ) {

return obj.innerOpt(key);

} else {

throw new RuntimeException("Not a JSONObject, perhaps you meant opt(int)?");

}

}

protected Object opt(int index) {

if( type == JSONType.ARRAY ) {

return arr.innerOpt(index);

} else {

throw new RuntimeException("Not a JSONArray, perhaps you meant opt(String)?");

}

}

public static JSON createObject(){

return new JSONObject();

}

public static JSON createArray(){

return new JSONArray();

}

/**

* Open a json file

*

* @param json

*

* @return

*/

public static JSON load(String filename) {

InputStream input = null;

try {

input = new FileInputStream(filename);

} catch (FileNotFoundException e1) {

throw new RuntimeException("Failed to find file " + filename);

}

JSONTokener tokener = new JSONTokener(input);

char next = tokener.nextClean();

tokener.back();

if (next == '{' || next == '[') {

try {

return new JSON(tokener);

} catch (Exception e) {

throw new RuntimeException("Failed to create JSON");

}

}

throw new RuntimeException("File is not JSON formatted");

}

public static JSON parse(String data){

JSONTokener tokener = new JSONTokener(data);

char next = tokener.nextClean();

tokener.back();

if (next == '{' || next == '[') {

try {

return new JSON(tokener);

} catch (Exception e) {

throw new RuntimeException("Failed to create JSON");

}

}

throw new RuntimeException("Text is not JSON formatted");

}

protected Object get(String key){

if( type == JSONType.OBJECT )

return obj.innerGet(key);

else

throw new RuntimeException("Not a JSONObject, try using get(int)");

}

protected Object get(int index){

if( type == JSONType.ARRAY )

return arr.get(index);

else

throw new RuntimeException("Not a JSONArray, try using get(String)");

}

protected JSON put(String key, Object value){

if( type == JSONType.OBJECT )

return obj.innerPut(key, value);

else

throw new RuntimeException("Not a JSONObject, try using get(int)");

}

public int length(){

if( type == JSONType.ARRAY ){

return arr.size();

}else if (type == JSONType.OBJECT){

return obj.size();

}else{

throw new RuntimeException("Not a JSON Type.");

}

}

// JSONObject methods

public Iterator keys() {

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject.");

}else{

return obj.keys();

}

}

public String getString(String key) {

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using getString(int) instead.");

}else{

return obj.getInnerString(key);

}

}

public JSON setString(String key, String value){

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using append(String) instead.");

}else{

return obj.setInnerString(key, value);

}

}

public int getInt(String key) {

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using getInt(int) instead.");

}else{

return obj.getInnerInt(key);

}

}

public JSON setInt(String key, int value){

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using append(int) instead.");

}else{

return obj.setInnerInt(key, value);

}

}

public float getFloat(String key) {

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using getFloat(int) instead.");

}else{

return obj.getInnerFloat(key);

}

}

public JSON setFloat(String key, float value){

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using append(float) instead.");

}else{

return obj.setInnerFloat(key, value);

}

}

public double getDouble(String key) {

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using getDouble(int) instead.");

}else{

return obj.getInnerDouble(key);

}

}

public JSON setDouble(String key, double value){

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using append(double) instead.");

}else{

return obj.setInnerDouble(key, value);

}

}

public boolean getBoolean(String key) {

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using getBoolean(int) instead.");

}else{

return obj.getInnerBoolean(key);

}

}

public JSON setBoolean(String key, boolean value){

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using append(boolean) instead.");

}else{

return obj.setInnerBoolean(key, value);

}

}

public JSONObject getObject(String key) {

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using getObject(int) instead.");

}else{

return obj.getInnerJSONObject(key);

}

}

public JSON setObject(String key, JSONObject value){

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using append(JSONObject) instead.");

}else{

return obj.setInnerObject(key, value);

}

}

public JSONArray getArray(String key) {

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using getArray(int) instead.");

}else{

return obj.getInnerJSONArray(key);

}

}

public JSON setArray(String key, JSONArray value){

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using append(JSONArray) instead.");

}else{

return obj.setInnerArray(key, value);

}

}

public JSON getJSON(String key) {

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using getJSON(int) instead.");

}else{

return obj.getInnerJSON(key);

}

}

public JSON setJSON(String key, JSON value){

if( type != JSONType.OBJECT ){

throw new RuntimeException("Not a JSONObject, try using append(JSON) instead.");

}else{

return obj.setInnerJSON(key, value);

}

}

//JSONArray methods

public String getString(int index){

if( type != JSONType.ARRAY ){

throw new RuntimeException("Not a JSONArray, try using getString(String) instead.");

}else{

return arr.getInnerString(index);

}

}

public JSON append(String value){

if( type != JSONType.ARRAY){

throw new RuntimeException("Not a JSONArray, try using setString(String, String) instead.");

} else {

return arr.innerAppend(value);

}

}

public int getInt(int index){

if( type != JSONType.ARRAY ){

throw new RuntimeException("Not a JSONArray, try using getInt(String) instead.");

}else{

return arr.getInnerInt(index);

}

}

public JSON append(int value){

if( type != JSONType.ARRAY){

throw new RuntimeException("Not a JSONArray, try using setInt(String, int) instead.");

} else {

return arr.innerAppend(value);

}

}

public float getFloat(int index){

if( type != JSONType.ARRAY ){

throw new RuntimeException("Not a JSONArray, try using getFloat(String) instead.");

}else{

return arr.getInnerFloat(index);

}

}

public JSON append(float value){

if( type != JSONType.ARRAY){

throw new RuntimeException("Not a JSONArray, try using setFloat(String, float) instead.");

} else {

return arr.innerAppend(value);

}

}

public double getDouble(int index){

if( type != JSONType.ARRAY ){

throw new RuntimeException("Not a JSONArray, try using getDouble(String) instead.");

}else{

return arr.getInnerDouble(index);

}

}

public JSON append(double value){

if( type != JSONType.ARRAY){

throw new RuntimeException("Not a JSONArray, try using setDouble(String, double) instead.");

} else {

return arr.innerAppend(value);

}

}

public boolean getBoolean(int index){

if( type != JSONType.ARRAY ){

throw new RuntimeException("Not a JSONArray, try using getBoolean(String) instead.");

}else{

return arr.getInnerBoolean(index);

}

}

public JSON append(boolean value){

if( type != JSONType.ARRAY){

throw new RuntimeException("Not a JSONArray, try using setBoolean(String, boolean) instead.");

} else {

return arr.innerAppend(value);

}

}

public JSONArray getArray(int index){

if( type != JSONType.ARRAY ){

throw new RuntimeException("Not a JSONArray, try using getArray(String) instead.");

}else{

return arr.getInnerArray(index);

}

}

public JSON append(JSONArray value){

if( type != JSONType.ARRAY){

throw new RuntimeException("Not a JSONArray, try using setArray(String, JSONArray) instead.");

} else {

return arr.innerAppend(value);

}

}

public JSONObject getObject(int index){

if( type != JSONType.ARRAY ){

throw new RuntimeException("Not a JSONArray, try using getObject(String) instead.");

}else{

return arr.getInnerObject(index);

}

}

public JSON append(JSONObject value){

if( type != JSONType.ARRAY){

throw new RuntimeException("Not a JSONArray, try using setObject(String, JSONObject) instead.");

} else {

return arr.innerAppend(value);

}

}

public JSON getJSON(int index){

if( type != JSONType.ARRAY ){

throw new RuntimeException("Not a JSONArray, try using getJSON(String) instead.");

}else{

return arr.getInnerJSON(index);

}

}

public JSON append(JSON value){

if( type != JSONType.ARRAY){

throw new RuntimeException("Not a JSONArray, try using setJSON(String, JSON) instead.");

} else {

return arr.innerAppend(value);

}

}

protected JSON append(Object object){

if( type != JSONType.ARRAY){

throw new RuntimeException("Not a JSONArray, try using setJSON(String, JSON) instead.");

} else {

return arr.innerAppend(object);

}

}

@Override

public String toString() {

if( type == JSONType.OBJECT){

return obj.toString();

}else if (type == JSONType.ARRAY){

return arr.toString();

}else{

throw new RuntimeException("Not an acceptable JSON type.");

}

}

/**

* JSONObject.NULL is equivalent to the value that JavaScript calls null,

* whilst Java's null is equivalent to the value that JavaScript calls

* undefined.

*/

private static final class Null extends JSON {

/**

* There is only intended to be a single instance of the NULL object, so

* the clone method returns itself.

*

* @return NULL.

*/

@Override

protected final Object clone() {

return this;

}

/**

* A Null object is equal to the null value and to itself.

*

* @param object

* An object to test for nullness.

* @return true if the object parameter is the JSONObject.NULL object or

* null.

*/

@Override

public boolean equals(Object object) {

return object == null || object == this;

}

/**

* Get the "null" string value.

*

* @return The string "null".

*/

@Override

public String toString() {

return "null";

}

@Override

public int hashCode() {

// TODO Auto-generated method stub

return super.hashCode();

}

}

/**

* It is sometimes more convenient and less ambiguous to have a

* <code>NULL</code> object than to use Java's <code>null</code> value.

* <code>JSONObject.NULL.equals(null)</code> returns <code>true</code>.

* <code>JSONObject.NULL.toString()</code> returns <code>"null"</code>.

*/

public static final Object NULL = new Null();

/**

* A JSONObject is an unordered collection of name/value pairs. Its external

* form is a string wrapped in curly braces with colons between the names and

* values, and commas between the values and names. The internal form is an

* object having <code>get</code> and <code>opt</code> methods for accessing the

* values by name, and <code>put</code> methods for adding or replacing values

* by name. The values can be any of these types: <code>Boolean</code>,

* <code>JSONArray</code>, <code>JSONObject</code>, <code>Number</code>,

* <code>String</code>, or the <code>JSONObject.NULL</code> object. A JSONObject

* constructor can be used to convert an external form JSON text into an

* internal form whose values can be retrieved with the <code>get</code> and

* <code>opt</code> methods, or to convert values into a JSON text using the

* <code>put</code> and <code>toString</code> methods. A <code>get</code> method

* returns a value if one can be found, and throws an exception if one cannot be

* found. An <code>opt</code> method returns a default value instead of throwing

* an exception, and so is useful for obtaining optional values.

* <p>

* The generic <code>get()</code> and <code>opt()</code> methods return an

* object, which you can cast or query for type. There are also typed

* <code>get</code> and <code>opt</code> methods that do type checking and type

* coercion for you. The opt methods differ from the get methods in that they do

* not throw. Instead, they return a specified value, such as null.

* <p>

* The <code>put</code> methods add or replace values in an object. For example,

*

* <pre>

* myString = new JSONObject().put(&quot;JSON&quot;, &quot;Hello, World!&quot;).toString();

* </pre>

*

* produces the string <code>{"JSON": "Hello, World"}</code>.

* <p>

* The texts produced by the <code>toString</code> methods strictly conform to

* the JSON syntax rules. The constructors are more forgiving in the texts they

* will accept:

* <ul>

* <li>An extra <code>,</code>&nbsp;<small>(comma)</small> may appear just

* before the closing brace.</li>

* <li>Strings may be quoted with <code>'</code>&nbsp;<small>(single

* quote)</small>.</li>

* <li>Strings do not need to be quoted at all if they do not begin with a quote

* or single quote, and if they do not contain leading or trailing spaces, and

* if they do not contain any of these characters:

* <code>{ } [ ] / \ : , = ; #</code> and if they do not look like numbers and

* if they are not the reserved words <code>true</code>, <code>false</code>, or

* <code>null</code>.</li>

* <li>Keys can be followed by <code>=</code> or <code>=></code> as well as by

* <code>:</code>.</li>

* <li>Values can be followed by <code>;</code> <small>(semicolon)</small> as

* well as by <code>,</code> <small>(comma)</small>.</li>

* </ul>

*

* @author JSON.org

* @version 2012-12-01

*/

static class JSONObject extends JSON {

/**

* The maximum number of keys in the key pool.

*/

private static final int keyPoolSize = 100;

/**

* Key pooling is like string interning, but without permanently tying up

* memory. To help conserve memory, storage of duplicated key strings in

* JSONObjects will be avoided by using a key pool to manage unique key

* string objects. This is used by JSONObject.put(string, object).

*/

static HashMap<String, Object> keyPool = new HashMap<String, Object>(keyPoolSize);

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

// /**

// * JSONObject.NULL is equivalent to the value that JavaScript calls null,

// * whilst Java's null is equivalent to the value that JavaScript calls

// * undefined.

// */

// private static final class Null {

//

// /**

// * There is only intended to be a single instance of the NULL object,

// * so the clone method returns itself.

// * @return NULL.

// */

// @Override

// protected final Object clone() {

// return this;

// }

//

// /**

// * A Null object is equal to the null value and to itself.

// * @param object An object to test for nullness.

// * @return true if the object parameter is the JSONObject.NULL object

// * or null.

// */

// @Override

// public boolean equals(Object object) {

// return object == null || object == this;

// }

//

// /**

// * Get the "null" string value.

// * @return The string "null".

// */

// @Override

// public String toString() {

// return "null";

// }

//

// @Override

// public int hashCode() {

// // TODO Auto-generated method stub

// return super.hashCode();

// }

// }

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/**

* The map where the JSONObject's properties are kept.

*/

// private final Map map;

private final HashMap<String, Object> map;

// /**

// * It is sometimes more convenient and less ambiguous to have a

// * <code>NULL</code> object than to use Java's <code>null</code> value.

// * <code>JSONObject.NULL.equals(null)</code> returns <code>true</code>.

// * <code>JSONObject.NULL.toString()</code> returns <code>"null"</code>.

// */

// public static final Object NULL = new Null();

/**

* Construct an empty JSONObject.

*/

public JSONObject() {

this.map = new HashMap<String, Object>();

this.type = JSONType.OBJECT;

obj = this;

}

// /**

// * Construct a JSONObject from a subset of another JSONObject.

// * An array of strings is used to identify the keys that should be copied.

// * Missing keys are ignored.

// * @param jo A JSONObject.

// * @param names An array of strings.

// * @throws JSONException

// * @exception JSONException If a value is a non-finite number or if a name is duplicated.

// */

// public JSONObject(JSONObject jo, String[] names) {

// this();

// for (int i = 0; i < names.length; i += 1) {

// try {

// this.putOnce(names[i], jo.opt(names[i]));

// } catch (Exception ignore) {

// }

// }

// }

/**

* Construct a JSONObject from a JSONTokener.

* @param x A JSONTokener object containing the source string.

* @throws JSONException If there is a syntax error in the source string

* or a duplicated key.

*/

protected JSONObject(JSONTokener x) {

this();

char c;

String key;

if (x.nextClean() != '{') {

throw new RuntimeException("A JSONObject text must begin with '{'");

}

for (;;) {

c = x.nextClean();

switch (c) {

case 0:

throw new RuntimeException("A JSONObject text must end with '}'");

case '}':

return;

default:

x.back();

key = x.nextValue().toString();

}

// The key is followed by ':'. We will also tolerate '=' or '=>'.

c = x.nextClean();

if (c == '=') {

if (x.next() != '>') {

x.back();

}

} else if (c != ':') {

throw new RuntimeException("Expected a ':' after a key");

}

this.putOnce(key, x.nextValue());

// Pairs are separated by ','. We will also tolerate ';'.

switch (x.nextClean()) {

case ';':

case ',':

if (x.nextClean() == '}') {

return;

}

x.back();

break;

case '}':

return;

default:

throw new RuntimeException("Expected a ',' or '}'");

}

}

}

/**

* Construct a JSONObject from a Map.

*

* @param map A map object that can be used to initialize the contents of

* the JSONObject.

* @throws JSONException

*/

protected JSONObject(HashMap<String, Object> map) {

this.map = new HashMap<String, Object>();

if (map != null) {

Iterator i = map.entrySet().iterator();

while (i.hasNext()) {

Map.Entry e = (Map.Entry) i.next();

Object value = e.getValue();

if (value != null) {

map.put((String) e.getKey(), wrap(value));

}

}

}

}

/**

* Construct a JSONObject from an Object using bean getters.

* It reflects on all of the public methods of the object.

* For each of the methods with no parameters and a name starting

* with <code>"get"</code> or <code>"is"</code> followed by an uppercase letter,

* the method is invoked, and a key and the value returned from the getter method

* are put into the new JSONObject.

*

* The key is formed by removing the <code>"get"</code> or <code>"is"</code> prefix.

* If the second remaining character is not upper case, then the first

* character is converted to lower case.

*

* For example, if an object has a method named <code>"getName"</code>, and

* if the result of calling <code>object.getName()</code> is <code>"Larry Fine"</code>,

* then the JSONObject will contain <code>"name": "Larry Fine"</code>.

*

* @param bean An object that has getter methods that should be used

* to make a JSONObject.

*/

protected JSONObject(Object bean) {

this();

this.populateMap(bean);

}

// holding off on this method until we decide on how to handle reflection

// /**

// * Construct a JSONObject from an Object, using reflection to find the

// * public members. The resulting JSONObject's keys will be the strings

// * from the names array, and the values will be the field values associated

// * with those keys in the object. If a key is not found or not visible,

// * then it will not be copied into the new JSONObject.

// * @param object An object that has fields that should be used to make a

// * JSONObject.

// * @param names An array of strings, the names of the fields to be obtained

// * from the object.

// */

// public JSONObject(Object object, String names[]) {

// this();

// Class c = object.getClass();

// for (int i = 0; i < names.length; i += 1) {

// String name = names[i];

// try {

// this.putOpt(name, c.getField(name).get(object));

// } catch (Exception ignore) {

// }

// }

// }

/**

* Construct a JSONObject from a source JSON text string.

* This is the most commonly used JSONObject constructor.

* @param source A string beginning

* with <code>{</code>&nbsp;<small>(left brace)</small> and ending

* with <code>}</code>&nbsp;<small>(right brace)</small>.

* @exception JSONException If there is a syntax error in the source

* string or a duplicated key.

*/

static public JSONObject parse(String source) {

return new JSONObject(new JSONTokener(source));

}

// /**

// * Construct a JSONObject from a ResourceBundle.

// * @param baseName The ResourceBundle base name.

// * @param locale The Locale to load the ResourceBundle for.

// * @throws JSONException If any JSONExceptions are detected.

// */

// public JSON(String baseName, Locale locale) {

// this();

// ResourceBundle bundle = ResourceBundle.getBundle(baseName, locale,

// Thread.currentThread().getContextClassLoader());

//

// // Iterate through the keys in the bundle.

//

// Enumeration keys = bundle.getKeys();

// while (keys.hasMoreElements()) {

// Object key = keys.nextElement();

// if (key instanceof String) {

//

// // Go through the path, ensuring that there is a nested JSONObject for each

// // segment except the last. Add the value using the last segment's name into

// // the deepest nested JSONObject.

//

// String[] path = ((String)key).split("\\.");

// int last = path.length - 1;

// JSON target = this;

// for (int i = 0; i < last; i += 1) {

// String segment = path[i];

// JSON nextTarget = target.optJSONObject(segment);

// if (nextTarget == null) {

// nextTarget = new JSON();

// target.put(segment, nextTarget);

// }

// target = nextTarget;

// }

// target.put(path[last], bundle.getString((String)key));

// }

// }

// }

/**

* Accumulate values under a key. It is similar to the put method except

* that if there is already an object stored under the key then a

* JSONArray is stored under the key to hold all of the accumulated values.

* If there is already a JSONArray, then the new value is appended to it.

* In contrast, the put method replaces the previous value.

*

* If only one value is accumulated that is not a JSONArray, then the

* result will be the same as using put. But if multiple values are

* accumulated, then the result will be like append.

* @param key A key string.

* @param value An object to be accumulated under the key.

* @return this.

* @throws JSONException If the value is an invalid number

* or if the key is null.

*/

public JSON/*Object*/ accumulate( String key, Object value ) /*throws JSONException*/ {

testValidity(value);

Object object = this.opt(key);

if (object == null) {

this.put(key, value instanceof JSONArray ? new JSONArray().innerAppend/*put*/(value) : value);

} else if (object instanceof JSONArray) {

((JSONArray)object).innerAppend/*put*/(value);

} else {

this.put(key, new JSONArray().innerAppend/*put*/(object).innerAppend/*put*/(value));

}

return this;

}

// /**

// * Append values to the array under a key. If the key does not exist in the

// * JSONObject, then the key is put in the JSONObject with its value being a

// * JSONArray containing the value parameter. If the key was already

// * associated with a JSONArray, then the value parameter is appended to it.

// * @param key A key string.

// * @param value An object to be accumulated under the key.

// * @return this.

// * @throws JSONException If the key is null or if the current value

// * associated with the key is not a JSONArray.

// */

// public JSONObject append(String key, Object value) throws JSONException {

// testValidity(value);

// Object object = this.opt(key);

// if (object == null) {

// this.put(key, new JSONArray().put(value));

// } else if (object instanceof JSONArray) {

// this.put(key, ((JSONArray)object).put(value));

// } else {

// throw new JSONException("JSONObject[" + key +

// "] is not a JSONArray.");

// }

// return this;

// }

/**

* Produce a string from a double. The string "null" will be returned if

* the number is not finite.

* @param d A double.

* @return A String.

*/

static protected String doubleToString(double d) {

if (Double.isInfinite(d) || Double.isNaN(d)) {

return "null";

}

// Shave off trailing zeros and decimal point, if possible.

String string = Double.toString(d);

if (string.indexOf('.') > 0 && string.indexOf('e') < 0 &&

string.indexOf('E') < 0) {

while (string.endsWith("0")) {

string = string.substring(0, string.length() - 1);

}

if (string.endsWith(".")) {

string = string.substring(0, string.length() - 1);

}

}

return string;

}

/**

* Get the value object associated with a key.

*

* @param key A key string.