content: package org.json;
  
  import java.io.IOException;
  import java.util.Collection;
  import java.util.Map;
  
  /*
  Public Domain.
  */
  
  /**
   * 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 200 levels deep.
   * <p>
   * This can sometimes be easier than using a JSONObject to build a string.
   * @author JSON.org
   * @version 2016-08-08
   */
  public class JSONWriter {
      private static final int maxdepth = 200;
  
      /**
       * 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 final 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 Appendable writer;
  
      /**
       * Make a fresh JSONWriter. It can be used to build one JSON text.
       * @param w an appendable object
       */
      public JSONWriter(Appendable w) {
          this.comma = false;
          this.mode = 'i';
          this.stack = new JSONObject[maxdepth];
          this.top = 0;
          this.writer = w;
      }
  
      /**
       * Append a value.
       * @param string A string value.
       * @return this
       * @throws JSONException If the value is out of sequence.
       */
      private JSONWriter append(String string) throws JSONException {
          if (string == null) {
              throw new JSONException("Null pointer");
          }
          if (this.mode == 'o' || this.mode == 'a') {
              try {
                  if (this.comma && this.mode == 'a') {
                      this.writer.append(',');
                  }
                  this.writer.append(string);
              } catch (IOException e) {
              	// Android as of API 25 does not support this exception constructor
              	// however we won't worry about it. If an exception is happening here
              	// it will just throw a "Method not found" exception instead.
                  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 == 'a'
                  ? "Misplaced endArray."
                  : "Misplaced endObject.");
          }
          this.pop(m);
          try {
              this.writer.append(c);
          } catch (IOException e) {
          	// Android as of API 25 does not support this exception constructor
          	// however we won't worry about it. If an exception is happening here
          	// it will just throw a "Method not found" exception instead.
              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 string 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 string) throws JSONException {
          if (string == null) {
              throw new JSONException("Null key.");
          }
          if (this.mode == 'k') {
              try {
                  JSONObject topObject = this.stack[this.top - 1];
                  // don't use the built in putOnce method to maintain Android support
  				if(topObject.has(string)) {
  					throw new JSONException("Duplicate key \"" + string + "\"");
  				}
                  topObject.put(string, true);
                  if (this.comma) {
                      this.writer.append(',');
                  }
                  this.writer.append(JSONObject.quote(string));
                  this.writer.append(':');
                  this.comma = false;
                  this.mode = 'o';
                  return this;
              } catch (IOException e) {
              	// Android as of API 25 does not support this exception constructor
              	// however we won't worry about it. If an exception is happening here
              	// it will just throw a "Method not found" exception instead.
                  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;
      }
  
      /**
       * 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 other means. If the value
       * is an array or Collection, then a JSONArray will be made from it and its
       * toJSONString method will be called. If the value is a MAP, then a
       * JSONObject will be made from it and its toJSONString method will be
       * called. Otherwise, the value's toString method will be called, and the
       * result will be quoted.
       *
       * <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 static String valueToString(Object value) throws JSONException {
          if (value == null || value.equals(null)) {
              return "null";
          }
          if (value instanceof JSONString) {
              String object;
              try {
                  object = ((JSONString) value).toJSONString();
              } catch (Exception e) {
                  throw new JSONException(e);
              }
              if (object != null) {
                  return object;
              }
              throw new JSONException("Bad value from toJSONString: " + object);
          }
          if (value instanceof Number) {
              // not all Numbers may match actual JSON Numbers. i.e. Fractions or Complex
              final String numberAsString = JSONObject.numberToString((Number) value);
              if(JSONObject.NUMBER_PATTERN.matcher(numberAsString).matches()) {
                  // Close enough to a JSON number that we will return it unquoted
                  return numberAsString;
              }
              // The Number value is not a valid JSON number.
              // Instead we will quote it as a string
              return JSONObject.quote(numberAsString);
          }
          if (value instanceof Boolean || value instanceof JSONObject
                  || value instanceof JSONArray) {
              return value.toString();
          }
          if (value instanceof Map) {
              Map<?, ?> map = (Map<?, ?>) value;
              return new JSONObject(map).toString();
          }
          if (value instanceof Collection) {
              Collection<?> coll = (Collection<?>) value;
              return new JSONArray(coll).toString();
          }
          if (value.getClass().isArray()) {
              return new JSONArray(value).toString();
          }
          if(value instanceof Enum<?>){
              return JSONObject.quote(((Enum<?>)value).name());
          }
          return JSONObject.quote(value.toString());
      }
  
      /**
       * Append either the value <code>true</code> or the value
       * <code>false</code>.
       * @param b A boolean.
       * @return this
       * @throws JSONException if a called function has an error
       */
      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(Double.valueOf(d));
      }
  
      /**
       * Append a long value.
       * @param l A long.
       * @return this
       * @throws JSONException if a called function has an error
       */
      public JSONWriter value(long l) throws JSONException {
          return this.append(Long.toString(l));
      }
  
  
      /**
       * Append an object value.
       * @param object The object to append. It can be null, or a Boolean, Number,
       *   String, JSONObject, or JSONArray, or an object that implements JSONString.
       * @return this
       * @throws JSONException If the value is out of sequence.
       */
      public JSONWriter value(Object object) throws JSONException {
          return this.append(valueToString(object));
      }
  }
  