qtimezoneprivate_icu.cpp

++ // Copyright (C) 2013 John Layt <jlayt@kde.org>

++ // Copyright (C) 2022 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:significant reason:default

++

++ #include "qtimezone.h"

++ #include "qtimezoneprivate_p.h"

++ #include "qtimezonelocale_p.h"

++

++ #include <unicode/ucal.h>

++

++ #include <qdebug.h>

++ #include <qlist.h>

++

++ #include <algorithm>

++

++ QT_BEGIN_NAMESPACE

++

++ /*

++     Private

++

++     ICU implementation

++ */

++

++ // ICU utilities

++

++ #ifdef Q_OS_HARMONY

++ #include <BasicServicesKit/time_service.h>

++ #endif

++

++ // Qt wrapper around ucal_getDefaultTimeZone()

++ static QByteArray ucalDefaultTimeZoneId()

++ {

++ #ifdef Q_OS_HARMONY

++     char tzBuffer[32] = { 0 };

++     TimeService_ErrCode err = OH_TimeService_GetTimeZone(tzBuffer, sizeof(tzBuffer));

++

++     if (err == TIMESERVICE_ERR_OK)

++         return QByteArray(tzBuffer);

++ #endif

++     int32_t size = 30;

++     QString result(size, Qt::Uninitialized);

++     UErrorCode status = U_ZERO_ERROR;

++

++     // size = ucal_getDefaultTimeZone(result, resultLength, status)

++     size = ucal_getDefaultTimeZone(reinterpret_cast<UChar *>(result.data()), size, &status);

++

++     // If overflow, then resize and retry

++     if (status == U_BUFFER_OVERFLOW_ERROR) {

++         result.resize(size);

++         status = U_ZERO_ERROR;

++         size = ucal_getDefaultTimeZone(reinterpret_cast<UChar *>(result.data()), size, &status);

++     }

++

++     // If successful on first or second go, resize and return

++     if (U_SUCCESS(status)) {

++         result.resize(size);

++         return std::move(result).toUtf8();

++     }

++

++     return QByteArray();

++ }

++

++ // Qt wrapper around ucal_get() for offsets

++ static bool ucalOffsetsAtTime(UCalendar *m_ucal, qint64 atMSecsSinceEpoch,

++                               int *utcOffset, int *dstOffset)

++ {

++     *utcOffset = 0;

++     *dstOffset = 0;

++

++     // Clone the ucal so we don't change the shared object

++     UErrorCode status = U_ZERO_ERROR;

++     UCalendar *ucal = ucal_clone(m_ucal, &status);

++     if (!U_SUCCESS(status))

++         return false;

++

++     // Set the date to find the offset for

++     status = U_ZERO_ERROR;

++     ucal_setMillis(ucal, atMSecsSinceEpoch, &status);

++

++     int32_t utc = 0;

++     if (U_SUCCESS(status)) {

++         status = U_ZERO_ERROR;

++         // Returns msecs

++         utc = ucal_get(ucal, UCAL_ZONE_OFFSET, &status) / 1000;

++     }

++

++     int32_t dst = 0;

++     if (U_SUCCESS(status)) {

++         status = U_ZERO_ERROR;

++         // Returns msecs

++         dst = ucal_get(ucal, UCAL_DST_OFFSET, &status) / 1000;

++     }

++

++     ucal_close(ucal);

++     if (U_SUCCESS(status)) {

++         *utcOffset = utc;

++         *dstOffset = dst;

++         return true;

++     }

++     return false;

++ }

++

++ #if U_ICU_VERSION_MAJOR_NUM >= 50

++ // Qt wrapper around qt_ucal_getTimeZoneTransitionDate & ucal_get

++ static QTimeZonePrivate::Data ucalTimeZoneTransition(UCalendar *m_ucal,

++                                                      UTimeZoneTransitionType type,

++                                                      qint64 atMSecsSinceEpoch)

++ {

++     QTimeZonePrivate::Data tran;

++

++     // Clone the ucal so we don't change the shared object

++     UErrorCode status = U_ZERO_ERROR;

++     UCalendar *ucal = ucal_clone(m_ucal, &status);

++     if (!U_SUCCESS(status))

++         return tran;

++

++     // Set the date to find the transition for

++     status = U_ZERO_ERROR;

++     const UDate when = UDate(atMSecsSinceEpoch);

++     ucal_setMillis(ucal, when, &status);

++

++     // Find the transition time

++     UDate tranMSecs = 0;

++     status = U_ZERO_ERROR;

++     bool ok = ucal_getTimeZoneTransitionDate(ucal, type, &tranMSecs, &status);

++

++     // Catch a known violation (in ICU 67) of the specified behavior:

++     if (U_SUCCESS(status) && ok && type == UCAL_TZ_TRANSITION_NEXT) {

++         // At the end of time, that can "succeed" with tranMSecs ==

++         // atMSecsSinceEpoch, which should be treated as a failure.

++         // (At the start of time, previous correctly fails.)

++         ok = tranMSecs > when;

++     }

++

++     // Set the transition time to find the offsets for

++     if (U_SUCCESS(status) && ok) {

++         status = U_ZERO_ERROR;

++         ucal_setMillis(ucal, tranMSecs, &status);

++     }

++

++     int32_t utc = 0;

++     if (U_SUCCESS(status) && ok) {

++         status = U_ZERO_ERROR;

++         utc = ucal_get(ucal, UCAL_ZONE_OFFSET, &status) / 1000;

++     }

++

++     int32_t dst = 0;

++     if (U_SUCCESS(status) && ok) {

++         status = U_ZERO_ERROR;

++         dst = ucal_get(ucal, UCAL_DST_OFFSET, &status) / 1000;

++     }

++

++     ucal_close(ucal);

++     if (!U_SUCCESS(status) || !ok)

++         return tran;

++     tran.atMSecsSinceEpoch = qint64(tranMSecs);

++     tran.offsetFromUtc = utc + dst;

++     tran.standardTimeOffset = utc;

++     tran.daylightTimeOffset = dst;

++     // TODO No ICU API, use short name as abbreviation.

++     QTimeZone::TimeType timeType = dst == 0 ? QTimeZone::StandardTime : QTimeZone::DaylightTime;

++     using namespace QtTimeZoneLocale;

++     tran.abbreviation = ucalTimeZoneDisplayName(m_ucal, timeType,

++                                                 QTimeZone::ShortName, QLocale().name().toUtf8());

++     return tran;

++ }

++ #endif // U_ICU_VERSION_SHORT

++

++ // Convert a uenum (listing zone names) to a QList<QByteArray>

++ static QList<QByteArray> uenumToIdList(UEnumeration *uenum)

++ {

++     QList<QByteArray> list;

++     int32_t size = 0;

++     UErrorCode status = U_ZERO_ERROR;

++     // TODO Perhaps use uenum_unext instead?

++     QByteArray result = uenum_next(uenum, &size, &status);

++     while (U_SUCCESS(status) && !result.isEmpty()) {

++         list << result;

++         // Include the CLDR-canonical name, as well

++         const QByteArrayView zone = QTimeZonePrivate::aliasToIana(result);

++         if (!zone.isEmpty()) {

++             list << zone.toByteArray();

++             Q_ASSERT(QTimeZonePrivate::aliasToIana(zone).isEmpty());

++         }

++         status = U_ZERO_ERROR;

++         result = uenum_next(uenum, &size, &status);

++     }

++

++     std::sort(list.begin(), list.end());

++     list.erase(std::unique(list.begin(), list.end()), list.end());

++     return list;

++ }

++

++ // Qt wrapper around ucal_getDSTSavings()

++ static int ucalDaylightOffset(const QByteArray &id)

++ {

++     UErrorCode status = U_ZERO_ERROR;

++     const QString utf16 = QString::fromLatin1(id);

++     const int32_t dstMSecs = ucal_getDSTSavings(

++         reinterpret_cast<const UChar *>(utf16.data()), &status);

++     return U_SUCCESS(status) ? dstMSecs / 1000 : 0;

++ }

++

++ // Create the system default time zone

++ QIcuTimeZonePrivate::QIcuTimeZonePrivate()

++     : m_ucal(nullptr)

++ {

++     // TODO No ICU C API to obtain system tz, assume default hasn't been changed

++     init(ucalDefaultTimeZoneId());

++ }

++

++ // Create a named time zone

++ QIcuTimeZonePrivate::QIcuTimeZonePrivate(const QByteArray &ianaId)

++     : m_ucal(nullptr)

++ {

++     // ICU misleadingly maps invalid IDs to GMT.

++     if (isTimeZoneIdAvailable(ianaId))

++         init(ianaId);

++ }

++

++ QIcuTimeZonePrivate::QIcuTimeZonePrivate(const QIcuTimeZonePrivate &other)

++     : QTimeZonePrivate(other), m_ucal(nullptr)

++ {

++     // Clone the ucal so we don't close the shared object

++     UErrorCode status = U_ZERO_ERROR;

++     m_ucal = ucal_clone(other.m_ucal, &status);

++     if (!U_SUCCESS(status)) {

++         m_id.clear();

++         m_ucal = nullptr;

++     }

++ }

++

++ QIcuTimeZonePrivate::~QIcuTimeZonePrivate()

++ {

++     ucal_close(m_ucal);

++ }

++

++ QIcuTimeZonePrivate *QIcuTimeZonePrivate::clone() const

++ {

++     return new QIcuTimeZonePrivate(*this);

++ }

++

++ void QIcuTimeZonePrivate::init(const QByteArray &ianaId)

++ {

++     m_id = ianaId;

++

++     const QString id = QString::fromUtf8(m_id);

++     UErrorCode status = U_ZERO_ERROR;

++     //TODO Use UCAL_GREGORIAN for now to match QLocale, change to UCAL_DEFAULT once full ICU support

++     m_ucal = ucal_open(reinterpret_cast<const UChar *>(id.data()), id.size(),

++                        QLocale().name().toUtf8(), UCAL_GREGORIAN, &status);

++

++     if (!U_SUCCESS(status)) {

++         m_id.clear();

++         m_ucal = nullptr;

++     }

++ }

++

++ QString QIcuTimeZonePrivate::displayName(QTimeZone::TimeType timeType,

++                                          QTimeZone::NameType nameType,

++                                          const QLocale &locale) const

++ {

++     // Base class has handled OffsetName if we came via the other overload.

++     if (nameType == QTimeZone::OffsetName) {

++         int offset = standardTimeOffset(QDateTime::currentMSecsSinceEpoch());

++         // We can't use transitions reliably to find out right DST offset.

++         // Instead use DST offset API to try to get it, when needed:

++         if (timeType == QTimeZone::DaylightTime)

++             offset += ucalDaylightOffset(m_id);

++         // This is only valid for times since the most recent standard offset

++         // change; for earlier times, caller must use the other overload.

++

++         // Use our own formating for offset names (ICU C API doesn't support it

++         // and we may as well be self-consistent anyway).

++         return isoOffsetFormat(offset);

++     }

++     // Technically this may be suspect, if locale isn't QLocale(), since that's

++     // what we used when constructing m_ucal; does ICU cope with inconsistency ?

++     using namespace QtTimeZoneLocale;

++     return ucalTimeZoneDisplayName(m_ucal, timeType, nameType, locale.name().toUtf8());

++ }

++

++ int QIcuTimeZonePrivate::offsetFromUtc(qint64 atMSecsSinceEpoch) const

++ {

++     int stdOffset = 0;

++     int dstOffset = 0;

++     ucalOffsetsAtTime(m_ucal, atMSecsSinceEpoch, &stdOffset, & dstOffset);

++     return stdOffset + dstOffset;

++ }

++

++ int QIcuTimeZonePrivate::standardTimeOffset(qint64 atMSecsSinceEpoch) const

++ {

++     int stdOffset = 0;

++     int dstOffset = 0;

++     ucalOffsetsAtTime(m_ucal, atMSecsSinceEpoch, &stdOffset, & dstOffset);

++     return stdOffset;

++ }

++

++ int QIcuTimeZonePrivate::daylightTimeOffset(qint64 atMSecsSinceEpoch) const

++ {

++     int stdOffset = 0;

++     int dstOffset = 0;

++     ucalOffsetsAtTime(m_ucal, atMSecsSinceEpoch, &stdOffset, & dstOffset);

++     return dstOffset;

++ }

++

++ bool QIcuTimeZonePrivate::hasDaylightTime() const

++ {

++     if (ucalDaylightOffset(m_id) != 0)

++         return true;

++ #if U_ICU_VERSION_MAJOR_NUM >= 50

++     for (qint64 when = minMSecs(); when != invalidMSecs(); ) {

++         auto data = nextTransition(when);

++         if (data.daylightTimeOffset && data.daylightTimeOffset != invalidSeconds())

++             return true;

++         when = data.atMSecsSinceEpoch;

++     }

++ #endif

++     return false;

++ }

++

++ bool QIcuTimeZonePrivate::isDaylightTime(qint64 atMSecsSinceEpoch) const

++ {

++     // Clone the ucal so we don't change the shared object

++     UErrorCode status = U_ZERO_ERROR;

++     UCalendar *ucal = ucal_clone(m_ucal, &status);

++     if (!U_SUCCESS(status))

++         return false;

++

++     // Set the date to find the offset for

++     status = U_ZERO_ERROR;

++     ucal_setMillis(ucal, atMSecsSinceEpoch, &status);

++

++     bool result = false;

++     if (U_SUCCESS(status)) {

++         status = U_ZERO_ERROR;

++         result = ucal_inDaylightTime(ucal, &status);

++     }

++

++     ucal_close(ucal);

++     return result;

++ }

++

++ QTimeZonePrivate::Data QIcuTimeZonePrivate::data(qint64 forMSecsSinceEpoch) const

++ {

++     // Available in ICU C++ api, and draft C api in v50

++     Data data;

++ #if U_ICU_VERSION_MAJOR_NUM >= 50

++     data = ucalTimeZoneTransition(m_ucal, UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE,

++                                   forMSecsSinceEpoch);

++     if (data.atMSecsSinceEpoch == invalidMSecs()) // before first transition

++ #endif

++     {

++         ucalOffsetsAtTime(m_ucal, forMSecsSinceEpoch, &data.standardTimeOffset,

++                           &data.daylightTimeOffset);

++         data.offsetFromUtc = data.standardTimeOffset + data.daylightTimeOffset;

++         // TODO No ICU API for abbreviation, use short name for it:

++         using namespace QtTimeZoneLocale;

++         QTimeZone::TimeType timeType

++             = data.daylightTimeOffset ? QTimeZone::DaylightTime : QTimeZone::StandardTime;

++         data.abbreviation = ucalTimeZoneDisplayName(m_ucal, timeType, QTimeZone::ShortName,

++                                                     QLocale().name().toUtf8());

++     }

++     data.atMSecsSinceEpoch = forMSecsSinceEpoch;

++     return data;

++ }

++

++ bool QIcuTimeZonePrivate::hasTransitions() const

++ {

++     // Available in ICU C++ api, and draft C api in v50

++ #if U_ICU_VERSION_MAJOR_NUM >= 50

++     return true;

++ #else

++     return false;

++ #endif

++ }

++

++ QTimeZonePrivate::Data QIcuTimeZonePrivate::nextTransition(qint64 afterMSecsSinceEpoch) const

++ {

++     // Available in ICU C++ api, and draft C api in v50

++ #if U_ICU_VERSION_MAJOR_NUM >= 50

++     return ucalTimeZoneTransition(m_ucal, UCAL_TZ_TRANSITION_NEXT, afterMSecsSinceEpoch);

++ #else

++     Q_UNUSED(afterMSecsSinceEpoch);

++     return {};

++ #endif

++ }

++

++ QTimeZonePrivate::Data QIcuTimeZonePrivate::previousTransition(qint64 beforeMSecsSinceEpoch) const

++ {

++     // Available in ICU C++ api, and draft C api in v50

++ #if U_ICU_VERSION_MAJOR_NUM >= 50

++     return ucalTimeZoneTransition(m_ucal, UCAL_TZ_TRANSITION_PREVIOUS, beforeMSecsSinceEpoch);

++ #else

++     Q_UNUSED(beforeMSecsSinceEpoch);

++     return {};

++ #endif

++ }

++

++ QByteArray QIcuTimeZonePrivate::systemTimeZoneId() const

++ {

++     // No ICU C API to obtain system tz

++     // TODO Assume default hasn't been changed and is the latests system

++     return ucalDefaultTimeZoneId();

++ }

++

++ bool QIcuTimeZonePrivate::isTimeZoneIdAvailable(QByteArrayView ianaId) const

++ {

++     return QtTimeZoneLocale::ucalKnownTimeZoneId(QString::fromUtf8(ianaId));

++ }

++

++ QList<QByteArray> QIcuTimeZonePrivate::availableTimeZoneIds() const

++ {

++     UErrorCode status = U_ZERO_ERROR;

++     UEnumeration *uenum = ucal_openTimeZones(&status);

++     // Does not document order of entries.

++     QList<QByteArray> result;

++     if (U_SUCCESS(status))

++         result = uenumToIdList(uenum); // Ensures sorted, unique.

++     uenum_close(uenum);

++     return result;

++ }

++

++ QList<QByteArray> QIcuTimeZonePrivate::availableTimeZoneIds(QLocale::Territory territory) const

++ {

++     const QLatin1StringView regionCode = QLocalePrivate::territoryToCode(territory);

++     const QByteArray regionCodeUtf8 = QString(regionCode).toUtf8();

++     UErrorCode status = U_ZERO_ERROR;

++     UEnumeration *uenum = ucal_openCountryTimeZones(regionCodeUtf8.data(), &status);

++     QList<QByteArray> result;

++     if (U_SUCCESS(status))

++         result = uenumToIdList(uenum);

++     uenum_close(uenum);

++     // We could merge in what matchingTimeZoneIds(territory) gives us, but

++     // hopefully that's redundant, as ICU packages CLDR.

++     return result;

++ }

++

++ QList<QByteArray> QIcuTimeZonePrivate::availableTimeZoneIds(int offsetFromUtc) const

++ {

++ // TODO Available directly in C++ api but not C api, from 4.8 onwards new filter method works

++ #if U_ICU_VERSION_MAJOR_NUM >= 49 || (U_ICU_VERSION_MAJOR_NUM == 4 && U_ICU_VERSION_MINOR_NUM == 8)

++     UErrorCode status = U_ZERO_ERROR;

++     UEnumeration *uenum = ucal_openTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, nullptr,

++                                                          &offsetFromUtc, &status);

++     QList<QByteArray> result;

++     if (U_SUCCESS(status))

++         result = uenumToIdList(uenum);

++     uenum_close(uenum);

++     // We could merge in what matchingTimeZoneIds(offsetFromUtc) gives us, but

++     // hopefully that's redundant, as ICU packages CLDR.

++     return result;

++ #else

++     return QTimeZonePrivate::availableTimeZoneIds(offsetFromUtc);

++ #endif

++ }

++

++ QT_END_NAMESPACE

Revision control