1 files changed, 156 insertions, 76 deletions
diff --git a/src/corelib/itemmodels/qrangemodeladapter.h b/src/corelib/itemmodels/qrangemodeladapter.h
index bd3342e6185..0234c402248 100644
--- a/src/corelib/itemmodels/qrangemodeladapter.h
+++ b/src/corelib/itemmodels/qrangemodeladapter.h
@@ -19,13 +19,11 @@ class QT_TECH_PREVIEW_API QRangeModelAdapter
 
 #ifdef Q_QDOC
     using range_type = Range;
-    using const_row_reference = typename std::iterator_traits<Range>::const_reference;
-    using row_reference = typename std::iterator_traits<Range>::reference;
 #else
     using range_type = QRangeModelDetails::wrapped_t<Range>;
+#endif
     using const_row_reference = typename Impl::const_row_reference;
     using row_reference = typename Impl::row_reference;
-#endif
     using range_features = typename QRangeModelDetails::range_traits<range_type>;
     using row_type = std::remove_reference_t<row_reference>;
     using row_features = QRangeModelDetails::range_traits<typename Impl::wrapped_row_type>;
@@ -78,16 +76,22 @@ class QT_TECH_PREVIEW_API QRangeModelAdapter
     template <typename C>
     using if_compatible_row_range = std::enable_if_t<is_compatible_row_range<C>, bool>;
     template <typename Data>
-    static constexpr bool is_compatible_data = true;
-        // std::is_convertible_v<Data, decltype(*std::begin(std::declval<const_row_reference>()))>;
+    static constexpr bool is_compatible_data = std::is_convertible_v<Data, data_type>;
     template <typename Data>
     using if_compatible_data = std::enable_if_t<is_compatible_data<Data>, bool>;
     template <typename C>
     static constexpr bool is_compatible_data_range = is_compatible_data<
+                                                typename QRangeModelDetails::data_type<
+                                                    typename QRangeModelDetails::row_traits<
                                                         decltype(*std::begin(std::declval<C&>()))
-                                                    >;
+                                                    >::item_type
+                                                >::type
+                                            >;
     template <typename C>
-    using if_compatible_data_range = std::enable_if_t<is_compatible_data_range<C>, bool>;
+    using if_compatible_column_data = std::enable_if_t<is_compatible_data<C>
+                                                    || is_compatible_data_range<C>, bool>;
+    template <typename C>
+    using if_compatible_column_range = std::enable_if_t<is_compatible_data_range<C>, bool>;
 
     template <typename R>
     using if_assignable_range = std::enable_if_t<std::is_assignable_v<range_type, R>, bool>;
@@ -141,6 +145,7 @@ public:
         }
 
         DataReference(const DataReference &other) = default;
+        DataReference(DataReference &&other) = default;
 
         // reference (not std::reference_wrapper) semantics
         DataReference &operator=(const DataReference &other)
@@ -149,29 +154,23 @@ public:
             return *this;
         }
 
+        DataReference &operator=(DataReference &&other)
+        {
+            *this = other.get();
+            return *this;
+        }
+
         ~DataReference() = default;
 
         DataReference &operator=(const value_type &value)
         {
-            constexpr Qt::ItemDataRole dataRole = Qt::RangeModelAdapterRole;
+            assign(value);
+            return *this;
+        }
 
-            if (m_index.isValid()) {
-                auto model = const_cast<QAbstractItemModel *>(m_index.model());
-                [[maybe_unused]] bool couldWrite = false;
-                if constexpr (std::is_same_v<q20::remove_cvref_t<value_type>, QVariant>)
-                    couldWrite = model->setData(m_index, value, dataRole);
-                else
-                    couldWrite = model->setData(m_index, QVariant::fromValue(value), dataRole);
-#ifndef QT_NO_DEBUG
-                if (!couldWrite) {
-                    qWarning() << "Writing value of type" << QMetaType::fromType<value_type>().name()
-                               << "to role" << dataRole << "at index" << m_index
-                               << "of the model failed";
-                }
-            } else {
-                qCritical("Data reference for invalid index, can't write to model");
-#endif
-            }
+        DataReference &operator=(value_type &&value)
+        {
+            assign(std::move(value));
             return *this;
         }
 
@@ -196,6 +195,33 @@ public:
     private:
         QModelIndex m_index;
 
+        template <typename Value>
+        void assign(Value &&value)
+        {
+            constexpr Qt::ItemDataRole dataRole = Qt::RangeModelAdapterRole;
+
+            if (m_index.isValid()) {
+                auto model = const_cast<QAbstractItemModel *>(m_index.model());
+                [[maybe_unused]] bool couldWrite = false;
+                if constexpr (std::is_same_v<q20::remove_cvref_t<Value>, QVariant>) {
+                    couldWrite = model->setData(m_index, value, dataRole);
+                } else {
+                    couldWrite = model->setData(m_index,
+                                                QVariant::fromValue(std::forward<Value>(value)),
+                                                dataRole);
+                }
+#ifndef QT_NO_DEBUG
+                if (!couldWrite) {
+                    qWarning() << "Writing value of type"
+                               << QMetaType::fromType<q20::remove_cvref_t<Value>>().name()
+                               << "to role" << dataRole << "at index" << m_index << "failed";
+                }
+            } else {
+                qCritical("Data reference for invalid index, can't write to model");
+#endif
+            }
+        }
+
         friend inline bool comparesEqual(const DataReference &lhs, const DataReference &rhs)
         {
             return lhs.m_index == rhs.m_index
@@ -1020,60 +1046,55 @@ public:
     template <typename NewRange = range_type, if_assignable_range<NewRange> = true>
     void setRange(NewRange &&newRange)
     {
-        using namespace QRangeModelDetails;
-
-        auto *impl = storage.implementation();
-        const QModelIndex root = storage.root();
-        const qsizetype newLastRow = qsizetype(Impl::size(refTo(newRange))) - 1;
-        auto *oldRange = impl->childRange(root);
-        const qsizetype oldLastRow = qsizetype(Impl::size(oldRange)) - 1;
-
-        if (!root.isValid()) {
-            impl->beginResetModel();
-            impl->deleteOwnedRows();
-        } else if constexpr (is_tree<Impl>) {
-            if (oldLastRow > 0) {
-                impl->beginRemoveRows(root, 0, model()->rowCount(root) - 1);
-                impl->deleteRemovedRows(refTo(oldRange));
-                impl->endRemoveRows();
-            }
-            if (newLastRow > 0)
-                impl->beginInsertRows(root, 0, newLastRow);
-        } else {
-            Q_ASSERT_X(false, "QRangeModelAdapter::setRange",
-                       "Internal error: The root index in a table or list must be invalid.");
-        }
-        refTo(oldRange) = std::forward<NewRange>(newRange);
-        if (!root.isValid()) {
-            impl->endResetModel();
-        } else if constexpr (is_tree<Impl>) {
-            if (newLastRow > 0) {
-                Q_ASSERT(model()->hasChildren(root));
-                // if it was moved, then newRange is now likely to be empty. Get
-                // the inserted row.
-                impl->setParentRow(refTo(impl->childRange(storage.root())),
-                                   pointerTo(impl->rowData(root)));
-                impl->endInsertRows();
-            }
-        }
-        if constexpr (Impl::itemsAreQObjects) {
-            if (model()->autoConnectPolicy() == QRangeModel::AutoConnectPolicy::Full) {
-                const auto begin = QRangeModelDetails::begin(refTo(oldRange));
-                const auto end = QRangeModelDetails::end(refTo(oldRange));
-                int rowIndex = 0;
-                for (auto it = begin; it != end; ++it, ++rowIndex)
-                    impl->autoConnectPropertiesInRow(*it, rowIndex, root);
-            }
-        }
+        setRangeImpl(qsizetype(Impl::size(QRangeModelDetails::refTo(newRange))) - 1,
+            [&newRange](auto &oldRange) {
+            oldRange = std::forward<NewRange>(newRange);
+        });
     }
 
-    template <typename NewRange = range_type, if_assignable_range<NewRange> = true>
+    template <typename NewRange = range_type, if_assignable_range<NewRange> = true,
+              unless_adapter<NewRange> = true>
     QRangeModelAdapter &operator=(NewRange &&newRange)
     {
         setRange(std::forward<NewRange>(newRange));
         return *this;
     }
 
+    template <typename Row, if_assignable_range<std::initializer_list<Row>> = true>
+    void setRange(std::initializer_list<Row> newRange)
+    {
+        setRangeImpl(qsizetype(newRange.size() - 1), [&newRange](auto &oldRange) {
+            oldRange = newRange;
+        });
+    }
+
+    template <typename Row, if_assignable_range<std::initializer_list<Row>> = true>
+    QRangeModelAdapter &operator=(std::initializer_list<Row> newRange)
+    {
+        setRange(newRange);
+        return *this;
+    }
+
+    template <typename Row, if_assignable_range<std::initializer_list<Row>> = true>
+    void assign(std::initializer_list<Row> newRange)
+    {
+        setRange(newRange);
+    }
+
+    template <typename InputIterator, typename Sentinel, typename I = Impl, if_writable<I> = true>
+    void setRange(InputIterator first, Sentinel last)
+    {
+        setRangeImpl(qsizetype(std::distance(first, last) - 1), [first, last](auto &oldRange) {
+            oldRange.assign(first, last);
+        });
+    }
+
+    template <typename InputIterator, typename Sentinel, typename I = Impl, if_writable<I> = true>
+    void assign(InputIterator first, Sentinel last)
+    {
+        setRange(first, last);
+    }
+
     // iterator API
     ConstRowIterator cbegin() const
     {
@@ -1245,12 +1266,12 @@ public:
     decltype(auto) operator[](int row) const { return at(row); }
 
     template <typename I = Impl, if_table<I> = true, if_writable<I> = true>
-    decltype(auto) at(int row)
+    auto at(int row)
     {
         return RowReference{index(row, 0), this};
     }
     template <typename I = Impl, if_table<I> = true, if_writable<I> = true>
-    decltype(auto) operator[](int row) { return at(row); }
+    auto operator[](int row) { return at(row); }
 
     // at/operator[int, int] for table: returns value at row/column
     template <typename I = Impl, unless_list<I> = true>
@@ -1428,15 +1449,15 @@ public:
         return storage.m_model->insertColumn(before);
     }
 
-    template <typename D = row_type, typename I = Impl,
-              if_canInsertColumns<I> = true, if_compatible_data<D> = true>
+    template <typename D, typename I = Impl,
+              if_canInsertColumns<I> = true, if_compatible_column_data<D> = true>
     bool insertColumn(int before, D &&data)
     {
         return insertColumnImpl(before, storage.root(), std::forward<D>(data));
     }
 
     template <typename C, typename I = Impl,
-              if_canInsertColumns<I> = true, if_compatible_data_range<C> = true>
+              if_canInsertColumns<I> = true, if_compatible_column_range<C> = true>
     bool insertColumns(int before, C &&data)
     {
         return insertColumnsImpl(before, storage.root(), std::forward<C>(data));
@@ -1503,6 +1524,65 @@ private:
         Q_EMIT storage.implementation()->dataChanged(topLeft, bottomRight, {});
     }
 
+    void beginSetRangeImpl(Impl *impl, range_type *oldRange, qsizetype newLastRow)
+    {
+        const QModelIndex root = storage.root();
+        const qsizetype oldLastRow = qsizetype(Impl::size(oldRange)) - 1;
+
+        if (!root.isValid()) {
+            impl->beginResetModel();
+            impl->deleteOwnedRows();
+        } else if constexpr (is_tree<Impl>) {
+            if (oldLastRow > 0) {
+                impl->beginRemoveRows(root, 0, model()->rowCount(root) - 1);
+                impl->deleteRemovedRows(QRangeModelDetails::refTo(oldRange));
+                impl->endRemoveRows();
+            }
+            if (newLastRow > 0)
+                impl->beginInsertRows(root, 0, newLastRow);
+        } else {
+            Q_ASSERT_X(false, "QRangeModelAdapter::setRange",
+                       "Internal error: The root index in a table or list must be invalid.");
+        }
+    }
+
+    void endSetRangeImpl(Impl *impl, qsizetype newLastRow)
+    {
+        const QModelIndex root = storage.root();
+        if (!root.isValid()) {
+            impl->endResetModel();
+        } else if constexpr (is_tree<Impl>) {
+            if (newLastRow > 0) {
+                Q_ASSERT(model()->hasChildren(root));
+                // if it was moved, then newRange is now likely to be empty. Get
+                // the inserted row.
+                impl->setParentRow(QRangeModelDetails::refTo(impl->childRange(root)),
+                                   QRangeModelDetails::pointerTo(impl->rowData(root)));
+                impl->endInsertRows();
+            }
+        }
+    }
+
+    template <typename Assigner>
+    void setRangeImpl(qsizetype newLastRow, Assigner &&assigner)
+    {
+        auto *impl = storage.implementation();
+        auto *oldRange = impl->childRange(storage.root());
+        beginSetRangeImpl(impl, oldRange, newLastRow);
+        assigner(QRangeModelDetails::refTo(oldRange));
+        endSetRangeImpl(impl, newLastRow);
+
+        if constexpr (Impl::itemsAreQObjects) {
+            if (model()->autoConnectPolicy() == QRangeModel::AutoConnectPolicy::Full) {
+                const auto begin = QRangeModelDetails::begin(QRangeModelDetails::refTo(oldRange));
+                const auto end = QRangeModelDetails::end(QRangeModelDetails::refTo(oldRange));
+                int rowIndex = 0;
+                for (auto it = begin; it != end; ++it, ++rowIndex)
+                    impl->autoConnectPropertiesInRow(*it, rowIndex, storage.root());
+            }
+        }
+    }
+
     template <typename P>
     static auto setParentRow(P protocol, row_type &newRow, row_ptr parentRow)
         -> decltype(protocol.setParentRow(std::declval<row_type&>(), std::declval<row_ptr>()))