You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@polygene.apache.org by ni...@apache.org on 2015/04/17 18:05:24 UTC
[04/50] [abbrv] zest-qi4j git commit: QI-318 Moved org.json packages
from Core API to SPI
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/13edb4e0/core/api/src/main/java/org/json/JSONWriter.java
----------------------------------------------------------------------
diff --git a/core/api/src/main/java/org/json/JSONWriter.java b/core/api/src/main/java/org/json/JSONWriter.java
deleted file mode 100644
index c1328c0..0000000
--- a/core/api/src/main/java/org/json/JSONWriter.java
+++ /dev/null
@@ -1,429 +0,0 @@
-/*
- * Copyright (c) 2009, Rickard Öberg. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package org.json;
-
-import java.io.IOException;
-import java.io.Writer;
-
-/*
-Copyright (c) 2006 JSON.org
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-The Software shall be used for Good, not Evil.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-/**
- * JSONWriter provides a quick and convenient way of producing JSON text.
- * The texts produced strictly conform to JSON syntax rules. No whitespace is
- * added, so the results are ready for transmission or storage. Each instance of
- * JSONWriter can produce one JSON text.
- * <p/>
- * A JSONWriter instance provides a <code>value</code> method for appending
- * values to the
- * text, and a <code>key</code>
- * method for adding keys before values in objects. There are <code>array</code>
- * and <code>endArray</code> methods that make and bound array values, and
- * <code>object</code> and <code>endObject</code> methods which make and bound
- * object values. All of these methods return the JSONWriter instance,
- * permitting a cascade style. For example, <pre>
- * new JSONWriter(myWriter)
- * .object()
- * .key("JSON")
- * .value("Hello, World!")
- * .endObject();</pre> which writes <pre>
- * {"JSON":"Hello, World!"}</pre>
- * <p/>
- * The first method called must be <code>array</code> or <code>object</code>.
- * There are no methods for adding commas or colons. JSONWriter adds them for
- * you. Objects and arrays can be nested up to 20 levels deep.
- * <p/>
- * This can sometimes be easier than using a JSONObject to build a string.
- */
-public class JSONWriter
-{
- private static final int maxdepth = 20;
-
- /**
- * The comma flag determines if a comma should be output before the next
- * value.
- */
- private boolean comma;
-
- /**
- * The current mode. Values:
- * 'a' (array),
- * 'd' (done),
- * 'i' (initial),
- * 'k' (key),
- * 'o' (object).
- */
- protected char mode;
-
- /**
- * The object/array stack.
- */
- private JSONObject stack[];
-
- /**
- * The stack top index. A value of 0 indicates that the stack is empty.
- */
- private int top;
-
- /**
- * The writer that will receive the output.
- */
- protected Writer writer;
-
- /**
- * Make a fresh JSONWriter. It can be used to build one JSON text.
- */
- public JSONWriter( Writer w )
- {
- this.comma = false;
- this.mode = 'i';
- this.stack = new JSONObject[ maxdepth ];
- this.top = 0;
- this.writer = w;
- }
-
- /**
- * Append a value.
- *
- * @param s A string value.
- *
- * @return this
- *
- * @throws JSONException If the value is out of sequence.
- */
- private JSONWriter append( String s )
- throws JSONException
- {
- if( s == null )
- {
- throw new JSONException( "Null pointer" );
- }
- if( this.mode == 'o' || this.mode == 'a' )
- {
- try
- {
- if( this.comma && this.mode == 'a' )
- {
- this.writer.write( ',' );
- }
- this.writer.write( s );
- }
- catch( IOException e )
- {
- throw new JSONException( e );
- }
- if( this.mode == 'o' )
- {
- this.mode = 'k';
- }
- this.comma = true;
- return this;
- }
- throw new JSONException( "Value out of sequence." );
- }
-
- /**
- * Begin appending a new array. All values until the balancing
- * <code>endArray</code> will be appended to this array. The
- * <code>endArray</code> method must be called to mark the array's end.
- *
- * @return this
- *
- * @throws JSONException If the nesting is too deep, or if the object is
- * started in the wrong place (for example as a key or after the end of the
- * outermost array or object).
- */
- public JSONWriter array()
- throws JSONException
- {
- if( this.mode == 'i' || this.mode == 'o' || this.mode == 'a' )
- {
- this.push( null );
- this.append( "[" );
- this.comma = false;
- return this;
- }
- throw new JSONException( "Misplaced array." );
- }
-
- /**
- * End something.
- *
- * @param m Mode
- * @param c Closing character
- *
- * @return this
- *
- * @throws JSONException If unbalanced.
- */
- private JSONWriter end( char m, char c )
- throws JSONException
- {
- if( this.mode != m )
- {
- throw new JSONException( m == 'o' ? "Misplaced endObject." :
- "Misplaced endArray." );
- }
- this.pop( m );
- try
- {
- this.writer.write( c );
- }
- catch( IOException e )
- {
- throw new JSONException( e );
- }
- this.comma = true;
- return this;
- }
-
- /**
- * End an array. This method most be called to balance calls to
- * <code>array</code>.
- *
- * @return this
- *
- * @throws JSONException If incorrectly nested.
- */
- public JSONWriter endArray()
- throws JSONException
- {
- return this.end( 'a', ']' );
- }
-
- /**
- * End an object. This method most be called to balance calls to
- * <code>object</code>.
- *
- * @return this
- *
- * @throws JSONException If incorrectly nested.
- */
- public JSONWriter endObject()
- throws JSONException
- {
- return this.end( 'k', '}' );
- }
-
- /**
- * Append a key. The key will be associated with the next value. In an
- * object, every value must be preceded by a key.
- *
- * @param s A key string.
- *
- * @return this
- *
- * @throws JSONException If the key is out of place. For example, keys
- * do not belong in arrays or if the key is null.
- */
- public JSONWriter key( String s )
- throws JSONException
- {
- if( s == null )
- {
- throw new JSONException( "Null key." );
- }
- if( this.mode == 'k' )
- {
- try
- {
- stack[ top - 1 ].putOnce( s, Boolean.TRUE );
- if( this.comma )
- {
- this.writer.write( ',' );
- }
- this.writer.write( JSONObject.quote( s ) );
- this.writer.write( ':' );
- this.comma = false;
- this.mode = 'o';
- return this;
- }
- catch( IOException e )
- {
- throw new JSONException( e );
- }
- }
- throw new JSONException( "Misplaced key." );
- }
-
- /**
- * Begin appending a new object. All keys and values until the balancing
- * <code>endObject</code> will be appended to this object. The
- * <code>endObject</code> method must be called to mark the object's end.
- *
- * @return this
- *
- * @throws JSONException If the nesting is too deep, or if the object is
- * started in the wrong place (for example as a key or after the end of the
- * outermost array or object).
- */
- public JSONWriter object()
- throws JSONException
- {
- if( this.mode == 'i' )
- {
- this.mode = 'o';
- }
- if( this.mode == 'o' || this.mode == 'a' )
- {
- this.append( "{" );
- this.push( new JSONObject() );
- this.comma = false;
- return this;
- }
- throw new JSONException( "Misplaced object." );
- }
-
- /**
- * Pop an array or object scope.
- *
- * @param c The scope to close.
- *
- * @throws JSONException If nesting is wrong.
- */
- private void pop( char c )
- throws JSONException
- {
- if( this.top <= 0 )
- {
- throw new JSONException( "Nesting error." );
- }
- char m = this.stack[ this.top - 1 ] == null ? 'a' : 'k';
- if( m != c )
- {
- throw new JSONException( "Nesting error." );
- }
- this.top -= 1;
- this.mode = this.top == 0 ? 'd' : this.stack[ this.top - 1 ] == null ? 'a' : 'k';
- }
-
- /**
- * Push an array or object scope.
- *
- * @param jo The scope to open.
- *
- * @throws JSONException If nesting is too deep.
- */
- private void push( JSONObject jo )
- throws JSONException
- {
- if( this.top >= maxdepth )
- {
- throw new JSONException( "Nesting too deep." );
- }
- this.stack[ this.top ] = jo;
- this.mode = jo == null ? 'a' : 'k';
- this.top += 1;
- }
-
- /**
- * Append either the value <code>true</code> or the value
- * <code>false</code>.
- *
- * @param b A boolean.
- *
- * @return this
- *
- * @throws JSONException
- */
- public JSONWriter value( boolean b )
- throws JSONException
- {
- return this.append( b ? "true" : "false" );
- }
-
- /**
- * Append a double value.
- *
- * @param d A double.
- *
- * @return this
- *
- * @throws JSONException If the number is not finite.
- */
- public JSONWriter value( double d )
- throws JSONException
- {
- return this.value( new Double( d ) );
- }
-
- /**
- * Append a long value.
- *
- * @param l A long.
- *
- * @return this
- *
- * @throws JSONException
- */
- public JSONWriter value( long l )
- throws JSONException
- {
- return this.append( Long.toString( l ) );
- }
-
- /**
- * Append an object value.
- *
- * @param o The object to append. It can be null, or a Boolean, Number,
- * String, JSONObject, or JSONArray, or an object with a toJSONString()
- * method.
- *
- * @return this
- *
- * @throws JSONException If the value is out of sequence.
- */
- public JSONWriter value( Object o )
- throws JSONException
- {
- return this.append( JSONObject.valueToString( o ) );
- }
-
- /**
- * Append JSON formatted string as-is
- *
- * @param json
- *
- * @return
- *
- * @throws JSONException
- */
- public JSONWriter json( String json )
- throws JSONException
- {
- return this.append( json );
- }
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/13edb4e0/core/api/src/main/java/org/json/package.html
----------------------------------------------------------------------
diff --git a/core/api/src/main/java/org/json/package.html b/core/api/src/main/java/org/json/package.html
deleted file mode 100644
index 6dc0ff7..0000000
--- a/core/api/src/main/java/org/json/package.html
+++ /dev/null
@@ -1,8 +0,0 @@
-<html>
- <body>
- <h2>JSON in Java.</h2>
- <p>
- See <a href="http://www.json.org/java/">json.org/java</a>.
- </p>
- </body>
-</html>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/13edb4e0/core/spi/src/main/java/org/json/JSONArray.java
----------------------------------------------------------------------
diff --git a/core/spi/src/main/java/org/json/JSONArray.java b/core/spi/src/main/java/org/json/JSONArray.java
new file mode 100644
index 0000000..fc29154
--- /dev/null
+++ b/core/spi/src/main/java/org/json/JSONArray.java
@@ -0,0 +1,1195 @@
+package org.json;
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+The Software shall be used for Good, not Evil.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import java.io.IOException;
+import java.io.Writer;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * A JSONArray is an ordered sequence of values. Its external text form is a
+ * string wrapped in square brackets with commas separating the values. The
+ * internal form is an object having <code>get</code> and <code>opt</code>
+ * methods for accessing the values by index, and <code>put</code> methods for
+ * adding or replacing values. The values can be any of these types:
+ * <code>Boolean</code>, <code>JSONArray</code>, <code>JSONObject</code>,
+ * <code>Number</code>, <code>String</code>, or the
+ * <code>JSONObject.NULL object</code>.
+ * <p/>
+ * The constructor can convert a JSON text into a Java object. The
+ * <code>toString</code> method converts to JSON text.
+ * <p/>
+ * A <code>get</code> method returns a value if one can be found, and throws an
+ * exception if one cannot be found. An <code>opt</code> method returns a
+ * default value instead of throwing an exception, and so is useful for
+ * obtaining optional values.
+ * <p/>
+ * The generic <code>get()</code> and <code>opt()</code> methods return an
+ * object which you can cast or query for type. There are also typed
+ * <code>get</code> and <code>opt</code> methods that do type checking and type
+ * coercion for you.
+ * <p/>
+ * The texts produced by the <code>toString</code> methods strictly conform to
+ * JSON syntax rules. The constructors are more forgiving in the texts they will
+ * accept:
+ * <ul>
+ * <li>An extra <code>,</code> <small>(comma)</small> may appear just
+ * before the closing bracket.</li>
+ * <li>The <code>null</code> value will be inserted when there
+ * is <code>,</code> <small>(comma)</small> elision.</li>
+ * <li>Strings may be quoted with <code>'</code> <small>(single
+ * quote)</small>.</li>
+ * <li>Strings do not need to be quoted at all if they do not begin with a quote
+ * or single quote, and if they do not contain leading or trailing spaces,
+ * and if they do not contain any of these characters:
+ * <code>{ } [ ] / \ : , = ; #</code> and if they do not look like numbers
+ * and if they are not the reserved words <code>true</code>,
+ * <code>false</code>, or <code>null</code>.</li>
+ * <li>Values can be separated by <code>;</code> <small>(semicolon)</small> as
+ * well as by <code>,</code> <small>(comma)</small>.</li>
+ * <li>Numbers may have the <code>0-</code> <small>(octal)</small> or
+ * <code>0x-</code> <small>(hex)</small> prefix.</li>
+ * </ul>
+ */
+public final class JSONArray
+{
+
+ /**
+ * The arrayList where the JSONArray's properties are kept.
+ */
+ private ArrayList myArrayList;
+
+ /**
+ * Construct an empty JSONArray.
+ */
+ public JSONArray()
+ {
+ this.myArrayList = new ArrayList();
+ }
+
+ /**
+ * 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();
+ this.myArrayList.add( null );
+ }
+ else
+ {
+ x.back();
+ this.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 '" + Character.valueOf( q ) + "'" );
+ }
+ return;
+ default:
+ throw x.syntaxError( "Expected a ',' or ']'" );
+ }
+ }
+ }
+
+ /**
+ * Construct a JSONArray from a source JSON text.
+ *
+ * @param source A string that begins with
+ * <code>[</code> <small>(left bracket)</small>
+ * and ends with <code>]</code> <small>(right bracket)</small>.
+ *
+ * @throws JSONException If there is a syntax error.
+ */
+ public JSONArray( String source )
+ throws JSONException
+ {
+ this( new JSONTokener( source ) );
+ }
+
+ /**
+ * Construct a JSONArray from a Collection.
+ *
+ * @param collection A Collection.
+ */
+ public JSONArray( Collection collection )
+ {
+ this.myArrayList = ( collection == null ) ?
+ new ArrayList() :
+ new ArrayList( collection );
+ }
+
+ /**
+ * Construct a JSONArray from a collection of beans.
+ * The collection should have Java Beans.
+ *
+ * @throws JSONException If not an array.
+ */
+
+ public JSONArray( Collection collection, boolean includeSuperClass )
+ {
+ this.myArrayList = new ArrayList();
+ if( collection != null )
+ {
+ Iterator iter = collection.iterator();
+ ;
+ while( iter.hasNext() )
+ {
+ Object o = iter.next();
+ if( o instanceof Map )
+ {
+ this.myArrayList.add( new JSONObject( (Map) o, includeSuperClass ) );
+ }
+ else if( !JSONObject.isStandardProperty( o.getClass() ) )
+ {
+ this.myArrayList.add( new JSONObject( o, includeSuperClass ) );
+ }
+ else
+ {
+ this.myArrayList.add( o );
+ }
+ }
+ }
+ }
+
+ /**
+ * Construct a JSONArray from 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.
+ *
+ * @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 )
+ {
+ Object o = Array.get( array, i );
+ if( JSONObject.isStandardProperty( o.getClass() ) )
+ {
+ this.myArrayList.add( o );
+ }
+ else
+ {
+ this.myArrayList.add( new JSONObject( o, includeSuperClass ) );
+ }
+ }
+ }
+ else
+ {
+ throw new JSONException( "JSONArray initial value should be a string or collection or array." );
+ }
+ }
+
+ /**
+ * 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.
+ * 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 subscript
+ *
+ * @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
+ * <code>separator</code> 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( this.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 this.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 : this.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 subscript
+ * @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 subscript
+ *
+ * @return A 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 The 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.
+ *
+ * @return this.
+ *
+ * @throws JSONException if the value is not finite.
+ */
+ 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( Integer.valueOf( 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( Long.valueOf( 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 )
+ {
+ this.myArrayList.add( 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 subscript.
+ * @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 subscript.
+ * @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 subscript.
+ * @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 subscript.
+ * @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, Integer.valueOf( 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 subscript.
+ * @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, Long.valueOf( 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 subscript.
+ * @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 subscript.
+ * @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() )
+ {
+ this.myArrayList.set( index, value );
+ }
+ else
+ {
+ while( index != length() )
+ {
+ put( JSONObject.NULL );
+ }
+ put( value );
+ }
+ return this;
+ }
+
+ /**
+ * Insert 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 subscript.
+ * @param value The value to insert 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 insert( int index, Object value )
+ throws JSONException
+ {
+ JSONObject.testValidity( value );
+ if( index < 0 )
+ {
+ throw new JSONException( "JSONArray[" + index + "] not found." );
+ }
+ if( index < length() )
+ {
+ this.myArrayList.add( index, value );
+ }
+ else
+ {
+ while( index != length() )
+ {
+ put( JSONObject.NULL );
+ }
+ put( value );
+ }
+ return this;
+ }
+
+ /**
+ * Remove a index and close the hole.
+ *
+ * @param index The index of the element to be removed.
+ *
+ * @return The value that was associated with the index,
+ * or null if there was no value.
+ */
+ public Object remove( int index )
+ {
+ Object o = opt( index );
+ this.myArrayList.remove( index );
+ return o;
+ }
+
+ /**
+ * 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 ), this.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.
+ * <p/>
+ * Warning: This method assumes that the data structure is acyclical.
+ *
+ * @return a printable, displayable, transmittable
+ * representation of the array.
+ */
+ public String toString()
+ {
+ try
+ {
+ return '[' + join( "," ) + ']';
+ }
+ catch( Exception e )
+ {
+ return null;
+ }
+ }
+
+ /**
+ * Make a prettyprinted 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 <code>[</code> <small>(left bracket)</small> and ending
+ * with <code>]</code> <small>(right bracket)</small>.
+ *
+ * @throws JSONException
+ */
+ public String toString( int indentFactor )
+ throws JSONException
+ {
+ return toString( indentFactor, 0 );
+ }
+
+ /**
+ * Make a prettyprinted 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
+ */
+ 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( this.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( this.myArrayList.get( i ),
+ indentFactor, newindent ) );
+ }
+ sb.append( '\n' );
+ for( i = 0; i < indent; i += 1 )
+ {
+ sb.append( ' ' );
+ }
+ }
+ sb.append( ']' );
+ return sb.toString();
+ }
+
+ /**
+ * Write the contents of the JSONArray as JSON text to a writer.
+ * For compactness, no whitespace is added.
+ * <p/>
+ * Warning: This method assumes that the data structure is acyclical.
+ *
+ * @return The writer.
+ *
+ * @throws JSONException
+ */
+ 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 = this.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 );
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/13edb4e0/core/spi/src/main/java/org/json/JSONException.java
----------------------------------------------------------------------
diff --git a/core/spi/src/main/java/org/json/JSONException.java b/core/spi/src/main/java/org/json/JSONException.java
new file mode 100644
index 0000000..41f2375
--- /dev/null
+++ b/core/spi/src/main/java/org/json/JSONException.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2009, Rickard Öberg. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.json;
+
+/**
+ * The JSONException is thrown by the JSON.org classes then things are amiss.
+ */
+public class JSONException
+ extends Exception
+{
+ private Throwable cause;
+
+ /**
+ * Constructs a JSONException with an explanatory message.
+ *
+ * @param message Detail about the reason for the exception.
+ */
+ public JSONException( String message )
+ {
+ super( message );
+ }
+
+ public JSONException( Throwable t )
+ {
+ super( t.getMessage() );
+ this.cause = t;
+ }
+
+ public Throwable getCause()
+ {
+ return this.cause;
+ }
+}