Do WinRT Calendar dates occur on the same day?

I have 2 winrt::Calendars, and I know I can Compare them, but that compares the dates down to (presumably) the nanosecond.

How can I robustly tell if 2 dates occur on the same day, or same hour, etc in history? I'm worried that zeroing out the hour/minute/time/etc is dangerous, after reading Falsehoods programmers believe about time.

eg April 28, 2023 at 3:12PM PDT and April 28, 2023 at 11:31AM PDT should compare equal, but May 12, 2021 at 1:24PM PDT and May 12, 2023 at 1:24PM PDT should not.

The falsehoods are a good list. I love the "I can easily maintain a timezone list myself" one. LOL.

Though I contributed to the previous answer, I wanted to share some additional thoughts without randomizeing that answer too much.

My key thoughts are "the context and scenario are important and need to be fully understood." Particularly with regard to potential edge cases and limitations of the chosen solution.

One item I'd add is that the processing location can have an impact. Eg: if the date/times are processed locally or on a server. My server's midnight batch process might be in the middle of the working day for some users.

I tend to recommend UTC, but you have to be careful. If you're only using the "date" part of a time, and then switch it to UTC, the date might change!

One question you might ask is if you're programming to an explicit moment in time, an actual timestamp. Or if you're intending a more conceptual use, like a calendar day. Eg: The US declared independence on July 4, 1776. People think of that date in their own frame of reference. It was in the afternoon sometime, so in actuality it was July 5th in some parts of the British Empire, yet they'd likely still answer July 4th on a history exam.

Also, be aware of the edge cases. "Same hour" is going to be a relatively meaningless question if you have events from EST and NST.

As programmers we always want someone to say "use the + operator to add two numbers" and know we're good (of course, that isn't even that simple, are they real or integers or too big).

Anyway, dates & times aren't one of those things where we can say "do it this way" and be done with it. The developer needs to understand what the goals are, and the limitations of their approach. "Who wrote to this file last?" is way easier than "what happened on July 4th for my wiki page?"

This is a complicated question.

Warning

As mentioned in the question, time is confusing. Here are a couple other concerns that apply to all these solutions:

• Do your users expect "same day" to mean "same calendar date"? Or do they expect "previous 24h"?

  • For example, users of a to-do app might expect tasks due on the "same day" to mean "same calendar date", but what if your users primarily use the app on a night shift? Splitting based on "same calendar date" might be really frustrating, as tasks might become overdue midway through their shift, at midnight.

• Are your dates time-zone--dependent?

  • For example, users of a to-do app might expect tasks to be due on apparent calendar date (eg if this task is "due tomorrow" and I cross the international date line, the task should still be "due tomorrow"). But they might instead expect the task to be due based on a concrete "moment" (eg crossing the line would make the task due today/2 days from now).

• Moments in time are confusing (UTC only goes back a few decades, and leap-seconds add further confusion).

• Users who are traveling might have a different perception of "days" than the calendar offers.

So the answer to this question is inherently laden with edge-cases. That said, here are some solutions suggested by my colleagues:

Option 1: compare both times using std::chrono (C++20 only)

bool IsSameDay(winrt::Windows::Globalization::Calendar const& a,
    winrt::Windows::Globalization::Calendar const& b)
{
    const aSys = winrt::clock::to_sys(a.GetDateTime());
    const bSys = winrt::clock::to_sys(b.GetDateTime());

    const auto ymdA = std::chrono::year_month_day(std::chrono::time_point_cast<std::chrono::days>(aSys));
    const auto ymdB = std::chrono::year_month_day(std::chrono::time_point_cast<std::chrono::days>(bSys));

    return ymdA == ymdB;
}

Option 2: zero-out the timepoints, yup

void SetCalendarToDay(winrt::Windows::Globalization::Calendar& c)
{
    // Assumes nanoseconds are the smallest tick in the calendar.
    c.Period(c.FirstPeriodInThisDay());
    c.Hour(c.FirstHourInThisPeriod());
    c.Minute(c.FirstMinuteInThisHour());
    c.Second(c.FirstSecondInThisMinute());
    c.Nanosecond(0);
}

bool IsSameDay(winrt::Windows::Globalization::Calendar const& a,
    winrt::Windows::Globalization::Calendar const& b)
{
    const a2 = a.Clone();
    const b2 = b.Clone();
    SetCalendarToDay(a2);
    SetCalendarToDay(b2);

    return a2.Compare(b2) == 0;
}

Option 3: compare year, month, and day manually

bool IsSameDay(winrt::Windows::Globalization::Calendar const& a,
    winrt::Windows::Globalization::Calendar const& b)
{
    auto dt1_tt = winrt::clock::to_time_t(a.GetDateTime());
    auto dt2_tt = winrt::clock::to_time_t(b.GetDateTime());

    // Conversion done to UTC time. If needed in Local time zone - use *localtime(&dt*_tt);
    auto dt1_tt_tm = *gmtime(&dt1_tt);
    auto dt2_tt_tm = *gmtime(&dt2_tt);

    return dt1_tt_tm.tm_year == dt2_tt_tm.tm_year && dt1_tt_tm.tm_mday == dt2_tt_tm.tm_mday;
}

Conclusion

"Do calendar dates occur on the same day" is a complicated question, so it's hard to answer completely. But these answers should help get a decent result.