diff options
5 files changed, 208 insertions, 75 deletions
diff --git a/src/corelib/global/qoperatingsystemversion.cpp b/src/corelib/global/qoperatingsystemversion.cpp index 61f64306e2..cca503ffae 100644 --- a/src/corelib/global/qoperatingsystemversion.cpp +++ b/src/corelib/global/qoperatingsystemversion.cpp @@ -38,6 +38,7 @@ ****************************************************************************/ #include "qoperatingsystemversion.h" + #if !defined(Q_OS_DARWIN) && !defined(Q_OS_WIN) #include "qoperatingsystemversion_p.h" #endif @@ -145,16 +146,19 @@ QT_BEGIN_NAMESPACE */ /*! - \fn QOperatingSystemVersion QOperatingSystemVersion::current() - Returns a QOperatingSystemVersion indicating the current OS and its version number. \sa currentType() */ -#if !defined(Q_OS_DARWIN) && !defined(Q_OS_WIN) QOperatingSystemVersion QOperatingSystemVersion::current() { - QOperatingSystemVersion version; + return QOperatingSystemVersionBase::current(); +} + +#if !defined(Q_OS_DARWIN) && !defined(Q_OS_WIN) +QOperatingSystemVersionBase QOperatingSystemVersionBase::current() +{ + QOperatingSystemVersionBase version; version.m_os = currentType(); #ifdef Q_OS_ANDROID #ifndef QT_BOOTSTRAPPED @@ -231,8 +235,8 @@ static inline int compareVersionComponents(int lhs, int rhs) return lhs >= 0 && rhs >= 0 ? lhs - rhs : 0; } -int QOperatingSystemVersion::compare(const QOperatingSystemVersion &v1, - const QOperatingSystemVersion &v2) +int QOperatingSystemVersionBase::compare(QOperatingSystemVersionBase v1, + QOperatingSystemVersionBase v2) { if (v1.m_major == v2.m_major) { if (v1.m_minor == v2.m_minor) { @@ -243,6 +247,12 @@ int QOperatingSystemVersion::compare(const QOperatingSystemVersion &v1, return compareVersionComponents(v1.m_major, v2.m_major); } +int QOperatingSystemVersion::compare(const QOperatingSystemVersion &v1, + const QOperatingSystemVersion &v2) +{ + return QOperatingSystemVersionBase::compare(v1, v2); +} + /*! \fn QVersionNumber QOperatingSystemVersion::version() const @@ -331,30 +341,35 @@ int QOperatingSystemVersion::compare(const QOperatingSystemVersion &v1, */ QString QOperatingSystemVersion::name() const { - switch (type()) { - case QOperatingSystemVersion::Windows: + return QOperatingSystemVersionBase::name(); +} + +QString QOperatingSystemVersionBase::name(QOperatingSystemVersionBase osversion) +{ + switch (osversion.type()) { + case QOperatingSystemVersionBase::Windows: return QStringLiteral("Windows"); - case QOperatingSystemVersion::MacOS: { - if (majorVersion() < 10) + case QOperatingSystemVersionBase::MacOS: { + if (osversion.majorVersion() < 10) return QStringLiteral("Mac OS"); - if (majorVersion() == 10 && minorVersion() < 8) + if (osversion.majorVersion() == 10 && osversion.minorVersion() < 8) return QStringLiteral("Mac OS X"); - if (majorVersion() == 10 && minorVersion() < 12) + if (osversion.majorVersion() == 10 && osversion.minorVersion() < 12) return QStringLiteral("OS X"); return QStringLiteral("macOS"); } - case QOperatingSystemVersion::IOS: { - if (majorVersion() < 4) + case QOperatingSystemVersionBase::IOS: { + if (osversion.majorVersion() < 4) return QStringLiteral("iPhone OS"); return QStringLiteral("iOS"); } - case QOperatingSystemVersion::TvOS: + case QOperatingSystemVersionBase::TvOS: return QStringLiteral("tvOS"); - case QOperatingSystemVersion::WatchOS: + case QOperatingSystemVersionBase::WatchOS: return QStringLiteral("watchOS"); - case QOperatingSystemVersion::Android: + case QOperatingSystemVersionBase::Android: return QStringLiteral("Android"); - case QOperatingSystemVersion::Unknown: + case QOperatingSystemVersionBase::Unknown: default: return QString(); } @@ -368,11 +383,13 @@ QString QOperatingSystemVersion::name() const */ bool QOperatingSystemVersion::isAnyOfType(std::initializer_list<OSType> types) const { - for (const auto &t : qAsConst(types)) { - if (type() == t) - return true; - } - return false; + // ### Qt7: Remove this function + return std::find(types.begin(), types.end(), type()) != types.end(); +} + +bool QOperatingSystemVersionBase::isAnyOfType(std::initializer_list<OSType> types, OSType type) +{ + return std::find(types.begin(), types.end(), type) != types.end(); } /*! diff --git a/src/corelib/global/qoperatingsystemversion.h b/src/corelib/global/qoperatingsystemversion.h index c884e0e3e8..3c87dc9966 100644 --- a/src/corelib/global/qoperatingsystemversion.h +++ b/src/corelib/global/qoperatingsystemversion.h @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2021 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtCore module of the Qt Toolkit. @@ -47,9 +47,11 @@ QT_BEGIN_NAMESPACE class QString; -class Q_CORE_EXPORT QOperatingSystemVersion +class QOperatingSystemVersionBase { public: + // ### Qt 7: Keep synchronized with the copy in QOperatingSystemVersion until Qt7, + // then remove this comment :) enum OSType { Unknown = 0, Windows, @@ -60,6 +62,102 @@ public: Android }; + constexpr QOperatingSystemVersionBase(OSType osType, + int vmajor, int vminor = -1, int vmicro = -1) + : m_os(osType), + m_major(vmajor), + m_minor(vminor), + m_micro(vmicro) + { } + + static Q_CORE_EXPORT QOperatingSystemVersionBase current(); + static Q_CORE_EXPORT QString name(QOperatingSystemVersionBase osversion); + static Q_CORE_EXPORT bool isAnyOfType(std::initializer_list<OSType> types, OSType type); + + static constexpr OSType currentType() + { +#if defined(Q_OS_WIN) + return Windows; +#elif defined(Q_OS_MACOS) + return MacOS; +#elif defined(Q_OS_IOS) + return IOS; +#elif defined(Q_OS_TVOS) + return TvOS; +#elif defined(Q_OS_WATCHOS) + return WatchOS; +#elif defined(Q_OS_ANDROID) + return Android; +#else + return Unknown; +#endif + } + + inline QVersionNumber version() const { return QVersionNumber(m_major, m_minor, m_micro); } + + constexpr int majorVersion() const { return m_major; } + constexpr int minorVersion() const { return m_minor; } + constexpr int microVersion() const { return m_micro; } + + constexpr int segmentCount() const + { return m_micro >= 0 ? 3 : m_minor >= 0 ? 2 : m_major >= 0 ? 1 : 0; } + + inline bool isAnyOfType(std::initializer_list<OSType> types) const + { + return QOperatingSystemVersionBase::isAnyOfType(types, type()); + } + constexpr OSType type() const { return m_os; } + inline QString name() const { return name(*this); } + + friend bool operator>(QOperatingSystemVersionBase lhs, QOperatingSystemVersionBase rhs) + { return lhs.type() == rhs.type() && QOperatingSystemVersionBase::compare(lhs, rhs) > 0; } + + friend bool operator>=(QOperatingSystemVersionBase lhs, QOperatingSystemVersionBase rhs) + { return lhs.type() == rhs.type() && QOperatingSystemVersionBase::compare(lhs, rhs) >= 0; } + + friend bool operator<(QOperatingSystemVersionBase lhs, QOperatingSystemVersionBase rhs) + { return lhs.type() == rhs.type() && QOperatingSystemVersionBase::compare(lhs, rhs) < 0; } + + friend bool operator<=(QOperatingSystemVersionBase lhs, QOperatingSystemVersionBase rhs) + { return lhs.type() == rhs.type() && QOperatingSystemVersionBase::compare(lhs, rhs) <= 0; } + +protected: + static Q_CORE_EXPORT int compare(QOperatingSystemVersionBase v1, + QOperatingSystemVersionBase v2); + + QOperatingSystemVersionBase() = default; +private: + + + OSType m_os; + int m_major; + int m_minor; + int m_micro; +}; + +// ### Qt 7: Un-export the class, export relevant functions. Remove the enum. +class Q_CORE_EXPORT QOperatingSystemVersion : public QOperatingSystemVersionBase +{ +public: + // ### Qt7: Remove. Keep synchronized with QOperatingSystemVersionBase::OSType until then! +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) + enum OSType { + Unknown = 0, + Windows, + MacOS, + IOS, + TvOS, + WatchOS, + Android + }; +#endif + + // ### Qt7: remove the branch with static const variables. Then group and sort the inline ones. + // Since the exported variables emit symbols they cannot be cherry-picked back to patch-releases + // without breaking our BC promises. They must be fully inline but we cannot make that change + // until Qt7 + // @note: New entries should be added after the if-def-ery until Qt 7!! +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) static const QOperatingSystemVersion Windows7; static const QOperatingSystemVersion Windows8; static const QOperatingSystemVersion Windows8_1; @@ -88,69 +186,76 @@ public: static const QOperatingSystemVersion AndroidPie; static const QOperatingSystemVersion Android10; static const QOperatingSystemVersion Android11; +#else + static constexpr QOperatingSystemVersionBase Windows7 { QOperatingSystemVersionBase::Windows, 6, 1 }; + static constexpr QOperatingSystemVersionBase Windows8 { QOperatingSystemVersionBase::Windows, 6, 2 }; + static constexpr QOperatingSystemVersionBase Windows8_1 { QOperatingSystemVersionBase::Windows, 6, 3 }; + static constexpr QOperatingSystemVersionBase Windows10 { QOperatingSystemVersionBase::Windows, 10 }; - constexpr QOperatingSystemVersion(OSType osType, - int vmajor, int vminor = -1, int vmicro = -1) - : m_os(osType), - m_major(qMax(-1, vmajor)), - m_minor(vmajor < 0 ? -1 : qMax(-1, vminor)), - m_micro(vmajor < 0 || vminor < 0 ? -1 : qMax(-1, vmicro)) - { } + static constexpr QOperatingSystemVersionBase OSXMavericks { QOperatingSystemVersionBase::MacOS, 10, 9 }; + static constexpr QOperatingSystemVersionBase OSXYosemite { QOperatingSystemVersionBase::MacOS, 10, 10 }; + static constexpr QOperatingSystemVersionBase OSXElCapitan { QOperatingSystemVersionBase::MacOS, 10, 11 }; + static constexpr QOperatingSystemVersionBase MacOSSierra { QOperatingSystemVersionBase::MacOS, 10, 12 }; + static constexpr QOperatingSystemVersionBase MacOSHighSierra { QOperatingSystemVersionBase::MacOS, 10, 13 }; + static constexpr QOperatingSystemVersionBase MacOSMojave { QOperatingSystemVersionBase::MacOS, 10, 14 }; + static constexpr QOperatingSystemVersionBase MacOSCatalina { QOperatingSystemVersionBase::MacOS, 10, 15 }; +#if QT_MACOS_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_11_0) + static constexpr QOperatingSystemVersionBase MacOSBigSur = { QOperatingSystemVersionBase::MacOS, 11, 0 }; +#else // ### Qt 7: Verify the assumption +# error Either you are using an outdated SDK or my assumption that Qt7 would require at least 11.0 was wrong +#endif + + static constexpr QOperatingSystemVersionBase AndroidJellyBean { QOperatingSystemVersionBase::Android, 4, 1 }; + static constexpr QOperatingSystemVersionBase AndroidJellyBean_MR1 { QOperatingSystemVersionBase::Android, 4, 2 }; + static constexpr QOperatingSystemVersionBase AndroidJellyBean_MR2 { QOperatingSystemVersionBase::Android, 4, 3 }; + static constexpr QOperatingSystemVersionBase AndroidKitKat { QOperatingSystemVersionBase::Android, 4, 4 }; + static constexpr QOperatingSystemVersionBase AndroidLollipop { QOperatingSystemVersionBase::Android, 5, 0 }; + static constexpr QOperatingSystemVersionBase AndroidLollipop_MR1 { QOperatingSystemVersionBase::Android, 5, 1 }; + static constexpr QOperatingSystemVersionBase AndroidMarshmallow { QOperatingSystemVersionBase::Android, 6, 0 }; + static constexpr QOperatingSystemVersionBase AndroidNougat { QOperatingSystemVersionBase::Android, 7, 0 }; + static constexpr QOperatingSystemVersionBase AndroidNougat_MR1 { QOperatingSystemVersionBase::Android, 7, 1 }; + static constexpr QOperatingSystemVersionBase AndroidOreo { QOperatingSystemVersionBase::Android, 8, 0 }; + static constexpr QOperatingSystemVersionBase AndroidOreo_MR1 { QOperatingSystemVersionBase::Android, 8, 1 }; + static constexpr QOperatingSystemVersionBase AndroidPie { QOperatingSystemVersionBase::Android, 9, 0 }; + static constexpr QOperatingSystemVersionBase Android10 { QOperatingSystemVersionBase::Android, 10, 0 }; + static constexpr QOperatingSystemVersionBase Android11 { QOperatingSystemVersionBase::Android, 11, 0 }; +#endif // New (static constexpr) entries go here, only cherry-pick as far back as 6.3 (QTBUG-97808): + + constexpr QOperatingSystemVersion(const QOperatingSystemVersionBase &osversion) + : QOperatingSystemVersionBase(osversion) {} + + constexpr QOperatingSystemVersion(OSType osType, int vmajor, int vminor = -1, int vmicro = -1) + : QOperatingSystemVersionBase(QOperatingSystemVersionBase::OSType(osType), vmajor, vminor, + vmicro) + { + } static QOperatingSystemVersion current(); static constexpr OSType currentType() { -#if defined(Q_OS_WIN) - return Windows; -#elif defined(Q_OS_MACOS) - return MacOS; -#elif defined(Q_OS_IOS) - return IOS; -#elif defined(Q_OS_TVOS) - return TvOS; -#elif defined(Q_OS_WATCHOS) - return WatchOS; -#elif defined(Q_OS_ANDROID) - return Android; -#else - return Unknown; -#endif + return OSType(QOperatingSystemVersionBase::currentType()); } - QVersionNumber version() const { return QVersionNumber(m_major, m_minor, m_micro); } + QVersionNumber version() const { return QOperatingSystemVersionBase::version(); } - constexpr int majorVersion() const { return m_major; } - constexpr int minorVersion() const { return m_minor; } - constexpr int microVersion() const { return m_micro; } + constexpr int majorVersion() const { return QOperatingSystemVersionBase::majorVersion(); } + constexpr int minorVersion() const { return QOperatingSystemVersionBase::minorVersion(); } + constexpr int microVersion() const { return QOperatingSystemVersionBase::microVersion(); } constexpr int segmentCount() const - { return m_micro >= 0 ? 3 : m_minor >= 0 ? 2 : m_major >= 0 ? 1 : 0; } + { return QOperatingSystemVersionBase::segmentCount(); } + constexpr OSType type() const { return OSType(QOperatingSystemVersionBase::type()); } bool isAnyOfType(std::initializer_list<OSType> types) const; - constexpr OSType type() const { return m_os; } QString name() const; - friend bool operator>(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) - { return lhs.type() == rhs.type() && QOperatingSystemVersion::compare(lhs, rhs) > 0; } - - friend bool operator>=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) - { return lhs.type() == rhs.type() && QOperatingSystemVersion::compare(lhs, rhs) >= 0; } - - friend bool operator<(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) - { return lhs.type() == rhs.type() && QOperatingSystemVersion::compare(lhs, rhs) < 0; } - - friend bool operator<=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) - { return lhs.type() == rhs.type() && QOperatingSystemVersion::compare(lhs, rhs) <= 0; } - private: QOperatingSystemVersion() = default; - OSType m_os; - int m_major; - int m_minor; - int m_micro; - static int compare(const QOperatingSystemVersion &v1, const QOperatingSystemVersion &v2); + // ### Qt 7: Remove. It's only here for backwards compat with previous inline calls. + [[maybe_unused]] static int compare(const QOperatingSystemVersion &v1, + const QOperatingSystemVersion &v2); }; Q_DECLARE_TYPEINFO(QOperatingSystemVersion, Q_PRIMITIVE_TYPE); diff --git a/src/corelib/global/qoperatingsystemversion_darwin.mm b/src/corelib/global/qoperatingsystemversion_darwin.mm index d8b927ff5d..9ecc8ca7a7 100644 --- a/src/corelib/global/qoperatingsystemversion_darwin.mm +++ b/src/corelib/global/qoperatingsystemversion_darwin.mm @@ -42,10 +42,10 @@ QT_BEGIN_NAMESPACE -QOperatingSystemVersion QOperatingSystemVersion::current() +QOperatingSystemVersionBase QOperatingSystemVersionBase::current() { NSOperatingSystemVersion osv = NSProcessInfo.processInfo.operatingSystemVersion; - QOperatingSystemVersion v; + QOperatingSystemVersionBase v; v.m_os = currentType(); v.m_major = osv.majorVersion; v.m_minor = osv.minorVersion; diff --git a/src/corelib/global/qoperatingsystemversion_win.cpp b/src/corelib/global/qoperatingsystemversion_win.cpp index c052cd9c9e..9dc8c96105 100644 --- a/src/corelib/global/qoperatingsystemversion_win.cpp +++ b/src/corelib/global/qoperatingsystemversion_win.cpp @@ -108,10 +108,10 @@ OSVERSIONINFOEX qWindowsVersionInfo() return realResult; } -QOperatingSystemVersion QOperatingSystemVersion::current() +QOperatingSystemVersionBase QOperatingSystemVersionBase::current() { - static QOperatingSystemVersion v = [](){ - QOperatingSystemVersion v; + static QOperatingSystemVersionBase v = [](){ + QOperatingSystemVersionBase v; v.m_os = currentType(); const OSVERSIONINFOEX osv = qWindowsVersionInfo(); v.m_major = osv.dwMajorVersion; diff --git a/tests/auto/corelib/global/qoperatingsystemversion/tst_qoperatingsystemversion.cpp b/tests/auto/corelib/global/qoperatingsystemversion/tst_qoperatingsystemversion.cpp index b109666be5..d1f9279b57 100644 --- a/tests/auto/corelib/global/qoperatingsystemversion/tst_qoperatingsystemversion.cpp +++ b/tests/auto/corelib/global/qoperatingsystemversion/tst_qoperatingsystemversion.cpp @@ -40,6 +40,8 @@ private slots: void comparison_data(); void comparison(); + + void mixedComparison(); }; void tst_QOperatingSystemVersion::construction_data() @@ -177,5 +179,14 @@ void tst_QOperatingSystemVersion::comparison() QCOMPARE(lhsSystemInfo >= rhsSystemInfo, moreEqualResult); } +void tst_QOperatingSystemVersion::mixedComparison() +{ + // == + QVERIFY(QOperatingSystemVersion::Windows10 + >= QOperatingSystemVersionBase(QOperatingSystemVersionBase::Windows, 10, 0)); + QVERIFY(QOperatingSystemVersion::Windows10 + <= QOperatingSystemVersionBase(QOperatingSystemVersionBase::Windows, 10, 0)); +} + QTEST_MAIN(tst_QOperatingSystemVersion) #include "tst_qoperatingsystemversion.moc" |