Format all dart: library files

sdk/lib/core/string.dart

 // Copyright (c) 2012, 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.core;
 
 /**
  * A sequence of characters.
  *
  * A string can be either single or multiline. Single line strings are
@@ skipping 93 matching lines @@
    *     var clef = new String.fromCharCodes([0x1D11E]);
    *     clef.codeUnitAt(0); // 0xD834
    *     clef.codeUnitAt(1); // 0xDD1E
    *
    * If [start] and [end] is provided, only the values of [charCodes]
    * at positions from `start` to, but not including, `end`, are used.
    * The `start` and `end` values must satisfy
    * `0 <= start <= end <= charCodes.length`.
    */
   external factory String.fromCharCodes(Iterable<int> charCodes,
-                                        [int start = 0, int end]);
+      [int start = 0, int end]);
 
   /**
    * Allocates a new String for the specified [charCode].
    *
    * If the [charCode] can be represented by a single UTF-16 code unit, the new
    * string contains a single code unit. Otherwise, the [length] is 2 and
    * the code units form a surrogate pair. See documentation for
    * [fromCharCodes].
    *
    * Creating a String with half of a surrogate pair is allowed.
@@ skipping 12 matching lines @@
    *
    * Example of getting a value:
    *
    *     const String.fromEnvironment("defaultFloo", defaultValue: "no floo")
    *
    * Example of checking whether a declaration is there at all:
    *
    *     var isDeclared = const String.fromEnvironment("maybeDeclared") != null;
    */
   external const factory String.fromEnvironment(String name,
-                                                {String defaultValue});
+      {String defaultValue});
 
   /**
    * Gets the character (as a single-code-unit [String]) at the given [index].
    *
    * The returned string represents exactly one UTF-16 code unit, which may be
    * half of a surrogate pair. A single member of a surrogate pair is an
    * invalid UTF-16 string:
    *
    *     var clef = '\u{1D11E}';
    *     // These represent invalid UTF-16 strings.
@@ skipping 271 matching lines @@
    * is replaced by the result of calling [replace] with the match object.
    *
    * The optional [startIndex] is by default set to 0. If provided, it must be
    * an integer in the range `[0 .. len]`, where `len` is this string's length.
    *
    * If the value returned by calling `replace` is not a [String], it
    * is converted to a `String` using its `toString` method, which must
    * then return a string.
    */
   String replaceFirstMapped(Pattern from, String replace(Match match),
-                            [int startIndex = 0]);
+      [int startIndex = 0]);
 
   /**
    * Replaces all substrings that match [from] with [replace].
    *
    * Returns a new string in which the non-overlapping substrings matching
    * [from] (the ones iterated by `from.allMatches(thisString)`) are replaced
    * by the literal string [replace].
    *
    *     'resume'.replaceAll(new RegExp(r'e'), 'é'); // 'résumé'
    *
@@ skipping 101 matching lines @@
    * Each non-matched part is converted by a call to [onNonMatch]. If
    * [onNonMatch] is omitted, the non-matching part is used.
    *
    * Then all the converted parts are combined into the resulting string.
    *
    *     'Eats shoots leaves'.splitMapJoin((new RegExp(r'shoots')),
    *         onMatch:    (m) => '${m.group(0)}',
    *         onNonMatch: (n) => '*'); // *shoots*
    */
   String splitMapJoin(Pattern pattern,
-                      {String onMatch(Match match),
-                       String onNonMatch(String nonMatch)});
+      {String onMatch(Match match), String onNonMatch(String nonMatch)});
 
   /**
    * Returns an unmodifiable list of the UTF-16 code units of this string.
    */
   List<int> get codeUnits;
 
   /**
    * Returns an [Iterable] of Unicode code-points of this string.
    *
    * If the string contains surrogate pairs, they are combined and returned
@@ skipping 45 matching lines @@
     int length = string.length;
     int code = string.codeUnitAt(length - 1);
     if (_isTrailSurrogate(code) && string.length > 1) {
       int previousCode = string.codeUnitAt(length - 2);
       if (_isLeadSurrogate(previousCode)) {
         return _combineSurrogatePair(previousCode, code);
       }
     }
     return code;
   }
-
 }
 
 // Is then code (a 16-bit unsigned integer) a UTF-16 lead surrogate.
 bool _isLeadSurrogate(int code) => (code & 0xFC00) == 0xD800;
 
 // Is then code (a 16-bit unsigned integer) a UTF-16 trail surrogate.
 bool _isTrailSurrogate(int code) => (code & 0xFC00) == 0xDC00;
 
 // Combine a lead and a trail surrogate value into a single code point.
 int _combineSurrogatePair(int start, int end) {
@@ skipping 13 matching lines @@
   /**
    * Current code point.
    *
    * If the iterator has hit either end, the [_currentCodePoint] is null
    * and [: _position == _nextPosition :].
    */
   int _currentCodePoint;
 
   /** Create an iterator positioned at the beginning of the string. */
   RuneIterator(String string)
-      : this.string = string, _position = 0, _nextPosition = 0;
+      : this.string = string,
+        _position = 0,
+        _nextPosition = 0;
 
   /**
    * Create an iterator positioned before the [index]th code unit of the string.
    *
    * When created, there is no [current] value.
    * A [moveNext] will use the rune starting at [index] the current value,
    * and a [movePrevious] will use the rune ending just before [index] as the
    * the current value.
    *
    * The [index] position must not be in the middle of a surrogate pair.
    */
   RuneIterator.at(String string, int index)
-      : string = string, _position = index, _nextPosition = index {
+      : string = string,
+        _position = index,
+        _nextPosition = index {
     RangeError.checkValueInInterval(index, 0, string.length);
     _checkSplitSurrogate(index);
   }
 
   /** Throw an error if the index is in the middle of a surrogate pair. */
   void _checkSplitSurrogate(int index) {
-    if (index > 0 && index < string.length &&
+    if (index > 0 &&
+        index < string.length &&
         _isLeadSurrogate(string.codeUnitAt(index - 1)) &&
         _isTrailSurrogate(string.codeUnitAt(index))) {
       throw new ArgumentError('Index inside surrogate pair: $index');
     }
   }
 
   /**
    * Returns the starting position of the current rune in the string.
    *
    * Returns null if the [current] rune is null.
@@ skipping 93 matching lines @@
         _position = position - 1;
         _currentCodePoint = _combineSurrogatePair(prevCodeUnit, codeUnit);
         return true;
       }
     }
     _position = position;
     _currentCodePoint = codeUnit;
     return true;
   }
 }