sdk/lib/core/date_time.dart - sdk.git - Git at Google

 // 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;

 /**
  * Deprecated class. Please use [DateTime] instead.
  */
 @deprecated
 abstract class Date implements Comparable {
   // Weekday constants that are returned by [weekday] method:
   static const int MON = 1;
   static const int TUE = 2;
   static const int WED = 3;
   static const int THU = 4;
   static const int FRI = 5;
   static const int SAT = 6;
   static const int SUN = 7;
   static const int DAYS_IN_WEEK = 7;

   // Month constants that are returned by the [month] getter.
   static const int JAN = 1;
   static const int FEB = 2;
   static const int MAR = 3;
   static const int APR = 4;
   static const int MAY = 5;
   static const int JUN = 6;
   static const int JUL = 7;
   static const int AUG = 8;
   static const int SEP = 9;
   static const int OCT = 10;
   static const int NOV = 11;
   static const int DEC = 12;

   factory Date(int year,
                [int month = 1,
                 int day = 1,
                 int hour = 0,
                 int minute = 0,
                 int second = 0,
                 int millisecond = 0]) {
     return new DateTime(year, month, day, hour, minute, second, millisecond);
   }

   factory Date.utc(int year,
                    [int month = 1,
                     int day = 1,
                     int hour = 0,
                     int minute = 0,
                     int second = 0,
                     int millisecond = 0]) {
     return
         new DateTime.utc(year, month, day, hour, minute, second, millisecond);
   }

   factory Date.now() => new DateTime.now();

   factory Date.fromString(String formattedString)
       => DateTime.parse(formattedString);

   factory Date.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch,
                                           {bool isUtc: false}) {
     return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
                                                    isUtc: isUtc);
   }

   bool operator ==(DateTime other);
   bool operator <(DateTime other);
   bool operator <=(DateTime other);
   bool operator >(DateTime other);
   bool operator >=(DateTime other);


   DateTime toLocal();
   DateTime toUtc();

   String get timeZoneName;
   Duration get timeZoneOffset;

   int get year;
   int get month;
   int get day;
   int get hour;
   int get minute;
   int get second;
   int get millisecond;

   int get weekday;

   int get millisecondsSinceEpoch;

   bool get isUtc;

   String toString();

   DateTime add(Duration duration);
   DateTime subtract(Duration duration);
   Duration difference(DateTime other);
 }

 /**
  * A DateTime object represents a point in time.
  *
  * It can represent time values that are at a distance of at most
  * 8,640,000,000,000,000ms (100,000,000 days) from epoch (1970-01-01 UTC). In
  * other words: [:millisecondsSinceEpoch.abs() <= 8640000000000000:].
  *
  * Also see [Stopwatch] for means to measure time-spans.
  */
 class DateTime implements Date {
   // Weekday constants that are returned by [weekday] method:
   static const int MON = 1;
   static const int TUE = 2;
   static const int WED = 3;
   static const int THU = 4;
   static const int FRI = 5;
   static const int SAT = 6;
   static const int SUN = 7;
   static const int DAYS_IN_WEEK = 7;

   // Month constants that are returned by the [month] getter.
   static const int JAN = 1;
   static const int FEB = 2;
   static const int MAR = 3;
   static const int APR = 4;
   static const int MAY = 5;
   static const int JUN = 6;
   static const int JUL = 7;
   static const int AUG = 8;
   static const int SEP = 9;
   static const int OCT = 10;
   static const int NOV = 11;
   static const int DEC = 12;

   /**
    * The milliseconds since 1970-01-01T00:00:00Z (UTC). This value is
    * independent of the time zone.
    *
    * See [Stopwatch] for means to measure time-spans.
    */
   final int millisecondsSinceEpoch;

   /**
    * True if this [DateTime] is set to UTC time.
    */
   final bool isUtc;

   /**
    * Constructs a [DateTime] instance based on the individual parts. The date is
    * in the local time zone.
    *
    * [month] and [day] are one-based. For example
    * [:new DateTime(1938, 1, 10):] represents the 10th of January 1938.
    */
   // TODO(8042): This should be a redirecting constructor and not a factory.
   factory DateTime(int year,
            [int month = 1,
             int day = 1,
             int hour = 0,
             int minute = 0,
             int second = 0,
             int millisecond = 0]) {
     return new DateTime._internal(
           year, month, day, hour, minute, second, millisecond, false);
   }

   /**
    * Constructs a [DateTime] instance based on the individual parts. The date is
    * in the UTC time zone.
    *
    * [month] and [day] are one-based. For example
    * [:new DateTime.utc(1938, 1, 10):] represents the 10th of January 1938 in
    * Coordinated Universal Time.
    */
   // TODO(8042): This should be a redirecting constructor and not a factory.
   factory DateTime.utc(int year,
                        [int month = 1,
                         int day = 1,
                         int hour = 0,
                         int minute = 0,
                         int second = 0,
                         int millisecond = 0]) {
     return new DateTime._internal(
           year, month, day, hour, minute, second, millisecond, true);
   }

   /**
    * Constructs a new [DateTime] instance with current date time value in the
    * local time zone.
    */
   // TODO(8042): This should be a redirecting constructor and not a factory.
   factory DateTime.now() { return new DateTime._now(); }

   /**
    * Constructs a new [DateTime] instance based on [formattedString].
    *
    * The function parses a subset of ISO 8601. Examples of accepted strings:
    *
    * * `"2012-02-27 13:27:00"`
    * * `"2012-02-27 13:27:00.123456z"`
    * * `"20120227 13:27:00"`
    * * `"20120227T132700"`
    * * `"20120227"`
    * * `"+20120227"`
    * * `"2012-02-27T14Z"`
    * * `"-123450101 00:00:00 Z"`: in the year -12345.
    */
   // TODO(floitsch): specify grammar.
   static DateTime parse(String formattedString) {
     final RegExp re = new RegExp(
         r'^([+-]?\d?\d\d\d\d)-?(\d\d)-?(\d\d)'  // The day part.
         r'(?:[ T](\d\d)(?::?(\d\d)(?::?(\d\d)(.\d{1,6})?)?)? ?([zZ])?)?$');
     Match match = re.firstMatch(formattedString);
     if (match != null) {
       int parseIntOrZero(String matched) {
         if (matched == null) return 0;
         return int.parse(matched);
       }

       double parseDoubleOrZero(String matched) {
         if (matched == null) return 0.0;
         return double.parse(matched);
       }

       int years = int.parse(match[1]);
       int month = int.parse(match[2]);
       int day = int.parse(match[3]);
       int hour = parseIntOrZero(match[4]);
       int minute = parseIntOrZero(match[5]);
       int second = parseIntOrZero(match[6]);
       bool addOneMillisecond = false;
       int millisecond = (parseDoubleOrZero(match[7]) * 1000).round().toInt();
       if (millisecond == 1000) {
         addOneMillisecond = true;
         millisecond = 999;
       }
       // TODO(floitsch): we should not need to test against the empty string.
       bool isUtc = (match[8] != null) && (match[8] != "");
       int millisecondsSinceEpoch = _brokenDownDateToMillisecondsSinceEpoch(
           years, month, day, hour, minute, second, millisecond, isUtc);
       if (millisecondsSinceEpoch == null) {
         throw new ArgumentError(formattedString);
       }
       if (addOneMillisecond) millisecondsSinceEpoch++;
       return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
                                                      isUtc: isUtc);
     } else {
       throw new ArgumentError(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).
    */
   // TODO(lrn): Have two constructors instead of taking an optional bool.
   DateTime.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch,
                                       {bool isUtc: false})
       : this.millisecondsSinceEpoch = millisecondsSinceEpoch,
         this.isUtc = isUtc {
     if (millisecondsSinceEpoch.abs() > _MAX_MILLISECONDS_SINCE_EPOCH) {
       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 timezone (UTC or local).
    *
    * See [isAtSameMomentAs] for a comparison that ignores the timezone.
    */
   bool operator ==(other) {
     if (!(other is DateTime)) return false;
     return (millisecondsSinceEpoch == other.millisecondsSinceEpoch &&
             isUtc == other.isUtc);
   }

   /**
    * Returns true if [this] occurs before [other]. The comparison is independent
    * of whether the time is in UTC or in the local time zone.
    *
    * *Deprecated* Use [isBefore] instead.
    */
   @deprecated
   bool operator <(DateTime other)
       => millisecondsSinceEpoch < other.millisecondsSinceEpoch;

   /**
    * Returns true if [this] occurs at the same time or before [other]. The
    * comparison is independent of whether the time is in UTC or in the local
    * time zone.
    *
    * *Deprecated* Use [isAfter] instead ([:!isAfter:]).
    */
   @deprecated
   bool operator <=(DateTime other)
       => millisecondsSinceEpoch <= other.millisecondsSinceEpoch;

   /**
    * Returns true if [this] occurs after [other]. The comparison is independent
    * of whether the time is in UTC or in the local time zone.
    *
    * *Deprecated* Use [isAfter] instead.
    */
   @deprecated
   bool operator >(DateTime other)
       => millisecondsSinceEpoch > other.millisecondsSinceEpoch;

   /**
    * Returns true if [this] occurs at the same time or after [other]. The
    * comparison is independent of whether the time is in UTC or in the local
    * time zone.
    *
    * *Deprecated* Use [isBefore] instead ([:!isBefore:]).
    */
   @deprecated
   bool operator >=(DateTime other)
       => millisecondsSinceEpoch >= other.millisecondsSinceEpoch;

   /**
    * Returns true if [this] occurs before [other]. The comparison is independent
    * of whether the time is in UTC or in the local time zone.
    */
   bool isBefore(DateTime other) {
     return millisecondsSinceEpoch < other.millisecondsSinceEpoch;
   }

   /**
    * Returns true if [this] occurs after [other]. The comparison is independent
    * of whether the time is in UTC or in the local time zone.
    */
   bool isAfter(DateTime other) {
     return millisecondsSinceEpoch > other.millisecondsSinceEpoch;
   }

   /**
    * Returns true if [this] occurs at the same moment as [other]. The
    * comparison is independent of whether the time is in UTC or in the local
    * time zone.
    */
   bool isAtSameMomentAs(DateTime other) {
     return millisecondsSinceEpoch == other.millisecondsSinceEpoch;
   }

   int compareTo(DateTime other)
       => millisecondsSinceEpoch.compareTo(other.millisecondsSinceEpoch);

   int get hashCode => millisecondsSinceEpoch;

   /**
    * Returns [this] in the local time zone. Returns itself if it is already in
    * the local time zone. Otherwise, this method is equivalent to
    *
    *     new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
    *                                             isUtc: false)
    */
   DateTime toLocal() {
     if (isUtc) {
       return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
                                                      isUtc: false);
     }
     return this;
   }

   /**
    * Returns [this] in UTC. Returns itself if it is already in UTC. Otherwise,
    * this method is equivalent to
    *
    *     new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
    *                                             isUtc: true)
    */
   DateTime toUtc() {
     if (isUtc) return this;
     return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
                                                    isUtc: true);
   }

   /**
    * Returns a human readable string for this instance.
    * The returned string is constructed for the time zone of this instance.
    */
   String toString() {
     String fourDigits(int n) {
       int absN = n.abs();
       String sign = n < 0 ? "-" : "";
       if (absN >= 1000) return "$n";
       if (absN >= 100) return "${sign}0$absN";
       if (absN >= 10) return "${sign}00$absN";
       return "${sign}000$absN";
     }

     String threeDigits(int n) {
       if (n >= 100) return "${n}";
       if (n >= 10) return "0${n}";
       return "00${n}";
     }

     String twoDigits(int n) {
       if (n >= 10) return "${n}";
       return "0${n}";
     }

     String y = fourDigits(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);
     if (isUtc) {
       return "$y-$m-$d $h:$min:$sec.${ms}Z";
     } else {
       return "$y-$m-$d $h:$min:$sec.$ms";
     }
   }

   /** Returns a new [DateTime] with the [duration] added to [this]. */
   DateTime add(Duration duration) {
     int ms = millisecondsSinceEpoch;
     return new DateTime.fromMillisecondsSinceEpoch(
         ms + duration.inMilliseconds, isUtc: isUtc);
   }

   /** Returns a new [DateTime] with the [duration] subtracted from [this]. */
   DateTime subtract(Duration duration) {
     int ms = millisecondsSinceEpoch;
     return new DateTime.fromMillisecondsSinceEpoch(
         ms - duration.inMilliseconds, isUtc: isUtc);
   }

   /** Returns a [Duration] with the difference of [this] and [other]. */
   Duration difference(DateTime other) {
     int ms = millisecondsSinceEpoch;
     int otherMs = other.millisecondsSinceEpoch;
     return new Duration(milliseconds: ms - otherMs);
   }

   external DateTime._internal(int year,
                               int month,
                               int day,
                               int hour,
                               int minute,
                               int second,
                               int millisecond,
                               bool isUtc);
   external DateTime._now();
   external static int _brokenDownDateToMillisecondsSinceEpoch(
       int year, int month, int day, int hour, int minute, int second,
       int millisecond, bool isUtc);

   /**
    * Returns the abbreviated time-zone name.
    *
    * Examples: [:"CET":] or [:"CEST":].
    */
   external String get timeZoneName;

   /**
    * The time-zone offset is the difference between local time and UTC. That is,
    * the offset is positive for time zones west of UTC.
    *
    * Note, that JavaScript, Python and C return the difference between UTC and
    * local time. Java, C# and Ruby return the difference between local time and
    * UTC.
    */
   external Duration get timeZoneOffset;

   /**
    * Returns the year.
    */
   external int get year;

   /**
    * Returns the month into the year [1..12].
    */
   external int get month;

   /**
    * Returns the day into the month [1..31].
    */
   external int get day;

   /**
    * Returns the hour into the day [0..23].
    */
   external int get hour;

   /**
    * Returns the minute into the hour [0...59].
    */
   external int get minute;

   /**
    * Returns the second into the minute [0...59].
    */
   external int get second;

   /**
    * Returns the millisecond into the second [0...999].
    */
   external int get millisecond;

   /**
    * Returns the week day [MON..SUN]. In accordance with ISO 8601
    * a week starts with Monday which has the value 1.
    */
   external int get weekday;
 }
	// 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;

	/**
	* Deprecated class. Please use [DateTime] instead.
	*/
	@deprecated
	abstract class Date implements Comparable {
	// Weekday constants that are returned by [weekday] method:
	static const int MON = 1;
	static const int TUE = 2;
	static const int WED = 3;
	static const int THU = 4;
	static const int FRI = 5;
	static const int SAT = 6;
	static const int SUN = 7;
	static const int DAYS_IN_WEEK = 7;

	// Month constants that are returned by the [month] getter.
	static const int JAN = 1;
	static const int FEB = 2;
	static const int MAR = 3;
	static const int APR = 4;
	static const int MAY = 5;
	static const int JUN = 6;
	static const int JUL = 7;
	static const int AUG = 8;
	static const int SEP = 9;
	static const int OCT = 10;
	static const int NOV = 11;
	static const int DEC = 12;

	factory Date(int year,
	[int month = 1,
	int day = 1,
	int hour = 0,
	int minute = 0,
	int second = 0,
	int millisecond = 0]) {
	return new DateTime(year, month, day, hour, minute, second, millisecond);
	}

	factory Date.utc(int year,
	[int month = 1,
	int day = 1,
	int hour = 0,
	int minute = 0,
	int second = 0,
	int millisecond = 0]) {
	return
	new DateTime.utc(year, month, day, hour, minute, second, millisecond);
	}

	factory Date.now() => new DateTime.now();

	factory Date.fromString(String formattedString)
	=> DateTime.parse(formattedString);

	factory Date.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch,
	{bool isUtc: false}) {
	return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
	isUtc: isUtc);
	}

	bool operator ==(DateTime other);
	bool operator <(DateTime other);
	bool operator <=(DateTime other);
	bool operator >(DateTime other);
	bool operator >=(DateTime other);


	DateTime toLocal();
	DateTime toUtc();

	String get timeZoneName;
	Duration get timeZoneOffset;

	int get year;
	int get month;
	int get day;
	int get hour;
	int get minute;
	int get second;
	int get millisecond;

	int get weekday;

	int get millisecondsSinceEpoch;

	bool get isUtc;

	String toString();

	DateTime add(Duration duration);
	DateTime subtract(Duration duration);
	Duration difference(DateTime other);
	}

	/**
	* A DateTime object represents a point in time.
	*
	* It can represent time values that are at a distance of at most
	* 8,640,000,000,000,000ms (100,000,000 days) from epoch (1970-01-01 UTC). In
	* other words: [:millisecondsSinceEpoch.abs() <= 8640000000000000:].
	*
	* Also see [Stopwatch] for means to measure time-spans.
	*/
	class DateTime implements Date {
	// Weekday constants that are returned by [weekday] method:
	static const int MON = 1;
	static const int TUE = 2;
	static const int WED = 3;
	static const int THU = 4;
	static const int FRI = 5;
	static const int SAT = 6;
	static const int SUN = 7;
	static const int DAYS_IN_WEEK = 7;

	// Month constants that are returned by the [month] getter.
	static const int JAN = 1;
	static const int FEB = 2;
	static const int MAR = 3;
	static const int APR = 4;
	static const int MAY = 5;
	static const int JUN = 6;
	static const int JUL = 7;
	static const int AUG = 8;
	static const int SEP = 9;
	static const int OCT = 10;
	static const int NOV = 11;
	static const int DEC = 12;

	/**
	* The milliseconds since 1970-01-01T00:00:00Z (UTC). This value is
	* independent of the time zone.
	*
	* See [Stopwatch] for means to measure time-spans.
	*/
	final int millisecondsSinceEpoch;

	/**
	* True if this [DateTime] is set to UTC time.
	*/
	final bool isUtc;

	/**
	* Constructs a [DateTime] instance based on the individual parts. The date is
	* in the local time zone.
	*
	* [month] and [day] are one-based. For example
	* [:new DateTime(1938, 1, 10):] represents the 10th of January 1938.
	*/
	// TODO(8042): This should be a redirecting constructor and not a factory.
	factory DateTime(int year,
	[int month = 1,
	int day = 1,
	int hour = 0,
	int minute = 0,
	int second = 0,
	int millisecond = 0]) {
	return new DateTime._internal(
	year, month, day, hour, minute, second, millisecond, false);
	}

	/**
	* Constructs a [DateTime] instance based on the individual parts. The date is
	* in the UTC time zone.
	*
	* [month] and [day] are one-based. For example
	* [:new DateTime.utc(1938, 1, 10):] represents the 10th of January 1938 in
	* Coordinated Universal Time.
	*/
	// TODO(8042): This should be a redirecting constructor and not a factory.
	factory DateTime.utc(int year,
	[int month = 1,
	int day = 1,
	int hour = 0,
	int minute = 0,
	int second = 0,
	int millisecond = 0]) {
	return new DateTime._internal(
	year, month, day, hour, minute, second, millisecond, true);
	}

	/**
	* Constructs a new [DateTime] instance with current date time value in the
	* local time zone.
	*/
	// TODO(8042): This should be a redirecting constructor and not a factory.
	factory DateTime.now() { return new DateTime._now(); }

	/**
	* Constructs a new [DateTime] instance based on [formattedString].
	*
	* The function parses a subset of ISO 8601. Examples of accepted strings:
	*
	* * `"2012-02-27 13:27:00"`
	* * `"2012-02-27 13:27:00.123456z"`
	* * `"20120227 13:27:00"`
	* * `"20120227T132700"`
	* * `"20120227"`
	* * `"+20120227"`
	* * `"2012-02-27T14Z"`
	* * `"-123450101 00:00:00 Z"`: in the year -12345.
	*/
	// TODO(floitsch): specify grammar.
	static DateTime parse(String formattedString) {
	final RegExp re = new RegExp(
	r'^([+-]?\d?\d\d\d\d)-?(\d\d)-?(\d\d)' // The day part.
	r'(?:[ T](\d\d)(?::?(\d\d)(?::?(\d\d)(.\d{1,6})?)?)? ?([zZ])?)?$');
	Match match = re.firstMatch(formattedString);
	if (match != null) {
	int parseIntOrZero(String matched) {
	if (matched == null) return 0;
	return int.parse(matched);
	}

	double parseDoubleOrZero(String matched) {
	if (matched == null) return 0.0;
	return double.parse(matched);
	}

	int years = int.parse(match[1]);
	int month = int.parse(match[2]);
	int day = int.parse(match[3]);
	int hour = parseIntOrZero(match[4]);
	int minute = parseIntOrZero(match[5]);
	int second = parseIntOrZero(match[6]);
	bool addOneMillisecond = false;
	int millisecond = (parseDoubleOrZero(match[7]) * 1000).round().toInt();
	if (millisecond == 1000) {
	addOneMillisecond = true;
	millisecond = 999;
	}
	// TODO(floitsch): we should not need to test against the empty string.
	bool isUtc = (match[8] != null) && (match[8] != "");
	int millisecondsSinceEpoch = _brokenDownDateToMillisecondsSinceEpoch(
	years, month, day, hour, minute, second, millisecond, isUtc);
	if (millisecondsSinceEpoch == null) {
	throw new ArgumentError(formattedString);
	}
	if (addOneMillisecond) millisecondsSinceEpoch++;
	return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
	isUtc: isUtc);
	} else {
	throw new ArgumentError(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).
	*/
	// TODO(lrn): Have two constructors instead of taking an optional bool.
	DateTime.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch,
	{bool isUtc: false})
	: this.millisecondsSinceEpoch = millisecondsSinceEpoch,
	this.isUtc = isUtc {
	if (millisecondsSinceEpoch.abs() > _MAX_MILLISECONDS_SINCE_EPOCH) {
	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 timezone (UTC or local).
	*
	* See [isAtSameMomentAs] for a comparison that ignores the timezone.
	*/
	bool operator ==(other) {
	if (!(other is DateTime)) return false;
	return (millisecondsSinceEpoch == other.millisecondsSinceEpoch &&
	isUtc == other.isUtc);
	}

	/**
	* Returns true if [this] occurs before [other]. The comparison is independent
	* of whether the time is in UTC or in the local time zone.
	*
	* Deprecated Use [isBefore] instead.
	*/
	@deprecated
	bool operator <(DateTime other)
	=> millisecondsSinceEpoch < other.millisecondsSinceEpoch;

	/**
	* Returns true if [this] occurs at the same time or before [other]. The
	* comparison is independent of whether the time is in UTC or in the local
	* time zone.
	*
	* Deprecated Use [isAfter] instead ([:!isAfter:]).
	*/
	@deprecated
	bool operator <=(DateTime other)
	=> millisecondsSinceEpoch <= other.millisecondsSinceEpoch;

	/**
	* Returns true if [this] occurs after [other]. The comparison is independent
	* of whether the time is in UTC or in the local time zone.
	*
	* Deprecated Use [isAfter] instead.
	*/
	@deprecated
	bool operator >(DateTime other)
	=> millisecondsSinceEpoch > other.millisecondsSinceEpoch;

	/**
	* Returns true if [this] occurs at the same time or after [other]. The
	* comparison is independent of whether the time is in UTC or in the local
	* time zone.
	*
	* Deprecated Use [isBefore] instead ([:!isBefore:]).
	*/
	@deprecated
	bool operator >=(DateTime other)
	=> millisecondsSinceEpoch >= other.millisecondsSinceEpoch;

	/**
	* Returns true if [this] occurs before [other]. The comparison is independent
	* of whether the time is in UTC or in the local time zone.
	*/
	bool isBefore(DateTime other) {
	return millisecondsSinceEpoch < other.millisecondsSinceEpoch;
	}

	/**
	* Returns true if [this] occurs after [other]. The comparison is independent
	* of whether the time is in UTC or in the local time zone.
	*/
	bool isAfter(DateTime other) {
	return millisecondsSinceEpoch > other.millisecondsSinceEpoch;
	}

	/**
	* Returns true if [this] occurs at the same moment as [other]. The
	* comparison is independent of whether the time is in UTC or in the local
	* time zone.
	*/
	bool isAtSameMomentAs(DateTime other) {
	return millisecondsSinceEpoch == other.millisecondsSinceEpoch;
	}

	int compareTo(DateTime other)
	=> millisecondsSinceEpoch.compareTo(other.millisecondsSinceEpoch);

	int get hashCode => millisecondsSinceEpoch;

	/**
	* Returns [this] in the local time zone. Returns itself if it is already in
	* the local time zone. Otherwise, this method is equivalent to
	*
	* new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
	* isUtc: false)
	*/
	DateTime toLocal() {
	if (isUtc) {
	return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
	isUtc: false);
	}
	return this;
	}

	/**
	* Returns [this] in UTC. Returns itself if it is already in UTC. Otherwise,
	* this method is equivalent to
	*
	* new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
	* isUtc: true)
	*/
	DateTime toUtc() {
	if (isUtc) return this;
	return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch,
	isUtc: true);
	}

	/**
	* Returns a human readable string for this instance.
	* The returned string is constructed for the time zone of this instance.
	*/
	String toString() {
	String fourDigits(int n) {
	int absN = n.abs();
	String sign = n < 0 ? "-" : "";
	if (absN >= 1000) return "$n";
	if (absN >= 100) return "${sign}0$absN";
	if (absN >= 10) return "${sign}00$absN";
	return "${sign}000$absN";
	}

	String threeDigits(int n) {
	if (n >= 100) return "${n}";
	if (n >= 10) return "0${n}";
	return "00${n}";
	}

	String twoDigits(int n) {
	if (n >= 10) return "${n}";
	return "0${n}";
	}

	String y = fourDigits(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);
	if (isUtc) {
	return "$y-$m-$d $h:$min:$sec.${ms}Z";
	} else {
	return "$y-$m-$d $h:$min:$sec.$ms";
	}
	}

	/** Returns a new [DateTime] with the [duration] added to [this]. */
	DateTime add(Duration duration) {
	int ms = millisecondsSinceEpoch;
	return new DateTime.fromMillisecondsSinceEpoch(
	ms + duration.inMilliseconds, isUtc: isUtc);
	}

	/** Returns a new [DateTime] with the [duration] subtracted from [this]. */
	DateTime subtract(Duration duration) {
	int ms = millisecondsSinceEpoch;
	return new DateTime.fromMillisecondsSinceEpoch(
	ms - duration.inMilliseconds, isUtc: isUtc);
	}

	/** Returns a [Duration] with the difference of [this] and [other]. */
	Duration difference(DateTime other) {
	int ms = millisecondsSinceEpoch;
	int otherMs = other.millisecondsSinceEpoch;
	return new Duration(milliseconds: ms - otherMs);
	}

	external DateTime._internal(int year,
	int month,
	int day,
	int hour,
	int minute,
	int second,
	int millisecond,
	bool isUtc);
	external DateTime._now();
	external static int _brokenDownDateToMillisecondsSinceEpoch(
	int year, int month, int day, int hour, int minute, int second,
	int millisecond, bool isUtc);

	/**
	* Returns the abbreviated time-zone name.
	*
	* Examples: [:"CET":] or [:"CEST":].
	*/
	external String get timeZoneName;

	/**
	* The time-zone offset is the difference between local time and UTC. That is,
	* the offset is positive for time zones west of UTC.
	*
	* Note, that JavaScript, Python and C return the difference between UTC and
	* local time. Java, C# and Ruby return the difference between local time and
	* UTC.
	*/
	external Duration get timeZoneOffset;

	/**
	* Returns the year.
	*/
	external int get year;

	/**
	* Returns the month into the year [1..12].
	*/
	external int get month;

	/**
	* Returns the day into the month [1..31].
	*/
	external int get day;

	/**
	* Returns the hour into the day [0..23].
	*/
	external int get hour;

	/**
	* Returns the minute into the hour [0...59].
	*/
	external int get minute;

	/**
	* Returns the second into the minute [0...59].
	*/
	external int get second;

	/**
	* Returns the millisecond into the second [0...999].
	*/
	external int get millisecond;

	/**
	* Returns the week day [MON..SUN]. In accordance with ISO 8601
	* a week starts with Monday which has the value 1.
	*/
	external int get weekday;
	}