qrangemodeladapter.h

qt/qtbase/src/corelib/itemmodels/qrangemodeladapter.h

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2025 The Qt Company Ltd.

// 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 QRANGEMODELADAPTER_H

#define QRANGEMODELADAPTER_H

#include <QtCore/qrangemodeladapter_impl.h>

#include <QtCore/q26numeric.h>

QT_BEGIN_NAMESPACE

template <typename Range, typename Protocol = void, typename Model = QRangeModel>

class QT_TECH_PREVIEW_API QRangeModelAdapter

    using Impl = QRangeModelDetails::RangeImplementation<Range, Protocol>;

    using Storage = QRangeModelDetails::AdapterStorage<Model, Impl>;

    Storage storage;

#ifdef Q_QDOC

    using range_type = Range;

#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;

    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>;

    using row_ptr = typename Impl::wrapped_row_type *;

    using row_traits = typename Impl::row_traits;

    using item_type = std::remove_reference_t<typename row_traits::item_type>;

    using data_type = typename QRangeModelDetails::data_type<item_type>::type;

    using const_data_type = QRangeModelDetails::asConst_t<data_type>;

    using protocol_traits = typename Impl::protocol_traits;

    template <typename I> static constexpr bool is_list = I::protocol_traits::is_list;

    template <typename I> static constexpr bool is_table = I::protocol_traits::is_table;

    template <typename I> static constexpr bool is_tree = I::protocol_traits::is_tree;

    template <typename I> static constexpr bool canInsertColumns = I::dynamicColumns()

                                                                 && I::isMutable()

                                                                 && row_features::has_insert;

    template <typename I> static constexpr bool canRemoveColumns = I::dynamicColumns()

                                                                 && I::isMutable()

                                                                 && row_features::has_erase;

    template <typename I> using if_writable = std::enable_if_t<I::isMutable(), bool>;

    template <typename I> using if_list = std::enable_if_t<is_list<I>, bool>;

    template <typename I> using unless_list = std::enable_if_t<!is_list<I>, bool>;

    template <typename I> using if_table = std::enable_if_t<is_table<I>, bool>;

    template <typename I> using if_tree = std::enable_if_t<is_tree<I>, bool>;

    template <typename I> using unless_tree = std::enable_if_t<!is_tree<I>, bool>;

    template <typename I> using if_flat = std::enable_if_t<is_list<I> || is_table<I>, bool>;

    template <typename I>

    using if_canInsertRows = std::enable_if_t<I::canInsertRows(), bool>;

    template <typename I>

    using if_canRemoveRows = std::enable_if_t<I::canRemoveRows(), bool>;

    template <typename F>

    using if_canMoveItems = std::enable_if_t<F::has_rotate || F::has_splice, bool>;

    template <typename I>

    using if_canInsertColumns = std::enable_if_t<canInsertColumns<I>, bool>;

    template <typename I>

    using if_canRemoveColumns = std::enable_if_t<canRemoveColumns<I>, bool>;

    template <typename Row>

    static constexpr bool is_compatible_row = std::is_convertible_v<Row, const_row_reference>;

    template <typename Row>

    using if_compatible_row = std::enable_if_t<is_compatible_row<Row>, bool>;

    template <typename C>

    static constexpr bool is_compatible_row_range = is_compatible_row<

                                                          decltype(*std::begin(std::declval<C&>()))

>;

    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 = 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_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>;

    friend class QRangeModel;

    template <typename T>

    static constexpr bool is_adapter = QRangeModelDetails::is_any_of<q20::remove_cvref_t<T>,

                                                                     QRangeModelAdapter>::value;

    template <typename T>

    using unless_adapter = std::enable_if_t<!is_adapter<T>, bool>;

    template <typename R, typename P>

    using if_compatible_model_params =

        std::enable_if_t<

           std::conjunction_v<

                std::disjunction<

                    std::is_convertible<R &&, Range>,

                    std::is_convertible<R &&, Range &&> // for C-arrays

>,

                std::is_convertible<P, Protocol> // note, only void is expected to be convertible to void

         >, bool>;

#if !defined(Q_OS_VXWORKS) && !defined(Q_OS_INTEGRITY)

    // An adapter on a mutable range can make itself an adapter on a const

    // version of that same range. To make the constructor for a sub-range

    // accessible, befriend the mutable version. We can use more

    // generic pattern matching here, as we only use as input what asConst

    // might produce as output.

    template <typename T> static constexpr T asMutable(const T &);

    template <typename T> static constexpr T *asMutable(const T *);

    template <template <typename, typename...> typename U, typename T, typename ...Args>

    static constexpr U<T, Args...> asMutable(const U<const T, Args...> &);

    template <typename T>

    using asMutable_t = decltype(asMutable(std::declval<T>()));

    friend class QRangeModelAdapter<asMutable_t<Range>, Protocol, Model>;

#else

    template <typename R, typename P, typename M>

    friend class QRangeModelAdapter;

#endif

    explicit QRangeModelAdapter(const std::shared_ptr<QRangeModel> &model, const QModelIndex &root,

                                std::in_place_t) // disambiguate from range/protocol c'tor

        : storage{model, root}

{}

    explicit QRangeModelAdapter(QRangeModel *model)

        : storage(model)

{}

public:

    struct DataReference

#ifdef Q_QDOC

        using value_type = int;

        using const_value_type = const int;

        using pointer = void *;

#else

        using value_type = data_type;

        using const_value_type = const_data_type;

        using pointer = QRangeModelDetails::data_pointer_t<const_value_type>;

#endif

        explicit DataReference(const QModelIndex &index) noexcept

            : m_index(index)

{}

        DataReference(const DataReference &other) = default;

        DataReference(DataReference &&other) = default;

        // reference (not std::reference_wrapper) semantics

        DataReference &operator=(const DataReference &other)

            *this = other.get();

            return *this;

        DataReference &operator=(DataReference &&other)

            *this = other.get();

            return *this;

        ~DataReference() = default;

        DataReference &operator=(const value_type &value)

            assign(value);

            return *this;

        DataReference &operator=(value_type &&value)

            assign(std::move(value));

            return *this;

        const_value_type get() const

            Q_ASSERT_X(m_index.isValid(), "QRangeModelAdapter::at", "Index at position is invalid");

            return QRangeModelDetails::dataAtIndex<q20::remove_cvref_t<value_type>>(m_index);

        operator const_value_type() const

            return get();

        pointer operator->() const

            return {get()};

        bool isValid() const { return m_index.isValid(); }

    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

                || lhs.get() == rhs.get();

        Q_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT(DataReference)

        friend inline bool comparesEqual(const DataReference &lhs, const value_type &rhs)

            return lhs.get() == rhs;

        Q_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT(DataReference, value_type)

        friend inline void swap(DataReference lhs, DataReference rhs)

            const value_type lhsValue = lhs.get();

            lhs = rhs;

            rhs = lhsValue; // no point in moving, we have to go through QVariant anyway

#ifndef QT_NO_DEBUG_STREAM

        friend inline QDebug operator<<(QDebug dbg, const DataReference &ref)

            return dbg << ref.get();

#endif

#ifndef QT_NO_DATASTREAM

        friend inline QDataStream &operator<<(QDataStream &ds, const DataReference &ref)

            return ds << ref.get();

        friend inline QDataStream &operator>>(QDataStream &ds, DataReference &ref)

            value_type value;

            ds >> value;

            ref = std::move(value);

            return ds;

#endif

};

    template <typename Iterator, typename Adapter>

    struct ColumnIteratorBase

        using iterator_category = std::random_access_iterator_tag;

        using difference_type = int;

        ColumnIteratorBase() = default;

        ColumnIteratorBase(const ColumnIteratorBase &other) = default;

        ColumnIteratorBase(ColumnIteratorBase &&other) = default;

        ColumnIteratorBase &operator=(const ColumnIteratorBase &other) = default;

        ColumnIteratorBase &operator=(ColumnIteratorBase &&other) = default;

        ColumnIteratorBase(const QModelIndex &rowIndex, int column, Adapter *adapter) noexcept

            : m_rowIndex(rowIndex), m_column(column), m_adapter(adapter)

        void swap(ColumnIteratorBase &other) noexcept

            std::swap(m_rowIndex, other.m_rowIndex);

            std::swap(m_column, other.m_column);

            q_ptr_swap(m_adapter, other.m_adapter);

        friend Iterator &operator++(Iterator &that)

            ++that.m_column;

            return that;

        friend Iterator operator++(Iterator &that, int)

            auto copy = that;

            ++that;

            return copy;

        friend Iterator operator+(const Iterator &that, difference_type n)

            return {that.m_rowIndex, that.m_column + n, that.m_adapter};

        friend Iterator operator+(difference_type n, const Iterator &that)

            return that + n;

        friend Iterator &operator+=(Iterator &that, difference_type n)

            that.m_column += n;

            return that;

        friend Iterator &operator--(Iterator &that)

            --that.m_column;

            return that;

        friend Iterator operator--(Iterator &that, int)

            auto copy = that;

            --that;

            return copy;

        friend Iterator operator-(const Iterator &that, difference_type n)

            return {that.m_rowIndex, that.m_column - n, that.m_adapter};

        friend Iterator operator-(difference_type n, const Iterator &that)

            return that - n;

        friend Iterator &operator-=(Iterator &that, difference_type n)

            that.m_column -= n;

            return that;

        friend difference_type operator-(const Iterator &lhs, const Iterator &rhs)

            Q_PRE(lhs.m_rowIndex == rhs.m_rowIndex);

            Q_PRE(lhs.m_adapter == rhs.m_adapter);

            return lhs.m_column - rhs.m_column;

    protected:

        ~ColumnIteratorBase() = default;

        QModelIndex m_rowIndex;

        int m_column = -1;

        Adapter *m_adapter = nullptr;

    private:

        friend bool comparesEqual(const Iterator &lhs, const Iterator &rhs)

            Q_ASSERT(lhs.m_rowIndex == rhs.m_rowIndex);

            return lhs.m_column == rhs.m_column;

        friend Qt::strong_ordering compareThreeWay(const Iterator &lhs, const Iterator &rhs)

            Q_ASSERT(lhs.m_rowIndex == rhs.m_rowIndex);

            return qCompareThreeWay(lhs.m_column, rhs.m_column);

        Q_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT(Iterator)

#ifndef QT_NO_DEBUG_STREAM

        friend inline QDebug operator<<(QDebug dbg, const Iterator &it)

            QDebugStateSaver saver(dbg);

            dbg.nospace();

            return dbg << "ColumnIterator(" << it.m_rowIndex.siblingAtColumn(it.m_column) << ")";

#endif

};

    struct ConstColumnIterator : ColumnIteratorBase<ConstColumnIterator, const QRangeModelAdapter>

    private:

        using Base = ColumnIteratorBase<ConstColumnIterator, const QRangeModelAdapter>;

    public:

        using difference_type = typename Base::difference_type;

        using value_type = data_type;

        using reference = const_data_type;

        using pointer = QRangeModelDetails::data_pointer_t<value_type>;

        using Base::Base;

        using Base::operator=;

        ~ConstColumnIterator() = default;

        pointer operator->() const

            return pointer{operator*()};

        reference operator*() const

            return std::as_const(this->m_adapter)->at(this->m_rowIndex.row(), this->m_column);

        reference operator[](difference_type n) const

            return *(*this + n);

};

    struct ColumnIterator : ColumnIteratorBase<ColumnIterator, QRangeModelAdapter>

    private:

        using Base = ColumnIteratorBase<ColumnIterator, QRangeModelAdapter>;

    public:

        using difference_type = typename Base::difference_type;

        using value_type = DataReference;

        using reference = DataReference;

        using pointer = reference;

        using Base::Base;

        using Base::operator=;

        ~ColumnIterator() = default;

        operator ConstColumnIterator() const

            return ConstColumnIterator{this->m_rowIndex, this->m_column, this->m_adapter};

        pointer operator->() const

            return operator*();

        reference operator*() const

            return reference{this->m_rowIndex.siblingAtColumn(this->m_column)};

        reference operator[](difference_type n) const

            return *(*this + n);

};

    template <typename Reference, typename const_row_type,

              bool = std::is_reference_v<const_row_type>,

              bool = std::is_pointer_v<const_row_type>>

    struct RowGetter

        const_row_type get() const

            const Reference *that = static_cast<const Reference *>(this);

            const auto *impl = that->m_adapter->storage.implementation();

            auto *childRange = impl->childRange(that->m_index.parent());

            if constexpr (std::is_convertible_v<const row_type &, const_row_type>) {

                return *std::next(QRangeModelDetails::adl_begin(childRange), that->m_index.row());

            } else {

                const auto &row = *std::next(QRangeModelDetails::adl_begin(childRange),

                                             that->m_index.row());

                return const_row_type{QRangeModelDetails::adl_begin(row),

                                      QRangeModelDetails::adl_end(row)};

        const_row_type operator->() const

            return {get()};

        operator const_row_type() const

            return get();

};

    template <typename Reference, typename const_row_type>

    struct RowGetter<Reference, const_row_type, true, false>

        const_row_type get() const

            const Reference *that = static_cast<const Reference *>(this);

            const auto *impl = that->m_adapter->storage.implementation();

            return *std::next(QRangeModelDetails::begin(

                                QRangeModelDetails::refTo(impl->childRange(that->m_index.parent()))),

                              that->m_index.row());

        auto operator->() const

            return std::addressof(get());

        operator const_row_type() const

            return get();

};

    template <typename Reference, typename const_row_type>

    struct RowGetter<Reference, const_row_type, false, true>

        const_row_type get() const

            const Reference *that = static_cast<const Reference *>(this);

            const auto *impl = that->m_adapter->storage.implementation();

            return *std::next(QRangeModelDetails::begin(

                                QRangeModelDetails::refTo(impl->childRange(that->m_index.parent()))),

                              that->m_index.row());

        const_row_type operator->() const

            return get();

        operator const_row_type() const

            return get();

};

    template <typename Reference, typename Adapter>

    struct RowReferenceBase : RowGetter<Reference, QRangeModelDetails::asConstRow_t<row_type>>

        using const_iterator = ConstColumnIterator;

        using size_type = int;

        using difference_type = int;

        using const_row_type = QRangeModelDetails::asConstRow_t<row_type>;

        RowReferenceBase(const QModelIndex &index, Adapter *adapter) noexcept

            : m_index(index), m_adapter(adapter)

{}

        template <typename I = Impl, if_tree<I> = true>

        bool hasChildren() const

            return m_adapter->model()->hasChildren(m_index);

        template <typename I = Impl, if_tree<I> = true>

        auto children() const

            using ConstRange = QRangeModelDetails::asConst_t<Range>;

            return QRangeModelAdapter<ConstRange, Protocol, Model>(m_adapter->storage.m_model,

                                                                   m_index, std::in_place);

        ConstColumnIterator cbegin() const

            return ConstColumnIterator{m_index, 0, m_adapter};

        ConstColumnIterator cend() const

            return ConstColumnIterator{m_index, m_adapter->columnCount(), m_adapter};

        ConstColumnIterator begin() const { return cbegin(); }

        ConstColumnIterator end() const { return cend(); }

        size_type size() const

            return m_adapter->columnCount();

        auto at(int column) const

            Q_ASSERT(column >= 0 && column < m_adapter->columnCount());

            return *ConstColumnIterator{m_index, column, m_adapter};

        auto operator[](int column) const

            return at(column);

    protected:

        friend struct RowGetter<Reference, const_row_type>;

        ~RowReferenceBase() = default;

        QModelIndex m_index;

        Adapter *m_adapter;

    private:

        friend bool comparesEqual(const Reference &lhs, const Reference &rhs)

            Q_ASSERT(lhs.m_adapter == rhs.m_adapter);

            return lhs.m_index == rhs.m_index;

        friend Qt::strong_ordering compareThreeWay(const Reference &lhs, const Reference &rhs)

            Q_ASSERT(lhs.m_adapter == rhs.m_adapter);

            return qCompareThreeWay(lhs.m_index, rhs.m_index);

        Q_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT(Reference)

        friend bool comparesEqual(const Reference &lhs, const row_type &rhs)

            return lhs.get() == rhs;

        Q_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT(Reference, row_type)

#ifndef QT_NO_DEBUG_STREAM

        friend inline QDebug operator<<(QDebug dbg, const Reference &ref)

            QDebugStateSaver saver(dbg);

            dbg.nospace();

            return dbg << "RowReference(" << ref.m_index << ")";

#endif

#ifndef QT_NO_DATASTREAM

        friend inline QDataStream &operator<<(QDataStream &ds, const Reference &ref)

            return ds << ref.get();

#endif

};

    struct ConstRowReference : RowReferenceBase<ConstRowReference, const QRangeModelAdapter>

    private:

        using Base = RowReferenceBase<ConstRowReference, const QRangeModelAdapter>;

    public:

        using Base::Base;

        ConstRowReference() = default;

        ConstRowReference(const ConstRowReference &) = default;

        ConstRowReference(ConstRowReference &&) = default;

        ConstRowReference &operator=(const ConstRowReference &) = default;

        ConstRowReference &operator=(ConstRowReference &&) = default;

        ~ConstRowReference() = default;

};

    struct RowReference : RowReferenceBase<RowReference, QRangeModelAdapter>

    private:

        using Base = RowReferenceBase<RowReference, QRangeModelAdapter>;

    public:

        using iterator = ColumnIterator;

        using const_iterator = typename Base::const_iterator;

        using size_type = typename Base::size_type;

        using difference_type = typename Base::difference_type;

#ifdef Q_QDOC

        using row_type = int;

#endif

        using const_row_type = typename Base::const_row_type;

        using Base::Base;

        RowReference() = delete;

        ~RowReference() = default;

        RowReference(const RowReference &other) = default;

        RowReference(RowReference &&other) = default;

        // assignment has reference (std::reference_wrapper) semantics

        RowReference &operator=(const ConstRowReference &other)

            *this = other.get();

            return *this;

        RowReference &operator=(const RowReference &other)

            *this = other.get();

            return *this;

        RowReference &operator=(const row_type &other)

            assign(other);

            return *this;

        RowReference &operator=(row_type &&other)

            assign(std::move(other));

            return *this;

        operator ConstRowReference() const

            return ConstRowReference{this->m_index, this->m_adapter};

        template <typename ConstRowType = const_row_type,

                  std::enable_if_t<!std::is_same_v<ConstRowType, const row_type &>, bool> = true>

        RowReference &operator=(const ConstRowType &other)

            assign(other);

            return *this;

        template <typename T, typename It, typename Sentinel>

        RowReference &operator=(const QRangeModelDetails::RowView<T, It, Sentinel> &other)

            *this = row_type{other.begin(), other.end()};

            return *this;

        friend inline void swap(RowReference lhs, RowReference rhs)

            auto lhsRow = lhs.get();

            lhs = rhs.get();

            rhs = std::move(lhsRow);

        template <typename I = Impl, if_tree<I> = true>

        auto children()

            return QRangeModelAdapter(this->m_adapter->storage.m_model, this->m_index,

                                      std::in_place);

        using Base::begin;

        ColumnIterator begin()

            return ColumnIterator{this->m_index, 0, this->m_adapter};

        using Base::end;

        ColumnIterator end()

            return ColumnIterator{this->m_index, this->m_adapter->columnCount(), this->m_adapter};

        using Base::at;

        auto at(int column)

            Q_ASSERT(column >= 0 && column < this->m_adapter->columnCount());

            return *ColumnIterator{this->m_index, column, this->m_adapter};

        using Base::operator[];

        auto operator[](int column)

            return at(column);

    private:

        template <typename RHS>

        void verifyRows(const row_type &oldRow, const RHS &newRow)

            if constexpr (QRangeModelDetails::test_size<row_type>::value) {

                // prevent that tables get populated with wrongly sized rows

                Q_ASSERT_X(Impl::size(newRow) == Impl::size(oldRow),

                           "RowReference::operator=()",

                           "The new row has the wrong size!");

            if constexpr (is_tree<Impl>) {

                // we cannot hook invalid rows up to the tree hierarchy

                Q_ASSERT_X(QRangeModelDetails::isValid(newRow),

                           "RowReference::operator=()",

                           "An invalid row can not inserted into a tree!");

        template <typename R>

        void assign(R &&other)

            auto *impl = this->m_adapter->storage.implementation();

            decltype(auto) oldRow = impl->rowData(this->m_index);

            verifyRows(oldRow, other);

            if constexpr (is_tree<Impl>) {

                auto &protocol = impl->protocol();

                auto *oldParent = protocol.parentRow(QRangeModelDetails::refTo(oldRow));

                // the old children will be removed; we don't try to overwrite

                // them with the new children, we replace them completely

                if (decltype(auto) oldChildren = protocol.childRows(QRangeModelDetails::refTo(oldRow));

                    QRangeModelDetails::isValid(oldChildren)) {

                    if (int oldChildCount = this->m_adapter->model()->rowCount(this->m_index)) {

                        impl->beginRemoveRows(this->m_index, 0, oldChildCount - 1);

                        impl->deleteRemovedRows(QRangeModelDetails::refTo(oldChildren));

                        // make sure the list is empty before we emit rowsRemoved

                        QRangeModelDetails::refTo(oldChildren) = range_type{};

                        impl->endRemoveRows();

                if constexpr (protocol_traits::has_deleteRow)

                    protocol.deleteRow(oldRow);

                oldRow = std::forward<R>(other);

                if constexpr (protocol_traits::has_setParentRow) {

                    protocol.setParentRow(QRangeModelDetails::refTo(oldRow),

                                          QRangeModelDetails::pointerTo(oldParent));

                    if (decltype(auto) newChildren = protocol.childRows(QRangeModelDetails::refTo(oldRow));

                        QRangeModelDetails::isValid(newChildren)) {

                        impl->beginInsertRows(this->m_index, 0,

                                              Impl::size(QRangeModelDetails::refTo(newChildren)) - 1);

                        impl->setParentRow(QRangeModelDetails::refTo(newChildren),

                                           QRangeModelDetails::pointerTo(oldRow));

                        impl->endInsertRows();

            } else {

                oldRow = std::forward<R>(other);

            this->m_adapter->emitDataChanged(this->m_index,

                                             this->m_index.siblingAtColumn(this->m_adapter->columnCount() - 1));

            if constexpr (Impl::itemsAreQObjects) {

                if (this->m_adapter->model()->autoConnectPolicy() == QRangeModel::AutoConnectPolicy::Full) {

                    impl->autoConnectPropertiesInRow(oldRow, this->m_index.row(), this->m_index.parent());

                    if constexpr (is_tree<Impl>)

                        impl->autoConnectProperties(this->m_index);

#ifndef QT_NO_DATASTREAM

        friend inline QDataStream &operator>>(QDataStream &ds, RowReference &ref)

            row_type value;

            ds >> value;

            ref = value;

            return ds;

#endif

};

    template <typename Iterator, typename Adapter>

    struct RowIteratorBase : QRangeModelDetails::ParentIndex<is_tree<Impl>>

        using iterator_category = std::random_access_iterator_tag;

        using difference_type = int;

        RowIteratorBase() = default;

        RowIteratorBase(const RowIteratorBase &) = default;

        RowIteratorBase(RowIteratorBase &&) = default;

        RowIteratorBase &operator=(const RowIteratorBase &) = default;

        RowIteratorBase &operator=(RowIteratorBase &&) = default;

        RowIteratorBase(int row, const QModelIndex &parent, Adapter *adapter)

            : QRangeModelDetails::ParentIndex<is_tree<Impl>>{parent}

            , m_row(row), m_adapter(adapter)

{}

        void swap(RowIteratorBase &other) noexcept

            qSwap(m_row, other.m_row);

            qSwap(this->m_rootIndex, other.m_rootIndex);

            q_ptr_swap(m_adapter, other.m_adapter);

        friend Iterator &operator++(Iterator &that)

            ++that.m_row;

            return that;

        friend Iterator operator++(Iterator &that, int)

            auto copy = that;

            ++that;

            return copy;

        friend Iterator operator+(const Iterator &that, difference_type n)

            return {that.m_row + n, that.root(), that.m_adapter};

        friend Iterator operator+(difference_type n, const Iterator &that)

            return that + n;

        friend Iterator &operator+=(Iterator &that, difference_type n)

            that.m_row += n;

            return that;

        friend Iterator &operator--(Iterator &that)

            --that.m_row;

            return that;

        friend Iterator operator--(Iterator &that, int)

            auto copy = that;

            --that;

            return copy;

        friend Iterator operator-(const Iterator &that, difference_type n)

            return {that.m_row - n, that.root(), that.m_adapter};

        friend Iterator operator-(difference_type n, const Iterator &that)

            return that - n;

        friend Iterator &operator-=(Iterator &that, difference_type n)

            that.m_row -= n;

            return that;

        friend difference_type operator-(const Iterator &lhs, const Iterator &rhs)

            return lhs.m_row - rhs.m_row;

    protected:

        ~RowIteratorBase() = default;

        int m_row = -1;

        Adapter *m_adapter = nullptr;

    private:

        friend bool comparesEqual(const Iterator &lhs, const Iterator &rhs) noexcept

            return lhs.m_row == rhs.m_row && lhs.root() == rhs.root();

        friend Qt::strong_ordering compareThreeWay(const Iterator &lhs, const Iterator &rhs) noexcept

            if (lhs.root() == rhs.root())

                return qCompareThreeWay(lhs.m_row, rhs.m_row);

            return qCompareThreeWay(lhs.root(), rhs.root());

        Q_DECLARE_STRONGLY_ORDERED(Iterator)

#ifndef QT_NO_DEBUG_STREAM

        friend inline QDebug operator<<(QDebug dbg, const Iterator &it)

            QDebugStateSaver saver(dbg);

            dbg.nospace();

            return dbg << "RowIterator(" << it.m_row << it.root() << ")";

#endif

};

public:

    struct ConstRowIterator : public RowIteratorBase<ConstRowIterator, const QRangeModelAdapter>

    private:

        using Base = RowIteratorBase<ConstRowIterator, const QRangeModelAdapter>;

    public:

        using Base::Base;

        using difference_type = typename Base::difference_type;

        using value_type = std::conditional_t<is_list<Impl>,

                                              const_data_type,

                                              ConstRowReference>;

        using reference = std::conditional_t<is_list<Impl>,

                                             const_data_type,

                                             ConstRowReference>;

        using pointer = std::conditional_t<is_list<Impl>,

                                           QRangeModelDetails::data_pointer_t<const_data_type>,

                                           ConstRowReference>;

        ConstRowIterator(const ConstRowIterator &other) = default;

        ConstRowIterator(ConstRowIterator &&other) = default;

        ConstRowIterator &operator=(const ConstRowIterator &other) = default;

        ConstRowIterator &operator=(ConstRowIterator &&other) = default;

        ~ConstRowIterator() = default;

        pointer operator->() const

            return pointer{operator*()};

        reference operator*() const

            if constexpr (is_list<Impl>) {

                return this->m_adapter->at(this->m_row);

            } else {

                const QModelIndex index = this->m_adapter->model()->index(this->m_row, 0,

                                                                          this->root());

                return ConstRowReference{index, this->m_adapter};

        reference operator[](difference_type n) const

            return *(*this + n);

};

    struct RowIterator : public RowIteratorBase<RowIterator, QRangeModelAdapter>

    private:

        using Base = RowIteratorBase<RowIterator, QRangeModelAdapter>;

    public:

        using Base::Base;

        using difference_type = typename Base::difference_type;

        using value_type = std::conditional_t<is_list<Impl>,

                                              DataReference,

                                              RowReference>;

        using reference = std::conditional_t<is_list<Impl>,

                                             DataReference,

                                             RowReference>;

        using pointer = std::conditional_t<is_list<Impl>,

                                           DataReference,

                                           RowReference>;

        RowIterator(const RowIterator &other) = default;

        RowIterator(RowIterator &&other) = default;

        RowIterator &operator=(const RowIterator &other) = default;

        RowIterator &operator=(RowIterator &&other) = default;

        ~RowIterator() = default;

        operator ConstRowIterator() const

            return ConstRowIterator{this->m_row, this->root(), this->m_adapter};

        pointer operator->() const

            return pointer{operator*()};

        reference operator*() const

            const QModelIndex index = this->m_adapter->model()->index(this->m_row, 0, this->root());

            if constexpr (is_list<Impl>) {

                return reference{index};

            } else {

                return reference{index, this->m_adapter};

        reference operator[](difference_type n) const

            return *(*this + n);

};

    using const_iterator = ConstRowIterator;

    using iterator = RowIterator;

    template <typename R,

              typename P,

              if_compatible_model_params<R, P> = true>

    explicit QRangeModelAdapter(R &&range, P &&protocol)

        : QRangeModelAdapter(new Model(QRangeModelDetails::forwardOrConvert<Range>(std::forward<R>(range)),

                                       QRangeModelDetails::forwardOrConvert<Protocol>(std::forward<P>(protocol))))

{}

    template <typename R,

              typename P = void, // to enable the ctr for void protocols only

              if_compatible_model_params<R, P> = true,

              unless_adapter<R> = true>

    explicit QRangeModelAdapter(R &&range)

        : QRangeModelAdapter(new Model(QRangeModelDetails::forwardOrConvert<Range>(std::forward<R>(range))))

{}

    // compiler-generated copy/move SMF are fine!

    Model *model() const

        return storage.m_model.get();

    const range_type &range() const

        return QRangeModelDetails::refTo(storage.implementation()->childRange(storage.root()));

    template <typename NewRange = range_type, if_assignable_range<NewRange> = true>

    void assign(NewRange &&newRange)

        assignImpl(qsizetype(Impl::size(QRangeModelDetails::refTo(newRange))),

            [&newRange](auto &oldRange) {

            oldRange = std::forward<NewRange>(newRange);

});

    template <typename NewRange = range_type, if_assignable_range<NewRange> = true,

              unless_adapter<NewRange> = true>

    QRangeModelAdapter &operator=(NewRange &&newRange)

        assign(std::forward<NewRange>(newRange));

        return *this;

    template <typename Row, if_assignable_range<std::initializer_list<Row>> = true>

    void assign(std::initializer_list<Row> newRange)

        assignImpl(newRange.size(), [&newRange](auto &oldRange) {

            oldRange = newRange;

});

    template <typename Row, if_assignable_range<std::initializer_list<Row>> = true>

    QRangeModelAdapter &operator=(std::initializer_list<Row> newRange)

        assign(newRange);

        return *this;

    template <typename InputIterator, typename Sentinel, typename I = Impl, if_writable<I> = true>

    void assign(InputIterator first, Sentinel last)

        assignImpl(size_t(std::distance(first, last)), [first, last](auto &oldRange) {

            oldRange.assign(first, last);

});

    // iterator API

    ConstRowIterator cbegin() const

        return ConstRowIterator{ 0, storage.root(), this };

    ConstRowIterator begin() const { return cbegin(); }

    ConstRowIterator cend() const

        return ConstRowIterator{ rowCount(), storage.root(), this };

    ConstRowIterator end() const { return cend(); }

    template <typename I = Impl, if_writable<I> = true>

    RowIterator begin()

        return RowIterator{ 0, storage.root(), this };

    template <typename I = Impl, if_writable<I> = true>

    RowIterator end()

        return RowIterator{ rowCount(), storage.root(), this };

    int size() const

        return rowCount();

    template <typename I = Impl, if_list<I> = true>

    QModelIndex index(int row) const

        return storage->index(row, 0, storage.root());

    template <typename I = Impl, unless_list<I> = true>

    QModelIndex index(int row, int column) const

        return storage->index(row, column, storage.root());

    template <typename I = Impl, if_tree<I> = true>

    QModelIndex index(QSpan<const int> path, int col) const

        QModelIndex result = storage.root();

        auto count = path.size();

        for (const int r : path) {

            if (--count)

                result = storage->index(r, 0, result);

            else

                result = storage->index(r, col, result);

        return result;

    int columnCount() const

        // all rows and tree branches have the same column count

        return storage->columnCount({});

    int rowCount() const

        return storage->rowCount(storage.root());

    template <typename I = Impl, if_tree<I> = true>

    int rowCount(int row) const

        return rowCount(index(row, 0));

    template <typename I = Impl, if_tree<I> = true>

    int rowCount(QSpan<const int> path) const

        return rowCount(index(path, 0));

    template <typename I = Impl, if_tree<I> = true>

    int rowCount(const QModelIndex &index) const

        return storage->rowCount(index);

    template <typename I = Impl, if_tree<I> = true>

    constexpr bool hasChildren(int row) const

        return hasChildren(index(row, 0));

    template <typename I = Impl, if_tree<I> = true>

    constexpr bool hasChildren(QSpan<const int> path) const

        return hasChildren(index(path, 0));

    template <typename I = Impl, if_tree<I> = true>

    constexpr bool hasChildren(const QModelIndex &index) const

        return storage.m_model->hasChildren(index);

    template <typename I = Impl, if_list<I> = true>

    QVariant data(int row) const

        return data(index(row));

    template <typename I = Impl, if_list<I> = true>

    QVariant data(int row, int role) const

        return data(index(row), role);

    template <typename I = Impl, if_list<I> = true, if_writable<I> = true>

    bool setData(int row, const QVariant &value, int role = Qt::EditRole)

        return setData(index(row), value, role);

    template <typename I = Impl, unless_list<I> = true>

    QVariant data(int row, int column) const

        return data(index(row, column));

    template <typename I = Impl, unless_list<I> = true>

    QVariant data(int row, int column, int role) const

        return data(index(row, column), role);

    template <typename I = Impl, unless_list<I> = true, if_writable<I> = true>

    bool setData(int row, int column, const QVariant &value, int role = Qt::EditRole)

        return setData(index(row, column), value, role);

    template <typename I = Impl, if_tree<I> = true>

    QVariant data(QSpan<const int> path, int column) const

        return data(index(path, column));

    template <typename I = Impl, if_tree<I> = true>

    QVariant data(QSpan<const int> path, int column, int role) const

        return data(index(path, column), role);

    template <typename I = Impl, if_tree<I> = true, if_writable<I> = true>

    bool setData(QSpan<const int> path, int column, const QVariant &value, int role = Qt::EditRole)

        return setData(index(path, column), value, role);

    QVariant data(const QModelIndex &index) const

        return QRangeModelDetails::dataAtIndex<QVariant>(index);

    QVariant data(const QModelIndex &index, int role) const

        return QRangeModelDetails::dataAtIndex<QVariant>(index, role);

    template <typename I = Impl, if_writable<I> = true>

    bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole)

        return storage->setData(index, value, role);

    // at/operator[int] for list: returns value at row

    // if multi-role value: return the entire object

    template <typename I= Impl, if_list<I> = true>

    const_data_type at(int row) const

        return QRangeModelDetails::dataAtIndex<data_type>(index(row));

    template <typename I = Impl, if_list<I> = true>

    const_data_type operator[](int row) const { return at(row); }

    template <typename I= Impl, if_list<I> = true, if_writable<I> = true>

    auto at(int row) {

        const QModelIndex idx = this->index(row);

        Q_ASSERT_X(idx.isValid(), "QRangeModelAdapter::at", "Index at row is invalid");

        return DataReference{idx};

    template <typename I = Impl, if_list<I> = true, if_writable<I> = true>

    auto operator[](int row) {

        const QModelIndex idx = this->index(row);

        Q_ASSERT_X(idx.isValid(), "QRangeModelAdapter::operator[]", "Index at row is invalid");

        return DataReference{idx};

    // at/operator[int] for table or tree: a reference or view of the row

    template <typename I = Impl, unless_list<I> = true>

    decltype(auto) at(int row) const

        return ConstRowReference{index(row, 0), this}.get();

    template <typename I = Impl, unless_list<I> = true>

    decltype(auto) operator[](int row) const { return at(row); }

    template <typename I = Impl, if_table<I> = true, if_writable<I> = true>

    auto at(int row)

        return RowReference{index(row, 0), this};

    template <typename I = Impl, if_table<I> = true, if_writable<I> = true>

    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>

    const_data_type at(int row, int column) const

        return QRangeModelDetails::dataAtIndex<data_type>(index(row, column));

#ifdef __cpp_multidimensional_subscript

    template <typename I = Impl, unless_list<I> = true>

    const_data_type operator[](int row, int column) const { return at(row, column); }

#endif

    template <typename I = Impl, unless_list<I> = true, if_writable<I> = true>

    auto at(int row, int column)

        const QModelIndex idx = this->index(row, column);

        Q_ASSERT_X(idx.isValid(), "QRangeModelAdapter::at", "Index at cell is invalid");

        return DataReference{idx};

#ifdef __cpp_multidimensional_subscript

    template <typename I = Impl, unless_list<I> = true, if_writable<I> = true>

    auto operator[](int row, int column)

        const QModelIndex idx = this->index(row, column);

        Q_ASSERT_X(idx.isValid(), "QRangeModelAdapter::operator[]", "Index at cell is invalid");

        return DataReference{idx};

#endif

    // at/operator[int] for tree: return a wrapper that maintains reference to

    // parent.

    template <typename I = Impl, if_tree<I> = true, if_writable<I> = true>

    auto at(int row)

        return RowReference{index(row, 0), this};

    template <typename I = Impl, if_tree<I> = true, if_writable<I> = true>

    auto operator[](int row) { return at(row); }

    // at/operator[path] for tree: a reference or view of the row

    template <typename I = Impl, if_tree<I> = true>

    decltype(auto) at(QSpan<const int> path) const

        return ConstRowReference{index(path, 0), this}.get();

    template <typename I = Impl, if_tree<I> = true>

    decltype(auto) operator[](QSpan<const int> path) const { return at(path); }

    template <typename I = Impl, if_tree<I> = true, if_writable<I> = true>

    auto at(QSpan<const int> path)

        return RowReference{index(path, 0), this};

    template <typename I = Impl, if_tree<I> = true, if_writable<I> = true>

    auto operator[](QSpan<const int> path) { return at(path); }

    // at/operator[path, column] for tree: return value

    template <typename I = Impl, if_tree<I> = true>

    const_data_type at(QSpan<const int> path, int column) const

        Q_PRE(path.size());

        return QRangeModelDetails::dataAtIndex<data_type>(index(path, column));

#ifdef __cpp_multidimensional_subscript

    template <typename I = Impl, if_tree<I> = true>

    const_data_type operator[](QSpan<const int> path, int column) const { return at(path, column); }

#endif

    template <typename I = Impl, if_tree<I> = true, if_writable<I> = true>

    auto at(QSpan<const int> path, int column)

        Q_PRE(path.size());

        const QModelIndex idx = this->index(path, column);

        Q_ASSERT_X(idx.isValid(), "QRangeModelAdapter::at", "Index at path is invalid");

        return DataReference{idx};

#ifdef __cpp_multidimensional_subscript

    template <typename I = Impl, if_tree<I> = true, if_writable<I> = true>

    auto operator[](QSpan<const int> path, int column)

        const QModelIndex idx = this->index(path, column);

        Q_ASSERT_X(idx.isValid(), "QRangeModelAdapter::operator[]", "Index at path is invalid");

        return DataReference{idx};

#endif

    const_data_type at(const QModelIndex &index) const

        Q_ASSERT_X(index.isValid(), "QRangeModelAdapter::at", "Index is invalid");

        return QRangeModelDetails::dataAtIndex<data_type>(index);

    template <typename I = Impl, if_writable<I> = true>

    auto at(const QModelIndex &index)

        Q_ASSERT_X(index.isValid(), "QRangeModelAdapter::at", "Index is invalid");

        return DataReference{index};

    template <typename I = Impl, if_canInsertRows<I> = true>

    bool insertRow(int before)

        return storage.m_model->insertRow(before);

    template <typename I = Impl, if_canInsertRows<I> = true, if_tree<I> = true>

    bool insertRow(QSpan<const int> before)

        Q_PRE(before.size());

        return insertRow(before.back(), this->index(before.first(before.size() - 1), 0));

    template <typename I = Impl, if_canInsertRows<I> = true, if_tree<I> = true>

    bool insertRow(int before, const QModelIndex &parent)

        return storage.m_model->insertRow(before, parent);

    template <typename D = row_type, typename I = Impl,

              if_canInsertRows<I> = true, if_compatible_row<D> = true>

    bool insertRow(int before, D &&data)

        return insertRowImpl(before, storage.root(), std::forward<D>(data));

    template <typename D = row_type, typename I = Impl,

              if_canInsertRows<I> = true, if_compatible_row<D> = true, if_tree<I> = true>

    bool insertRow(QSpan<const int> before, D &&data)

        return insertRow(before.back(), this->index(before.sliced(0, before.size() - 1), 0),

                         std::forward<D>(data));

    template <typename D = row_type, typename I = Impl,

              if_canInsertRows<I> = true, if_compatible_row<D> = true, if_tree<I> = true>

    bool insertRow(int before, const QModelIndex &parent, D &&data)

        return insertRowImpl(before, parent, std::forward<D>(data));

    template <typename C, typename I = Impl,

              if_canInsertRows<I> = true, if_compatible_row_range<C> = true>

    bool insertRows(int before, C &&data)

        return insertRowsImpl(before, storage.root(), std::forward<C>(data));

    template <typename C, typename I = Impl,

              if_canInsertRows<I> = true, if_compatible_row_range<C> = true, if_tree<I> = true>

    bool insertRows(QSpan<const int> before, C &&data)

        return insertRows(before.back(), this->index(before.sliced(0, before.size() - 1), 0),

                          std::forward<C>(data));

    template <typename C, typename I = Impl,

              if_canInsertRows<I> = true, if_compatible_row_range<C> = true, if_tree<I> = true>

    bool insertRows(int before, const QModelIndex &parent, C &&data)

        return insertRowsImpl(before, parent, std::forward<C>(data));

    template <typename I = Impl, if_canRemoveRows<I> = true>

    bool removeRow(int row)

        return removeRows(row, 1);

    template <typename I = Impl, if_canRemoveRows<I> = true, if_tree<I> = true>

    bool removeRow(QSpan<const int> path)

        return removeRows(path, 1);

    template <typename I = Impl, if_canRemoveRows<I> = true, if_tree<I> = true>

    bool removeRow(int row, const QModelIndex &parent)

        return removeRows(row, 1, parent);

    template <typename I = Impl, if_canRemoveRows<I> = true>

    bool removeRows(int row, int count)

        return storage->removeRows(row, count, storage.root());

    template <typename I = Impl, if_canRemoveRows<I> = true, if_tree<I> = true>

    bool removeRows(QSpan<const int> path, int count)

        return removeRows(path.back(), count, this->index(path.first(path.size() - 1), 0));

    template <typename I = Impl, if_canRemoveRows<I> = true, if_tree<I> = true>

    bool removeRows(int row, int count, const QModelIndex &parent)

        return storage->removeRows(row, count, parent);

    template <typename F = range_features, if_canMoveItems<F> = true>

    bool moveRow(int source, int destination)

        return moveRows(source, 1, destination);

    template <typename F = range_features, if_canMoveItems<F> = true>

    bool moveRows(int source, int count, int destination)

        return storage->moveRows(storage.root(), source, count, storage.root(), destination);

    template <typename I = Impl, typename F = range_features,

              if_canMoveItems<F> = true, if_tree<I> = true>

    bool moveRow(QSpan<const int> source, QSpan<const int> destination)

        return moveRows(source, 1, destination);

    template <typename I = Impl, typename F = range_features,

              if_canMoveItems<F> = true, if_tree<I> = true>

    bool moveRow(const QModelIndex &sourceParent, int sourceRow,

                 const QModelIndex &destinationParent, int destinationChild)

        return moveRows(sourceParent, sourceRow, 1, destinationParent, destinationChild);

    template <typename I = Impl, typename F = range_features,

              if_canMoveItems<F> = true, if_tree<I> = true>

    bool moveRows(QSpan<const int> source, int count, QSpan<const int> destination)

        return moveRows(this->index(source.first(source.size() - 1), 0),

                        source.back(),

                        count,

                        this->index(destination.first(destination.size() - 1), 0),

                        destination.back());

    template <typename I = Impl, typename F = range_features,

              if_canMoveItems<F> = true, if_tree<I> = true>

    bool moveRows(const QModelIndex &sourceParent, int sourceRow, int count,

                  const QModelIndex &destinationParent, int destinationChild)

        return storage->moveRows(sourceParent, sourceRow, count,

                                 destinationParent, destinationChild);

    template <typename I = Impl, if_canInsertColumns<I> = true>

    bool insertColumn(int before)

        return storage.m_model->insertColumn(before);

    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_column_range<C> = true>

    bool insertColumns(int before, C &&data)

        return insertColumnsImpl(before, storage.root(), std::forward<C>(data));

    template <typename I = Impl, if_canRemoveColumns<I> = true>

    bool removeColumn(int column)

        return storage.m_model->removeColumn(column);

    template <typename I = Impl, if_canRemoveColumns<I> = true>

    bool removeColumns(int column, int count)

        return storage->removeColumns(column, count, {});

    template <typename F = row_features, if_canMoveItems<F> = true>

    bool moveColumn(int from, int to)

        return moveColumns(from, 1, to);

    template <typename F = row_features, if_canMoveItems<F> = true>

    bool moveColumns(int from, int count, int to)

        return storage->moveColumns(storage.root(), from, count, storage.root(), to);

    template <typename I = Impl, typename F = row_features,

              if_canMoveItems<F> = true, if_tree<I> = true>

    bool moveColumn(QSpan<const int> source, int to)

        const QModelIndex parent = this->index(source.first(source.size() - 1), 0);

        return storage->moveColumns(parent, source.back(), 1, parent, to);

    template <typename I = Impl, typename F = row_features,

              if_canMoveItems<F> = true, if_tree<I> = true>

    bool moveColumns(QSpan<const int> source, int count, int destination)

        const QModelIndex parent = this->index(source.first(source.size() - 1), 0);

        return storage->moveColumns(parent, source.back(), count, parent, destination);

private:

    friend inline

    bool comparesEqual(const QRangeModelAdapter &lhs, const QRangeModelAdapter &rhs) noexcept

        return lhs.storage.m_model == rhs.storage.m_model;

    Q_DECLARE_EQUALITY_COMPARABLE(QRangeModelAdapter)

    friend inline

    bool comparesEqual(const QRangeModelAdapter &lhs, const range_type &rhs)

        return lhs.range() == rhs;

    Q_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT(QRangeModelAdapter, range_type)

    void emitDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)

        Q_EMIT storage.implementation()->dataChanged(topLeft, bottomRight, {});

    void beginAssignImpl(Impl *impl, range_type *oldRange, int 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::assign",

                       "Internal error: The root index in a table or list must be invalid.");

    void endAssignImpl(Impl *impl, int 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 assignImpl(std::size_t newSize, Assigner &&assigner)

        const auto sz = q26::saturating_cast<int>(newSize);

        Q_ASSERT_X(q20::cmp_equal(sz, newSize),

                   "QRangeModelAdapter::assign", "New range is too large");

        const int newLastRow = sz - 1;

        auto *impl = storage.implementation();

        auto *oldRange = impl->childRange(storage.root());

        beginAssignImpl(impl, oldRange, newLastRow);

        assigner(QRangeModelDetails::refTo(oldRange));

        endAssignImpl(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, typename Row>

    static auto setParentRow(P &protocol, Row &newRow, row_ptr parentRow)

        -> decltype(protocol.setParentRow(newRow, parentRow))

        return protocol.setParentRow(newRow, parentRow);

    template <typename ...Args> static constexpr void setParentRow(Args &&...)

        static_assert(!protocol_traits::has_setParentRow,

                      "Internal error, wrong setParentRow overload called");

    template <typename D>

    bool insertRowImpl(int before, const QModelIndex &parent, D &&data)

        return storage.implementation()->doInsertRows(before, 1, parent, [&data, this]

                                        (range_type &range, auto *parentRow, int row, int count) {

            Q_UNUSED(this);

            const auto oldSize = range.size();

            auto newRow = range.emplace(QRangeModelDetails::pos(range, row), std::forward<D>(data));

            setParentRow(storage->protocol(), QRangeModelDetails::refTo(*newRow),

                                              QRangeModelDetails::pointerTo(parentRow));

            return range.size() == oldSize + count;

});

    template <typename LHS>

    static auto selfInsertion(LHS *lhs, LHS *rhs) -> decltype(lhs == rhs)

        if (lhs == rhs) {

#ifndef QT_NO_DEBUG

            qCritical("Inserting data into itself is not supported");

#endif

            return true;

        return false;

    template <typename LHS, typename RHS>

    static constexpr bool selfInsertion(LHS *, RHS *) { return false; }

    template <typename C>

    bool insertRowsImpl(int before, const QModelIndex &parent, C &&data)

        bool result = false;

        result = storage->doInsertRows(before, int(std::size(data)), parent, [&data, this]

                                        (range_type &range, auto *parentRow, int row, int count){

            Q_UNUSED(parentRow);

            Q_UNUSED(this);

            const auto pos = QRangeModelDetails::pos(range, row);

            const auto oldSize = range.size();

            auto dataRange = [&data]{

                if constexpr (std::is_rvalue_reference_v<C&&>) {

                    return std::make_pair(

                        std::move_iterator(std::begin(data)),

                        std::move_iterator(std::end(data))

);

                } else {

                    return std::make_pair(std::begin(data), std::end(data));

            }();

            if constexpr (range_features::has_insert_range) {

                if (selfInsertion(&range, &data))

                    return false;

                auto start = range.insert(pos, dataRange.first, dataRange.second);

                if constexpr (protocol_traits::has_setParentRow) {

                    while (count) {

                        setParentRow(storage->protocol(), QRangeModelDetails::refTo(*start),

                                                          QRangeModelDetails::pointerTo(parentRow));

                        ++start;

                        --count;

                } else {

                    Q_UNUSED(start);

            } else {

                auto newRow = range.insert(pos, count, row_type{});

                while (dataRange.first != dataRange.second) {

                    *newRow = *dataRange.first;

                    setParentRow(storage->protocol(), QRangeModelDetails::refTo(*newRow),

                                                      QRangeModelDetails::pointerTo(parentRow));

                    ++dataRange.first;

                    ++newRow;

            return range.size() == oldSize + count;

});

        return result;

    template <typename D, typename = void>

    struct DataFromList {

        static constexpr auto first(D &data) { return &data; }

        static constexpr auto next(D &, D *entry) { return entry; }

};

    template <typename D>

    struct DataFromList<D, std::enable_if_t<QRangeModelDetails::range_traits<D>::value>>

        static constexpr auto first(D &data) { return std::begin(data); }

        static constexpr auto next(D &data, typename D::iterator entry)

            ++entry;

            if (entry == std::end(data))

                entry = first(data);

            return entry;

};

    template <typename D, typename = void> struct RowFromTable

        static constexpr auto first(D &data) { return &data; }

        static constexpr auto next(D &, D *entry) { return entry; }

};

    template <typename D>

    struct RowFromTable<D, std::enable_if_t<std::conjunction_v<

                                            QRangeModelDetails::range_traits<D>,

                                            QRangeModelDetails::range_traits<typename D::value_type>

>>

                        > : DataFromList<D>

{};

    template <typename D>

    bool insertColumnImpl(int before, const QModelIndex &parent, D data)

        auto entry = DataFromList<D>::first(data);

        return storage->doInsertColumns(before, 1, parent, [&entry, &data]

                                        (auto &range, auto pos, int count) {

            const auto oldSize = range.size();

            range.insert(pos, *entry);

            entry = DataFromList<D>::next(data, entry);

            return range.size() == oldSize + count;

});

    template <typename C>

    bool insertColumnsImpl(int before, const QModelIndex &parent, C data)

        bool result = false;

        auto entries = RowFromTable<C>::first(data);

        auto begin = std::begin(*entries);

        auto end = std::end(*entries);

        result = storage->doInsertColumns(before, int(std::size(*entries)), parent,

                            [&begin, &end, &entries, &data](auto &range, auto pos, int count) {

            const auto oldSize = range.size();

            if constexpr (row_features::has_insert_range) {

                range.insert(pos, begin, end);

            } else {

                auto start = range.insert(pos, count, {});

                std::copy(begin, end, start);

            entries = RowFromTable<C>::next(data, entries);

            begin = std::begin(*entries);

            end = std::end(*entries);

            return range.size() == oldSize + count;

});

        return result;

};

// Deduction guides are needed to correctly map single-parameter construction

// to the void-protocol case, and to disable construction from incompatible

// ranges.

template <typename Range, typename Protocol,

          QRangeModelDetails::if_can_construct<Range, Protocol> = true>

QRangeModelAdapter(Range &&, Protocol &&) -> QRangeModelAdapter<Range, Protocol>;

template <typename Range,

          QRangeModelDetails::if_can_construct<Range> = true>

QRangeModelAdapter(Range &&) -> QRangeModelAdapter<Range, void>;

QT_END_NAMESPACE

#endif // QRANGEMODELADAPTER_H