polygene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nic...@apache.org
Subject [04/50] [abbrv] zest-qi4j git commit: QI-318 Moved org.json packages from Core API to SPI
Date Fri, 17 Apr 2015 16:05:24 GMT
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>&nbsp;<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>&nbsp;<small>(comma)</small> elision.</li>
+ * <li>Strings may be quoted with <code>'</code>&nbsp;<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>&nbsp;<small>(left bracket)</small>
+     *               and ends with <code>]</code>&nbsp;<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>&nbsp;<small>(left bracket)</small> and ending
+     *         with <code>]</code>&nbsp;<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;
+    }
+}


Mime
View raw message