/**

private static final class Null {

/**

@Override

@SuppressWarnings("lgtm[java/unchecked-cast-in-equals]")

public boolean equals(Object object) {

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

}

/**

@Override

public int hashCode() {

return 0;

}

/**

@Override

public String toString() {

return "null";

}

}

/**

static final Pattern NUMBER_PATTERN = Pattern.compile("-?(?:0|[1-9]\\d*)(?:\\.\\d+)?(?:[eE][+-]?\\d+)?");

/**

private final Map<String, Object> map;

/**

public Class<? extends Map> getMapType() {

return map.getClass();

}

/**

public static final Object NULL = new Null();

/**

private static final Set<String> EXCLUDED_RECORD_METHOD_NAMES = Collections.unmodifiableSet(

new HashSet<String>(Arrays.asList(

"get", "is", "set",

"toString", "hashCode", "equals", "clone",

"notify", "notifyAll", "wait"

))

);

/**

public JSONObject() {

// HashMap is used on purpose to ensure that elements are unordered by

// the specification.

// JSON tends to be a portable transfer format to allows the container

// implementations to rearrange their items for a faster element

// retrieval based on associative access.

// Therefore, an implementation mustn't rely on the order of the item.

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

}

/**

public JSONObject(JSONObject jo, String ... names) {

this(names.length);

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

try {

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

} catch (Exception ignore) { // exception thrown for missing key

}

}

}

/**

public JSONObject(JSONTokener x) throws JSONException {

this(x, x.getJsonParserConfiguration());

}

/**

public JSONObject(JSONTokener x, JSONParserConfiguration jsonParserConfiguration) throws JSONException {

this();

boolean isInitial = x.getPrevious() == 0;

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

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

}

for (;;) {

if (parseJSONObject(x, jsonParserConfiguration, isInitial)) {

return;

}

}

}

/**

private boolean parseJSONObject(JSONTokener jsonTokener, JSONParserConfiguration jsonParserConfiguration, boolean isInitial) {

Object obj;

String key;

boolean doneParsing = false;

char c = jsonTokener.nextClean();

switch (c) {

case 0:

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

case '}':

if (isInitial && jsonParserConfiguration.isStrictMode() && jsonTokener.nextClean() != 0) {

throw jsonTokener.syntaxError("Strict mode error: Unparsed characters found at end of input text");

}

return true;

default:

obj = jsonTokener.nextSimpleValue(c);

key = obj.toString();

}

checkKeyForStrictMode(jsonTokener, jsonParserConfiguration, obj);

// The key is followed by ':'.

c = jsonTokener.nextClean();

if (c != ':') {

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

}

// Use syntaxError(..) to include error location

if (key != null) {

// Check if key exists

boolean keyExists = this.opt(key) != null;

if (keyExists && !jsonParserConfiguration.isOverwriteDuplicateKey()) {

throw jsonTokener.syntaxError("Duplicate key \"" + key + "\"");

}

Object value = jsonTokener.nextValue();

// Only add value if non-null

if (value != null) {

this.put(key, value);

}

}

// Pairs are separated by ','.

if (parseEndOfKeyValuePair(jsonTokener, jsonParserConfiguration, isInitial)) {

doneParsing = true;

}

return doneParsing;

}

/**

private static boolean parseEndOfKeyValuePair(JSONTokener jsonTokener, JSONParserConfiguration jsonParserConfiguration, boolean isInitial) {

switch (jsonTokener.nextClean()) {

case ';':

// In strict mode semicolon is not a valid separator

if (jsonParserConfiguration.isStrictMode()) {

throw jsonTokener.syntaxError("Strict mode error: Invalid character ';' found");

}

break;

case ',':

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

// trailing commas are not allowed in strict mode

if (jsonParserConfiguration.isStrictMode()) {

throw jsonTokener.syntaxError("Strict mode error: Expected another object element");

}

// End of JSON object

return true;

}

if (jsonTokener.end()) {

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

}

jsonTokener.back();

break;

case '}':

if (isInitial && jsonParserConfiguration.isStrictMode() && jsonTokener.nextClean() != 0) {

throw jsonTokener.syntaxError("Strict mode error: Unparsed characters found at end of input text");

}

// End of JSON object

return true;

default:

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

}

// Not at end of JSON object

return false;

}

/**

private static void checkKeyForStrictMode(JSONTokener jsonTokener, JSONParserConfiguration jsonParserConfiguration, Object obj) {

if (jsonParserConfiguration != null && jsonParserConfiguration.isStrictMode()) {

if(obj instanceof Boolean) {

throw jsonTokener.syntaxError(String.format("Strict mode error: key '%s' cannot be boolean", obj.toString()));

}

if(obj == JSONObject.NULL) {

throw jsonTokener.syntaxError(String.format("Strict mode error: key '%s' cannot be null", obj.toString()));

}

if(obj instanceof Number) {

throw jsonTokener.syntaxError(String.format("Strict mode error: key '%s' cannot be number", obj.toString()));

}

}

}

/**

public JSONObject(Map<?, ?> m) {

this(m, 0, new JSONParserConfiguration());

}

/**

public JSONObject(Map<?, ?> m, JSONParserConfiguration jsonParserConfiguration) {

this(m, 0, jsonParserConfiguration);

}

/**

private JSONObject(Map<?, ?> m, int recursionDepth, JSONParserConfiguration jsonParserConfiguration) {

if (recursionDepth > jsonParserConfiguration.getMaxNestingDepth()) {

throw new JSONException("JSONObject has reached recursion depth limit of " + jsonParserConfiguration.getMaxNestingDepth());

}

if (m == null) {

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

} else {

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

for (final Entry<?, ?> e : m.entrySet()) {

if(e.getKey() == null) {

throw new NullPointerException("Null key.");

}

final Object value = e.getValue();

if (value != null || jsonParserConfiguration.isUseNativeNulls()) {

testValidity(value);

this.map.put(String.valueOf(e.getKey()), wrap(value, recursionDepth + 1, jsonParserConfiguration));

}

}

}

}

/**

public JSONObject(Object bean) {

this();

this.populateMap(bean, new JSONParserConfiguration());

}

public JSONObject(Object bean, JSONParserConfiguration jsonParserConfiguration) {

this();

this.populateMap(bean, jsonParserConfiguration);

}

private JSONObject(Object bean, Set<Object> objectsRecord) {

this();

this.populateMap(bean, objectsRecord, new JSONParserConfiguration());

}

/**

public JSONObject(Object object, String ... names) {

this(names.length);

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

// if invalid, do not include key:value pair in JSONObject

}

}

}

/**

public JSONObject(String source) throws JSONException {

this(source, new JSONParserConfiguration());

}

/**

public JSONObject(String source, JSONParserConfiguration jsonParserConfiguration) throws JSONException {

this(new JSONTokener(source, jsonParserConfiguration), jsonParserConfiguration);

}

/**

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

this();

ResourceBundle bundle = ResourceBundle.getBundle(baseName, locale,

Thread.currentThread().getContextClassLoader());

Enumeration<String> keys = bundle.getKeys();

while (keys.hasMoreElements()) {

Object key = keys.nextElement();

if (key != null) {

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

}

}

}

/**

protected JSONObject(int initialCapacity){

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

}

/**

public JSONObject 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().put(value)

: value);

} else if (object instanceof JSONArray) {

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

} else {

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

}

return this;

}

/**

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 wrongValueFormatException(key, "JSONArray", null, null);

}

return this;

}

/**

public static 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);

// idx = 0 case is covered by behavior of Double.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 get(String key) throws JSONException {

if (key == null) {

throw new JSONException("Null key.");

}

Object object = this.opt(key);

if (object == null) {

throw new JSONException("JSONObject[" + quote(key) + "] not found.");

}

return object;

}

/**

public <E extends Enum<E>> E getEnum(Class<E> clazz, String key) throws JSONException {

E val = optEnum(clazz, key);

if(val==null) {

// JSONException should really take a throwable argument.

// If it did, I would re-implement this with the Enum.valueOf

// method and place any thrown exception in the JSONException

throw wrongValueFormatException(key, "enum of type " + quote(clazz.getSimpleName()), opt(key), null);

}

return val;

}

/**

public boolean getBoolean(String key) throws JSONException {

Object object = this.get(key);

if (Boolean.FALSE.equals(object)

|| (object instanceof String && "false".equalsIgnoreCase((String) object))) {

return false;

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

|| (object instanceof String && "true".equalsIgnoreCase((String) object))) {

return true;

}

throw wrongValueFormatException(key, "Boolean", object, null);

}

/**

public BigInteger getBigInteger(String key) throws JSONException {

Object object = this.get(key);

BigInteger ret = objectToBigInteger(object, null);

if (ret != null) {

return ret;

}

throw wrongValueFormatException(key, "BigInteger", object, null);

}

/**

public BigDecimal getBigDecimal(String key) throws JSONException {

Object object = this.get(key);

BigDecimal ret = objectToBigDecimal(object, null);

if (ret != null) {

return ret;

}

throw wrongValueFormatException(key, "BigDecimal", object, null);

}

/**

public double getDouble(String key) throws JSONException {

final Object object = this.get(key);

if(object instanceof Number) {

return ((Number)object).doubleValue();

}

try {

return Double.parseDouble(object.toString());

} catch (Exception e) {

throw wrongValueFormatException(key, "double", object, e);

}

}

/**

public float getFloat(String key) throws JSONException {

final Object object = this.get(key);

if(object instanceof Number) {

return ((Number)object).floatValue();

}

try {

return Float.parseFloat(object.toString());

} catch (Exception e) {

throw wrongValueFormatException(key, "float", object, e);

}

}

/**

public Number getNumber(String key) throws JSONException {

Object object = this.get(key);

try {

if (object instanceof Number) {

return (Number)object;

}

return stringToNumber(object.toString());

} catch (Exception e) {

throw wrongValueFormatException(key, "number", object, e);

}

}

/**

public int getInt(String key) throws JSONException {

final Object object = this.get(key);

if(object instanceof Number) {

return ((Number)object).intValue();

}

try {

return Integer.parseInt(object.toString());

} catch (Exception e) {

throw wrongValueFormatException(key, "int", object, e);

}

}

/**

public JSONArray getJSONArray(String key) throws JSONException {

Object object = this.get(key);

if (object instanceof JSONArray) {

return (JSONArray) object;

}

throw wrongValueFormatException(key, "JSONArray", object, null);

}

/**

public JSONObject getJSONObject(String key) throws JSONException {

Object object = this.get(key);

if (object instanceof JSONObject) {

return (JSONObject) object;

}

throw wrongValueFormatException(key, "JSONObject", object, null);

}

/**

public long getLong(String key) throws JSONException {

final Object object = this.get(key);

if(object instanceof Number) {

return ((Number)object).longValue();

}

try {

return Long.parseLong(object.toString());

} catch (Exception e) {

throw wrongValueFormatException(key, "long", object, e);

}

}

/**

public static String[] getNames(JSONObject jo) {

if (jo.isEmpty()) {

return null;

}

return jo.keySet().toArray(new String[jo.length()]);

}

/**

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 = this.get(key);

if (object instanceof String) {

return (String) object;

}

throw wrongValueFormatException(key, "string", object, null);

}

/**

public boolean has(String key) {

return this.map.containsKey(key);