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; + } +}
