include/QtCore/qversionnumber.h

0001 // Copyright (C) 2020 The Qt Company Ltd.
0002 // Copyright (C) 2022 Intel Corporation.
0003 // Copyright (C) 2015 Keith Gardner <kreios4004@gmail.com>
0004 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
0005 // Qt-Security score:critical reason:data-parser
0006
0007 #ifndef QVERSIONNUMBER_H
0008 #define QVERSIONNUMBER_H
0009
0010 #include <QtCore/qcompare.h>
0011 #include <QtCore/qcontainertools_impl.h>
0012 #include <QtCore/qlist.h>
0013 #include <QtCore/qmetatype.h>
0014 #include <QtCore/qnamespace.h>
0015 #include <QtCore/qspan.h>
0016 #include <QtCore/qstring.h>
0017 #include <QtCore/qtypeinfo.h>
0018 #if !defined(QT_LEAN_HEADERS) || QT_LEAN_HEADERS < 2
0019 #include <QtCore/qtyperevision.h>
0020 #endif // lean headers level 2
0021
0022 QT_BEGIN_NAMESPACE
0023
0024 class QVersionNumber;
0025 Q_CORE_EXPORT size_t qHash(const QVersionNumber &key, size_t seed = 0);
0026
0027 #ifndef QT_NO_DATASTREAM
0028 Q_CORE_EXPORT QDataStream &operator<<(QDataStream &out, const QVersionNumber &version);
0029 Q_CORE_EXPORT QDataStream &operator>>(QDataStream &in, QVersionNumber &version);
0030 #endif
0031
0032 class QVersionNumber
0033 {
0034     /*
0035      * QVersionNumber stores small values inline, without memory allocation.
0036      * We do that by setting the LSB in the pointer that would otherwise hold
0037      * the longer form of the segments.
0038      * The constants below help us deal with the permutations for 32- and 64-bit,
0039      * little- and big-endian architectures.
0040      */
0041     enum {
0042         // in little-endian, inline_segments[0] is shared with the pointer's LSB, while
0043         // in big-endian, it's inline_segments[7]
0044         InlineSegmentMarker = Q_BYTE_ORDER == Q_LITTLE_ENDIAN ? 0 : sizeof(void *) - 1,
0045         InlineSegmentStartIdx = !InlineSegmentMarker, // 0 for BE, 1 for LE
0046         InlineSegmentCount = sizeof(void *) - 1
0047     };
0048     static_assert(InlineSegmentCount >= 3);   // at least major, minor, micro
0049
0050     struct SegmentStorage
0051     {
0052         // Note: we alias the use of dummy and inline_segments in the use of the
0053         // union below. This is undefined behavior in C++98, but most compilers implement
0054         // the C++11 behavior. The one known exception is older versions of Sun Studio.
0055         union {
0056             quintptr dummy;
0057             qint8 inline_segments[sizeof(void *)];
0058             QList<int> *pointer_segments;
0059         };
0060
0061         // set the InlineSegmentMarker and set length to zero
0062         SegmentStorage() noexcept : dummy(1) {}
0063
0064         SegmentStorage(const QList<int> &seg)
0065         {
0066             if (dataFitsInline(seg.data(), seg.size()))
0067                 setInlineData(seg.data(), seg.size());
0068             else
0069                 setListData(seg);
0070         }
0071
0072         Q_CORE_EXPORT void setListData(const QList<int> &seg);
0073
0074         SegmentStorage(const SegmentStorage &other)
0075         {
0076             if (other.isUsingPointer())
0077                 setListData(*other.pointer_segments);
0078             else
0079                 dummy = other.dummy;
0080         }
0081
0082         SegmentStorage &operator=(const SegmentStorage &other)
0083         {
0084             if (isUsingPointer() && other.isUsingPointer()) {
0085                 *pointer_segments = *other.pointer_segments;
0086             } else if (other.isUsingPointer()) {
0087                 setListData(*other.pointer_segments);
0088             } else {
0089                 if (isUsingPointer())
0090                     delete pointer_segments;
0091                 dummy = other.dummy;
0092             }
0093             return *this;
0094         }
0095
0096         SegmentStorage(SegmentStorage &&other) noexcept
0097             : dummy(other.dummy)
0098         {
0099             other.dummy = 1;
0100         }
0101
0102         QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(SegmentStorage)
0103
0104         void swap(SegmentStorage &other) noexcept
0105         {
0106             std::swap(dummy, other.dummy);
0107         }
0108
0109         explicit SegmentStorage(QList<int> &&seg)
0110         {
0111             if (dataFitsInline(std::as_const(seg).data(), seg.size()))
0112                 setInlineData(std::as_const(seg).data(), seg.size());
0113             else
0114                 setListData(std::move(seg));
0115         }
0116
0117         Q_CORE_EXPORT void setListData(QList<int> &&seg);
0118
0119         explicit SegmentStorage(QSpan<const int> args)
0120             : SegmentStorage(args.begin(), args.end()) {}
0121
0122         explicit SegmentStorage(const int *first, const int *last)
0123         {
0124             if (dataFitsInline(first, last - first)) {
0125                 setInlineData(first, last - first);
0126             } else {
0127                 setListData(first, last);
0128             }
0129         }
0130
0131         Q_CORE_EXPORT void setListData(const int *first, const int *last);
0132
0133         ~SegmentStorage() { if (isUsingPointer()) delete pointer_segments; }
0134
0135         bool isUsingPointer() const noexcept
0136         { return (inline_segments[InlineSegmentMarker] & 1) == 0; }
0137
0138         qsizetype size() const noexcept
0139         { return isUsingPointer() ? pointer_segments->size() : (inline_segments[InlineSegmentMarker] >> 1); }
0140
0141         void setInlineSize(qsizetype len)
0142         {
0143             Q_ASSERT(len <= InlineSegmentCount);
0144             inline_segments[InlineSegmentMarker] = qint8(1 + 2 * len);
0145         }
0146
0147         Q_CORE_EXPORT void resize(qsizetype len);
0148
0149         int at(qsizetype index) const
0150         {
0151             return isUsingPointer() ?
0152                         pointer_segments->at(index) :
0153                         inline_segments[InlineSegmentStartIdx + index];
0154         }
0155
0156         void setSegments(int len, int maj, int min = 0, int mic = 0)
0157         {
0158             if (maj == qint8(maj) && min == qint8(min) && mic == qint8(mic)) {
0159                 int data[] = { maj, min, mic };
0160                 setInlineData(data, len);
0161             } else {
0162                 setVector(len, maj, min, mic);
0163             }
0164         }
0165
0166     private:
0167         static bool dataFitsInline(const int *data, qsizetype len)
0168         {
0169             if (len > InlineSegmentCount)
0170                 return false;
0171             for (qsizetype i = 0; i < len; ++i)
0172                 if (data[i] != qint8(data[i]))
0173                     return false;
0174             return true;
0175         }
0176         void setInlineData(const int *data, qsizetype len)
0177         {
0178             Q_ASSERT(len <= InlineSegmentCount);
0179             dummy = 1 + len * 2;
0180 #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
0181             for (qsizetype i = 0; i < len; ++i)
0182                 dummy |= quintptr(data[i] & 0xFF) << (8 * (i + 1));
0183 #elif Q_BYTE_ORDER == Q_BIG_ENDIAN
0184             for (qsizetype i = 0; i < len; ++i)
0185                 dummy |= quintptr(data[i] & 0xFF) << (8 * (sizeof(void *) - i - 1));
0186 #else
0187             // the code above is equivalent to:
0188             setInlineSize(len);
0189             for (qsizetype i = 0; i < len; ++i)
0190                 inline_segments[InlineSegmentStartIdx + i] = data[i] & 0xFF;
0191 #endif
0192         }
0193
0194         Q_CORE_EXPORT void setVector(int len, int maj, int min, int mic);
0195     } m_segments;
0196
0197     class It
0198     {
0199         const QVersionNumber *v;
0200         qsizetype i;
0201
0202         friend class QVersionNumber;
0203         explicit constexpr It(const QVersionNumber *vn, qsizetype idx) noexcept : v(vn), i(idx) {}
0204
0205         friend constexpr bool comparesEqual(const It &lhs, const It &rhs)
0206         { Q_ASSERT(lhs.v == rhs.v); return lhs.i == rhs.i; }
0207         friend constexpr Qt::strong_ordering compareThreeWay(const It &lhs, const It &rhs)
0208         { Q_ASSERT(lhs.v == rhs.v); return Qt::compareThreeWay(lhs.i, rhs.i); }
0209         // macro variant does not exist: Q_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_NON_NOEXCEPT(It)
0210         friend constexpr bool operator==(It lhs, It rhs) {
0211             return comparesEqual(lhs, rhs);
0212         }
0213 #ifdef __cpp_lib_three_way_comparison
0214         friend constexpr std::strong_ordering operator<=>(It lhs, It rhs) {
0215             return compareThreeWay(lhs, rhs);
0216         }
0217 #else
0218         friend constexpr bool operator!=(It lhs, It rhs) {
0219             return !operator==(lhs, rhs);
0220         }
0221         friend constexpr bool operator<(It lhs, It rhs) {
0222             return is_lt(compareThreeWay(lhs, rhs));
0223         }
0224         friend constexpr bool operator<=(It lhs, It rhs) {
0225             return is_lteq(compareThreeWay(lhs, rhs));
0226         }
0227         friend constexpr bool operator>(It lhs, It rhs) {
0228             return is_gt(compareThreeWay(lhs, rhs));
0229         }
0230         friend constexpr bool operator>=(It lhs, It rhs) {
0231             return is_gteq(compareThreeWay(lhs, rhs));
0232         }
0233 #endif
0234
0235     public:
0236         // Rule Of Zero applies
0237         It() = default;
0238
0239         using iterator_category = std::random_access_iterator_tag;
0240         using value_type = int;
0241 #ifdef QT_COMPILER_HAS_LWG3346
0242         using element_type = const int;
0243 #endif
0244         using difference_type = qptrdiff; // difference to container requirements
0245         using size_type = qsizetype;      // difference to container requirements
0246         using reference = value_type;     // difference to container requirements
0247         using pointer = QtPrivate::ArrowProxy<reference>;
0248
0249         reference operator*() const { return v->segmentAt(i); }
0250         pointer operator->() const { return {**this}; }
0251
0252         It &operator++() { ++i; return *this; }
0253         It operator++(int) { auto copy = *this; ++*this; return copy; }
0254
0255         It &operator--() { --i; return *this; }
0256         It operator--(int) { auto copy = *this; --*this; return copy; }
0257
0258         It &operator+=(difference_type n) { i += n; return *this; }
0259         friend It operator+(It it, difference_type n) { it += n; return it; }
0260         friend It operator+(difference_type n, It it) { return it + n; }
0261
0262         It &operator-=(difference_type n) { i -= n; return *this; }
0263         friend It operator-(It it, difference_type n) { it -= n; return it; }
0264
0265         friend difference_type operator-(It lhs, It rhs)
0266         { Q_ASSERT(lhs.v == rhs.v); return lhs.i - rhs.i; }
0267
0268         reference operator[](difference_type n) const { return *(*this + n); }
0269     };
0270
0271 public:
0272     using const_iterator = It;
0273     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
0274
0275     using value_type = It::value_type;
0276     using difference_type = It::difference_type;
0277     using size_type = It::size_type;
0278     using reference = It::reference;
0279     using const_reference = reference;
0280     using pointer = It::pointer;
0281     using const_pointer = pointer;
0282
0283     inline QVersionNumber() noexcept
0284         : m_segments()
0285     {}
0286     Q_WEAK_OVERLOAD
0287     inline explicit QVersionNumber(const QList<int> &seg) : m_segments(seg) { }
0288
0289     // compiler-generated copy/move ctor/assignment operators and the destructor are ok
0290
0291     Q_WEAK_OVERLOAD
0292     explicit QVersionNumber(QList<int> &&seg) : m_segments(std::move(seg)) { }
0293
0294     inline QVersionNumber(std::initializer_list<int> args)
0295         : m_segments(QSpan{args})
0296     {}
0297
0298     explicit QVersionNumber(QSpan<const int> args)
0299         : m_segments(args)
0300     {}
0301
0302     inline explicit QVersionNumber(int maj)
0303     { m_segments.setSegments(1, maj); }
0304
0305     inline explicit QVersionNumber(int maj, int min)
0306     { m_segments.setSegments(2, maj, min); }
0307
0308     inline explicit QVersionNumber(int maj, int min, int mic)
0309     { m_segments.setSegments(3, maj, min, mic); }
0310
0311     [[nodiscard]] inline bool isNull() const noexcept
0312     { return segmentCount() == 0; }
0313
0314     [[nodiscard]] inline bool isNormalized() const noexcept
0315     { return isNull() || segmentAt(segmentCount() - 1) != 0; }
0316
0317     [[nodiscard]] inline int majorVersion() const noexcept
0318     { return segmentAt(0); }
0319
0320     [[nodiscard]] inline int minorVersion() const noexcept
0321     { return segmentAt(1); }
0322
0323     [[nodiscard]] inline int microVersion() const noexcept
0324     { return segmentAt(2); }
0325
0326     [[nodiscard]] Q_CORE_EXPORT QVersionNumber normalized() const;
0327
0328     [[nodiscard]] Q_CORE_EXPORT QList<int> segments() const;
0329
0330     [[nodiscard]] inline int segmentAt(qsizetype index) const noexcept
0331     { return (m_segments.size() > index) ? m_segments.at(index) : 0; }
0332
0333     [[nodiscard]] inline qsizetype segmentCount() const noexcept
0334     { return m_segments.size(); }
0335
0336     [[nodiscard]] const_iterator begin()  const noexcept { return const_iterator{this, 0}; }
0337     [[nodiscard]] const_iterator end()    const noexcept { return begin() + segmentCount(); }
0338     [[nodiscard]] const_iterator cbegin() const noexcept { return begin(); }
0339     [[nodiscard]] const_iterator cend()   const noexcept { return end(); }
0340
0341     [[nodiscard]] const_reverse_iterator rbegin()  const noexcept { return const_reverse_iterator{end()}; }
0342     [[nodiscard]] const_reverse_iterator rend()    const noexcept { return const_reverse_iterator{begin()}; }
0343     [[nodiscard]] const_reverse_iterator crbegin() const noexcept { return rbegin(); }
0344     [[nodiscard]] const_reverse_iterator crend()   const noexcept { return rend(); }
0345
0346     [[nodiscard]] const_iterator constBegin() const noexcept { return begin(); }
0347     [[nodiscard]] const_iterator constEnd() const noexcept { return end(); }
0348
0349     [[nodiscard]] Q_CORE_EXPORT bool isPrefixOf(const QVersionNumber &other) const noexcept;
0350
0351     [[nodiscard]] Q_CORE_EXPORT static int compare(const QVersionNumber &v1, const QVersionNumber &v2) noexcept;
0352
0353     [[nodiscard]] Q_CORE_EXPORT static QVersionNumber commonPrefix(const QVersionNumber &v1, const QVersionNumber &v2);
0354
0355     [[nodiscard]] Q_CORE_EXPORT QString toString() const;
0356     [[nodiscard]] Q_CORE_EXPORT static QVersionNumber fromString(QAnyStringView string, qsizetype *suffixIndex = nullptr);
0357
0358 #if QT_DEPRECATED_SINCE(6, 4) && QT_POINTER_SIZE != 4
0359     Q_WEAK_OVERLOAD
0360     QT_DEPRECATED_VERSION_X_6_4("Use the 'qsizetype *suffixIndex' overload.")
0361     [[nodiscard]] static QVersionNumber fromString(QAnyStringView string, int *suffixIndex)
0362     {
0363         QT_WARNING_PUSH
0364         // fromString() writes to *n unconditionally, but GCC can't know that
0365         QT_WARNING_DISABLE_GCC("-Wmaybe-uninitialized")
0366         qsizetype n;
0367         auto r = fromString(string, &n);
0368         if (suffixIndex) {
0369             Q_ASSERT(int(n) == n);
0370             *suffixIndex = int(n);
0371         }
0372         return r;
0373         QT_WARNING_POP
0374     }
0375 #endif
0376
0377
0378 #if QT_CORE_REMOVED_SINCE(6, 4)
0379     [[nodiscard]] Q_CORE_EXPORT static QVersionNumber fromString(const QString &string, int *suffixIndex);
0380     [[nodiscard]] Q_CORE_EXPORT static QVersionNumber fromString(QLatin1StringView string, int *suffixIndex);
0381     [[nodiscard]] Q_CORE_EXPORT static QVersionNumber fromString(QStringView string, int *suffixIndex);
0382 #endif
0383
0384 private:
0385     [[nodiscard]] friend bool comparesEqual(const QVersionNumber &lhs,
0386                                             const QVersionNumber &rhs) noexcept
0387     {
0388         return lhs.segmentCount() == rhs.segmentCount() && compare(lhs, rhs) == 0;
0389     }
0390     [[nodiscard]] friend Qt::strong_ordering compareThreeWay(const QVersionNumber &lhs,
0391                                                              const QVersionNumber &rhs) noexcept
0392     {
0393         int c = compare(lhs, rhs);
0394         return Qt::compareThreeWay(c, 0);
0395     }
0396     Q_DECLARE_STRONGLY_ORDERED(QVersionNumber)
0397
0398 #ifndef QT_NO_DATASTREAM
0399     friend Q_CORE_EXPORT QDataStream& operator>>(QDataStream &in, QVersionNumber &version);
0400 #endif
0401     friend Q_CORE_EXPORT size_t qHash(const QVersionNumber &key, size_t seed);
0402 };
0403
0404 Q_DECLARE_TYPEINFO(QVersionNumber, Q_RELOCATABLE_TYPE);
0405
0406 #ifndef QT_NO_DEBUG_STREAM
0407 Q_CORE_EXPORT QDebug operator<<(QDebug, const QVersionNumber &version);
0408 #endif
0409
0410 QT_END_NAMESPACE
0411
0412 QT_DECL_METATYPE_EXTERN(QVersionNumber, Q_CORE_EXPORT)
0413
0414 #endif // QVERSIONNUMBER_H