Revision control
++ // Copyright (C) 2020 The Qt Company Ltd.
++ // Copyright (C) 2022 Intel Corporation.
++ // Copyright (C) 2015 Keith Gardner <kreios4004@gmail.com>
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:critical reason:data-parser
++
++ #ifndef QVERSIONNUMBER_H
++ #define QVERSIONNUMBER_H
++
++ #include <QtCore/qcompare.h>
++ #include <QtCore/qcontainertools_impl.h>
++ #include <QtCore/qlist.h>
++ #include <QtCore/qmetatype.h>
++ #include <QtCore/qnamespace.h>
++ #include <QtCore/qspan.h>
++ #include <QtCore/qstring.h>
++ #include <QtCore/qtypeinfo.h>
++ #if !defined(QT_LEAN_HEADERS) || QT_LEAN_HEADERS < 2
++ #include <QtCore/qtyperevision.h>
++ #endif // lean headers level 2
++
++ QT_BEGIN_NAMESPACE
++
++ class QVersionNumber;
++ Q_CORE_EXPORT size_t qHash(const QVersionNumber &key, size_t seed = 0);
++
++ #ifndef QT_NO_DATASTREAM
++ Q_CORE_EXPORT QDataStream &operator<<(QDataStream &out, const QVersionNumber &version);
++ Q_CORE_EXPORT QDataStream &operator>>(QDataStream &in, QVersionNumber &version);
++ #endif
++
++ class QVersionNumber
++ {
++ /*
++ * QVersionNumber stores small values inline, without memory allocation.
++ * We do that by setting the LSB in the pointer that would otherwise hold
++ * the longer form of the segments.
++ * The constants below help us deal with the permutations for 32- and 64-bit,
++ * little- and big-endian architectures.
++ */
++ enum {
++ // in little-endian, inline_segments[0] is shared with the pointer's LSB, while
++ // in big-endian, it's inline_segments[7]
++ InlineSegmentMarker = Q_BYTE_ORDER == Q_LITTLE_ENDIAN ? 0 : sizeof(void *) - 1,
++ InlineSegmentStartIdx = !InlineSegmentMarker, // 0 for BE, 1 for LE
++ InlineSegmentCount = sizeof(void *) - 1
++ };
++ static_assert(InlineSegmentCount >= 3); // at least major, minor, micro
++
++ struct SegmentStorage
++ {
++ // Note: we alias the use of dummy and inline_segments in the use of the
++ // union below. This is undefined behavior in C++98, but most compilers implement
++ // the C++11 behavior. The one known exception is older versions of Sun Studio.
++ union {
++ quintptr dummy;
++ qint8 inline_segments[sizeof(void *)];
++ QList<int> *pointer_segments;
++ };
++
++ // set the InlineSegmentMarker and set length to zero
++ SegmentStorage() noexcept : dummy(1) {}
++
++ SegmentStorage(const QList<int> &seg)
++ {
++ if (dataFitsInline(seg.data(), seg.size()))
++ setInlineData(seg.data(), seg.size());
++ else
++ setListData(seg);
++ }
++
++ Q_CORE_EXPORT void setListData(const QList<int> &seg);
++
++ SegmentStorage(const SegmentStorage &other)
++ {
++ if (other.isUsingPointer())
++ setListData(*other.pointer_segments);
++ else
++ dummy = other.dummy;
++ }
++
++ SegmentStorage &operator=(const SegmentStorage &other)
++ {
++ if (isUsingPointer() && other.isUsingPointer()) {
++ *pointer_segments = *other.pointer_segments;
++ } else if (other.isUsingPointer()) {
++ setListData(*other.pointer_segments);
++ } else {
++ if (isUsingPointer())
++ delete pointer_segments;
++ dummy = other.dummy;
++ }
++ return *this;
++ }
++
++ SegmentStorage(SegmentStorage &&other) noexcept
++ : dummy(other.dummy)
++ {
++ other.dummy = 1;
++ }
++
++ QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(SegmentStorage)
++
++ void swap(SegmentStorage &other) noexcept
++ {
++ std::swap(dummy, other.dummy);
++ }
++
++ explicit SegmentStorage(QList<int> &&seg)
++ {
++ if (dataFitsInline(std::as_const(seg).data(), seg.size()))
++ setInlineData(std::as_const(seg).data(), seg.size());
++ else
++ setListData(std::move(seg));
++ }
++
++ Q_CORE_EXPORT void setListData(QList<int> &&seg);
++
++ explicit SegmentStorage(QSpan<const int> args)
++ : SegmentStorage(args.begin(), args.end()) {}
++
++ explicit SegmentStorage(const int *first, const int *last)
++ {
++ if (dataFitsInline(first, last - first)) {
++ setInlineData(first, last - first);
++ } else {
++ setListData(first, last);
++ }
++ }
++
++ Q_CORE_EXPORT void setListData(const int *first, const int *last);
++
++ ~SegmentStorage() { if (isUsingPointer()) delete pointer_segments; }
++
++ bool isUsingPointer() const noexcept
++ { return (inline_segments[InlineSegmentMarker] & 1) == 0; }
++
++ qsizetype size() const noexcept
++ { return isUsingPointer() ? pointer_segments->size() : (inline_segments[InlineSegmentMarker] >> 1); }
++
++ void setInlineSize(qsizetype len)
++ {
++ Q_ASSERT(len <= InlineSegmentCount);
++ inline_segments[InlineSegmentMarker] = qint8(1 + 2 * len);
++ }
++
++ Q_CORE_EXPORT void resize(qsizetype len);
++
++ int at(qsizetype index) const
++ {
++ return isUsingPointer() ?
++ pointer_segments->at(index) :
++ inline_segments[InlineSegmentStartIdx + index];
++ }
++
++ void setSegments(int len, int maj, int min = 0, int mic = 0)
++ {
++ if (maj == qint8(maj) && min == qint8(min) && mic == qint8(mic)) {
++ int data[] = { maj, min, mic };
++ setInlineData(data, len);
++ } else {
++ setVector(len, maj, min, mic);
++ }
++ }
++
++ private:
++ static bool dataFitsInline(const int *data, qsizetype len)
++ {
++ if (len > InlineSegmentCount)
++ return false;
++ for (qsizetype i = 0; i < len; ++i)
++ if (data[i] != qint8(data[i]))
++ return false;
++ return true;
++ }
++ void setInlineData(const int *data, qsizetype len)
++ {
++ Q_ASSERT(len <= InlineSegmentCount);
++ dummy = 1 + len * 2;
++ #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
++ for (qsizetype i = 0; i < len; ++i)
++ dummy |= quintptr(data[i] & 0xFF) << (8 * (i + 1));
++ #elif Q_BYTE_ORDER == Q_BIG_ENDIAN
++ for (qsizetype i = 0; i < len; ++i)
++ dummy |= quintptr(data[i] & 0xFF) << (8 * (sizeof(void *) - i - 1));
++ #else
++ // the code above is equivalent to:
++ setInlineSize(len);
++ for (qsizetype i = 0; i < len; ++i)
++ inline_segments[InlineSegmentStartIdx + i] = data[i] & 0xFF;
++ #endif
++ }
++
++ Q_CORE_EXPORT void setVector(int len, int maj, int min, int mic);
++ } m_segments;
++
++ friend class QTypeInfo<SegmentStorage>;
++
++ class It
++ {
++ const QVersionNumber *v;
++ qsizetype i;
++
++ friend class QVersionNumber;
++ explicit constexpr It(const QVersionNumber *vn, qsizetype idx) noexcept : v(vn), i(idx) {}
++
++ friend constexpr bool comparesEqual(const It &lhs, const It &rhs)
++ { Q_ASSERT(lhs.v == rhs.v); return lhs.i == rhs.i; }
++ friend constexpr Qt::strong_ordering compareThreeWay(const It &lhs, const It &rhs)
++ { Q_ASSERT(lhs.v == rhs.v); return Qt::compareThreeWay(lhs.i, rhs.i); }
++ // macro variant does not exist: Q_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_NON_NOEXCEPT(It)
++ friend constexpr bool operator==(It lhs, It rhs) {
++ return comparesEqual(lhs, rhs);
++ }
++ #ifdef __cpp_lib_three_way_comparison
++ friend constexpr std::strong_ordering operator<=>(It lhs, It rhs) {
++ return compareThreeWay(lhs, rhs);
++ }
++ #else
++ friend constexpr bool operator!=(It lhs, It rhs) {
++ return !operator==(lhs, rhs);
++ }
++ friend constexpr bool operator<(It lhs, It rhs) {
++ return is_lt(compareThreeWay(lhs, rhs));
++ }
++ friend constexpr bool operator<=(It lhs, It rhs) {
++ return is_lteq(compareThreeWay(lhs, rhs));
++ }
++ friend constexpr bool operator>(It lhs, It rhs) {
++ return is_gt(compareThreeWay(lhs, rhs));
++ }
++ friend constexpr bool operator>=(It lhs, It rhs) {
++ return is_gteq(compareThreeWay(lhs, rhs));
++ }
++ #endif
++
++ public:
++ // Rule Of Zero applies
++ It() = default;
++
++ using iterator_category = std::random_access_iterator_tag;
++ using value_type = int;
++ #ifdef QT_COMPILER_HAS_LWG3346
++ using element_type = const int;
++ #endif
++ using difference_type = qptrdiff; // difference to container requirements
++ using size_type = qsizetype; // difference to container requirements
++ using reference = value_type; // difference to container requirements
++ using pointer = QtPrivate::ArrowProxy<reference>;
++
++ reference operator*() const { return v->segmentAt(i); }
++ pointer operator->() const { return {**this}; }
++
++ It &operator++() { ++i; return *this; }
++ It operator++(int) { auto copy = *this; ++*this; return copy; }
++
++ It &operator--() { --i; return *this; }
++ It operator--(int) { auto copy = *this; --*this; return copy; }
++
++ It &operator+=(difference_type n) { i += n; return *this; }
++ friend It operator+(It it, difference_type n) { it += n; return it; }
++ friend It operator+(difference_type n, It it) { return it + n; }
++
++ It &operator-=(difference_type n) { i -= n; return *this; }
++ friend It operator-(It it, difference_type n) { it -= n; return it; }
++
++ friend difference_type operator-(It lhs, It rhs)
++ { Q_ASSERT(lhs.v == rhs.v); return lhs.i - rhs.i; }
++
++ reference operator[](difference_type n) const { return *(*this + n); }
++ };
++
++ public:
++ using const_iterator = It;
++ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
++
++ using value_type = It::value_type;
++ using difference_type = It::difference_type;
++ using size_type = It::size_type;
++ using reference = It::reference;
++ using const_reference = reference;
++ using pointer = It::pointer;
++ using const_pointer = pointer;
++
++ inline QVersionNumber() noexcept
++ : m_segments()
++ {}
++ Q_WEAK_OVERLOAD
++ inline explicit QVersionNumber(const QList<int> &seg) : m_segments(seg) { }
++
++ // compiler-generated copy/move ctor/assignment operators and the destructor are ok
++
++ Q_WEAK_OVERLOAD
++ explicit QVersionNumber(QList<int> &&seg) : m_segments(std::move(seg)) { }
++
++ inline QVersionNumber(std::initializer_list<int> args)
++ : m_segments(QSpan{args})
++ {}
++
++ explicit QVersionNumber(QSpan<const int> args)
++ : m_segments(args)
++ {}
++
++ inline explicit QVersionNumber(int maj)
++ { m_segments.setSegments(1, maj); }
++
++ inline explicit QVersionNumber(int maj, int min)
++ { m_segments.setSegments(2, maj, min); }
++
++ inline explicit QVersionNumber(int maj, int min, int mic)
++ { m_segments.setSegments(3, maj, min, mic); }
++
++ [[nodiscard]] inline bool isNull() const noexcept
++ { return segmentCount() == 0; }
++
++ [[nodiscard]] inline bool isNormalized() const noexcept
++ { return isNull() || segmentAt(segmentCount() - 1) != 0; }
++
++ [[nodiscard]] inline int majorVersion() const noexcept
++ { return segmentAt(0); }
++
++ [[nodiscard]] inline int minorVersion() const noexcept
++ { return segmentAt(1); }
++
++ [[nodiscard]] inline int microVersion() const noexcept
++ { return segmentAt(2); }
++
++ [[nodiscard]] Q_CORE_EXPORT QVersionNumber normalized() const;
++
++ [[nodiscard]] Q_CORE_EXPORT QList<int> segments() const;
++
++ [[nodiscard]] inline int segmentAt(qsizetype index) const noexcept
++ { return (m_segments.size() > index) ? m_segments.at(index) : 0; }
++
++ [[nodiscard]] inline qsizetype segmentCount() const noexcept
++ { return m_segments.size(); }
++
++ [[nodiscard]] const_iterator begin() const noexcept { return const_iterator{this, 0}; }
++ [[nodiscard]] const_iterator end() const noexcept { return begin() + segmentCount(); }
++ [[nodiscard]] const_iterator cbegin() const noexcept { return begin(); }
++ [[nodiscard]] const_iterator cend() const noexcept { return end(); }
++
++ [[nodiscard]] const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator{end()}; }
++ [[nodiscard]] const_reverse_iterator rend() const noexcept { return const_reverse_iterator{begin()}; }
++ [[nodiscard]] const_reverse_iterator crbegin() const noexcept { return rbegin(); }
++ [[nodiscard]] const_reverse_iterator crend() const noexcept { return rend(); }
++
++ [[nodiscard]] const_iterator constBegin() const noexcept { return begin(); }
++ [[nodiscard]] const_iterator constEnd() const noexcept { return end(); }
++
++ [[nodiscard]] Q_CORE_EXPORT bool isPrefixOf(const QVersionNumber &other) const noexcept;
++
++ [[nodiscard]] Q_CORE_EXPORT static int compare(const QVersionNumber &v1, const QVersionNumber &v2) noexcept;
++
++ [[nodiscard]] Q_CORE_EXPORT static QVersionNumber commonPrefix(const QVersionNumber &v1, const QVersionNumber &v2);
++
++ [[nodiscard]] Q_CORE_EXPORT QString toString() const;
++ [[nodiscard]] Q_CORE_EXPORT static QVersionNumber fromString(QAnyStringView string, qsizetype *suffixIndex = nullptr);
++
++ #if QT_DEPRECATED_SINCE(6, 4) && QT_POINTER_SIZE != 4
++ Q_WEAK_OVERLOAD
++ QT_DEPRECATED_VERSION_X_6_4("Use the 'qsizetype *suffixIndex' overload.")
++ [[nodiscard]] static QVersionNumber fromString(QAnyStringView string, int *suffixIndex)
++ {
++ QT_WARNING_PUSH
++ // fromString() writes to *n unconditionally, but GCC can't know that
++ QT_WARNING_DISABLE_GCC("-Wmaybe-uninitialized")
++ qsizetype n;
++ auto r = fromString(string, &n);
++ if (suffixIndex) {
++ Q_ASSERT(int(n) == n);
++ *suffixIndex = int(n);
++ }
++ return r;
++ QT_WARNING_POP
++ }
++ #endif
++
++
++ #if QT_CORE_REMOVED_SINCE(6, 4)
++ [[nodiscard]] Q_CORE_EXPORT static QVersionNumber fromString(const QString &string, int *suffixIndex);
++ [[nodiscard]] Q_CORE_EXPORT static QVersionNumber fromString(QLatin1StringView string, int *suffixIndex);
++ [[nodiscard]] Q_CORE_EXPORT static QVersionNumber fromString(QStringView string, int *suffixIndex);
++ #endif
++
++ private:
++ [[nodiscard]] friend bool comparesEqual(const QVersionNumber &lhs,
++ const QVersionNumber &rhs) noexcept
++ {
++ return lhs.segmentCount() == rhs.segmentCount() && compare(lhs, rhs) == 0;
++ }
++ [[nodiscard]] friend Qt::strong_ordering compareThreeWay(const QVersionNumber &lhs,
++ const QVersionNumber &rhs) noexcept
++ {
++ int c = compare(lhs, rhs);
++ return Qt::compareThreeWay(c, 0);
++ }
++ Q_DECLARE_STRONGLY_ORDERED(QVersionNumber)
++
++ #ifndef QT_NO_DATASTREAM
++ friend Q_CORE_EXPORT QDataStream& operator>>(QDataStream &in, QVersionNumber &version);
++ #endif
++ friend Q_CORE_EXPORT size_t qHash(const QVersionNumber &key, size_t seed);
++ };
++
++ Q_DECLARE_TYPEINFO(QVersionNumber::SegmentStorage, Q_RELOCATABLE_TYPE);
++ Q_DECLARE_TYPEINFO(QVersionNumber, Q_RELOCATABLE_TYPE);
++
++ #ifndef QT_NO_DEBUG_STREAM
++ Q_CORE_EXPORT QDebug operator<<(QDebug, const QVersionNumber &version);
++ #endif
++
++ QT_END_NAMESPACE
++
++ QT_DECL_METATYPE_EXTERN(QVersionNumber, Q_CORE_EXPORT)
++
++ #endif // QVERSIONNUMBER_H