Native: implement (untested) atStartOfDay

dkhalanskyjb · ilya-g · commit 15a7d590d2f3 · 2020-08-04T17:52:24.000+03:00
Tests fail on Windows because its record for Asia/Gaza is
incomplete or inaccurate (it stores 23:59:59 as the start of the
transition to DST, but according to the documentation and from
looking at results for other time zones, it should instead store
the moment of the transition and not the moment right before it).
diff --git a/core/nativeMain/cinterop/cpp/apple.mm b/core/nativeMain/cinterop/cpp/apple.mm
@@ -172,27 +172,31 @@ TZID timezone_by_name(const char *zone_name) {
     return id_by_name([NSString stringWithUTF8String: zone_name]);
 }
 
-int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset) {
-    *offset = INT_MAX;
-    // timezone
-    auto zone = timezone_by_id(zone_id);
-    if (zone == nil) { return 0; }
-    /* a date in an unspecified timezone, defined by the number of seconds since
-       the start of the epoch in *that* unspecified timezone */
-    auto date = dateWithTimeIntervalSince1970Saturating(epoch_sec);
-    // The ISO8601 calendar.
+static NSDate *system_date_by_local_date(NSTimeZone *zone, NSDate *local_date) {
+    // The Gregorian calendar.
     NSCalendar *iso8601 = [NSCalendar
         calendarWithIdentifier: NSCalendarIdentifierISO8601];
-    if (iso8601 == nil) { return 0; }
+    if (iso8601 == nil) { return nil; }
     // The UTC time zone
     NSTimeZone *utc = [NSTimeZone timeZoneForSecondsFromGMT: 0];
     /* Now, we say that the date that we initially meant is `date`, only with
        the context of being in a timezone `zone`. */
     NSDateComponents *dateComponents = [iso8601
         componentsInTimeZone: utc
-        fromDate: date];
+        fromDate: local_date];
     dateComponents.timeZone = zone;
-    NSDate *newDate = [iso8601 dateFromComponents:dateComponents];
+    return [iso8601 dateFromComponents:dateComponents];
+}
+
+int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset) {
+    *offset = INT_MAX;
+    // timezone
+    auto zone = timezone_by_id(zone_id);
+    if (zone == nil) { return 0; }
+    /* a date in an unspecified timezone, defined by the number of seconds since
+       the start of the epoch in *that* unspecified timezone */
+    NSDate *date = dateWithTimeIntervalSince1970Saturating(epoch_sec);
+    NSDate *newDate = system_date_by_local_date(zone, date);
     if (newDate == nil) { return 0; }
     // we now know the offset of that timezone at this time.
     *offset = (int)[zone secondsFromGMTForDate: newDate];
@@ -203,5 +207,28 @@ int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset) {
     return result;
 }
 
+int64_t at_start_of_day(TZID zone_id, int64_t epoch_sec) {
+    // timezone
+    auto zone = timezone_by_id(zone_id);
+    if (zone == nil) { return INT_MAX; }
+    NSDate *date = [NSDate dateWithTimeIntervalSince1970: epoch_sec];
+    NSDate *newDate = system_date_by_local_date(zone, date);
+    if (newDate == nil) { return INT_MAX; }
+    int offset = (int)[zone secondsFromGMTForDate: newDate];
+    /* if `epoch_sec` is not in the range supported by Darwin, assume that it
+       is the correct local time for the midnight and just convert it to
+       the system time. */
+    if ([date timeIntervalSinceDate:[NSDate distantPast]] < 0 ||
+        [date timeIntervalSinceDate:[NSDate distantFuture]] > 0)
+        return epoch_sec - offset;
+    // The ISO-8601 calendar.
+    NSCalendar *iso8601 = [NSCalendar
+        calendarWithIdentifier: NSCalendarIdentifierISO8601];
+    iso8601.timeZone = zone;
+    // start of the day denoted by `newDate`
+    NSDate *midnight = [iso8601 startOfDayForDate: newDate];
+    return (int64_t)([midnight timeIntervalSince1970]);
+}
+
 }
 #endif // TARGET_OS_IPHONE
diff --git a/core/nativeMain/cinterop/cpp/cdate.cpp b/core/nativeMain/cinterop/cpp/cdate.cpp
@@ -12,6 +12,7 @@
 #include "date/date.h"
 #include "date/tz.h"
 #include "helper_macros.hpp"
+#include <cstring>
 using namespace date;
 using namespace std::chrono;
 
@@ -48,12 +49,7 @@ extern "C" {
 template <class T>
 static char * timezone_name(const T& zone)
 {
-    auto name = zone.name();
-    char * name_copy = check_allocation(
-        (char *)malloc(sizeof(char) * (name.size() + 1)));
-    name_copy[name.size()] = '\0';
-    name.copy(name_copy, name.size());
-    return name_copy;
+    return strdup(zone.name().c_str());
 }
 
 static const time_zone *zone_by_id(TZID id)
@@ -139,21 +135,33 @@ TZID timezone_by_name(const char *zone_name)
     }
 }
 
-int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset)
+static int offset_at_datetime_impl(TZID zone_id, seconds sec, int *offset,
+GAP_HANDLING gap_handling)
 {
     try {
         auto zone = zone_by_id(zone_id);
-        local_seconds seconds(saturating(epoch_sec));
+        local_seconds seconds(sec);
         auto info = zone->get_info(seconds);
         switch (info.result) {
             case local_info::unique:
                 *offset = info.first.offset.count();
                 return 0;
             case local_info::nonexistent: {
-                auto trans_duration = info.second.offset.count() -
-                    info.first.offset.count();
                 *offset = info.second.offset.count();
-                return trans_duration;
+                switch (gap_handling) {
+                    case GAP_HANDLING_MOVE_FORWARD:
+                        return info.second.offset.count() -
+                            info.first.offset.count();
+                    case GAP_HANDLING_NEXT_CORRECT: {
+                        return duration_cast<std::chrono::seconds>(
+                            info.second.begin.time_since_epoch()).count() -
+                            sec.count() + info.second.offset.count();
+                    }
+                    default:
+                        // impossible
+                        *offset = INT_MAX;
+                        return 0;
+                }
             }
             case local_info::ambiguous:
                 if (info.second.offset.count() != *offset)
@@ -170,6 +178,25 @@ int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset)
     }
 }
 
+int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset)
+{
+    return offset_at_datetime_impl(zone_id, saturating(epoch_sec), offset,
+        GAP_HANDLING_MOVE_FORWARD);
+}
+
+int64_t at_start_of_day(TZID zone_id, int64_t epoch_sec)
+{
+    int offset = 0;
+    int trans = offset_at_datetime_impl(zone_id, saturating(epoch_sec), &offset,
+        GAP_HANDLING_NEXT_CORRECT);
+    if (offset == INT_MAX)
+        return LONG_MAX;
+    if (epoch_sec > max_available_instant || epoch_sec < min_available_instant) {
+        trans = 0;
+    }
+    return epoch_sec - offset + trans;
+}
+
 }
 #endif // !DATETIME_TARGET_WIN32
 #endif // !TARGET_OS_IPHONE
diff --git a/core/nativeMain/cinterop/cpp/windows.cpp b/core/nativeMain/cinterop/cpp/windows.cpp
@@ -212,23 +212,28 @@ static int64_t systemtime_to_unix_time(const SYSTEMTIME& systime)
         SECS_BETWEEN_1601_1970;
 }
 
+struct TRANSITIONS_INFO {
+    TIME_ZONE_INFORMATION tzi;
+    SYSTEMTIME standard_local;
+    SYSTEMTIME daylight_local;
+};
+
 /* Checks whether the daylight saving time is in effect at the given time.
    `tzi` could be calculated here, but is passed along to avoid recomputing
    it. */
 static bool is_daylight_time(
     const DYNAMIC_TIME_ZONE_INFORMATION& dtzi,
-    const TIME_ZONE_INFORMATION& tzi,
+    TRANSITIONS_INFO& trans,
     const SYSTEMTIME& time)
 {
     // it means that daylight saving time is not supported at all
-    if (tzi.StandardDate.wMonth == 0) {
+    if (trans.tzi.StandardDate.wMonth == 0) {
         return false;
     }
     /* translate the "date" values stored in `tzi` into real dates of
        transitions to and from the daylight saving time. */
-    SYSTEMTIME standard_local, daylight_local;
-    get_transition_date(time.wYear, tzi.StandardDate, standard_local);
-    get_transition_date(time.wYear, tzi.DaylightDate, daylight_local);
+    get_transition_date(time.wYear, trans.tzi.StandardDate, trans.standard_local);
+    get_transition_date(time.wYear, trans.tzi.DaylightDate, trans.daylight_local);
     /* Two things happen here:
         * All the relevant dates are converted to a number of ticks an some
           unified scale, counted in seconds. This is done so that we are able
@@ -239,10 +244,10 @@ static bool is_daylight_time(
           time, as seen by a person that is currently on the daylight saving
           time. So, in order for the dates to be on the same scale, the biases
           that are assumed to be currently active are negated. */
-    int64_t standard = systemtime_to_ticks(standard_local) /
-        WINDOWS_TICKS_PER_SEC + (tzi.Bias + tzi.DaylightBias) * 60;
-    int64_t daylight = systemtime_to_ticks(daylight_local) /
-        WINDOWS_TICKS_PER_SEC + (tzi.Bias + tzi.StandardBias) * 60;
+    int64_t standard = systemtime_to_ticks(trans.standard_local) /
+        WINDOWS_TICKS_PER_SEC + (trans.tzi.Bias + trans.tzi.DaylightBias) * 60;
+    int64_t daylight = systemtime_to_ticks(trans.daylight_local) /
+        WINDOWS_TICKS_PER_SEC + (trans.tzi.Bias + trans.tzi.StandardBias) * 60;
     int64_t time_secs = systemtime_to_ticks(time) /
         WINDOWS_TICKS_PER_SEC;
     /* Maybe `else` is never hit, but I've seen no indication of that assumption
@@ -258,18 +263,18 @@ static bool is_daylight_time(
 
 // Get the UTC offset for a given timezone at a given time.
 static int offset_at_systime(DYNAMIC_TIME_ZONE_INFORMATION& dtzi,
+    TRANSITIONS_INFO& ts,
     const SYSTEMTIME& systime)
 {
-    TIME_ZONE_INFORMATION tzi{};
-    bool result = GetTimeZoneInformationForYear(systime.wYear, &dtzi, &tzi);
+    bool result = GetTimeZoneInformationForYear(systime.wYear, &dtzi, &ts.tzi);
     if (!result) {
         return INT_MAX;
     }
-    auto bias = tzi.Bias;
-    if (is_daylight_time(dtzi, tzi, systime)) {
-        bias += tzi.DaylightBias;
+    auto bias = ts.tzi.Bias;
+    if (is_daylight_time(dtzi, ts, systime)) {
+        bias += ts.tzi.DaylightBias;
     } else {
-        bias += tzi.StandardBias;
+        bias += ts.tzi.StandardBias;
     }
     return -bias * 60;
 }
@@ -330,7 +335,8 @@ int offset_at_instant(TZID zone_id, int64_t epoch_sec)
     }
     SYSTEMTIME systime;
     unix_time_to_systemtime(epoch_sec, systime);
-    return offset_at_systime(dtzi, systime);
+    TRANSITIONS_INFO ts{};
+    return offset_at_systime(dtzi, ts, systime);
 }
 
 TZID timezone_by_name(const char *zone_name)
@@ -344,7 +350,8 @@ TZID timezone_by_name(const char *zone_name)
     }
 }
 
-int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset)
+static int offset_at_datetime_impl(TZID zone_id, int64_t epoch_sec, int *offset,
+GAP_HANDLING gap_handling)
 {
     DYNAMIC_TIME_ZONE_INFORMATION dtzi{};
     bool result = time_zone_by_id(zone_id, dtzi);
@@ -354,7 +361,8 @@ int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset)
     SYSTEMTIME localtime, utctime, adjusted;
     unix_time_to_systemtime(epoch_sec, localtime);
     TzSpecificLocalTimeToSystemTimeEx(&dtzi, &localtime, &utctime);
-    *offset = offset_at_systime(dtzi, utctime);
+    TRANSITIONS_INFO trans{};
+    *offset = offset_at_systime(dtzi, trans, utctime);
     SystemTimeToTzSpecificLocalTimeEx(&dtzi, &utctime, &adjusted);
     /* We don't use `epoch_sec` instead of `systemtime_to_unix_time(localtime)
     because `unix_time_to_systemtime(epoch_sec, localtime)` above could
@@ -364,8 +372,55 @@ int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset)
     result to return: timezone database information outside of [1970; current
     time) is not accurate anyway, and WinAPI supports dates in years [1601;
     30827], which should be enough for all practical purposes. */
-    return (int)(systemtime_to_unix_time(adjusted) -
+    const auto transition_duration = (int)(systemtime_to_unix_time(adjusted) -
         systemtime_to_unix_time(localtime));
+    if (transition_duration == 0)
+        return 0;
+    switch (gap_handling) {
+        case GAP_HANDLING_MOVE_FORWARD:
+            return transition_duration;
+        case GAP_HANDLING_NEXT_CORRECT:
+        /* Let x, y in {daylight, standard}
+           If a gap happened, then
+               xEnd + xOffset < utctime < yBegin + yOffset
+           What we need to return is
+               yBegin + yOffset - epoch_sec
+           To learn whether we crossed from daylight to standard or vice versa:
+               xEnd = yBegin - epsilon => yOffset + epsilon > xOffset
+           Thus, we crossed from the lower offset to the bigger one. So,
+           return (daylight.offset > standard.offset ?
+                   daylight.begin + daylight.offset :
+                   standard.begin + standard.offset) - epoch_sec */
+            if (trans.tzi.DaylightBias < trans.tzi.StandardBias) {
+                return systemtime_to_unix_time(trans.daylight_local)
+                    + trans.tzi.StandardBias - trans.tzi.DaylightBias
+                    - epoch_sec + 1;
+            } else {
+                return systemtime_to_unix_time(trans.standard_local)
+                    + trans.tzi.DaylightBias - trans.tzi.StandardBias
+                    - epoch_sec + 1;
+            }
+        default:
+            // impossible
+            *offset = INT_MAX;
+            return 0;
+    }
+}
+
+int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset)
+{
+    return offset_at_datetime_impl(zone_id, epoch_sec, offset,
+        GAP_HANDLING_MOVE_FORWARD);
+}
+
+int64_t at_start_of_day(TZID zone_id, int64_t epoch_sec)
+{
+    int offset = 0;
+    int trans = offset_at_datetime_impl(zone_id, epoch_sec, &offset,
+        GAP_HANDLING_NEXT_CORRECT);
+    if (offset == INT_MAX)
+        return LONG_MAX;
+    return epoch_sec - offset + trans;
 }
 
 }
diff --git a/core/nativeMain/cinterop/public/cdate.h b/core/nativeMain/cinterop/public/cdate.h
@@ -8,7 +8,12 @@
 #include <stddef.h>
 
 typedef size_t TZID;
-const size_t TZID_INVALID = SIZE_MAX;
+const TZID TZID_INVALID = SIZE_MAX;
+
+enum GAP_HANDLING {
+    GAP_HANDLING_MOVE_FORWARD,
+    GAP_HANDLING_NEXT_CORRECT,
+};
 
 /* Returns a string that must be freed by the caller, or null.
    If something is returned, `id` has the id of the timezone. */
@@ -31,3 +36,5 @@ TZID timezone_by_name(const char *zone_name);
    case the time does not exist, having fallen in the gap.
    In case of an error, "offset" is set to INT_MAX. */
 int offset_at_datetime(TZID zone, int64_t epoch_sec, int *offset);
+
+int64_t at_start_of_day(TZID zone, int64_t midnight_epoch_sec);
diff --git a/core/nativeMain/cinterop_actuals/TimeZoneNative.kt b/core/nativeMain/cinterop_actuals/TimeZoneNative.kt
@@ -22,6 +22,9 @@ internal actual fun available_zone_ids(): kotlinx.cinterop.CPointer<kotlinx.cint
 internal actual fun offset_at_datetime(zone: kotlinx.datetime.TZID /* = kotlin.ULong */, epoch_sec: platform.posix.int64_t /* = kotlin.Long */, offset: kotlinx.cinterop.CValuesRef<kotlinx.cinterop.IntVar /* = kotlinx.cinterop.IntVarOf<kotlin.Int> */>?): kotlin.Int =
         kotlinx.datetime.internal.offset_at_datetime(zone, epoch_sec, offset)
 
+internal actual fun at_start_of_day(zone: kotlinx.datetime.TZID /* = kotlin.ULong */, epoch_sec: platform.posix.int64_t /* = kotlin.Long */): kotlin.Long =
+    kotlinx.datetime.internal.at_start_of_day(zone, epoch_sec)
+
 internal actual fun offset_at_instant(zone: kotlinx.datetime.TZID /* = kotlin.ULong */, epoch_sec: platform.posix.int64_t /* = kotlin.Long */): kotlin.Int =
         kotlinx.datetime.internal.offset_at_instant(zone, epoch_sec)
 
diff --git a/core/nativeMain/src/TimeZone.kt b/core/nativeMain/src/TimeZone.kt
@@ -19,6 +19,7 @@ internal typealias TZID = platform.posix.size_t
 internal expect val TZID_INVALID: TZID
 internal expect fun available_zone_ids(): kotlinx.cinterop.CPointer<kotlinx.cinterop.CPointerVar<kotlinx.cinterop.ByteVar>>?
 internal expect fun offset_at_datetime(zone: kotlinx.datetime.TZID /* = kotlin.ULong */, epoch_sec: platform.posix.int64_t /* = kotlin.Long */, offset: kotlinx.cinterop.CValuesRef<kotlinx.cinterop.IntVar /* = kotlinx.cinterop.IntVarOf<kotlin.Int> */>?): kotlin.Int
+internal expect fun at_start_of_day(zone: kotlinx.datetime.TZID /* = kotlin.ULong */, epoch_sec: platform.posix.int64_t /* = kotlin.Long */): kotlin.Long
 internal expect fun offset_at_instant(zone: kotlinx.datetime.TZID /* = kotlin.ULong */, epoch_sec: platform.posix.int64_t /* = kotlin.Long */): kotlin.Int
 internal expect fun timezone_by_name(zone_name: kotlin.String?): kotlinx.datetime.TZID /* = kotlin.ULong */
 
@@ -100,6 +101,16 @@ public actual open class TimeZone internal constructor(private val tzid: TZID, a
 
     actual fun LocalDateTime.toInstant(): Instant = atZone().toInstant()
 
+    internal open fun atStartOfDay(date: LocalDate): Instant = memScoped {
+        val ldt = LocalDateTime(date, LocalTime.MIN)
+        val epochSeconds = ldt.toEpochSecond(ZoneOffset.UTC)
+        val midnightInstantSeconds = at_start_of_day(tzid, epochSeconds)
+        if (midnightInstantSeconds == Long.MAX_VALUE) {
+            throw RuntimeException("Unable to acquire the time of start of day at $date for zone $this")
+        }
+        Instant(midnightInstantSeconds, 0)
+    }
+
     internal open fun LocalDateTime.atZone(preferred: ZoneOffset? = null): ZonedDateTime = memScoped {
         val epochSeconds = toEpochSecond(ZoneOffset.UTC)
         val offset = alloc<IntVar>()
@@ -250,6 +261,9 @@ public actual class ZoneOffset internal constructor(actual val totalSeconds: Int
         }
     }
 
+    internal override fun atStartOfDay(date: LocalDate): Instant =
+        LocalDateTime(date, LocalTime.MIN).atZone(null).toInstant()
+
     internal override fun LocalDateTime.atZone(preferred: ZoneOffset?): ZonedDateTime =
         ZonedDateTime(this@atZone, this@ZoneOffset, this@ZoneOffset)
 
diff --git a/core/nativeTest/src/ThreeTenBpTimeZoneTest.kt b/core/nativeTest/src/ThreeTenBpTimeZoneTest.kt
