Deprecate use of timezones.

frog/lib/date_implementation.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.
 
 // TODO(jmesserly): the native class should be the real JS Date.
 // TODO(jimhug): Making the date value non-lazy might be a good path there.
 class DateImplementation implements Date {
   final int value;
   final TimeZone timeZone;
 
   factory DateImplementation(int years,
                              [int month = 1,
                               int day = 1,
                               int hours = 0,
                               int minutes = 0,
                               int seconds = 0,
-                              int milliseconds = 0]) {
+                              int milliseconds = 0,
+                              bool isUtc = false]) {
     return new DateImplementation.withTimeZone(

[ngeoffray, 2012/05/22 08:58:45]

If that one is deprecated, maybe don't use it.

[floitsch, 2012/05/22 14:50:38]

This is the frog-implementation of the library. Given its limited life-time I
kept the changes minimal.

         years, month, day,
         hours, minutes, seconds, milliseconds,
-        new TimeZoneImplementation.local());
+        isUtc ? const TimeZoneImplementation.utc()
+              : new TimeZoneImplementation.local());
   }
 
   DateImplementation.withTimeZone(int years,
                                   int month,
                                   int day,
                                   int hours,
                                   int minutes,
                                   int seconds,
                                   int milliseconds,
                                   TimeZone timeZone)
@@ skipping 45 matching lines @@
       int minutes = parseIntOrZero(match[5]);
       int seconds = parseIntOrZero(match[6]);
       bool addOneMillisecond = false;
       int milliseconds = (parseDoubleOrZero(match[7]) * 1000).round().toInt();
       if (milliseconds == 1000) {
         addOneMillisecond = true;
         milliseconds = 999;
       }
       // TODO(floitsch): we should not need to test against the empty string.
       bool isUtc = (match[8] !== null) && (match[8] != "");
-      TimeZone timezone = isUtc ? const TimeZone.utc() : new TimeZone.local();
       int epochValue = _valueFromDecomposed(
           years, month, day, hours, minutes, seconds, milliseconds, isUtc);
       if (epochValue === null) {
         throw new IllegalArgumentException(formattedString);
       }
       if (addOneMillisecond) epochValue++;
-      return new DateImplementation.fromEpoch(epochValue, timezone);
+      return new DateImplementation.fromEpoch(epochValue, isUtc);
     } else {
       throw new IllegalArgumentException(formattedString);
     }
   }
 
-  const DateImplementation.fromEpoch(this.value, this.timeZone);
+  DateImplementation.fromEpoch(this.value, [bool isUtc = false])
+      : this.timeZone = isUtc ? const TimeZoneImplementation.utc()
+                              : new TimeZoneImplementation.local();
 
   bool operator ==(other) {
     if (!(other is DateImplementation)) return false;

[ngeoffray, 2012/05/22 08:58:45]

other is !DateImplementation

[floitsch, 2012/05/22 14:50:38]

Done.

-    return (value == other.value) && (timeZone == other.timeZone);
+    return (value == other.value);
   }
 
   bool operator <(Date other) => value < other.value;
 
   bool operator <=(Date other) => value <= other.value;
 
   bool operator >(Date other) => value > other.value;
 
   bool operator >=(Date other) => value >= other.value;
 
   int compareTo(Date other) {
     return value.compareTo(other.value);
   }
 
   int hashCode() {
     return value;
   }
 
+  Date toLocal() {
+    if (isUtc()) return changeTimeZone(new TimeZoneImplementation.local());

[ngeoffray, 2012/05/22 08:58:45]

Don't use the deprecated method?

[floitsch, 2012/05/22 14:50:38]

ditto.

+    return this;
+  }
+
+  Date toUtc() {
+    if (isUtc()) return this;
+    return changeTimeZone(const TimeZoneImplementation.utc());

[ngeoffray, 2012/05/22 08:58:45]

ditto

[floitsch, 2012/05/22 14:50:38]

ditto.

+  }
+
   Date changeTimeZone(TimeZone targetTimeZone) {
     if (targetTimeZone == null) {
       targetTimeZone = new TimeZoneImplementation.local();
     }
-    return new Date.fromEpoch(value, targetTimeZone);
+    print(targetTimeZone.isUtc);

[ngeoffray, 2012/05/22 08:58:45]

Remove print

[floitsch, 2012/05/22 14:50:38]

ouch.
done.

+    return new Date.fromEpoch(value, targetTimeZone.isUtc);
   }
 
   String get timeZoneName() { throw "Unimplemented"; }
   Duration get timeZoneOffset() { throw "Unimplemented"; }
 
   int get year() native
   '''return this.isUtc() ? this._asJs().getUTCFullYear() :
     this._asJs().getFullYear();''' {
     isUtc();
     _asJs();
@@ skipping 39 matching lines @@
     this._asJs().getMilliseconds();''' {
     isUtc();
     _asJs();
   }
 
   // Adjust by one because JS weeks start on Sunday.
   int get weekday() native '''
     var day = this.isUtc() ? this._asJs().getUTCDay() : this._asJs().getDay();
     return (day + 6) % 7;''';
 
-  // TODO(jimhug): Could this please be getters?
-  bool isLocalTime() {
-    return !timeZone.isUtc;
-  }
-
   bool isUtc() {
     return timeZone.isUtc;
   }
 
   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";
@@ skipping 21 matching lines @@
       return "$y-$m-$d $h:$min:$sec.${ms}Z";
     } else {
       return "$y-$m-$d $h:$min:$sec.$ms";
     }
   }
 
   // TODO(jimhug): Why not use operators here?
     // Adds the [duration] to this Date instance.
   Date add(Duration duration) {
     return new DateImplementation.fromEpoch(value + duration.inMilliseconds,
-                                            timeZone);
+                                            timeZone.isUtc);
   }
 
   // Subtracts the [duration] from this Date instance.
   Date subtract(Duration duration) {
     return new DateImplementation.fromEpoch(value - duration.inMilliseconds,
-                                            timeZone);
+                                            timeZone.isUtc);
   }
 
   // Returns a [Duration] with the difference of [this] and [other].
   Duration difference(Date other) {
     return new Duration(milliseconds: value - other.value);
   }
 
   // TODO(floitsch): Use real exception object.
   static int _valueFromDecomposed(int years, int month, int day,
                                   int hours, int minutes, int seconds,
@@ skipping 36 matching lines @@
     return isUtc == other.isUtc;
   }
 
   String toString() {
     if (isUtc) return "TimeZone (UTC)";
     return "TimeZone (Local)";
   }
 
   final bool isUtc;
 }