src/main/java/org/apache/sling/commons/json/io/JSONRenderer.java - sling-old-svn-mirror - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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.apache.sling.commons.json.io;

 import java.io.IOException;
 import java.io.StringWriter;
 import java.io.Writer;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;

 import org.apache.sling.commons.json.JSONArray;
 import org.apache.sling.commons.json.JSONException;
 import org.apache.sling.commons.json.JSONObject;
 import org.apache.sling.commons.json.JSONString;

 /** Various JSON-to-String primitives, used by other classes
  *  when outputting/formatting JSON.
  *
  *  Streaming variants of some methods are provided.
  *  The existing code in this module is often not streaming, but
  *  we should write newer code using streams, as much as
  *  possible.
  */
 public class JSONRenderer {

     /** Rendering options */
     static public class Options {
         int indent;
         private boolean indentIsPositive;
         int initialIndent;
         boolean arraysForChildren;

         public static final String DEFAULT_CHILDREN_KEY = "__children__";
         public static final String DEFAULT_CHILD_NAME_KEY = "__name__";

         String childrenKey = DEFAULT_CHILDREN_KEY;
         String childNameKey = DEFAULT_CHILD_NAME_KEY;

         /** Clients use JSONRenderer.options() to create objects */
         private Options() {
         }

         Options(Options opt) {
             this.indent = opt.indent;
             this.indentIsPositive = opt.indentIsPositive;
             this.initialIndent = opt.initialIndent;
             this.arraysForChildren = opt.arraysForChildren;
         }

         public Options withIndent(int n) {
             indent = n;
             indentIsPositive = indent > 0;
             return this;
         }

         public Options withInitialIndent(int n) {
             initialIndent = n;
             return this;
         }

         public Options withArraysForChildren(boolean b) {
             arraysForChildren = b;
             return this;
         }

         public Options withChildNameKey(String key) {
             childNameKey = key;
             return this;
         }

         public Options withChildrenKey(String key) {
             childrenKey = key;
             return this;
         }

         boolean hasIndent() {
             return indentIsPositive;
         }
     }

     /** JSONObject that has a name - overrides just what we
      *  need for our rendering purposes.
      */
     static private class NamedJSONObject extends JSONObject {
         final String name;
         final JSONObject jsonObject;
         final String nameKey;
         final List<String> keysWithName;

         NamedJSONObject(String name, JSONObject jsonObject, Options opt) {
             this.name = name;
             this.jsonObject = jsonObject;
             this.nameKey = opt.childNameKey;
             keysWithName = new ArrayList<String>();
             keysWithName.add(nameKey);
             final Iterator<String> it = jsonObject.keys();
             while(it.hasNext()) {
                 keysWithName.add(it.next());
             }
         }

         @Override
         public int length() {
             return keysWithName.size();
         }

         @Override
         public Object get(String key) throws JSONException {
             if(key.equals(nameKey)) {
                 return name;
             }
             return jsonObject.get(key);
         }

         @Override
         public Iterator<String> keys() {
             return keysWithName.iterator();
         }
     }

     /** Return an Options object with default values */
     public Options options() {
         return new Options();
     }

     /** Write N spaces to sb for indentation */
     private void indent(StringBuilder sb, int howMuch) {
         for (int i=0; i < howMuch; i++) {
             sb.append(' ');
         }
     }

     /** Render the supplied JSONObject to a String, in
      *  the simplest possible way.
      */
     public String toString(JSONObject jo) {
         try {
             final Iterator<String> keys = jo.keys();
             final StringBuffer sb = new StringBuffer("{");

             while (keys.hasNext()) {
                 if (sb.length() > 1) {
                     sb.append(',');
                 }
                 String o = keys.next();
                 sb.append(quote(o));
                 sb.append(':');
                 sb.append(valueToString(jo.get(o)));
             }
             sb.append('}');
             return sb.toString();
         } catch (Exception e) {
             return null;
         }
     }

     /** Make a JSON text of the supplied 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(JSONArray ja) {
         try {
             return '[' + join(ja,",") + ']';
         } catch (Exception e) {
             return null;
         }
     }

     /** Quote the supplied string for JSON */
     public String quote(String string) {
         final StringWriter sw = new StringWriter();
         try {
             quote(sw, string);
         } catch(IOException ioex) {
             throw new RuntimeException("IOException in quote()", ioex);
         }
         return sw.toString();
     }

     /** Quote the supplied string for JSON, to the supplied Writer */
     public void quote(Writer w, String string) throws IOException {
         if (string == null || string.length() == 0) {
             w.write("\"\"");
             return;
         }

         char         b;
         char         c = 0;
         int          i;
         int          len = string.length();
         String       t;

         w.write('"');
         for (i = 0; i < len; i += 1) {
             b = c;
             c = string.charAt(i);
             switch (c) {
             case '\\':
             case '"':
                 w.write('\\');
                 w.write(c);
                 break;
             case '/':
                 if (b == '<') {
                     w.write('\\');
                 }
                 w.write(c);
                 break;
             case '\b':
                 w.write("\\b");
                 break;
             case '\t':
                 w.write("\\t");
                 break;
             case '\n':
                 w.write("\\n");
                 break;
             case '\f':
                 w.write("\\f");
                 break;
             case '\r':
                 w.write("\\r");
                 break;
             default:
                 if (c < ' ' || (c >= '\u0080' && c < '\u00a0') ||
                                (c >= '\u2000' && c < '\u2100')) {
                     t = "000" + Integer.toHexString(c);
                     w.write("\\u" + t.substring(t.length() - 4));
                 } else {
                     w.write(c);
                 }
             }
         }
         w.write('"');
     }

     /**
      * Make a JSON text of an Object value. If the object has an
      * value.toJSONString() method, then that method will be used to produce
      * the JSON text. The method is required to produce a strictly
      * conforming text. If the object does not contain a toJSONString
      * method (which is the most common case), then a text will be
      * produced by the rules.
      * <p>
      * Warning: This method assumes that the data structure is acyclical.
      * @param value The value to be serialized.
      * @return a printable, displayable, transmittable
      *  representation of the object, beginning
      *  with <code>{</code>&nbsp;<small>(left brace)</small> and ending
      *  with <code>}</code>&nbsp;<small>(right brace)</small>.
      * @throws JSONException If the value is or contains an invalid number.
      */
     public String valueToString(Object value) throws JSONException {
         // TODO call the other valueToString instead
         if (value == null || value.equals(null)) {
             return "null";
         }
         if (value instanceof JSONString) {
             Object o;
             try {
                 o = ((JSONString)value).toJSONString();
             } catch (Exception e) {
                 throw new JSONException(e);
             }
             if (o instanceof String) {
                 return (String)o;
             }
             throw new JSONException("Bad value from toJSONString: " + o);
         }
         if (value instanceof Number) {
             return numberToString((Number) value);
         }
         if (value instanceof Boolean || value instanceof JSONObject ||
                 value instanceof JSONArray) {
             return value.toString();
         }
         return quote(value.toString());
     }

     /** Make a JSON String of an Object value, with rendering options
      * <p>
      * Warning: This method assumes that the data structure is acyclical.
      * @param value The value to be serialized.
      * @param indentFactor The number of spaces to add to each level of
      *  indentation.
      * @param indent The indentation of the top level.
      * @return a printable, displayable, transmittable
      *  representation of the object, beginning
      *  with <code>{</code>&nbsp;<small>(left brace)</small> and ending
      *  with <code>}</code>&nbsp;<small>(right brace)</small>.
      * @throws JSONException If the object contains an invalid number.
      */
     public String valueToString(Object value, Options opt) throws JSONException {
         if (value == null || value.equals(null)) {
             return "null";
         }
         try {
             if (value instanceof JSONString) {
                 Object o = ((JSONString)value).toJSONString();
                 if (o instanceof String) {
                     return (String)o;
                 }
             }
         } catch (Exception e) {
             /* forget about it */
         }
         if (value instanceof Number) {
             return numberToString((Number) value);
         }
         if (value instanceof Boolean) {
             return value.toString();
         }
         if (value instanceof JSONObject) {
             return prettyPrint((JSONObject)value, opt);
         }
         if (value instanceof JSONArray) {
             return prettyPrint((JSONArray)value, opt);
         }
         return quote(value.toString());

     }

     /**
      * Produce a string from a Number.
      * @param  n A Number
      * @return A String.
      * @throws JSONException If n is a non-finite number.
      */
     public String numberToString(Number n)
             throws JSONException {
         if (n == null) {
             throw new JSONException("Null pointer");
         }
         testNumberValidity(n);

         // Shave off trailing zeros and decimal point, if possible.

         String s = n.toString();
         if (s.indexOf('.') > 0 && s.indexOf('e') < 0 && s.indexOf('E') < 0) {
             while (s.endsWith("0")) {
                 s = s.substring(0, s.length() - 1);
             }
             if (s.endsWith(".")) {
                 s = s.substring(0, s.length() - 1);
             }
         }
         return s;
     }

     /** Decide whether o must be skipped and added to a, when rendering a JSONObject */
     private boolean skipChildObject(JSONArray a, Options  opt, String key, Object value) {
         if(opt.arraysForChildren && (value instanceof JSONObject)) {
             a.put(new NamedJSONObject(key, (JSONObject)value, opt));
             return true;
         }
         return false;
     }

     /**
      * Make a prettyprinted JSON text of this JSONObject.
      * <p>
      * 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 indentation of the top level.
      * @return a printable, displayable, transmittable
      *  representation of the object, beginning
      *  with <code>{</code>&nbsp;<small>(left brace)</small> and ending
      *  with <code>}</code>&nbsp;<small>(right brace)</small>.
      * @throws JSONException If the object contains an invalid number.
      */
     public String prettyPrint(JSONObject jo, Options opt) throws JSONException {
         int n = jo.length();
         if (n == 0) {
             return "{}";
         }
         final JSONArray children = new JSONArray();
         Iterator<String> keys = jo.keys();
         StringBuilder sb = new StringBuilder("{");
         int newindent = opt.initialIndent + opt.indent;
         String o;
         if (n == 1) {
             o = keys.next();
             final Object v = jo.get(o);
             if(!skipChildObject(children, opt, o, v)) {
                 sb.append(quote(o));
                 sb.append(": ");
                 sb.append(valueToString(v, opt));
             }
         } else {
             while (keys.hasNext()) {
                 o = keys.next();
                 final Object v = jo.get(o);
                 if(skipChildObject(children, opt, o, v)) {
                     continue;
                 }
                 if (sb.length() > 1) {
                     sb.append(",\n");
                 } else {
                     sb.append('\n');
                 }
                 indent(sb, newindent);
                 sb.append(quote(o.toString()));
                 sb.append(": ");
                 sb.append(valueToString(v,
                         options().withIndent(opt.indent).withInitialIndent(newindent)));
             }
             if (sb.length() > 1) {
                 sb.append('\n');
                 indent(sb, newindent);
             }
         }

         /** Render children if any were skipped (in "children in arrays" mode) */
         if(children.length() > 0) {
             if (sb.length() > 1) {
                 sb.append(",\n");
             } else {
                 sb.append('\n');
             }
             final Options childOpt = new Options(opt);
             childOpt.withInitialIndent(childOpt.initialIndent + newindent);
             indent(sb, childOpt.initialIndent);
             sb.append(quote(opt.childrenKey)).append(":");
             sb.append(prettyPrint(children, childOpt));
         }

         sb.append('}');
         return sb.toString();
     }

     /** Pretty-print a JSONArray */
     public String prettyPrint(JSONArray ja, Options opt) throws JSONException {
         int len = ja.length();
         if (len == 0) {
             return "[]";
         }
         int i;
         StringBuilder sb = new StringBuilder("[");
         if (len == 1) {
             sb.append(valueToString(ja.get(0), opt));
         } else {
             final int newindent = opt.initialIndent + opt.indent;
             if(opt.hasIndent()) {
                 sb.append('\n');
             }
             for (i = 0; i < len; i += 1) {
                 if (i > 0) {
                     sb.append(',');
                     if(opt.hasIndent()) {
                         sb.append('\n');
                     }
                 }
                 indent(sb, newindent);
                 sb.append(valueToString(ja.get(i), opt));
             }
             if(opt.hasIndent()) {
                 sb.append('\n');
             }
             indent(sb, opt.initialIndent);
         }
         sb.append(']');
         return sb.toString();
     }

     /**
      * Throw an exception if the object is an NaN or infinite number.
      * @param o The object to test.
      * @throws JSONException If o is a non-finite number.
      */
     public void testNumberValidity(Object o) throws JSONException {
         if (o != null) {
             if (o instanceof Double) {
                 if (((Double)o).isInfinite() || ((Double)o).isNaN()) {
                     throw new JSONException(
                         "JSON does not allow non-finite numbers");
                 }
             } else if (o instanceof Float) {
                 if (((Float)o).isInfinite() || ((Float)o).isNaN()) {
                     throw new JSONException(
                         "JSON does not allow non-finite numbers.");
                 }
             }
         }
     }

     /**
      * 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(JSONArray ja, String separator) throws JSONException {
         final int len = ja.length();
         StringBuffer sb = new StringBuffer();

         for (int i = 0; i < len; i += 1) {
             if (i > 0) {
                 sb.append(separator);
             }
             sb.append(JSONObject.valueToString(ja.get(i)));
         }
         return sb.toString();
     }

     /**
      * Write the contents of the supplied JSONObject 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, JSONObject jo) throws JSONException {
        try {
            boolean  b = false;
            Iterator<String> keys = jo.keys();
            writer.write('{');

            while (keys.hasNext()) {
                if (b) {
                    writer.write(',');
                }
                String k = keys.next();
                writer.write(quote(k));
                writer.write(':');
                final Object v = jo.get(k);
                if (v instanceof JSONObject) {
                    ((JSONObject)v).write(writer);
                } else if (v instanceof JSONArray) {
                    ((JSONArray)v).write(writer);
                } else {
                    writer.write(valueToString(v));
                }
                b = true;
            }
            writer.write('}');
            return writer;
        } catch (IOException e) {
            throw new JSONException(e);
        }
     }

     /**
      * Write the contents of the supplied 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, JSONArray ja) throws JSONException {
         try {
             boolean b = false;
             int len = ja.length();

             writer.write('[');

             for (int i = 0; i < len; i += 1) {
                 if (b) {
                     writer.write(',');
                 }
                 final Object v = ja.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);
         }
     }

     /**
      * Produce a string from a double. The string "null" will be returned if
      * the number is not finite.
      * @param  d A double.
      * @return A String.
      */
     public String doubleToString(double d) {
         if (Double.isInfinite(d) || Double.isNaN(d)) {
             return "null";
         }

         // Shave off trailing zeros and decimal point, if possible.

         String s = Double.toString(d);
         if (s.indexOf('.') > 0 && s.indexOf('e') < 0 && s.indexOf('E') < 0) {
             while (s.endsWith("0")) {
                 s = s.substring(0, s.length() - 1);
             }
             if (s.endsWith(".")) {
                 s = s.substring(0, s.length() - 1);
             }
         }
         return s;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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.apache.sling.commons.json.io;

	import java.io.IOException;
	import java.io.StringWriter;
	import java.io.Writer;
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;

	import org.apache.sling.commons.json.JSONArray;
	import org.apache.sling.commons.json.JSONException;
	import org.apache.sling.commons.json.JSONObject;
	import org.apache.sling.commons.json.JSONString;

	/** Various JSON-to-String primitives, used by other classes
	* when outputting/formatting JSON.
	*
	* Streaming variants of some methods are provided.
	* The existing code in this module is often not streaming, but
	* we should write newer code using streams, as much as
	* possible.
	*/
	public class JSONRenderer {

	/** Rendering options */
	static public class Options {
	int indent;
	private boolean indentIsPositive;
	int initialIndent;
	boolean arraysForChildren;

	public static final String DEFAULT_CHILDREN_KEY = "__children__";
	public static final String DEFAULT_CHILD_NAME_KEY = "__name__";

	String childrenKey = DEFAULT_CHILDREN_KEY;
	String childNameKey = DEFAULT_CHILD_NAME_KEY;

	/** Clients use JSONRenderer.options() to create objects */
	private Options() {
	}

	Options(Options opt) {
	this.indent = opt.indent;
	this.indentIsPositive = opt.indentIsPositive;
	this.initialIndent = opt.initialIndent;
	this.arraysForChildren = opt.arraysForChildren;
	}

	public Options withIndent(int n) {
	indent = n;
	indentIsPositive = indent > 0;
	return this;
	}

	public Options withInitialIndent(int n) {
	initialIndent = n;
	return this;
	}

	public Options withArraysForChildren(boolean b) {
	arraysForChildren = b;
	return this;
	}

	public Options withChildNameKey(String key) {
	childNameKey = key;
	return this;
	}

	public Options withChildrenKey(String key) {
	childrenKey = key;
	return this;
	}

	boolean hasIndent() {
	return indentIsPositive;
	}
	}

	/** JSONObject that has a name - overrides just what we
	* need for our rendering purposes.
	*/
	static private class NamedJSONObject extends JSONObject {
	final String name;
	final JSONObject jsonObject;
	final String nameKey;
	final List<String> keysWithName;

	NamedJSONObject(String name, JSONObject jsonObject, Options opt) {
	this.name = name;
	this.jsonObject = jsonObject;
	this.nameKey = opt.childNameKey;
	keysWithName = new ArrayList<String>();
	keysWithName.add(nameKey);
	final Iterator<String> it = jsonObject.keys();
	while(it.hasNext()) {
	keysWithName.add(it.next());
	}
	}

	@Override
	public int length() {
	return keysWithName.size();
	}

	@Override
	public Object get(String key) throws JSONException {
	if(key.equals(nameKey)) {
	return name;
	}
	return jsonObject.get(key);
	}

	@Override
	public Iterator<String> keys() {
	return keysWithName.iterator();
	}
	}

	/** Return an Options object with default values */
	public Options options() {
	return new Options();
	}

	/** Write N spaces to sb for indentation */
	private void indent(StringBuilder sb, int howMuch) {
	for (int i=0; i < howMuch; i++) {
	sb.append(' ');
	}
	}

	/** Render the supplied JSONObject to a String, in
	* the simplest possible way.
	*/
	public String toString(JSONObject jo) {
	try {
	final Iterator<String> keys = jo.keys();
	final StringBuffer sb = new StringBuffer("{");

	while (keys.hasNext()) {
	if (sb.length() > 1) {
	sb.append(',');
	}
	String o = keys.next();
	sb.append(quote(o));
	sb.append(':');
	sb.append(valueToString(jo.get(o)));
	}
	sb.append('}');
	return sb.toString();
	} catch (Exception e) {
	return null;
	}
	}

	/** Make a JSON text of the supplied 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(JSONArray ja) {
	try {
	return '[' + join(ja,",") + ']';
	} catch (Exception e) {
	return null;
	}
	}

	/** Quote the supplied string for JSON */
	public String quote(String string) {
	final StringWriter sw = new StringWriter();
	try {
	quote(sw, string);
	} catch(IOException ioex) {
	throw new RuntimeException("IOException in quote()", ioex);
	}
	return sw.toString();
	}

	/** Quote the supplied string for JSON, to the supplied Writer */
	public void quote(Writer w, String string) throws IOException {
	if (string == null \|\| string.length() == 0) {
	w.write("\"\"");
	return;
	}

	char b;
	char c = 0;
	int i;
	int len = string.length();
	String t;

	w.write('"');
	for (i = 0; i < len; i += 1) {
	b = c;
	c = string.charAt(i);
	switch (c) {
	case '\\':
	case '"':
	w.write('\\');
	w.write(c);
	break;
	case '/':
	if (b == '<') {
	w.write('\\');
	}
	w.write(c);
	break;
	case '\b':
	w.write("\\b");
	break;
	case '\t':
	w.write("\\t");
	break;
	case '\n':
	w.write("\\n");
	break;
	case '\f':
	w.write("\\f");
	break;
	case '\r':
	w.write("\\r");
	break;
	default:
	if (c < ' ' \|\| (c >= '\u0080' && c < '\u00a0') \|\|
	(c >= '\u2000' && c < '\u2100')) {
	t = "000" + Integer.toHexString(c);
	w.write("\\u" + t.substring(t.length() - 4));
	} else {
	w.write(c);
	}
	}
	}
	w.write('"');
	}

	/**
	* Make a JSON text of an Object value. If the object has an
	* value.toJSONString() method, then that method will be used to produce
	* the JSON text. The method is required to produce a strictly
	* conforming text. If the object does not contain a toJSONString
	* method (which is the most common case), then a text will be
	* produced by the rules.
	* <p>
	* Warning: This method assumes that the data structure is acyclical.
	* @param value The value to be serialized.
	* @return a printable, displayable, transmittable
	* representation of the object, beginning
	* with <code>{</code> <small>(left brace)</small> and ending
	* with <code>}</code> <small>(right brace)</small>.
	* @throws JSONException If the value is or contains an invalid number.
	*/
	public String valueToString(Object value) throws JSONException {
	// TODO call the other valueToString instead
	if (value == null \|\| value.equals(null)) {
	return "null";
	}
	if (value instanceof JSONString) {
	Object o;
	try {
	o = ((JSONString)value).toJSONString();
	} catch (Exception e) {
	throw new JSONException(e);
	}
	if (o instanceof String) {
	return (String)o;
	}
	throw new JSONException("Bad value from toJSONString: " + o);
	}
	if (value instanceof Number) {
	return numberToString((Number) value);
	}
	if (value instanceof Boolean \|\| value instanceof JSONObject \|\|
	value instanceof JSONArray) {
	return value.toString();
	}
	return quote(value.toString());
	}

	/** Make a JSON String of an Object value, with rendering options
	* <p>
	* Warning: This method assumes that the data structure is acyclical.
	* @param value The value to be serialized.
	* @param indentFactor The number of spaces to add to each level of
	* indentation.
	* @param indent The indentation of the top level.
	* @return a printable, displayable, transmittable
	* representation of the object, beginning
	* with <code>{</code> <small>(left brace)</small> and ending
	* with <code>}</code> <small>(right brace)</small>.
	* @throws JSONException If the object contains an invalid number.
	*/
	public String valueToString(Object value, Options opt) throws JSONException {
	if (value == null \|\| value.equals(null)) {
	return "null";
	}
	try {
	if (value instanceof JSONString) {
	Object o = ((JSONString)value).toJSONString();
	if (o instanceof String) {
	return (String)o;
	}
	}
	} catch (Exception e) {
	/* forget about it */
	}
	if (value instanceof Number) {
	return numberToString((Number) value);
	}
	if (value instanceof Boolean) {
	return value.toString();
	}
	if (value instanceof JSONObject) {
	return prettyPrint((JSONObject)value, opt);
	}
	if (value instanceof JSONArray) {
	return prettyPrint((JSONArray)value, opt);
	}
	return quote(value.toString());

	}

	/**
	* Produce a string from a Number.
	* @param n A Number
	* @return A String.
	* @throws JSONException If n is a non-finite number.
	*/
	public String numberToString(Number n)
	throws JSONException {
	if (n == null) {
	throw new JSONException("Null pointer");
	}
	testNumberValidity(n);

	// Shave off trailing zeros and decimal point, if possible.

	String s = n.toString();
	if (s.indexOf('.') > 0 && s.indexOf('e') < 0 && s.indexOf('E') < 0) {
	while (s.endsWith("0")) {
	s = s.substring(0, s.length() - 1);
	}
	if (s.endsWith(".")) {
	s = s.substring(0, s.length() - 1);
	}
	}
	return s;
	}

	/** Decide whether o must be skipped and added to a, when rendering a JSONObject */
	private boolean skipChildObject(JSONArray a, Options opt, String key, Object value) {
	if(opt.arraysForChildren && (value instanceof JSONObject)) {
	a.put(new NamedJSONObject(key, (JSONObject)value, opt));
	return true;
	}
	return false;
	}

	/**
	* Make a prettyprinted JSON text of this JSONObject.
	* <p>
	* 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 indentation of the top level.
	* @return a printable, displayable, transmittable
	* representation of the object, beginning
	* with <code>{</code> <small>(left brace)</small> and ending
	* with <code>}</code> <small>(right brace)</small>.
	* @throws JSONException If the object contains an invalid number.
	*/
	public String prettyPrint(JSONObject jo, Options opt) throws JSONException {
	int n = jo.length();
	if (n == 0) {
	return "{}";
	}
	final JSONArray children = new JSONArray();
	Iterator<String> keys = jo.keys();
	StringBuilder sb = new StringBuilder("{");
	int newindent = opt.initialIndent + opt.indent;
	String o;
	if (n == 1) {
	o = keys.next();
	final Object v = jo.get(o);
	if(!skipChildObject(children, opt, o, v)) {
	sb.append(quote(o));
	sb.append(": ");
	sb.append(valueToString(v, opt));
	}
	} else {
	while (keys.hasNext()) {
	o = keys.next();
	final Object v = jo.get(o);
	if(skipChildObject(children, opt, o, v)) {
	continue;
	}
	if (sb.length() > 1) {
	sb.append(",\n");
	} else {
	sb.append('\n');
	}
	indent(sb, newindent);
	sb.append(quote(o.toString()));
	sb.append(": ");
	sb.append(valueToString(v,
	options().withIndent(opt.indent).withInitialIndent(newindent)));
	}
	if (sb.length() > 1) {
	sb.append('\n');
	indent(sb, newindent);
	}
	}

	/** Render children if any were skipped (in "children in arrays" mode) */
	if(children.length() > 0) {
	if (sb.length() > 1) {
	sb.append(",\n");
	} else {
	sb.append('\n');
	}
	final Options childOpt = new Options(opt);
	childOpt.withInitialIndent(childOpt.initialIndent + newindent);
	indent(sb, childOpt.initialIndent);
	sb.append(quote(opt.childrenKey)).append(":");
	sb.append(prettyPrint(children, childOpt));
	}

	sb.append('}');
	return sb.toString();
	}

	/** Pretty-print a JSONArray */
	public String prettyPrint(JSONArray ja, Options opt) throws JSONException {
	int len = ja.length();
	if (len == 0) {
	return "[]";
	}
	int i;
	StringBuilder sb = new StringBuilder("[");
	if (len == 1) {
	sb.append(valueToString(ja.get(0), opt));
	} else {
	final int newindent = opt.initialIndent + opt.indent;
	if(opt.hasIndent()) {
	sb.append('\n');
	}
	for (i = 0; i < len; i += 1) {
	if (i > 0) {
	sb.append(',');
	if(opt.hasIndent()) {
	sb.append('\n');
	}
	}
	indent(sb, newindent);
	sb.append(valueToString(ja.get(i), opt));
	}
	if(opt.hasIndent()) {
	sb.append('\n');
	}
	indent(sb, opt.initialIndent);
	}
	sb.append(']');
	return sb.toString();
	}

	/**
	* Throw an exception if the object is an NaN or infinite number.
	* @param o The object to test.
	* @throws JSONException If o is a non-finite number.
	*/
	public void testNumberValidity(Object o) throws JSONException {
	if (o != null) {
	if (o instanceof Double) {
	if (((Double)o).isInfinite() \|\| ((Double)o).isNaN()) {
	throw new JSONException(
	"JSON does not allow non-finite numbers");
	}
	} else if (o instanceof Float) {
	if (((Float)o).isInfinite() \|\| ((Float)o).isNaN()) {
	throw new JSONException(
	"JSON does not allow non-finite numbers.");
	}
	}
	}
	}

	/**
	* 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(JSONArray ja, String separator) throws JSONException {
	final int len = ja.length();
	StringBuffer sb = new StringBuffer();

	for (int i = 0; i < len; i += 1) {
	if (i > 0) {
	sb.append(separator);
	}
	sb.append(JSONObject.valueToString(ja.get(i)));
	}
	return sb.toString();
	}

	/**
	* Write the contents of the supplied JSONObject 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, JSONObject jo) throws JSONException {
	try {
	boolean b = false;
	Iterator<String> keys = jo.keys();
	writer.write('{');

	while (keys.hasNext()) {
	if (b) {
	writer.write(',');
	}
	String k = keys.next();
	writer.write(quote(k));
	writer.write(':');
	final Object v = jo.get(k);
	if (v instanceof JSONObject) {
	((JSONObject)v).write(writer);
	} else if (v instanceof JSONArray) {
	((JSONArray)v).write(writer);
	} else {
	writer.write(valueToString(v));
	}
	b = true;
	}
	writer.write('}');
	return writer;
	} catch (IOException e) {
	throw new JSONException(e);
	}
	}

	/**
	* Write the contents of the supplied 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, JSONArray ja) throws JSONException {
	try {
	boolean b = false;
	int len = ja.length();

	writer.write('[');

	for (int i = 0; i < len; i += 1) {
	if (b) {
	writer.write(',');
	}
	final Object v = ja.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);
	}
	}

	/**
	* Produce a string from a double. The string "null" will be returned if
	* the number is not finite.
	* @param d A double.
	* @return A String.
	*/
	public String doubleToString(double d) {
	if (Double.isInfinite(d) \|\| Double.isNaN(d)) {
	return "null";
	}

	// Shave off trailing zeros and decimal point, if possible.

	String s = Double.toString(d);
	if (s.indexOf('.') > 0 && s.indexOf('e') < 0 && s.indexOf('E') < 0) {
	while (s.endsWith("0")) {
	s = s.substring(0, s.length() - 1);
	}
	if (s.endsWith(".")) {
	s = s.substring(0, s.length() - 1);
	}
	}
	return s;
	}
	}