/*
|
* Copyright (C) 2010 Google Inc.
|
*
|
* 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 cn.emay.sdk.util.json.gson.stream;
|
|
import static cn.emay.sdk.util.json.gson.stream.JsonScope.DANGLING_NAME;
|
import static cn.emay.sdk.util.json.gson.stream.JsonScope.EMPTY_ARRAY;
|
import static cn.emay.sdk.util.json.gson.stream.JsonScope.EMPTY_DOCUMENT;
|
import static cn.emay.sdk.util.json.gson.stream.JsonScope.EMPTY_OBJECT;
|
import static cn.emay.sdk.util.json.gson.stream.JsonScope.NONEMPTY_ARRAY;
|
import static cn.emay.sdk.util.json.gson.stream.JsonScope.NONEMPTY_DOCUMENT;
|
import static cn.emay.sdk.util.json.gson.stream.JsonScope.NONEMPTY_OBJECT;
|
|
import java.io.Closeable;
|
import java.io.Flushable;
|
import java.io.IOException;
|
import java.io.Writer;
|
|
/**
|
* Writes a JSON (<a href="http://www.ietf.org/rfc/rfc7159.txt">RFC 7159</a>)
|
* encoded value to a stream, one token at a time. The stream includes both
|
* literal values (strings, numbers, booleans and nulls) as well as the begin
|
* and end delimiters of objects and arrays.
|
*
|
* <h3>Encoding JSON</h3> To encode your data as JSON, create a new
|
* {@code JsonWriter}. Each JSON document must contain one top-level array or
|
* object. Call methods on the writer as you walk the structure's contents,
|
* nesting arrays and objects as necessary:
|
* <ul>
|
* <li>To write <strong>arrays</strong>, first call {@link #beginArray()}. Write
|
* each of the array's elements with the appropriate {@link #value} methods or
|
* by nesting other arrays and objects. Finally close the array using
|
* {@link #endArray()}.
|
* <li>To write <strong>objects</strong>, first call {@link #beginObject()}.
|
* Write each of the object's properties by alternating calls to {@link #name}
|
* with the property's value. Write property values with the appropriate
|
* {@link #value} method or by nesting other objects or arrays. Finally close
|
* the object using {@link #endObject()}.
|
* </ul>
|
*
|
* <h3>Example</h3> Suppose we'd like to encode a stream of messages such as the
|
* following:
|
*
|
* <pre>
|
* {@code
|
* [
|
* {
|
* "id": 912345678901,
|
* "text": "How do I stream JSON in Java?",
|
* "geo": null,
|
* "user": {
|
* "name": "json_newb",
|
* "followers_count": 41
|
* }
|
* },
|
* {
|
* "id": 912345678902,
|
* "text": "@json_newb just use JsonWriter!",
|
* "geo": [50.454722, -104.606667],
|
* "user": {
|
* "name": "jesse",
|
* "followers_count": 2
|
* }
|
* }
|
* ]}
|
* </pre>
|
*
|
* This code encodes the above structure:
|
*
|
* <pre>
|
* {@code
|
* public void writeJsonStream(OutputStream out, List<Message> messages) throws IOException {
|
* JsonWriter writer = new JsonWriter(new OutputStreamWriter(out, "UTF-8"));
|
* writer.setIndent(" ");
|
* writeMessagesArray(writer, messages);
|
* writer.close();
|
* }
|
*
|
* public void writeMessagesArray(JsonWriter writer, List<Message> messages) throws IOException {
|
* writer.beginArray();
|
* for (Message message : messages) {
|
* writeMessage(writer, message);
|
* }
|
* writer.endArray();
|
* }
|
*
|
* public void writeMessage(JsonWriter writer, Message message) throws IOException {
|
* writer.beginObject();
|
* writer.name("id").value(message.getId());
|
* writer.name("text").value(message.getText());
|
* if (message.getGeo() != null) {
|
* writer.name("geo");
|
* writeDoublesArray(writer, message.getGeo());
|
* } else {
|
* writer.name("geo").nullValue();
|
* }
|
* writer.name("user");
|
* writeUser(writer, message.getUser());
|
* writer.endObject();
|
* }
|
*
|
* public void writeUser(JsonWriter writer, User user) throws IOException {
|
* writer.beginObject();
|
* writer.name("name").value(user.getName());
|
* writer.name("followers_count").value(user.getFollowersCount());
|
* writer.endObject();
|
* }
|
*
|
* public void writeDoublesArray(JsonWriter writer, List<Double> doubles) throws IOException {
|
* writer.beginArray();
|
* for (Double value : doubles) {
|
* writer.value(value);
|
* }
|
* writer.endArray();
|
* }}
|
* </pre>
|
*
|
* <p>
|
* Each {@code JsonWriter} may be used to write a single JSON stream. Instances
|
* of this class are not thread safe. Calls that would result in a malformed
|
* JSON string will fail with an {@link IllegalStateException}.
|
*
|
* @author Jesse Wilson
|
* @since 1.6
|
*/
|
public class JsonWriter implements Closeable, Flushable {
|
|
/*
|
* From RFC 7159, "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)."
|
*
|
* We also escape '\u2028' and '\u2029', which JavaScript interprets as newline
|
* characters. This prevents eval() from failing with a syntax error.
|
* http://code.google.com/p/google-gson/issues/detail?id=341
|
*/
|
private static final String[] REPLACEMENT_CHARS;
|
private static final String[] HTML_SAFE_REPLACEMENT_CHARS;
|
static {
|
REPLACEMENT_CHARS = new String[128];
|
for (int i = 0; i <= 0x1f; i++) {
|
REPLACEMENT_CHARS[i] = String.format("\\u%04x", (int) i);
|
}
|
REPLACEMENT_CHARS['"'] = "\\\"";
|
REPLACEMENT_CHARS['\\'] = "\\\\";
|
REPLACEMENT_CHARS['\t'] = "\\t";
|
REPLACEMENT_CHARS['\b'] = "\\b";
|
REPLACEMENT_CHARS['\n'] = "\\n";
|
REPLACEMENT_CHARS['\r'] = "\\r";
|
REPLACEMENT_CHARS['\f'] = "\\f";
|
HTML_SAFE_REPLACEMENT_CHARS = REPLACEMENT_CHARS.clone();
|
HTML_SAFE_REPLACEMENT_CHARS['<'] = "\\u003c";
|
HTML_SAFE_REPLACEMENT_CHARS['>'] = "\\u003e";
|
HTML_SAFE_REPLACEMENT_CHARS['&'] = "\\u0026";
|
HTML_SAFE_REPLACEMENT_CHARS['='] = "\\u003d";
|
HTML_SAFE_REPLACEMENT_CHARS['\''] = "\\u0027";
|
}
|
|
/** The output data, containing at most one top-level array or object. */
|
private final Writer out;
|
|
private int[] stack = new int[32];
|
private int stackSize = 0;
|
{
|
push(EMPTY_DOCUMENT);
|
}
|
|
/**
|
* A string containing a full set of spaces for a single level of indentation,
|
* or null for no pretty printing.
|
*/
|
private String indent;
|
|
/**
|
* The name/value separator; either ":" or ": ".
|
*/
|
private String separator = ":";
|
|
private boolean lenient;
|
|
private boolean htmlSafe;
|
|
private String deferredName;
|
|
private boolean serializeNulls = true;
|
|
/**
|
* Creates a new instance that writes a JSON-encoded stream to {@code out}. For
|
* best performance, ensure {@link Writer} is buffered; wrapping in
|
* {@link java.io.BufferedWriter BufferedWriter} if necessary.
|
*/
|
public JsonWriter(Writer out) {
|
if (out == null) {
|
throw new NullPointerException("out == null");
|
}
|
this.out = out;
|
}
|
|
/**
|
* Sets the indentation string to be repeated for each level of indentation in
|
* the encoded document. If {@code indent.isEmpty()} the encoded document will
|
* be compact. Otherwise the encoded document will be more human-readable.
|
*
|
* @param indent
|
* a string containing only whitespace.
|
*/
|
public final void setIndent(String indent) {
|
if (indent.length() == 0) {
|
this.indent = null;
|
this.separator = ":";
|
} else {
|
this.indent = indent;
|
this.separator = ": ";
|
}
|
}
|
|
/**
|
* Configure this writer to relax its syntax rules. By default, this writer only
|
* emits well-formed JSON as specified by
|
* <a href="http://www.ietf.org/rfc/rfc7159.txt">RFC 7159</a>. Setting the
|
* writer to lenient permits the following:
|
* <ul>
|
* <li>Top-level values of any type. With strict writing, the top-level value
|
* must be an object or an array.
|
* <li>Numbers may be {@link Double#isNaN() NaNs} or {@link Double#isInfinite()
|
* infinities}.
|
* </ul>
|
*/
|
public final void setLenient(boolean lenient) {
|
this.lenient = lenient;
|
}
|
|
/**
|
* Returns true if this writer has relaxed syntax rules.
|
*/
|
public boolean isLenient() {
|
return lenient;
|
}
|
|
/**
|
* Configure this writer to emit JSON that's safe for direct inclusion in HTML
|
* and XML documents. This escapes the HTML characters {@code <}, {@code >},
|
* {@code &} and {@code =} before writing them to the stream. Without this
|
* setting, your XML/HTML encoder should replace these characters with the
|
* corresponding escape sequences.
|
*/
|
public final void setHtmlSafe(boolean htmlSafe) {
|
this.htmlSafe = htmlSafe;
|
}
|
|
/**
|
* Returns true if this writer writes JSON that's safe for inclusion in HTML and
|
* XML documents.
|
*/
|
public final boolean isHtmlSafe() {
|
return htmlSafe;
|
}
|
|
/**
|
* Sets whether object members are serialized when their value is null. This has
|
* no impact on array elements. The default is true.
|
*/
|
public final void setSerializeNulls(boolean serializeNulls) {
|
this.serializeNulls = serializeNulls;
|
}
|
|
/**
|
* Returns true if object members are serialized when their value is null. This
|
* has no impact on array elements. The default is true.
|
*/
|
public final boolean getSerializeNulls() {
|
return serializeNulls;
|
}
|
|
/**
|
* Begins encoding a new array. Each call to this method must be paired with a
|
* call to {@link #endArray}.
|
*
|
* @return this writer.
|
*/
|
public JsonWriter beginArray() throws IOException {
|
writeDeferredName();
|
return open(EMPTY_ARRAY, "[");
|
}
|
|
/**
|
* Ends encoding the current array.
|
*
|
* @return this writer.
|
*/
|
public JsonWriter endArray() throws IOException {
|
return close(EMPTY_ARRAY, NONEMPTY_ARRAY, "]");
|
}
|
|
/**
|
* Begins encoding a new object. Each call to this method must be paired with a
|
* call to {@link #endObject}.
|
*
|
* @return this writer.
|
*/
|
public JsonWriter beginObject() throws IOException {
|
writeDeferredName();
|
return open(EMPTY_OBJECT, "{");
|
}
|
|
/**
|
* Ends encoding the current object.
|
*
|
* @return this writer.
|
*/
|
public JsonWriter endObject() throws IOException {
|
return close(EMPTY_OBJECT, NONEMPTY_OBJECT, "}");
|
}
|
|
/**
|
* Enters a new scope by appending any necessary whitespace and the given
|
* bracket.
|
*/
|
private JsonWriter open(int empty, String openBracket) throws IOException {
|
beforeValue();
|
push(empty);
|
out.write(openBracket);
|
return this;
|
}
|
|
/**
|
* Closes the current scope by appending any necessary whitespace and the given
|
* bracket.
|
*/
|
private JsonWriter close(int empty, int nonempty, String closeBracket) throws IOException {
|
int context = peek();
|
if (context != nonempty && context != empty) {
|
throw new IllegalStateException("Nesting problem.");
|
}
|
if (deferredName != null) {
|
throw new IllegalStateException("Dangling name: " + deferredName);
|
}
|
|
stackSize--;
|
if (context == nonempty) {
|
newline();
|
}
|
out.write(closeBracket);
|
return this;
|
}
|
|
private void push(int newTop) {
|
if (stackSize == stack.length) {
|
int[] newStack = new int[stackSize * 2];
|
System.arraycopy(stack, 0, newStack, 0, stackSize);
|
stack = newStack;
|
}
|
stack[stackSize++] = newTop;
|
}
|
|
/**
|
* Returns the value on the top of the stack.
|
*/
|
private int peek() {
|
if (stackSize == 0) {
|
throw new IllegalStateException("JsonWriter is closed.");
|
}
|
return stack[stackSize - 1];
|
}
|
|
/**
|
* Replace the value on the top of the stack with the given value.
|
*/
|
private void replaceTop(int topOfStack) {
|
stack[stackSize - 1] = topOfStack;
|
}
|
|
/**
|
* Encodes the property name.
|
*
|
* @param name
|
* the name of the forthcoming value. May not be null.
|
* @return this writer.
|
*/
|
public JsonWriter name(String name) throws IOException {
|
if (name == null) {
|
throw new NullPointerException("name == null");
|
}
|
if (deferredName != null) {
|
throw new IllegalStateException();
|
}
|
if (stackSize == 0) {
|
throw new IllegalStateException("JsonWriter is closed.");
|
}
|
deferredName = name;
|
return this;
|
}
|
|
private void writeDeferredName() throws IOException {
|
if (deferredName != null) {
|
beforeName();
|
string(deferredName);
|
deferredName = null;
|
}
|
}
|
|
/**
|
* Encodes {@code value}.
|
*
|
* @param value
|
* the literal string value, or null to encode a null literal.
|
* @return this writer.
|
*/
|
public JsonWriter value(String value) throws IOException {
|
if (value == null) {
|
return nullValue();
|
}
|
writeDeferredName();
|
beforeValue();
|
string(value);
|
return this;
|
}
|
|
/**
|
* Writes {@code value} directly to the writer without quoting or escaping.
|
*
|
* @param value
|
* the literal string value, or null to encode a null literal.
|
* @return this writer.
|
*/
|
public JsonWriter jsonValue(String value) throws IOException {
|
if (value == null) {
|
return nullValue();
|
}
|
writeDeferredName();
|
beforeValue();
|
out.append(value);
|
return this;
|
}
|
|
/**
|
* Encodes {@code null}.
|
*
|
* @return this writer.
|
*/
|
public JsonWriter nullValue() throws IOException {
|
if (deferredName != null) {
|
if (serializeNulls) {
|
writeDeferredName();
|
} else {
|
deferredName = null;
|
return this; // skip the name and the value
|
}
|
}
|
beforeValue();
|
out.write("null");
|
return this;
|
}
|
|
/**
|
* Encodes {@code value}.
|
*
|
* @return this writer.
|
*/
|
public JsonWriter value(boolean value) throws IOException {
|
writeDeferredName();
|
beforeValue();
|
out.write(value ? "true" : "false");
|
return this;
|
}
|
|
/**
|
* Encodes {@code value}.
|
*
|
* @param value
|
* a finite value. May not be {@link Double#isNaN() NaNs} or
|
* {@link Double#isInfinite() infinities}.
|
* @return this writer.
|
*/
|
public JsonWriter value(double value) throws IOException {
|
if (Double.isNaN(value) || Double.isInfinite(value)) {
|
throw new IllegalArgumentException("Numeric values must be finite, but was " + value);
|
}
|
writeDeferredName();
|
beforeValue();
|
out.append(Double.toString(value));
|
return this;
|
}
|
|
/**
|
* Encodes {@code value}.
|
*
|
* @return this writer.
|
*/
|
public JsonWriter value(long value) throws IOException {
|
writeDeferredName();
|
beforeValue();
|
out.write(Long.toString(value));
|
return this;
|
}
|
|
/**
|
* Encodes {@code value}.
|
*
|
* @param value
|
* a finite value. May not be {@link Double#isNaN() NaNs} or
|
* {@link Double#isInfinite() infinities}.
|
* @return this writer.
|
*/
|
public JsonWriter value(Number value) throws IOException {
|
if (value == null) {
|
return nullValue();
|
}
|
|
writeDeferredName();
|
String string = value.toString();
|
if (!lenient && (string.equals("-Infinity") || string.equals("Infinity") || string.equals("NaN"))) {
|
throw new IllegalArgumentException("Numeric values must be finite, but was " + value);
|
}
|
beforeValue();
|
out.append(string);
|
return this;
|
}
|
|
/**
|
* Ensures all buffered data is written to the underlying {@link Writer} and
|
* flushes that writer.
|
*/
|
public void flush() throws IOException {
|
if (stackSize == 0) {
|
throw new IllegalStateException("JsonWriter is closed.");
|
}
|
out.flush();
|
}
|
|
/**
|
* Flushes and closes this writer and the underlying {@link Writer}.
|
*
|
* @throws IOException
|
* if the JSON document is incomplete.
|
*/
|
public void close() throws IOException {
|
out.close();
|
|
int size = stackSize;
|
if (size > 1 || size == 1 && stack[size - 1] != NONEMPTY_DOCUMENT) {
|
throw new IOException("Incomplete document");
|
}
|
stackSize = 0;
|
}
|
|
private void string(String value) throws IOException {
|
String[] replacements = htmlSafe ? HTML_SAFE_REPLACEMENT_CHARS : REPLACEMENT_CHARS;
|
out.write("\"");
|
int last = 0;
|
int length = value.length();
|
for (int i = 0; i < length; i++) {
|
char c = value.charAt(i);
|
String replacement;
|
if (c < 128) {
|
replacement = replacements[c];
|
if (replacement == null) {
|
continue;
|
}
|
} else if (c == '\u2028') {
|
replacement = "\\u2028";
|
} else if (c == '\u2029') {
|
replacement = "\\u2029";
|
} else {
|
continue;
|
}
|
if (last < i) {
|
out.write(value, last, i - last);
|
}
|
out.write(replacement);
|
last = i + 1;
|
}
|
if (last < length) {
|
out.write(value, last, length - last);
|
}
|
out.write("\"");
|
}
|
|
private void newline() throws IOException {
|
if (indent == null) {
|
return;
|
}
|
|
out.write("\n");
|
for (int i = 1, size = stackSize; i < size; i++) {
|
out.write(indent);
|
}
|
}
|
|
/**
|
* Inserts any necessary separators and whitespace before a name. Also adjusts
|
* the stack to expect the name's value.
|
*/
|
private void beforeName() throws IOException {
|
int context = peek();
|
if (context == NONEMPTY_OBJECT) { // first in object
|
out.write(',');
|
} else if (context != EMPTY_OBJECT) { // not in an object!
|
throw new IllegalStateException("Nesting problem.");
|
}
|
newline();
|
replaceTop(DANGLING_NAME);
|
}
|
|
/**
|
* 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.
|
*/
|
@SuppressWarnings("fallthrough")
|
private void beforeValue() throws IOException {
|
switch (peek()) {
|
case NONEMPTY_DOCUMENT:
|
if (!lenient) {
|
throw new IllegalStateException("JSON must have only one top-level value.");
|
}
|
// fall-through
|
case EMPTY_DOCUMENT: // first in document
|
replaceTop(NONEMPTY_DOCUMENT);
|
break;
|
|
case EMPTY_ARRAY: // first in array
|
replaceTop(NONEMPTY_ARRAY);
|
newline();
|
break;
|
|
case NONEMPTY_ARRAY: // another in array
|
out.append(',');
|
newline();
|
break;
|
|
case DANGLING_NAME: // value for name
|
out.append(separator);
|
replaceTop(NONEMPTY_OBJECT);
|
break;
|
|
default:
|
throw new IllegalStateException("Nesting problem.");
|
}
|
}
|
}
|
