Format all dart: library files

sdk/lib/convert/latin1.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;
 
 /**
  * An instance of the default implementation of the [Latin1Codec].
  *
  * This instance provides a convenient access to the most common ISO Latin 1
@@ skipping 32 matching lines @@
   /**
    * Decodes the Latin-1 [bytes] (a list of unsigned 8-bit integers) to the
    * corresponding string.
    *
    * If [bytes] contains values that are not in the range 0 .. 255, the decoder
    * will eventually throw a [FormatException].
    *
    * If [allowInvalid] is not provided, it defaults to the value used to create
    * this [Latin1Codec].
    */
-  String decode(List<int> bytes, { bool allowInvalid }) {
+  String decode(List<int> bytes, {bool allowInvalid}) {
     if (allowInvalid == null) allowInvalid = _allowInvalid;
     if (allowInvalid) {
       return const Latin1Decoder(allowInvalid: true).convert(bytes);
     } else {
       return const Latin1Decoder(allowInvalid: false).convert(bytes);
     }
   }
 
   Latin1Encoder get encoder => const Latin1Encoder();
 
-  Latin1Decoder get decoder =>
-      _allowInvalid ? const Latin1Decoder(allowInvalid: true)
-                    : const Latin1Decoder(allowInvalid: false);
+  Latin1Decoder get decoder => _allowInvalid
+      ? const Latin1Decoder(allowInvalid: true)
+      : const Latin1Decoder(allowInvalid: false);
 }
 
 /**
  * This class converts strings of only ISO Latin-1 characters to bytes.
  */
 class Latin1Encoder extends _UnicodeSubsetEncoder {
   const Latin1Encoder() : super(_LATIN1_MASK);
 }
 
 /**
  * This class converts Latin-1 bytes (lists of unsigned 8-bit integers)
  * to a string.
  */
 class Latin1Decoder extends _UnicodeSubsetDecoder {
   /**
    * Instantiates a new [Latin1Decoder].
    *
    * The optional [allowInvalid] argument defines how [convert] deals
    * with invalid bytes.
    *
    * If it is `true`, [convert] replaces invalid bytes with the Unicode
    * Replacement character `U+FFFD` (�).
    * Otherwise it throws a [FormatException].
    */
-  const Latin1Decoder({ bool allowInvalid: false })
+  const Latin1Decoder({bool allowInvalid: false})
       : super(allowInvalid, _LATIN1_MASK);
 
   /**
    * Starts a chunked conversion.
    *
    * The converter works more efficiently if the given [sink] is a
    * [StringConversionSink].
    */
   ByteConversionSink startChunkedConversion(Sink<String> sink) {
     StringConversionSink stringSink;
@@ skipping 43 matching lines @@
   }
 
   static void _checkValidLatin1(List<int> source, int start, int end) {
     int mask = 0;
     for (int i = start; i < end; i++) {
       mask |= source[i];
     }
     if (mask >= 0 && mask <= _LATIN1_MASK) {
       return;
     }
-    _reportInvalidLatin1(source, start, end);  // Always throws.
+    _reportInvalidLatin1(source, start, end); // Always throws.
   }
 
-
   static void _reportInvalidLatin1(List<int> source, int start, int end) {
     // Find the index of the first non-Latin-1 character code.
     for (int i = start; i < end; i++) {
       int char = source[i];
       if (char < 0 || char > _LATIN1_MASK) {
-        throw new FormatException("Source contains non-Latin-1 characters.",
-                                  source, i);
+        throw new FormatException(
+            "Source contains non-Latin-1 characters.", source, i);
       }
     }
     // Unreachable - we only call the function if the loop above throws.
     assert(false);
   }
 }
 
 class _Latin1AllowInvalidDecoderSink extends _Latin1DecoderSink {
-  _Latin1AllowInvalidDecoderSink(StringConversionSink sink): super(sink);
+  _Latin1AllowInvalidDecoderSink(StringConversionSink sink) : super(sink);
 
   void addSlice(List<int> source, int start, int end, bool isLast) {
     RangeError.checkValidRange(start, end, source.length);
     for (int i = start; i < end; i++) {
       int char = source[i];
       if (char > _LATIN1_MASK || char < 0) {
         if (i > start) _addSliceToSink(source, start, i, false);
         // Add UTF-8 encoding of U+FFFD.
-        _addSliceToSink(const[0xFFFD], 0, 1, false);
+        _addSliceToSink(const [0xFFFD], 0, 1, false);
         start = i + 1;
       }
     }
     if (start < end) {
       _addSliceToSink(source, start, end, isLast);
     }
     if (isLast) {
       close();
     }
   }
 }