/**

public XML() {

}

/** 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 final int length = string.length();

@Override

public boolean hasNext() {

return this.nextIndex < this.length;

}

@Override

public Integer next() {

if (!hasNext()) {

throw new NoSuchElementException();

}

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

}

/**

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 character range per W3C XML 1.0 spec:

// #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]

// Previously omitted #x9/#xA/#xD, causing unescape("&#10;") etc.

// to reject valid LF/TAB/CR as illegal (see #1059)

cp == 0x9

|| cp == 0xA

|| cp == 0xD

|| (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.");

}

}

}

/**

static void noXmlMetachars(String string) throws JSONException {

int length = string.length();

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

char c = string.charAt(i);

if (c == '<' || c == '>' || c == '&'

|| c == '"' || c == '\'' || c == '/') {

throw new JSONException("'" + string

+ "' contains an XML metacharacter and may not be used as an element name.");

}

}

}

/**

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

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

Object obj = stringToValue((String) token);

if (obj instanceof Boolean) {

jsonObject.accumulate(string,

config.isKeepBooleanAsString()

? ((String) token)

: obj);

} else if (obj instanceof Number) {

jsonObject.accumulate(string,

config.isKeepNumberAsString()

? ((String) token)

: obj);

} else {

jsonObject.accumulate(string, 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 if(context.isEmpty()) { //avoids resetting the array in case of an empty tag in the middle or end

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

if (jsonObject.isEmpty()){

context.append(tagName, "");

}

} else {

context.append(tagName, "");

}

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

Object obj = stringToValue((String) token);

if (obj instanceof Boolean) {

jsonObject.accumulate(config.getcDataTagName(),

config.isKeepBooleanAsString()

? ((String) token)

: obj);

} else if (obj instanceof Number) {

jsonObject.accumulate(config.getcDataTagName(),

config.isKeepNumberAsString()

? ((String) token)

: obj);

} else if (obj == JSONObject.NULL) {

jsonObject.accumulate(config.getcDataTagName(),

config.isKeepStrings() ? ((String) token) : obj);

} else {

jsonObject.accumulate(config.getcDataTagName(), stringToValue((String) token));

}

}

}

} else if (token == LT) {

// Nested element

if (currentNestingDepth == config.getMaxNestingDepth()) {

throw x.syntaxError("Maximum nesting depth of " + config.getMaxNestingDepth() + " reached");

}

if (parse(x, jsonObject, tagName, config, currentNestingDepth + 1)) {

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

// Force the value to be an array

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

//avoids resetting the array in case of an empty element in the middle or end

if(context.isEmpty()) {

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

}

context.append(tagName, "");

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

if (!config.shouldTrimWhiteSpace()) {

removeEmpty(jsonObject, config);

}

context.accumulate(tagName, jsonObject);

}

}

return false;

}

}

}

} else {

throw x.syntaxError("Misshaped tag");

}

}

}

}

/**

private static void removeEmpty(final JSONObject jsonObject, final XMLParserConfiguration config) {

if (jsonObject.has(config.getcDataTagName())) {

final Object s = jsonObject.get(config.getcDataTagName());

if (s instanceof String) {

if (isStringAllWhiteSpace(s.toString())) {

jsonObject.remove(config.getcDataTagName());

}

}

else if (s instanceof JSONArray) {

final JSONArray sArray = (JSONArray) s;

for (int k = sArray.length()-1; k >= 0; k--){

final Object eachString = sArray.get(k);

if (eachString instanceof String) {

String s1 = (String) eachString;

if (isStringAllWhiteSpace(s1)) {

sArray.remove(k);

}

}

}

if (sArray.isEmpty()) {

jsonObject.remove(config.getcDataTagName());

}

}

}

}

private static boolean isStringAllWhiteSpace(final String s) {

for (int k = 0; k<s.length(); k++){

final char eachChar = s.charAt(k);

if (!Character.isWhitespace(eachChar)) {

return false;

}

}

return true;

}

/**

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

return stringToValue(str, new XMLParserConfiguration());

}

/**

// 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, XMLParserConfiguration xmlParserConfiguration) {

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 {

// user declines max number checking

if (xmlParserConfiguration.getMaxNumberLength() == ParserConfiguration.UNDEFINED_MAXIMUM_NUMBER_LENGTH) {

return stringToNumber(string);

}

if(string.length() <= xmlParserConfiguration.getMaxNumberLength()) {

return stringToNumber(string);

}

} catch (Exception ignore) {

}

}

return string;

}

/**

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, boolean keepNumberAsString, boolean keepBooleanAsString) throws JSONException {

XMLParserConfiguration xmlParserConfiguration = new XMLParserConfiguration();

if(keepNumberAsString) {

xmlParserConfiguration = xmlParserConfiguration.withKeepNumberAsString(keepNumberAsString);

}

if(keepBooleanAsString) {

xmlParserConfiguration = xmlParserConfiguration.withKeepBooleanAsString(keepBooleanAsString);

}

return toJSONObject(reader, xmlParserConfiguration);

}

/**

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

JSONObject jo = new JSONObject();

XMLTokener x = new XMLTokener(reader, config);

while (x.more()) {

x.skipPast("<");

if(x.more()) {

parse(x, jo, null, config, 0);

}

}

return jo;

}

/**

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

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

}

/**

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

return toJSONObject(new StringReader(string), keepNumberAsString, keepBooleanAsString);

}

/**

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 {

return toString(object, tagName, config, 0, 0);

}

/**

private static String toString(final Object object, final String tagName, final XMLParserConfiguration config, int indentFactor, int indent)

throws JSONException {

StringBuilder sb = new StringBuilder();

JSONArray ja;

JSONObject jo;

String string;

if (tagName != null) {

noXmlMetachars(tagName);