qdatetime.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2021 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdatetime.h"
 
#include "qcalendar.h"
#include "qdatastream.h"
#include "qdebug.h"
#include "qlocale.h"
#include "qset.h"
 
#include "private/qcalendarmath_p.h"
#include "private/qdatetime_p.h"
#if QT_CONFIG(datetimeparser)
#include "private/qdatetimeparser_p.h"
#endif
#ifdef Q_OS_DARWIN
#include "private/qcore_mac_p.h"
#endif
#include "private/qgregoriancalendar_p.h"
#include "private/qlocale_tools_p.h"
#include "private/qlocaltime_p.h"
#include "private/qnumeric_p.h"
#include "private/qstringconverter_p.h"
#include "private/qstringiterator_p.h"
#if QT_CONFIG(timezone)
#include "private/qtimezoneprivate_p.h"
#endif
 
#include <cmath>
#ifdef Q_OS_WIN
#  include <qt_windows.h>
#endif
 
#include <private/qtools_p.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
using namespace QtPrivate::DateTimeConstants;
using namespace QtMiscUtils;
 
/*****************************************************************************
  Date/Time Constants
 *****************************************************************************/
 
/*****************************************************************************
  QDate static helper functions
 *****************************************************************************/
static_assert(std::is_trivially_copyable_v<QCalendar::YearMonthDay>);
 
static inline QDate fixedDate(QCalendar::YearMonthDay parts, QCalendar cal)
{
    if ((parts.year < 0 && !cal.isProleptic()) || (parts.year == 0 && !cal.hasYearZero()))
        return QDate();
 
    parts.day = qMin(parts.day, cal.daysInMonth(parts.month, parts.year));
    return cal.dateFromParts(parts);
}
 
static inline QDate fixedDate(QCalendar::YearMonthDay parts)
{
    if (parts.year) {
        parts.day = qMin(parts.day, QGregorianCalendar::monthLength(parts.month, parts.year));
        const auto jd = QGregorianCalendar::julianFromParts(parts.year, parts.month, parts.day);
        if (jd)
            return QDate::fromJulianDay(*jd);
    }
    return QDate();
}
 
/*****************************************************************************
  Date/Time formatting helper functions
 *****************************************************************************/
 
#if QT_CONFIG(textdate)
static const char qt_shortMonthNames[][4] = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
 
static int fromShortMonthName(QStringView monthName)
{
    for (unsigned int i = 0; i < sizeof(qt_shortMonthNames) / sizeof(qt_shortMonthNames[0]); ++i) {
        if (monthName == QLatin1StringView(qt_shortMonthNames[i], 3))
            return i + 1;
    }
    return -1;
}
#endif // textdate
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
namespace {
using ParsedInt = QSimpleParsedNumber<qulonglong>;
 
/*
    Reads a whole number that must be the whole text.
*/
ParsedInt readInt(QLatin1StringView text)
{
    // Various date formats' fields (e.g. all in ISO) should not accept spaces
    // or signs, so check that the string starts with a digit and that qstrntoull()
    // converted the whole string.
 
    if (text.isEmpty() || !isAsciiDigit(text.front().toLatin1()))
        return {};
 
    QSimpleParsedNumber res = qstrntoull(text.data(), text.size(), 10);
    return res.used == text.size() ? res : ParsedInt{};
}
 
ParsedInt readInt(QStringView text)
{
    if (text.isEmpty())
        return {};
 
    // Converting to Latin-1 because QStringView::toULongLong() works with
    // US-ASCII only by design anyway.
    // Also QStringView::toULongLong() can't be used here as it will happily ignore
    // spaces and accept signs; but various date formats' fields (e.g. all in ISO)
    // should not.
    QVarLengthArray<char> latin1(text.size());
    QLatin1::convertFromUnicode(latin1.data(), text);
    return readInt(QLatin1StringView{latin1.data(), latin1.size()});
}
 
} // namespace
 
struct ParsedRfcDateTime {
    QDate date;
    QTime time;
    int utcOffset;
};
 
static int shortDayFromName(QStringView name)
{
    const char16_t shortDayNames[] = u"MonTueWedThuFriSatSun";
    for (int i = 0; i < 7; i++) {
        if (name == QStringView(shortDayNames + 3 * i, 3))
            return i + 1;
    }
    return 0;
}
 
static ParsedRfcDateTime rfcDateImpl(QStringView s)
{
    // Matches "[ddd,] dd MMM yyyy[ hh:mm[:ss]] [±hhmm]" - correct RFC 822, 2822, 5322 format -
    // or           "ddd MMM dd[ hh:mm:ss] yyyy [±hhmm]" - permissive RFC 850, 1036 (read only)
    ParsedRfcDateTime result;
 
    QVarLengthArray<QStringView, 6> words;
 
    auto tokens = s.tokenize(u' ', Qt::SkipEmptyParts);
    auto it = tokens.begin();
    for (int i = 0; i < 6 && it != tokens.end(); ++i, ++it)
        words.emplace_back(*it);
 
    if (words.size() < 3 || it != tokens.end())
        return result;
    const QChar colon(u':');
    bool ok = true;
    QDate date;
 
    const auto isShortName = [](QStringView name) {
        return (name.size() == 3 && name[0].isUpper()
                && name[1].isLower() && name[2].isLower());
    };
 
    /* Reject entirely (return) if the string is malformed; however, if the date
     * is merely invalid, (break, so as to) go on to parsing of the time.
     */
    int yearIndex;
    do { // "loop" so that we can use break on merely invalid, but "right shape" date.
        QStringView dayName;
        bool rfcX22 = true;
        const QStringView maybeDayName = words.front();
        if (maybeDayName.endsWith(u',')) {
            dayName = maybeDayName.chopped(1);
            words.erase(words.begin());
        } else if (!maybeDayName.front().isDigit()) {
            dayName = maybeDayName;
            words.erase(words.begin());
            rfcX22 = false;
        } // else: dayName is not specified (so we can only be RFC *22)
        if (words.size() < 3 || words.size() > 5)
            return result;
 
        // Don't break before setting yearIndex.
        int dayIndex, monthIndex;
        if (rfcX22) {
            // dd MMM yyyy [hh:mm[:ss]] [±hhmm]
            dayIndex = 0;
            monthIndex = 1;
            yearIndex = 2;
        } else {
            // MMM dd[ hh:mm:ss] yyyy [±hhmm]
            dayIndex = 1;
            monthIndex = 0;
            yearIndex = words.size() > 3 && words.at(2).contains(colon) ? 3 : 2;
        }
 
        int dayOfWeek = 0;
        if (!dayName.isEmpty()) {
            if (!isShortName(dayName))
                return result;
            dayOfWeek = shortDayFromName(dayName);
            if (!dayOfWeek)
                break;
        }
 
        const int day = words.at(dayIndex).toInt(&ok);
        if (!ok)
            return result;
        const int year = words.at(yearIndex).toInt(&ok);
        if (!ok)
            return result;
        const QStringView monthName = words.at(monthIndex);
        if (!isShortName(monthName))
            return result;
        int month = fromShortMonthName(monthName);
        if (month < 0)
            break;
 
        date = QDate(year, month, day);
        if (dayOfWeek && date.dayOfWeek() != dayOfWeek)
            date = QDate();
    } while (false);
    words.remove(yearIndex);
    words.remove(0, 2); // month and day-of-month, in some order
 
    // Time: [hh:mm[:ss]]
    QTime time;
    if (words.size() && words.at(0).contains(colon)) {
        const QStringView when = words.front();
        words.erase(words.begin());
        if (when.size() < 5 || when[2] != colon
            || (when.size() == 8 ? when[5] != colon : when.size() > 5)) {
            return result;
        }
        const int hour = when.first(2).toInt(&ok);
        if (!ok)
            return result;
        const int minute = when.sliced(3, 2).toInt(&ok);
        if (!ok)
            return result;
        const auto secs = when.size() == 8 ? when.last(2).toInt(&ok) : 0;
        if (!ok)
            return result;
        time = QTime(hour, minute, secs);
    }
 
    // Offset: [±hh[mm]]
    int offset = 0;
    if (words.size()) {
        const QStringView zone = words.front();
        words.erase(words.begin());
        if (words.size() || !(zone.size() == 3 || zone.size() == 5))
            return result;
        bool negate = false;
        if (zone[0] == u'-')
            negate = true;
        else if (zone[0] != u'+')
            return result;
        const int hour = zone.sliced(1, 2).toInt(&ok);
        if (!ok)
            return result;
        const auto minute = zone.size() == 5 ? zone.last(2).toInt(&ok) : 0;
        if (!ok)
            return result;
        offset = (hour * 60 + minute) * 60;
        if (negate)
            offset = -offset;
    }
 
    result.date = date;
    result.time = time;
    result.utcOffset = offset;
    return result;
}
#endif // datestring
 
// Return offset in [+-]HH:mm format
static QString toOffsetString(Qt::DateFormat format, int offset)
{
    return QString::asprintf("%c%02d%s%02d",
                             offset >= 0 ? '+' : '-',
                             qAbs(offset) / int(SECS_PER_HOUR),
                             // Qt::ISODate puts : between the hours and minutes, but Qt:TextDate does not:
                             format == Qt::TextDate ? "" : ":",
                             (qAbs(offset) / 60) % 60);
}
 
#if QT_CONFIG(datestring)
// Parse offset in [+-]HH[[:]mm] format
static int fromOffsetString(QStringView offsetString, bool *valid) noexcept
{
    *valid = false;
 
    const int size = offsetString.size();
    if (size < 2 || size > 6)
        return 0;
 
    // sign will be +1 for a positive and -1 for a negative offset
    int sign;
 
    // First char must be + or -
    const QChar signChar = offsetString[0];
    if (signChar == u'+')
        sign = 1;
    else if (signChar == u'-')
        sign = -1;
    else
        return 0;
 
    // Split the hour and minute parts
    const QStringView time = offsetString.sliced(1);
    qsizetype hhLen = time.indexOf(u':');
    qsizetype mmIndex;
    if (hhLen == -1)
        mmIndex = hhLen = 2; // [+-]HHmm or [+-]HH format
    else
        mmIndex = hhLen + 1;
 
    const QStringView hhRef = time.first(qMin(hhLen, time.size()));
    bool ok = false;
    const int hour = hhRef.toInt(&ok);
    if (!ok || hour > 23) // More generous than QTimeZone::MaxUtcOffsetSecs
        return 0;
 
    const QStringView mmRef = time.sliced(qMin(mmIndex, time.size()));
    const int minute = mmRef.isEmpty() ? 0 : mmRef.toInt(&ok);
    if (!ok || minute < 0 || minute > 59)
        return 0;
 
    *valid = true;
    return sign * ((hour * 60) + minute) * 60;
}
#endif // datestring
 
/*****************************************************************************
  QDate member functions
 *****************************************************************************/
 
QDate::QDate(int y, int m, int d)
{
    static_assert(QDate::maxJd() == JulianDayMax);
    static_assert(QDate::minJd() == JulianDayMin);
    jd = QGregorianCalendar::julianFromParts(y, m, d).value_or(nullJd());
}
 
QDate::QDate(int y, int m, int d, QCalendar cal)
{
    *this = cal.dateFromParts(y, m, d);
}
 
int QDate::year(QCalendar cal) const
{
    if (isValid()) {
        const auto parts = cal.partsFromDate(*this);
        if (parts.isValid())
            return parts.year;
    }
    return 0;
}
 
int QDate::year() const
{
    if (isValid()) {
        const auto parts = QGregorianCalendar::partsFromJulian(jd);
        if (parts.isValid())
            return parts.year;
    }
    return 0;
}
 
int QDate::month(QCalendar cal) const
{
    if (isValid()) {
        const auto parts = cal.partsFromDate(*this);
        if (parts.isValid())
            return parts.month;
    }
    return 0;
}
 
int QDate::month() const
{
    if (isValid()) {
        const auto parts = QGregorianCalendar::partsFromJulian(jd);
        if (parts.isValid())
            return parts.month;
    }
    return 0;
}
 
int QDate::day(QCalendar cal) const
{
    if (isValid()) {
        const auto parts = cal.partsFromDate(*this);
        if (parts.isValid())
            return parts.day;
    }
    return 0;
}
 
int QDate::day() const
{
    if (isValid()) {
        const auto parts = QGregorianCalendar::partsFromJulian(jd);
        if (parts.isValid())
            return parts.day;
    }
    return 0;
}
 
int QDate::dayOfWeek(QCalendar cal) const
{
    if (isNull())
        return 0;
 
    return cal.dayOfWeek(*this);
}
 
int QDate::dayOfWeek() const
{
    return isValid() ? QGregorianCalendar::weekDayOfJulian(jd) : 0;
}
 
int QDate::dayOfYear(QCalendar cal) const
{
    if (isValid()) {
        QDate firstDay = cal.dateFromParts(year(cal), 1, 1);
        if (firstDay.isValid())
            return firstDay.daysTo(*this) + 1;
    }
    return 0;
}
 
int QDate::dayOfYear() const
{
    if (isValid()) {
        if (const auto first = QGregorianCalendar::julianFromParts(year(), 1, 1))
            return jd - *first + 1;
    }
    return 0;
}
 
int QDate::daysInMonth(QCalendar cal) const
{
    if (isValid()) {
        const auto parts = cal.partsFromDate(*this);
        if (parts.isValid())
            return cal.daysInMonth(parts.month, parts.year);
    }
    return 0;
}
 
int QDate::daysInMonth() const
{
    if (isValid()) {
        const auto parts = QGregorianCalendar::partsFromJulian(jd);
        if (parts.isValid())
            return QGregorianCalendar::monthLength(parts.month, parts.year);
    }
    return 0;
}
 
int QDate::daysInYear(QCalendar cal) const
{
    if (isNull())
        return 0;
 
    return cal.daysInYear(year(cal));
}
 
int QDate::daysInYear() const
{
    return isValid() ? QGregorianCalendar::leapTest(year()) ? 366 : 365 : 0;
}
 
int QDate::weekNumber(int *yearNumber) const
{
    if (!isValid())
        return 0;
 
    // This could be replaced by use of QIso8601Calendar, once we implement it.
    // The Thursday of the same week determines our answer:
    const QDate thursday(addDays(4 - dayOfWeek()));
    if (yearNumber)
        *yearNumber = thursday.year();
 
    // Week n's Thurs's DOY has 1 <= DOY - 7*(n-1) < 8, so 0 <= DOY + 6 - 7*n < 7:
    return (thursday.dayOfYear() + 6) / 7;
}
 
#if QT_DEPRECATED_SINCE(6, 9)
// Only called by deprecated methods (so bootstrap builds warn unused without this #if).
static QTimeZone asTimeZone(Qt::TimeSpec spec, int offset, const char *warner)
{
    if (warner) {
        switch (spec) {
        case Qt::TimeZone:
            qWarning("%s: Pass a QTimeZone instead of Qt::TimeZone.", warner);
            break;
        case Qt::LocalTime:
            if (offset) {
                qWarning("%s: Ignoring offset (%d seconds) passed with Qt::LocalTime",
                         warner, offset);
            }
            break;
        case Qt::UTC:
            if (offset) {
                qWarning("%s: Ignoring offset (%d seconds) passed with Qt::UTC",
                         warner, offset);
                offset = 0;
            }
            break;
        case Qt::OffsetFromUTC:
            break;
        }
    }
    return QTimeZone::isUtcOrFixedOffset(spec)
        ? QTimeZone::fromSecondsAheadOfUtc(offset)
        : QTimeZone(QTimeZone::LocalTime);
}
#endif // Helper for 6.9 deprecation
 
enum class DaySide { Start, End };
 
static bool inDateTimeRange(qint64 jd, DaySide side)
{
    using Bounds = std::numeric_limits<qint64>;
    if (jd < Bounds::min() + JULIAN_DAY_FOR_EPOCH)
        return false;
    jd -= JULIAN_DAY_FOR_EPOCH;
    const qint64 maxDay = Bounds::max() / MSECS_PER_DAY;
    const qint64 minDay = Bounds::min() / MSECS_PER_DAY - 1;
    // (Divisions rounded towards zero, as MSECS_PER_DAY is even - so doesn't
    // divide max() - and has factors other than two, so doesn't divide min().)
    // Range includes start of last day and end of first:
    switch (side) {
    case DaySide::Start:
        return jd > minDay && jd <= maxDay;
    case DaySide::End:
        return jd >= minDay && jd < maxDay;
    }
    Q_UNREACHABLE_RETURN(false);
}
 
static QDateTime toEarliest(QDate day, const QTimeZone &zone)
{
    Q_ASSERT(!zone.isUtcOrFixedOffset());
    const auto moment = [=](QTime time) { return QDateTime(day, time, zone); };
    // Longest routine time-zone transition is 2 hours:
    QDateTime when = moment(QTime(2, 0));
    if (!when.isValid()) {
        // Noon should be safe ...
        when = moment(QTime(12, 0));
        if (!when.isValid()) {
            // ... unless it's a 24-hour jump (moving the date-line)
            when = moment(QTime(23, 59, 59, 999));
            if (!when.isValid())
                return QDateTime();
        }
    }
    int high = when.time().msecsSinceStartOfDay() / 60000;
    int low = 0;
    // Binary chop to the right minute
    while (high > low + 1) {
        const int mid = (high + low) / 2;
        const QDateTime probe = moment(QTime(mid / 60, mid % 60));
        if (probe.isValid() && probe.date() == day) {
            high = mid;
            when = probe;
        } else {
            low = mid;
        }
    }
    // Transitions out of local solar mean time, and the few international
    // date-line crossings before that (Alaska, Philippines), may have happened
    // between minute boundaries. Don't try to fix milliseconds.
    if (QDateTime p = moment(when.time().addSecs(-1)); Q_UNLIKELY(p.isValid() && p.date() == day)) {
        high *= 60;
        low *= 60;
        while (high > low + 1) {
            const int mid = (high + low) / 2;
            const int min = mid / 60;
            const QDateTime probe = moment(QTime(min / 60, min % 60, mid % 60));
            if (probe.isValid() && probe.date() == day) {
                high = mid;
                when = probe;
            } else {
                low = mid;
            }
        }
    }
    return when.isValid() ? when : QDateTime();
}
 
QDateTime QDate::startOfDay(const QTimeZone &zone) const
{
    if (!inDateTimeRange(jd, DaySide::Start) || !zone.isValid())
        return QDateTime();
 
    QDateTime when(*this, QTime(0, 0), zone);
    if (Q_LIKELY(when.isValid()))
        return when;
 
#if QT_CONFIG(timezone)
    // The start of the day must have fallen in a spring-forward's gap; find the spring-forward:
    if (zone.timeSpec() == Qt::TimeZone && zone.hasTransitions()) {
        QTimeZone::OffsetData tran
            // There's unlikely to be another transition before noon tomorrow.
            // However, the whole of today may have been skipped !
            = zone.previousTransition(QDateTime(addDays(1), QTime(12, 0), zone));
        const QDateTime &at = tran.atUtc.toTimeZone(zone);
        if (at.isValid() && at.date() == *this)
            return at;
    }
#endif
 
    return toEarliest(*this, zone);
}
 
QDateTime QDate::startOfDay() const
{
    return startOfDay(QTimeZone::LocalTime);
}
 
#if QT_DEPRECATED_SINCE(6, 9)
QDateTime QDate::startOfDay(Qt::TimeSpec spec, int offsetSeconds) const
{
    QTimeZone zone = asTimeZone(spec, offsetSeconds, "QDate::startOfDay");
    // If spec was Qt::TimeZone, zone's is Qt::LocalTime.
    return zone.timeSpec() == spec ? startOfDay(zone) :  QDateTime();
}
#endif // 6.9 deprecation
 
static QDateTime toLatest(QDate day, const QTimeZone &zone)
{
    Q_ASSERT(!zone.isUtcOrFixedOffset());
    const auto moment = [=](QTime time) { return QDateTime(day, time, zone); };
    // Longest routine time-zone transition is 2 hours:
    QDateTime when = moment(QTime(21, 59, 59, 999));
    if (!when.isValid()) {
        // Noon should be safe ...
        when = moment(QTime(12, 0));
        if (!when.isValid()) {
            // ... unless it's a 24-hour jump (moving the date-line)
            when = moment(QTime(0, 0));
            if (!when.isValid())
                return QDateTime();
        }
    }
    int high = 24 * 60;
    int low = when.time().msecsSinceStartOfDay() / 60000;
    // Binary chop to the right minute
    while (high > low + 1) {
        const int mid = (high + low) / 2;
        const QDateTime probe = moment(QTime(mid / 60, mid % 60, 59, 999));
        if (probe.isValid() && probe.date() == day) {
            low = mid;
            when = probe;
        } else {
            high = mid;
        }
    }
    // Transitions out of local solar mean time, and the few international
    // date-line crossings before that (Alaska, Philippines), may have happened
    // between minute boundaries. Don't try to fix milliseconds.
    if (QDateTime p = moment(when.time().addSecs(1)); Q_UNLIKELY(p.isValid() && p.date() == day)) {
        high *= 60;
        low *= 60;
        while (high > low + 1) {
            const int mid = (high + low) / 2;
            const int min = mid / 60;
            const QDateTime probe = moment(QTime(min / 60, min % 60, mid % 60, 999));
            if (probe.isValid() && probe.date() == day) {
                low = mid;
                when = probe;
            } else {
                high = mid;
            }
        }
    }
    return when.isValid() ? when : QDateTime();
}
 
QDateTime QDate::endOfDay(const QTimeZone &zone) const
{
    if (!inDateTimeRange(jd, DaySide::End) || !zone.isValid())
        return QDateTime();
 
    QDateTime when(*this, QTime(23, 59, 59, 999), zone);
    if (Q_LIKELY(when.isValid()))
        return when;
 
#if QT_CONFIG(timezone)
    // The end of the day must have fallen in a spring-forward's gap; find the spring-forward:
    if (zone.timeSpec() == Qt::TimeZone && zone.hasTransitions()) {
        QTimeZone::OffsetData tran
            // It's unlikely there's been another transition since yesterday noon.
            // However, the whole of today may have been skipped !
            = zone.nextTransition(QDateTime(addDays(-1), QTime(12, 0), zone));
        const QDateTime &at = tran.atUtc.toTimeZone(zone);
        if (at.isValid() && at.date() == *this)
            return at;
    }
#endif
 
    return toLatest(*this, zone);
}
 
QDateTime QDate::endOfDay() const
{
    return endOfDay(QTimeZone::LocalTime);
}
 
#if QT_DEPRECATED_SINCE(6, 9)
QDateTime QDate::endOfDay(Qt::TimeSpec spec, int offsetSeconds) const
{
    QTimeZone zone = asTimeZone(spec, offsetSeconds, "QDate::endOfDay");
    // If spec was Qt::TimeZone, zone's is Qt::LocalTime.
    return endOfDay(zone);
}
#endif // 6.9 deprecation
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
 
static QString toStringTextDate(QDate date)
{
    if (date.isValid()) {
        QCalendar cal; // Always Gregorian
        const auto parts = cal.partsFromDate(date);
        if (parts.isValid()) {
            const QLatin1Char sp(' ');
            return QLocale::c().dayName(cal.dayOfWeek(date), QLocale::ShortFormat) + sp
                + cal.monthName(QLocale::c(), parts.month, parts.year, QLocale::ShortFormat)
                // Documented to use 4-digit year
                + sp + QString::asprintf("%d %04d", parts.day, parts.year);
        }
    }
    return QString();
}
 
static QString toStringIsoDate(QDate date)
{
    const auto parts = QCalendar().partsFromDate(date);
    if (parts.isValid() && parts.year >= 0 && parts.year <= 9999)
        return QString::asprintf("%04d-%02d-%02d", parts.year, parts.month, parts.day);
    return QString();
}
 
QString QDate::toString(Qt::DateFormat format) const
{
    if (!isValid())
        return QString();
 
    switch (format) {
    case Qt::RFC2822Date:
        return QLocale::c().toString(*this, u"dd MMM yyyy");
    default:
    case Qt::TextDate:
        return toStringTextDate(*this);
    case Qt::ISODate:
    case Qt::ISODateWithMs:
        // No calendar dependence
        return toStringIsoDate(*this);
    }
}
 
QString QDate::toString(QStringView format, QCalendar cal) const
{
    return QLocale::c().toString(*this, format, cal);
}
#endif // datestring
 
bool QDate::setDate(int year, int month, int day)
{
    const auto maybe = QGregorianCalendar::julianFromParts(year, month, day);
    jd = maybe.value_or(nullJd());
    return bool(maybe);
}
 
bool QDate::setDate(int year, int month, int day, QCalendar cal)
{
    *this = QDate(year, month, day, cal);
    return isValid();
}
 
void QDate::getDate(int *year, int *month, int *day) const
{
    QCalendar::YearMonthDay parts; // invalid by default
    if (isValid())
        parts = QGregorianCalendar::partsFromJulian(jd);
 
    const bool ok = parts.isValid();
    if (year)
        *year = ok ? parts.year : 0;
    if (month)
        *month = ok ? parts.month : 0;
    if (day)
        *day = ok ? parts.day : 0;
}
 
QDate QDate::addDays(qint64 ndays) const
{
    if (isNull())
        return QDate();
 
    if (qint64 r; Q_UNLIKELY(qAddOverflow(jd, ndays, &r)))
        return QDate();
    else
        return fromJulianDay(r);
}
 
QDate QDate::addMonths(int nmonths, QCalendar cal) const
{
    if (!isValid())
        return QDate();
 
    if (nmonths == 0)
        return *this;
 
    auto parts = cal.partsFromDate(*this);
 
    if (!parts.isValid())
        return QDate();
    Q_ASSERT(parts.year || cal.hasYearZero());
 
    parts.month += nmonths;
    while (parts.month <= 0) {
        if (--parts.year || cal.hasYearZero())
            parts.month += cal.monthsInYear(parts.year);
    }
    int count = cal.monthsInYear(parts.year);
    while (parts.month > count) {
        parts.month -= count;
        count = (++parts.year || cal.hasYearZero()) ? cal.monthsInYear(parts.year) : 0;
    }
 
    return fixedDate(parts, cal);
}
 
QDate QDate::addMonths(int nmonths) const
{
    if (isNull())
        return QDate();
 
    if (nmonths == 0)
        return *this;
 
    auto parts = QGregorianCalendar::partsFromJulian(jd);
 
    if (!parts.isValid())
        return QDate();
    Q_ASSERT(parts.year);
 
    parts.month += nmonths;
    while (parts.month <= 0) {
        if (--parts.year) // skip over year 0
            parts.month += 12;
    }
    while (parts.month > 12) {
        parts.month -= 12;
        if (!++parts.year) // skip over year 0
            ++parts.year;
    }
 
    return fixedDate(parts);
}
 
QDate QDate::addYears(int nyears, QCalendar cal) const
{
    if (!isValid())
        return QDate();
 
    auto parts = cal.partsFromDate(*this);
    if (!parts.isValid())
        return QDate();
 
    int old_y = parts.year;
    parts.year += nyears;
 
    // If we just crossed (or hit) a missing year zero, adjust year by +/- 1:
    if (!cal.hasYearZero() && ((old_y > 0) != (parts.year > 0) || !parts.year))
        parts.year += nyears > 0 ? +1 : -1;
 
    return fixedDate(parts, cal);
}
 
QDate QDate::addYears(int nyears) const
{
    if (isNull())
        return QDate();
 
    auto parts = QGregorianCalendar::partsFromJulian(jd);
    if (!parts.isValid())
        return QDate();
 
    int old_y = parts.year;
    parts.year += nyears;
 
    // If we just crossed (or hit) a missing year zero, adjust year by +/- 1:
    if ((old_y > 0) != (parts.year > 0) || !parts.year)
        parts.year += nyears > 0 ? +1 : -1;
 
    return fixedDate(parts);
}
 
qint64 QDate::daysTo(QDate d) const
{
    if (isNull() || d.isNull())
        return 0;
 
    // Due to limits on minJd() and maxJd() we know this will never overflow
    return d.jd - jd;
}
 
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
 
QDate QDate::fromString(QStringView string, Qt::DateFormat format)
{
    if (string.isEmpty())
        return QDate();
 
    switch (format) {
    case Qt::RFC2822Date:
        return rfcDateImpl(string).date;
    default:
    case Qt::TextDate: {
        // Documented as "ddd MMM d yyyy"
        QVarLengthArray<QStringView, 4> parts;
        auto tokens = string.tokenize(u' ', Qt::SkipEmptyParts);
        auto it = tokens.begin();
        for (int i = 0; i < 4 && it != tokens.end(); ++i, ++it)
            parts.emplace_back(*it);
 
        if (parts.size() != 4 || it != tokens.end())
            return QDate();
 
        bool ok = false;
        int year = parts.at(3).toInt(&ok);
        int day = ok ? parts.at(2).toInt(&ok) : 0;
        if (!ok || !day)
            return QDate();
 
        const int month = fromShortMonthName(parts.at(1));
        if (month == -1) // Month name matches no English or localised name.
            return QDate();
 
        return QDate(year, month, day);
        }
    case Qt::ISODate:
        // Semi-strict parsing, must be long enough and have punctuators as separators
        if (string.size() >= 10 && string[4].isPunct() && string[7].isPunct()
                && (string.size() == 10 || !string[10].isDigit())) {
            const ParsedInt year = readInt(string.first(4));
            const ParsedInt month = readInt(string.sliced(5, 2));
            const ParsedInt day = readInt(string.sliced(8, 2));
            if (year.ok() && year.result > 0 && year.result <= 9999 && month.ok() && day.ok())
                return QDate(year.result, month.result, day.result);
        }
        break;
    }
    return QDate();
}
 
QDate QDate::fromString(const QString &string, QStringView format, QCalendar cal)
{
    QDate date;
#if QT_CONFIG(datetimeparser)
    QDateTimeParser dt(QMetaType::QDate, QDateTimeParser::FromString, cal);
    dt.setDefaultLocale(QLocale::c());
    if (dt.parseFormat(format))
        dt.fromString(string, &date, nullptr);
#else
    Q_UNUSED(string);
    Q_UNUSED(format);
    Q_UNUSED(cal);
#endif
    return date;
}
#endif // datestring
 
bool QDate::isValid(int year, int month, int day)
{
    return QGregorianCalendar::validParts(year, month, day);
}
 
bool QDate::isLeapYear(int y)
{
    return QGregorianCalendar::leapTest(y);
}
 
/*****************************************************************************
  QTime member functions
 *****************************************************************************/
 
QTime::QTime(int h, int m, int s, int ms)
{
    setHMS(h, m, s, ms);
}
 
 
bool QTime::isValid() const
{
    return mds > NullTime && mds < MSECS_PER_DAY;
}
 
 
int QTime::hour() const
{
    if (!isValid())
        return -1;
 
    return ds() / MSECS_PER_HOUR;
}
 
int QTime::minute() const
{
    if (!isValid())
        return -1;
 
    return (ds() % MSECS_PER_HOUR) / MSECS_PER_MIN;
}
 
int QTime::second() const
{
    if (!isValid())
        return -1;
 
    return (ds() / MSECS_PER_SEC) % SECS_PER_MIN;
}
 
int QTime::msec() const
{
    if (!isValid())
        return -1;
 
    return ds() % MSECS_PER_SEC;
}
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
QString QTime::toString(Qt::DateFormat format) const
{
    if (!isValid())
        return QString();
 
    switch (format) {
    case Qt::ISODateWithMs:
        return QString::asprintf("%02d:%02d:%02d.%03d", hour(), minute(), second(), msec());
    case Qt::RFC2822Date:
    case Qt::ISODate:
    case Qt::TextDate:
    default:
        return QString::asprintf("%02d:%02d:%02d", hour(), minute(), second());
    }
}
 
// ### Qt 7 The 't' format specifiers should be specific to QDateTime (compare fromString).
QString QTime::toString(QStringView format) const
{
    return QLocale::c().toString(*this, format);
}
#endif // datestring
 
bool QTime::setHMS(int h, int m, int s, int ms)
{
    if (!isValid(h,m,s,ms)) {
        mds = NullTime;                // make this invalid
        return false;
    }
    mds = ((h * MINS_PER_HOUR + m) * SECS_PER_MIN + s) * MSECS_PER_SEC + ms;
    Q_ASSERT(mds >= 0 && mds < MSECS_PER_DAY);
    return true;
}
 
QTime QTime::addSecs(int s) const
{
    s %= SECS_PER_DAY;
    return addMSecs(s * MSECS_PER_SEC);
}
 
int QTime::secsTo(QTime t) const
{
    if (!isValid() || !t.isValid())
        return 0;
 
    // Truncate milliseconds as we do not want to consider them.
    int ourSeconds = ds() / MSECS_PER_SEC;
    int theirSeconds = t.ds() / MSECS_PER_SEC;
    return theirSeconds - ourSeconds;
}
 
QTime QTime::addMSecs(int ms) const
{
    QTime t;
    if (isValid())
        t.mds = QRoundingDown::qMod<MSECS_PER_DAY>(ds() + ms);
    return t;
}
 
int QTime::msecsTo(QTime t) const
{
    if (!isValid() || !t.isValid())
        return 0;
    return t.ds() - ds();
}
 
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
 
static QTime fromIsoTimeString(QStringView string, Qt::DateFormat format, bool *isMidnight24)
{
    Q_ASSERT(format == Qt::TextDate || format == Qt::ISODate || format == Qt::ISODateWithMs);
    if (isMidnight24)
        *isMidnight24 = false;
    // Match /\d\d(:\d\d(:\d\d)?)?([,.]\d+)?/ as "HH[:mm[:ss]][.zzz]"
    // The fractional part, if present, is in the same units as the field it follows.
    // TextDate restricts fractional parts to the seconds field.
 
    QStringView tail;
    const int dot = string.indexOf(u'.'), comma = string.indexOf(u',');
    if (dot != -1) {
        tail = string.sliced(dot + 1);
        if (tail.indexOf(u'.') != -1) // Forbid second dot:
            return QTime();
        string = string.first(dot);
    } else if (comma != -1) {
        tail = string.sliced(comma + 1);
        string = string.first(comma);
    }
    if (tail.indexOf(u',') != -1) // Forbid comma after first dot-or-comma:
        return QTime();
 
    const ParsedInt frac = readInt(tail);
    // There must be *some* digits in a fractional part; and it must be all digits:
    if (tail.isEmpty() ? dot != -1 || comma != -1 : !frac.ok())
        return QTime();
    Q_ASSERT(frac.ok() ^ tail.isEmpty());
    double fraction = frac.ok() ? frac.result * std::pow(0.1, tail.size()) : 0.0;
 
    const int size = string.size();
    if (size < 2 || size > 8)
        return QTime();
 
    ParsedInt hour = readInt(string.first(2));
    if (!hour.ok() || hour.result > (format == Qt::TextDate ? 23 : 24))
        return QTime();
 
    ParsedInt minute{};
    if (string.size() > 2) {
        if (string[2] == u':' && string.size() > 4)
            minute = readInt(string.sliced(3, 2));
        if (!minute.ok() || minute.result >= MINS_PER_HOUR)
            return QTime();
    } else if (format == Qt::TextDate) { // Requires minutes
        return QTime();
    } else if (frac.ok()) {
        Q_ASSERT(!(fraction < 0.0) && fraction < 1.0);
        fraction *= MINS_PER_HOUR;
        minute.result = qulonglong(fraction);
        fraction -= minute.result;
    }
 
    ParsedInt second{};
    if (string.size() > 5) {
        if (string[5] == u':' && string.size() == 8)
            second = readInt(string.sliced(6, 2));
        if (!second.ok() || second.result >= SECS_PER_MIN)
            return QTime();
    } else if (frac.ok()) {
        if (format == Qt::TextDate) // Doesn't allow fraction of minutes
            return QTime();
        Q_ASSERT(!(fraction < 0.0) && fraction < 1.0);
        fraction *= SECS_PER_MIN;
        second.result = qulonglong(fraction);
        fraction -= second.result;
    }
 
    Q_ASSERT(!(fraction < 0.0) && fraction < 1.0);
    // Round millis to nearest (unlike minutes and seconds, rounded down):
    int msec = frac.ok() ? qRound(MSECS_PER_SEC * fraction) : 0;
    // But handle overflow gracefully:
    if (msec == MSECS_PER_SEC) {
        // If we can (when data were otherwise valid) validly propagate overflow
        // into other fields, do so:
        if (isMidnight24 || hour.result < 23 || minute.result < 59 || second.result < 59) {
            msec = 0;
            if (++second.result == SECS_PER_MIN) {
                second.result = 0;
                if (++minute.result == MINS_PER_HOUR) {
                    minute.result = 0;
                    ++hour.result;
                    // May need to propagate further via isMidnight24, see below
                }
            }
        } else {
            // QTime::fromString() or Qt::TextDate: rounding up would cause
            // 23:59:59.999... to become invalid; clip to 999 ms instead:
            msec = MSECS_PER_SEC - 1;
        }
    }
 
    // For ISO date format, 24:0:0 means 0:0:0 on the next day:
    if (hour.result == 24 && minute.result == 0 && second.result == 0 && msec == 0) {
        Q_ASSERT(format != Qt::TextDate); // It clipped hour at 23, above.
        if (isMidnight24)
            *isMidnight24 = true;
        hour.result = 0;
    }
 
    return QTime(hour.result, minute.result, second.result, msec);
}
 
QTime QTime::fromString(QStringView string, Qt::DateFormat format)
{
    if (string.isEmpty())
        return QTime();
 
    switch (format) {
    case Qt::RFC2822Date:
        return rfcDateImpl(string).time;
    case Qt::ISODate:
    case Qt::ISODateWithMs:
    case Qt::TextDate:
    default:
        return fromIsoTimeString(string, format, nullptr);
    }
}
 
QTime QTime::fromString(const QString &string, QStringView format)
{
    QTime time;
#if QT_CONFIG(datetimeparser)
    QDateTimeParser dt(QMetaType::QTime, QDateTimeParser::FromString, QCalendar());
    dt.setDefaultLocale(QLocale::c());
    if (dt.parseFormat(format))
        dt.fromString(string, nullptr, &time);
#else
    Q_UNUSED(string);
    Q_UNUSED(format);
#endif
    return time;
}
#endif // datestring
 
 
bool QTime::isValid(int h, int m, int s, int ms)
{
    return (uint(h) < 24 && uint(m) < MINS_PER_HOUR && uint(s) < SECS_PER_MIN
            && uint(ms) < MSECS_PER_SEC);
}
 
/*****************************************************************************
  QDateTime static helper functions
 *****************************************************************************/
 
// get the types from QDateTime (through QDateTimePrivate)
typedef QDateTimePrivate::QDateTimeShortData ShortData;
typedef QDateTimePrivate::QDateTimeData QDateTimeData;
 
// Converts milliseconds since the start of 1970 into a date and/or time:
static qint64 msecsToJulianDay(qint64 msecs)
{
    return JULIAN_DAY_FOR_EPOCH + QRoundingDown::qDiv<MSECS_PER_DAY>(msecs);
}
 
static QDate msecsToDate(qint64 msecs)
{
    return QDate::fromJulianDay(msecsToJulianDay(msecs));
}
 
static QTime msecsToTime(qint64 msecs)
{
    return QTime::fromMSecsSinceStartOfDay(QRoundingDown::qMod<MSECS_PER_DAY>(msecs));
}
 
// True if combining days with millis overflows; otherwise, stores result in *sumMillis
// The inputs should not have opposite signs.
static inline bool daysAndMillisOverflow(qint64 days, qint64 millisInDay, qint64 *sumMillis)
{
    return qMulOverflow(days, std::integral_constant<qint64, MSECS_PER_DAY>(), sumMillis)
        || qAddOverflow(*sumMillis, millisInDay, sumMillis);
}
 
// Converts a date/time value into msecs
static qint64 timeToMSecs(QDate date, QTime time)
{
    qint64 days = date.toJulianDay() - JULIAN_DAY_FOR_EPOCH;
    qint64 msecs, dayms = time.msecsSinceStartOfDay();
    if (days < 0 && dayms > 0) {
        ++days;
        dayms -= MSECS_PER_DAY;
    }
    if (daysAndMillisOverflow(days, dayms, &msecs)) {
        using Bound = std::numeric_limits<qint64>;
        return days < 0 ? Bound::min() : Bound::max();
    }
    return msecs;
}
 
static inline bool millisInSystemRange(qint64 millis, qint64 slack = 0)
{
    static const auto bounds = QLocalTime::computeSystemMillisRange();
    return (bounds.minClip || millis >= bounds.min - slack)
        && (bounds.maxClip || millis <= bounds.max + slack);
}
 
static int systemTimeYearMatching(int year)
{
#if defined(Q_OS_WIN) || defined(Q_OS_WASM)// They don't support times before the epoch
    static constexpr int forLeapEarly[] = { 1984, 1996, 1980, 1992, 1976, 1988, 1972 };
    static constexpr int regularEarly[] = { 1978, 1973, 1974, 1975, 1970, 1971, 1977 };
#else // First year fully in 32-bit time_t range is 1902
    static constexpr int forLeapEarly[] = { 1928, 1912, 1924, 1908, 1920, 1904, 1916 };
    static constexpr int regularEarly[] = { 1905, 1906, 1907, 1902, 1903, 1909, 1910 };
#endif
    static constexpr int forLeapLate[] = { 2012, 2024, 2036, 2020, 2032, 2016, 2028 };
    static constexpr int regularLate[] = { 2034, 2035, 2030, 2031, 2037, 2027, 2033 };
    const int dow = QGregorianCalendar::yearStartWeekDay(year);
    Q_ASSERT(dow == QDate(year, 1, 1).dayOfWeek());
    const int res = (QGregorianCalendar::leapTest(year)
                     ? (year < 1970 ? forLeapEarly : forLeapLate)
                     : (year < 1970 ? regularEarly : regularLate))[dow == 7 ? 0 : dow];
    Q_ASSERT(QDate(res, 1, 1).dayOfWeek() == dow);
    Q_ASSERT(QDate(res, 12, 31).dayOfWeek() == QDate(year, 12, 31).dayOfWeek());
    return res;
}
 
// Sets up d and status to represent local time at the given UTC msecs since epoch:
QDateTimePrivate::ZoneState QDateTimePrivate::expressUtcAsLocal(qint64 utcMSecs)
{
    ZoneState result{utcMSecs};
    // Within the time_t supported range, localtime() can handle it:
    if (millisInSystemRange(utcMSecs)) {
        result = QLocalTime::utcToLocal(utcMSecs);
        if (result.valid)
            return result;
    }
 
    // Docs state any LocalTime after 2038-01-18 *will* have any DST applied.
    // When this falls outside the supported range, we need to fake it.
#if QT_CONFIG(timezone) // Use the system time-zone.
    if (const auto sys = QTimeZone::systemTimeZone(); sys.isValid()) {
        result.offset = sys.d->offsetFromUtc(utcMSecs);
        if (qAddOverflow(utcMSecs, result.offset * MSECS_PER_SEC, &result.when))
            return result;
        result.dst = sys.d->isDaylightTime(utcMSecs) ? DaylightTime : StandardTime;
        result.valid = true;
        return result;
    }
#endif // timezone
 
    // Kludge
    // Do the conversion in a year with the same days of the week, so DST
    // dates might be right, and adjust by the number of days that was off:
    const qint64 jd = msecsToJulianDay(utcMSecs);
    const auto ymd = QGregorianCalendar::partsFromJulian(jd);
    qint64 diffMillis, fakeUtc;
    const auto fakeJd = QGregorianCalendar::julianFromParts(systemTimeYearMatching(ymd.year),
                                                            ymd.month, ymd.day);
    if (Q_UNLIKELY(!fakeJd
                   || qMulOverflow(jd - *fakeJd, std::integral_constant<qint64, MSECS_PER_DAY>(),
                                   &diffMillis)
                   || qSubOverflow(utcMSecs, diffMillis, &fakeUtc))) {
        return result;
    }
 
    result = QLocalTime::utcToLocal(fakeUtc);
    // Now correct result.when for the use of the fake date:
    if (!result.valid || qAddOverflow(result.when, diffMillis, &result.when)) {
        // If utcToLocal() failed, its return has the fake when; restore utcMSecs.
        // Fail on overflow, but preserve offset and DST-ness.
        result.when = utcMSecs;
        result.valid = false;
    }
    return result;
}
 
static auto millisToWithinRange(qint64 millis)
{
    struct R {
        qint64 shifted = 0;
        bool good = false;
    } result;
    qint64 jd = msecsToJulianDay(millis);
    auto ymd = QGregorianCalendar::partsFromJulian(jd);
    const auto fakeJd = QGregorianCalendar::julianFromParts(systemTimeYearMatching(ymd.year),
                                                            ymd.month, ymd.day);
    result.good = fakeJd && !daysAndMillisOverflow(*fakeJd - jd, millis, &result.shifted);
    return result;
}
 
QString QDateTimePrivate::localNameAtMillis(qint64 millis, DaylightStatus dst)
{
    QString abbreviation;
    if (millisInSystemRange(millis, MSECS_PER_DAY)) {
        abbreviation = QLocalTime::localTimeAbbbreviationAt(millis, dst);
        if (!abbreviation.isEmpty())
            return abbreviation;
    }
 
    // Otherwise, outside the system range.
#if QT_CONFIG(timezone)
    // Use the system zone:
    const auto sys = QTimeZone::systemTimeZone();
    if (sys.isValid()) {
        ZoneState state = zoneStateAtMillis(sys, millis, dst);
        if (state.valid)
            return sys.d->abbreviation(state.when - state.offset * MSECS_PER_SEC);
    }
#endif // timezone
 
    // Kludge
    // Use a time in the system range with the same day-of-week pattern to its year:
    auto fake = millisToWithinRange(millis);
    if (Q_LIKELY(fake.good))
        return QLocalTime::localTimeAbbbreviationAt(fake.shifted, dst);
 
    // Overflow, apparently.
    return {};
}
 
// Determine the offset from UTC at the given local time as millis.
QDateTimePrivate::ZoneState QDateTimePrivate::localStateAtMillis(qint64 millis, DaylightStatus dst)
{
    // First, if millis is within a day of the viable range, try mktime() in
    // case it does fall in the range and gets useful information:
    if (millisInSystemRange(millis, MSECS_PER_DAY)) {
        auto result = QLocalTime::mapLocalTime(millis, dst);
        if (result.valid)
            return result;
    }
 
    // Otherwise, outside the system range.
#if QT_CONFIG(timezone)
    // Use the system zone:
    const auto sys = QTimeZone::systemTimeZone();
    if (sys.isValid())
        return zoneStateAtMillis(sys, millis, dst);
#endif // timezone
 
    // Kludge
    // Use a time in the system range with the same day-of-week pattern to its year:
    auto fake = millisToWithinRange(millis);
    if (Q_LIKELY(fake.good)) {
        auto result = QLocalTime::mapLocalTime(fake.shifted, dst);
        if (result.valid) {
            qint64 adjusted;
            if (Q_UNLIKELY(qAddOverflow(result.when, millis - fake.shifted, &adjusted))) {
                using Bound = std::numeric_limits<qint64>;
                adjusted = millis < fake.shifted ? Bound::min() : Bound::max();
            }
            result.when = adjusted;
        } else {
            result.when = millis;
        }
        return result;
    }
    // Overflow, apparently.
    return {millis};
}
 
#if QT_CONFIG(timezone)
// For a TimeZone and a time expressed in zone msecs encoding, possibly with a
// hint to DST-ness, compute the actual DST-ness and offset, adjusting the time
// if needed to escape a spring-forward.
QDateTimePrivate::ZoneState QDateTimePrivate::zoneStateAtMillis(const QTimeZone &zone,
                                                                qint64 millis, DaylightStatus dst)
{
    Q_ASSERT(zone.isValid());
    Q_ASSERT(zone.timeSpec() == Qt::TimeZone);
    // Get the effective data from QTimeZone
    QTimeZonePrivate::Data data = zone.d->dataForLocalTime(millis, int(dst));
    if (data.offsetFromUtc == QTimeZonePrivate::invalidSeconds())
        return {millis};
    Q_ASSERT(zone.d->offsetFromUtc(data.atMSecsSinceEpoch) == data.offsetFromUtc);
    ZoneState state(data.atMSecsSinceEpoch + data.offsetFromUtc * MSECS_PER_SEC,
                    data.offsetFromUtc,
                    data.daylightTimeOffset ? DaylightTime : StandardTime);
    // Revise offset, when stepping out of a spring-forward, to what makes a
    // fromMSecsSinceEpoch(toMSecsSinceEpoch()) of the resulting QDT work:
    if (millis != state.when)
        state.offset += (millis - state.when) / MSECS_PER_SEC;
    return state;
}
#endif // timezone
 
static inline QDateTimePrivate::ZoneState stateAtMillis(QTimeZone zone, qint64 millis,
                                                        QDateTimePrivate::DaylightStatus dst)
{
    if (zone.timeSpec() == Qt::LocalTime)
        return QDateTimePrivate::localStateAtMillis(millis, dst);
#if QT_CONFIG(timezone)
    if (zone.timeSpec() == Qt::TimeZone && zone.isValid())
        return QDateTimePrivate::zoneStateAtMillis(zone, millis, dst);
#endif
    return {millis};
}
 
static inline bool specCanBeSmall(Qt::TimeSpec spec)
{
    return spec == Qt::LocalTime || spec == Qt::UTC;
}
 
static inline bool msecsCanBeSmall(qint64 msecs)
{
    if constexpr (!QDateTimeData::CanBeSmall)
        return false;
 
    ShortData sd;
    sd.msecs = qintptr(msecs);
    return sd.msecs == msecs;
}
 
static constexpr inline
QDateTimePrivate::StatusFlags mergeSpec(QDateTimePrivate::StatusFlags status, Qt::TimeSpec spec)
{
    status &= ~QDateTimePrivate::TimeSpecMask;
    status |= QDateTimePrivate::StatusFlags::fromInt(int(spec) << QDateTimePrivate::TimeSpecShift);
    return status;
}
 
static constexpr inline Qt::TimeSpec extractSpec(QDateTimePrivate::StatusFlags status)
{
    return Qt::TimeSpec((status & QDateTimePrivate::TimeSpecMask).toInt() >> QDateTimePrivate::TimeSpecShift);
}
 
// Set the Daylight Status if LocalTime set via msecs
static constexpr inline QDateTimePrivate::StatusFlags
mergeDaylightStatus(QDateTimePrivate::StatusFlags sf, QDateTimePrivate::DaylightStatus status)
{
    sf &= ~QDateTimePrivate::DaylightMask;
    if (status == QDateTimePrivate::DaylightTime) {
        sf |= QDateTimePrivate::SetToDaylightTime;
    } else if (status == QDateTimePrivate::StandardTime) {
        sf |= QDateTimePrivate::SetToStandardTime;
    }
    return sf;
}
 
// Get the DST Status if LocalTime set via msecs
static constexpr inline
QDateTimePrivate::DaylightStatus extractDaylightStatus(QDateTimePrivate::StatusFlags status)
{
    if (status.testFlag(QDateTimePrivate::SetToDaylightTime))
        return QDateTimePrivate::DaylightTime;
    if (status.testFlag(QDateTimePrivate::SetToStandardTime))
        return QDateTimePrivate::StandardTime;
    return QDateTimePrivate::UnknownDaylightTime;
}
 
static inline qint64 getMSecs(const QDateTimeData &d)
{
    if (d.isShort()) {
        // same as, but producing better code
        //return d.data.msecs;
        return qintptr(d.d) >> 8;
    }
    return d->m_msecs;
}
 
static inline QDateTimePrivate::StatusFlags getStatus(const QDateTimeData &d)
{
    if (d.isShort()) {
        // same as, but producing better code
        //return StatusFlag(d.data.status);
        return QDateTimePrivate::StatusFlag(qintptr(d.d) & 0xFF);
    }
    return d->m_status;
}
 
static inline Qt::TimeSpec getSpec(const QDateTimeData &d)
{
    return extractSpec(getStatus(d));
}
 
/* True if we *can cheaply determine* that a and b use the same offset.
   If they use different offsets or it would be expensive to find out, false.
   Calls to toMSecsSinceEpoch() are expensive, for these purposes.
   See QDateTime's comparison operators.
*/
static inline bool usesSameOffset(const QDateTimeData &a, const QDateTimeData &b)
{
    const auto status = getStatus(a);
    if (status != getStatus(b))
        return false;
    // Status includes DST-ness, so we now know they match in it.
 
    switch (extractSpec(status)) {
    case Qt::LocalTime:
    case Qt::UTC:
        return true;
 
    case Qt::TimeZone:
        /* TimeZone always determines its offset during construction of the
           private data. Even if we're in different zones, what matters is the
           offset actually in effect at the specific time. (DST can cause things
           with the same time-zone to use different offsets, but we already
           checked their DSTs match.) */
    case Qt::OffsetFromUTC: // always knows its offset, which is all that matters.
        Q_ASSERT(!a.isShort() && !b.isShort());
        return a->m_offsetFromUtc == b->m_offsetFromUtc;
    }
    Q_UNREACHABLE_RETURN(false);
}
 
// Refresh the LocalTime or TimeZone validity and offset
static void refreshZonedDateTime(QDateTimeData &d, const QTimeZone &zone)
{
    Q_ASSERT(zone.timeSpec() == Qt::TimeZone || zone.timeSpec() == Qt::LocalTime);
    auto status = getStatus(d);
    Q_ASSERT(extractSpec(status) == zone.timeSpec());
    int offsetFromUtc = 0;
 
    // If not valid date and time then is invalid
    if (!status.testFlags(QDateTimePrivate::ValidDate | QDateTimePrivate::ValidTime)) {
        status.setFlag(QDateTimePrivate::ValidDateTime, false);
    } else {
        // We have a valid date and time and a Qt::LocalTime or Qt::TimeZone that needs calculating
        // LocalTime and TimeZone might fall into a "missing" DST transition hour
        // Calling toEpochMSecs will adjust the returned date/time if it does
        qint64 msecs = getMSecs(d);
        QDateTimePrivate::ZoneState state = stateAtMillis(zone, msecs,
                                                          extractDaylightStatus(status));
        // Save the offset to use in offsetFromUtc() &c., even if the next check
        // marks invalid; this lets fromMSecsSinceEpoch() give a useful fallback
        // for times in spring-forward gaps.
        offsetFromUtc = state.offset;
        Q_ASSERT(!state.valid || (state.offset >= -SECS_PER_DAY && state.offset <= SECS_PER_DAY));
        if (state.valid && msecs == state.when)
            status = mergeDaylightStatus(status | QDateTimePrivate::ValidDateTime, state.dst);
        else // msecs changed or failed to convert (e.g. overflow)
            status.setFlag(QDateTimePrivate::ValidDateTime, false);
    }
 
    if (status.testFlag(QDateTimePrivate::ShortData)) {
        d.data.status = status.toInt();
    } else {
        d->m_status = status;
        d->m_offsetFromUtc = offsetFromUtc;
    }
}
 
// Check the UTC / offsetFromUTC validity
static void refreshSimpleDateTime(QDateTimeData &d)
{
    auto status = getStatus(d);
    Q_ASSERT(QTimeZone::isUtcOrFixedOffset(extractSpec(status)));
    status.setFlag(QDateTimePrivate::ValidDateTime,
                   status.testFlags(QDateTimePrivate::ValidDate | QDateTimePrivate::ValidTime));
 
    if (status.testFlag(QDateTimePrivate::ShortData))
        d.data.status = status.toInt();
    else
        d->m_status = status;
}
 
// Clean up and set status after assorted set-up or reworking:
static void checkValidDateTime(QDateTimeData &d)
{
    auto spec = extractSpec(getStatus(d));
    switch (spec) {
    case Qt::OffsetFromUTC:
    case Qt::UTC:
        // for these, a valid date and a valid time imply a valid QDateTime
        refreshSimpleDateTime(d);
        break;
    case Qt::TimeZone:
    case Qt::LocalTime:
        // For these, we need to check whether (the zone is valid and) the time
        // is valid for the zone. Expensive, but we have no other option.
        refreshZonedDateTime(d, d.timeZone());
        break;
    }
}
 
static void reviseTimeZone(QDateTimeData &d, QTimeZone zone)
{
    Qt::TimeSpec spec = zone.timeSpec();
    auto status = mergeSpec(getStatus(d), spec);
    bool reuse = d.isShort();
    int offset = 0;
 
    switch (spec) {
    case Qt::UTC:
        Q_ASSERT(zone.fixedSecondsAheadOfUtc() == 0);
        break;
    case Qt::OffsetFromUTC:
        reuse = false;
        offset = zone.fixedSecondsAheadOfUtc();
        Q_ASSERT(offset);
        break;
    case Qt::TimeZone:
        reuse = false;
        break;
    case Qt::LocalTime:
        break;
    }
 
    status &= ~(QDateTimePrivate::ValidDateTime | QDateTimePrivate::DaylightMask);
    if (reuse) {
        d.data.status = status.toInt();
    } else {
        d.detach();
        d->m_status = status & ~QDateTimePrivate::ShortData;
        d->m_offsetFromUtc = offset;
#if QT_CONFIG(timezone)
        if (spec == Qt::TimeZone)
            d->m_timeZone = zone;
#endif // timezone
    }
 
    if (QTimeZone::isUtcOrFixedOffset(spec))
        refreshSimpleDateTime(d);
    else
        refreshZonedDateTime(d, zone);
}
 
static void setDateTime(QDateTimeData &d, QDate date, QTime time)
{
    // If the date is valid and the time is not we set time to 00:00:00
    if (!time.isValid() && date.isValid())
        time = QTime::fromMSecsSinceStartOfDay(0);
 
    QDateTimePrivate::StatusFlags newStatus = { };
 
    // Set date value and status
    qint64 days = 0;
    if (date.isValid()) {
        days = date.toJulianDay() - JULIAN_DAY_FOR_EPOCH;
        newStatus = QDateTimePrivate::ValidDate;
    }
 
    // Set time value and status
    int ds = 0;
    if (time.isValid()) {
        ds = time.msecsSinceStartOfDay();
        newStatus |= QDateTimePrivate::ValidTime;
    }
    Q_ASSERT(ds < MSECS_PER_DAY);
    // Only the later parts of the very first day are representable - its start
    // would overflow - so get ds the same side of 0 as days:
    if (days < 0 && ds > 0) {
        days++;
        ds -= MSECS_PER_DAY;
    }
 
    // Check in representable range:
    qint64 msecs = 0;
    if (daysAndMillisOverflow(days, qint64(ds), &msecs)) {
        newStatus = QDateTimePrivate::StatusFlags{};
        msecs = 0;
    }
    if (d.isShort()) {
        // let's see if we can keep this short
        if (msecsCanBeSmall(msecs)) {
            // yes, we can
            d.data.msecs = qintptr(msecs);
            d.data.status &= ~(QDateTimePrivate::ValidityMask | QDateTimePrivate::DaylightMask).toInt();
            d.data.status |= newStatus.toInt();
        } else {
            // nope...
            d.detach();
        }
    }
    if (!d.isShort()) {
        d.detach();
        d->m_msecs = msecs;
        d->m_status &= ~(QDateTimePrivate::ValidityMask | QDateTimePrivate::DaylightMask);
        d->m_status |= newStatus;
    }
}
 
static QPair<QDate, QTime> getDateTime(const QDateTimeData &d)
{
    auto status = getStatus(d);
    const qint64 msecs = getMSecs(d);
    const auto dayMilli = QRoundingDown::qDivMod<MSECS_PER_DAY>(msecs);
    return { status.testFlag(QDateTimePrivate::ValidDate)
            ? QDate::fromJulianDay(JULIAN_DAY_FOR_EPOCH + dayMilli.quotient)
            : QDate(),
            status.testFlag(QDateTimePrivate::ValidTime)
            ? QTime::fromMSecsSinceStartOfDay(dayMilli.remainder)
            : QTime() };
}
 
/*****************************************************************************
  QDateTime::Data member functions
 *****************************************************************************/
 
inline QDateTime::Data::Data() noexcept
{
    // default-constructed data has a special exception:
    // it can be small even if CanBeSmall == false
    // (optimization so we don't allocate memory in the default constructor)
    quintptr value = mergeSpec(QDateTimePrivate::ShortData, Qt::LocalTime).toInt();
    d = reinterpret_cast<QDateTimePrivate *>(value);
}
 
inline QDateTime::Data::Data(const QTimeZone &zone)
{
    Qt::TimeSpec spec = zone.timeSpec();
    if (CanBeSmall && Q_LIKELY(specCanBeSmall(spec))) {
        quintptr value = mergeSpec(QDateTimePrivate::ShortData, spec).toInt();
        d = reinterpret_cast<QDateTimePrivate *>(value);
        Q_ASSERT(isShort());
    } else {
        // the structure is too small, we need to detach
        d = new QDateTimePrivate;
        d->ref.ref();
        d->m_status = mergeSpec({}, spec);
        if (spec == Qt::OffsetFromUTC)
            d->m_offsetFromUtc = zone.fixedSecondsAheadOfUtc();
        else if (spec == Qt::TimeZone)
            d->m_timeZone = zone;
        Q_ASSERT(!isShort());
    }
}
 
inline QDateTime::Data::Data(const Data &other) noexcept
    : data(other.data)
{
    if (!isShort()) {
        // check if we could shrink
        if (specCanBeSmall(extractSpec(d->m_status)) && msecsCanBeSmall(d->m_msecs)) {
            ShortData sd;
            sd.msecs = qintptr(d->m_msecs);
            sd.status = (d->m_status | QDateTimePrivate::ShortData).toInt();
            data = sd;
        } else {
            // no, have to keep it big
            d->ref.ref();
        }
    }
}
 
inline QDateTime::Data::Data(Data &&other) noexcept
    : data(other.data)
{
    // reset the other to a short state
    Data dummy;
    Q_ASSERT(dummy.isShort());
    other.data = dummy.data;
}
 
inline QDateTime::Data &QDateTime::Data::operator=(const Data &other) noexcept
{
    if (isShort() ? data == other.data : d == other.d)
        return *this;
 
    auto x = d;
    d = other.d;
    if (!other.isShort()) {
        // check if we could shrink
        if (specCanBeSmall(extractSpec(other.d->m_status)) && msecsCanBeSmall(other.d->m_msecs)) {
            ShortData sd;
            sd.msecs = qintptr(other.d->m_msecs);
            sd.status = (other.d->m_status | QDateTimePrivate::ShortData).toInt();
            data = sd;
        } else {
            // no, have to keep it big
            other.d->ref.ref();
        }
    }
 
    if (!(quintptr(x) & QDateTimePrivate::ShortData) && !x->ref.deref())
        delete x;
    return *this;
}
 
inline QDateTime::Data::~Data()
{
    if (!isShort() && !d->ref.deref())
        delete d;
}
 
inline bool QDateTime::Data::isShort() const
{
    bool b = quintptr(d) & QDateTimePrivate::ShortData;
 
    // sanity check:
    Q_ASSERT(b || !d->m_status.testFlag(QDateTimePrivate::ShortData));
 
    // even if CanBeSmall = false, we have short data for a default-constructed
    // QDateTime object. But it's unlikely.
    if constexpr (CanBeSmall)
        return Q_LIKELY(b);
    return Q_UNLIKELY(b);
}
 
inline void QDateTime::Data::detach()
{
    QDateTimePrivate *x;
    bool wasShort = isShort();
    if (wasShort) {
        // force enlarging
        x = new QDateTimePrivate;
        x->m_status = QDateTimePrivate::StatusFlags::fromInt(data.status) & ~QDateTimePrivate::ShortData;
        x->m_msecs = data.msecs;
    } else {
        if (d->ref.loadRelaxed() == 1)
            return;
 
        x = new QDateTimePrivate(*d);
    }
 
    x->ref.storeRelaxed(1);
    if (!wasShort && !d->ref.deref())
        delete d;
    d = x;
}
 
QTimeZone QDateTime::Data::timeZone() const
{
    switch (getSpec(*this)) {
    case Qt::UTC:
        return QTimeZone::UTC;
    case Qt::OffsetFromUTC:
        return QTimeZone::fromSecondsAheadOfUtc(d->m_offsetFromUtc);
    case Qt::TimeZone:
#if QT_CONFIG(timezone)
        if (d->m_timeZone.isValid())
            return d->m_timeZone;
#endif
        break;
    case Qt::LocalTime:
        return QTimeZone::LocalTime;
    }
    return QTimeZone();
}
 
inline const QDateTimePrivate *QDateTime::Data::operator->() const
{
    Q_ASSERT(!isShort());
    return d;
}
 
inline QDateTimePrivate *QDateTime::Data::operator->()
{
    // should we attempt to detach here?
    Q_ASSERT(!isShort());
    Q_ASSERT(d->ref.loadRelaxed() == 1);
    return d;
}
 
/*****************************************************************************
  QDateTimePrivate member functions
 *****************************************************************************/
 
Q_NEVER_INLINE
QDateTime::Data QDateTimePrivate::create(QDate toDate, QTime toTime, const QTimeZone &zone)
{
    QDateTime::Data result(zone);
    setDateTime(result, toDate, toTime);
    if (zone.isUtcOrFixedOffset())
        refreshSimpleDateTime(result);
    else
        refreshZonedDateTime(result, zone);
    return result;
}
 
/*****************************************************************************
  QDateTime member functions
 *****************************************************************************/
 
QDateTime::QDateTime() noexcept
{
#if QT_VERSION >= QT_VERSION_CHECK(7, 0, 0) || defined(QT_BOOTSTRAPPED) || QT_POINTER_SIZE == 8
    static_assert(sizeof(ShortData) == sizeof(qint64));
    static_assert(sizeof(Data) == sizeof(qint64));
#endif
    static_assert(sizeof(ShortData) >= sizeof(void*), "oops, Data::swap() is broken!");
}
 
#if QT_DEPRECATED_SINCE(6, 9)
QDateTime::QDateTime(QDate date, QTime time, Qt::TimeSpec spec, int offsetSeconds)
    : d(QDateTimePrivate::create(date, time, asTimeZone(spec, offsetSeconds, "QDateTime")))
{
}
#endif // 6.9 deprecation
 
QDateTime::QDateTime(QDate date, QTime time, const QTimeZone &timeZone)
    : d(QDateTimePrivate::create(date, time, timeZone))
{
}
 
QDateTime::QDateTime(QDate date, QTime time)
    : d(QDateTimePrivate::create(date, time, QTimeZone::LocalTime))
{
}
 
QDateTime::QDateTime(const QDateTime &other) noexcept
    : d(other.d)
{
}
 
QDateTime::QDateTime(QDateTime &&other) noexcept
    : d(std::move(other.d))
{
}
 
QDateTime::~QDateTime()
{
}
 
QDateTime &QDateTime::operator=(const QDateTime &other) noexcept
{
    d = other.d;
    return *this;
}
bool QDateTime::isNull() const
{
    // If date or time is invalid, we don't set datetime valid.
    return !getStatus(d).testAnyFlag(QDateTimePrivate::ValidityMask);
}
 
bool QDateTime::isValid() const
{
    return getStatus(d).testFlag(QDateTimePrivate::ValidDateTime);
}
 
QDate QDateTime::date() const
{
    return getStatus(d).testFlag(QDateTimePrivate::ValidDate) ? msecsToDate(getMSecs(d)) : QDate();
}
 
QTime QDateTime::time() const
{
    return getStatus(d).testFlag(QDateTimePrivate::ValidTime) ? msecsToTime(getMSecs(d)) : QTime();
}
 
Qt::TimeSpec QDateTime::timeSpec() const
{
    return getSpec(d);
}
 
QTimeZone QDateTime::timeRepresentation() const
{
    return d.timeZone();
}
 
#if QT_CONFIG(timezone)
QTimeZone QDateTime::timeZone() const
{
    return d.timeZone().asBackendZone();
}
#endif // timezone
 
int QDateTime::offsetFromUtc() const
{
    if (!d.isShort())
        return d->m_offsetFromUtc;
    if (!isValid())
        return 0;
 
    auto spec = getSpec(d);
    if (spec == Qt::LocalTime) {
        // we didn't cache the value, so we need to calculate it now...
        qint64 msecs = getMSecs(d);
        return (msecs - toMSecsSinceEpoch()) / MSECS_PER_SEC;
    }
 
    Q_ASSERT(spec == Qt::UTC);
    return 0;
}
 
QString QDateTime::timeZoneAbbreviation() const
{
    if (!isValid())
        return QString();
 
    switch (getSpec(d)) {
    case Qt::UTC:
        return "UTC"_L1;
    case Qt::OffsetFromUTC:
        return "UTC"_L1 + toOffsetString(Qt::ISODate, d->m_offsetFromUtc);
    case Qt::TimeZone:
#if !QT_CONFIG(timezone)
        break;
#else
        Q_ASSERT(d->m_timeZone.isValid());
        return d->m_timeZone.abbreviation(*this);
#endif // timezone
    case Qt::LocalTime:
        return QDateTimePrivate::localNameAtMillis(getMSecs(d),
                                                   extractDaylightStatus(getStatus(d)));
    }
    return QString();
}
 
bool QDateTime::isDaylightTime() const
{
    if (!isValid())
        return false;
 
    switch (getSpec(d)) {
    case Qt::UTC:
    case Qt::OffsetFromUTC:
        return false;
    case Qt::TimeZone:
#if !QT_CONFIG(timezone)
        break;
#else
        Q_ASSERT(d->m_timeZone.isValid());
        if (auto dst = extractDaylightStatus(getStatus(d));
            dst != QDateTimePrivate::UnknownDaylightTime) {
            return dst == QDateTimePrivate::DaylightTime;
        }
        return d->m_timeZone.d->isDaylightTime(toMSecsSinceEpoch());
#endif // timezone
    case Qt::LocalTime: {
        auto dst = extractDaylightStatus(getStatus(d));
        if (dst == QDateTimePrivate::UnknownDaylightTime)
            dst = QDateTimePrivate::localStateAtMillis(getMSecs(d), dst).dst;
        return dst == QDateTimePrivate::DaylightTime;
        }
    }
    return false;
}
 
void QDateTime::setDate(QDate date)
{
    setDateTime(d, date, time());
    checkValidDateTime(d);
}
 
void QDateTime::setTime(QTime time)
{
    setDateTime(d, date(), time);
    checkValidDateTime(d);
}
 
#if QT_DEPRECATED_SINCE(6, 9)
void QDateTime::setTimeSpec(Qt::TimeSpec spec)
{
    reviseTimeZone(d, asTimeZone(spec, 0, "QDateTime::setTimeSpec"));
}
 
void QDateTime::setOffsetFromUtc(int offsetSeconds)
{
    reviseTimeZone(d, QTimeZone::fromSecondsAheadOfUtc(offsetSeconds));
}
#endif // 6.9 deprecations
 
void QDateTime::setTimeZone(const QTimeZone &toZone)
{
    reviseTimeZone(d, toZone);
}
 
qint64 QDateTime::toMSecsSinceEpoch() const
{
    // Note: QDateTimeParser relies on this producing a useful result, even when
    // !isValid(), at least when the invalidity is a time in a fall-back (that
    // we'll have adjusted to lie outside it, but marked invalid because it's
    // not what was asked for). Other things may be doing similar.
    switch (getSpec(d)) {
    case Qt::UTC:
        return getMSecs(d);
 
    case Qt::OffsetFromUTC:
        Q_ASSERT(!d.isShort());
        return d->m_msecs - d->m_offsetFromUtc * MSECS_PER_SEC;
 
    case Qt::LocalTime:
        if (d.isShort()) {
            // Short form has nowhere to cache the offset, so recompute.
            auto dst = extractDaylightStatus(getStatus(d));
            auto state = QDateTimePrivate::localStateAtMillis(getMSecs(d), dst);
            return state.when - state.offset * MSECS_PER_SEC;
        }
        // Use the offset saved by refreshZonedDateTime() on creation.
        return d->m_msecs - d->m_offsetFromUtc * MSECS_PER_SEC;
 
    case Qt::TimeZone:
        Q_ASSERT(!d.isShort());
#if QT_CONFIG(timezone)
        // Use offset refreshZonedDateTime() saved on creation:
        if (d->m_timeZone.isValid())
            return d->m_msecs - d->m_offsetFromUtc * MSECS_PER_SEC;
#endif
        return 0;
    }
    Q_UNREACHABLE_RETURN(0);
}
 
qint64 QDateTime::toSecsSinceEpoch() const
{
    return toMSecsSinceEpoch() / MSECS_PER_SEC;
}
 
void QDateTime::setMSecsSinceEpoch(qint64 msecs)
{
    auto status = getStatus(d);
    const auto spec = extractSpec(status);
    Q_ASSERT(specCanBeSmall(spec) || !d.isShort());
    QDateTimePrivate::ZoneState state(msecs);
 
    status &= ~QDateTimePrivate::ValidityMask;
    if (QTimeZone::isUtcOrFixedOffset(spec)) {
        if (spec == Qt::OffsetFromUTC)
            state.offset = d->m_offsetFromUtc;
        if (!state.offset || !qAddOverflow(msecs, state.offset * MSECS_PER_SEC, &state.when))
            status |= QDateTimePrivate::ValidityMask;
    } else if (spec == Qt::LocalTime) {
        state = QDateTimePrivate::expressUtcAsLocal(msecs);
        if (state.valid)
            status = mergeDaylightStatus(status | QDateTimePrivate::ValidityMask, state.dst);
#if QT_CONFIG(timezone)
    } else if (spec == Qt::TimeZone && (d.detach(), d->m_timeZone.isValid())) {
        const auto data = d->m_timeZone.d->data(msecs);
        if (Q_LIKELY(data.offsetFromUtc != QTimeZonePrivate::invalidSeconds())) {
            state.offset = data.offsetFromUtc;
            Q_ASSERT(state.offset >= -SECS_PER_DAY && state.offset <= SECS_PER_DAY);
            if (!state.offset
                || !Q_UNLIKELY(qAddOverflow(msecs, state.offset * MSECS_PER_SEC, &state.when))) {
                d->m_status = mergeDaylightStatus(status | QDateTimePrivate::ValidityMask,
                                                  data.daylightTimeOffset
                                                  ? QDateTimePrivate::DaylightTime
                                                  : QDateTimePrivate::StandardTime);
                d->m_msecs = state.when;
                d->m_offsetFromUtc = state.offset;
                return;
            } // else: zone can't represent this UTC time
        } // else: zone unable to represent given UTC time (should only happen on overflow).
#endif // timezone
    }
    Q_ASSERT(!status.testFlag(QDateTimePrivate::ValidDateTime)
             || (state.offset >= -SECS_PER_DAY && state.offset <= SECS_PER_DAY));
 
    if (msecsCanBeSmall(state.when) && d.isShort()) {
        // we can keep short
        d.data.msecs = qintptr(state.when);
        d.data.status = status.toInt();
    } else {
        d.detach();
        d->m_status = status & ~QDateTimePrivate::ShortData;
        d->m_msecs = state.when;
        d->m_offsetFromUtc = state.offset;
    }
}
 
void QDateTime::setSecsSinceEpoch(qint64 secs)
{
    qint64 msecs;
    if (!qMulOverflow(secs, std::integral_constant<qint64, MSECS_PER_SEC>(), &msecs)) {
        setMSecsSinceEpoch(msecs);
    } else if (d.isShort()) {
        d.data.status &= ~int(QDateTimePrivate::ValidityMask);
    } else {
        d.detach();
        d->m_status &= ~QDateTimePrivate::ValidityMask;
    }
}
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
QString QDateTime::toString(Qt::DateFormat format) const
{
    QString buf;
    if (!isValid())
        return buf;
 
    switch (format) {
    case Qt::RFC2822Date:
        buf = QLocale::c().toString(*this, u"dd MMM yyyy hh:mm:ss ");
        buf += toOffsetString(Qt::TextDate, offsetFromUtc());
        return buf;
    default:
    case Qt::TextDate: {
        const QPair<QDate, QTime> p = getDateTime(d);
        buf = toStringTextDate(p.first);
        // Insert time between date's day and year:
        buf.insert(buf.lastIndexOf(u' '),
                   u' ' + p.second.toString(Qt::TextDate));
        // Append zone/offset indicator, as appropriate:
        switch (timeSpec()) {
        case Qt::LocalTime:
            break;
#if QT_CONFIG(timezone)
        case Qt::TimeZone:
            buf += u' ' + d->m_timeZone.displayName(
                *this, QTimeZone::OffsetName, QLocale::c());
            break;
#endif
        default:
#if 0 // ### Qt 7 GMT: use UTC instead, see qnamespace.qdoc documentation
            buf += " UTC"_L1;
#else
            buf += " GMT"_L1;
#endif
            if (getSpec(d) == Qt::OffsetFromUTC)
                buf += toOffsetString(Qt::TextDate, offsetFromUtc());
        }
        return buf;
    }
    case Qt::ISODate:
    case Qt::ISODateWithMs: {
        const QPair<QDate, QTime> p = getDateTime(d);
        buf = toStringIsoDate(p.first);
        if (buf.isEmpty())
            return QString();   // failed to convert
        buf += u'T' + p.second.toString(format);
        switch (getSpec(d)) {
        case Qt::UTC:
            buf += u'Z';
            break;
        case Qt::OffsetFromUTC:
        case Qt::TimeZone:
            buf += toOffsetString(Qt::ISODate, offsetFromUtc());
            break;
        default:
            break;
        }
        return buf;
    }
    }
}
 
QString QDateTime::toString(QStringView format, QCalendar cal) const
{
    return QLocale::c().toString(*this, format, cal);
}
#endif // datestring
 
static inline void massageAdjustedDateTime(QDateTimeData &d, QDate date, QTime time)
{
    /*
      If we have just adjusted to a day with a DST transition, our given time
      may lie in the transition hour (either missing or duplicated).  For any
      other time, telling mktime() or QTimeZone what we know about DST-ness, of
      the time we adjusted from, will make no difference; it'll just tell us the
      actual DST-ness of the given time. When landing in a transition that
      repeats an hour, passing the prior DST-ness - when known - will get us the
      indicated side of the duplicate (either local or zone). When landing in a
      gap, the zone gives us the other side of the gap and mktime() is wrapped
      to coax it into doing the same (which it does by default on Unix).
    */
    auto status = getStatus(d);
    Q_ASSERT(status.testFlags(QDateTimePrivate::ValidDate | QDateTimePrivate::ValidTime
                              | QDateTimePrivate::ValidDateTime));
    auto spec = extractSpec(status);
    if (QTimeZone::isUtcOrFixedOffset(spec)) {
        setDateTime(d, date, time);
        refreshSimpleDateTime(d);
        return;
    }
    auto dst = extractDaylightStatus(status);
    qint64 local = timeToMSecs(date, time);
    const QDateTimePrivate::ZoneState state = stateAtMillis(d.timeZone(), local, dst);
    if (state.valid)
        status = mergeDaylightStatus(status | QDateTimePrivate::ValidDateTime, state.dst);
    else
        status.setFlag(QDateTimePrivate::ValidDateTime, false);
 
    if (status & QDateTimePrivate::ShortData) {
        d.data.msecs = state.when;
        d.data.status = status.toInt();
    } else {
        d.detach();
        d->m_status = status;
        if (state.valid) {
            d->m_msecs = state.when;
            d->m_offsetFromUtc = state.offset;
        }
    }
}
 
QDateTime QDateTime::addDays(qint64 ndays) const
{
    if (isNull())
        return QDateTime();
 
    QDateTime dt(*this);
    QPair<QDate, QTime> p = getDateTime(d);
    massageAdjustedDateTime(dt.d, p.first.addDays(ndays), p.second);
    return dt;
}
 
QDateTime QDateTime::addMonths(int nmonths) const
{
    if (isNull())
        return QDateTime();
 
    QDateTime dt(*this);
    QPair<QDate, QTime> p = getDateTime(d);
    massageAdjustedDateTime(dt.d, p.first.addMonths(nmonths), p.second);
    return dt;
}
 
QDateTime QDateTime::addYears(int nyears) const
{
    if (isNull())
        return QDateTime();
 
    QDateTime dt(*this);
    QPair<QDate, QTime> p = getDateTime(d);
    massageAdjustedDateTime(dt.d, p.first.addYears(nyears), p.second);
    return dt;
}
 
QDateTime QDateTime::addSecs(qint64 s) const
{
    qint64 msecs;
    if (qMulOverflow(s, std::integral_constant<qint64, MSECS_PER_SEC>(), &msecs))
        return QDateTime();
    return addMSecs(msecs);
}
 
QDateTime QDateTime::addMSecs(qint64 msecs) const
{
    if (!isValid())
        return QDateTime();
 
    QDateTime dt(*this);
    switch (getSpec(d)) {
    case Qt::LocalTime:
    case Qt::TimeZone:
        // Convert to real UTC first in case this crosses a DST transition:
        if (!qAddOverflow(toMSecsSinceEpoch(), msecs, &msecs)) {
            dt.setMSecsSinceEpoch(msecs);
        } else if (dt.d.isShort()) {
            dt.d.data.status &= ~int(QDateTimePrivate::ValidityMask);
        } else {
            dt.d.detach();
            dt.d->m_status &= ~QDateTimePrivate::ValidityMask;
        }
        break;
    case Qt::UTC:
    case Qt::OffsetFromUTC:
        // No need to convert, just add on
        if (qAddOverflow(getMSecs(d), msecs, &msecs)) {
            if (dt.d.isShort()) {
                dt.d.data.status &= ~int(QDateTimePrivate::ValidityMask);
            } else {
                dt.d.detach();
                dt.d->m_status &= ~QDateTimePrivate::ValidityMask;
            }
        } else if (d.isShort()) {
            // need to check if we need to enlarge first
            if (msecsCanBeSmall(msecs)) {
                dt.d.data.msecs = qintptr(msecs);
            } else {
                dt.d.detach();
                dt.d->m_msecs = msecs;
            }
        } else {
            dt.d.detach();
            dt.d->m_msecs = msecs;
        }
        break;
    }
    return dt;
}
 
qint64 QDateTime::daysTo(const QDateTime &other) const
{
    return date().daysTo(other.date());
}
 
qint64 QDateTime::secsTo(const QDateTime &other) const
{
    return msecsTo(other) / MSECS_PER_SEC;
}
 
qint64 QDateTime::msecsTo(const QDateTime &other) const
{
    if (!isValid() || !other.isValid())
        return 0;
 
    return other.toMSecsSinceEpoch() - toMSecsSinceEpoch();
}
 
#if QT_DEPRECATED_SINCE(6, 9)
QDateTime QDateTime::toTimeSpec(Qt::TimeSpec spec) const
{
    return toTimeZone(asTimeZone(spec, 0, "toTimeSpec"));
}
#endif // 6.9 deprecation
 
QDateTime QDateTime::toOffsetFromUtc(int offsetSeconds) const
{
    return toTimeZone(QTimeZone::fromSecondsAheadOfUtc(offsetSeconds));
}
 
QDateTime QDateTime::toLocalTime() const
{
    return toTimeZone(QTimeZone::LocalTime);
}
 
QDateTime QDateTime::toUTC() const
{
    return toTimeZone(QTimeZone::UTC);
}
 
QDateTime QDateTime::toTimeZone(const QTimeZone &timeZone) const
{
    if (timeRepresentation() == timeZone)
        return *this;
 
    if (!isValid()) {
        QDateTime ret = *this;
        ret.setTimeZone(timeZone);
        return ret;
    }
 
    return fromMSecsSinceEpoch(toMSecsSinceEpoch(), timeZone);
}
 
bool QDateTime::equals(const QDateTime &other) const
{
    if (!isValid())
        return !other.isValid();
    if (!other.isValid())
        return false;
 
    if (usesSameOffset(d, other.d))
        return getMSecs(d) == getMSecs(other.d);
 
    // Convert to UTC and compare
    return toMSecsSinceEpoch() == other.toMSecsSinceEpoch();
}
 
bool QDateTime::precedes(const QDateTime &other) const
{
    if (!isValid())
        return other.isValid();
    if (!other.isValid())
        return false;
 
    if (usesSameOffset(d, other.d))
        return getMSecs(d) < getMSecs(other.d);
 
    // Convert to UTC and compare
    return toMSecsSinceEpoch() < other.toMSecsSinceEpoch();
}
 
QDateTime QDateTime::currentDateTime()
{
    return currentDateTime(QTimeZone::LocalTime);
}
 
QDateTime QDateTime::currentDateTimeUtc()
{
    return currentDateTime(QTimeZone::UTC);
}
 
#if defined(Q_OS_WIN)
static inline uint msecsFromDecomposed(int hour, int minute, int sec, int msec = 0)
{
    return MSECS_PER_HOUR * hour + MSECS_PER_MIN * minute + MSECS_PER_SEC * sec + msec;
}
 
QDate QDate::currentDate()
{
    SYSTEMTIME st = {};
    GetLocalTime(&st);
    return QDate(st.wYear, st.wMonth, st.wDay);
}
 
QTime QTime::currentTime()
{
    QTime ct;
    SYSTEMTIME st = {};
    GetLocalTime(&st);
    ct.setHMS(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
    return ct;
}
 
QDateTime QDateTime::currentDateTime(const QTimeZone &zone)
{
    // We can get local time or "system" time (which is UTC); otherwise, we must
    // convert, which is most efficiently done from UTC.
    const Qt::TimeSpec spec = zone.timeSpec();
    SYSTEMTIME st = {};
    // GetSystemTime()'s page links to its partner page for GetLocalTime().
    // https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getsystemtime
    (spec == Qt::LocalTime ? GetLocalTime : GetSystemTime)(&st);
    QDate d(st.wYear, st.wMonth, st.wDay);
    QTime t(msecsFromDecomposed(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds));
    if (spec == Qt::LocalTime)
        return QDateTime(d, t);
    QDateTime utc(d, t, QTimeZone::UTC);
    return spec == Qt::UTC ? utc : utc.toTimeZone(zone);
}
 
qint64 QDateTime::currentMSecsSinceEpoch() noexcept
{
    SYSTEMTIME st = {};
    GetSystemTime(&st);
    const qint64 daysAfterEpoch = QDate(1970, 1, 1).daysTo(QDate(st.wYear, st.wMonth, st.wDay));
 
    return msecsFromDecomposed(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds) +
           daysAfterEpoch * MSECS_PER_DAY;
}
 
qint64 QDateTime::currentSecsSinceEpoch() noexcept
{
    SYSTEMTIME st = {};
    GetSystemTime(&st);
    const qint64 daysAfterEpoch = QDate(1970, 1, 1).daysTo(QDate(st.wYear, st.wMonth, st.wDay));
 
    return st.wHour * SECS_PER_HOUR + st.wMinute * SECS_PER_MIN + st.wSecond +
           daysAfterEpoch * SECS_PER_DAY;
}
 
#elif defined(Q_OS_UNIX)
QDate QDate::currentDate()
{
    return QDateTime::currentDateTime().date();
}
 
QTime QTime::currentTime()
{
    return QDateTime::currentDateTime().time();
}
 
QDateTime QDateTime::currentDateTime(const QTimeZone &zone)
{
    return fromMSecsSinceEpoch(currentMSecsSinceEpoch(), zone);
}
 
qint64 QDateTime::currentMSecsSinceEpoch() noexcept
{
    // posix compliant system
    // we have milliseconds
    struct timeval tv;
    gettimeofday(&tv, nullptr);
    return tv.tv_sec * MSECS_PER_SEC + tv.tv_usec / 1000;
}
 
qint64 QDateTime::currentSecsSinceEpoch() noexcept
{
    struct timeval tv;
    gettimeofday(&tv, nullptr);
    return tv.tv_sec;
}
#else
#error "What system is this?"
#endif
 
#if QT_DEPRECATED_SINCE(6, 9)
QDateTime QDateTime::fromMSecsSinceEpoch(qint64 msecs, Qt::TimeSpec spec, int offsetSeconds)
{
    return fromMSecsSinceEpoch(msecs,
                               asTimeZone(spec, offsetSeconds, "QDateTime::fromMSecsSinceEpoch"));
}
 
QDateTime QDateTime::fromSecsSinceEpoch(qint64 secs, Qt::TimeSpec spec, int offsetSeconds)
{
    return fromSecsSinceEpoch(secs,
                              asTimeZone(spec, offsetSeconds, "QDateTime::fromSecsSinceEpoch"));
}
#endif // 6.9 deprecations
 
QDateTime QDateTime::fromMSecsSinceEpoch(qint64 msecs, const QTimeZone &timeZone)
{
    QDateTime dt;
    reviseTimeZone(dt.d, timeZone);
    if (timeZone.isValid())
        dt.setMSecsSinceEpoch(msecs);
    return dt;
}
 
QDateTime QDateTime::fromMSecsSinceEpoch(qint64 msecs)
{
    return fromMSecsSinceEpoch(msecs, QTimeZone::LocalTime);
}
 
QDateTime QDateTime::fromSecsSinceEpoch(qint64 secs, const QTimeZone &timeZone)
{
    QDateTime dt;
    reviseTimeZone(dt.d, timeZone);
    if (timeZone.isValid())
        dt.setSecsSinceEpoch(secs);
    return dt;
}
 
QDateTime QDateTime::fromSecsSinceEpoch(qint64 secs)
{
    return fromSecsSinceEpoch(secs, QTimeZone::LocalTime);
}
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
 
QDateTime QDateTime::fromString(QStringView string, Qt::DateFormat format)
{
    if (string.isEmpty())
        return QDateTime();
 
    switch (format) {
    case Qt::RFC2822Date: {
        const ParsedRfcDateTime rfc = rfcDateImpl(string);
 
        if (!rfc.date.isValid() || !rfc.time.isValid())
            return QDateTime();
 
        QDateTime dateTime(rfc.date, rfc.time, QTimeZone::UTC);
        dateTime.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(rfc.utcOffset));
        return dateTime;
    }
    case Qt::ISODate:
    case Qt::ISODateWithMs: {
        const int size = string.size();
        if (size < 10)
            return QDateTime();
 
        QDate date = QDate::fromString(string.first(10), Qt::ISODate);
        if (!date.isValid())
            return QDateTime();
        if (size == 10)
            return date.startOfDay();
 
        QTimeZone zone = QTimeZone::LocalTime;
        QStringView isoString = string.sliced(10); // trim "yyyy-MM-dd"
 
        // Must be left with T (or space) and at least one digit for the hour:
        if (isoString.size() < 2
            || !(isoString.startsWith(u'T', Qt::CaseInsensitive)
                 // RFC 3339 (section 5.6) allows a space here.  (It actually
                 // allows any separator one considers more readable, merely
                 // giving space as an example - but let's not go wild !)
                 || isoString.startsWith(u' '))) {
            return QDateTime();
        }
        isoString = isoString.sliced(1); // trim 'T' (or space)
 
        // Check end of string for Time Zone definition, either Z for UTC or [+-]HH:mm for Offset
        if (isoString.endsWith(u'Z', Qt::CaseInsensitive)) {
            zone = QTimeZone::UTC;
            isoString.chop(1); // trim 'Z'
        } else {
            // the loop below is faster but functionally equal to:
            // const int signIndex = isoString.indexOf(QRegulargExpression(QStringLiteral("[+-]")));
            int signIndex = isoString.size() - 1;
            Q_ASSERT(signIndex >= 0);
            bool found = false;
            do {
                QChar character(isoString[signIndex]);
                found = character == u'+' || character == u'-';
            } while (!found && --signIndex >= 0);
 
            if (found) {
                bool ok;
                int offset = fromOffsetString(isoString.sliced(signIndex), &ok);
                if (!ok)
                    return QDateTime();
                isoString = isoString.first(signIndex);
                zone = QTimeZone::fromSecondsAheadOfUtc(offset);
            }
        }
 
        // Might be end of day (24:00, including variants), which QTime considers invalid.
        // ISO 8601 (section 4.2.3) says that 24:00 is equivalent to 00:00 the next day.
        bool isMidnight24 = false;
        QTime time = fromIsoTimeString(isoString, format, &isMidnight24);
        if (!time.isValid())
            return QDateTime();
        if (isMidnight24) // time is 0:0, but we want the start of next day:
            return date.addDays(1).startOfDay(zone);
        return QDateTime(date, time, zone);
    }
    case Qt::TextDate: {
        QVarLengthArray<QStringView, 6> parts;
 
        auto tokens = string.tokenize(u' ', Qt::SkipEmptyParts);
        auto it = tokens.begin();
        for (int i = 0; i < 6 && it != tokens.end(); ++i, ++it)
            parts.emplace_back(*it);
 
        // Documented as "ddd MMM d HH:mm:ss yyyy" with optional offset-suffix;
        // and allow time either before or after year.
        if (parts.size() < 5 || it != tokens.end())
            return QDateTime();
 
        // Year and time can be in either order.
        // Guess which by looking for ':' in the time
        int yearPart = 3;
        int timePart = 3;
        if (parts.at(3).contains(u':'))
            yearPart = 4;
        else if (parts.at(4).contains(u':'))
            timePart = 4;
        else
            return QDateTime();
 
        bool ok = false;
        int day = parts.at(2).toInt(&ok);
        int year = ok ? parts.at(yearPart).toInt(&ok) : 0;
        int month = fromShortMonthName(parts.at(1));
        if (!ok || year == 0 || day == 0 || month < 1)
            return QDateTime();
 
        const QDate date(year, month, day);
        if (!date.isValid())
            return QDateTime();
 
        const QTime time = fromIsoTimeString(parts.at(timePart), format, nullptr);
        if (!time.isValid())
            return QDateTime();
 
        if (parts.size() == 5)
            return QDateTime(date, time);
 
        QStringView tz = parts.at(5);
        if (tz.startsWith("UTC"_L1)
            // GMT has long been deprecated as an alias for UTC.
            || tz.startsWith("GMT"_L1, Qt::CaseInsensitive)) {
            tz = tz.sliced(3);
            if (tz.isEmpty())
                return QDateTime(date, time, QTimeZone::UTC);
 
            int offset = fromOffsetString(tz, &ok);
            return ok ? QDateTime(date, time, QTimeZone::fromSecondsAheadOfUtc(offset))
                      : QDateTime();
        }
        return QDateTime();
    }
    }
 
    return QDateTime();
}
 
QDateTime QDateTime::fromString(const QString &string, QStringView format, QCalendar cal)
{
#if QT_CONFIG(datetimeparser)
    QDateTime datetime;
 
    QDateTimeParser dt(QMetaType::QDateTime, QDateTimeParser::FromString, cal);
    dt.setDefaultLocale(QLocale::c());
    if (dt.parseFormat(format) && (dt.fromString(string, &datetime) || !datetime.isValid()))
        return datetime;
#else
    Q_UNUSED(string);
    Q_UNUSED(format);
    Q_UNUSED(cal);
#endif
    return QDateTime();
}
 
#endif // datestring
 
/*****************************************************************************
  Date/time stream functions
 *****************************************************************************/
 
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &out, QDate date)
{
    if (out.version() < QDataStream::Qt_5_0)
        return out << quint32(date.jd);
    else
        return out << date.jd;
}
 
QDataStream &operator>>(QDataStream &in, QDate &date)
{
    if (in.version() < QDataStream::Qt_5_0) {
        quint32 jd;
        in >> jd;
        // Older versions consider 0 an invalid jd.
        date.jd = (jd != 0 ? jd : QDate::nullJd());
    } else {
        in >> date.jd;
    }
 
    return in;
}
 
QDataStream &operator<<(QDataStream &out, QTime time)
{
    if (out.version() >= QDataStream::Qt_4_0) {
        return out << quint32(time.mds);
    } else {
        // Qt3 had no support for reading -1, QTime() was valid and serialized as 0
        return out << quint32(time.isNull() ? 0 : time.mds);
    }
}
 
QDataStream &operator>>(QDataStream &in, QTime &time)
{
    quint32 ds;
    in >> ds;
    if (in.version() >= QDataStream::Qt_4_0) {
        time.mds = int(ds);
    } else {
        // Qt3 would write 0 for a null time
        time.mds = (ds == 0) ? QTime::NullTime : int(ds);
    }
    return in;
}
 
QDataStream &operator<<(QDataStream &out, const QDateTime &dateTime)
{
    QPair<QDate, QTime> dateAndTime;
 
    // TODO: new version, route spec and details via QTimeZone
    if (out.version() >= QDataStream::Qt_5_2) {
 
        // In 5.2 we switched to using Qt::TimeSpec and added offset and zone support
        dateAndTime = getDateTime(dateTime.d);
        out << dateAndTime << qint8(dateTime.timeSpec());
        if (dateTime.timeSpec() == Qt::OffsetFromUTC)
            out << qint32(dateTime.offsetFromUtc());
#if QT_CONFIG(timezone)
        else if (dateTime.timeSpec() == Qt::TimeZone)
            out << dateTime.timeZone();
#endif // timezone
 
    } else if (out.version() == QDataStream::Qt_5_0) {
 
        // In Qt 5.0 we incorrectly serialised all datetimes as UTC.
        // This approach is wrong and should not be used again; it breaks
        // the guarantee that a deserialised local datetime is the same time
        // of day, regardless of which timezone it was serialised in.
        dateAndTime = getDateTime((dateTime.isValid() ? dateTime.toUTC() : dateTime).d);
        out << dateAndTime << qint8(dateTime.timeSpec());
 
    } else if (out.version() >= QDataStream::Qt_4_0) {
 
        // From 4.0 to 5.1 (except 5.0) we used QDateTimePrivate::Spec
        dateAndTime = getDateTime(dateTime.d);
        out << dateAndTime;
        switch (dateTime.timeSpec()) {
        case Qt::UTC:
            out << (qint8)QDateTimePrivate::UTC;
            break;
        case Qt::OffsetFromUTC:
            out << (qint8)QDateTimePrivate::OffsetFromUTC;
            break;
        case Qt::TimeZone:
            out << (qint8)QDateTimePrivate::TimeZone;
            break;
        case Qt::LocalTime:
            out << (qint8)QDateTimePrivate::LocalUnknown;
            break;
        }
 
    } else { // version < QDataStream::Qt_4_0
 
        // Before 4.0 there was no TimeSpec, only Qt::LocalTime was supported
        dateAndTime = getDateTime(dateTime.d);
        out << dateAndTime;
 
    }
 
    return out;
}
 
QDataStream &operator>>(QDataStream &in, QDateTime &dateTime)
{
    QDate dt;
    QTime tm;
    qint8 ts = 0;
    QTimeZone zone(QTimeZone::LocalTime);
 
    if (in.version() >= QDataStream::Qt_5_2) {
 
        // In 5.2 we switched to using Qt::TimeSpec and added offset and zone support
        in >> dt >> tm >> ts;
        switch (static_cast<Qt::TimeSpec>(ts)) {
        case Qt::UTC:
            zone = QTimeZone::UTC;
            break;
        case Qt::OffsetFromUTC: {
            qint32 offset = 0;
            in >> offset;
            zone = QTimeZone::fromSecondsAheadOfUtc(offset);
            break;
        }
        case Qt::LocalTime:
            break;
        case Qt::TimeZone:
            in >> zone;
            break;
        }
        dateTime = QDateTime(dt, tm, zone);
 
    } else if (in.version() == QDataStream::Qt_5_0) {
 
        // In Qt 5.0 we incorrectly serialised all datetimes as UTC
        in >> dt >> tm >> ts;
        dateTime = QDateTime(dt, tm, QTimeZone::UTC);
        if (static_cast<Qt::TimeSpec>(ts) == Qt::LocalTime)
            dateTime = dateTime.toTimeZone(zone);
 
    } else if (in.version() >= QDataStream::Qt_4_0) {
 
        // From 4.0 to 5.1 (except 5.0) we used QDateTimePrivate::Spec
        in >> dt >> tm >> ts;
        switch (static_cast<QDateTimePrivate::Spec>(ts)) {
        case QDateTimePrivate::OffsetFromUTC: // No offset was stored, so treat as UTC.
        case QDateTimePrivate::UTC:
            zone = QTimeZone::UTC;
            break;
        case QDateTimePrivate::TimeZone: // No zone was stored, so treat as LocalTime:
        case QDateTimePrivate::LocalUnknown:
        case QDateTimePrivate::LocalStandard:
        case QDateTimePrivate::LocalDST:
            break;
        }
        dateTime = QDateTime(dt, tm, zone);
 
    } else { // version < QDataStream::Qt_4_0
 
        // Before 4.0 there was no TimeSpec, only Qt::LocalTime was supported
        in >> dt >> tm;
        dateTime = QDateTime(dt, tm);
 
    }
 
    return in;
}
#endif // QT_NO_DATASTREAM
 
/*****************************************************************************
  Date / Time Debug Streams
*****************************************************************************/
 
#if !defined(QT_NO_DEBUG_STREAM) && QT_CONFIG(datestring)
QDebug operator<<(QDebug dbg, QDate date)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QDate(";
    if (date.isValid())
        // QTBUG-91070, ISODate only supports years in the range 0-9999
        if (int y = date.year(); y > 0 && y <= 9999)
            dbg.nospace() << date.toString(Qt::ISODate);
        else
            dbg.nospace() << date.toString(Qt::TextDate);
    else
        dbg.nospace() << "Invalid";
    dbg.nospace() << ')';
    return dbg;
}
 
QDebug operator<<(QDebug dbg, QTime time)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QTime(";
    if (time.isValid())
        dbg.nospace() << time.toString(u"HH:mm:ss.zzz");
    else
        dbg.nospace() << "Invalid";
    dbg.nospace() << ')';
    return dbg;
}
 
QDebug operator<<(QDebug dbg, const QDateTime &date)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QDateTime(";
    if (date.isValid()) {
        const Qt::TimeSpec ts = date.timeSpec();
        dbg.noquote() << date.toString(u"yyyy-MM-dd HH:mm:ss.zzz t")
                      << ' ' << ts;
        switch (ts) {
        case Qt::UTC:
            break;
        case Qt::OffsetFromUTC:
            dbg.space() << date.offsetFromUtc() << 's';
            break;
        case Qt::TimeZone:
#if QT_CONFIG(timezone)
            dbg.space() << date.timeZone().id();
#endif // timezone
            break;
        case Qt::LocalTime:
            break;
        }
    } else {
        dbg.nospace() << "Invalid";
    }
    return dbg.nospace() << ')';
}
#endif // debug_stream && datestring
 
size_t qHash(const QDateTime &key, size_t seed)
{
    // Use to toMSecsSinceEpoch instead of individual qHash functions for
    // QDate/QTime/spec/offset because QDateTime::operator== converts both arguments
    // to the same timezone. If we don't, qHash would return different hashes for
    // two QDateTimes that are equivalent once converted to the same timezone.
    return key.isValid() ? qHash(key.toMSecsSinceEpoch(), seed) : seed;
}
 
size_t qHash(QDate key, size_t seed) noexcept
{
    return qHash(key.toJulianDay(), seed);
}
 
size_t qHash(QTime key, size_t seed) noexcept
{
    return qHash(key.msecsSinceStartOfDay(), seed);
}
 
QT_END_NAMESPACE