package org.json;

import java.io.IOException;

import java.io.Writer;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.lang.reflect.Method;

import java.util.Collection;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Locale;

import java.util.Map;

import java.util.ResourceBundle;

public class JSONObject {

/**

private static final class Null {

/**

protected final Object clone() {

return this;

}

/**

public boolean equals(Object object) {

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

}

/**

public String toString() {

return "null";

}

}

/**

private Map map;

/**

public static final Object NULL = new Null();

/**

public JSONObject() {

this.map = new HashMap();

}

/**

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

this();

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

try {

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

} catch (Exception ignore) {

}

}

}

/**

public JSONObject(JSONTokener x) throws JSONException {

this();

char c;

String key;

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

throw x.syntaxError("A JSONObject text must begin with '{'");

}

for (;;) {

c = x.nextClean();

switch (c) {

case 0:

throw x.syntaxError("A JSONObject text must end with '}'");

case '}':

return;

default:

x.back();

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

}

c = x.nextClean();

if (c == '=') {

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

x.back();

}

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

throw x.syntaxError("Expected a ':' after a key");

}

putOnce(key, x.nextValue());

switch (x.nextClean()) {

case ';':

case ',':

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

return;

}

x.back();

break;

case '}':

return;

default:

throw x.syntaxError("Expected a ',' or '}'");

}

}

}

/**

public JSONObject(Map map) {

this.map = new HashMap();

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) {

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

}

}

}

}

/**

public JSONObject(Object bean) {

this();

populateMap(bean);

}

/**

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 {

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

} catch (Exception ignore) {

}

}

}

/**

public JSONObject(String source) throws JSONException {

this(new JSONTokener(source));

}

/**

public JSONObject(String baseName, Locale locale) throws JSONException {

this();

ResourceBundle bundle = ResourceBundle.getBundle(baseName, locale,

Thread.currentThread().getContextClassLoader());

Enumeration keys = bundle.getKeys();

while (keys.hasMoreElements()) {

Object key = keys.nextElement();

if (key instanceof String) {

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

int last = path.length - 1;

JSONObject target = this;

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

String segment = path[i];

JSONObject nextTarget = target.optJSONObject(segment);

if (nextTarget == null) {

nextTarget = new JSONObject();

target.put(segment, nextTarget);

}

target = nextTarget;

}

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

}

}

}

/**

public JSONObject accumulate(

String key,

Object value

) throws JSONException {

testValidity(value);

Object object = opt(key);

if (object == null) {

put(key, value instanceof JSONArray ?

new JSONArray().put(value) : value);

} else if (object instanceof JSONArray) {

((JSONArray)object).put(value);

} else {

put(key, new JSONArray().put(object).put(value));

}

return this;

}

/**

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

testValidity(value);

Object object = opt(key);

if (object == null) {

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

} else if (object instanceof JSONArray) {

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

} else {

throw new JSONException("JSONObject[" + key +

"] is not a JSONArray.");

}

return this;

}

/**

public static String doubleToString(double d) {

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

return "null";

}

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;

}

/**

public Object get(String key) throws JSONException {

if (key == null) {

throw new JSONException("Null key.");

}

Object object = opt(key);

if (object == null) {

throw new JSONException("JSONObject[" + quote(key) +

"] not found.");

}

return object;

}

/**

public boolean getBoolean(String key) throws JSONException {

Object object = get(key);

if (object.equals(Boolean.FALSE) ||

(object instanceof String &&

((String)object).equalsIgnoreCase("false"))) {

return false;

} else if (object.equals(Boolean.TRUE) ||

(object instanceof String &&

((String)object).equalsIgnoreCase("true"))) {

return true;

}

throw new JSONException("JSONObject[" + quote(key) +

"] is not a Boolean.");

}

/**

public double getDouble(String key) throws JSONException {

Object object = get(key);

try {

return object instanceof Number ?

((Number)object).doubleValue() :

Double.parseDouble((String)object);

} catch (Exception e) {

throw new JSONException("JSONObject[" + quote(key) +

"] is not a number.");

}

}

/**

public int getInt(String key) throws JSONException {

Object object = get(key);

try {

return object instanceof Number ?

((Number)object).intValue() :

Integer.parseInt((String)object);

} catch (Exception e) {

throw new JSONException("JSONObject[" + quote(key) +

"] is not an int.");

}

}

/**

public JSONArray getJSONArray(String key) throws JSONException {

Object object = get(key);

if (object instanceof JSONArray) {

return (JSONArray)object;

}

throw new JSONException("JSONObject[" + quote(key) +

"] is not a JSONArray.");

}

/**

public JSONObject getJSONObject(String key) throws JSONException {

Object object = get(key);

if (object instanceof JSONObject) {

return (JSONObject)object;

}

throw new JSONException("JSONObject[" + quote(key) +

"] is not a JSONObject.");

}

/**

public long getLong(String key) throws JSONException {

Object object = get(key);

try {

return object instanceof Number ?

((Number)object).longValue() :

Long.parseLong((String)object);

} catch (Exception e) {

throw new JSONException("JSONObject[" + quote(key) +

"] is not a long.");

}

}

/**

public static String[] getNames(JSONObject jo) {

int length = jo.length();

if (length == 0) {

return null;

}

Iterator iterator = jo.keys();

String[] names = new String[length];

int i = 0;

while (iterator.hasNext()) {

names[i] = (String)iterator.next();

i += 1;

}

return names;

}

/**

public static String[] getNames(Object object) {

if (object == null) {

return null;

}

Class klass = object.getClass();

Field[] fields = klass.getFields();

int length = fields.length;

if (length == 0) {

return null;

}

String[] names = new String[length];

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

names[i] = fields[i].getName();

}

return names;

}

/**

public String getString(String key) throws JSONException {

Object object = get(key);

if (object instanceof String) {

return (String)object;

}

throw new JSONException("JSONObject[" + quote(key) +

"] not a string.");

}

/**

public boolean has(String key) {

return this.map.containsKey(key);

}

/**

public JSONObject increment(String key) throws JSONException {

Object value = opt(key);

if (value == null) {

put(key, 1);

} else if (value instanceof Integer) {

put(key, ((Integer)value).intValue() + 1);

} else if (value instanceof Long) {

put(key, ((Long)value).longValue() + 1);

} else if (value instanceof Double) {

put(key, ((Double)value).doubleValue() + 1);

} else if (value instanceof Float) {

put(key, ((Float)value).floatValue() + 1);

} else {

throw new JSONException("Unable to increment [" + quote(key) + "].");

}

return this;

}

/**

public boolean isNull(String key) {

return JSONObject.NULL.equals(opt(key));

}

/**

public Iterator keys() {

return this.map.keySet().iterator();

}

/**

public int length() {

return this.map.size();

}

/**

public JSONArray names() {

JSONArray ja = new JSONArray();

Iterator keys = this.keys();

while (keys.hasNext()) {

ja.put(keys.next());

}

return ja.length() == 0 ? null : ja;

}

/**

public static String numberToString(Number number)

throws JSONException {

if (number == null) {

throw new JSONException("Null pointer");

}

testValidity(number);

String string = number.toString();

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;

}

/**

public Object opt(String key) {

return key == null ? null : this.map.get(key);

}

/**

public boolean optBoolean(String key) {

return optBoolean(key, false);

}

/**

public boolean optBoolean(String key, boolean defaultValue) {

try {

return getBoolean(key);

} catch (Exception e) {

return defaultValue;

}

}

/**

public double optDouble(String key) {

return optDouble(key, Double.NaN);

}

/**

public double optDouble(String key, double defaultValue) {

try {

return getDouble(key);

} catch (Exception e) {

return defaultValue;

}

}

/**

public int optInt(String key) {

return optInt(key, 0);

}

/**

public int optInt(String key, int defaultValue) {

try {

return getInt(key);

} catch (Exception e) {

return defaultValue;

}

}

/**

public JSONArray optJSONArray(String key) {

Object o = opt(key);

return o instanceof JSONArray ? (JSONArray)o : null;

}

/**

public JSONObject optJSONObject(String key) {

Object object = opt(key);

return object instanceof JSONObject ? (JSONObject)object : null;

}

/**

public long optLong(String key) {

return optLong(key, 0);

}

/**

public long optLong(String key, long defaultValue) {

try {

return getLong(key);

} catch (Exception e) {

return defaultValue;

}

}

/**

public String optString(String key) {

return optString(key, "");

}

/**

public String optString(String key, String defaultValue) {

Object object = opt(key);

return NULL.equals(object) ? defaultValue : object.toString();

}

private void populateMap(Object bean) {

Class klass = bean.getClass();

boolean includeSuperClass = klass.getClassLoader() != null;

Method[] methods = (includeSuperClass) ?

klass.getMethods() : klass.getDeclaredMethods();

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

try {

Method method = methods[i];

if (Modifier.isPublic(method.getModifiers())) {

String name = method.getName();

String key = "";

if (name.startsWith("get")) {

if (name.equals("getClass") ||

name.equals("getDeclaringClass")) {

key = "";

} else {

key = name.substring(3);

}

} else if (name.startsWith("is")) {

key = name.substring(2);

}

if (key.length() > 0 &&

Character.isUpperCase(key.charAt(0)) &&

method.getParameterTypes().length == 0) {

if (key.length() == 1) {

key = key.toLowerCase();

} else if (!Character.isUpperCase(key.charAt(1))) {

key = key.substring(0, 1).toLowerCase() +

key.substring(1);

}

Object result = method.invoke(bean, (Object[])null);

if (result != null) {

map.put(key, wrap(result));

}

}

}

} catch (Exception ignore) {

}

}

}

/**