| // 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 be 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 }); |
| |
| 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); |
| 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> { |
| final _Reviver _reviver; |
| final _ToEncodable _toEncodable; |
| |
| /** |
| * Creates a `JsonCodec` with the given reviver and encoding function. |
| * |
| * The [reviver] function is called during decoding. It is invoked |
| * once for each object or list property that has been parsed. |
| * The `key` argument is either the |
| * integer list index for a list property, the string map key for object |
| * properties, or `null` for the final result. |
| * |
| * If [reviver] is omitted, it defaults to returning the value argument. |
| * |
| * The [toEncodable] function is used during encoding. It is invoked for |
| * values that are not directly encodable to a JSON1toE |
| * string (a value that is not a number, boolean, string, null, list or a map |
| * with string keys). The function must return an object that is directly |
| * encodable. The elements of a returned list and values of a returned map |
| * do not need be directly encodable, and if they aren't, `toEncodable` will |
| * be used on them as well. |
| * Please notice that it is possible to cause an infinite recursive |
| * regress in this way, by effectively creating an infinite data structure |
| * through repeated call to `toEncodable`. |
| * |
| * If [toEncodable] is omitted, it defaults to a function that returns the |
| * result of calling `.toJson()` on the unencodable object. |
| */ |
| const JsonCodec({reviver(var key, var value), toEncodable(var object)}) |
| : _reviver = reviver, |
| _toEncodable = toEncodable; |
| |
| /** |
| * Creates a `JsonCodec` with the given reviver. |
| * |
| * The [reviver] function is called once for each object or list property |
| * that has been parsed during decoding. The `key` argument is either the |
| * integer list index for a list property, the string map key for object |
| * properties, or `null` for the final result. |
| */ |
| JsonCodec.withReviver(reviver(var key, var value)) : this(reviver: reviver); |
| |
| /** |
| * Parses the string and returns the resulting Json object. |
| * |
| * The optional [reviver] function is called once for each object or list |
| * property that has been parsed during decoding. The `key` argument is either |
| * the integer list index for a list property, the string map key for object |
| * properties, or `null` for the final result. |
| * |
| * The default [reviver] (when not provided) is the identity function. |
| */ |
| dynamic decode(String source, {reviver(var key, var value)}) { |
| if (reviver == null) reviver = _reviver; |
| if (reviver == null) return decoder.convert(source); |
| return new JsonDecoder(reviver).convert(source); |
| } |
| |
| /** |
| * Converts [value] to a JSON string. |
| * |
| * If value contains objects that are not directly encodable to a JSON |
| * string (a value that is not a number, boolean, string, null, list or a map |
| * with string keys), the [toEncodable] function is used to convert it to an |
| * object that must be directly encodable. |
| * |
| * If [toEncodable] is omitted, it defaults to a function that returns the |
| * result of calling `.toJson()` on the unencodable object. |
| */ |
| String encode(Object value, {toEncodable(var object)}) { |
| if (toEncodable == null) toEncodable = _toEncodable; |
| if (toEncodable == null) return encoder.convert(value); |
| return new JsonEncoder(toEncodable).convert(value); |
| } |
| |
| JsonEncoder get encoder { |
| if (_toEncodable == null) return const JsonEncoder(); |
| return new JsonEncoder(_toEncodable); |
| } |
| |
| JsonDecoder get decoder { |
| if (_reviver == null) return const JsonDecoder(); |
| return new JsonDecoder(_reviver); |
| } |
| } |
| |
| /** |
| * This class converts JSON objects to strings. |
| */ |
| class JsonEncoder extends Converter<Object, String> { |
| /** |
| * The string used for indention. |
| * |
| * When generating multi-line output, this string is inserted once at the |
| * beginning of each indented line for each level of indentation. |
| * |
| * If `null`, the output is encoded as a single line. |
| */ |
| final String indent; |
| |
| /** |
| * Function called on non-encodable objects to return a replacement |
| * encodable object that will be encoded in the orignal's place. |
| */ |
| final Function _toEncodable; |
| |
| /** |
| * Creates a JSON encoder. |
| * |
| * 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. |
| */ |
| const JsonEncoder([Object toEncodable(Object nonSerializable)]) |
| : this.indent = null, |
| this._toEncodable = toEncodable; |
| |
| /** |
| * Creates a JSON encoder that creates multi-line JSON. |
| * |
| * The encoding of elements of lists and maps are indented and put on separate |
| * lines. The [indent] string is prepended to these elements, once for each |
| * level of indentation. |
| * |
| * If [indent] is `null`, the output is encoded as a single line. |
| * |
| * 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. |
| */ |
| const JsonEncoder.withIndent(this.indent, |
| [Object toEncodable(Object nonSerializable)]) |
| : this._toEncodable = toEncodable; |
| |
| /** |
| * Converts [object] to a JSON [String]. |
| * |
| * Directly serializable values are [num], [String], [bool], and [Null], as |
| * well as some [List] and [Map] values. |
| * For [List], the elements must all be serializable. |
| * For [Map], the keys must be [String] and the values must be serializable. |
| * |
| * If a value is any other type is attempted serialized, the conversion |
| * function provided in the constructor is invoked with the object as argument |
| * and the result, which must be a directly serializable value, |
| * is serialized instead of the original value. |
| * |
| * If the conversion throws, or returns a value that is not directly |
| * serializable, a [JsonUnsupportedObjectError] exception is thrown. |
| * If the call throws, the error is caught and stored in the |
| * [JsonUnsupportedObjectError]'s [:cause:] field. |
| * |
| * If a [List] or [Map] contains a reference to itself, directly or through |
| * other lists or maps, it cannot be serialized and a [JsonCyclicError] is |
| * thrown. |
| * |
| * [object] should not change during serialization. |
| * |
| * If an object is serialized more than once, [convert] may cache the text |
| * for it. In other words, if the content of an object changes after it is |
| * first serialized, the new values may not be reflected in the result. |
| */ |
| String convert(Object object) => |
| _JsonStringStringifier.stringify(object, _toEncodable, indent); |
| |
| /** |
| * Starts a chunked conversion. |
| * |
| * 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 _JsonEncoderSink(sink, _toEncodable, indent); |
| } |
| |
| // Override the base-classes bind, to provide a better type. |
| Stream<String> bind(Stream<Object> stream) => super.bind(stream); |
| |
| Converter<Object, dynamic> fuse(Converter<String, dynamic> other) { |
| if (other is Utf8Encoder) { |
| return new JsonUtf8Encoder(indent, _toEncodable); |
| } |
| return super.fuse(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>> { |
| /** 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 Function _toEncodable; |
| /** UTF-8 buffer size. */ |
| final int _bufferSize; |
| |
| /** |
| * Create converter. |
| * |
| * If [indent] is non-`null`, the converter attempts to "pretty-print" the |
| * JSON, and uses `indent` as the indentation. Otherwise the result has no |
| * whitespace outside of string literals. |
| * If `indent` contains characters that are not valid JSON whitespace |
| * characters, the result will not be valid JSON. JSON whitespace characters |
| * are space (U+0020), tab (U+0009), line feed (U+000a) and carriage return |
| * (U+000d) (ECMA 404). |
| * |
| * The [bufferSize] is the size of the internal buffers used to collect |
| * UTF-8 code units. |
| * If using [startChunkedConversion], it will be the size of the chunks. |
| * |
| * 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 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: { |
| 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); |
| } |
| bytes.add(chunk); |
| } |
| _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); |
| offset = end; |
| } |
| return result; |
| } |
| |
| /** |
| * Start a chunked conversion. |
| * |
| * Only one object can be passed into the returned sink. |
| * |
| * 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); |
| } |
| |
| // Override the base-classes bind, to provide a better type. |
| Stream<List<int>> bind(Stream<Object> stream) { |
| return super.bind(stream); |
| } |
| |
| Converter<Object, dynamic> fuse(Converter<List<int>, dynamic> other) { |
| return super.fuse(other); |
| } |
| } |
| |
| /** |
| * Implements the chunked conversion from object to its JSON representation. |
| * |
| * The sink only accepts one value, but will produce output in a chunked way. |
| */ |
| class _JsonEncoderSink extends ChunkedConversionSink<Object> { |
| final String _indent; |
| final Function _toEncodable; |
| final StringConversionSink _sink; |
| bool _isDone = false; |
| |
| _JsonEncoderSink(this._sink, this._toEncodable, this._indent); |
| |
| /** |
| * Encodes the given object [o]. |
| * |
| * It is an error to invoke this method more than once on any instance. While |
| * this makes the input effectly non-chunked the output will be generated in |
| * a chunked way. |
| */ |
| 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 */ } |
| } |
| |
| /** |
| * 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 Function _toEncodable; |
| final int _bufferSize; |
| bool _isDone = false; |
| _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); |
| _sink.close(); |
| } |
| |
| void close() { |
| if (!_isDone) { |
| _isDone = true; |
| _sink.close(); |
| } |
| } |
| } |
| |
| /** |
| * This class parses JSON strings and builds the corresponding objects. |
| */ |
| class JsonDecoder extends Converter<String, Object> { |
| final _Reviver _reviver; |
| /** |
| * Constructs a new JsonDecoder. |
| * |
| * The [reviver] may be `null`. |
| */ |
| const JsonDecoder([reviver(var key, var value)]) : this._reviver = reviver; |
| |
| /** |
| * Converts the given JSON-string [input] to its corresponding object. |
| * |
| * Parsed JSON values are of the types [num], [String], [bool], [Null], |
| * [List]s of parsed JSON values or [Map]s from [String] to parsed |
| * JSON values. |
| * |
| * If `this` was initialized with a reviver, then the parsing operation |
| * invokes the reviver on every object or list property that has been parsed. |
| * The arguments are the property name ([String]) or list index ([int]), and |
| * the value is the parsed value. The return value of the reviver is used as |
| * the value of that property instead the parsed value. |
| * |
| * Throws [FormatException] if the input is not valid JSON text. |
| */ |
| dynamic convert(String input) => _parseJson(input, _reviver); |
| |
| /** |
| * Starts a conversion from a chunked JSON string to its corresponding |
| * object. |
| * |
| * The output [sink] receives exactly one decoded element through `add`. |
| */ |
| external StringConversionSink startChunkedConversion(Sink<Object> sink); |
| |
| // Override the base-classes 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. |
| |
| Object _defaultToEncodable(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 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; |
| |
| /** List of objects currently being traversed. Used to detect cycles. */ |
| final List _seen = new List(); |
| /** Function called for each un-encodable object encountered. */ |
| final Function _toEncodable; |
| |
| _JsonStringifier(Object _toEncodable(Object o)) |
| : _toEncodable = (_toEncodable != null) ? _toEncodable |
| : _defaultToEncodable; |
| |
| /** Append a string to the JSON output. */ |
| void writeString(String characters); |
| /** Append part of a string to the JSON output. */ |
| void writeStringSlice(String characters, int start, int end); |
| /** Append a single character, given by its code point, to the JSON output. */ |
| void writeCharCode(int charCode); |
| /** Write a number to the JSON output. */ |
| void writeNumber(num number); |
| |
| // ('0' + x) or ('a' + x - 10) |
| static int hexDigit(int x) => x < 10 ? 48 + x : 87 + x; |
| |
| /** |
| * Write, and suitably escape, a string's content as a JSON string literal. |
| */ |
| void writeStringContent(String s) { |
| 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; |
| } |
| } 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); |
| } else if (offset < length) { |
| writeStringSlice(s, offset, length); |
| } |
| } |
| |
| /** |
| * Check if an encountered object is already being traversed. |
| * |
| * Records the object if it isn't already seen. |
| * Should have a matching call to [_removeSeen] when the object |
| * is no longer being traversed. |
| */ |
| void _checkCycle(object) { |
| for (int i = 0; i < _seen.length; i++) { |
| if (identical(object, _seen[i])) { |
| throw new JsonCyclicError(object); |
| } |
| } |
| _seen.add(object); |
| } |
| |
| /** |
| * Removes object from the list of currently traversed objects. |
| * |
| * Should be called in the opposite order of the matching [_checkCycle] |
| * calls. |
| */ |
| void _removeSeen(object) { |
| assert(!_seen.isEmpty); |
| assert(identical(_seen.last, object)); |
| _seen.removeLast(); |
| } |
| |
| /** |
| * Writes an object. |
| * |
| * If the object isn't directly encodable, the [_toEncodable] function |
| * gets one chance to return a replacement which is encodable. |
| */ |
| void writeObject(object) { |
| // Tries stringifying object directly. If it's not a simple value, List or |
| // Map, call toJson() to get a custom representation and try serializing |
| // that. |
| if (writeJsonValue(object)) return; |
| _checkCycle(object); |
| try { |
| var customJson = _toEncodable(object); |
| if (!writeJsonValue(customJson)) { |
| throw new JsonUnsupportedObjectError(object); |
| } |
| _removeSeen(object); |
| } catch (e) { |
| throw new JsonUnsupportedObjectError(object, cause: e); |
| } |
| } |
| |
| /** |
| * Serializes a [num], [String], [bool], [Null], [List] or [Map] value. |
| * |
| * Returns true if the value is one of these types, and false if not. |
| * If a value is both a [List] and a [Map], it's serialized as a [List]. |
| */ |
| 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; |
| } 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); |
| writeList(object); |
| _removeSeen(object); |
| return true; |
| } else if (object is Map) { |
| _checkCycle(object); |
| // writeMap can fail if keys are not all strings. |
| var success = writeMap(object); |
| _removeSeen(object); |
| return success; |
| } else { |
| return false; |
| } |
| } |
| |
| /** Serializes a [List]. */ |
| void writeList(List list) { |
| writeString('['); |
| if (list.length > 0) { |
| writeObject(list[0]); |
| for (int i = 1; i < list.length; i++) { |
| writeString(','); |
| writeObject(list[i]); |
| } |
| } |
| writeString(']'); |
| } |
| |
| /** Serializes a [Map]. */ |
| bool writeMap(Map<String, Object> map) { |
| if (map.isEmpty) { |
| writeString("{}"); |
| return true; |
| } |
| List keyValueList = new List(map.length * 2); |
| int i = 0; |
| bool allStringKeys = true; |
| map.forEach((key, value) { |
| if (key is! String) { |
| allStringKeys = false; |
| } |
| keyValueList[i++] = key; |
| keyValueList[i++] = value; |
| }); |
| if (!allStringKeys) return false; |
| writeString('{'); |
| String separator = '"'; |
| for (int i = 0; i < keyValueList.length; i += 2) { |
| writeString(separator); |
| separator = ',"'; |
| writeStringContent(keyValueList[i]); |
| writeString('":'); |
| writeObject(keyValueList[i + 1]); |
| } |
| writeString('}'); |
| return true; |
| } |
| } |
| |
| /** |
| * A modification of [_JsonStringifier] which indents the contents of [List] and |
| * [Map] objects using the specified indent value. |
| * |
| * Subclasses should implement [writeIndentation]. |
| */ |
| abstract class _JsonPrettyPrintMixin implements _JsonStringifier { |
| int _indentLevel = 0; |
| |
| /** |
| * Add [indentLevel] indentations to the JSON output. |
| */ |
| void writeIndentation(indentLevel); |
| |
| void writeList(List list) { |
| if (list.isEmpty) { |
| writeString('[]'); |
| } else { |
| writeString('[\n'); |
| _indentLevel++; |
| writeIndentation(_indentLevel); |
| writeObject(list[0]); |
| for (int i = 1; i < list.length; i++) { |
| writeString(',\n'); |
| writeIndentation(_indentLevel); |
| writeObject(list[i]); |
| } |
| writeString('\n'); |
| _indentLevel--; |
| writeIndentation(_indentLevel); |
| writeString(']'); |
| } |
| } |
| |
| bool writeMap(Map map) { |
| if (map.isEmpty) { |
| writeString("{}"); |
| return true; |
| } |
| List keyValueList = new List(map.length * 2); |
| int i = 0; |
| bool allStringKeys = true; |
| map.forEach((key, value) { |
| if (key is! String) { |
| allStringKeys = false; |
| } |
| keyValueList[i++] = key; |
| keyValueList[i++] = value; |
| }); |
| if (!allStringKeys) return false; |
| writeString('{\n'); |
| _indentLevel++; |
| String separator = ""; |
| for (int i = 0; i < keyValueList.length; i += 2) { |
| writeString(separator); |
| separator = ",\n"; |
| writeIndentation(_indentLevel); |
| writeString('"'); |
| writeStringContent(keyValueList[i]); |
| writeString('": '); |
| writeObject(keyValueList[i + 1]); |
| } |
| writeString('\n'); |
| _indentLevel--; |
| writeIndentation(_indentLevel); |
| writeString('}'); |
| return true; |
| } |
| } |
| |
| /** |
| * A specialziation of [_JsonStringifier] that writes its JSON to a string. |
| */ |
| class _JsonStringStringifier extends _JsonStringifier { |
| final StringSink _sink; |
| |
| _JsonStringStringifier(this._sink, _toEncodable) : super(_toEncodable); |
| |
| /** |
| * Convert object to a string. |
| * |
| * The [toEncodable] function is used to convert non-encodable objects |
| * to encodable ones. |
| * |
| * If [indent] is not `null`, the resulting JSON will be "pretty-printed" |
| * with newlines and indentation. The `indent` string is added as indentation |
| * for each indentation level. It should only contain valid JSON whitespace |
| * characters (space, tab, carriage return or line feed). |
| */ |
| static String stringify(object, toEncodable(object), String indent) { |
| StringBuffer output = new StringBuffer(); |
| printOn(object, output, toEncodable, indent); |
| return output.toString(); |
| } |
| |
| /** |
| * Convert object to a string, and write the result to the [output] sink. |
| * |
| * The result is written piecemally to the sink. |
| */ |
| static void printOn(object, StringSink output, toEncodable(object), |
| String indent) { |
| var stringifier; |
| if (indent == null) { |
| stringifier = new _JsonStringStringifier(output, toEncodable); |
| } 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 { |
| final String _indent; |
| |
| _JsonStringStringifierPretty(StringSink sink, Function toEncodable, |
| this._indent) |
| : super(sink, toEncodable); |
| |
| void writeIndentation(int count) { |
| for (int i = 0; i < count; i++) writeString(_indent); |
| } |
| } |
| |
| /** |
| * Specialization of [_JsonStringifier] that writes the JSON as UTF-8. |
| * |
| * The JSON text is UTF-8 encoded and written to [Uint8List] buffers. |
| * The buffers are then passed back to a user provided callback method. |
| */ |
| class _JsonUtf8Stringifier extends _JsonStringifier { |
| final int bufferSize; |
| final Function addChunk; |
| Uint8List buffer; |
| int index = 0; |
| |
| _JsonUtf8Stringifier(toEncodable, int bufferSize, this.addChunk) |
| : this.bufferSize = bufferSize, |
| buffer = new Uint8List(bufferSize), |
| super(toEncodable); |
| |
| /** |
| * 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, |
| toEncodableFunction(Object o), |
| int bufferSize, |
| void addChunk(Uint8List chunk, int start, int end)) { |
| _JsonUtf8Stringifier stringifier; |
| if (indent != null) { |
| stringifier = new _JsonUtf8StringifierPretty(toEncodableFunction, indent, |
| bufferSize, addChunk); |
| } else { |
| stringifier = new _JsonUtf8Stringifier(toEncodableFunction, |
| bufferSize, addChunk); |
| } |
| stringifier.writeObject(object); |
| stringifier.flush(); |
| } |
| |
| /** |
| * Must be called at the end to push the last chunk to the [addChunk] |
| * callback. |
| */ |
| void flush() { |
| if (index > 0) { |
| addChunk(buffer, 0, index); |
| } |
| buffer = null; |
| index = 0; |
| } |
| |
| void writeNumber(num number) { |
| writeAsciiString(number.toString()); |
| } |
| |
| /** Write a string that is known to not have non-ASCII characters. */ |
| void writeAsciiString(String string) { |
| // TODO(lrn): Optimize by copying directly into buffer instead of going |
| // through writeCharCode; |
| for (int i = 0; i < string.length; i++) { |
| int char = string.codeUnitAt(i); |
| assert(char <= 0x7f); |
| writeByte(char); |
| } |
| } |
| |
| void writeString(String string) { |
| writeStringSlice(string, 0, string.length); |
| } |
| |
| void writeStringSlice(String string, int start, int end) { |
| // TODO(lrn): Optimize by copying directly into buffer instead of going |
| // through writeCharCode/writeByte. Assumption is the most characters |
| // in starings are plain ASCII. |
| for (int i = start; i < end; i++) { |
| int char = string.codeUnitAt(i); |
| if (char <= 0x7f) { |
| writeByte(char); |
| } else { |
| if ((char & 0xFC00) == 0xD800 && i + 1 < end) { |
| // Lead surrogate. |
| int nextChar = string.codeUnitAt(i + 1); |
| if ((nextChar & 0xFC00) == 0xDC00) { |
| // Tail surrogate. |
| char = 0x10000 + ((char & 0x3ff) << 10) + (nextChar & 0x3ff); |
| writeFourByteCharCode(char); |
| i++; |
| continue; |
| } |
| } |
| writeMultiByteCharCode(char); |
| } |
| } |
| } |
| |
| void writeCharCode(int charCode) { |
| if (charCode <= 0x7f) { |
| writeByte(charCode); |
| return; |
| } |
| writeMultiByteCharCode(charCode); |
| } |
| |
| void writeMultiByteCharCode(int charCode) { |
| if (charCode <= 0x7ff) { |
| writeByte(0xC0 | (charCode >> 6)); |
| writeByte(0x80 | (charCode & 0x3f)); |
| return; |
| } |
| if (charCode <= 0xffff) { |
| writeByte(0xE0 | (charCode >> 12)); |
| writeByte(0x80 | ((charCode >> 6) & 0x3f)); |
| writeByte(0x80 | (charCode & 0x3f)); |
| return; |
| } |
| writeFourByteCharCode(charCode); |
| } |
| |
| void writeFourByteCharCode(int charCode) { |
| assert(charCode <= 0x10ffff); |
| writeByte(0xF0 | (charCode >> 18)); |
| writeByte(0x80 | ((charCode >> 12) & 0x3f)); |
| writeByte(0x80 | ((charCode >> 6) & 0x3f)); |
| writeByte(0x80 | (charCode & 0x3f)); |
| } |
| |
| void writeByte(int byte) { |
| assert(byte <= 0xff); |
| if (index == buffer.length) { |
| addChunk(buffer, 0, index); |
| buffer = new Uint8List(bufferSize); |
| index = 0; |
| } |
| buffer[index++] = byte; |
| } |
| } |
| |
| /** |
| * Pretty-printing version of [_JsonUtf8Stringifier]. |
| */ |
| class _JsonUtf8StringifierPretty extends _JsonUtf8Stringifier |
| with _JsonPrettyPrintMixin { |
| final List<int> indent; |
| _JsonUtf8StringifierPretty(toEncodableFunction, this.indent, |
| bufferSize, addChunk) |
| : super(toEncodableFunction, 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]); |
| } |
| } |
| } |
| } |
| } |
