private static final int initdepth = 16;

/**

private boolean comma;

/**

protected char mode;

/**

private final ALStack<Set<String>> stack;

/**

protected final Appendable writer;

/**

public JSONWriter(Appendable w) {

this.comma = false;

this.mode = 'i';

this.stack = new ALStack<Set<String>>(initdepth);

this.writer = w;

}

/**

private void prepValue() throws JSONException {

try {

switch (this.mode) {

case 'a':

if (this.comma) {

this.writer.append(',');

}

break;

case 'o':

this.mode = 'k';

break;

default:

throw new JSONException("Value out of sequence.");

}

this.comma = true;

} catch (IOException e) {

throw new JSONException(e);

}

}

/**

public JSONWriter array() throws JSONException {

if (this.mode == 'i' || this.mode == 'o' || this.mode == 'a') {

this.push(false);

try {

this.prepValue();

this.writer.append('[');

} catch (IOException e) {

throw new JSONException(e);

}

this.comma = false;

return this;

}

throw new JSONException("Misplaced array.");

}

/**

private JSONWriter end(char mode, char c) throws JSONException {

if (this.mode != mode) {

throw new JSONException(mode == 'a'

? "Misplaced endArray."

: "Misplaced endObject.");

}

this.pop(mode);

try {

this.writer.append(c);

} catch (IOException e) {

throw new JSONException(e);

}

this.comma = true;

return this;

}

/**

public JSONWriter endArray() throws JSONException {

return this.end('a', ']');

}

/**

public JSONWriter endObject() throws JSONException {

return this.end('k', '}');

}

/**

public JSONWriter key(String string) throws JSONException {

if (string == null) {

throw new JSONException("Null key.");

}

if (this.mode == 'k') {

try {

if(!this.stack.peek().add(string)) {

throw new JSONException("Duplicate key \"" + string + "\"");

}

if (this.comma) {

this.writer.append(',');

}

writeString(string, this.writer).append(':');

this.comma = false;

this.mode = 'o';

return this;

} catch (IOException e) {

throw new JSONException(e);

}

}

throw new JSONException("Misplaced key.");

}

/**

public JSONWriter object() throws JSONException {

if (this.mode == 'i') {

this.mode = 'o';

}

if (this.mode == 'o' || this.mode == 'a') {

try {

this.prepValue();

this.writer.append('{');

} catch (IOException e) {

throw new JSONException(e);

}

this.push(true);

this.comma = false;

return this;

}

throw new JSONException("Misplaced object.");

}

/**

private void pop(char c) throws JSONException {

if (this.stack.isEmpty()) {

throw new JSONException("Nesting error.");

}

char m = this.stack.pop() == null ? 'a' : 'k';

if (m != c) {

throw new JSONException("Nesting error.");

}

this.mode = this.stack.isEmpty()

? 'd'

: this.stack.peek() == null

? 'a'

: 'k';

}

/**

private void push(boolean obj) throws JSONException {

this.stack.push(obj ? new HashSet<String>() : null);

this.mode = obj ? 'k' : 'a';

}

/**

public JSONWriter nullValue() throws JSONException {

this.prepValue();

writeNull(this.writer);

return this;

}

/**

public JSONWriter value(boolean b) throws JSONException {

String string = Boolean.toString(b);

try {

this.prepValue();

this.writer.append(string);

return this;

} catch (IOException e) {

throw new JSONException(e);

}

}

/**

public JSONWriter value(double d) throws JSONException {

this.prepValue();

writeDouble(d, this.writer);

return this;

}

/**

public JSONWriter value(long l) throws JSONException {

String string = Long.toString(l);

try {

this.prepValue();

this.writer.append(string);

return this;

} catch (IOException e) {

throw new JSONException(e);

}

}

/**

public JSONWriter value(Object object) throws JSONException {

this.prepValue();

writeValue(object, this.writer);

return this;

}

/**

public JSONWriter values(Iterable<?> values) throws JSONException {

for(Object obj : values) {

this.prepValue();

writeValue(obj, this.writer);

}

return this;

}

/**

public JSONWriter entries(Map<?, ?> kvPairs) throws JSONException {

for(Entry<?, ?> entry : kvPairs.entrySet()) {

this.key(String.valueOf(entry.getKey()));

this.prepValue();

writeValue(entry.getValue(), this.writer);

}

return this;

}

/**

@Override

public void close() throws IOException {

if(!this.stack.isEmpty()) {

throw new IOException("JSON stack is not empty");

}

if(writer instanceof Closeable) {

((Closeable)writer).close();

}

}

// -- static writer methods

// 120 spaces, divides by 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, ...

private static final String PADDING_SPACES = makePaddingSpaces();

private static final int PADDING_LENGTH = 120;

private static String makePaddingSpaces() {

char[] padding = new char[PADDING_LENGTH];

Arrays.fill(padding, ' ');

return String.valueOf(padding);

}

/**

static <T extends Appendable> T indent(int indent, T writer) throws IOException {

while(indent >= PADDING_LENGTH) {

writer.append(PADDING_SPACES);

indent -= PADDING_LENGTH;

}

if(indent > 0) {

writer.append(PADDING_SPACES, 0, indent);

}

return writer;

}

/**

static <T extends Appendable> T writeValue(Object value, T writer)

throws JSONException {

return writeValue(value, writer, 0, 0);

}

/**

static <T extends Appendable> T writeValue(Object value, T writer,

int indentFactor, int indent) throws JSONException {

if ((value == null) || JSONObject.NULL.equals(value)) {

return writeNull(writer);

}

if (value instanceof JSONAppendable) {

return writeJSONAppendable((JSONAppendable) value, writer);

}

if (value instanceof JSONString) {

return writeJSONString((JSONString) value, writer);

}

if (value instanceof JSONObject) {

return writeJSONObject((JSONObject) value, writer, indentFactor, indent);

}

if (value instanceof JSONArray) {

return writeJSONArray((JSONArray) value, writer, indentFactor, indent);

}

if (value instanceof Number) {

return writeNumber((Number) value, writer);

}

if (value instanceof Boolean) {

return writeBoolean((Boolean) value, writer);

}

if (value instanceof CharSequence) {

return writeString((CharSequence) value, writer);

}

if (value instanceof Map) {

return writeMap((Map<?, ?>) value, writer, indentFactor, indent);

}

if (value instanceof Iterable) {

return writeIterable((Iterable<?>) value, writer, indentFactor, indent);

}

if (value.getClass().isArray()) {

return writeArray(value, writer, indentFactor, indent);

}

if (value instanceof Enum<?>) {

return writeEnum((Enum<?>) value, writer);

}

if (JSONObject.objectIsBean(value)) {

return writeBean(value, writer, indentFactor, indent);

}

return writeString(value.toString(), writer);

}

/**

static <T extends Appendable> T writeJSONAppendable(JSONAppendable value,

T writer) throws JSONException {

try {

value.appendJSON(writer);

return writer;

} catch(JSONException e) {

// Propagate directly, because JSONException is a RuntimeException

throw e;

} catch(IOException e) {

throw new JSONException(e);

} catch(RuntimeException e) {

throw new JSONException(e);

}

}

/**

static <T extends Appendable> T writeJSONString(JSONString value, T writer)

throws JSONException {

try {

String o = value.toJSONString();

if (o != null) {

writer.append(o);

} else {

writeString(value.toString(), writer);

}

return writer;

} catch(JSONException e) {

// Propagate directly, because JSONException is a RuntimeException

throw e;

} catch (IOException e) {

throw new JSONException(e);

} catch (RuntimeException e) {

throw new JSONException(e);

}

}

/**

static <T extends Appendable> T writeBean(Object bean, T writer,

int indentFactor, int indent) throws JSONException {

try {

final int newindent = indent + indentFactor;

Class<?> klass = bean.getClass();

// If klass is a System class then set includeSuperClass to false.

boolean includeSuperClass = klass.getClassLoader() != null;

Method[] methods = includeSuperClass ? klass.getMethods()

: klass.getDeclaredMethods();

boolean commanate = false;

writer.append('{');

for (int i = 0; i < methods.length; i += 1) {

try {

Method method = methods[i];

if (Modifier.isPublic(method.getModifiers()) &&

!Modifier.isStatic(method.getModifiers()) &&

!method.isSynthetic() &&

(method.getReturnType() != Void.TYPE)) {

String name = method.getName();

String key = JSONObject.keyFromMethodName(name);

if ((key != null)

&& (method.getParameterTypes().length == 0)) {

Object result = method.invoke(bean, (Object[]) null);

if (result != null) {

if (commanate) {

writer.append(',');

}

if (indentFactor > 0) {

writer.append('\n');

}

indent(newindent, writer);

writeString(String.valueOf(key), writer).append(':');

if (indentFactor > 0) {

writer.append(' ');

}

writeValue(result, writer, indentFactor, newindent);

commanate = true;

}

}

}

} catch (Exception ignore) {

}

}

if(commanate) {

if (indentFactor > 0) {

writer.append('\n');

}

indent(indent, writer);

}

writer.append('}');

return writer;

} catch (IOException exception) {

throw new JSONException(exception);

} catch (RuntimeException exception) {

throw new JSONException(exception);

}

}

/**

static <T extends Appendable> T writeMap(Map<?, ?> map, T writer,

int indentFactor, int indent) throws JSONException {

try {

boolean commanate = false;

final int length = map.size();

Iterator<?> keys = map.keySet().iterator();

writer.append('{');

if (length == 1) {

Object key = keys.next();

writeString(String.valueOf(key), writer).append(':');

if (indentFactor > 0) {

writer.append(' ');

}

writeValue(map.get(key), writer, indentFactor, indent);

} else if (length != 0) {

final int newindent = indent + indentFactor;

while (keys.hasNext()) {

Object key = keys.next();

if (commanate) {

writer.append(',');

}

if (indentFactor > 0) {

writer.append('\n');

}

indent(newindent, writer);

writeString(String.valueOf(key), writer).append(':');

if (indentFactor > 0) {

writer.append(' ');

}

writeValue(map.get(key), writer, indentFactor, newindent);

commanate = true;

}

if (indentFactor > 0) {

writer.append('\n');

}

indent(indent, writer);

}

writer.append('}');

return writer;

} catch (IOException exception) {

throw new JSONException(exception);

}

}

/**

private static boolean singleIterableElement(Iterable<?> iterable) {

if(iterable instanceof Collection) {

return ((Collection)iterable).size() == 1;

}

Iterator<?> iterator = iterable.iterator();

if(!iterator.hasNext()) {

return false;

}

iterator.next();

return !iterator.hasNext();

}

/**

static <T extends Appendable> T writeIterable(Iterable<?> collection, T writer,

int indentFactor, int indent) throws JSONException {

try {

boolean singleElement = singleIterableElement(collection);

Iterator<?> iterator = collection.iterator();

boolean commanate = false;

writer.append('[');

if ((singleElement) && (iterator.hasNext())) {

writeValue(iterator.next(), writer,

indentFactor, indent);

} else if (iterator.hasNext()) {

final int newindent = indent + indentFactor;

while (iterator.hasNext()) {

if (commanate) {

writer.append(',');

}

if (indentFactor > 0) {

writer.append('\n');

}

indent(newindent, writer);

writeValue(iterator.next(), writer,

indentFactor, newindent);

commanate = true;

}

if (indentFactor > 0) {

writer.append('\n');

}

indent(indent, writer);

}

writer.append(']');

return writer;

} catch (IOException e) {

throw new JSONException(e);

}

}

/**

static <T extends Appendable> T writeArray(Object array, T writer,

int indentFactor, int indent) throws JSONException {

try {

final int length = Array.getLength(array);

boolean commanate = false;

writer.append('[');

if (length == 1) {

writeValue(Array.get(array, 0), writer,

indentFactor, indent);

} else if (length != 0) {

final int newindent = indent + indentFactor;

for (int i = 0; i < length; i += 1) {

if (commanate) {

writer.append(',');

}

if (indentFactor > 0) {

writer.append('\n');

}

indent(newindent, writer);

writeValue(Array.get(array, i), writer,

indentFactor, newindent);

commanate = true;

}

if (indentFactor > 0) {

writer.append('\n');

}

indent(indent, writer);

}

writer.append(']');

return writer;

} catch (IOException e) {

throw new JSONException(e);

}

}

/**

static <T extends Appendable> T writeEnum(Enum<?> value, T writer)

throws JSONException {

return writeString(value.name(), writer);

}

/**

static <T extends Appendable> T writeJSONObject(JSONObject object, T writer,

int indentFactor, int indent) throws JSONException {

try {

boolean commanate = false;

final int length = object.length();

Iterator<String> keys = object.keys();

writer.append('{');

if (length == 1) {

String key = keys.next();

writeString(key, writer).append(':');

if (indentFactor > 0) {

writer.append(' ');

}

writeValue(object.opt(key), writer, indentFactor, indent);

} else if (length != 0) {

final int newindent = indent + indentFactor;

while (keys.hasNext()) {

String key = keys.next();

if (commanate) {

writer.append(',');

}

if (indentFactor > 0) {

writer.append('\n');

}

indent(newindent, writer);

writeString(key, writer).append(':');

if (indentFactor > 0) {

writer.append(' ');

}

writeValue(object.opt(key), writer, indentFactor, newindent);

commanate = true;

}

if (indentFactor > 0) {

writer.append('\n');

}

indent(indent, writer);

}

writer.append('}');

return writer;

} catch (IOException exception) {

throw new JSONException(exception);

}

}

/**

static <T extends Appendable> T writeJSONArray(JSONArray array, T writer,

int indentFactor, int indent) throws JSONException {

try {

boolean commanate = false;

int length = array.length();

writer.append('[');

if (length == 1) {

writeValue(array.get(0), writer, indentFactor, indent);

} else if (length != 0) {

final int newindent = indent + indentFactor;

for (int i = 0; i < length; i += 1) {

if (commanate) {

writer.append(',');

}

if (indentFactor > 0) {