Changeset 51

Timestamp:

03/28/06 11:04:26 (4 years ago)

Author:

PeyloW

Message:

Rearranged functions and did soem new ones to make timestamp more consistent

Files:

• branches/date.d (modified) (11 diffs)
• branches/dateparse.d (modified) (1 diff)

branches/date.d

@@ -252 +252 @@
-
-/**
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -360 +369 @@
- *  day =          A day of month.
- *
-tim
+dat
- */
-public d_date toDate(int year, int month, int day) {
@@ -387 +396 @@
-
-/**
+ * Creates a date from a timestamp.
+ *
+ * Params:
+ *  timestamp =    A d_timestamp date/time.
+ *
+ * Return: A d_date date.
+ */
+public d_date toDate(d_timestamp timestamp) {
+  return cast(d_date)timestamp;
+}
+
+
+/**
- * Creates a date from an *nix epoch.
- *
@@ -398 +420 @@
-  epoch -= DATE_UNIX_EPOCH_OFFSET;
-  return cast(d_date)epoch;
+}
+
+
+/**
+ * Crates a d_time time from a string.
+ *
+ * Params:
+ *  timeString =   A time astring.
+ *  format =       An optional format string, defaults to ISO 8601.
+ *
+ * Returns: A d_time time.
+ */
+public d_time toTime(char[] timeString) {
+  d_datetime datetime;
+  char[][] fields;
+  FieldType[] ftypes;
+  FieldType dtype;
+  if (!parseDateTime(timeString, fields, ftypes)) {
+    throw new ParseDateException(timeString ~ " can not be parsed as time");
+  }
+  if (!decodeDateTime(fields, ftypes, dtype, datetime, false)) {
+    throw new ParseDateException(timeString ~ " can not be parsed as time");
+  }
+  switch (dtype) {
+    case FieldType.TIME:
+      break;
+    case FieldType.EPOCH:
+      assert(0);
+    default:
+    throw new ParseDateException(timeString ~ " can not be parsed as time");
+  }
+  return toTime(datetime.hour, datetime.minute, datetime.second, datetime.millisecond);
+}
+unittest {
+  // Also tests toTime(int, int, int) and toString(), splitTime()
+  d_time t = toTime("12:01:02");
+  assert(toString(t) == "12:01:02");
+  assert(t == toTime(12, 1, 2));
+// TODO: Allow for compact ISO times.
+//  assert(t == toTime("120102"));
+  assert(t == toTime("12:01:02.000"));
+  assert(t == toTime("00:01:02 PM"));
+  int h, m, s, ms;
+  splitTime(t, h, m, s, ms);
+  assert(h == 12);
+  assert(m == 1);
+  assert(s == 2);
+  assert(ms == 0);
+}
+
+
+/**
+ * Compose a d_time time from a hour, minute, second and millisecond part.
+ *
+ * Params:
+ *  hour =         An hour.
+ *  minute =       A minute.
+ *  second =       A second.
+ *  millisecond =  An optional millisecond, defaults to 0.
+ *
+ * Returns: Time as d_time.
+ */
+public d_time toTime(int hour, int minute, int second, int millisecond = 0) {
+  d_time time;
+  time = cast(d_time)(MSEC_PER_HOUR * hour + 
+                      MSEC_PER_MIN * minute +
+                      MSEC_PER_SEC * second +
+                      millisecond);
+  return normTime(time);
+}
+
+
+/**
+ * Creates a time from a timestamp.
+ *
+ * Params:
+ *  timestamp =    A d_timestamp date/time.
+ *
+ * Return: A d_time time.
+ */
+public d_time toTime(d_timestamp timestamp) {
+  double d = cast(double)timestamp % 1.0;
+  if (d < 0.0) {
+    d += 1.0;
+  }
+  return cast(d_time)(d * MSEC_PER_DAY);
+}
+
+
+/**
+ * Crates a d_timestamp date/time from a string.
+ *
+ * Params:
+ *  tsString =     A date and time time string.
+ *  format =       An optional format string, defaults to ISO 8601.
+ *
+ * Returns: A d_timestamp date/time.
+ */
+public d_timestamp toTimeStamp(char[] tsString) {
+  d_datetime datetime;
+  char[][] fields;
+  FieldType[] ftypes;
+  FieldType dtype;
+  if (!parseDateTime(tsString, fields, ftypes)) {
+    throw new ParseDateException(tsString ~ " can not be parsed as timestamp");
+  }
+  if (!decodeDateTime(fields, ftypes, dtype, datetime, false)) {
+    throw new ParseDateException(tsString ~ " can not be parsed as timestamp");
+  }
+  switch (dtype) {
+    case FieldType.DATE:
+      break;
+    case FieldType.EPOCH:
+      assert(0);
+    default:
+    throw new ParseDateException(tsString ~ " can not be parsed as timestamp");
+  }
+  d_date date = toDate(datetime.year, datetime.month, datetime.day);
+  d_time time = toTime(datetime.hour, datetime.minute, datetime.second, datetime.millisecond);
+  return toTimeStamp(date, time);
+}
+unittest {
+  // Also tests toTimeStamp(int, int...), toTimeStamp(date, time),
+  // toTimeStamp(int), toString(), and splitTimeStamp()
+  d_timestamp ts = toTimeStamp("2006-03-19 11:42:00");
+  assert(ts == toTimeStamp(toDate("2006-03-19"), toTime("11:42:00")));
+  assert(toString(toTimeStamp(0)) == "1970-01-01 00:00:00");
+  d_date d = toDate(ts);
+  d_time t = toTime(ts);
+  assert(d == toDate(2006,3,19));
+  assert(t == toTime(11, 42, 0)); 
+}
+
+
+/**
+ * Convert a d_date date to a d_timestamp date/time.
+ *
+ * Params:
+ *  date =         A d_date date.
+ *
+ * Returns: A d_timestamp date/time.
+ */
+public d_timestamp toTimeStamp(d_date date) {
+  return cast(d_timestamp)date;
+}
+
+
+/**
+ * Convert a d_time time to a d_timestamp date/time.
+ *
+ * Datepart will be today.
+ *
+ * Params:
+ *  time =         A d_time time.
+ *
+ * Returns: A d_timestamp date/time.
+ */
+public d_timestamp toTimeStamp(d_time time) {
+  return cast(d_timestamp)date() + cast(d_timestamp)(cast(double)time / 
+      MSEC_PER_DAY);
+}
+
+
+/**
+ * Convert a d_date date and a d_time time to a d_timestamp date/time.
+ *
+ * Params:
+ *  date =         A d_date date.
+ *  time =         A d_time time.
+ *
+ * Returns: A d_timestamp date/time.
+ */
+public d_timestamp toTimeStamp(d_date date, d_time time) {
+  return cast(d_timestamp)date + cast(d_timestamp)(cast(double)time / 
+      MSEC_PER_DAY);
+}
+
+
+/**
+ * Compose a d_timestamp from a year, a month, and a day components.
+ *
+ * Values less than 1 indicates days from the end of the month, 0 is the last 
+ * day of the month, and -1 is the second to last, etc.
+ *
+ * Days that does not fit into a month will spill into the next month. Day 35 of
+ * january will for example result in the 4th of february.
+ *
+ * Params:
+ *  year =         A year.
+ *  month =        A month of year.
+ *  day =          A day of month.
+ *  hour =         An hour.
+ *  minute =       A minute.
+ *  second =       A second.
+ *  millisecond =  An optional millisecond, defaults to 0.
+ *
+ * Returns: Date/time as a d_timestamp.
+ */
+public d_timestamp toTimeStamp(int year, int month, int day, int hour, 
+    int minute, int second, int millisecond = 0) {
+  return toTimeStamp(toDate(year, month, day), toTime(hour, minute, second, 
+      millisecond));
+}
+
+
+/**
+ * Compose a d_timestamp from a year, month, day, hour, minute, second, and 
+ * millisecond part.
+ *
+ * Values less than 1 indicates days from the end of the month, 0 is the last 
+ * day of the month, and -1 is the second to last, etc.
+ *
+ * Days that does not fit into a month will spill into the next month. Day 35 of
+ * january will for example result in the 4th of february.
+ *
+ * Params:
+ *  year =         A year.
+ *  month =        A month of year.
+ *  day =          A day of month.
+ *
+ * Returns: Date as a d_timestamp.
+ */
+public d_timestamp toDateTimeStamp(int year, int month, int day) {
+  return toTimeStamp(toDate(year, month, day));
+}
+
+
+/**
+ * Compose a d_timestamp time from a hour, minute, second and millisecond part.
+ *
+ * Params:
+ *  hour =         An hour.
+ *  minute =       A minute.
+ *  second =       A second.
+ *  millisecond =  An optional millisecond, defaults to 0.
+ *
+ * Returns: Time as d_timestamp.
+ */
+public d_timestamp toTimeTimeStamp(int hour, int minute, int second, 
+    int millisecond) {
+  return toTimeStamp(toTime(hour, minute, second, millisecond));
+}
+
+
+/**
+ * Creates a date/time from an *nix epoch.
+ *
+ * Params:
+ *  epoch =        An *nix epoch.
+ *
+ * Return: A d_timestamp date/time.
+ */
+public d_timestamp toTimeStamp(int epoch) {
+  double timestamp;
+  timestamp = cast(double)epoch / SEC_PER_DAY;
+  timestamp -= DATE_UNIX_EPOCH_OFFSET;
+  return cast(d_timestamp)timestamp;
+}
+
+
+/**
+ * Creates an d_duration duration from a string.
+ *
+ * Params:
+ *  durationString = A date string.
+ *
+ * Returns: An d_duration duration.
+ */
+public d_duration toDuration(char[] durationString) {
+  d_datetime datetime;
+  char[][] fields;
+  FieldType[] ftypes;
+  if (!parseDateTime(durationString, fields, ftypes)) {
+    throw new ParseDateException(durationString ~ " can not be parsed as duration");
+  }
+  if (!decodeDuration(fields, ftypes, datetime)) {
+    throw new ParseDateException(durationString ~ " can not be parsed as duration");
+  }
+  return toDuration(datetime.year, datetime.month, datetime.day, 
+      datetime.hour, datetime.minute, datetime.second, datetime.millisecond);
+}
+unittest {
+  d_duration d = toDateDuration(1, 2, 3);
+  assert(d == toDuration("1 year, 2 months and 3 days")); 
+}
+
+
+/**
+ * Creates an d_duration duration from years, months, days, hours, minutes,
+ * seconds and milliseconds parts.
+ *
+ * Params:
+ *  years =        Number of years.
+ *  months =       Number of months.
+ *  days =         Number of days.
+ *  hours =        Numbr of hours.
+ *  minutes =      Number of minutes.
+ *  seconds =      Number of seconds.
+ *  milliseconds = Optional number of milliseconds, defaults to 0.
+ *
+ * Returns: An d_duration duration.
+ */
+public d_duration toDuration(int years, int months, int days, int hours, 
+    int minutes, int seconds, int milliseconds = 0) {
+  d_duration duration;
+  duration.daysAndTime = cast(double)days +
+                         (1.0 / HOUR_PER_DAY) * hours + 
+                         (1.0 / MIN_PER_DAY) * minutes +
+                         (1.0 / SEC_PER_DAY) * seconds +
+                         (1.0 / MSEC_PER_DAY) * milliseconds;
+  duration.months = years * 12 + months;
+  return duration;
+}
+
+
+/**
+ * Creates an d_duration duration from years, months, and days parts.
+ *
+ * Params:
+ *  years =        Number of years.
+ *  months =       Number of months.
+ *  days =         Number of days.
+ *
+ * Returns: An d_duration duration.
+ */
+public d_duration toDateDuration(int years, int months, int days) {
+  return toDuration(years, months, days, 0, 0, 0);
+}
+
+
+/**
+ * Creates an d_duration duration from hours, minutes, seconds and milliseconds 
+ * parts.
+ *
+ * Params:
+ *  hours =        Numbr of hours.
+ *  minutes =      Number of minutes.
+ *  seconds =      Number of seconds.
+ *  milliseconds = Optional number of milliseconds, defaults to 0.
+ *
+ * Returns: An d_duration duration.
+ */
+public d_duration toTimeDuration(int hours, int minutes, int seconds, int milliseconds = 0) {
+  return toDuration(0, 0, 0, hours, minutes, seconds, milliseconds);
+}
+
+
+/**
+ * Return the difference between two d_date dates as a d_duration duration.
+ *
+ * The difference can be extracted as an exact measure in days (default), and
+ * optionally in relative measure by months and years.
+ *
+ * Params:
+ *  fromDate =     A base d_date date.
+ *  toDate =       A relative d_date date.
+ *  relative =     If true duration is relative.
+ *
+ * Returns: A d_duration duration.
+ */
+public d_duration age(d_date fromDate, d_date toDate, bool relative = false) {
+  d_duration duration;
+  
+  if (!relative) {
+    duration.daysAndTime = cast(double)(toDate - fromDate);
+  } else {
+    int fromYear, fromMonth, fromDay;
+    int toYear, toMonth, toDay;
+    splitDate(fromDate, fromYear, fromMonth, fromDay);
+    splitDate(toDate, toYear, toMonth, toDay);
+    duration.daysAndTime = cast(double)(toDay - fromDay);
+    duration.months = (toYear * 12 + toMonth) - (fromYear * 12 + fromMonth);
+  }
+  return duration;
+}
+
+
+/**
+ * Return the difference between two d_time times as a d_duration duration.
+ *
+ * Params:
+ *  fromTime =     A base d_time time.
+ *  toTime =       A relative d_time time.
+ *
+ * Returns: A d_duration duration.
+ */
+public d_duration age(d_time fromTime, d_time toTime) {
+  d_duration duration;
+  duration.daysAndTime = cast(double)(toTime - fromTime);
+  return duration;
+}
+
+
+/**
+ * Return the difference between two d_timestamp date/times as a d_duration 
+ * duration.
+ *
+ * The difference can be extracted as an exact measure in days (default), and
+ * optionally in relative measure by months and years.
+ *
+ * Params:
+ *  fromTimeStamp = A base d_timestamp date/time.
+ *  toTimeStamp =  A relative d_timestamp date/time.
+ *  relative =     If true duration is relative.
+ *
+ * Returns: A d_duration duration.
+ */
+public d_duration age(d_timestamp fromTimeStamp, d_timestamp toTimeStamp, 
+    bool relative = false) {
+  d_duration duration;
+
+  duration = age(toDate(fromTimeStamp), toDate(toTimeStamp), relative);
+  duration.daysAndTime += cast(double)(toTime(toTimeStamp) -  
+      toTime(fromTimeStamp));
+  return duration; 
-}
-
@@ -445 +882 @@
-    month = (quad + 10) % 12 + 1;
-    day = date - 7834 * quad / 256;
+}
+
+
+/**
+ * Split a d_time into hour, minute, second, and millisecond parts.
+ *
+ * Params: 
+ *  time =         A d_time time.
+ *  hour =         (OUT) The hour.
+ *  minute =       (OUT) The minute.
+ *  second =       (OUT) The second.
+ *  millisecond =  (OUT) The millisecond.
+ */
+public void splitTime(d_time time, out int hour, out int minute, out int second, 
+    out int millisecond) {
+  time = normTime(time);
+  hour = cast(int)time / MSEC_PER_HOUR;
+  minute = cast(int)(time / MSEC_PER_MIN) % 60;
+  second = cast(int)(time / MSEC_PER_SEC) % 60;
+  millisecond = cast(int)time % 1000;
+}
+
+
+/**
+ * Split a d_timestamp time into year, month, day, hour, minute, second, and 
+ * millisecond parts.
+ *
+ * Params:
+ *  timestamp =    A d_timestamp date/time.
+ *  year =         (OUT) The year.
+ *  month =        (OUT) The month of year.
+ *  day =          (OUT) The day of month.
+ *  hour =         (OUT) The hour.
+ *  minute =       (OUT) The minute.
+ *  second =       (OUT) The second.
+ *  millisecond =  (OUT) The millisecond.
+ */
+public void splitTimeStamp(d_timestamp timestamp, out int year, 
+    out int month, out int day, out int hour, out int minute, out int second,
+    out int millisecond) {
+  splitDate(toDate(timestamp), year, month, day);
+  splitTime(toTime(timestamp), hour, minute, second, millisecond);
+}
+
+
+/**
+ * Split a d_timestamp into year, month, and day components.
+ *
+ * Params:
+ *  timestamp =    A d_timestamp date/time.
+ *  year =         (OUT) The year.
+ *  month =        (OUT) The month of year.
+ *  day =          (OUT) The day of month.
+ */
+public void splitDateTimeStamp(d_timestamp timestamp, out int year, 
+    out int month, out int day) {
+  splitDate(toDate(timestamp), year, month, day);
+}
+
+
+/**
+ * Split a d_timestamp time into hour, minute, second, and millisecond parts.
+ *
+ * Params: 
+ *  timestamp =    A d_timestamp date/time.
+ *  hour =         (OUT) The hour.
+ *  minute =       (OUT) The minute.
+ *  second =       (OUT) The second.
+ *  millisecond =  (OUT) The millisecond.
+ */
+public void splitTimeTimeStamp(d_timestamp timestamp, out int hour, 
+    out int minute, out int second, out int millisecond) {
+  splitTime(toTime(timestamp), hour, minute, second, millisecond);
+}
+
+
+/**
+ * Splits an d_duration duration into years, months, days, hours, minutes,
+ * seconds and milliseconds parts.
+ *
+ * Params:
+ *  years =        (OUT) Number of years.
+ *  months =       (OUT) Number of months.
+ *  days =         (OUT) Number of days.
+ *  hours =        (OUT) Numbr of hours.
+ *  minutes =      (OUT) Number of minutes.
+ *  seconds =      (OUT) Number of seconds.
+ *  milliseconds = (OUT) Number of milliseconds.
+ */
+public void splitDuration(d_duration duration, out int years, out int months, 
+    out int days, out int hours, out int minutes, out int seconds, out int milliseconds) {
+  years = duration.months / 12;
+  months = duration.months % 12;
+  days = cast(int)duration.daysAndTime;
+  float timePart = duration.daysAndTime - days;
+  hours = cast(int)((timePart * HOUR_PER_DAY) % 24);
+  minutes = cast(int)((timePart * MIN_PER_DAY) % 60);
+  seconds = cast(int)((timePart * SEC_PER_DAY) % 60);
+  milliseconds = cast(int)((timePart * MSEC_PER_DAY) % 1000);
+}
+
+
+/**
+ * Splits an d_duration duration into years, months, and days parts.
+ *
+ * Params:
+ *  years =        (OUT) Number of years.
+ *  months =       (OUT) Number of months.
+ *  days =         (OUT) Number of days.
+ */
+public void splitDateDuration(d_duration duration, out int years, 
+    out int months, out int days) {
+  years = duration.months / 12;
+  months = duration.months % 12;
+  days = cast(int)duration.daysAndTime;
+  // float timePart = duration.daysAndTime - days;
+}
+
+
+/**
+ * Splits an d_duration duration into hours, minutes, seconds and milliseconds 
+ * parts.
+ *
+ * The days of the duration will be converted to hours, any months and/or years
+ * will be ignored as their length in hours can not be determined.
+ *
+ * Params:
+ *  hours =        (OUT) Numbr of hours.
+ *  minutes =      (OUT) Number of minutes.
+ *  seconds =      (OUT) Number of seconds.
+ *  milliseconds = (OUT) Number of milliseconds.
+ *
+ */
+public void splitTimeDuration(d_duration duration, out int hours, 
+    out int minutes, out int seconds, out int milliseconds) {
+  double timePart = duration.daysAndTime;
+  hours = cast(int)(timePart * HOUR_PER_DAY); 
+  minutes = cast(int)((timePart * MIN_PER_DAY) % 60);
+  seconds = cast(int)((timePart * SEC_PER_DAY) % 60);
+  milliseconds = cast(int)((timePart * MSEC_PER_DAY) % 1000);
-}
-
@@ -517 +1094 @@
-
-/**
- * Incremet a d_date date's date part datePart by a count.
- *
- * Params:
- *  date =         A d_date date.
- *  datePart =     A DatePart dat part, in range MILLENIA..DAY.
- *  count =        A count of dateparts to increment.
- *
- * Returns: A d_date date.
- */
-public d_date increment(d_date date, DatePart datePart, int count) {
-  switch (datePart) {
-    case DatePart.MILLENIA:
-      return addYearsToDate(date, count * 1000);
-    case DatePart.DECADE:
-      return addYearsToDate(date, count * 10);
-    case DatePart.YEAR:
-      return addYearsToDate(date, count);
-    case DatePart.QUARTER:
-      return addMonthsToDate(date, count * 3);
-    case DatePart.MONTH:
-      return addMonthsToDate(date, count);
-    case DatePart.WEEK:
-      return date + count * 7;
-    case DatePart.DAY:
-      return date + count;
-    default:
-      throw new InvalidDatePartException(std.string.toString(cast(int)datePart) ~ 
-          " is an invalid date part");
-  }
-}
-
-
-/**
- * Increment d_date date with a d_duration duration.
- *
- * Params:
- *  date =         A d_date date.
- *  duration =     A d_duration duration.
- *
- * Returns: A d_date date.
- */
-public d_date increment(d_date date, d_duration duration) {
-  return addMonthsToDate(date, duration.months) + cast(int)duration.daysAndTime;
-}
- 
-
-/**
- * Trunc a d_date date to a given date part.
- *
- * Params:
- *  date =         A d_date date.
- *  datePart =     A DatePart, in the range MILLENIA..WEEK.
- *
- * Returns: A d_date date.
- */
-public d_date truncate(d_date date, DatePart datePart) {
-  int year, month, day;
-  splitDate(date, year, month, day);
-  switch (datePart) {
-    case DatePart.MILLENIA:
-      year = (year / 1000) * 1000;
-      month = 1;
-      day = 1;
-      break;
-    case DatePart.DECADE:
-      year = (year / 10) * 10;
-      month = 1;
-      day = 1;
-      break;
-    case DatePart.YEAR:
-      month = 1;
-      day = 1;
-      break;
-    case DatePart.QUARTER:
-      month = ((month - 1) / 3) * 3 + 1;
-    case DatePart.MONTH:
-      day = 1;
-      break;
-    case DatePart.WEEK:
-      return date - weekDayOfDate(date);
-    default:
-      throw new InvalidDatePartException(std.string.toString(cast(int)datePart) ~ 
-          " is an invalid date part");
-  }
-  return toDate(year, month, day);
-}
-unittest {
-  d_date d = toDate(2026, 10, 28);
-  assert(truncate(d, DatePart.MILLENIA) == toDate(2000, 1, 1));
-  assert(truncate(d, DatePart.DECADE) == toDate(2020, 1, 1));
-  assert(truncate(d, DatePart.YEAR) == toDate(2026, 1, 1));
-  assert(truncate(d, DatePart.QUARTER) == toDate(2026, 10, 1));
-  assert(truncate(d, DatePart.MONTH) == toDate(2026, 10, 1));
-  assert(truncate(d, DatePart.WEEK) == toDate(2026, 10, 26));  
-}
-
-
-/**
- * Get current system local time.
- *
- * Returns: Current system local time as a d_time time.
- */
-public d_time time() {
-  tm* _tm = localtime(null);
-  d_time time = toTime(_tm.tm_hour, _tm.tm_min, _tm.tm_sec, 0);
-  //free(tm);
-  return time;
-}
-
-
-/**
- * Get current system UDT time.
- *
- * Returns: Current system UDT time as a d_time time.
- */
-public d_time udtTime() {
-  tm* _tm = gmtime(null);
-  d_time time = toTime(_tm.tm_hour, _tm.tm_min, _tm.tm_sec, 0);
-  //free(tm);
-  return time;
-}
-
-
-/**
- * Create a string from a d_time time.
- *
- * Params:
- *  time =         A d_time time.
- *  format =       An optional format string, defaults to ISO 8601.
- *
- * Returns: The d_time time as a string.
- */
-public char[] toString(d_time time, char[] format = ISO_FORMAT_TIME) {
-  int hour, minute, second, millisecond;
-
-  assert(format == ISO_FORMAT_TIME);
-
-  splitTime(time, hour, minute, second, millisecond);
-  return std.string.format("%02d:%02d:%02d", hour, minute, second);
-}
- 
- 
-/**
- * Crates a d_time time from a string.
- *
- * Params:
- *  timeString =   A time astring.
- *  format =       An optional format string, defaults to ISO 8601.
- *
- * Returns: A d_time time.
- */
-public d_time toTime(char[] timeString) {
-  d_datetime datetime;
-  char[][] fields;
-  FieldType[] ftypes;
-  FieldType dtype;
-  if (!parseDateTime(timeString, fields, ftypes)) {
-    throw new ParseDateException(timeString ~ " can not be parsed as time");
-  }
-  if (!decodeDateTime(fields, ftypes, dtype, datetime, false)) {
-    throw new ParseDateException(timeString ~ " can not be parsed as time");
-  }
-  switch (dtype) {
-    case FieldType.TIME:
-      break;
-    case FieldType.EPOCH:
-      assert(0);
-    default:
-    throw new ParseDateException(timeString ~ " can not be parsed as time");
-  }
-  return toTime(datetime.hour, datetime.minute, datetime.second, datetime.millisecond);
-}
-unittest {
-  // Also tests toTime(int, int, int) and toString(), splitTime()
-  d_time t = toTime("12:01:02");
-  assert(toString(t) == "12:01:02");
-  assert(t == toTime(12, 1, 2));
-// TODO: Allow for compact ISO times.
-//  assert(t == toTime("120102"));
-  assert(t == toTime("12:01:02.000"));
-  assert(t == toTime("00:01:02 PM"));
-  int h, m, s, ms;
-  splitTime(t, h, m, s, ms);
-  assert(h == 12);
-  assert(m == 1);
-  assert(s == 2);
-  assert(ms == 0);
-}
-
-
-/**
- * Compose a d_time time from a hour, minute, second and millisecond part.
- *
- * Params:
- *  hour =         An hour.
- *  minute =       A minute.
- *  second =       A second.
- *  millisecond =  An optional millisecond, defaults to 0.
- *
- * Returns: Time as d_time.
- */
-public d_time toTime(int hour, int minute, int second, int millisecond = 0) {
-  d_time time;
-  time = cast(d_time)(MSEC_PER_HOUR * hour + 
-                      MSEC_PER_MIN * minute +
-                      MSEC_PER_SEC * second +
-                      millisecond);
-  return normTime(time);
-}
-
-
-/**
- * Split a d_time time into hour, minute, second, and millisecond parts.
- *
- * Params: 
- *  time =         A d_time time.
- *  hour =         (OUT) The hour.
- *  minute =       (OUT) The minute.
- *  second =       (OUT) The second.
- *  millisecond =  (OUT) The millisecond.
- */
-public void splitTime(d_time time, out int hour, out int minute, out int second, 
-    out int millisecond) {
-  time = normTime(time);
-  hour = cast(int)time / MSEC_PER_HOUR;
-  minute = cast(int)(time / MSEC_PER_MIN) % 60;
-  second = cast(int)(time / MSEC_PER_SEC) % 60;
-  millisecond = cast(int)time % 1000;
-}
-
-
-/**
- * Get date part of a d_time time.
- *
@@ -786 +1131 @@
-
-/**
- * Trunc a d_time time to a given date part.
- *
- * Params:
- *  time =         A d_time date.
- *  datePart =     A DatePart, in the range HOUR..SECOND.
- *
- * Returns: A d_time time.
- */
-public d_time truncate(d_time time, DatePart datePart) {
-  time = normTime(time);
-  switch (datePart) {
-    case DatePart.HOUR:
-      return cast(d_time)(cast(int)(time / MSEC_PER_HOUR) * MSEC_PER_HOUR);
-    case DatePart.MINUTE:
-      return cast(d_time)(cast(int)(time / MSEC_PER_MIN) * MSEC_PER_MIN);
-    case DatePart.SECOND:
-      return cast(d_time)(cast(int)(time / MSEC_PER_SEC) * MSEC_PER_SEC);
-    default:
-      throw new InvalidDatePartException(std.string.toString(cast(int)datePart) ~ 
-          " is an invalid date part");
-  }
-}
-unittest {
-  d_time t = toTime(12, 13, 14, 15);
-  assert(truncate(t, DatePart.SECOND) == toTime("12:13:14"));
-  assert(truncate(t, DatePart.MINUTE) == toTime("12:13:00"));
-  assert(truncate(t, DatePart.HOUR) == toTime("12:00:00"));
-}
-
-
-/**
- * Incremet a d_time times's date part datePart by a count.
- *
- * Params:
- *  time =         A d_time time.
- *  datePart =     A DatePart date part, in range HOUR..MILLISECOND.
- *  count =        A count of dateparts to increment.
- *
- * Returns: A d_time time.
- */
-public d_time increment(d_time time, DatePart datePart, int count) {
-  switch (datePart) {
-    case DatePart.HOUR:
-      time += cast(d_time)(count * MSEC_PER_HOUR);
-      break;
-    case DatePart.MINUTE:
-      time += cast(d_time)(count * MSEC_PER_MIN);
-      break;
-    case DatePart.SECOND:
-      time += cast(d_time)(count * MSEC_PER_SEC);
-      break;
-    case DatePart.MILLISECOND:
-      time += cast(d_time)count;
-      break;
-    default:
-      throw new InvalidDatePartException(std.string.toString(cast(int)datePart) ~ 
-          " is an invalid date part");
-  }
-  return normTime(time);
-}
-
-
-/**
- * Increment d_time time with a d_duration duration.
- *
- * Params:
- *  time =         A d_time time.
- *  duration =     A d_duration duration.
- *
- * Returns: A d_time time.
- */
-public d_time increment(d_time time, d_duration duration) {
-  time += cast(d_time)(duration.daysAndTime * MSEC_PER_DAY) %
-      MSEC_PER_DAY;
-  return normTime(time);
-}
-
-
-/**
- * Create a string from a d_timestamp date/time.
- *
- * Params:
- *  timestamp =    A timestamnp_t date/time.
- *  format =       An optional format string, defaults to ISO 8601.
- *
- * Returns: The d_timestamp time as a string.
- */
-public char[] toString(d_timestamp timestamp, 
-    char[] format = ISO_FORMAT_TIMESTAMP) {
-  assert(format == ISO_FORMAT_TIMESTAMP);
-  
-  return toString(dateOfTimeStamp(timestamp), format[0..8]) ~ " " ~
-         toString(timeOfTimeStamp(timestamp), format[9..$]);
-}
- 
- 
-/**
- * Crates a d_timestamp date/time from a string.
- *
- * Params:
- *  tsString =     A date and time time string.
- *  format =       An optional format string, defaults to ISO 8601.
- *
- * Returns: A d_timestamp date/time.
- */
-public d_timestamp toTimeStamp(char[] tsString) {
-  d_datetime datetime;
-  char[][] fields;
-  FieldType[] ftypes;
-  FieldType dtype;
-  if (!parseDateTime(tsString, fields, ftypes)) {
-    throw new ParseDateException(tsString ~ " can not be parsed as timestamp");
-  }
-  if (!decodeDateTime(fields, ftypes, dtype, datetime, false)) {
-    throw new ParseDateException(tsString ~ " can not be parsed as timestamp");
-  }
-  switch (dtype) {
-    case FieldType.DATE:
-      break;
-    case FieldType.EPOCH:
-      assert(0);
-    default:
-    throw new ParseDateException(tsString ~ " can not be parsed as timestamp");
-  }
-  d_date date = toDate(datetime.year, datetime.month, datetime.day);
-  d_time time = toTime(datetime.hour, datetime.minute, datetime.second, datetime.millisecond);
-  return toTimeStamp(date, time);
-}
-unittest {
-  // Also tests toTimeStamp(int, int...), toTimeStamp(date, time),
-  // toTimeStamp(int), toString(), and splitTimeStamp()
-  d_timestamp ts = toTimeStamp("2006-03-19 11:42:00");
-  assert(ts == toTimeStamp(toDate("2006-03-19"), toTime("11:42:00")));
-  assert(toString(toTimeStamp(0)) == "1970-01-01 00:00:00");
-  d_date d;
-  d_time t;
-  splitTimeStamp(ts, d, t);
-  assert(d == toDate(2006,3,19));
-  assert(t == toTime(11, 42, 0)); 
-}
-
-
-/**
- * Convert a d_date date to a d_timestamp date/time.
- *
- * Params:
- *  date =         A d_date date.
- *
- * Returns: A d_timestamp date/time.
- */
-public d_timestamp toTimeStamp(d_date date) {
-  return cast(d_timestamp)date;
-}
-
-
-/**
- * Convert a d_time time to a d_timestamp date/time.
- *
- * Params:
- *  time =         A d_time time.
- *
- * Returns: A d_timestamp date/time.
- */
-public d_timestamp toTimeStamp(d_time time) {
-  return cast(d_timestamp)date() + cast(d_timestamp)(cast(double)time / 
-      MSEC_PER_DAY);
-}
-
-
-/**
- * Convert a d_date date and a d_time time to a d_timestamp date/time.
- *
- * Params:
- *  date =         A d_date date.
- *  time =         A d_time time.
- *
- * Returns: A d_timestamp date/time.
- */
-public d_timestamp toTimeStamp(d_date date, d_time time) {
-  return cast(d_timestamp)date + cast(d_timestamp)(cast(double)time / 
-      MSEC_PER_DAY);
-}
-
-
-/**
- * Creates a date/time from an *nix epoch.
- *
- * Params:
- *  epoch =        An *nix epoch.
- *
- * Return: A d_timestamp date/time.
- */
-public d_timestamp toTimeStamp(int epoch) {
-  double timestamp;
-  timestamp = cast(double)epoch / SEC_PER_DAY;
-  timestamp -= DATE_UNIX_EPOCH_OFFSET;
-  return cast(d_timestamp)timestamp;
-}
-
-
-/**
- * Split a d_timestamp date/time into d_date date, and d_time time components.
- *
- * Params:
- *  timestamp =    A timetamp_t date/time.
- *  date =         (OUT) A d_date date.
- *  time =         (OUT) A d_time time.
- */
-public void splitTimeStamp(d_timestamp timestamp, out d_date date, 
-    out d_time time) {
-  date = dateOfTimeStamp(timestamp);
-  time = timeOfTimeStamp(timestamp);
-}
-
-
-
-/**
- * Get date part of a d_timestamp date/time.
- *
@@ -1012 +1140 @@
- * Returns: The datepart of a date/time.
- */
-aD
-aD
+d
+d
-    return cast(int)((cast(double)timestamp + DATE_UNIX_EPOCH_OFFSET) * 
-        SEC_PER_DAY);
-aD
-dateOfTimeStamp(timestamp), aD
+d
+toDate(timestamp), d
-  } else {
-imeOfTimeStamp(timestamp), aD
+oTime(timestamp), d
-  }
-}
@@ -1040 +1168 @@
-  assert(extract(ts, DatePart.MONTH) == 1);
-  assert(extract(ts, DatePart.YEAR) == 2005);
-}
-
-
-/**
- * Trunc a d_timestamp date to a given date part.
- *
- * Params:
- *  timestamp =         A d_timestamp date/time.
- *  datePart =     A DatePart, in the range MILLENIA..DAY, HOUR..SECOND.
- *
- * Returns: A d_timestamp date/time.
- */
-public d_timestamp truncate(d_timestamp timestamp, DatePart datePart) {
-  if (datePart == DatePart.DAY) {
-    return cast(d_timestamp)(cast(int)timestamp);
-  } else {
-    if (datePart < DatePart.HOUR) {
-      return toTimeStamp(truncate(dateOfTimeStamp(timestamp), datePart), 0);
-    } else {
-      return toTimeStamp(dateOfTimeStamp(timestamp), 
-          truncate(timeOfTimeStamp(timestamp), datePart));
-    }
-  }
-}
-unittest {
-  d_timestamp ts = toTimeStamp("2006-03-19 12:26:42");
-  assert(truncate(ts, DatePart.MINUTE) == toTimeStamp("2006-03-19 12:26:00"));
-  assert(truncate(ts, DatePart.HOUR) == toTimeStamp("2006-03-19 12:00:00"));
-  assert(truncate(ts, DatePart.DAY) == toTimeStamp("2006-03-19 00:00:00"));
-  assert(truncate(ts, DatePart.WEEK) == toTimeStamp("2006-03-13 00:00:00"));
-  assert(truncate(ts, DatePart.MONTH) == toTimeStamp("2006-03-01 00:00:00"));
-  assert(truncate(ts, DatePart.QUARTER) == toTimeStamp("2006-01-01 00:00:00"));
-  assert(truncate(ts, DatePart.YEAR) == toTimeStamp("2006-01-01 00:00:00"));
-  assert(truncate(ts, DatePart.DECADE) == toTimeStamp("2000-01-01 00:00:00"));
-  assert(truncate(ts, DatePart.MILLENIA) == toTimeStamp("2000-01-01 00:00:00"));
-}
-
-
-/**
- * Incremet a d_timestamp date/times's date part datePart by a count.
- *
- * Params:
- *  timestamp =    A d_timestamp date/time.
- *  datePart =     A DatePart date part, in range MILLENIA..MILLISECOND.
- *  count =        A count of dateparts to increment.
- *
- * Returns: A d_time time.
- */
-public d_timestamp increment(d_timestamp timestamp, DatePart datePart, int count) {
-  if (datePart < DatePart.HOUR) {
-    return toTimeStamp(increment(dateOfTimeStamp(timestamp), datePart, count), 
-        timeOfTimeStamp(timestamp));
-  } else {
-    switch (datePart) {
-      case DatePart.HOUR:
-        timestamp += cast(d_timestamp)(count * (1.0 / HOUR_PER_DAY));
-        break;
-      case DatePart.MINUTE:
-        timestamp += cast(d_timestamp)(count * (1.0 / MIN_PER_DAY));
-        break;
-      case DatePart.SECOND:
-        timestamp += cast(d_timestamp)(count * (1.0 / SEC_PER_DAY));
-        break;
-      case DatePart.MILLISECOND:
-        timestamp += cast(d_timestamp)(count * (1.0 / MSEC_PER_DAY));
-        break;
-      default:
-        throw new InvalidDatePartException(std.string.toString(cast(int)datePart) ~ 
-            " is an invalid date part");
-    }
-    return timestamp;
-  }
-}
-
-
-/**
- * Increment d_timestamp date/time with a d_duration duration.
- *
- * Params:
- *  timestamp =    A d_time time.
- *  duration =     A d_duration duration.
- *
- * Returns: A d_timestamp date/time.
- */
-public d_timestamp increment(d_timestamp timestamp, d_duration duration) {
-  return increment(timestamp, DatePart.MONTH, duration.months) + 
-      cast(d_timestamp)duration.daysAndTime;
-}
-
-
-/**
- * Get the d_date date part of a d_timestamp date/time.
- *
- * Params:
- *  timestamp =    A d_timestamp date/time.
- *
- * Returns: A d_date date.
- */
-public d_date dateOfTimeStamp(d_timestamp timestamp) {
-  return cast(d_date)timestamp;
-}
-
-
-/**
- * Replace the date part of a d_timestamp date/time.
- *
- * Params:
- *  timestamp =    (INOUT) A d_timestamp date/time.
- *  date =         A d_date date.
- */
-public void setDateOfTimeStamp(inout d_timestamp timestamp, d_date date) {
-  timestamp = timestamp - cast(d_timestamp)(cast(long)timestamp) + 
-      cast(d_timestamp)date;
-}
-
-
-/**
- * Get the d_time date part of a d_timestamp date/time.
- *
- * Params:
- *  timestamp =    A d_timestamp date/time.
- *
- * Returns: A d_time time.
- */
-public d_time timeOfTimeStamp(d_timestamp timestamp) {
-  return cast(d_time)((cast(double)timestamp * MSEC_PER_DAY) % MSEC_PER_DAY);
-}
-
-
-/**
- * Replace the time part of a d_timestamp date/time.
- *
- * Params:
- *  timestamp =    (INOUT) A d_timestamp date/time.
- *  time =         A d_time time.
- */
-public void setTimeOfTimeStamp(inout d_timestamp timestamp, d_time time) {
-  timestamp = cast(d_timestamp)(cast(long)timestamp) + 
-      cast(d_timestamp)(cast(double)time / MSEC_PER_DAY);
-}
-
-
-/**
- * Create a string from a d_duration duration.
- *
- * Params:
- *  duration =     An d_duration duration.
- *
- * Returns: The d_duration duration as a string.
- */
-public char[] toString(d_duration duration) {
-  assert(0);
-}
-
-
-/**
- * Creates an d_duration duration from a string.
- *
- * Params:
- *  durationString = A date string.
- *
- * Returns: An d_duration duration.
- */
-public d_duration toDuration(char[] durationString) {
-  d_datetime datetime;
-  char[][] fields;
-  FieldType[] ftypes;
-  if (!parseDateTime(durationString, fields, ftypes)) {
-    throw new ParseDateException(durationString ~ " can not be parsed as duration");
-  }
-  if (!decodeDuration(fields, ftypes, datetime)) {
-    throw new ParseDateException(durationString ~ " can not be parsed as duration");
-  }
-  return toDuration(datetime.year, datetime.month, datetime.day, 
-      datetime.hour, datetime.minute, datetime.second, datetime.millisecond);
-}
-unittest {
-  d_duration d = toDateDuration(1, 2, 3);
-  assert(d == toDuration("1 year, 2 months and 3 days")); 
-}
-
-
-/**
- * Creates an d_duration duration from years, months, days, hours, minutes,
- * seconds and milliseconds parts.
- *
- * Params:
- *  years =        Number of years.
- *  months =       Number of months.
- *  days =         Number of days.
- *  hours =        Numbr of hours.
- *  minutes =      Number of minutes.
- *  seconds =      Number of seconds.
- *  milliseconds = Optional number of milliseconds, defaults to 0.
- *
- * Returns: An d_duration duration.
- */
-public d_duration toDuration(int years, int months, int days, int hours, 
-    int minutes, int seconds, int milliseconds = 0) {
-  d_duration duration;
-  duration.daysAndTime = cast(double)days +
-                         (1.0 / HOUR_PER_DAY) * hours + 
-                         (1.0 / MIN_PER_DAY) * minutes +
-                         (1.0 / SEC_PER_DAY) * seconds +
-                         (1.0 / MSEC_PER_DAY) * milliseconds;
-  duration.months = years * 12 + months;
-  return duration;
-}
-
-
-/**
- * Creates an d_duration duration from years, months, and days parts.
- *
- * Params:
- *  years =        Number of years.
- *  months =       Number of months.
- *  days =         Number of days.
- *
- * Returns: An d_duration duration.
- */
-public d_duration toDateDuration(int years, int months, int days) {
-  return toDuration(years, months, days, 0, 0, 0);
-}
-
-
-/**
- * Creates an d_duration duration from hours, minutes, seconds and milliseconds 
- * parts.
- *
- * Params:
- *  hours =        Numbr of hours.
- *  minutes =      Number of minutes.
- *  seconds =      Number of seconds.
- *  milliseconds = Optional number of milliseconds, defaults to 0.
- *
- * Returns: An d_duration duration.
- */
-public d_duration toTimeDuration(int hours, int minutes, int seconds, int milliseconds = 0) {
-  return toDuration(0, 0, 0, hours, minutes, seconds, milliseconds);
-}
-
-
-/**
- * Splits an d_duration duration into years, months, days, hours, minutes,
- * seconds and milliseconds parts.
- *
- * Params:
- *  years =        (OUT) Number of years.
- *  months =       (OUT) Number of months.
- *  days =         (OUT) Number of days.
- *  hours =        (OUT) Numbr of hours.
- *  minutes =      (OUT) Number of minutes.
- *  seconds =      (OUT) Number of seconds.
- *  milliseconds = (OUT) Number of milliseconds.
- */
-public void splitDuration(d_duration duration, out int years, out int months, 
-    out int days, out int hours, out int minutes, out int seconds, out int milliseconds) {
-  years = duration.months / 12;
-  months = duration.months % 12;
-  days = cast(int)duration.daysAndTime;
-  float timePart = duration.daysAndTime - days;
-  hours = cast(int)((timePart * HOUR_PER_DAY) % 24);
-  minutes = cast(int)((timePart * MIN_PER_DAY) % 60);
-  seconds = cast(int)((timePart * SEC_PER_DAY) % 60);
-  milliseconds = cast(int)((timePart * MSEC_PER_DAY) % 1000);
-}
-
-
-/**
- * Splits an d_duration duration into years, months, and days parts.
- *
- * Params:
- *  years =        (OUT) Number of years.
- *  months =       (OUT) Number of months.
- *  days =         (OUT) Number of days.
- */
-public void splitDateDuration(d_duration duration, out int years, 
-    out int months, out int days) {
-  years = duration.months / 12;
-  months = duration.months % 12;
-  days = cast(int)duration.daysAndTime;
-  // float timePart = duration.daysAndTime - days;
-}
-
-
-/**
- * Splits an d_duration duration into hours, minutes, seconds and milliseconds 
- * parts.
- *
- * The days of the duration will be converted to hours, any months and/or years
- * will be ignored as their length in hours can not be determined.
- *
- * Params:
- *  hours =        (OUT) Numbr of hours.
- *  minutes =      (OUT) Number of minutes.
- *  seconds =      (OUT) Number of seconds.
- *  milliseconds = (OUT) Number of milliseconds.
- *
- */
-public void splitTimeDuration(d_duration duration, out int hours, 
-    out int minutes, out int seconds, out int milliseconds) {
-  double timePart = duration.daysAndTime;
-  hours = cast(int)(timePart * HOUR_PER_DAY); 
-  minutes = cast(int)((timePart * MIN_PER_DAY) % 60);
-  seconds = cast(int)((timePart * SEC_PER_DAY) % 60);
-  milliseconds = cast(int)((timePart * MSEC_PER_DAY) % 1000);
-}
-
@@ -1400 +1222 @@
-
-/**
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-  switch (datePart) {
-    case DatePart.MILLENIA:
-
-
+
-    case DatePart.DECADE:
-
-
+
-    case DatePart.YEAR:
-
-
+
-    case DatePart.QUARTER:
-
-
+
-    case DatePart.MONTH:
-
-
+
-    case DatePart.WEEK:
-
-
-
+
-    case DatePart.DAY:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    default:
-      throw new InvalidDatePartException(std.string.toString(cast(int)datePart) ~ 
-          " is an invalid date part");
-  }
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -1530 +1440 @@
-
-/**
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-  
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-

branches/dateparse.d

@@ -537 +537 @@
-                            /* fractional Julian Day? */
-                            if (vald != int.min) {
-(timeOfTimeStamp(cast(d_timestamp)toDouble(field[pos..$])
+TimeStamp(cast(d_timestamp)toDouble(field[pos..$]
-                    datetime.hour, datetime.minute, datetime.second, datetime.millisecond);
-                                tmask |= maskTime();