Format all dart: library files

sdk/lib/convert/json.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.convert;
 
 /**
  * Error thrown by JSON serialization if an object cannot be serialized.
  *
  * The [unsupportedObject] field holds that object that failed to be serialized.
  *
  * If an object isn't directly serializable, the serializer calls the `toJson`
  * method on the object. If that call fails, the error will be stored in the
  * [cause] field. If the call returns an object that isn't directly
  * serializable, the [cause] is null.
  */
 class JsonUnsupportedObjectError extends Error {
   /** The object that could not be serialized. */
   final unsupportedObject;
   /** The exception thrown when trying to convert the object. */
   final cause;
 
-  JsonUnsupportedObjectError(this.unsupportedObject, { this.cause });
+  JsonUnsupportedObjectError(this.unsupportedObject, {this.cause});
 
   String toString() {
     if (cause != null) {
       return "Converting object to an encodable object failed.";
     } else {
       return "Converting object did not return an encodable object.";
     }
   }
 }
 
-
 /**
  * Reports that an object could not be stringified due to cyclic references.
  *
  * An object that references itself cannot be serialized by [stringify].
  * When the cycle is detected, a [JsonCyclicError] is thrown.
  */
 class JsonCyclicError extends JsonUnsupportedObjectError {
   /** The first object that was detected as part of a cycle. */
-  JsonCyclicError(Object object): super(object);
+  JsonCyclicError(Object object) : super(object);
   String toString() => "Cyclic error in JSON stringify";
 }
 
-
 /**
  * An instance of the default implementation of the [JsonCodec].
  *
  * This instance provides a convenient access to the most common JSON
  * use cases.
  *
  * Examples:
  *
  *     var encoded = JSON.encode([1, 2, { "a": null }]);
  *     var decoded = JSON.decode('["foo", { "bar": 499 }]');
  */
 const JsonCodec JSON = const JsonCodec();
 
 typedef _Reviver(var key, var value);
 typedef _ToEncodable(var o);
 
-
 /**
  * A [JsonCodec] encodes JSON objects to strings and decodes strings to
  * JSON objects.
  *
  * Examples:
  *
  *     var encoded = JSON.encode([1, 2, { "a": null }]);
  *     var decoded = JSON.decode('["foo", { "bar": 499 }]');
  */
 class JsonCodec extends Codec<Object, String> {
@@ skipping 176 matching lines @@
    * The converter works more efficiently if the given [sink] is a
    * [StringConversionSink].
    *
    * Returns a chunked-conversion sink that accepts at most one object. It is
    * an error to invoke `add` more than once on the returned sink.
    */
   ChunkedConversionSink<Object> startChunkedConversion(Sink<String> sink) {
     if (sink is! StringConversionSink) {
       sink = new StringConversionSink.from(sink);
     } else if (sink is _Utf8EncoderSink) {
-      return new _JsonUtf8EncoderSink(sink._sink, _toEncodable,
-                                      JsonUtf8Encoder._utf8Encode(indent),
-                                      JsonUtf8Encoder.DEFAULT_BUFFER_SIZE);
+      return new _JsonUtf8EncoderSink(
+          sink._sink,
+          _toEncodable,
+          JsonUtf8Encoder._utf8Encode(indent),
+          JsonUtf8Encoder.DEFAULT_BUFFER_SIZE);
     }
     return new _JsonEncoderSink(sink, _toEncodable, indent);
   }
 
   // Override the base class's bind, to provide a better type.
   Stream<String> bind(Stream<Object> stream) => super.bind(stream);
 
   Converter<Object, T> fuse<T>(Converter<String, T> other) {
     if (other is Utf8Encoder) {
       return new JsonUtf8Encoder(indent, _toEncodable)
           as dynamic/*=Converter<Object, T>*/;
     }
     return super.fuse<T>(other);
   }
 }
 
 /**
  * Encoder that encodes a single object as a UTF-8 encoded JSON string.
  *
  * This encoder works equivalently to first converting the object to
  * a JSON string, and then UTF-8 encoding the string, but without
  * creating an intermediate string.
  */
 class JsonUtf8Encoder extends Converter<Object, List<int>>
     implements ChunkedConverter<Object, List<int>, Object, List<int>> {
-
   /** Default buffer size used by the JSON-to-UTF-8 encoder. */
   static const int DEFAULT_BUFFER_SIZE = 256;
   /** Indentation used in pretty-print mode, `null` if not pretty. */
   final List<int> _indent;
   /** Function called with each un-encodable object encountered. */
   final _ToEncodable _toEncodable;
   /** UTF-8 buffer size. */
   final int _bufferSize;
 
   /**
@@ skipping 14 matching lines @@
    *
    * The JSON encoder handles numbers, strings, booleans, null, lists and maps
    * directly.
    *
    * Any other object is attempted converted by [toEncodable] to an object that
    * is of one of the convertible types.
    *
    * If [toEncodable] is omitted, it defaults to calling `.toJson()` on the
    * object.
    */
-  JsonUtf8Encoder([String indent,
-                   toEncodable(object),
-                   int bufferSize = DEFAULT_BUFFER_SIZE])
+  JsonUtf8Encoder(
+      [String indent,
+      toEncodable(object),
+      int bufferSize = DEFAULT_BUFFER_SIZE])
       : _indent = _utf8Encode(indent),
         _toEncodable = toEncodable,
         _bufferSize = bufferSize;
 
   static List<int> _utf8Encode(String string) {
     if (string == null) return null;
     if (string.isEmpty) return new Uint8List(0);
-    checkAscii: {
+    checkAscii:
+    {
       for (int i = 0; i < string.length; i++) {
         if (string.codeUnitAt(i) >= 0x80) break checkAscii;
       }
       return string.codeUnits;
     }
     return UTF8.encode(string);
   }
 
   /** Convert [object] into UTF-8 encoded JSON. */
   List<int> convert(Object object) {
     List<List<int>> bytes = [];
     // The `stringify` function always converts into chunks.
     // Collect the chunks into the `bytes` list, then combine them afterwards.
     void addChunk(Uint8List chunk, int start, int end) {
       if (start > 0 || end < chunk.length) {
         int length = end - start;
-        chunk = new Uint8List.view(chunk.buffer,
-                                   chunk.offsetInBytes + start,
-                                   length);
+        chunk = new Uint8List.view(
+            chunk.buffer, chunk.offsetInBytes + start, length);
       }
       bytes.add(chunk);
     }
-    _JsonUtf8Stringifier.stringify(object,
-                                   _indent,
-                                   _toEncodable,
-                                   _bufferSize,
-                                   addChunk);
+
+    _JsonUtf8Stringifier.stringify(
+        object, _indent, _toEncodable, _bufferSize, addChunk);
     if (bytes.length == 1) return bytes[0];
     int length = 0;
     for (int i = 0; i < bytes.length; i++) {
       length += bytes[i].length;
     }
     Uint8List result = new Uint8List(length);
     for (int i = 0, offset = 0; i < bytes.length; i++) {
       var byteList = bytes[i];
       int end = offset + byteList.length;
       result.setRange(offset, end, byteList);
@@ skipping 10 matching lines @@
    * The argument [sink] will receive byte lists in sizes depending on the
    * `bufferSize` passed to the constructor when creating this encoder.
    */
   ChunkedConversionSink<Object> startChunkedConversion(Sink<List<int>> sink) {
     ByteConversionSink byteSink;
     if (sink is ByteConversionSink) {
       byteSink = sink;
     } else {
       byteSink = new ByteConversionSink.from(sink);
     }
-    return new _JsonUtf8EncoderSink(byteSink, _toEncodable,
-                                    _indent, _bufferSize);
+    return new _JsonUtf8EncoderSink(
+        byteSink, _toEncodable, _indent, _bufferSize);
   }
 
   // Override the base class's bind, to provide a better type.
   Stream<List<int>> bind(Stream<Object> stream) {
     return super.bind(stream);
   }
 }
 
 /**
  * Implements the chunked conversion from object to its JSON representation.
@@ skipping 18 matching lines @@
   void add(Object o) {
     if (_isDone) {
       throw new StateError("Only one call to add allowed");
     }
     _isDone = true;
     ClosableStringSink stringSink = _sink.asStringSink();
     _JsonStringStringifier.printOn(o, stringSink, _toEncodable, _indent);
     stringSink.close();
   }
 
-  void close() { /* do nothing */ }
+  void close() {/* do nothing */}
 }
 
 /**
  * Sink returned when starting a chunked conversion from object to bytes.
  */
 class _JsonUtf8EncoderSink extends ChunkedConversionSink<Object> {
   /** The byte sink receiveing the encoded chunks. */
   final ByteConversionSink _sink;
   final List<int> _indent;
   final _ToEncodable _toEncodable;
   final int _bufferSize;
   bool _isDone = false;
-  _JsonUtf8EncoderSink(this._sink, this._toEncodable, this._indent,
-                       this._bufferSize);
+  _JsonUtf8EncoderSink(
+      this._sink, this._toEncodable, this._indent, this._bufferSize);
 
   /** Callback called for each slice of result bytes. */
   void _addChunk(Uint8List chunk, int start, int end) {
     _sink.addSlice(chunk, start, end, false);
   }
 
   void add(Object object) {
     if (_isDone) {
       throw new StateError("Only one call to add allowed");
     }
     _isDone = true;
-    _JsonUtf8Stringifier.stringify(object, _indent, _toEncodable,
-                                   _bufferSize,
-                                   _addChunk);
+    _JsonUtf8Stringifier.stringify(
+        object, _indent, _toEncodable, _bufferSize, _addChunk);
     _sink.close();
   }
 
   void close() {
     if (!_isDone) {
       _isDone = true;
       _sink.close();
     }
   }
 }
@@ skipping 35 matching lines @@
    */
   external StringConversionSink startChunkedConversion(Sink<Object> sink);
 
   // Override the base class's bind, to provide a better type.
   Stream<Object> bind(Stream<String> stream) => super.bind(stream);
 }
 
 // Internal optimized JSON parsing implementation.
 external _parseJson(String source, reviver(key, value));
 
-
 // Implementation of encoder/stringifier.
 
 dynamic _defaultToEncodable(dynamic object) => object.toJson();
 
 /**
  * JSON encoder that traverses an object structure and writes JSON source.
  *
  * This is an abstract implementation that doesn't decide on the output
  * format, but writes the JSON through abstract methods like [writeString].
  */
 abstract class _JsonStringifier {
   // Character code constants.
-  static const int BACKSPACE       = 0x08;
-  static const int TAB             = 0x09;
-  static const int NEWLINE         = 0x0a;
+  static const int BACKSPACE = 0x08;
+  static const int TAB = 0x09;
+  static const int NEWLINE = 0x0a;
   static const int CARRIAGE_RETURN = 0x0d;
-  static const int FORM_FEED       = 0x0c;
-  static const int QUOTE           = 0x22;
-  static const int CHAR_0          = 0x30;
-  static const int BACKSLASH       = 0x5c;
-  static const int CHAR_b          = 0x62;
-  static const int CHAR_f          = 0x66;
-  static const int CHAR_n          = 0x6e;
-  static const int CHAR_r          = 0x72;
-  static const int CHAR_t          = 0x74;
-  static const int CHAR_u          = 0x75;
+  static const int FORM_FEED = 0x0c;
+  static const int QUOTE = 0x22;
+  static const int CHAR_0 = 0x30;
+  static const int BACKSLASH = 0x5c;
+  static const int CHAR_b = 0x62;
+  static const int CHAR_f = 0x66;
+  static const int CHAR_n = 0x6e;
+  static const int CHAR_r = 0x72;
+  static const int CHAR_t = 0x74;
+  static const int CHAR_u = 0x75;
 
   /** List of objects currently being traversed. Used to detect cycles. */
   final List _seen = new List();
   /** Function called for each un-encodable object encountered. */
   final _ToEncodable _toEncodable;
 
   _JsonStringifier(toEncodable(o))
       : _toEncodable = toEncodable ?? _defaultToEncodable;
 
   /** Append a string to the JSON output. */
@@ skipping 15 matching lines @@
     int offset = 0;
     final int length = s.length;
     for (int i = 0; i < length; i++) {
       int charCode = s.codeUnitAt(i);
       if (charCode > BACKSLASH) continue;
       if (charCode < 32) {
         if (i > offset) writeStringSlice(s, offset, i);
         offset = i + 1;
         writeCharCode(BACKSLASH);
         switch (charCode) {
-        case BACKSPACE:
-          writeCharCode(CHAR_b);
-          break;
-        case TAB:
-          writeCharCode(CHAR_t);
-          break;
-        case NEWLINE:
-          writeCharCode(CHAR_n);
-          break;
-        case FORM_FEED:
-          writeCharCode(CHAR_f);
-          break;
-        case CARRIAGE_RETURN:
-          writeCharCode(CHAR_r);
-          break;
-        default:
-          writeCharCode(CHAR_u);
-          writeCharCode(CHAR_0);
-          writeCharCode(CHAR_0);
-          writeCharCode(hexDigit((charCode >> 4) & 0xf));
-          writeCharCode(hexDigit(charCode & 0xf));
-          break;
+          case BACKSPACE:
+            writeCharCode(CHAR_b);
+            break;
+          case TAB:
+            writeCharCode(CHAR_t);
+            break;
+          case NEWLINE:
+            writeCharCode(CHAR_n);
+            break;
+          case FORM_FEED:
+            writeCharCode(CHAR_f);
+            break;
+          case CARRIAGE_RETURN:
+            writeCharCode(CHAR_r);
+            break;
+          default:
+            writeCharCode(CHAR_u);
+            writeCharCode(CHAR_0);
+            writeCharCode(CHAR_0);
+            writeCharCode(hexDigit((charCode >> 4) & 0xf));
+            writeCharCode(hexDigit(charCode & 0xf));
+            break;
         }
       } else if (charCode == QUOTE || charCode == BACKSLASH) {
         if (i > offset) writeStringSlice(s, offset, i);
         offset = i + 1;
         writeCharCode(BACKSLASH);
         writeCharCode(charCode);
       }
     }
     if (offset == 0) {
       writeString(s);
@@ skipping 61 matching lines @@
   bool writeJsonValue(object) {
     if (object is num) {
       if (!object.isFinite) return false;
       writeNumber(object);
       return true;
     } else if (identical(object, true)) {
       writeString('true');
       return true;
     } else if (identical(object, false)) {
       writeString('false');
-       return true;
+      return true;
     } else if (object == null) {
       writeString('null');
       return true;
     } else if (object is String) {
       writeString('"');
       writeStringContent(object);
       writeString('"');
       return true;
     } else if (object is List) {
       _checkCycle(object);
@@ skipping 163 matching lines @@
     } else {
       stringifier =
           new _JsonStringStringifierPretty(output, toEncodable, indent);
     }
     stringifier.writeObject(object);
   }
 
   void writeNumber(num number) {
     _sink.write(number.toString());
   }
+
   void writeString(String string) {
     _sink.write(string);
   }
+
   void writeStringSlice(String string, int start, int end) {
     _sink.write(string.substring(start, end));
   }
+
   void writeCharCode(int charCode) {
     _sink.writeCharCode(charCode);
   }
 }
 
 class _JsonStringStringifierPretty extends _JsonStringStringifier
-                                   with _JsonPrettyPrintMixin {
+    with _JsonPrettyPrintMixin {
   final String _indent;
 
   _JsonStringStringifierPretty(StringSink sink, toEncodable(o), this._indent)
       : super(sink, toEncodable);
 
   void writeIndentation(int count) {
     for (int i = 0; i < count; i++) writeString(_indent);
   }
 }
 
@@ skipping 20 matching lines @@
    * Convert [object] to UTF-8 encoded JSON.
    *
    * Calls [addChunk] with slices of UTF-8 code units.
    * These will typically have size [bufferSize], but may be shorter.
    * The buffers are not reused, so the [addChunk] call may keep and reuse the
    * chunks.
    *
    * If [indent] is non-`null`, the result will be "pretty-printed" with extra
    * newlines and indentation, using [indent] as the indentation.
    */
-  static void stringify(Object object,
-                        List<int> indent,
-                        toEncodable(o),
-                        int bufferSize,
-                        void addChunk(Uint8List chunk, int start, int end)) {
+  static void stringify(Object object, List<int> indent, toEncodable(o),
+      int bufferSize, void addChunk(Uint8List chunk, int start, int end)) {
     _JsonUtf8Stringifier stringifier;
     if (indent != null) {
-      stringifier = new _JsonUtf8StringifierPretty(toEncodable, indent,
-                                                   bufferSize, addChunk);
+      stringifier = new _JsonUtf8StringifierPretty(
+          toEncodable, indent, bufferSize, addChunk);
     } else {
       stringifier = new _JsonUtf8Stringifier(toEncodable, bufferSize, addChunk);
     }
     stringifier.writeObject(object);
     stringifier.flush();
   }
 
   /**
    * Must be called at the end to push the last chunk to the [addChunk]
    * callback.
@@ skipping 89 matching lines @@
       index = 0;
     }
     buffer[index++] = byte;
   }
 }
 
 /**
  * Pretty-printing version of [_JsonUtf8Stringifier].
  */
 class _JsonUtf8StringifierPretty extends _JsonUtf8Stringifier
-                                 with _JsonPrettyPrintMixin {
+    with _JsonPrettyPrintMixin {
   final List<int> indent;
-  _JsonUtf8StringifierPretty(
-      toEncodable(o), this.indent,
-      bufferSize, void addChunk(Uint8List buffer, int start, int end))
+  _JsonUtf8StringifierPretty(toEncodable(o), this.indent, bufferSize,
+      void addChunk(Uint8List buffer, int start, int end))
       : super(toEncodable, bufferSize, addChunk);
 
   void writeIndentation(int count) {
     List<int> indent = this.indent;
     int indentLength = indent.length;
     if (indentLength == 1) {
       int char = indent[0];
       while (count > 0) {
         writeByte(char);
         count -= 1;
       }
       return;
     }
     while (count > 0) {
       count--;
       int end = index + indentLength;
       if (end <= buffer.length) {
         buffer.setRange(index, end, indent);
         index = end;
       } else {
         for (int i = 0; i < indentLength; i++) {
           writeByte(indent[i]);
         }
       }
     }
   }
 }