DateImplementation Class / dart:coreimpl Library / Dart API Reference

DateImplementation Class

Implements

Constructors

Code new DateImplementation.now() #

DateImplementation.now()
: isUtc = false,
millisecondsSinceEpoch = Primitives.dateNow() {
Primitives.lazyAsJsDate(this);
}

Code factory DateImplementation.fromString(String formattedString) #

factory DateImplementation.fromString(String formattedString) {
  // Read in (a subset of) ISO 8601.
  // Examples:
  //    - "2012-02-27 13:27:00"
  //    - "2012-02-27 13:27:00.423z"
  //    - "20120227 13:27:00"
  //    - "20120227T132700"
  //    - "20120227"
  //    - "2012-02-27T14Z"
  //    - "-123450101 00:00:00 Z"  // In the year -12345.
  final RegExp re = const RegExp(
      @'^([+-]?\d?\d\d\d\d)-?(\d\d)-?(\d\d)' // The day part.
      @'(?:[ T](\d\d)(?::?(\d\d)(?::?(\d\d)(.\d{1,6})?)?)? ?([zZ])?)?$');
  Match match = re.firstMatch(formattedString);
  if (match !== null) {
    int parseIntOrZero(String matched) {
      // TODO(floitsch): we should not need to test against the empty string.
      if (matched === null || matched == "") return 0;
      return Math.parseInt(matched);
    }

    double parseDoubleOrZero(String matched) {
      // TODO(floitsch): we should not need to test against the empty string.
      if (matched === null || matched == "") return 0.0;
      return Math.parseDouble(matched);
    }

    int years = Math.parseInt(match[1]);
    int month = Math.parseInt(match[2]);
    int day = Math.parseInt(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 = Primitives.valueFromDecomposedDate(
        years, month, day, hour, minute, second, millisecond, isUtc);
    if (millisecondsSinceEpoch === null) {
      throw new IllegalArgumentException(formattedString);
    }
    if (addOneMillisecond) millisecondsSinceEpoch++;
    return new Date.fromMillisecondsSinceEpoch(millisecondsSinceEpoch, isUtc);
  } else {
    throw new IllegalArgumentException(formattedString);
  }
}

Code new DateImplementation.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch, [bool isUtc = false]) #

DateImplementation.fromMillisecondsSinceEpoch(this.millisecondsSinceEpoch,
                                              [this.isUtc = false]) {
  if (millisecondsSinceEpoch.abs() > _MAX_MILLISECONDS_SINCE_EPOCH) {
    throw new IllegalArgumentException(millisecondsSinceEpoch);
  }
  if (isUtc === null) throw new IllegalArgumentException(isUtc);
}

Code new DateImplementation(int years, [int month = 1, int day = 1, int hour = 0, int minute = 0, int second = 0, int millisecond = 0, bool isUtc = false]) #

DateImplementation(int years,
                   [int month = 1,
                    int day = 1,
                    int hour = 0,
                    int minute = 0,
                    int second = 0,
                    int millisecond = 0,
                    bool isUtc = false])
: this.isUtc = checkNull(isUtc),
millisecondsSinceEpoch = Primitives.valueFromDecomposedDate(
    years, month, day, hour, minute, second, millisecond, isUtc) {
Primitives.lazyAsJsDate(this);
}

Methods

Code Date add(Duration duration) #

Date add(Duration duration) {
  int ms = millisecondsSinceEpoch;
  return new Date.fromMillisecondsSinceEpoch(
      ms + duration.inMilliseconds, isUtc);
}

Code int compareTo(Date other) #

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

Code int get day() #

int get day() => Primitives.getDay(this);

Code Duration difference(Date other) #

Duration difference(Date other) {
  int ms = millisecondsSinceEpoch;
  int otherMs = other.millisecondsSinceEpoch;
  return new Duration(milliseconds: ms - otherMs);
}

Code int hashCode() #

int hashCode() => millisecondsSinceEpoch;

Code int get hour() #

int get hour() => Primitives.getHours(this);

Code int get millisecond() #

int get millisecond() => Primitives.getMilliseconds(this);

Code int get minute() #

int get minute() => Primitives.getMinutes(this);

Code int get month() #

int get month() => Primitives.getMonth(this);

Code bool operator >=(Date other) #

bool operator >=(Date other)
    => millisecondsSinceEpoch >= other.millisecondsSinceEpoch;

Code bool operator >(Date other) #

bool operator >(Date other)
    => millisecondsSinceEpoch > other.millisecondsSinceEpoch;

Code bool operator <=(Date other) #

bool operator <=(Date other)
    => millisecondsSinceEpoch <= other.millisecondsSinceEpoch;

Code bool operator <(Date other) #

bool operator <(Date other)
    => millisecondsSinceEpoch < other.millisecondsSinceEpoch;

Code bool operator ==(other) #

bool operator ==(other) {
  if (!(other is Date)) return false;
  return (millisecondsSinceEpoch == other.millisecondsSinceEpoch);
}

Code int get second() #

int get second() => Primitives.getSeconds(this);

Code Date subtract(Duration duration) #

Date subtract(Duration duration) {
  int ms = millisecondsSinceEpoch;
  return new Date.fromMillisecondsSinceEpoch(
      ms - duration.inMilliseconds, isUtc);
}

Code String get timeZoneName() #

String get timeZoneName() {
if (isUtc) return "UTC";
return Primitives.getTimeZoneName(this);
}

Code Duration get timeZoneOffset() #

Duration get timeZoneOffset() {
if (isUtc) return new Duration(0);
return new Duration(minutes: Primitives.getTimeZoneOffsetInMinutes(this));
}

Code Date toLocal() #

Date toLocal() {
  if (isUtc) {
    return new Date.fromMillisecondsSinceEpoch(millisecondsSinceEpoch, false);
  }
  return this;
}

Code String toString() #

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";
  }
}

Code Date toUtc() #

Date toUtc() {
  if (isUtc) return this;
  return new Date.fromMillisecondsSinceEpoch(millisecondsSinceEpoch, true);
}

Code int get weekday() #

int get weekday() => Primitives.getWeekday(this);

Code int get year() #

int get year() => Primitives.getYear(this);

Fields

Code final bool isUtc #

final bool isUtc;

Code final int millisecondsSinceEpoch #

final int millisecondsSinceEpoch;