iter = collection.iterator(); iter.hasNext();) {
m_myArrayList.add(new JSONObject(iter.next(), includeSuperClass));
}
}
}
/**
* Construct a JSONArray from a JSONTokener.
*
* @param x a JSONTokener
* @throws JSONException if there is a syntax error
*/
public JSONArray(JSONTokener x)
throws JSONException {
this();
char c = x.nextClean();
char q;
if (c == '[') {
q = ']';
} else if (c == '(') {
q = ')';
} else {
throw x.syntaxError("A JSONArray text must start with '['");
}
if (x.nextClean() == ']') {
return;
}
x.back();
for (;;) {
if (x.nextClean() == ',') {
x.back();
m_myArrayList.add(null);
} else {
x.back();
m_myArrayList.add(x.nextValue());
}
c = x.nextClean();
switch (c) {
case ';':
case ',':
if (x.nextClean() == ']') {
return;
}
x.back();
break;
case ']':
case ')':
if (q != c) {
throw x.syntaxError("Expected a '" + new Character(q) + "'");
}
return;
default:
throw x.syntaxError("Expected a ',' or ']'");
}
}
}
/**
* Construct a JSONArray from an array.
*
* @param array an array
* @throws JSONException if not an array
*/
public JSONArray(Object array)
throws JSONException {
this();
if (array.getClass().isArray()) {
int length = Array.getLength(array);
for (int i = 0; i < length; i += 1) {
this.put(Array.get(array, i));
}
} else {
throw new JSONException("JSONArray initial value should be a string or collection or array.");
}
}
/**
* Construct a JSONArray from an array with a bean.
*
* The array should have Java Beans.
*
* @param array an array
* @param includeSuperClass tell whether to include the super class properties
* @throws JSONException if not an array
*/
public JSONArray(Object array, boolean includeSuperClass)
throws JSONException {
this();
if (array.getClass().isArray()) {
int length = Array.getLength(array);
for (int i = 0; i < length; i += 1) {
this.put(new JSONObject(Array.get(array, i), includeSuperClass));
}
} else {
throw new JSONException("JSONArray initial value should be a string or collection or array.");
}
}
/**
* Construct a JSONArray from a source JSON text.
*
* @param source a string that begins with
* [ (left bracket)
* and ends with ] (right bracket)
* @throws JSONException if there is a syntax error
*/
public JSONArray(String source)
throws JSONException {
this(new JSONTokener(source));
}
/**
* Appends values from another JSON array.
*
* @param array the array whose values should be appended
*/
public void append(JSONArray array) {
for (int i = 0; i < array.length(); i++) {
put(array.opt(i));
}
}
/**
* Check if this array contains the given string value.
*
* @param value the value to check
*
* @return true if found, false if not
*/
public boolean containsString(String value) {
return m_myArrayList.contains(value);
}
/**
* Get the object value associated with an index.
*
* @param index the index must be between 0 and length() - 1
* @return an object value
* @throws JSONException if there is no value for the index
*/
public Object get(int index) throws JSONException {
Object o = opt(index);
if (o == null) {
throw new JSONException("JSONArray[" + index + "] not found.");
}
return o;
}
/**
* Get the boolean value associated with an index.
*
* The string values "true" and "false" are converted to boolean.
*
* @param index the index must be between 0 and length() - 1
* @return the truth
* @throws JSONException if there is no value for the index or if the value is not convertable to boolean
*/
public boolean getBoolean(int index) throws JSONException {
Object o = get(index);
if (o.equals(Boolean.FALSE) || ((o instanceof String) && ((String)o).equalsIgnoreCase("false"))) {
return false;
} else if (o.equals(Boolean.TRUE) || ((o instanceof String) && ((String)o).equalsIgnoreCase("true"))) {
return true;
}
throw new JSONException("JSONArray[" + index + "] is not a Boolean.");
}
/**
* Get the double value associated with an index.
*
* @param index the index must be between 0 and length() - 1
* @return the value
* @throws JSONException if the key is not found or if the value cannot be converted to a number
*/
public double getDouble(int index) throws JSONException {
Object o = get(index);
try {
return o instanceof Number ? ((Number)o).doubleValue() : Double.valueOf((String)o).doubleValue();
} catch (Exception e) {
throw new JSONException("JSONArray[" + index + "] is not a number.");
}
}
/**
* Get the int value associated with an index.
*
* @param index the index must be between 0 and length() - 1
* @return the value
* @throws JSONException if the key is not found or if the value cannot be converted to a number
*/
public int getInt(int index) throws JSONException {
Object o = get(index);
return o instanceof Number ? ((Number)o).intValue() : (int)getDouble(index);
}
/**
* Get the JSONArray associated with an index.
*
* @param index the index must be between 0 and length() - 1
* @return a JSONArray value
* @throws JSONException if there is no value for the index or if the value is not a JSONArray
*/
public JSONArray getJSONArray(int index) throws JSONException {
Object o = get(index);
if (o instanceof JSONArray) {
return (JSONArray)o;
}
throw new JSONException("JSONArray[" + index + "] is not a JSONArray.");
}
/**
* Get the JSONObject associated with an index.
*
* @param index the index must be between 0 and length() - 1
* @return a JSONObject value
* @throws JSONException if there is no value for the index or if the value is not a JSONObject
*/
public JSONObject getJSONObject(int index) throws JSONException {
Object o = get(index);
if (o instanceof JSONObject) {
return (JSONObject)o;
}
throw new JSONException("JSONArray[" + index + "] is not a JSONObject.");
}
/**
* Get the long value associated with an index.
*
* @param index the index must be between 0 and length() - 1
* @return the value
* @throws JSONException if the key is not found or if the value cannot be converted to a number
*/
public long getLong(int index) throws JSONException {
Object o = get(index);
return o instanceof Number ? ((Number)o).longValue() : (long)getDouble(index);
}
/**
* Get the string associated with an index.
*
* @param index the index must be between 0 and length() - 1
* @return a string value
* @throws JSONException if there is no value for the index
*/
public String getString(int index) throws JSONException {
return get(index).toString();
}
/**
* Determine if the value is null.
*
* @param index the index must be between 0 and length() - 1
* @return true if the value at the index is null, or if there is no value
*/
public boolean isNull(int index) {
return JSONObject.NULL.equals(opt(index));
}
/**
* Make a string from the contents of this JSONArray.
*
* The separator string is inserted between each element.
*
* Warning: This method assumes that the data structure is acyclical.
*
* @param separator a string that will be inserted between the elements
* @return a string
* @throws JSONException if the array contains an invalid number
*/
public String join(String separator) throws JSONException {
int len = length();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < len; i += 1) {
if (i > 0) {
sb.append(separator);
}
sb.append(JSONObject.valueToString(m_myArrayList.get(i)));
}
return sb.toString();
}
/**
* Get the number of elements in the JSONArray, included nulls.
*
* @return the length (or size)
*/
public int length() {
return m_myArrayList.size();
}
/**
* Get the optional object value associated with an index.
*
* @param index the index must be between 0 and length() - 1
* @return an object value, or null if there is no object at that index
*/
public Object opt(int index) {
return ((index < 0) || (index >= length())) ? null : m_myArrayList.get(index);
}
/**
* Get the optional boolean value associated with an index.
*
* It returns false if there is no value at that index,
* or if the value is not Boolean.TRUE or the String "true".
*
* @param index the index must be between 0 and length() - 1
* @return the truth
*/
public boolean optBoolean(int index) {
return optBoolean(index, false);
}
/**
* Get the optional boolean value associated with an index.
*
* It returns the defaultValue if there is no value at that index or if
* it is not a Boolean or the String "true" or "false" (case insensitive).
*
* @param index the index must be between 0 and length() - 1
* @param defaultValue a boolean default
* @return the truth
*/
public boolean optBoolean(int index, boolean defaultValue) {
try {
return getBoolean(index);
} catch (Exception e) {
return defaultValue;
}
}
/**
* Get the optional double value associated with an index.
*
* NaN is returned if there is no value for the index,
* or if the value is not a number and cannot be converted to a number.
*
* @param index the index must be between 0 and length() - 1
* @return the value
*/
public double optDouble(int index) {
return optDouble(index, Double.NaN);
}
/**
* Get the optional double value associated with an index.
*
* The defaultValue is returned if there is no value for the index,
* or if the value is not a number and cannot be converted to a number.
*
* @param index the index must be between 0 and length() - 1
* @param defaultValue the default value
* @return the value
*/
public double optDouble(int index, double defaultValue) {
try {
return getDouble(index);
} catch (Exception e) {
return defaultValue;
}
}
/**
* Get the optional int value associated with an index.
*
* Zero is returned if there is no value for the index,
* or if the value is not a number and cannot be converted to a number.
*
* @param index the index must be between 0 and length() - 1
* @return the value
*/
public int optInt(int index) {
return optInt(index, 0);
}
/**
* Get the optional int value associated with an index.
*
* The defaultValue is returned if there is no value for the index,
* or if the value is not a number and cannot be converted to a number.
*
* @param index the index must be between 0 and length() - 1
* @param defaultValue the default value
* @return the value
*/
public int optInt(int index, int defaultValue) {
try {
return getInt(index);
} catch (Exception e) {
return defaultValue;
}
}
/**
* Get the optional JSONArray associated with an index.
*
* @param index the index must be between 0 and length() - 1
* @return aA JSONArray value, or null if the index has no value, or if the value is not a JSONArray
*/
public JSONArray optJSONArray(int index) {
Object o = opt(index);
return o instanceof JSONArray ? (JSONArray)o : null;
}
/**
* Get the optional JSONObject associated with an index.
*
* Null is returned if the key is not found, or null if the index has
* no value, or if the value is not a JSONObject.
*
* @param index the index must be between 0 and length() - 1
* @return a JSONObject value
*/
public JSONObject optJSONObject(int index) {
Object o = opt(index);
return o instanceof JSONObject ? (JSONObject)o : null;
}
/**
* Get the optional long value associated with an index.
*
* Zero is returned if there is no value for the index,
* or if the value is not a number and cannot be converted to a number.
*
* @param index the index must be between 0 and length() - 1
* @return the value
*/
public long optLong(int index) {
return optLong(index, 0);
}
/**
* Get the optional long value associated with an index.
*
* The defaultValue is returned if there is no value for the index,
* or if the value is not a number and cannot be converted to a number.
*
* @param index the index must be between 0 and length() - 1
* @param defaultValue the default value
* @return the value
*/
public long optLong(int index, long defaultValue) {
try {
return getLong(index);
} catch (Exception e) {
return defaultValue;
}
}
/**
* Get the optional string value associated with an index.
*
* It returns an empty string if there is no value at that index. If the value
* is not a string and is not null, then it is coverted to a string.
*
* @param index the index must be between 0 and length() - 1
* @return a String value
*/
public String optString(int index) {
return optString(index, "");
}
/**
* Get the optional string associated with an index.
*
* The defaultValue is returned if the key is not found.
*
* @param index tThe index must be between 0 and length() - 1
* @param defaultValue the default value
* @return a String value
*/
public String optString(int index, String defaultValue) {
Object o = opt(index);
return o != null ? o.toString() : defaultValue;
}
/**
* Append a boolean value. This increases the array's length by one.
*
* @param value a boolean value
* @return this
*/
public JSONArray put(boolean value) {
put(value ? Boolean.TRUE : Boolean.FALSE);
return this;
}
/**
* Put a value in the JSONArray, where the value will be a
* JSONArray which is produced from a Collection.
*
* @param value a Collection value
* @return this
*/
public JSONArray put(Collection value) {
put(new JSONArray(value));
return this;
}
/**
* Append a double value. This increases the array's length by one.
*
* @param value a double value
* @throws JSONException if the value is not finite
* @return this
*/
public JSONArray put(double value) throws JSONException {
Double d = new Double(value);
JSONObject.testValidity(d);
put(d);
return this;
}
/**
* Append an int value. This increases the array's length by one.
*
* @param value an int value
* @return this
*/
public JSONArray put(int value) {
put(new Integer(value));
return this;
}
/**
* Put or replace a boolean value in the JSONArray. If the index is greater
* than the length of the JSONArray, then null elements will be added as
* necessary to pad it out.
*
* @param index the index
* @param value a boolean value
* @return this
* @throws JSONException if the index is negative
*/
public JSONArray put(int index, boolean value) throws JSONException {
put(index, value ? Boolean.TRUE : Boolean.FALSE);
return this;
}
/**
* Put a value in the JSONArray, where the value will be a
* JSONArray which is produced from a Collection.
*
* @param index the index must be between 0 and length() - 1
* @param value a Collection value
* @return this
* @throws JSONException if the index is negative or if the value is
* not finite
*/
public JSONArray put(int index, Collection value) throws JSONException {
put(index, new JSONArray(value));
return this;
}
/**
* Put or replace a double value. If the index is greater than the length of
* the JSONArray, then null elements will be added as necessary to pad
* it out.
*
* @param index the index
* @param value a double value
* @return this
* @throws JSONException if the index is negative or if the value is
* not finite
*/
public JSONArray put(int index, double value) throws JSONException {
put(index, new Double(value));
return this;
}
/**
* Put or replace an int value. If the index is greater than the length of
* the JSONArray, then null elements will be added as necessary to pad
* it out.
*
* @param index the index
* @param value an int value
* @return this
* @throws JSONException if the index is negative
*/
public JSONArray put(int index, int value) throws JSONException {
put(index, new Integer(value));
return this;
}
/**
* Put or replace a long value. If the index is greater than the length of
* the JSONArray, then null elements will be added as necessary to pad
* it out.
*
* @param index the index
* @param value a long value
* @return this
* @throws JSONException if the index is negative
*/
public JSONArray put(int index, long value) throws JSONException {
put(index, new Long(value));
return this;
}
/**
* Put a value in the JSONArray, where the value will be a
* JSONObject which is produced from a Map.
*
* @param index the index must be between 0 and length() - 1
* @param value the Map value
* @return this
* @throws JSONException if the index is negative or if the the value is
* an invalid number
*/
public JSONArray put(int index, Map value) throws JSONException {
put(index, new JSONObject(value));
return this;
}
/**
* Put or replace an object value in the JSONArray. If the index is greater
* than the length of the JSONArray, then null elements will be added as
* necessary to pad it out.
*
* @param index the index
* @param value the value to put into the array. The value should be a
* Boolean, Double, Integer, JSONArray, JSONObject, Long, or String, or the
* JSONObject.NULL object
* @return this
* @throws JSONException if the index is negative or if the the value is
* an invalid number
*/
public JSONArray put(int index, Object value) throws JSONException {
JSONObject.testValidity(value);
if (index < 0) {
throw new JSONException("JSONArray[" + index + "] not found.");
}
if (index < length()) {
m_myArrayList.set(index, value);
} else {
while (index != length()) {
put(JSONObject.NULL);
}
put(value);
}
return this;
}
/**
* Append an long value. This increases the array's length by one.
*
* @param value a long value
* @return this
*/
public JSONArray put(long value) {
put(new Long(value));
return this;
}
/**
* Put a value in the JSONArray, where the value will be a
* JSONObject which is produced from a Map.
*
* @param value a Map value
* @return this
*/
public JSONArray put(Map value) {
put(new JSONObject(value));
return this;
}
/**
* Append an object value. This increases the array's length by one.
*
* @param value an object value. The value should be a
* Boolean, Double, Integer, JSONArray, JSONObject, Long, or String, or the
* JSONObject.NULL object
* @return this
*/
public JSONArray put(Object value) {
m_myArrayList.add(value);
return this;
}
/**
* Produce a JSONObject by combining a JSONArray of names with the values
* of this JSONArray.
*
* @param names a JSONArray containing a list of key strings. These will be
* paired with the values
* @return a JSONObject, or null if there are no names or if this JSONArray
* has no values
* @throws JSONException if any of the names are null
*/
public JSONObject toJSONObject(JSONArray names) throws JSONException {
if ((names == null) || (names.length() == 0) || (length() == 0)) {
return null;
}
JSONObject jo = new JSONObject();
for (int i = 0; i < names.length(); i += 1) {
jo.put(names.getString(i), opt(i));
}
return jo;
}
/**
* Make a JSON text of this JSONArray.
*
* For compactness, no unnecessary whitespace is added. If it is not possible to produce a
* syntactically correct JSON text then null will be returned instead. This
* could occur if the array contains an invalid number.
*
* Warning: This method assumes that the data structure is acyclical.
*
* @return a printable, displayable, transmittable representation of the array
*/
@Override
public String toString() {
try {
return '[' + join(",") + ']';
} catch (Exception e) {
return null;
}
}
/**
* Make a pretty printed JSON text of this JSONArray.
*
* Warning: This method assumes that the data structure is acyclical.
*
* @param indentFactor the number of spaces to add to each level of
* indentation
* @return a printable, displayable, transmittable
* representation of the object, beginning
* with [ (left bracket) and ending
* with ] (right bracket)
* @throws JSONException if something goes wrong
*/
public String toString(int indentFactor) throws JSONException {
return toString(indentFactor, 0);
}
/**
* Write the contents of the JSONArray as JSON text to a writer.
*
* For compactness, no whitespace is added.
*
* Warning: This method assumes that the data structure is acyclical.
*
* @param writer the writer to write the contents to
* @return the writer
* @throws JSONException if something goes wrong
*/
public Writer write(Writer writer) throws JSONException {
try {
boolean b = false;
int len = length();
writer.write('[');
for (int i = 0; i < len; i += 1) {
if (b) {
writer.write(',');
}
Object v = m_myArrayList.get(i);
if (v instanceof JSONObject) {
((JSONObject)v).write(writer);
} else if (v instanceof JSONArray) {
((JSONArray)v).write(writer);
} else {
writer.write(JSONObject.valueToString(v));
}
b = true;
}
writer.write(']');
return writer;
} catch (IOException e) {
throw new JSONException(e);
}
}
/**
* Make a pretty printed JSON text of this JSONArray.
*
* Warning: This method assumes that the data structure is acyclical.
*
* @param indentFactor the number of spaces to add to each level of
* indentation
* @param indent the indention of the top level
* @return a printable, displayable, transmittable
* representation of the array
* @throws JSONException if something goes wrong
*/
String toString(int indentFactor, int indent) throws JSONException {
int len = length();
if (len == 0) {
return "[]";
}
int i;
StringBuffer sb = new StringBuffer("[");
if (len == 1) {
sb.append(JSONObject.valueToString(m_myArrayList.get(0), indentFactor, indent));
} else {
int newindent = indent + indentFactor;
sb.append('\n');
for (i = 0; i < len; i += 1) {
if (i > 0) {
sb.append(",\n");
}
for (int j = 0; j < newindent; j += 1) {
sb.append(' ');
}
sb.append(JSONObject.valueToString(m_myArrayList.get(i), indentFactor, newindent));
}
sb.append('\n');
for (i = 0; i < indent; i += 1) {
sb.append(' ');
}
}
sb.append(']');
return sb.toString();
}
}
