Revision control
++ // Copyright (C) 2017 The Qt Company Ltd.
++ // Copyright (C) 2013 John Layt <jlayt@kde.org>
++ // 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
++
++ #ifndef QTIMEZONE_H
++ #define QTIMEZONE_H
++
++ #include <QtCore/qcompare.h>
++ #include <QtCore/qdatetime.h>
++ #include <QtCore/qlocale.h>
++ #include <QtCore/qswap.h>
++ #include <QtCore/qtclasshelpermacros.h>
++
++ #include <chrono>
++
++ #if QT_CONFIG(timezone) && (defined(Q_OS_DARWIN) || defined(Q_QDOC))
++ Q_FORWARD_DECLARE_CF_TYPE(CFTimeZone);
++ Q_FORWARD_DECLARE_OBJC_CLASS(NSTimeZone);
++ #endif
++
++ QT_BEGIN_NAMESPACE
++
++ class QTimeZonePrivate;
++
++ class Q_CORE_EXPORT QTimeZone
++ {
++ struct ShortData
++ {
++ #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
++ quintptr mode : 2;
++ #endif
++ qintptr offset : sizeof(void *) * 8 - 2;
++
++ #if Q_BYTE_ORDER == Q_BIG_ENDIAN
++ quintptr mode : 2;
++ #endif
++
++ // mode is a cycled Qt::TimeSpec, (int(spec) + 1) % 4, so that zero
++ // (lowest bits of a pointer) matches spec being Qt::TimeZone, for which
++ // Data holds a QTZP pointer instead of ShortData.
++ // Passing Qt::TimeZone gets the equivalent of a null QTZP; it is not short.
++ constexpr ShortData(Qt::TimeSpec spec, int secondsAhead = 0)
++ #if Q_BYTE_ORDER == Q_BIG_ENDIAN
++ : offset(spec == Qt::OffsetFromUTC ? secondsAhead : 0),
++ mode((int(spec) + 1) & 3)
++ #else
++ : mode((int(spec) + 1) & 3),
++ offset(spec == Qt::OffsetFromUTC ? secondsAhead : 0)
++ #endif
++ {
++ }
++ friend constexpr bool operator==(ShortData lhs, ShortData rhs)
++ { return lhs.mode == rhs.mode && lhs.offset == rhs.offset; }
++ constexpr Qt::TimeSpec spec() const { return Qt::TimeSpec((mode + 3) & 3); }
++ };
++
++ union Data
++ {
++ Data() noexcept;
++ Data(ShortData sd) : s(sd) {}
++ Data(const Data &other) noexcept;
++ Data(Data &&other) noexcept : d(std::exchange(other.d, nullptr)) {}
++ Data &operator=(const Data &other) noexcept;
++ Data &operator=(Data &&other) noexcept { swap(other); return *this; }
++ ~Data();
++
++ void swap(Data &other) noexcept { qt_ptr_swap(d, other.d); }
++ // isShort() is equivalent to s.spec() != Qt::TimeZone
++ bool isShort() const { return s.mode; } // a.k.a. quintptr(d) & 3
++
++ // Typse must support: out << wrap("C-strings");
++ template <typename Stream, typename Wrap>
++ void serialize(Stream &out, const Wrap &wrap) const;
++
++ Data(QTimeZonePrivate *dptr) noexcept;
++ Data &operator=(QTimeZonePrivate *dptr) noexcept;
++ const QTimeZonePrivate *operator->() const { Q_ASSERT(!isShort()); return d; }
++ QTimeZonePrivate *operator->() { Q_ASSERT(!isShort()); return d; }
++
++ QTimeZonePrivate *d = nullptr;
++ ShortData s;
++ };
++
++ friend class QTypeInfo<Data>;
++
++ QTimeZone(ShortData sd) : d(sd) {}
++ QTimeZone(Qt::TimeSpec) Q_DECL_EQ_DELETE_X(
++ "Would be treated as int offsetSeconds. "
++ "Use QTimeZone::UTC or QTimeZone::LocalTime instead.");
++
++ public:
++ // Sane UTC offsets range from -16 to +16 hours:
++ static constexpr int MinUtcOffsetSecs = -16 * 3600;
++ // No known modern zone > 12 hrs West of Greenwich.
++ // Until 1844, Asia/Manila (in The Philippines) was at 15:56 West.
++ static constexpr int MaxUtcOffsetSecs = +16 * 3600;
++ // No known modern zone > 14 hrs East of Greenwich.
++ // Until 1867, America/Metlakatla (in Alaska) was at 15:13:42 East.
++
++ enum Initialization { LocalTime, UTC };
++
++ QTimeZone() noexcept;
++ Q_IMPLICIT QTimeZone(Initialization spec) noexcept
++ : d(ShortData(spec == UTC ? Qt::UTC : Qt::LocalTime)) {}
++
++ #if QT_CONFIG(timezone)
++ explicit QTimeZone(int offsetSeconds);
++ explicit QTimeZone(const QByteArray &ianaId);
++ QTimeZone(const QByteArray &zoneId, int offsetSeconds, const QString &name,
++ const QString &abbreviation, QLocale::Territory territory = QLocale::AnyTerritory,
++ const QString &comment = QString());
++ #endif // timezone backends
++
++ QTimeZone(const QTimeZone &other) noexcept;
++ QTimeZone(QTimeZone &&other) noexcept : d(std::move(other.d)) {}
++ ~QTimeZone();
++
++ QTimeZone &operator=(const QTimeZone &other);
++ QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(QTimeZone)
++
++ void swap(QTimeZone &other) noexcept
++ { d.swap(other.d); }
++
++ #if QT_CORE_REMOVED_SINCE(6, 7)
++ bool operator==(const QTimeZone &other) const;
++ bool operator!=(const QTimeZone &other) const;
++ #endif
++
++ bool isValid() const;
++
++ static QTimeZone fromDurationAheadOfUtc(std::chrono::seconds offset)
++ {
++ return QTimeZone((offset.count() >= MinUtcOffsetSecs && offset.count() <= MaxUtcOffsetSecs)
++ ? ShortData(offset.count() ? Qt::OffsetFromUTC : Qt::UTC,
++ int(offset.count()))
++ : ShortData(Qt::TimeZone));
++ }
++ static QTimeZone fromSecondsAheadOfUtc(int offset)
++ {
++ return fromDurationAheadOfUtc(std::chrono::seconds{offset});
++ }
++ constexpr Qt::TimeSpec timeSpec() const noexcept { return d.s.spec(); }
++ constexpr int fixedSecondsAheadOfUtc() const noexcept
++ { return timeSpec() == Qt::OffsetFromUTC ? int(d.s.offset) : 0; }
++
++ static constexpr bool isUtcOrFixedOffset(Qt::TimeSpec spec) noexcept
++ { return spec == Qt::UTC || spec == Qt::OffsetFromUTC; }
++ constexpr bool isUtcOrFixedOffset() const noexcept { return isUtcOrFixedOffset(timeSpec()); }
++
++ #if QT_CONFIG(timezone)
++ QTimeZone asBackendZone() const;
++
++ enum TimeType {
++ StandardTime = 0,
++ DaylightTime = 1,
++ GenericTime = 2
++ };
++
++ enum NameType {
++ DefaultName = 0,
++ LongName = 1,
++ ShortName = 2,
++ OffsetName = 3
++ };
++
++ struct OffsetData {
++ QString abbreviation;
++ QDateTime atUtc;
++ int offsetFromUtc;
++ int standardTimeOffset;
++ int daylightTimeOffset;
++ };
++ typedef QList<OffsetData> OffsetDataList;
++
++ bool hasAlternativeName(QByteArrayView alias) const;
++ QByteArray id() const;
++ QLocale::Territory territory() const;
++ # if QT_DEPRECATED_SINCE(6, 6)
++ QT_DEPRECATED_VERSION_X_6_6("Use territory() instead")
++ QLocale::Country country() const;
++ # endif
++ QString comment() const;
++
++ QString displayName(const QDateTime &atDateTime, NameType nameType = DefaultName,
++ const QLocale &locale = QLocale()) const;
++ QString displayName(TimeType timeType, NameType nameType = DefaultName,
++ const QLocale &locale = QLocale()) const;
++ QString abbreviation(const QDateTime &atDateTime) const;
++
++ int offsetFromUtc(const QDateTime &atDateTime) const;
++ int standardTimeOffset(const QDateTime &atDateTime) const;
++ int daylightTimeOffset(const QDateTime &atDateTime) const;
++
++ bool hasDaylightTime() const;
++ bool isDaylightTime(const QDateTime &atDateTime) const;
++
++ OffsetData offsetData(const QDateTime &forDateTime) const;
++
++ bool hasTransitions() const;
++ OffsetData nextTransition(const QDateTime &afterDateTime) const;
++ OffsetData previousTransition(const QDateTime &beforeDateTime) const;
++ OffsetDataList transitions(const QDateTime &fromDateTime, const QDateTime &toDateTime) const;
++
++ static QByteArray systemTimeZoneId();
++ static QTimeZone systemTimeZone();
++ static QTimeZone utc();
++
++ #if QT_CORE_REMOVED_SINCE(6, 12)
++ static bool isTimeZoneIdAvailable(const QByteArray &ianaId);
++ #endif
++ static bool isTimeZoneIdAvailable(QByteArrayView ianaId);
++
++ static QList<QByteArray> availableTimeZoneIds();
++ static QList<QByteArray> availableTimeZoneIds(QLocale::Territory territory);
++ static QList<QByteArray> availableTimeZoneIds(int offsetSeconds);
++
++ static QByteArray ianaIdToWindowsId(const QByteArray &ianaId);
++ static QByteArray windowsIdToDefaultIanaId(const QByteArray &windowsId);
++ static QByteArray windowsIdToDefaultIanaId(const QByteArray &windowsId,
++ QLocale::Territory territory);
++ static QList<QByteArray> windowsIdToIanaIds(const QByteArray &windowsId);
++ static QList<QByteArray> windowsIdToIanaIds(const QByteArray &windowsId,
++ QLocale::Territory territory);
++
++ # if defined(Q_OS_DARWIN) || defined(Q_QDOC)
++ static QTimeZone fromCFTimeZone(CFTimeZoneRef timeZone);
++ CFTimeZoneRef toCFTimeZone() const Q_DECL_CF_RETURNS_RETAINED;
++ static QTimeZone fromNSTimeZone(const NSTimeZone *timeZone);
++ NSTimeZone *toNSTimeZone() const Q_DECL_NS_RETURNS_AUTORELEASED;
++ # endif
++
++ # if __cpp_lib_chrono >= 201907L || defined(Q_QDOC)
++ QT_POST_CXX17_API_IN_EXPORTED_CLASS
++ static QTimeZone fromStdTimeZonePtr(const std::chrono::time_zone *timeZone)
++ {
++ if (!timeZone)
++ return QTimeZone();
++ const std::string_view timeZoneName = timeZone->name();
++ return QTimeZone(QByteArrayView(timeZoneName).toByteArray());
++ }
++ # endif
++ #endif // feature timezone
++ private:
++ friend Q_CORE_EXPORT bool comparesEqual(const QTimeZone &lhs, const QTimeZone &rhs) noexcept;
++ Q_DECLARE_EQUALITY_COMPARABLE(QTimeZone)
++
++ #ifndef QT_NO_DATASTREAM
++ friend Q_CORE_EXPORT QDataStream &operator<<(QDataStream &ds, const QTimeZone &tz);
++ #endif
++ #ifndef QT_NO_DEBUG_STREAM
++ friend Q_CORE_EXPORT QDebug operator<<(QDebug dbg, const QTimeZone &tz);
++ #endif
++ QTimeZone(QTimeZonePrivate &dd);
++ friend class QTimeZonePrivate;
++ friend class QDateTime;
++ friend class QDateTimePrivate;
++ Data d;
++ };
++
++ #if QT_CONFIG(timezone)
++ Q_DECLARE_TYPEINFO(QTimeZone::OffsetData, Q_RELOCATABLE_TYPE);
++ #endif
++
++ Q_DECLARE_TYPEINFO(QTimeZone::Data, Q_RELOCATABLE_TYPE);
++ Q_DECLARE_SHARED(QTimeZone)
++
++ #ifndef QT_NO_DATASTREAM
++ Q_CORE_EXPORT QDataStream &operator<<(QDataStream &ds, const QTimeZone &tz);
++ Q_CORE_EXPORT QDataStream &operator>>(QDataStream &ds, QTimeZone &tz);
++ #endif
++
++ #ifndef QT_NO_DEBUG_STREAM
++ Q_CORE_EXPORT QDebug operator<<(QDebug dbg, const QTimeZone &tz);
++ #endif
++
++ #if QT_CONFIG(timezone) && __cpp_lib_chrono >= 201907L
++ // zoned_time
++ template <typename> // QT_POST_CXX17_API_IN_EXPORTED_CLASS
++ inline QDateTime QDateTime::fromStdZonedTime(const std::chrono::zoned_time<
++ std::chrono::milliseconds,
++ const std::chrono::time_zone *
++ > &time)
++ {
++ const auto sysTime = time.get_sys_time();
++ const QTimeZone timeZone = QTimeZone::fromStdTimeZonePtr(time.get_time_zone());
++ return fromMSecsSinceEpoch(sysTime.time_since_epoch().count(), timeZone);
++ }
++ #endif
++
++ QT_END_NAMESPACE
++
++ #endif // QTIMEZONE_H