Revision control
++ // Copyright (C) 2020 The Qt Company Ltd.
++ // Copyright (C) 2019 Intel Corporation
++ // 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 QLIST_H
++ #define QLIST_H
++
++ #include <QtCore/qarraydatapointer.h>
++ #include <QtCore/qcompare.h>
++ #include <QtCore/qnamespace.h>
++ #include <QtCore/qhashfunctions.h>
++ #include <QtCore/qiterator.h>
++ #include <QtCore/qcontainertools_impl.h>
++ #include <QtCore/qnamespace.h>
++ #include <QtCore/qscopeguard.h>
++ #include <QtCore/qttypetraits.h>
++
++ #include <functional>
++ #include <limits>
++ #include <initializer_list>
++ #include <type_traits>
++
++ class tst_QList;
++
++ QT_BEGIN_NAMESPACE
++
++ namespace QtPrivate {
++ template <typename V, typename U> qsizetype indexOf(const QList<V> &list, const U &u, qsizetype from) noexcept;
++ template <typename V, typename U> qsizetype lastIndexOf(const QList<V> &list, const U &u, qsizetype from) noexcept;
++ }
++
++ template <typename T> struct QListSpecialMethodsBase
++ {
++ protected:
++ QListSpecialMethodsBase() = default;
++ QT_DECLARE_RO5_SMF_AS_DEFAULTED(QListSpecialMethodsBase)
++
++ using Self = QList<T>;
++ Self *self() { return static_cast<Self *>(this); }
++ const Self *self() const { return static_cast<const Self *>(this); }
++
++ public:
++ template <typename AT = T>
++ qsizetype indexOf(const AT &t, qsizetype from = 0) const noexcept;
++ template <typename AT = T>
++ qsizetype lastIndexOf(const AT &t, qsizetype from = -1) const noexcept;
++
++ template <typename AT = T>
++ bool contains(const AT &t) const noexcept
++ {
++ return self()->indexOf(t) != -1;
++ }
++ };
++ template <typename T> struct QListSpecialMethods : QListSpecialMethodsBase<T>
++ {
++ protected:
++ QListSpecialMethods() = default;
++ QT_DECLARE_RO5_SMF_AS_DEFAULTED(QListSpecialMethods)
++
++ public:
++ using QListSpecialMethodsBase<T>::indexOf;
++ using QListSpecialMethodsBase<T>::lastIndexOf;
++ using QListSpecialMethodsBase<T>::contains;
++ };
++ template <> struct QListSpecialMethods<QByteArray>;
++ template <> struct QListSpecialMethods<QString>;
++
++ #if !defined(QT_STRICT_QLIST_ITERATORS) && (QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)) && !defined(Q_OS_WIN)
++ #define QT_STRICT_QLIST_ITERATORS
++ #endif
++
++ #ifdef Q_QDOC // define QVector for QDoc
++ template<typename T> class QVector : public QList<T> {};
++ #endif
++
++ template <typename T>
++ class QList
++ #ifndef Q_QDOC
++ : public QListSpecialMethods<T>
++ #endif
++ {
++ using Data = QTypedArrayData<T>;
++ using DataOps = QArrayDataOps<T>;
++ using DataPointer = QArrayDataPointer<T>;
++ class DisableRValueRefs {};
++
++ friend class ::tst_QList;
++
++ DataPointer d;
++
++ template <typename V, typename U> friend qsizetype QtPrivate::indexOf(const QList<V> &list, const U &u, qsizetype from) noexcept;
++ template <typename V, typename U> friend qsizetype QtPrivate::lastIndexOf(const QList<V> &list, const U &u, qsizetype from) noexcept;
++ // This alias prevents the QtPrivate namespace from being exposed into the docs.
++ template <typename InputIterator>
++ using if_input_iterator = QtPrivate::IfIsInputIterator<InputIterator>;
++
++ template <typename InputIterator> explicit
++ QList(InputIterator i1, InputIterator i2, std::input_iterator_tag)
++ {
++ std::copy(i1, i2, std::back_inserter(*this));
++ }
++
++ template <typename ForwardIterator> explicit
++ QList(ForwardIterator i1, ForwardIterator i2, std::forward_iterator_tag)
++ : d(std::distance(i1, i2))
++ {
++ if (i1 != i2) {
++ // appendIteratorRange can deal with contiguous iterators on its own,
++ // this is an optimization for C++17 code.
++ Q_CHECK_PTR(d.data());
++ if constexpr (std::is_same_v<std::decay_t<ForwardIterator>, iterator> ||
++ std::is_same_v<std::decay_t<ForwardIterator>, const_iterator>) {
++ d->copyAppend(i1.i, i2.i);
++ } else {
++ d->appendIteratorRange(i1, i2);
++ }
++ }
++ }
++
++ public:
++ using Type = T;
++ using value_type = T;
++ using pointer = T *;
++ using const_pointer = const T *;
++ using reference = T &;
++ using const_reference = const T &;
++ using size_type = qsizetype;
++ using difference_type = qptrdiff;
++ #ifndef Q_QDOC
++ using parameter_type = typename DataPointer::parameter_type;
++ using rvalue_ref = typename std::conditional<DataPointer::pass_parameter_by_value, DisableRValueRefs, T &&>::type;
++ #else // simplified aliases for QDoc
++ using parameter_type = const T &;
++ using rvalue_ref = T &&;
++ #endif
++
++ DataPointer &data_ptr() & { return d; }
++ const DataPointer &data_ptr() const & { return d; }
++ DataPointer &&data_ptr() && { return std::move(d); }
++ // No current use-case for a `const &&` overload
++
++ class const_iterator;
++ class iterator {
++ friend class QList<T>;
++ friend class const_iterator;
++ T *i = nullptr;
++ #ifdef QT_STRICT_QLIST_ITERATORS
++ inline constexpr explicit iterator(T *n) : i(n) {}
++ #endif
++
++ public:
++ using difference_type = qsizetype;
++ using value_type = T;
++ #ifdef QT_COMPILER_HAS_LWG3346
++ using iterator_concept = std::contiguous_iterator_tag;
++ #endif
++ using element_type = value_type;
++ using iterator_category = std::random_access_iterator_tag;
++ using pointer = T *;
++ using reference = T &;
++
++ inline constexpr iterator() = default;
++ #ifndef QT_STRICT_QLIST_ITERATORS
++ inline constexpr explicit iterator(T *n) : i(n) {}
++ #endif
++ inline T &operator*() const { return *i; }
++ inline T *operator->() const { return i; }
++ inline T &operator[](qsizetype j) const { return *(i + j); }
++ #ifdef __cpp_lib_three_way_comparison
++ friend constexpr auto operator<=>(iterator, iterator) noexcept = default;
++ friend constexpr bool operator==(iterator, iterator) noexcept = default;
++ #else
++ inline constexpr bool operator==(iterator o) const { return i == o.i; }
++ inline constexpr bool operator!=(iterator o) const { return i != o.i; }
++ inline constexpr bool operator<(iterator other) const { return i < other.i; }
++ inline constexpr bool operator<=(iterator other) const { return i <= other.i; }
++ inline constexpr bool operator>(iterator other) const { return i > other.i; }
++ inline constexpr bool operator>=(iterator other) const { return i >= other.i; }
++ inline constexpr bool operator==(const_iterator o) const { return i == o.i; }
++ inline constexpr bool operator!=(const_iterator o) const { return i != o.i; }
++ inline constexpr bool operator<(const_iterator other) const { return i < other.i; }
++ inline constexpr bool operator<=(const_iterator other) const { return i <= other.i; }
++ inline constexpr bool operator>(const_iterator other) const { return i > other.i; }
++ inline constexpr bool operator>=(const_iterator other) const { return i >= other.i; }
++ #endif // __cpp_lib_three_way_comparison
++ inline constexpr bool operator==(pointer p) const { return i == p; }
++ inline constexpr bool operator!=(pointer p) const { return i != p; }
++ inline iterator &operator++() { ++i; return *this; }
++ inline iterator operator++(int) { auto copy = *this; ++*this; return copy; }
++ inline iterator &operator--() { --i; return *this; }
++ inline iterator operator--(int) { auto copy = *this; --*this; return copy; }
++ inline qsizetype operator-(iterator j) const { return i - j.i; }
++ #if QT_DEPRECATED_SINCE(6, 3) && !defined(QT_STRICT_QLIST_ITERATORS)
++ QT_DEPRECATED_VERSION_X_6_3("Use operator* or operator-> rather than relying on "
++ "the implicit conversion between a QList/QVector::iterator "
++ "and a raw pointer")
++ inline operator T*() const { return i; }
++
++ template <typename Int> std::enable_if_t<std::is_integral_v<Int>, iterator>
++ &operator+=(Int j) { i+=j; return *this; }
++ template <typename Int> std::enable_if_t<std::is_integral_v<Int>, iterator>
++ &operator-=(Int j) { i-=j; return *this; }
++ template <typename Int> std::enable_if_t<std::is_integral_v<Int>, iterator>
++ operator+(Int j) const { return iterator(i+j); }
++ template <typename Int> std::enable_if_t<std::is_integral_v<Int>, iterator>
++ operator-(Int j) const { return iterator(i-j); }
++ template <typename Int> friend std::enable_if_t<std::is_integral_v<Int>, iterator>
++ operator+(Int j, iterator k) { return k + j; }
++ #else
++ inline iterator &operator+=(qsizetype j) { i += j; return *this; }
++ inline iterator &operator-=(qsizetype j) { i -= j; return *this; }
++ inline iterator operator+(qsizetype j) const { return iterator(i + j); }
++ inline iterator operator-(qsizetype j) const { return iterator(i - j); }
++ friend inline iterator operator+(qsizetype j, iterator k) { return k + j; }
++ #endif
++ };
++
++ class const_iterator {
++ friend class QList<T>;
++ friend class iterator;
++ const T *i = nullptr;
++ #ifdef QT_STRICT_QLIST_ITERATORS
++ inline constexpr explicit const_iterator(const T *n) : i(n) {}
++ #endif
++
++ public:
++ using difference_type = qsizetype;
++ using value_type = T;
++ #ifdef QT_COMPILER_HAS_LWG3346
++ using iterator_concept = std::contiguous_iterator_tag;
++ #endif
++ using element_type = const value_type;
++ using iterator_category = std::random_access_iterator_tag;
++ using pointer = const T *;
++ using reference = const T &;
++
++ inline constexpr const_iterator() = default;
++ #ifndef QT_STRICT_QLIST_ITERATORS
++ inline constexpr explicit const_iterator(const T *n) : i(n) {}
++ #endif
++ inline constexpr const_iterator(iterator o): i(o.i) {}
++ inline const T &operator*() const { return *i; }
++ inline const T *operator->() const { return i; }
++ inline const T &operator[](qsizetype j) const { return *(i + j); }
++ #ifdef __cpp_lib_three_way_comparison
++ friend constexpr auto operator<=>(const_iterator, const_iterator) noexcept = default;
++ friend constexpr auto operator<=>(const_iterator a, iterator b) noexcept
++ { return a <=> const_iterator(b); }
++ friend constexpr bool operator==(const_iterator, const_iterator) noexcept = default;
++ friend constexpr bool operator==(const_iterator a, iterator b) noexcept
++ { return a == const_iterator(b); }
++ #else
++ inline constexpr bool operator==(const_iterator o) const { return i == o.i; }
++ inline constexpr bool operator!=(const_iterator o) const { return i != o.i; }
++ inline constexpr bool operator<(const_iterator other) const { return i < other.i; }
++ inline constexpr bool operator<=(const_iterator other) const { return i <= other.i; }
++ inline constexpr bool operator>(const_iterator other) const { return i > other.i; }
++ inline constexpr bool operator>=(const_iterator other) const { return i >= other.i; }
++ inline constexpr bool operator==(iterator o) const { return i == o.i; }
++ inline constexpr bool operator!=(iterator o) const { return i != o.i; }
++ inline constexpr bool operator<(iterator other) const { return i < other.i; }
++ inline constexpr bool operator<=(iterator other) const { return i <= other.i; }
++ inline constexpr bool operator>(iterator other) const { return i > other.i; }
++ inline constexpr bool operator>=(iterator other) const { return i >= other.i; }
++ #endif // __cpp_lib_three_way_comparison
++ inline constexpr bool operator==(pointer p) const { return i == p; }
++ inline constexpr bool operator!=(pointer p) const { return i != p; }
++ inline const_iterator &operator++() { ++i; return *this; }
++ inline const_iterator operator++(int) { auto copy = *this; ++*this; return copy; }
++ inline const_iterator &operator--() { --i; return *this; }
++ inline const_iterator operator--(int) { auto copy = *this; --*this; return copy; }
++ inline qsizetype operator-(const_iterator j) const { return i - j.i; }
++ #if QT_DEPRECATED_SINCE(6, 3) && !defined(QT_STRICT_QLIST_ITERATORS)
++ QT_DEPRECATED_VERSION_X_6_3("Use operator* or operator-> rather than relying on "
++ "the implicit conversion between a QList/QVector::const_iterator "
++ "and a raw pointer")
++ inline operator const T*() const { return i; }
++
++ template <typename Int> std::enable_if_t<std::is_integral_v<Int>, const_iterator>
++ &operator+=(Int j) { i+=j; return *this; }
++ template <typename Int> std::enable_if_t<std::is_integral_v<Int>, const_iterator>
++ &operator-=(Int j) { i-=j; return *this; }
++ template <typename Int> std::enable_if_t<std::is_integral_v<Int>, const_iterator>
++ operator+(Int j) const { return const_iterator(i+j); }
++ template <typename Int> std::enable_if_t<std::is_integral_v<Int>, const_iterator>
++ operator-(Int j) const { return const_iterator(i-j); }
++ template <typename Int> friend std::enable_if_t<std::is_integral_v<Int>, const_iterator>
++ operator+(Int j, const_iterator k) { return k + j; }
++ #else
++ inline const_iterator &operator+=(qsizetype j) { i += j; return *this; }
++ inline const_iterator &operator-=(qsizetype j) { i -= j; return *this; }
++ inline const_iterator operator+(qsizetype j) const { return const_iterator(i + j); }
++ inline const_iterator operator-(qsizetype j) const { return const_iterator(i - j); }
++ friend inline const_iterator operator+(qsizetype j, const_iterator k) { return k + j; }
++ #endif
++ };
++ using Iterator = iterator;
++ using ConstIterator = const_iterator;
++ using reverse_iterator = std::reverse_iterator<iterator>;
++ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
++
++ private:
++ void resize_internal(qsizetype i);
++ bool isValidIterator(const_iterator i) const
++ {
++ const std::less<const T*> less = {};
++ return !less(d.end(), i.i) && !less(i.i, d.begin());
++ }
++
++ void verify([[maybe_unused]] qsizetype pos = 0, [[maybe_unused]] qsizetype n = 1) const
++ {
++ Q_ASSERT(pos >= 0);
++ Q_ASSERT(pos <= size());
++ Q_ASSERT(n >= 0);
++ Q_ASSERT(n <= size() - pos);
++ }
++ public:
++ QList(DataPointer dd) noexcept
++ : d(dd)
++ {
++ }
++
++ public:
++ constexpr QList() noexcept = default;
++ explicit QList(qsizetype size)
++ : d(size)
++ {
++ if (size) {
++ Q_CHECK_PTR(d.data());
++ d.appendInitialize(size);
++ }
++ }
++ QList(qsizetype size, parameter_type t)
++ : d(size)
++ {
++ if (size) {
++ Q_CHECK_PTR(d.data());
++ d->copyAppend(size, t);
++ }
++ }
++
++ inline QList(std::initializer_list<T> args)
++ : d(qsizetype(args.size()))
++ {
++ if (args.size()) {
++ Q_CHECK_PTR(d.data());
++ d->copyAppend(args.begin(), args.end());
++ }
++ }
++
++ QList<T> &operator=(std::initializer_list<T> args)
++ {
++ return assign(args);
++ }
++
++ template <typename InputIterator, if_input_iterator<InputIterator> = true>
++ QList(InputIterator i1, InputIterator i2)
++ : QList(i1, i2, typename std::iterator_traits<InputIterator>::iterator_category{})
++ {
++ }
++
++ // This constructor is here for compatibility with QStringList in Qt 5, that has a QStringList(const QString &) constructor
++ template<typename String, typename = std::enable_if_t<std::is_same_v<T, QString> && std::is_convertible_v<String, QString>>>
++ inline explicit QList(const String &str)
++ { append(str); }
++
++ QList(qsizetype size, Qt::Initialization)
++ : d(size)
++ {
++ if (size) {
++ Q_CHECK_PTR(d.data());
++ d->appendUninitialized(size);
++ }
++ }
++
++ // compiler-generated special member functions are fine!
++
++ void swap(QList &other) noexcept { d.swap(other.d); }
++
++ #ifndef Q_QDOC
++ private:
++ template <typename U = T,
++ Qt::if_has_qt_compare_three_way<U, U> = true>
++ friend auto compareThreeWay(const QList &lhs, const QList &rhs)
++ {
++ return QtOrderingPrivate::lexicographicalCompareThreeWay(lhs.begin(), lhs.end(),
++ rhs.begin(), rhs.end());
++ }
++
++ #if defined(__cpp_lib_three_way_comparison) && defined(__cpp_lib_concepts)
++ template <typename U = T,
++ QtOrderingPrivate::if_has_op_less_or_op_compare_three_way<QList, U> = true>
++ friend auto operator<=>(const QList &lhs, const QList &rhs)
++ {
++ return std::lexicographical_compare_three_way(lhs.begin(), lhs.end(),
++ rhs.begin(), rhs.end(),
++ QtOrderingPrivate::synthThreeWay);
++ }
++ #endif // __cpp_lib_three_way_comparison && __cpp_lib_concepts
++
++ public:
++ template <typename U = T>
++ QTypeTraits::compare_eq_result_container<QList, U> operator==(const QList &other) const
++ {
++ if (size() != other.size())
++ return false;
++ if (begin() == other.begin())
++ return true;
++
++ // do element-by-element comparison
++ return std::equal(begin(), end(), other.begin(), other.end());
++ }
++
++ template <typename U = T>
++ QTypeTraits::compare_eq_result_container<QList, U> operator!=(const QList &other) const
++ {
++ return !(*this == other);
++ }
++
++ #ifndef __cpp_lib_three_way_comparison
++ template <typename U = T>
++ QTypeTraits::compare_lt_result_container<QList, U> operator<(const QList &other) const
++ noexcept(noexcept(std::lexicographical_compare<typename QList<U>::const_iterator,
++ typename QList::const_iterator>(
++ std::declval<QList<U>>().begin(), std::declval<QList<U>>().end(),
++ other.begin(), other.end())))
++ {
++ return std::lexicographical_compare(begin(), end(),
++ other.begin(), other.end());
++ }
++
++ template <typename U = T>
++ QTypeTraits::compare_lt_result_container<QList, U> operator>(const QList &other) const
++ noexcept(noexcept(other < std::declval<QList<U>>()))
++ {
++ return other < *this;
++ }
++
++ template <typename U = T>
++ QTypeTraits::compare_lt_result_container<QList, U> operator<=(const QList &other) const
++ noexcept(noexcept(other < std::declval<QList<U>>()))
++ {
++ return !(other < *this);
++ }
++
++ template <typename U = T>
++ QTypeTraits::compare_lt_result_container<QList, U> operator>=(const QList &other) const
++ noexcept(noexcept(std::declval<QList<U>>() < other))
++ {
++ return !(*this < other);
++ }
++ #endif // __cpp_lib_three_way_comparison
++ #else
++ bool operator==(const QList &other) const;
++ bool operator!=(const QList &other) const;
++ bool operator<(const QList &other) const;
++ bool operator>(const QList &other) const;
++ bool operator<=(const QList &other) const;
++ bool operator>=(const QList &other) const;
++ friend auto operator<=>(const QList &lhs, const QList &rhs);
++ #endif // Q_QDOC
++
++ static constexpr qsizetype maxSize() { return Data::maxSize(); }
++ constexpr qsizetype size() const noexcept
++ {
++ constexpr size_t MaxSize = maxSize();
++ Q_PRESUME(size_t(d.size) <= MaxSize);
++ return d.size;
++ }
++ constexpr qsizetype count() const noexcept { return size(); }
++ constexpr qsizetype length() const noexcept { return size(); }
++
++ constexpr bool isEmpty() const noexcept { return size() == 0; }
++
++ void resize(qsizetype size)
++ {
++ resize_internal(size);
++ if (size > this->size())
++ d.appendInitialize(size);
++ }
++ void resize(qsizetype size, parameter_type c)
++ {
++ resize_internal(size);
++ if (size > this->size())
++ d->copyAppend(size - this->size(), c);
++ }
++ void resizeForOverwrite(qsizetype size)
++ {
++ resize_internal(size);
++ if (size > this->size())
++ d->appendUninitialized(size);
++ }
++
++ inline qsizetype capacity() const { return qsizetype(d.constAllocatedCapacity()); }
++ void reserve(qsizetype size);
++ inline void squeeze();
++
++ void detach() { d.detach(); }
++ bool isDetached() const noexcept { return !d.isShared(); }
++
++ inline bool isSharedWith(const QList<T> &other) const { return d == other.d; }
++
++ pointer data() { detach(); return d.data(); }
++ const_pointer data() const noexcept { return d.data(); }
++ const_pointer constData() const noexcept { return d.data(); }
++ void clear() {
++ if (!size())
++ return;
++ if (d.needsDetach()) {
++ // must allocate memory
++ DataPointer detached(d.allocatedCapacity());
++ d.swap(detached);
++ } else {
++ d->truncate(0);
++ }
++ }
++
++ const_reference at(qsizetype i) const noexcept
++ {
++ Q_ASSERT_X(size_t(i) < size_t(d.size), "QList::at", "index out of range");
++ return data()[i];
++ }
++ reference operator[](qsizetype i)
++ {
++ Q_ASSERT_X(size_t(i) < size_t(d.size), "QList::operator[]", "index out of range");
++ // don't detach() here, we detach in data below:
++ return data()[i];
++ }
++ const_reference operator[](qsizetype i) const noexcept { return at(i); }
++ void append(parameter_type t) { emplaceBack(t); }
++ void append(const_iterator i1, const_iterator i2);
++ void append(rvalue_ref t)
++ {
++ if constexpr (DataPointer::pass_parameter_by_value) {
++ Q_UNUSED(t);
++ } else {
++ emplaceBack(std::move(t));
++ }
++ }
++ void append(const QList<T> &l)
++ {
++ append(l.constBegin(), l.constEnd());
++ }
++ void append(QList<T> &&l);
++ void prepend(rvalue_ref t) {
++ if constexpr (DataPointer::pass_parameter_by_value) {
++ Q_UNUSED(t);
++ } else {
++ emplaceFront(std::move(t));
++ }
++ }
++ void prepend(parameter_type t) { emplaceFront(t); }
++
++ template<typename... Args>
++ inline reference emplaceBack(Args &&... args);
++
++ template <typename ...Args>
++ inline reference emplaceFront(Args&&... args);
++
++ iterator insert(qsizetype i, parameter_type t)
++ { return emplace(i, t); }
++ iterator insert(qsizetype i, qsizetype n, parameter_type t);
++ iterator insert(const_iterator before, parameter_type t)
++ {
++ Q_ASSERT_X(isValidIterator(before), "QList::insert", "The specified iterator argument 'before' is invalid");
++ return insert(before, 1, t);
++ }
++ iterator insert(const_iterator before, qsizetype n, parameter_type t)
++ {
++ Q_ASSERT_X(isValidIterator(before), "QList::insert", "The specified iterator argument 'before' is invalid");
++ return insert(std::distance(constBegin(), before), n, t);
++ }
++ iterator insert(const_iterator before, rvalue_ref t)
++ {
++ Q_ASSERT_X(isValidIterator(before), "QList::insert", "The specified iterator argument 'before' is invalid");
++ return insert(std::distance(constBegin(), before), std::move(t));
++ }
++ iterator insert(qsizetype i, rvalue_ref t) {
++ if constexpr (DataPointer::pass_parameter_by_value) {
++ Q_UNUSED(i);
++ Q_UNUSED(t);
++ return end();
++ } else {
++ return emplace(i, std::move(t));
++ }
++ }
++
++ QList &assign(qsizetype n, parameter_type t)
++ {
++ Q_ASSERT(n >= 0);
++ return fill(t, n);
++ }
++
++ template <typename InputIterator, if_input_iterator<InputIterator> = true>
++ QList &assign(InputIterator first, InputIterator last)
++ { d->assign(first, last); return *this; }
++
++ QList &assign(std::initializer_list<T> l)
++ {
++ if (l.size())
++ return assign(l.begin(), l.end());
++ clear();
++ return *this;
++ }
++
++ template <typename ...Args>
++ iterator emplace(const_iterator before, Args&&... args)
++ {
++ Q_ASSERT_X(isValidIterator(before), "QList::emplace", "The specified iterator argument 'before' is invalid");
++ return emplace(std::distance(constBegin(), before), std::forward<Args>(args)...);
++ }
++
++ template <typename ...Args>
++ iterator emplace(qsizetype i, Args&&... args);
++ #if 0
++ template< class InputIt >
++ iterator insert( const_iterator pos, InputIt first, InputIt last );
++ iterator insert( const_iterator pos, std::initializer_list<T> ilist );
++ #endif
++ void replace(qsizetype i, parameter_type t)
++ {
++ Q_ASSERT_X(i >= 0 && i < d.size, "QList<T>::replace", "index out of range");
++ DataPointer oldData;
++ d.detach(&oldData);
++ d.data()[i] = t;
++ }
++ void replace(qsizetype i, rvalue_ref t)
++ {
++ if constexpr (DataPointer::pass_parameter_by_value) {
++ Q_UNUSED(i);
++ Q_UNUSED(t);
++ } else {
++ Q_ASSERT_X(i >= 0 && i < d.size, "QList<T>::replace", "index out of range");
++ DataPointer oldData;
++ d.detach(&oldData);
++ d.data()[i] = std::move(t);
++ }
++ }
++
++ void remove(qsizetype i, qsizetype n = 1);
++ void removeFirst() noexcept;
++ void removeLast() noexcept;
++ value_type takeFirst()
++ {
++ Q_ASSERT(!isEmpty());
++ const auto eraser = qScopeGuard([&] { d->eraseFirst(); });
++ return std::move(first());
++ }
++ value_type takeLast()
++ {
++ Q_ASSERT(!isEmpty());
++ const auto eraser = qScopeGuard([&] { d->eraseLast(); });
++ return std::move(last());
++ }
++
++ QList<T> &fill(parameter_type t, qsizetype size = -1);
++
++ #ifndef Q_QDOC
++ using QListSpecialMethods<T>::contains;
++ using QListSpecialMethods<T>::indexOf;
++ using QListSpecialMethods<T>::lastIndexOf;
++ #else
++ template <typename AT>
++ qsizetype indexOf(const AT &t, qsizetype from = 0) const noexcept;
++ template <typename AT>
++ qsizetype lastIndexOf(const AT &t, qsizetype from = -1) const noexcept;
++ template <typename AT>
++ bool contains(const AT &t) const noexcept;
++ #endif
++
++ template <typename AT = T>
++ qsizetype count(const AT &t) const noexcept
++ {
++ return qsizetype(std::count(data(), data() + size(), t));
++ }
++
++ void removeAt(qsizetype i) { remove(i); }
++ template <typename AT = T>
++ qsizetype removeAll(const AT &t)
++ {
++ return QtPrivate::sequential_erase_with_copy(*this, t);
++ }
++
++ template <typename AT = T>
++ bool removeOne(const AT &t)
++ {
++ return QtPrivate::sequential_erase_one(*this, t);
++ }
++
++ template <typename Predicate>
++ qsizetype removeIf(Predicate pred)
++ {
++ return QtPrivate::sequential_erase_if(*this, pred);
++ }
++
++ T takeAt(qsizetype i)
++ {
++ T &t = (*this)[i]; // trigger assert, if any
++ const auto remover = qScopeGuard([&] { remove(i); });
++ return std::move(t);
++ }
++
++ void move(qsizetype from, qsizetype to)
++ {
++ Q_ASSERT_X(from >= 0 && from < size(), "QList::move(qsizetype, qsizetype)", "'from' is out-of-range");
++ Q_ASSERT_X(to >= 0 && to < size(), "QList::move(qsizetype, qsizetype)", "'to' is out-of-range");
++ if (from == to) // don't detach when no-op
++ return;
++ detach();
++ T * const b = d.begin();
++ if (from < to)
++ std::rotate(b + from, b + from + 1, b + to + 1);
++ else
++ std::rotate(b + to, b + from, b + from + 1);
++ }
++
++ // STL-style
++ iterator begin() { detach(); return iterator(d.begin()); }
++ iterator end() { detach(); return iterator(d.end()); }
++
++ const_iterator begin() const noexcept { return const_iterator(d.constBegin()); }
++ const_iterator end() const noexcept { return const_iterator(d.constEnd()); }
++ const_iterator cbegin() const noexcept { return const_iterator(d.constBegin()); }
++ const_iterator cend() const noexcept { return const_iterator(d.constEnd()); }
++ const_iterator constBegin() const noexcept { return const_iterator(d.constBegin()); }
++ const_iterator constEnd() const noexcept { return const_iterator(d.constEnd()); }
++ reverse_iterator rbegin() { return reverse_iterator(end()); }
++ reverse_iterator rend() { return reverse_iterator(begin()); }
++ const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
++ const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
++ const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
++ const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
++
++ iterator erase(const_iterator begin, const_iterator end);
++ inline iterator erase(const_iterator pos) { return erase(pos, pos+1); }
++
++ // more Qt
++ inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); }
++ inline const T &first() const noexcept { Q_ASSERT(!isEmpty()); return *begin(); }
++ inline const T &constFirst() const noexcept { Q_ASSERT(!isEmpty()); return *begin(); }
++ inline T& last() { Q_ASSERT(!isEmpty()); return *(end()-1); }
++ inline const T &last() const noexcept { Q_ASSERT(!isEmpty()); return *(end()-1); }
++ inline const T &constLast() const noexcept { Q_ASSERT(!isEmpty()); return *(end()-1); }
++ inline bool startsWith(parameter_type t) const { return !isEmpty() && first() == t; }
++ inline bool endsWith(parameter_type t) const { return !isEmpty() && last() == t; }
++ QList<T> mid(qsizetype pos, qsizetype len = -1) const;
++
++ QList<T> first(qsizetype n) const
++ { verify(0, n); return QList<T>(begin(), begin() + n); }
++ QList<T> last(qsizetype n) const
++ { verify(0, n); return QList<T>(end() - n, end()); }
++ QList<T> sliced(qsizetype pos) const
++ { verify(pos, 0); return QList<T>(begin() + pos, end()); }
++ QList<T> sliced(qsizetype pos, qsizetype n) const
++ { verify(pos, n); return QList<T>(begin() + pos, begin() + pos + n); }
++
++ T value(qsizetype i) const { return value(i, T()); }
++ T value(qsizetype i, parameter_type defaultValue) const;
++
++ void swapItemsAt(qsizetype i, qsizetype j) {
++ Q_ASSERT_X(i >= 0 && i < size() && j >= 0 && j < size(),
++ "QList<T>::swap", "index out of range");
++ detach();
++ qSwap(d.begin()[i], d.begin()[j]);
++ }
++
++ // STL compatibility
++ inline void push_back(parameter_type t) { append(t); }
++ void push_back(rvalue_ref t) { append(std::move(t)); }
++ void push_front(rvalue_ref t) { prepend(std::move(t)); }
++ inline void push_front(parameter_type t) { prepend(t); }
++ void pop_back() noexcept { removeLast(); }
++ void pop_front() noexcept { removeFirst(); }
++
++ template <typename ...Args>
++ reference emplace_back(Args&&... args) { return emplaceBack(std::forward<Args>(args)...); }
++
++ inline bool empty() const noexcept
++ { return d.size == 0; }
++ inline reference front() { return first(); }
++ inline const_reference front() const noexcept { return first(); }
++ inline reference back() { return last(); }
++ inline const_reference back() const noexcept { return last(); }
++ void shrink_to_fit() { squeeze(); }
++ constexpr qsizetype max_size() const noexcept
++ {
++ return maxSize();
++ }
++
++ // comfort
++ QList<T> &operator+=(const QList<T> &l) { append(l); return *this; }
++ QList<T> &operator+=(QList<T> &&l) { append(std::move(l)); return *this; }
++ inline QList<T> operator+(const QList<T> &l) const &
++ { QList n = *this; n += l; return n; }
++ QList<T> operator+(const QList<T> &l) &&
++ { return std::move(*this += l); }
++ inline QList<T> operator+(QList<T> &&l) const &
++ { QList n = *this; n += std::move(l); return n; }
++ QList<T> operator+(QList<T> &&l) &&
++ { return std::move(*this += std::move(l)); }
++ inline QList<T> &operator+=(parameter_type t)
++ { append(t); return *this; }
++ inline QList<T> &operator<< (parameter_type t)
++ { append(t); return *this; }
++ inline QList<T> &operator<<(const QList<T> &l)
++ { *this += l; return *this; }
++ inline QList<T> &operator<<(QList<T> &&l)
++ { *this += std::move(l); return *this; }
++ inline QList<T> &operator+=(rvalue_ref t)
++ { append(std::move(t)); return *this; }
++ inline QList<T> &operator<<(rvalue_ref t)
++ { append(std::move(t)); return *this; }
++
++ // Consider deprecating in 6.4 or later
++ static QList<T> fromList(const QList<T> &list) noexcept { return list; }
++ QList<T> toList() const noexcept { return *this; }
++
++ static inline QList<T> fromVector(const QList<T> &vector) noexcept { return vector; }
++ inline QList<T> toVector() const noexcept { return *this; }
++
++ template<qsizetype N>
++ static QList<T> fromReadOnlyData(const T (&t)[N]) noexcept
++ {
++ return QList<T>({ nullptr, const_cast<T *>(t), N });
++ }
++ };
++
++ template <typename InputIterator,
++ typename ValueType = typename std::iterator_traits<InputIterator>::value_type,
++ QtPrivate::IfIsInputIterator<InputIterator> = true>
++ QList(InputIterator, InputIterator) -> QList<ValueType>;
++
++ template <typename T>
++ inline void QList<T>::resize_internal(qsizetype newSize)
++ {
++ Q_ASSERT(newSize >= 0);
++
++ if (d.needsDetach() || newSize > capacity() - d.freeSpaceAtBegin()) {
++ d.detachAndGrow(QArrayData::GrowsAtEnd, newSize - d.size, nullptr, nullptr);
++ } else if (newSize < size()) {
++ d->truncate(newSize);
++ }
++ }
++
++ template <typename T>
++ void QList<T>::reserve(qsizetype asize)
++ {
++ // capacity() == 0 for immutable data, so this will force a detaching below
++ if (asize <= capacity() - d.freeSpaceAtBegin()) {
++ if (d.flags() & Data::CapacityReserved)
++ return; // already reserved, don't shrink
++ if (!d.isShared()) {
++ // accept current allocation, don't shrink
++ d.setFlag(Data::CapacityReserved);
++ return;
++ }
++ }
++
++ qsizetype newSize = qMax(asize, size());
++ DataPointer detached(newSize);
++ if (newSize)
++ Q_CHECK_PTR(detached.data());
++ detached->copyAppend(d.begin(), d.end());
++ if (detached.d_ptr())
++ detached.setFlag(Data::CapacityReserved);
++ d.swap(detached);
++ }
++
++ template <typename T>
++ inline void QList<T>::squeeze()
++ {
++ if (!d.isMutable())
++ return;
++ if (d.needsDetach() || size() < capacity()) {
++ // must allocate memory
++ DataPointer detached(size());
++ if (size()) {
++ Q_CHECK_PTR(detached.data());
++ if (d.needsDetach())
++ detached->copyAppend(d.data(), d.data() + d.size);
++ else
++ detached->moveAppend(d.data(), d.data() + d.size);
++ }
++ d.swap(detached);
++ }
++ // We're detached so this is fine
++ d.clearFlag(Data::CapacityReserved);
++ }
++
++ template <typename T>
++ inline void QList<T>::remove(qsizetype i, qsizetype n)
++ {
++ Q_ASSERT_X(size_t(i) + size_t(n) <= size_t(d.size), "QList::remove", "index out of range");
++ Q_ASSERT_X(n >= 0, "QList::remove", "invalid count");
++
++ if (n == 0)
++ return;
++
++ d.detach();
++ d->erase(d.begin() + i, n);
++ }
++
++ template <typename T>
++ inline void QList<T>::removeFirst() noexcept
++ {
++ Q_ASSERT(!isEmpty());
++ d.detach();
++ d->eraseFirst();
++ }
++
++ template <typename T>
++ inline void QList<T>::removeLast() noexcept
++ {
++ Q_ASSERT(!isEmpty());
++ d.detach();
++ d->eraseLast();
++ }
++
++
++ template<typename T>
++ inline T QList<T>::value(qsizetype i, parameter_type defaultValue) const
++ {
++ return size_t(i) < size_t(d.size) ? at(i) : defaultValue;
++ }
++
++ template <typename T>
++ inline void QList<T>::append(const_iterator i1, const_iterator i2)
++ {
++ d->growAppend(i1.i, i2.i);
++ }
++
++ template <typename T>
++ inline void QList<T>::append(QList<T> &&other)
++ {
++ Q_ASSERT(&other != this);
++ if (other.isEmpty())
++ return;
++ if (other.d.needsDetach() || !std::is_nothrow_move_constructible_v<T>)
++ return append(other);
++
++ // due to precondition &other != this, we can unconditionally modify 'this'
++ d.detachAndGrow(QArrayData::GrowsAtEnd, other.size(), nullptr, nullptr);
++ Q_ASSERT(d.freeSpaceAtEnd() >= other.size());
++ d->moveAppend(other.d.begin(), other.d.end());
++ }
++
++ template<typename T>
++ template<typename... Args>
++ inline typename QList<T>::reference QList<T>::emplaceFront(Args &&... args)
++ {
++ d->emplace(0, std::forward<Args>(args)...);
++ return *d.begin();
++ }
++
++
++ template <typename T>
++ inline typename QList<T>::iterator
++ QList<T>::insert(qsizetype i, qsizetype n, parameter_type t)
++ {
++ Q_ASSERT_X(size_t(i) <= size_t(d.size), "QList<T>::insert", "index out of range");
++ Q_ASSERT_X(n >= 0, "QList::insert", "invalid count");
++ if (Q_LIKELY(n))
++ d->insert(i, n, t);
++ return begin() + i;
++ }
++
++ template <typename T>
++ template <typename ...Args>
++ typename QList<T>::iterator
++ QList<T>::emplace(qsizetype i, Args&&... args)
++ {
++ Q_ASSERT_X(i >= 0 && i <= d.size, "QList<T>::insert", "index out of range");
++ d->emplace(i, std::forward<Args>(args)...);
++ return begin() + i;
++ }
++
++ template<typename T>
++ template<typename... Args>
++ inline typename QList<T>::reference QList<T>::emplaceBack(Args &&... args)
++ {
++ d->emplace(d.size, std::forward<Args>(args)...);
++ return *(end() - 1);
++ }
++
++ template <typename T>
++ typename QList<T>::iterator QList<T>::erase(const_iterator abegin, const_iterator aend)
++ {
++ Q_ASSERT_X(isValidIterator(abegin), "QList::erase", "The specified iterator argument 'abegin' is invalid");
++ Q_ASSERT_X(isValidIterator(aend), "QList::erase", "The specified iterator argument 'aend' is invalid");
++ Q_ASSERT(aend >= abegin);
++
++ qsizetype i = std::distance(constBegin(), abegin);
++ qsizetype n = std::distance(abegin, aend);
++ remove(i, n);
++
++ return begin() + i;
++ }
++
++ template <typename T>
++ inline QList<T> &QList<T>::fill(parameter_type t, qsizetype newSize)
++ {
++ if (newSize == -1)
++ newSize = size();
++ if (d.needsDetach() || newSize > capacity()) {
++ // must allocate memory
++ DataPointer detached(d.detachCapacity(newSize));
++ detached->copyAppend(newSize, t);
++ d.swap(detached);
++ } else {
++ // we're detached
++ const T copy(t);
++ d->assign(d.begin(), d.begin() + qMin(size(), newSize), t);
++ if (newSize > size()) {
++ d->copyAppend(newSize - size(), copy);
++ } else if (newSize < size()) {
++ d->truncate(newSize);
++ }
++ }
++ return *this;
++ }
++
++ namespace QtPrivate {
++ template <typename T, typename U>
++ qsizetype indexOf(const QList<T> &vector, const U &u, qsizetype from) noexcept
++ {
++ if (from < 0)
++ from = qMax(from + vector.size(), qsizetype(0));
++ if (from < vector.size()) {
++ auto n = vector.begin() + from - 1;
++ auto e = vector.end();
++ while (++n != e)
++ if (*n == u)
++ return qsizetype(n - vector.begin());
++ }
++ return -1;
++ }
++
++ template <typename T, typename U>
++ qsizetype lastIndexOf(const QList<T> &vector, const U &u, qsizetype from) noexcept
++ {
++ if (from < 0)
++ from += vector.d.size;
++ else if (from >= vector.size())
++ from = vector.size() - 1;
++ if (from >= 0) {
++ auto b = vector.begin();
++ auto n = vector.begin() + from + 1;
++ while (n != b) {
++ if (*--n == u)
++ return qsizetype(n - b);
++ }
++ }
++ return -1;
++ }
++ }
++
++ template <typename T>
++ template <typename AT>
++ qsizetype QListSpecialMethodsBase<T>::indexOf(const AT &t, qsizetype from) const noexcept
++ {
++ return QtPrivate::indexOf(*self(), t, from);
++ }
++
++ template <typename T>
++ template <typename AT>
++ qsizetype QListSpecialMethodsBase<T>::lastIndexOf(const AT &t, qsizetype from) const noexcept
++ {
++ return QtPrivate::lastIndexOf(*self(), t, from);
++ }
++
++ template <typename T>
++ inline QList<T> QList<T>::mid(qsizetype pos, qsizetype len) const
++ {
++ qsizetype p = pos;
++ qsizetype l = len;
++ using namespace QtPrivate;
++ switch (QContainerImplHelper::mid(d.size, &p, &l)) {
++ case QContainerImplHelper::Null:
++ case QContainerImplHelper::Empty:
++ return QList();
++ case QContainerImplHelper::Full:
++ return *this;
++ case QContainerImplHelper::Subset:
++ break;
++ }
++
++ // Allocate memory
++ DataPointer copied(l);
++ copied->copyAppend(data() + p, data() + p + l);
++ return copied;
++ }
++
++ Q_DECLARE_SEQUENTIAL_ITERATOR(List)
++ Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(List)
++
++ template <typename T>
++ size_t qHash(const QList<T> &key, size_t seed = 0)
++ noexcept(noexcept(qHashRange(key.cbegin(), key.cend(), seed)))
++ {
++ return qHashRange(key.cbegin(), key.cend(), seed);
++ }
++
++ template <typename T, typename AT>
++ qsizetype erase(QList<T> &list, const AT &t)
++ {
++ return QtPrivate::sequential_erase(list, t);
++ }
++
++ template <typename T, typename Predicate>
++ qsizetype erase_if(QList<T> &list, Predicate pred)
++ {
++ return QtPrivate::sequential_erase_if(list, pred);
++ }
++
++ // ### Qt 7 char32_t
++ QList<uint> QStringView::toUcs4() const { return QtPrivate::convertToUcs4(*this); }
++
++ QT_END_NAMESPACE
++
++ #include <QtCore/qbytearraylist.h>
++ #include <QtCore/qstringlist.h>
++
++ #endif // QLIST_H