/** The Character '&'. */

public static final Character AMP = '&';

/** The Character '''. */

public static final Character APOS = '\'';

/** The Character '!'. */

public static final Character BANG = '!';

/** The Character '='. */

public static final Character EQ = '=';

/** The Character <pre>{@code '>'. }</pre>*/

public static final Character GT = '>';

/** The Character '&lt;'. */

public static final Character LT = '<';

/** The Character '?'. */

public static final Character QUEST = '?';

/** The Character '"'. */

public static final Character QUOT = '"';

/** The Character '/'. */

public static final Character SLASH = '/';

/**

public static final String NULL_ATTR = "xsi:nil";

public static final String TYPE_ATTR = "xsi:type";

/**

private static Iterable<Integer> codePointIterator(final String string) {

return new Iterable<Integer>() {

@Override

public Iterator<Integer> iterator() {

return new Iterator<Integer>() {

private int nextIndex = 0;

private int length = string.length();

@Override

public boolean hasNext() {

return this.nextIndex < this.length;

}

@Override

public Integer next() {

int result = string.codePointAt(this.nextIndex);

this.nextIndex += Character.charCount(result);

return result;

}

@Override

public void remove() {

throw new UnsupportedOperationException();

}

};

}

};

}

/**

public static String escape(String string) {

StringBuilder sb = new StringBuilder(string.length());

for (final int cp : codePointIterator(string)) {

switch (cp) {

case '&':

sb.append("&amp;");

break;

case '<':

sb.append("&lt;");

break;

case '>':

sb.append("&gt;");

break;

case '"':

sb.append("&quot;");

break;

case '\'':

sb.append("&apos;");

break;

default:

if (mustEscape(cp)) {

sb.append("&#x");

sb.append(Integer.toHexString(cp));

sb.append(';');

} else {

sb.appendCodePoint(cp);

}

}

}

return sb.toString();

}

/**

private static boolean mustEscape(int cp) {

/* Valid range from https://www.w3.org/TR/REC-xml/#charsets

// isISOControl is true when (cp >= 0 && cp <= 0x1F) || (cp >= 0x7F && cp <= 0x9F)

// all ISO control characters are out of range except tabs and new lines

return (Character.isISOControl(cp)

&& cp != 0x9

&& cp != 0xA

&& cp != 0xD

) || !(

// valid the range of acceptable characters that aren't control

(cp >= 0x20 && cp <= 0xD7FF)

|| (cp >= 0xE000 && cp <= 0xFFFD)

|| (cp >= 0x10000 && cp <= 0x10FFFF)

)

;

}

/**

public static String unescape(String string) {

StringBuilder sb = new StringBuilder(string.length());

for (int i = 0, length = string.length(); i < length; i++) {

char c = string.charAt(i);

if (c == '&') {

final int semic = string.indexOf(';', i);

if (semic > i) {

final String entity = string.substring(i + 1, semic);

sb.append(XMLTokener.unescapeEntity(entity));

// skip past the entity we just parsed.

i += entity.length() + 1;

} else {

// this shouldn't happen in most cases since the parser

// errors on unclosed entries.

sb.append(c);

}

} else {

// not part of an entity

sb.append(c);

}

}

return sb.toString();

}

/**

public static void noSpace(String string) throws JSONException {

int i, length = string.length();

if (length == 0) {

throw new JSONException("Empty string.");

}

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

if (Character.isWhitespace(string.charAt(i))) {

throw new JSONException("'" + string

+ "' contains a space character.");

}

}

}

/**

private static boolean parse(XMLTokener x, JSONObject context, String name, XMLParserConfiguration config)

throws JSONException {

char c;

int i;

JSONObject jsonObject = null;

String string;

String tagName;

Object token;

XMLXsiTypeConverter<?> xmlXsiTypeConverter;

// Test for and skip past these forms:

// <!-- ... -->

// <! ... >

// <![ ... ]]>

// <? ... ?>

// Report errors for these forms:

// <>

// <=

// <<

token = x.nextToken();

// <!

if (token == BANG) {

c = x.next();

if (c == '-') {

if (x.next() == '-') {

x.skipPast("-->");

return false;

}

x.back();

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

token = x.nextToken();

if ("CDATA".equals(token)) {

if (x.next() == '[') {

string = x.nextCDATA();

if (string.length() > 0) {

context.accumulate(config.getcDataTagName(), string);

}

return false;

}

}

throw x.syntaxError("Expected 'CDATA['");

}

i = 1;

do {

token = x.nextMeta();

if (token == null) {

throw x.syntaxError("Missing '>' after '<!'.");

} else if (token == LT) {

i += 1;

} else if (token == GT) {

i -= 1;

}

} while (i > 0);

return false;

} else if (token == QUEST) {

// <?

x.skipPast("?>");

return false;

} else if (token == SLASH) {

// Close tag </

token = x.nextToken();

if (name == null) {

throw x.syntaxError("Mismatched close tag " + token);

}

if (!token.equals(name)) {

throw x.syntaxError("Mismatched " + name + " and " + token);

}

if (x.nextToken() != GT) {

throw x.syntaxError("Misshaped close tag");

}

return true;

} else if (token instanceof Character) {

throw x.syntaxError("Misshaped tag");

// Open tag <

} else {

tagName = (String) token;

token = null;

jsonObject = new JSONObject();

boolean nilAttributeFound = false;

xmlXsiTypeConverter = null;

for (;;) {

if (token == null) {

token = x.nextToken();

}

// attribute = value

if (token instanceof String) {

string = (String) token;

token = x.nextToken();

if (token == EQ) {

token = x.nextToken();

if (!(token instanceof String)) {

throw x.syntaxError("Missing value");

}

if (config.isConvertNilAttributeToNull()

&& NULL_ATTR.equals(string)

&& Boolean.parseBoolean((String) token)) {

nilAttributeFound = true;

} else if(config.getXsiTypeMap() != null && !config.getXsiTypeMap().isEmpty()

&& TYPE_ATTR.equals(string)) {

xmlXsiTypeConverter = config.getXsiTypeMap().get(token);

} else if (!nilAttributeFound) {

jsonObject.accumulate(string,

config.isKeepStrings()

? ((String) token)

: stringToValue((String) token));

}

token = null;

} else {

jsonObject.accumulate(string, "");

}

} else if (token == SLASH) {

// Empty tag <.../>

if (x.nextToken() != GT) {

throw x.syntaxError("Misshaped tag");

}

if (config.getForceList().contains(tagName)) {

// Force the value to be an array

if (nilAttributeFound) {

context.append(tagName, JSONObject.NULL);

} else if (jsonObject.length() > 0) {

context.append(tagName, jsonObject);

} else {

context.put(tagName, new JSONArray());

}

} else {

if (nilAttributeFound) {

context.accumulate(tagName, JSONObject.NULL);

} else if (jsonObject.length() > 0) {

context.accumulate(tagName, jsonObject);

} else {

context.accumulate(tagName, "");

}

}

return false;

} else if (token == GT) {

// Content, between <...> and </...>

for (;;) {

token = x.nextContent();

if (token == null) {

if (tagName != null) {

throw x.syntaxError("Unclosed tag " + tagName);

}

return false;

} else if (token instanceof String) {

string = (String) token;

if (string.length() > 0) {

if(xmlXsiTypeConverter != null) {

jsonObject.accumulate(config.getcDataTagName(),

stringToValue(string, xmlXsiTypeConverter));

} else {

jsonObject.accumulate(config.getcDataTagName(),

config.isKeepStrings() ? string : stringToValue(string));

}

}

} else if (token == LT) {

// Nested element

if (parse(x, jsonObject, tagName, config)) {

if (config.getForceList().contains(tagName)) {

// Force the value to be an array

if (jsonObject.length() == 0) {

context.put(tagName, new JSONArray());

} else if (jsonObject.length() == 1

&& jsonObject.opt(config.getcDataTagName()) != null) {

context.append(tagName, jsonObject.opt(config.getcDataTagName()));

} else {

context.append(tagName, jsonObject);

}

} else {

if (jsonObject.length() == 0) {

context.accumulate(tagName, "");

} else if (jsonObject.length() == 1

&& jsonObject.opt(config.getcDataTagName()) != null) {

context.accumulate(tagName, jsonObject.opt(config.getcDataTagName()));

} else {

context.accumulate(tagName, jsonObject);

}

}

return false;

}

}

}

} else {

throw x.syntaxError("Misshaped tag");

}

}

}

}

/**

public static Object stringToValue(String string, XMLXsiTypeConverter<?> typeConverter) {

if(typeConverter != null) {

return typeConverter.convert(string);

}

return stringToValue(string);

}

/**

// To maintain compatibility with the Android API, this method is a direct copy of

// the one in JSONObject. Changes made here should be reflected there.

// This method should not make calls out of the XML object.

public static Object stringToValue(String string) {

if ("".equals(string)) {

return string;

}

// check JSON key words true/false/null

if ("true".equalsIgnoreCase(string)) {

return Boolean.TRUE;

}

if ("false".equalsIgnoreCase(string)) {

return Boolean.FALSE;

}

if ("null".equalsIgnoreCase(string)) {

return JSONObject.NULL;

}

/*

char initial = string.charAt(0);

if ((initial >= '0' && initial <= '9') || initial == '-') {

try {

return stringToNumber(string);

} catch (Exception ignore) {

}

}

return string;

}

/**

private static Number stringToNumber(final String val) throws NumberFormatException {

char initial = val.charAt(0);

if ((initial >= '0' && initial <= '9') || initial == '-') {

// decimal representation

if (isDecimalNotation(val)) {

// Use a BigDecimal all the time so we keep the original

// representation. BigDecimal doesn't support -0.0, ensure we

// keep that by forcing a decimal.

try {

BigDecimal bd = new BigDecimal(val);

if(initial == '-' && BigDecimal.ZERO.compareTo(bd)==0) {

return Double.valueOf(-0.0);

}

return bd;

} catch (NumberFormatException retryAsDouble) {

// this is to support "Hex Floats" like this: 0x1.0P-1074

try {

Double d = Double.valueOf(val);

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

throw new NumberFormatException("val ["+val+"] is not a valid number.");

}

return d;

} catch (NumberFormatException ignore) {

throw new NumberFormatException("val ["+val+"] is not a valid number.");

}

}

}

// block items like 00 01 etc. Java number parsers treat these as Octal.

if(initial == '0' && val.length() > 1) {

char at1 = val.charAt(1);

if(at1 >= '0' && at1 <= '9') {

throw new NumberFormatException("val ["+val+"] is not a valid number.");

}

} else if (initial == '-' && val.length() > 2) {

char at1 = val.charAt(1);

char at2 = val.charAt(2);

if(at1 == '0' && at2 >= '0' && at2 <= '9') {

throw new NumberFormatException("val ["+val+"] is not a valid number.");

}

}

// integer representation.

// This will narrow any values to the smallest reasonable Object representation

// (Integer, Long, or BigInteger)

// BigInteger down conversion: We use a similar bitLength compare as

// BigInteger#intValueExact uses. Increases GC, but objects hold

// only what they need. i.e. Less runtime overhead if the value is

// long lived.

BigInteger bi = new BigInteger(val);

if(bi.bitLength() <= 31){

return Integer.valueOf(bi.intValue());

}

if(bi.bitLength() <= 63){

return Long.valueOf(bi.longValue());

}

return bi;

}

throw new NumberFormatException("val ["+val+"] is not a valid number.");

}

/**

private static boolean isDecimalNotation(final String val) {

return val.indexOf('.') > -1 || val.indexOf('e') > -1

|| val.indexOf('E') > -1 || "-0".equals(val);

}

/**

public static JSONObject toJSONObject(String string) throws JSONException {

return toJSONObject(string, XMLParserConfiguration.ORIGINAL);

}

/**

public static JSONObject toJSONObject(Reader reader) throws JSONException {

return toJSONObject(reader, XMLParserConfiguration.ORIGINAL);

}

/**

public static JSONObject toJSONObject(Reader reader, boolean keepStrings) throws JSONException {

if(keepStrings) {

return toJSONObject(reader, XMLParserConfiguration.KEEP_STRINGS);

}

return toJSONObject(reader, XMLParserConfiguration.ORIGINAL);

}

/**

public static JSONObject toJSONObject(Reader reader, XMLParserConfiguration config) throws JSONException {

JSONObject jo = new JSONObject();

XMLTokener x = new XMLTokener(reader);

while (x.more()) {

x.skipPast("<");

if(x.more()) {

parse(x, jo, null, config);

}

}

return jo;

}

/**

public static JSONObject toJSONObject(String string, boolean keepStrings) throws JSONException {

return toJSONObject(new StringReader(string), keepStrings);

}

/**

public static JSONObject toJSONObject(String string, XMLParserConfiguration config) throws JSONException {

return toJSONObject(new StringReader(string), config);

}

/**

public static String toString(Object object) throws JSONException {

return toString(object, null, XMLParserConfiguration.ORIGINAL);

}

/**

public static String toString(final Object object, final String tagName) {

return toString(object, tagName, XMLParserConfiguration.ORIGINAL);

}

/**

public static String toString(final Object object, final String tagName, final XMLParserConfiguration config)

throws JSONException {

StringBuilder sb = new StringBuilder();

JSONArray ja;

JSONObject jo;

String string;

if (object instanceof JSONObject) {

// Emit <tagName>

if (tagName != null) {

sb.append('<');

sb.append(tagName);

sb.append('>');

}

// Loop thru the keys.

// don't use the new entrySet accessor to maintain Android Support

jo = (JSONObject) object;

for (final String key : jo.keySet()) {

Object value = jo.opt(key);

if (value == null) {

value = "";

} else if (value.getClass().isArray()) {

value = new JSONArray(value);

}

// Emit content in body

if (key.equals(config.getcDataTagName())) {

if (value instanceof JSONArray) {

ja = (JSONArray) value;

int jaLength = ja.length();

// don't use the new iterator API to maintain support for Android

for (int i = 0; i < jaLength; i++) {

if (i > 0) {

sb.append('\n');

}

Object val = ja.opt(i);

sb.append(escape(val.toString()));

}

} else {

sb.append(escape(value.toString()));

}

// Emit an array of similar keys

} else if (value instanceof JSONArray) {

ja = (JSONArray) value;

int jaLength = ja.length();

// don't use the new iterator API to maintain support for Android

for (int i = 0; i < jaLength; i++) {

Object val = ja.opt(i);

if (val instanceof JSONArray) {

sb.append('<');

sb.append(key);

sb.append('>');

sb.append(toString(val, null, config));

sb.append("</");

sb.append(key);

sb.append('>');

} else {

sb.append(toString(val, key, config));

}

}

} else if ("".equals(value)) {

sb.append('<');

sb.append(key);

sb.append("/>");

// Emit a new tag <k>

} else {

sb.append(toString(value, key, config));

}

}

if (tagName != null) {

// Emit the </tagName> close tag

sb.append("</");

sb.append(tagName);

sb.append('>');

}

return sb.toString();

}

if (object != null && (object instanceof JSONArray || object.getClass().isArray())) {

if(object.getClass().isArray()) {

ja = new JSONArray(object);

} else {

ja = (JSONArray) object;

}

int jaLength = ja.length();

// don't use the new iterator API to maintain support for Android

for (int i = 0; i < jaLength; i++) {

Object val = ja.opt(i);

// XML does not have good support for arrays. If an array

// appears in a place where XML is lacking, synthesize an

// <array> element.

sb.append(toString(val, tagName == null ? "array" : tagName, config));

}

return sb.toString();

}

string = (object == null) ? "null" : escape(object.toString());

return (tagName == null) ? "\"" + string + "\""

: (string.length() == 0) ? "<" + tagName + "/>" : "<" + tagName

+ ">" + string + "</" + tagName + ">";

}