libcore/json/src/rewrite/java/org/json/JSONStringer.java - platform/dalvik - Git at Google

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * 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.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

 // Note: this class was written without inspecting the non-free org.json sourcecode.

 /**
  *
  */
 public class JSONStringer {

     /** The output data, containing at most one top-level array or object. */
     final StringBuilder out = new StringBuilder();

     /**
      * Lexical scoping elements within this stringer, necessary to insert the
      * appropriate separator characters (ie. commas and colons) and to detect
      * nesting errors.
      */
     enum Scope {

         /**
          * An array with no elements requires no separators or newlines before
          * it is closed.
          */
         EMPTY_ARRAY,

         /**
          * A array with at least one value requires a comma and newline before
          * the next element.
          */
         NONEMPTY_ARRAY,

         /**
          * An object with no keys or values requires no separators or newlines
          * before it is closed.
          */
         EMPTY_OBJECT,

         /**
          * An object whose most recent element is a key. The next element must
          * be a value.
          */
         DANGLING_KEY,

         /**
          * An object with at least one name/value pair requires a comma and
          * newline before the next element.
          */
         NONEMPTY_OBJECT,

         /**
          * A special bracketless array needed by JSONStringer.join() and
          * JSONObject.quote() only. Not used for JSON encoding.
          */
         NULL,
     }

     /**
      * Unlike the original implementation, this stack isn't limited to 20
      * levels of nesting.
      */
     private final List<Scope> stack = new ArrayList<Scope>();

     /**
      * A string containing a full set of spaces for a single level of
      * indentation, or null for no pretty printing.
      */
     private final String indent;

     public JSONStringer() {
         indent = null;
     }

     JSONStringer(int indentSpaces) {
         char[] indentChars = new char[indentSpaces];
         Arrays.fill(indentChars, ' ');
         indent = new String(indentChars);
     }

     public JSONStringer array() throws JSONException {
         return open(Scope.EMPTY_ARRAY, "[");
     }

     public JSONStringer endArray() throws JSONException {
         return close(Scope.EMPTY_ARRAY, Scope.NONEMPTY_ARRAY, "]");
     }

     public JSONStringer object() throws JSONException {
         return open(Scope.EMPTY_OBJECT, "{");
     }

     public JSONStringer endObject() throws JSONException {
         return close(Scope.EMPTY_OBJECT, Scope.NONEMPTY_OBJECT, "}");
     }

     /**
      * Enters a new scope by appending any necessary whitespace and the given
      * bracket.
      */
     JSONStringer open(Scope empty, String openBracket) throws JSONException {
         if (stack.isEmpty() && out.length() > 0) {
             throw new JSONException("Nesting problem: multiple top-level roots");
         }
         beforeValue();
         stack.add(empty);
         out.append(openBracket);
         return this;
     }

     /**
      * Closes the current scope by appending any necessary whitespace and the
      * given bracket.
      */
     JSONStringer close(Scope empty, Scope nonempty, String closeBracket) throws JSONException {
         Scope context = peek();
         if (context != nonempty && context != empty) {
             throw new JSONException("Nesting problem");
         }

         stack.remove(stack.size() - 1);
         if (context == nonempty) {
             newline();
         }
         out.append(closeBracket);
         return this;
     }

     /**
      * Returns the value on the top of the stack.
      */
     private Scope peek() throws JSONException {
         if (stack.isEmpty()) {
             throw new JSONException("Nesting problem");
         }
         return stack.get(stack.size() - 1);
     }

     /**
      * Replace the value on the top of the stack with the given value.
      */
     private void replaceTop(Scope topOfStack) {
         stack.set(stack.size() - 1, topOfStack);
     }

     public JSONStringer value(Object value) throws JSONException {
         if (stack.isEmpty()) {
             throw new JSONException("Nesting problem");
         }

         if (value instanceof JSONArray) {
             ((JSONArray) value).writeTo(this);
             return this;

         } else if (value instanceof JSONObject) {
             ((JSONObject) value).writeTo(this);
             return this;
         }

         beforeValue();

         if (value == null
                 || value instanceof Boolean
                 || value == JSONObject.NULL) {
             out.append(value);

         } else if (value instanceof Number) {
             out.append(JSONObject.numberToString((Number) value));

         } else {
             string(value.toString());
         }

         return this;
     }

     public JSONStringer value(boolean value) throws JSONException {
         if (stack.isEmpty()) {
             throw new JSONException("Nesting problem");
         }
         beforeValue();
         out.append(value);
         return this;
     }

     public JSONStringer value(double value) throws JSONException {
         if (stack.isEmpty()) {
             throw new JSONException("Nesting problem");
         }
         beforeValue();
         out.append(JSONObject.numberToString(value));
         return this;
     }

     public JSONStringer value(long value) throws JSONException {
         if (stack.isEmpty()) {
             throw new JSONException("Nesting problem");
         }
         beforeValue();
         out.append(value);
         return this;
     }

     private void string(String value) {
         out.append("\"");
         for (int i = 0, length = value.length(); i < length; i++) {
             char c = value.charAt(i);

             /*
              * From RFC 4627, "All Unicode characters may be placed within the
              * quotation marks except for the characters that must be escaped:
              * quotation mark, reverse solidus, and the control characters
              * (U+0000 through U+001F)."
              */
             switch (c) {
                 case '"':
                 case '\\':
                 case '/':
                     out.append('\\').append(c);
                     break;

                 case '\t':
                     out.append("\\t");
                     break;

                 case '\b':
                     out.append("\\b");
                     break;

                 case '\n':
                     out.append("\\n");
                     break;

                 case '\r':
                     out.append("\\r");
                     break;

                 case '\f':
                     out.append("\\f");
                     break;

                 default:
                     if (c <= 0x1F) {
                         out.append(String.format("\\u%04x", (int) c));
                     } else {
                         out.append(c);
                     }
                     break;
             }

         }
         out.append("\"");
     }

     private void newline() {
         if (indent == null) {
             return;
         }

         out.append("\n");
         for (int i = 0; i < stack.size(); i++) {
             out.append(indent);
         }
     }

     public JSONStringer key(String name) throws JSONException {
         if (name == null) {
             throw new JSONException("Names must be non-null");
         }
         beforeKey();
         string(name);
         return this;
     }

     /**
      * Inserts any necessary separators and whitespace before a name. Also
      * adjusts the stack to expect the key's value.
      */
     private void beforeKey() throws JSONException {
         Scope context = peek();
         if (context == Scope.NONEMPTY_OBJECT) { // first in object
             out.append(',');
         } else if (context != Scope.EMPTY_OBJECT) { // not in an object!
             throw new JSONException("Nesting problem");
         }
         newline();
         replaceTop(Scope.DANGLING_KEY);
     }

     /**
      * Inserts any necessary separators and whitespace before a literal value,
      * inline array, or inline object. Also adjusts the stack to expect either a
      * closing bracket or another element.
      */
     private void beforeValue() throws JSONException {
         if (stack.isEmpty()) {
             return;
         }

         Scope context = peek();
         if (context == Scope.EMPTY_ARRAY) { // first in array
             replaceTop(Scope.NONEMPTY_ARRAY);
             newline();
         } else if (context == Scope.NONEMPTY_ARRAY) { // another in array
             out.append(',');
             newline();
         } else if (context == Scope.DANGLING_KEY) { // value for key
             out.append(indent == null ? ":" : ": ");
             replaceTop(Scope.NONEMPTY_OBJECT);
         } else if (context != Scope.NULL) {
             throw new JSONException("Nesting problem");
         }
     }

     /**
      * Although it contradicts the general contract of {@link Object#toString},
      * this method returns null if the stringer contains no data.
      */
     @Override public String toString() {
         return out.length() == 0 ? null : out.toString();
     }
 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* 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.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;

	// Note: this class was written without inspecting the non-free org.json sourcecode.

	/**
	*
	*/
	public class JSONStringer {

	/** The output data, containing at most one top-level array or object. */
	final StringBuilder out = new StringBuilder();

	/**
	* Lexical scoping elements within this stringer, necessary to insert the
	* appropriate separator characters (ie. commas and colons) and to detect
	* nesting errors.
	*/
	enum Scope {

	/**
	* An array with no elements requires no separators or newlines before
	* it is closed.
	*/
	EMPTY_ARRAY,

	/**
	* A array with at least one value requires a comma and newline before
	* the next element.
	*/
	NONEMPTY_ARRAY,

	/**
	* An object with no keys or values requires no separators or newlines
	* before it is closed.
	*/
	EMPTY_OBJECT,

	/**
	* An object whose most recent element is a key. The next element must
	* be a value.
	*/
	DANGLING_KEY,

	/**
	* An object with at least one name/value pair requires a comma and
	* newline before the next element.
	*/
	NONEMPTY_OBJECT,

	/**
	* A special bracketless array needed by JSONStringer.join() and
	* JSONObject.quote() only. Not used for JSON encoding.
	*/
	NULL,
	}

	/**
	* Unlike the original implementation, this stack isn't limited to 20
	* levels of nesting.
	*/
	private final List<Scope> stack = new ArrayList<Scope>();

	/**
	* A string containing a full set of spaces for a single level of
	* indentation, or null for no pretty printing.
	*/
	private final String indent;

	public JSONStringer() {
	indent = null;
	}

	JSONStringer(int indentSpaces) {
	char[] indentChars = new char[indentSpaces];
	Arrays.fill(indentChars, ' ');
	indent = new String(indentChars);
	}

	public JSONStringer array() throws JSONException {
	return open(Scope.EMPTY_ARRAY, "[");
	}

	public JSONStringer endArray() throws JSONException {
	return close(Scope.EMPTY_ARRAY, Scope.NONEMPTY_ARRAY, "]");
	}

	public JSONStringer object() throws JSONException {
	return open(Scope.EMPTY_OBJECT, "{");
	}

	public JSONStringer endObject() throws JSONException {
	return close(Scope.EMPTY_OBJECT, Scope.NONEMPTY_OBJECT, "}");
	}

	/**
	* Enters a new scope by appending any necessary whitespace and the given
	* bracket.
	*/
	JSONStringer open(Scope empty, String openBracket) throws JSONException {
	if (stack.isEmpty() && out.length() > 0) {
	throw new JSONException("Nesting problem: multiple top-level roots");
	}
	beforeValue();
	stack.add(empty);
	out.append(openBracket);
	return this;
	}

	/**
	* Closes the current scope by appending any necessary whitespace and the
	* given bracket.
	*/
	JSONStringer close(Scope empty, Scope nonempty, String closeBracket) throws JSONException {
	Scope context = peek();
	if (context != nonempty && context != empty) {
	throw new JSONException("Nesting problem");
	}

	stack.remove(stack.size() - 1);
	if (context == nonempty) {
	newline();
	}
	out.append(closeBracket);
	return this;
	}

	/**
	* Returns the value on the top of the stack.
	*/
	private Scope peek() throws JSONException {
	if (stack.isEmpty()) {
	throw new JSONException("Nesting problem");
	}
	return stack.get(stack.size() - 1);
	}

	/**
	* Replace the value on the top of the stack with the given value.
	*/
	private void replaceTop(Scope topOfStack) {
	stack.set(stack.size() - 1, topOfStack);
	}

	public JSONStringer value(Object value) throws JSONException {
	if (stack.isEmpty()) {
	throw new JSONException("Nesting problem");
	}

	if (value instanceof JSONArray) {
	((JSONArray) value).writeTo(this);
	return this;

	} else if (value instanceof JSONObject) {
	((JSONObject) value).writeTo(this);
	return this;
	}

	beforeValue();

	if (value == null
	\|\| value instanceof Boolean
	\|\| value == JSONObject.NULL) {
	out.append(value);

	} else if (value instanceof Number) {
	out.append(JSONObject.numberToString((Number) value));

	} else {
	string(value.toString());
	}

	return this;
	}

	public JSONStringer value(boolean value) throws JSONException {
	if (stack.isEmpty()) {
	throw new JSONException("Nesting problem");
	}
	beforeValue();
	out.append(value);
	return this;
	}

	public JSONStringer value(double value) throws JSONException {
	if (stack.isEmpty()) {
	throw new JSONException("Nesting problem");
	}
	beforeValue();
	out.append(JSONObject.numberToString(value));
	return this;
	}

	public JSONStringer value(long value) throws JSONException {
	if (stack.isEmpty()) {
	throw new JSONException("Nesting problem");
	}
	beforeValue();
	out.append(value);
	return this;
	}

	private void string(String value) {
	out.append("\"");
	for (int i = 0, length = value.length(); i < length; i++) {
	char c = value.charAt(i);

	/*
	* From RFC 4627, "All Unicode characters may be placed within the
	* quotation marks except for the characters that must be escaped:
	* quotation mark, reverse solidus, and the control characters
	* (U+0000 through U+001F)."
	*/
	switch (c) {
	case '"':
	case '\\':
	case '/':
	out.append('\\').append(c);
	break;

	case '\t':
	out.append("\\t");
	break;

	case '\b':
	out.append("\\b");
	break;

	case '\n':
	out.append("\\n");
	break;

	case '\r':
	out.append("\\r");
	break;

	case '\f':
	out.append("\\f");
	break;

	default:
	if (c <= 0x1F) {
	out.append(String.format("\\u%04x", (int) c));
	} else {
	out.append(c);
	}
	break;
	}

	}
	out.append("\"");
	}

	private void newline() {
	if (indent == null) {
	return;
	}

	out.append("\n");
	for (int i = 0; i < stack.size(); i++) {
	out.append(indent);
	}
	}

	public JSONStringer key(String name) throws JSONException {
	if (name == null) {
	throw new JSONException("Names must be non-null");
	}
	beforeKey();
	string(name);
	return this;
	}

	/**
	* Inserts any necessary separators and whitespace before a name. Also
	* adjusts the stack to expect the key's value.
	*/
	private void beforeKey() throws JSONException {
	Scope context = peek();
	if (context == Scope.NONEMPTY_OBJECT) { // first in object
	out.append(',');
	} else if (context != Scope.EMPTY_OBJECT) { // not in an object!
	throw new JSONException("Nesting problem");
	}
	newline();
	replaceTop(Scope.DANGLING_KEY);
	}

	/**
	* Inserts any necessary separators and whitespace before a literal value,
	* inline array, or inline object. Also adjusts the stack to expect either a
	* closing bracket or another element.
	*/
	private void beforeValue() throws JSONException {
	if (stack.isEmpty()) {
	return;
	}

	Scope context = peek();
	if (context == Scope.EMPTY_ARRAY) { // first in array
	replaceTop(Scope.NONEMPTY_ARRAY);
	newline();
	} else if (context == Scope.NONEMPTY_ARRAY) { // another in array
	out.append(',');
	newline();
	} else if (context == Scope.DANGLING_KEY) { // value for key
	out.append(indent == null ? ":" : ": ");
	replaceTop(Scope.NONEMPTY_OBJECT);
	} else if (context != Scope.NULL) {
	throw new JSONException("Nesting problem");
	}
	}

	/**
	* Although it contradicts the general contract of {@link Object#toString},
	* this method returns null if the stringer contains no data.
	*/
	@Override public String toString() {
	return out.length() == 0 ? null : out.toString();
	}
	}