Clover icon

Coverage Report

  1. Project Clover database Thu Aug 13 2020 12:04:21 BST
  2. Package org.json

File JSONArray.java

 

Coverage histogram

../../img/srcFileCovDistChart1.png
52% of files have more coverage

Code metrics

166
326
72
1
1,541
628
197
0.6
4.53
72
2.74

Classes

Class Line # Actions
JSONArray 84 326 197
0.070921997.1%
 

Contributing tests

This file is covered by 3 tests. .

Source view

1    package org.json;
2   
3    /*
4    Copyright (c) 2002 JSON.org
5   
6    Permission is hereby granted, free of charge, to any person obtaining a copy
7    of this software and associated documentation files (the "Software"), to deal
8    in the Software without restriction, including without limitation the rights
9    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10    copies of the Software, and to permit persons to whom the Software is
11    furnished to do so, subject to the following conditions:
12   
13    The above copyright notice and this permission notice shall be included in all
14    copies or substantial portions of the Software.
15   
16    The Software shall be used for Good, not Evil.
17   
18    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24    SOFTWARE.
25    */
26   
27    import java.io.IOException;
28    import java.io.StringWriter;
29    import java.io.Writer;
30    import java.lang.reflect.Array;
31    import java.math.BigDecimal;
32    import java.math.BigInteger;
33    import java.util.ArrayList;
34    import java.util.Collection;
35    import java.util.Iterator;
36    import java.util.List;
37    import java.util.Map;
38   
39   
40    /**
41    * A JSONArray is an ordered sequence of values. Its external text form is a
42    * string wrapped in square brackets with commas separating the values. The
43    * internal form is an object having <code>get</code> and <code>opt</code>
44    * methods for accessing the values by index, and <code>put</code> methods for
45    * adding or replacing values. The values can be any of these types:
46    * <code>Boolean</code>, <code>JSONArray</code>, <code>JSONObject</code>,
47    * <code>Number</code>, <code>String</code>, or the
48    * <code>JSONObject.NULL object</code>.
49    * <p>
50    * The constructor can convert a JSON text into a Java object. The
51    * <code>toString</code> method converts to JSON text.
52    * <p>
53    * A <code>get</code> method returns a value if one can be found, and throws an
54    * exception if one cannot be found. An <code>opt</code> method returns a
55    * default value instead of throwing an exception, and so is useful for
56    * obtaining optional values.
57    * <p>
58    * The generic <code>get()</code> and <code>opt()</code> methods return an
59    * object which you can cast or query for type. There are also typed
60    * <code>get</code> and <code>opt</code> methods that do type checking and type
61    * coercion for you.
62    * <p>
63    * The texts produced by the <code>toString</code> methods strictly conform to
64    * JSON syntax rules. The constructors are more forgiving in the texts they will
65    * accept:
66    * <ul>
67    * <li>An extra <code>,</code>&nbsp;<small>(comma)</small> may appear just
68    * before the closing bracket.</li>
69    * <li>The <code>null</code> value will be inserted when there is <code>,</code>
70    * &nbsp;<small>(comma)</small> elision.</li>
71    * <li>Strings may be quoted with <code>'</code>&nbsp;<small>(single
72    * quote)</small>.</li>
73    * <li>Strings do not need to be quoted at all if they do not begin with a quote
74    * or single quote, and if they do not contain leading or trailing spaces, and
75    * if they do not contain any of these characters:
76    * <code>{ } [ ] / \ : , #</code> and if they do not look like numbers and
77    * if they are not the reserved words <code>true</code>, <code>false</code>, or
78    * <code>null</code>.</li>
79    * </ul>
80    *
81    * @author JSON.org
82    * @version 2016-08/15
83    */
 
84    public class JSONArray implements Iterable<Object> {
85   
86    /**
87    * The arrayList where the JSONArray's properties are kept.
88    */
89    private final ArrayList<Object> myArrayList;
90   
91    /**
92    * Construct an empty JSONArray.
93    */
 
94  0 toggle public JSONArray() {
95  0 this.myArrayList = new ArrayList<Object>();
96    }
97   
98    /**
99    * Construct a JSONArray from a JSONTokener.
100    *
101    * @param x
102    * A JSONTokener
103    * @throws JSONException
104    * If there is a syntax error.
105    */
 
106  0 toggle public JSONArray(JSONTokener x) throws JSONException {
107  0 this();
108  0 if (x.nextClean() != '[') {
109  0 throw x.syntaxError("A JSONArray text must start with '['");
110    }
111   
112  0 char nextChar = x.nextClean();
113  0 if (nextChar == 0) {
114    // array is unclosed. No ']' found, instead EOF
115  0 throw x.syntaxError("Expected a ',' or ']'");
116    }
117  0 if (nextChar != ']') {
118  0 x.back();
119  0 for (;;) {
120  0 if (x.nextClean() == ',') {
121  0 x.back();
122  0 this.myArrayList.add(JSONObject.NULL);
123    } else {
124  0 x.back();
125  0 this.myArrayList.add(x.nextValue());
126    }
127  0 switch (x.nextClean()) {
128  0 case 0:
129    // array is unclosed. No ']' found, instead EOF
130  0 throw x.syntaxError("Expected a ',' or ']'");
131  0 case ',':
132  0 nextChar = x.nextClean();
133  0 if (nextChar == 0) {
134    // array is unclosed. No ']' found, instead EOF
135  0 throw x.syntaxError("Expected a ',' or ']'");
136    }
137  0 if (nextChar == ']') {
138  0 return;
139    }
140  0 x.back();
141  0 break;
142  0 case ']':
143  0 return;
144  0 default:
145  0 throw x.syntaxError("Expected a ',' or ']'");
146    }
147    }
148    }
149    }
150   
151    /**
152    * Construct a JSONArray from a source JSON text.
153    *
154    * @param source
155    * A string that begins with <code>[</code>&nbsp;<small>(left
156    * bracket)</small> and ends with <code>]</code>
157    * &nbsp;<small>(right bracket)</small>.
158    * @throws JSONException
159    * If there is a syntax error.
160    */
 
161  0 toggle public JSONArray(String source) throws JSONException {
162  0 this(new JSONTokener(source));
163    }
164   
165    /**
166    * Construct a JSONArray from a Collection.
167    *
168    * @param collection
169    * A Collection.
170    */
 
171  25 toggle public JSONArray(Collection<?> collection) {
172  25 if (collection == null) {
173  0 this.myArrayList = new ArrayList<Object>();
174    } else {
175  25 this.myArrayList = new ArrayList<Object>(collection.size());
176  25 for (Object o: collection){
177  144 this.myArrayList.add(JSONObject.wrap(o));
178    }
179    }
180    }
181   
182    /**
183    * Construct a JSONArray from an array
184    *
185    * @throws JSONException
186    * If not an array or if an array value is non-finite number.
187    */
 
188  0 toggle public JSONArray(Object array) throws JSONException {
189  0 this();
190  0 if (array.getClass().isArray()) {
191  0 int length = Array.getLength(array);
192  0 this.myArrayList.ensureCapacity(length);
193  0 for (int i = 0; i < length; i += 1) {
194  0 this.put(JSONObject.wrap(Array.get(array, i)));
195    }
196    } else {
197  0 throw new JSONException(
198    "JSONArray initial value should be a string or collection or array.");
199    }
200    }
201   
 
202  0 toggle @Override
203    public Iterator<Object> iterator() {
204  0 return this.myArrayList.iterator();
205    }
206   
207    /**
208    * Get the object value associated with an index.
209    *
210    * @param index
211    * The index must be between 0 and length() - 1.
212    * @return An object value.
213    * @throws JSONException
214    * If there is no value for the index.
215    */
 
216  0 toggle public Object get(int index) throws JSONException {
217  0 Object object = this.opt(index);
218  0 if (object == null) {
219  0 throw new JSONException("JSONArray[" + index + "] not found.");
220    }
221  0 return object;
222    }
223   
224    /**
225    * Get the boolean value associated with an index. The string values "true"
226    * and "false" are converted to boolean.
227    *
228    * @param index
229    * The index must be between 0 and length() - 1.
230    * @return The truth.
231    * @throws JSONException
232    * If there is no value for the index or if the value is not
233    * convertible to boolean.
234    */
 
235  0 toggle public boolean getBoolean(int index) throws JSONException {
236  0 Object object = this.get(index);
237  0 if (object.equals(Boolean.FALSE)
238    || (object instanceof String && ((String) object)
239    .equalsIgnoreCase("false"))) {
240  0 return false;
241  0 } else if (object.equals(Boolean.TRUE)
242    || (object instanceof String && ((String) object)
243    .equalsIgnoreCase("true"))) {
244  0 return true;
245    }
246  0 throw new JSONException("JSONArray[" + index + "] is not a boolean.");
247    }
248   
249    /**
250    * Get the double value associated with an index.
251    *
252    * @param index
253    * The index must be between 0 and length() - 1.
254    * @return The value.
255    * @throws JSONException
256    * If the key is not found or if the value cannot be converted
257    * to a number.
258    */
 
259  0 toggle public double getDouble(int index) throws JSONException {
260  0 Object object = this.get(index);
261  0 try {
262  0 return object instanceof Number ? ((Number) object).doubleValue()
263    : Double.parseDouble((String) object);
264    } catch (Exception e) {
265  0 throw new JSONException("JSONArray[" + index + "] is not a number.", e);
266    }
267    }
268   
269    /**
270    * Get the float value associated with a key.
271    *
272    * @param index
273    * The index must be between 0 and length() - 1.
274    * @return The numeric value.
275    * @throws JSONException
276    * if the key is not found or if the value is not a Number
277    * object and cannot be converted to a number.
278    */
 
279  0 toggle public float getFloat(int index) throws JSONException {
280  0 Object object = this.get(index);
281  0 try {
282  0 return object instanceof Number ? ((Number) object).floatValue()
283    : Float.parseFloat(object.toString());
284    } catch (Exception e) {
285  0 throw new JSONException("JSONArray[" + index
286    + "] is not a number.", e);
287    }
288    }
289   
290    /**
291    * Get the Number value associated with a key.
292    *
293    * @param index
294    * The index must be between 0 and length() - 1.
295    * @return The numeric value.
296    * @throws JSONException
297    * if the key is not found or if the value is not a Number
298    * object and cannot be converted to a number.
299    */
 
300  0 toggle public Number getNumber(int index) throws JSONException {
301  0 Object object = this.get(index);
302  0 try {
303  0 if (object instanceof Number) {
304  0 return (Number)object;
305    }
306  0 return JSONObject.stringToNumber(object.toString());
307    } catch (Exception e) {
308  0 throw new JSONException("JSONArray[" + index + "] is not a number.", e);
309    }
310    }
311   
312    /**
313    * Get the enum value associated with an index.
314    *
315    * @param clazz
316    * The type of enum to retrieve.
317    * @param index
318    * The index must be between 0 and length() - 1.
319    * @return The enum value at the index location
320    * @throws JSONException
321    * if the key is not found or if the value cannot be converted
322    * to an enum.
323    */
 
324  0 toggle public <E extends Enum<E>> E getEnum(Class<E> clazz, int index) throws JSONException {
325  0 E val = optEnum(clazz, index);
326  0 if(val==null) {
327    // JSONException should really take a throwable argument.
328    // If it did, I would re-implement this with the Enum.valueOf
329    // method and place any thrown exception in the JSONException
330  0 throw new JSONException("JSONArray[" + index + "] is not an enum of type "
331    + JSONObject.quote(clazz.getSimpleName()) + ".");
332    }
333  0 return val;
334    }
335   
336    /**
337    * Get the BigDecimal value associated with an index.
338    *
339    * @param index
340    * The index must be between 0 and length() - 1.
341    * @return The value.
342    * @throws JSONException
343    * If the key is not found or if the value cannot be converted
344    * to a BigDecimal.
345    */
 
346  0 toggle public BigDecimal getBigDecimal (int index) throws JSONException {
347  0 Object object = this.get(index);
348  0 try {
349  0 return new BigDecimal(object.toString());
350    } catch (Exception e) {
351  0 throw new JSONException("JSONArray[" + index +
352    "] could not convert to BigDecimal.", e);
353    }
354    }
355   
356    /**
357    * Get the BigInteger value associated with an index.
358    *
359    * @param index
360    * The index must be between 0 and length() - 1.
361    * @return The value.
362    * @throws JSONException
363    * If the key is not found or if the value cannot be converted
364    * to a BigInteger.
365    */
 
366  0 toggle public BigInteger getBigInteger (int index) throws JSONException {
367  0 Object object = this.get(index);
368  0 try {
369  0 return new BigInteger(object.toString());
370    } catch (Exception e) {
371  0 throw new JSONException("JSONArray[" + index +
372    "] could not convert to BigInteger.", e);
373    }
374    }
375   
376    /**
377    * Get the int value associated with an index.
378    *
379    * @param index
380    * The index must be between 0 and length() - 1.
381    * @return The value.
382    * @throws JSONException
383    * If the key is not found or if the value is not a number.
384    */
 
385  0 toggle public int getInt(int index) throws JSONException {
386  0 Object object = this.get(index);
387  0 try {
388  0 return object instanceof Number ? ((Number) object).intValue()
389    : Integer.parseInt((String) object);
390    } catch (Exception e) {
391  0 throw new JSONException("JSONArray[" + index + "] is not a number.", e);
392    }
393    }
394   
395    /**
396    * Get the JSONArray associated with an index.
397    *
398    * @param index
399    * The index must be between 0 and length() - 1.
400    * @return A JSONArray value.
401    * @throws JSONException
402    * If there is no value for the index. or if the value is not a
403    * JSONArray
404    */
 
405  0 toggle public JSONArray getJSONArray(int index) throws JSONException {
406  0 Object object = this.get(index);
407  0 if (object instanceof JSONArray) {
408  0 return (JSONArray) object;
409    }
410  0 throw new JSONException("JSONArray[" + index + "] is not a JSONArray.");
411    }
412   
413    /**
414    * Get the JSONObject associated with an index.
415    *
416    * @param index
417    * subscript
418    * @return A JSONObject value.
419    * @throws JSONException
420    * If there is no value for the index or if the value is not a
421    * JSONObject
422    */
 
423  0 toggle public JSONObject getJSONObject(int index) throws JSONException {
424  0 Object object = this.get(index);
425  0 if (object instanceof JSONObject) {
426  0 return (JSONObject) object;
427    }
428  0 throw new JSONException("JSONArray[" + index + "] is not a JSONObject.");
429    }
430   
431    /**
432    * Get the long value associated with an index.
433    *
434    * @param index
435    * The index must be between 0 and length() - 1.
436    * @return The value.
437    * @throws JSONException
438    * If the key is not found or if the value cannot be converted
439    * to a number.
440    */
 
441  0 toggle public long getLong(int index) throws JSONException {
442  0 Object object = this.get(index);
443  0 try {
444  0 return object instanceof Number ? ((Number) object).longValue()
445    : Long.parseLong((String) object);
446    } catch (Exception e) {
447  0 throw new JSONException("JSONArray[" + index + "] is not a number.", e);
448    }
449    }
450   
451    /**
452    * Get the string associated with an index.
453    *
454    * @param index
455    * The index must be between 0 and length() - 1.
456    * @return A string value.
457    * @throws JSONException
458    * If there is no string value for the index.
459    */
 
460  0 toggle public String getString(int index) throws JSONException {
461  0 Object object = this.get(index);
462  0 if (object instanceof String) {
463  0 return (String) object;
464    }
465  0 throw new JSONException("JSONArray[" + index + "] not a string.");
466    }
467   
468    /**
469    * Determine if the value is <code>null</code>.
470    *
471    * @param index
472    * The index must be between 0 and length() - 1.
473    * @return true if the value at the index is <code>null</code>, or if there is no value.
474    */
 
475  0 toggle public boolean isNull(int index) {
476  0 return JSONObject.NULL.equals(this.opt(index));
477    }
478   
479    /**
480    * Make a string from the contents of this JSONArray. The
481    * <code>separator</code> string is inserted between each element. Warning:
482    * This method assumes that the data structure is acyclical.
483    *
484    * @param separator
485    * A string that will be inserted between the elements.
486    * @return a string.
487    * @throws JSONException
488    * If the array contains an invalid number.
489    */
 
490  0 toggle public String join(String separator) throws JSONException {
491  0 int len = this.length();
492  0 StringBuilder sb = new StringBuilder();
493   
494  0 for (int i = 0; i < len; i += 1) {
495  0 if (i > 0) {
496  0 sb.append(separator);
497    }
498  0 sb.append(JSONObject.valueToString(this.myArrayList.get(i)));
499    }
500  0 return sb.toString();
501    }
502   
503    /**
504    * Get the number of elements in the JSONArray, included nulls.
505    *
506    * @return The length (or size).
507    */
 
508  25 toggle public int length() {
509  25 return this.myArrayList.size();
510    }
511   
512    /**
513    * Get the optional object value associated with an index.
514    *
515    * @param index
516    * The index must be between 0 and length() - 1. If not, null is returned.
517    * @return An object value, or null if there is no object at that index.
518    */
 
519  0 toggle public Object opt(int index) {
520  0 return (index < 0 || index >= this.length()) ? null : this.myArrayList
521    .get(index);
522    }
523   
524    /**
525    * Get the optional boolean value associated with an index. It returns false
526    * if there is no value at that index, or if the value is not Boolean.TRUE
527    * or the String "true".
528    *
529    * @param index
530    * The index must be between 0 and length() - 1.
531    * @return The truth.
532    */
 
533  0 toggle public boolean optBoolean(int index) {
534  0 return this.optBoolean(index, false);
535    }
536   
537    /**
538    * Get the optional boolean value associated with an index. It returns the
539    * defaultValue if there is no value at that index or if it is not a Boolean
540    * or the String "true" or "false" (case insensitive).
541    *
542    * @param index
543    * The index must be between 0 and length() - 1.
544    * @param defaultValue
545    * A boolean default.
546    * @return The truth.
547    */
 
548  0 toggle public boolean optBoolean(int index, boolean defaultValue) {
549  0 try {
550  0 return this.getBoolean(index);
551    } catch (Exception e) {
552  0 return defaultValue;
553    }
554    }
555   
556    /**
557    * Get the optional double value associated with an index. NaN is returned
558    * if there is no value for the index, or if the value is not a number and
559    * cannot be converted to a number.
560    *
561    * @param index
562    * The index must be between 0 and length() - 1.
563    * @return The value.
564    */
 
565  0 toggle public double optDouble(int index) {
566  0 return this.optDouble(index, Double.NaN);
567    }
568   
569    /**
570    * Get the optional double value associated with an index. The defaultValue
571    * is returned if there is no value for the index, or if the value is not a
572    * number and cannot be converted to a number.
573    *
574    * @param index
575    * subscript
576    * @param defaultValue
577    * The default value.
578    * @return The value.
579    */
 
580  0 toggle public double optDouble(int index, double defaultValue) {
581  0 Object val = this.opt(index);
582  0 if (JSONObject.NULL.equals(val)) {
583  0 return defaultValue;
584    }
585  0 if (val instanceof Number){
586  0 return ((Number) val).doubleValue();
587    }
588  0 if (val instanceof String) {
589  0 try {
590  0 return Double.parseDouble((String) val);
591    } catch (Exception e) {
592  0 return defaultValue;
593    }
594    }
595  0 return defaultValue;
596    }
597   
598    /**
599    * Get the optional float value associated with an index. NaN is returned
600    * if there is no value for the index, or if the value is not a number and
601    * cannot be converted to a number.
602    *
603    * @param index
604    * The index must be between 0 and length() - 1.
605    * @return The value.
606    */
 
607  0 toggle public float optFloat(int index) {
608  0 return this.optFloat(index, Float.NaN);
609    }
610   
611    /**
612    * Get the optional float value associated with an index. The defaultValue
613    * is returned if there is no value for the index, or if the value is not a
614    * number and cannot be converted to a number.
615    *
616    * @param index
617    * subscript
618    * @param defaultValue
619    * The default value.
620    * @return The value.
621    */
 
622  0 toggle public float optFloat(int index, float defaultValue) {
623  0 Object val = this.opt(index);
624  0 if (JSONObject.NULL.equals(val)) {
625  0 return defaultValue;
626    }
627  0 if (val instanceof Number){
628  0 return ((Number) val).floatValue();
629    }
630  0 if (val instanceof String) {
631  0 try {
632  0 return Float.parseFloat((String) val);
633    } catch (Exception e) {
634  0 return defaultValue;
635    }
636    }
637  0 return defaultValue;
638    }
639   
640    /**
641    * Get the optional int value associated with an index. Zero is returned if
642    * there is no value for the index, or if the value is not a number and
643    * cannot be converted to a number.
644    *
645    * @param index
646    * The index must be between 0 and length() - 1.
647    * @return The value.
648    */
 
649  0 toggle public int optInt(int index) {
650  0 return this.optInt(index, 0);
651    }
652   
653    /**
654    * Get the optional int value associated with an index. The defaultValue is
655    * returned if there is no value for the index, or if the value is not a
656    * number and cannot be converted to a number.
657    *
658    * @param index
659    * The index must be between 0 and length() - 1.
660    * @param defaultValue
661    * The default value.
662    * @return The value.
663    */
 
664  0 toggle public int optInt(int index, int defaultValue) {
665  0 Object val = this.opt(index);
666  0 if (JSONObject.NULL.equals(val)) {
667  0 return defaultValue;
668    }
669  0 if (val instanceof Number){
670  0 return ((Number) val).intValue();
671    }
672   
673  0 if (val instanceof String) {
674  0 try {
675  0 return new BigDecimal(val.toString()).intValue();
676    } catch (Exception e) {
677  0 return defaultValue;
678    }
679    }
680  0 return defaultValue;
681    }
682   
683    /**
684    * Get the enum value associated with a key.
685    *
686    * @param clazz
687    * The type of enum to retrieve.
688    * @param index
689    * The index must be between 0 and length() - 1.
690    * @return The enum value at the index location or null if not found
691    */
 
692  0 toggle public <E extends Enum<E>> E optEnum(Class<E> clazz, int index) {
693  0 return this.optEnum(clazz, index, null);
694    }
695   
696    /**
697    * Get the enum value associated with a key.
698    *
699    * @param clazz
700    * The type of enum to retrieve.
701    * @param index
702    * The index must be between 0 and length() - 1.
703    * @param defaultValue
704    * The default in case the value is not found
705    * @return The enum value at the index location or defaultValue if
706    * the value is not found or cannot be assigned to clazz
707    */
 
708  0 toggle public <E extends Enum<E>> E optEnum(Class<E> clazz, int index, E defaultValue) {
709  0 try {
710  0 Object val = this.opt(index);
711  0 if (JSONObject.NULL.equals(val)) {
712  0 return defaultValue;
713    }
714  0 if (clazz.isAssignableFrom(val.getClass())) {
715    // we just checked it!
716  0 @SuppressWarnings("unchecked")
717    E myE = (E) val;
718  0 return myE;
719    }
720  0 return Enum.valueOf(clazz, val.toString());
721    } catch (IllegalArgumentException e) {
722  0 return defaultValue;
723    } catch (NullPointerException e) {
724  0 return defaultValue;
725    }
726    }
727   
728   
729    /**
730    * Get the optional BigInteger value associated with an index. The
731    * defaultValue is returned if there is no value for the index, or if the
732    * value is not a number and cannot be converted to a number.
733    *
734    * @param index
735    * The index must be between 0 and length() - 1.
736    * @param defaultValue
737    * The default value.
738    * @return The value.
739    */
 
740  0 toggle public BigInteger optBigInteger(int index, BigInteger defaultValue) {
741  0 Object val = this.opt(index);
742  0 if (JSONObject.NULL.equals(val)) {
743  0 return defaultValue;
744    }
745  0 if (val instanceof BigInteger){
746  0 return (BigInteger) val;
747    }
748  0 if (val instanceof BigDecimal){
749  0 return ((BigDecimal) val).toBigInteger();
750    }
751  0 if (val instanceof Double || val instanceof Float){
752  0 return new BigDecimal(((Number) val).doubleValue()).toBigInteger();
753    }
754  0 if (val instanceof Long || val instanceof Integer
755    || val instanceof Short || val instanceof Byte){
756  0 return BigInteger.valueOf(((Number) val).longValue());
757    }
758  0 try {
759  0 final String valStr = val.toString();
760  0 if(JSONObject.isDecimalNotation(valStr)) {
761  0 return new BigDecimal(valStr).toBigInteger();
762    }
763  0 return new BigInteger(valStr);
764    } catch (Exception e) {
765  0 return defaultValue;
766    }
767    }
768   
769    /**
770    * Get the optional BigDecimal value associated with an index. The
771    * defaultValue is returned if there is no value for the index, or if the
772    * value is not a number and cannot be converted to a number.
773    *
774    * @param index
775    * The index must be between 0 and length() - 1.
776    * @param defaultValue
777    * The default value.
778    * @return The value.
779    */
 
780  0 toggle public BigDecimal optBigDecimal(int index, BigDecimal defaultValue) {
781  0 Object val = this.opt(index);
782  0 if (JSONObject.NULL.equals(val)) {
783  0 return defaultValue;
784    }
785  0 if (val instanceof BigDecimal){
786  0 return (BigDecimal) val;
787    }
788  0 if (val instanceof BigInteger){
789  0 return new BigDecimal((BigInteger) val);
790    }
791  0 if (val instanceof Double || val instanceof Float){
792  0 return new BigDecimal(((Number) val).doubleValue());
793    }
794  0 if (val instanceof Long || val instanceof Integer
795    || val instanceof Short || val instanceof Byte){
796  0 return new BigDecimal(((Number) val).longValue());
797    }
798  0 try {
799  0 return new BigDecimal(val.toString());
800    } catch (Exception e) {
801  0 return defaultValue;
802    }
803    }
804   
805    /**
806    * Get the optional JSONArray associated with an index.
807    *
808    * @param index
809    * subscript
810    * @return A JSONArray value, or null if the index has no value, or if the
811    * value is not a JSONArray.
812    */
 
813  0 toggle public JSONArray optJSONArray(int index) {
814  0 Object o = this.opt(index);
815  0 return o instanceof JSONArray ? (JSONArray) o : null;
816    }
817   
818    /**
819    * Get the optional JSONObject associated with an index. Null is returned if
820    * the key is not found, or null if the index has no value, or if the value
821    * is not a JSONObject.
822    *
823    * @param index
824    * The index must be between 0 and length() - 1.
825    * @return A JSONObject value.
826    */
 
827  0 toggle public JSONObject optJSONObject(int index) {
828  0 Object o = this.opt(index);
829  0 return o instanceof JSONObject ? (JSONObject) o : null;
830    }
831   
832    /**
833    * Get the optional long value associated with an index. Zero is returned if
834    * there is no value for the index, or if the value is not a number and
835    * cannot be converted to a number.
836    *
837    * @param index
838    * The index must be between 0 and length() - 1.
839    * @return The value.
840    */
 
841  0 toggle public long optLong(int index) {
842  0 return this.optLong(index, 0);
843    }
844   
845    /**
846    * Get the optional long value associated with an index. The defaultValue is
847    * returned if there is no value for the index, or if the value is not a
848    * number and cannot be converted to a number.
849    *
850    * @param index
851    * The index must be between 0 and length() - 1.
852    * @param defaultValue
853    * The default value.
854    * @return The value.
855    */
 
856  0 toggle public long optLong(int index, long defaultValue) {
857  0 Object val = this.opt(index);
858  0 if (JSONObject.NULL.equals(val)) {
859  0 return defaultValue;
860    }
861  0 if (val instanceof Number){
862  0 return ((Number) val).longValue();
863    }
864   
865  0 if (val instanceof String) {
866  0 try {
867  0 return new BigDecimal(val.toString()).longValue();
868    } catch (Exception e) {
869  0 return defaultValue;
870    }
871    }
872  0 return defaultValue;
873    }
874   
875    /**
876    * Get an optional {@link Number} value associated with a key, or <code>null</code>
877    * if there is no such key or if the value is not a number. If the value is a string,
878    * an attempt will be made to evaluate it as a number ({@link BigDecimal}). This method
879    * would be used in cases where type coercion of the number value is unwanted.
880    *
881    * @param index
882    * The index must be between 0 and length() - 1.
883    * @return An object which is the value.
884    */
 
885  0 toggle public Number optNumber(int index) {
886  0 return this.optNumber(index, null);
887    }
888   
889    /**
890    * Get an optional {@link Number} value associated with a key, or the default if there
891    * is no such key or if the value is not a number. If the value is a string,
892    * an attempt will be made to evaluate it as a number ({@link BigDecimal}). This method
893    * would be used in cases where type coercion of the number value is unwanted.
894    *
895    * @param index
896    * The index must be between 0 and length() - 1.
897    * @param defaultValue
898    * The default.
899    * @return An object which is the value.
900    */
 
901  0 toggle public Number optNumber(int index, Number defaultValue) {
902  0 Object val = this.opt(index);
903  0 if (JSONObject.NULL.equals(val)) {
904  0 return defaultValue;
905    }
906  0 if (val instanceof Number){
907  0 return (Number) val;
908    }
909   
910  0 if (val instanceof String) {
911  0 try {
912  0 return JSONObject.stringToNumber((String) val);
913    } catch (Exception e) {
914  0 return defaultValue;
915    }
916    }
917  0 return defaultValue;
918    }
919   
920    /**
921    * Get the optional string value associated with an index. It returns an
922    * empty string if there is no value at that index. If the value is not a
923    * string and is not null, then it is converted to a string.
924    *
925    * @param index
926    * The index must be between 0 and length() - 1.
927    * @return A String value.
928    */
 
929  0 toggle public String optString(int index) {
930  0 return this.optString(index, "");
931    }
932   
933    /**
934    * Get the optional string associated with an index. The defaultValue is
935    * returned if the key is not found.
936    *
937    * @param index
938    * The index must be between 0 and length() - 1.
939    * @param defaultValue
940    * The default value.
941    * @return A String value.
942    */
 
943  0 toggle public String optString(int index, String defaultValue) {
944  0 Object object = this.opt(index);
945  0 return JSONObject.NULL.equals(object) ? defaultValue : object
946    .toString();
947    }
948   
949    /**
950    * Append a boolean value. This increases the array's length by one.
951    *
952    * @param value
953    * A boolean value.
954    * @return this.
955    */
 
956  0 toggle public JSONArray put(boolean value) {
957  0 return this.put(value ? Boolean.TRUE : Boolean.FALSE);
958    }
959   
960    /**
961    * Put a value in the JSONArray, where the value will be a JSONArray which
962    * is produced from a Collection.
963    *
964    * @param value
965    * A Collection value.
966    * @return this.
967    * @throws JSONException
968    * If the value is non-finite number.
969    */
 
970  0 toggle public JSONArray put(Collection<?> value) {
971  0 return this.put(new JSONArray(value));
972    }
973   
974    /**
975    * Append a double value. This increases the array's length by one.
976    *
977    * @param value
978    * A double value.
979    * @return this.
980    * @throws JSONException
981    * if the value is not finite.
982    */
 
983  0 toggle public JSONArray put(double value) throws JSONException {
984  0 return this.put(Double.valueOf(value));
985    }
986   
987    /**
988    * Append a float value. This increases the array's length by one.
989    *
990    * @param value
991    * A float value.
992    * @return this.
993    * @throws JSONException
994    * if the value is not finite.
995    */
 
996  0 toggle public JSONArray put(float value) throws JSONException {
997  0 return this.put(Float.valueOf(value));
998    }
999   
1000    /**
1001    * Append an int value. This increases the array's length by one.
1002    *
1003    * @param value
1004    * An int value.
1005    * @return this.
1006    */
 
1007  0 toggle public JSONArray put(int value) {
1008  0 return this.put(Integer.valueOf(value));
1009    }
1010   
1011    /**
1012    * Append an long value. This increases the array's length by one.
1013    *
1014    * @param value
1015    * A long value.
1016    * @return this.
1017    */
 
1018  0 toggle public JSONArray put(long value) {
1019  0 return this.put(Long.valueOf(value));
1020    }
1021   
1022    /**
1023    * Put a value in the JSONArray, where the value will be a JSONObject which
1024    * is produced from a Map.
1025    *
1026    * @param value
1027    * A Map value.
1028    * @return this.
1029    * @throws JSONException
1030    * If a value in the map is non-finite number.
1031    * @throws NullPointerException
1032    * If a key in the map is <code>null</code>
1033    */
 
1034  0 toggle public JSONArray put(Map<?, ?> value) {
1035  0 return this.put(new JSONObject(value));
1036    }
1037   
1038    /**
1039    * Append an object value. This increases the array's length by one.
1040    *
1041    * @param value
1042    * An object value. The value should be a Boolean, Double,
1043    * Integer, JSONArray, JSONObject, Long, or String, or the
1044    * JSONObject.NULL object.
1045    * @return this.
1046    * @throws JSONException
1047    * If the value is non-finite number.
1048    */
 
1049  0 toggle public JSONArray put(Object value) {
1050  0 JSONObject.testValidity(value);
1051  0 this.myArrayList.add(value);
1052  0 return this;
1053    }
1054   
1055    /**
1056    * Put or replace a boolean value in the JSONArray. If the index is greater
1057    * than the length of the JSONArray, then null elements will be added as
1058    * necessary to pad it out.
1059    *
1060    * @param index
1061    * The subscript.
1062    * @param value
1063    * A boolean value.
1064    * @return this.
1065    * @throws JSONException
1066    * If the index is negative.
1067    */
 
1068  0 toggle public JSONArray put(int index, boolean value) throws JSONException {
1069  0 return this.put(index, value ? Boolean.TRUE : Boolean.FALSE);
1070    }
1071   
1072    /**
1073    * Put a value in the JSONArray, where the value will be a JSONArray which
1074    * is produced from a Collection.
1075    *
1076    * @param index
1077    * The subscript.
1078    * @param value
1079    * A Collection value.
1080    * @return this.
1081    * @throws JSONException
1082    * If the index is negative or if the value is non-finite.
1083    */
 
1084  0 toggle public JSONArray put(int index, Collection<?> value) throws JSONException {
1085  0 return this.put(index, new JSONArray(value));
1086    }
1087   
1088    /**
1089    * Put or replace a double value. If the index is greater than the length of
1090    * the JSONArray, then null elements will be added as necessary to pad it
1091    * out.
1092    *
1093    * @param index
1094    * The subscript.
1095    * @param value
1096    * A double value.
1097    * @return this.
1098    * @throws JSONException
1099    * If the index is negative or if the value is non-finite.
1100    */
 
1101  0 toggle public JSONArray put(int index, double value) throws JSONException {
1102  0 return this.put(index, Double.valueOf(value));
1103    }
1104   
1105    /**
1106    * Put or replace a float value. If the index is greater than the length of
1107    * the JSONArray, then null elements will be added as necessary to pad it
1108    * out.
1109    *
1110    * @param index
1111    * The subscript.
1112    * @param value
1113    * A float value.
1114    * @return this.
1115    * @throws JSONException
1116    * If the index is negative or if the value is non-finite.
1117    */
 
1118  0 toggle public JSONArray put(int index, float value) throws JSONException {
1119  0 return this.put(index, Float.valueOf(value));
1120    }
1121   
1122    /**
1123    * Put or replace an int value. If the index is greater than the length of
1124    * the JSONArray, then null elements will be added as necessary to pad it
1125    * out.
1126    *
1127    * @param index
1128    * The subscript.
1129    * @param value
1130    * An int value.
1131    * @return this.
1132    * @throws JSONException
1133    * If the index is negative.
1134    */
 
1135  0 toggle public JSONArray put(int index, int value) throws JSONException {
1136  0 return this.put(index, Integer.valueOf(value));
1137    }
1138   
1139    /**
1140    * Put or replace a long value. If the index is greater than the length of
1141    * the JSONArray, then null elements will be added as necessary to pad it
1142    * out.
1143    *
1144    * @param index
1145    * The subscript.
1146    * @param value
1147    * A long value.
1148    * @return this.
1149    * @throws JSONException
1150    * If the index is negative.
1151    */
 
1152  0 toggle public JSONArray put(int index, long value) throws JSONException {
1153  0 return this.put(index, Long.valueOf(value));
1154    }
1155   
1156    /**
1157    * Put a value in the JSONArray, where the value will be a JSONObject that
1158    * is produced from a Map.
1159    *
1160    * @param index
1161    * The subscript.
1162    * @param value
1163    * The Map value.
1164    * @return this.
1165    * @throws JSONException
1166    * If the index is negative or if the the value is an invalid
1167    * number.
1168    * @throws NullPointerException
1169    * If a key in the map is <code>null</code>
1170    */
 
1171  0 toggle public JSONArray put(int index, Map<?, ?> value) throws JSONException {
1172  0 this.put(index, new JSONObject(value));
1173  0 return this;
1174    }
1175   
1176    /**
1177    * Put or replace an object value in the JSONArray. If the index is greater
1178    * than the length of the JSONArray, then null elements will be added as
1179    * necessary to pad it out.
1180    *
1181    * @param index
1182    * The subscript.
1183    * @param value
1184    * The value to put into the array. The value should be a
1185    * Boolean, Double, Integer, JSONArray, JSONObject, Long, or
1186    * String, or the JSONObject.NULL object.
1187    * @return this.
1188    * @throws JSONException
1189    * If the index is negative or if the the value is an invalid
1190    * number.
1191    */
 
1192  0 toggle public JSONArray put(int index, Object value) throws JSONException {
1193  0 if (index < 0) {
1194  0 throw new JSONException("JSONArray[" + index + "] not found.");
1195    }
1196  0 if (index < this.length()) {
1197  0 JSONObject.testValidity(value);
1198  0 this.myArrayList.set(index, value);
1199  0 return this;
1200    }
1201  0 if(index == this.length()){
1202    // simple append
1203  0 return this.put(value);
1204    }
1205    // if we are inserting past the length, we want to grow the array all at once
1206    // instead of incrementally.
1207  0 this.myArrayList.ensureCapacity(index + 1);
1208  0 while (index != this.length()) {
1209    // we don't need to test validity of NULL objects
1210  0 this.myArrayList.add(JSONObject.NULL);
1211    }
1212  0 return this.put(value);
1213    }
1214   
1215    /**
1216    * Creates a JSONPointer using an initialization string and tries to
1217    * match it to an item within this JSONArray. For example, given a
1218    * JSONArray initialized with this document:
1219    * <pre>
1220    * [
1221    * {"b":"c"}
1222    * ]
1223    * </pre>
1224    * and this JSONPointer string:
1225    * <pre>
1226    * "/0/b"
1227    * </pre>
1228    * Then this method will return the String "c"
1229    * A JSONPointerException may be thrown from code called by this method.
1230    *
1231    * @param jsonPointer string that can be used to create a JSONPointer
1232    * @return the item matched by the JSONPointer, otherwise null
1233    */
 
1234  0 toggle public Object query(String jsonPointer) {
1235  0 return query(new JSONPointer(jsonPointer));
1236    }
1237   
1238    /**
1239    * Uses a uaer initialized JSONPointer and tries to
1240    * match it to an item whithin this JSONArray. For example, given a
1241    * JSONArray initialized with this document:
1242    * <pre>
1243    * [
1244    * {"b":"c"}
1245    * ]
1246    * </pre>
1247    * and this JSONPointer:
1248    * <pre>
1249    * "/0/b"
1250    * </pre>
1251    * Then this method will return the String "c"
1252    * A JSONPointerException may be thrown from code called by this method.
1253    *
1254    * @param jsonPointer string that can be used to create a JSONPointer
1255    * @return the item matched by the JSONPointer, otherwise null
1256    */
 
1257  0 toggle public Object query(JSONPointer jsonPointer) {
1258  0 return jsonPointer.queryFrom(this);
1259    }
1260   
1261    /**
1262    * Queries and returns a value from this object using {@code jsonPointer}, or
1263    * returns null if the query fails due to a missing key.
1264    *
1265    * @param jsonPointer the string representation of the JSON pointer
1266    * @return the queried value or {@code null}
1267    * @throws IllegalArgumentException if {@code jsonPointer} has invalid syntax
1268    */
 
1269  0 toggle public Object optQuery(String jsonPointer) {
1270  0 return optQuery(new JSONPointer(jsonPointer));
1271    }
1272   
1273    /**
1274    * Queries and returns a value from this object using {@code jsonPointer}, or
1275    * returns null if the query fails due to a missing key.
1276    *
1277    * @param jsonPointer The JSON pointer
1278    * @return the queried value or {@code null}
1279    * @throws IllegalArgumentException if {@code jsonPointer} has invalid syntax
1280    */
 
1281  0 toggle public Object optQuery(JSONPointer jsonPointer) {
1282  0 try {
1283  0 return jsonPointer.queryFrom(this);
1284    } catch (JSONPointerException e) {
1285  0 return null;
1286    }
1287    }
1288   
1289    /**
1290    * Remove an index and close the hole.
1291    *
1292    * @param index
1293    * The index of the element to be removed.
1294    * @return The value that was associated with the index, or null if there
1295    * was no value.
1296    */
 
1297  0 toggle public Object remove(int index) {
1298  0 return index >= 0 && index < this.length()
1299    ? this.myArrayList.remove(index)
1300    : null;
1301    }
1302   
1303    /**
1304    * Determine if two JSONArrays are similar.
1305    * They must contain similar sequences.
1306    *
1307    * @param other The other JSONArray
1308    * @return true if they are equal
1309    */
 
1310  0 toggle public boolean similar(Object other) {
1311  0 if (!(other instanceof JSONArray)) {
1312  0 return false;
1313    }
1314  0 int len = this.length();
1315  0 if (len != ((JSONArray)other).length()) {
1316  0 return false;
1317    }
1318  0 for (int i = 0; i < len; i += 1) {
1319  0 Object valueThis = this.myArrayList.get(i);
1320  0 Object valueOther = ((JSONArray)other).myArrayList.get(i);
1321  0 if(valueThis == valueOther) {
1322  0 continue;
1323    }
1324  0 if(valueThis == null) {
1325  0 return false;
1326    }
1327  0 if (valueThis instanceof JSONObject) {
1328  0 if (!((JSONObject)valueThis).similar(valueOther)) {
1329  0 return false;
1330    }
1331  0 } else if (valueThis instanceof JSONArray) {
1332  0 if (!((JSONArray)valueThis).similar(valueOther)) {
1333  0 return false;
1334    }
1335  0 } else if (!valueThis.equals(valueOther)) {
1336  0 return false;
1337    }
1338    }
1339  0 return true;
1340    }
1341   
1342    /**
1343    * Produce a JSONObject by combining a JSONArray of names with the values of
1344    * this JSONArray.
1345    *
1346    * @param names
1347    * A JSONArray containing a list of key strings. These will be
1348    * paired with the values.
1349    * @return A JSONObject, or null if there are no names or if this JSONArray
1350    * has no values.
1351    * @throws JSONException
1352    * If any of the names are null.
1353    */
 
1354  0 toggle public JSONObject toJSONObject(JSONArray names) throws JSONException {
1355  0 if (names == null || names.isEmpty() || this.isEmpty()) {
1356  0 return null;
1357    }
1358  0 JSONObject jo = new JSONObject(names.length());
1359  0 for (int i = 0; i < names.length(); i += 1) {
1360  0 jo.put(names.getString(i), this.opt(i));
1361    }
1362  0 return jo;
1363    }
1364   
1365    /**
1366    * Make a JSON text of this JSONArray. For compactness, no unnecessary
1367    * whitespace is added. If it is not possible to produce a syntactically
1368    * correct JSON text then null will be returned instead. This could occur if
1369    * the array contains an invalid number.
1370    * <p><b>
1371    * Warning: This method assumes that the data structure is acyclical.
1372    * </b>
1373    *
1374    * @return a printable, displayable, transmittable representation of the
1375    * array.
1376    */
 
1377  0 toggle @Override
1378    public String toString() {
1379  0 try {
1380  0 return this.toString(0);
1381    } catch (Exception e) {
1382  0 return null;
1383    }
1384    }
1385   
1386    /**
1387    * Make a pretty-printed JSON text of this JSONArray.
1388    *
1389    * <p>If <code>indentFactor > 0</code> and the {@link JSONArray} has only
1390    * one element, then the array will be output on a single line:
1391    * <pre>{@code [1]}</pre>
1392    *
1393    * <p>If an array has 2 or more elements, then it will be output across
1394    * multiple lines: <pre>{@code
1395    * [
1396    * 1,
1397    * "value 2",
1398    * 3
1399    * ]
1400    * }</pre>
1401    * <p><b>
1402    * Warning: This method assumes that the data structure is acyclical.
1403    * </b>
1404    *
1405    * @param indentFactor
1406    * The number of spaces to add to each level of indentation.
1407    * @return a printable, displayable, transmittable representation of the
1408    * object, beginning with <code>[</code>&nbsp;<small>(left
1409    * bracket)</small> and ending with <code>]</code>
1410    * &nbsp;<small>(right bracket)</small>.
1411    * @throws JSONException
1412    */
 
1413  0 toggle public String toString(int indentFactor) throws JSONException {
1414  0 StringWriter sw = new StringWriter();
1415  0 synchronized (sw.getBuffer()) {
1416  0 return this.write(sw, indentFactor, 0).toString();
1417    }
1418    }
1419   
1420    /**
1421    * Write the contents of the JSONArray as JSON text to a writer. For
1422    * compactness, no whitespace is added.
1423    * <p><b>
1424    * Warning: This method assumes that the data structure is acyclical.
1425    *</b>
1426    *
1427    * @return The writer.
1428    * @throws JSONException
1429    */
 
1430  0 toggle public Writer write(Writer writer) throws JSONException {
1431  0 return this.write(writer, 0, 0);
1432    }
1433   
1434    /**
1435    * Write the contents of the JSONArray as JSON text to a writer.
1436    *
1437    * <p>If <code>indentFactor > 0</code> and the {@link JSONArray} has only
1438    * one element, then the array will be output on a single line:
1439    * <pre>{@code [1]}</pre>
1440    *
1441    * <p>If an array has 2 or more elements, then it will be output across
1442    * multiple lines: <pre>{@code
1443    * [
1444    * 1,
1445    * "value 2",
1446    * 3
1447    * ]
1448    * }</pre>
1449    * <p><b>
1450    * Warning: This method assumes that the data structure is acyclical.
1451    * </b>
1452    *
1453    * @param writer
1454    * Writes the serialized JSON
1455    * @param indentFactor
1456    * The number of spaces to add to each level of indentation.
1457    * @param indent
1458    * The indentation of the top level.
1459    * @return The writer.
1460    * @throws JSONException
1461    */
 
1462  25 toggle public Writer write(Writer writer, int indentFactor, int indent)
1463    throws JSONException {
1464  25 try {
1465  25 boolean commanate = false;
1466  25 int length = this.length();
1467  25 writer.write('[');
1468   
1469  25 if (length == 1) {
1470  5 try {
1471  5 JSONObject.writeValue(writer, this.myArrayList.get(0),
1472    indentFactor, indent);
1473    } catch (Exception e) {
1474  0 throw new JSONException("Unable to write JSONArray value at index: 0", e);
1475    }
1476  20 } else if (length != 0) {
1477  13 final int newindent = indent + indentFactor;
1478   
1479  152 for (int i = 0; i < length; i += 1) {
1480  139 if (commanate) {
1481  126 writer.write(',');
1482    }
1483  139 if (indentFactor > 0) {
1484  0 writer.write('\n');
1485    }
1486  139 JSONObject.indent(writer, newindent);
1487  139 try {
1488  139 JSONObject.writeValue(writer, this.myArrayList.get(i),
1489    indentFactor, newindent);
1490    } catch (Exception e) {
1491  0 throw new JSONException("Unable to write JSONArray value at index: " + i, e);
1492    }
1493  139 commanate = true;
1494    }
1495  13 if (indentFactor > 0) {
1496  0 writer.write('\n');
1497    }
1498  13 JSONObject.indent(writer, indent);
1499    }
1500  25 writer.write(']');
1501  25 return writer;
1502    } catch (IOException e) {
1503  0 throw new JSONException(e);
1504    }
1505    }
1506   
1507    /**
1508    * Returns a java.util.List containing all of the elements in this array.
1509    * If an element in the array is a JSONArray or JSONObject it will also
1510    * be converted.
1511    * <p>
1512    * Warning: This method assumes that the data structure is acyclical.
1513    *
1514    * @return a java.util.List containing the elements of this array
1515    */
 
1516  0 toggle public List<Object> toList() {
1517  0 List<Object> results = new ArrayList<Object>(this.myArrayList.size());
1518  0 for (Object element : this.myArrayList) {
1519  0 if (element == null || JSONObject.NULL.equals(element)) {
1520  0 results.add(null);
1521  0 } else if (element instanceof JSONArray) {
1522  0 results.add(((JSONArray) element).toList());
1523  0 } else if (element instanceof JSONObject) {
1524  0 results.add(((JSONObject) element).toMap());
1525    } else {
1526  0 results.add(element);
1527    }
1528    }
1529  0 return results;
1530    }
1531   
1532    /**
1533    * Check if JSONArray is empty.
1534    *
1535    * @return true if JSONArray is empty, otherwise false.
1536    */
 
1537  0 toggle public boolean isEmpty() {
1538  0 return myArrayList.isEmpty();
1539    }
1540   
1541    }
  • Report generated by OpenClover v 4.4.1 on Thu Aug 13 2020 12:06:48 BST using coverage data from Thu Aug 13 2020 12:06:40 BST.
  • OpenClover is free and open-source software.