Rename Date to DateTime.

pkg/intl/lib/src/date_format_field.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 intl;
 
 /**
  * This is a private class internal to DateFormat which is used for formatting
  * particular fields in a template. e.g. if the format is hh:mm:ss then the
  * fields would be "hh", ":", "mm", ":", and "ss". Each type of field knows
@@ skipping 12 matching lines @@
    * Return the width of [pattern]. Different widths represent different
    * formatting options. See the comment for DateFormat for details.
    */
   int get width => pattern.length;
 
   String fullPattern() => pattern;
 
   String toString() => pattern;
 
   /** Format date according to our specification and return the result. */
-  String format(Date date) {
+  String format(DateTime date) {
     // Default implementation in the superclass, works for both types of
     // literal patterns, and is overridden by _DateFormatPatternField.
     return pattern;
   }
 
   /** Abstract method for subclasses to implementing parsing for their format.*/
   void parse(_Stream input, _DateBuilder dateFields);
 
   /** Parse a literal field. We just look for the exact input. */
   void parseLiteral(_Stream input) {
@@ skipping 57 matching lines @@
 /*
  * Represents a field in the pattern that formats some aspect of the
  * date. Consists primarily of a switch on the particular pattern characters
  * to determine what to do.
  */
 class _DateFormatPatternField extends _DateFormatField {
 
   _DateFormatPatternField(pattern, parent): super(pattern,  parent);
 
   /** Format date according to our specification and return the result. */
-  String format(Date date) {
+  String format(DateTime date) {
       return formatField(date);
   }
 
   /**
    * Parse the date according to our specification and put the result
    * into the correct place in dateFields.
    */
   void parse(_Stream input, _DateBuilder dateFields) {
     parseField(input, dateFields);
   }
@@ skipping 23 matching lines @@
        case 'v': break; // time zone id
        case 'y': handleNumericField(input, builder.setYear); break;
        case 'z': break; // time zone
        case 'Z': break; // time zone RFC
        default: return;
      }
    } catch (e) { throwFormatException(input); }
  }
 
   /** Formatting logic if we are of type FIELD */
-  String formatField(Date date) {
+  String formatField(DateTime date) {
      switch (pattern[0]) {
       case 'a': return formatAmPm(date);
       case 'c': return formatStandaloneDay(date);
       case 'd': return formatDayOfMonth(date);
       case 'E': return formatDayOfWeek(date);
       case 'G': return formatEra(date);
       case 'h': return format1To12Hours(date);
       case 'H': return format0To23Hours(date);
       case 'K': return format0To11Hours(date);
       case 'k': return format24Hours(date);
       case 'L': return formatStandaloneMonth(date);
       case 'M': return formatMonth(date);
       case 'm': return formatMinutes(date);
       case 'Q': return formatQuarter(date);
       case 'S': return formatFractionalSeconds(date);
       case 's': return formatSeconds(date);
       case 'v': return formatTimeZoneId(date);
       case 'y': return formatYear(date);
       case 'z': return formatTimeZone(date);
       case 'Z': return formatTimeZoneRFC(date);
       default: return '';
     }
   }
 
   /** Return the symbols for our current locale. */
   DateSymbols get symbols => dateTimeSymbols[parent.locale];
 
-  formatEra(Date date) {
+  formatEra(DateTime date) {
     var era = date.year > 0 ? 1 : 0;
     return width >= 4 ? symbols.ERANAMES[era] :
                         symbols.ERAS[era];
   }
 
-  formatYear(Date date) {
+  formatYear(DateTime date) {
     // TODO(alanknight): Proper handling of years <= 0
     var year = date.year;
     if (year < 0) {
       year = -year;
     }
     return width == 2 ? padTo(2, year % 100) : year.toString();
   }
 
   /**
    * We are given [input] as a stream from which we want to read a date. We
@@ skipping 22 matching lines @@
      var results = new _Stream(possibilities).findIndexes(
        (each) => input.peek(each.length) == each);
      if (results.isEmpty) throwFormatException(input);
      results.sort(
        (a, b) => possibilities[a].length.compareTo(possibilities[b].length));
      var longestResult = results.last;
      input.read(possibilities[longestResult].length);
      return longestResult;
      }
 
-  String formatMonth(Date date) {
+  String formatMonth(DateTime date) {
     switch (width) {
       case 5: return symbols.NARROWMONTHS[date.month-1];
       case 4: return symbols.MONTHS[date.month-1];
       case 3: return symbols.SHORTMONTHS[date.month-1];
       default:
         return padTo(width, date.month);
     }
   }
 
   void parseMonth(input, dateFields) {
     var possibilities;
     switch(width) {
       case 5: possibilities = symbols.NARROWMONTHS; break;
       case 4: possibilities = symbols.MONTHS; break;
       case 3: possibilities = symbols.SHORTMONTHS; break;
       default: return handleNumericField(input, dateFields.setMonth);
     }
     dateFields.month = parseEnumeratedString(input, possibilities) + 1;
   }
 
-  String format24Hours(Date date) {
+  String format24Hours(DateTime date) {
     return padTo(width, date.hour);
   }
 
-  String formatFractionalSeconds(Date date) {
+  String formatFractionalSeconds(DateTime date) {
     // Always print at least 3 digits. If the width is greater, append 0s
     var basic = padTo(3, date.millisecond);
     if (width - 3 > 0) {
       var extra = padTo(width - 3, 0);
       return basic.concat(extra);
     } else {
       return basic;
     }
   }
 
-  String formatAmPm(Date date) {
+  String formatAmPm(DateTime date) {
     var hours = date.hour;
     var index = (date.hour >= 12) && (date.hour < 24) ? 1 : 0;
     var ampm = symbols.AMPMS;
     return ampm[index];
   }
 
   void parseAmPm(input, dateFields) {
     // If we see a "PM" note it in an extra field.
     var ampm = parseEnumeratedString(input, symbols.AMPMS);
     if (ampm == 1) dateFields.pm = true;
   }
 
-  String format1To12Hours(Date date) {
+  String format1To12Hours(DateTime date) {
     var hours = date.hour;
     if (date.hour > 12) hours = hours - 12;
     if (hours == 0) hours = 12;
     return padTo(width, hours);
   }
 
   void parse1To12Hours(_Stream input, _DateBuilder dateFields) {
     handleNumericField(input, dateFields.setHour);
     if (dateFields.hour == 12) dateFields.hour = 0;
   }
 
-  String format0To11Hours(Date date) {
+  String format0To11Hours(DateTime date) {
     return padTo(width, date.hour % 12);
   }
 
-  String format0To23Hours(Date date) {
+  String format0To23Hours(DateTime date) {
     return padTo(width, date.hour);
   }
 
-  String formatStandaloneDay(Date date) {
+  String formatStandaloneDay(DateTime date) {
     switch (width) {
       case 5: return symbols.STANDALONENARROWWEEKDAYS[date.weekday % 7];
       case 4: return symbols.STANDALONEWEEKDAYS[date.weekday % 7];
       case 3: return symbols.STANDALONESHORTWEEKDAYS[date.weekday % 7];
       default:
         return padTo(1, date.day);
     }
   }
 
   void parseStandaloneDay(_Stream input) {
     // This is ignored, but we still have to skip over it the correct amount.
     var possibilities;
     switch(width) {
       case 5: possibilities = symbols.STANDALONENARROWWEEKDAYS; break;
       case 4: possibilities = symbols.STANDALONEWEEKDAYS; break;
       case 3: possibilities = symbols.STANDALONESHORTWEEKDAYS; break;
       default: return handleNumericField(input, (x)=>x);
     }
     parseEnumeratedString(input, possibilities);
   }
 
-  String formatStandaloneMonth(Date date) {
+  String formatStandaloneMonth(DateTime date) {
   switch (width) {
     case 5:
       return symbols.STANDALONENARROWMONTHS[date.month-1];
     case 4:
       return symbols.STANDALONEMONTHS[date.month-1];
     case 3:
       return symbols.STANDALONESHORTMONTHS[date.month-1];
     default:
       return padTo(width, date.month);
     }
   }
 
   void parseStandaloneMonth(input, dateFields) {
     var possibilities;
     switch(width) {
       case 5: possibilities = symbols.STANDALONENARROWMONTHS; break;
       case 4: possibilities = symbols.STANDALONEMONTHS; break;
       case 3: possibilities = symbols.STANDALONESHORTMONTHS; break;
       default: return handleNumericField(input, dateFields.setMonth);
     }
     dateFields.month = parseEnumeratedString(input, possibilities) + 1;
   }
 
-  String formatQuarter(Date date) {
+  String formatQuarter(DateTime date) {
     var quarter = (date.month / 3).truncate().toInt();
     if (width < 4) {
       return symbols.SHORTQUARTERS[quarter];
     } else {
       return symbols.QUARTERS[quarter];
     }
   }
-  String formatDayOfMonth(Date date) {
+  String formatDayOfMonth(DateTime date) {
     return padTo(width, date.day);
   }
 
-  String formatDayOfWeek(Date date) {
+  String formatDayOfWeek(DateTime date) {
     // Note that Dart's weekday returns 1 for Monday and 7 for Sunday.
     return (width >= 4 ? symbols.WEEKDAYS :
                         symbols.SHORTWEEKDAYS)[(date.weekday) % 7];
   }
 
   void parseDayOfWeek(_Stream input) {
     // This is IGNORED, but we still have to skip over it the correct amount.
     var possibilities = width >= 4 ? symbols.WEEKDAYS : symbols.SHORTWEEKDAYS;
     parseEnumeratedString(input, possibilities);
   }
 
-  String formatMinutes(Date date) {
+  String formatMinutes(DateTime date) {
     return padTo(width, date.minute);
   }
 
-  String formatSeconds(Date date) {
+  String formatSeconds(DateTime date) {
     return padTo(width, date.second);
   }
 
-  String formatTimeZoneId(Date date) {
+  String formatTimeZoneId(DateTime date) {
     // TODO(alanknight): implement time zone support
     throw new UnimplementedError();
   }
 
-  String formatTimeZone(Date date) {
+  String formatTimeZone(DateTime date) {
     throw new UnimplementedError();
   }
 
-  String formatTimeZoneRFC(Date date) {
+  String formatTimeZoneRFC(DateTime date) {
     throw new UnimplementedError();
   }
 
  /**
   * Return a string representation of the object padded to the left with
   * zeros. Primarily useful for numbers.
   */
   String padTo(int width, Object toBePrinted) {
     var basicString = toBePrinted.toString();
     if (basicString.length >= width) return basicString;
     var buffer = new StringBuffer();
     for (var i = 0; i < width - basicString.length; i++) {
       buffer.add('0');
      }
     buffer.add(basicString);
     return buffer.toString();
   }
 }