Format all dart: library files

sdk/lib/core/date_time.dart

 // Copyright (c) 2011, 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;
 
 /**
  * An instant in time, such as July 20, 1969, 8:18pm GMT.
  *
  * Create a DateTime object by using one of the constructors
@@ skipping 137 matching lines @@
 
   /**
    * Constructs a [DateTime] instance specified in the local time zone.
    *
    * For example,
    * to create a new DateTime object representing April 29, 2014, 6:04am:
    *
    *     DateTime annularEclipse = new DateTime(2014, DateTime.APRIL, 29, 6, 4);
    */
   DateTime(int year,
-           [int month = 1,
-            int day = 1,
-            int hour = 0,
-            int minute = 0,
-            int second = 0,
-            int millisecond = 0,
-            int microsecond = 0])
-      : this._internal(
-            year, month, day, hour, minute, second, millisecond, microsecond,
-            false);
+      [int month = 1,
+      int day = 1,
+      int hour = 0,
+      int minute = 0,
+      int second = 0,
+      int millisecond = 0,
+      int microsecond = 0])
+      : this._internal(year, month, day, hour, minute, second, millisecond,
+            microsecond, false);
 
   /**
    * Constructs a [DateTime] instance specified in the UTC time zone.
    *
    *     DateTime dDay = new DateTime.utc(1944, DateTime.JUNE, 6);
    */
   DateTime.utc(int year,
-               [int month = 1,
-                int day = 1,
-                int hour = 0,
-                int minute = 0,
-                int second = 0,
-                int millisecond = 0,
-                int microsecond = 0])
-    : this._internal(
-          year, month, day, hour, minute, second, millisecond, microsecond,
-          true);
+      [int month = 1,
+      int day = 1,
+      int hour = 0,
+      int minute = 0,
+      int second = 0,
+      int millisecond = 0,
+      int microsecond = 0])
+      : this._internal(year, month, day, hour, minute, second, millisecond,
+            microsecond, true);
 
   /**
    * Constructs a [DateTime] instance with current date and time in the
    * local time zone.
    *
    *     DateTime thisInstant = new DateTime.now();
    *
    */
   DateTime.now() : this._now();
 
@@ skipping 61 matching lines @@
      * day ::= digit{2}
      * time_opt ::= <empty> | (' ' | 'T') hour minutes_opt
      * minutes_opt ::= <empty> | colon_opt digit{2} seconds_opt
      * seconds_opt ::= <empty> | colon_opt digit{2} millis_opt
      * micros_opt ::= <empty> | '.' digit{1,6}
      * timezone_opt ::= <empty> | space_opt timezone
      * space_opt :: ' ' | <empty>
      * timezone ::= 'z' | 'Z' | sign digit{2} timezonemins_opt
      * timezonemins_opt ::= <empty> | colon_opt digit{2}
      */
-    final RegExp re = new RegExp(
-        r'^([+-]?\d{4,6})-?(\d\d)-?(\d\d)'  // Day part.
+    final RegExp re = new RegExp(r'^([+-]?\d{4,6})-?(\d\d)-?(\d\d)' // Day part.
         r'(?:[ T](\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d{1,6}))?)?)?' // Time part.
         r'( ?[zZ]| ?([-+])(\d\d)(?::?(\d\d))?)?)?$'); // Timezone part.
 
     Match match = re.firstMatch(formattedString);
     if (match != null) {
       int parseIntOrZero(String matched) {
         if (matched == null) return 0;
         return int.parse(matched);
       }
 
@@ skipping 21 matching lines @@
       int hour = parseIntOrZero(match[4]);
       int minute = parseIntOrZero(match[5]);
       int second = parseIntOrZero(match[6]);
       bool addOneMillisecond = false;
       int milliAndMicroseconds = parseMilliAndMicroseconds(match[7]);
       int millisecond =
           milliAndMicroseconds ~/ Duration.MICROSECONDS_PER_MILLISECOND;
       int microsecond =
           milliAndMicroseconds.remainder(Duration.MICROSECONDS_PER_MILLISECOND);
       bool isUtc = false;
-      if (match[8] != null) {  // timezone part
+      if (match[8] != null) {
+        // timezone part
         isUtc = true;
         if (match[9] != null) {
           // timezone other than 'Z' and 'z'.
           int sign = (match[9] == '-') ? -1 : 1;
           int hourDifference = int.parse(match[10]);
           int minuteDifference = parseIntOrZero(match[11]);
           minuteDifference += 60 * hourDifference;
           minute -= sign * minuteDifference;
         }
       }
-      int value = _brokenDownDateToValue(
-          years, month, day, hour, minute, second, millisecond, microsecond,
-          isUtc);
+      int value = _brokenDownDateToValue(years, month, day, hour, minute,
+          second, millisecond, microsecond, isUtc);
       if (value == null) {
         throw new FormatException("Time out of range", formattedString);
       }
       return new DateTime._withValue(value, isUtc: isUtc);
     } else {
       throw new FormatException("Invalid date format", formattedString);
     }
   }
 
   static const int _MAX_MILLISECONDS_SINCE_EPOCH = 8640000000000000;
 
   /**
    * Constructs a new [DateTime] instance
    * with the given [millisecondsSinceEpoch].
    *
    * If [isUtc] is false then the date is in the local time zone.
    *
    * The constructed [DateTime] represents
    * 1970-01-01T00:00:00Z + [millisecondsSinceEpoch] ms in the given
    * time zone (local or UTC).
    */
   external DateTime.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch,
-                                              {bool isUtc: false});
+      {bool isUtc: false});
 
   /**
    * Constructs a new [DateTime] instance
    * with the given [microsecondsSinceEpoch].
    *
    * If [isUtc] is false then the date is in the local time zone.
    *
    * The constructed [DateTime] represents
    * 1970-01-01T00:00:00Z + [microsecondsSinceEpoch] us in the given
    * time zone (local or UTC).
    */
   external DateTime.fromMicrosecondsSinceEpoch(int microsecondsSinceEpoch,
-                                               {bool isUtc: false});
+      {bool isUtc: false});
 
   /**
    * Constructs a new [DateTime] instance with the given value.
    *
    * If [isUtc] is false then the date is in the local time zone.
    */
   DateTime._withValue(this._value, {this.isUtc}) {
     if (millisecondsSinceEpoch.abs() > _MAX_MILLISECONDS_SINCE_EPOCH ||
         (millisecondsSinceEpoch.abs() == _MAX_MILLISECONDS_SINCE_EPOCH &&
-         microsecond != 0)) {
+            microsecond != 0)) {
       throw new ArgumentError(millisecondsSinceEpoch);
     }
     if (isUtc == null) throw new ArgumentError(isUtc);
   }
 
   /**
    * Returns true if [other] is a [DateTime] at the same moment and in the
    * same time zone (UTC or local).
    *
    *     DateTime dDayUtc   = new DateTime.utc(1944, DateTime.JUNE, 6);
@@ skipping 167 matching lines @@
    * * `HH` are hours in the range 00 to 23,
    * * `mm` are minutes in the range 00 to 59,
    * * `ss` are seconds in the range 00 to 59 (no leap seconds),
    * * `mmm` are milliseconds in the range 000 to 999, and
    * * `uuu` are microseconds in the range 001 to 999. If [microsecond] equals
    *   0, then this part is omitted.
    *
    * The resulting string can be parsed back using [parse].
    */
   String toIso8601String() {
-    String y = (year >= -9999 && year <= 9999) ? _fourDigits(year)
-                                               : _sixDigits(year);
+    String y =
+        (year >= -9999 && year <= 9999) ? _fourDigits(year) : _sixDigits(year);
     String m = _twoDigits(month);
     String d = _twoDigits(day);
     String h = _twoDigits(hour);
     String min = _twoDigits(minute);
     String sec = _twoDigits(second);
     String ms = _threeDigits(millisecond);
     String us = microsecond == 0 ? "" : _threeDigits(microsecond);
     if (isUtc) {
       return "$y-$m-${d}T$h:$min:$sec.$ms${us}Z";
     } else {
@@ skipping 52 matching lines @@
    *     DateTime berlinWallFell = new DateTime(1989, DateTime.NOVEMBER, 9);
    *     DateTime dDay = new DateTime(1944, DateTime.JUNE, 6);
    *     Duration difference = berlinWallFell.difference(dDay);
    *     assert(difference.inDays == 16592);
    *
    * will fail because the difference is actually 16591 days and 23 hours, and
    * [Duration.inDays] only returns the number of whole days.
    */
   external Duration difference(DateTime other);
 
-  external DateTime._internal(int year,
-                              int month,
-                              int day,
-                              int hour,
-                              int minute,
-                              int second,
-                              int millisecond,
-                              int microsecond,
-                              bool isUtc);
+  external DateTime._internal(int year, int month, int day, int hour,
+      int minute, int second, int millisecond, int microsecond, bool isUtc);
 
   external DateTime._now();
 
   /// Returns the time as value (millisecond or microsecond since epoch), or
   /// null if the values are out of range.
   external static int _brokenDownDateToValue(
-      int year, int month, int day, int hour, int minute, int second,
-      int millisecond, int microsecond, bool isUtc);
+      int year,
+      int month,
+      int day,
+      int hour,
+      int minute,
+      int second,
+      int millisecond,
+      int microsecond,
+      bool isUtc);
 
   /**
    * The number of milliseconds since
    * the "Unix epoch" 1970-01-01T00:00:00Z (UTC).
    *
    * This value is independent of the time zone.
    *
    * This value is at most
    * 8,640,000,000,000,000ms (100,000,000 days) from the Unix epoch.
    * In other words: `millisecondsSinceEpoch.abs() <= 8640000000000000`.
@@ skipping 110 matching lines @@
    * In accordance with ISO 8601
    * a week starts with Monday, which has the value 1.
    *
    *     DateTime moonLanding = DateTime.parse("1969-07-20 20:18:00");
    *     assert(moonLanding.weekday == 7);
    *     assert(moonLanding.weekday == DateTime.SUNDAY);
    *
    */
   external int get weekday;
 }