Back to Qt.io
Contact Us Blog Download Qt
Sur cette page

QRangeModelAdapter Class

QRangeModelAdapter offre un accès conforme à l'interface « QAbstractItemModel » à n'importe quelle plage C++. En savoir plus...

En-tête : #include <QRangeModelAdapter>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core
Depuis : Qt 6.11
Statut : Aperçu technologique

Cette classe est en avant-première technologique et est susceptible d'être modifiée.

Comparaisons QRangeModelAdapter

CatégorieTypes comparables
égalitéQRangeModelAdapter
égalitéRange.

Types publics

(technology preview) struct ColumnIterator
(technology preview) struct ConstColumnIterator
(technology preview) struct ConstRowIterator
(technology preview) struct ConstRowReference
(technology preview) struct DataReference
(technology preview) struct RowIterator
(technology preview) struct RowReference
(technology preview) struct RowReferenceBase

Fonctions publiques

QRangeModelAdapter(Range &&range)
QRangeModelAdapter(Range &&range, Protocol &&protocol)
void assign(NewRange &&newRange)
void assign(std::initializer_list<Row> newRange)
void assign(InputIterator first, Sentinel last)
auto at(QSpan<const int> path)
auto at(int listRow)
auto at(int tableRow)
auto at(int treeRow)
decltype(auto) at(QSpan<const int> path) const
auto at(int listRow) const
decltype(auto) at(int tableRow) const
auto at(QSpan<const int> path, int column)
auto at(int tableRow, int column)
auto at(QSpan<const int> path, int column) const
auto at(int tableRow, int column) const
(since 6.12) auto at(const QModelIndex &index)
(since 6.12) auto at(const QModelIndex &index) const
int columnCount() const
QVariant data(int listRow) const
QVariant data(QSpan<const int> path, int column) const
QVariant data(int listRow, int role) const
QVariant data(int tableRow, int column) const
QVariant data(QSpan<const int> path, int column, int role) const
QVariant data(int tableRow, int column, int role) const
(since 6.12) QVariant data(const QModelIndex &index) const
(since 6.12) QVariant data(const QModelIndex &index, int role) const
bool hasChildren(QSpan<const int> row) const
(since 6.12) bool hasChildren(const QModelIndex &index) const
bool hasChildren(int row) const
QModelIndex index(int listRow) const
QModelIndex index(QSpan<const int> path, int column) const
QModelIndex index(int tableRow, int column) const
bool insertColumn(int before)
bool insertColumn(int before, D &&data)
bool insertColumns(int before, C &&data)
bool insertRow(QSpan<const int> before)
bool insertRow(int before)
bool insertRow(QSpan<const int> before, D &&data)
bool insertRow(int before, D &&data)
bool insertRow(int before, const QModelIndex &parent)
bool insertRow(int before, const QModelIndex &parent, D &&data)
bool insertRows(QSpan<const int> before, C &&data)
bool insertRows(int before, C &&data)
bool insertRows(int before, const QModelIndex &parent, C &&data)
Model *model() const
bool moveColumn(int from, int to)
bool moveColumns(int from, int count, int to)
bool moveRow(QSpan<const int> source, QSpan<const int> destination)
bool moveRow(int source, int destination)
bool moveRow(const QModelIndex &sourceParent, int sourceRow, const QModelIndex &destinationParent, int destinationChild)
bool moveRows(QSpan<const int> source, int count, QSpan<const int> destination)
bool moveRows(int source, int count, int destination)
bool moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild)
const QRangeModelAdapter<Range, Protocol, Model>::range_type &range() const
bool removeColumn(int column)
bool removeColumns(int column, int count)
bool removeRow(QSpan<const int> path)
bool removeRow(int row)
bool removeRow(int row, const QModelIndex &parent)
bool removeRows(QSpan<const int> path, int count)
bool removeRows(int row, int count)
bool removeRows(int row, int count, const QModelIndex &parent)
int rowCount() const
int rowCount(QSpan<const int> row) const
(since 6.12) int rowCount(const QModelIndex &index) const
int rowCount(int row) const
bool setData(int listRow, const QVariant &value, int role = Qt::EditRole)
bool setData(QSpan<const int> path, int column, const QVariant &value, int role = Qt::EditRole)
bool setData(int tableRow, int column, const QVariant &value, int role = Qt::EditRole)
(since 6.12) bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole)
QRangeModelAdapter<Range, Protocol, Model> &operator=(NewRange &&newRange)
QRangeModelAdapter<Range, Protocol, Model> &operator=(std::initializer_list<Row> newRange)
auto operator[](QSpan<const int> path)
auto operator[](int listRow)
auto operator[](int tableRow)
auto operator[](int treeRow)
decltype(auto) operator[](QSpan<const int> path) const
auto operator[](int listRow) const
decltype(auto) operator[](int tableRow) const

Types privés

range_type
bool operator!=(const QRangeModelAdapter<Range, Protocol, Model> &lhs, const QRangeModelAdapter<Range, Protocol, Model> &rhs)
bool operator==(const QRangeModelAdapter<Range, Protocol, Model> &lhs, const QRangeModelAdapter<Range, Protocol, Model> &rhs)

Description détaillée

QRangeModelAdapter fournit une API C++ sécurisée au niveau des types et tenant compte de la structure, autour d’une plage C++ et d’une instance de ` QRangeModel`. Les modifications apportées à la plage C++ à l’aide de l’adaptateur informent les clients de l’ QRangeModel de ces changements. Cela garantit que les vues des éléments sont mises à jour, que les caches sont vidés et que les index des éléments persistants sont invalidés et adaptés correctement.

Construction et propriété du modèle

QRangeModelAdapter doit être instancié à partir d’une plage C++. Comme pour QRangeModel, la plage peut être fournie sous forme de référence lvalue ou rvalue, en tant que wrapper de référence, ou encore sous forme de pointeur brut ou intelligent.

std::vector<int> data = {1, 2, 3, 4, 5};
QRangeModelAdapter adapter(&data);

Le type exact qui est instancié est déduit par le compilateur en fonction du ou des arguments du constructeur, et les différences entre les catégories de valeurs peuvent entraîner des comportements différents. Par conséquent, vous ne devez pas spécifier explicitement les paramètres du modèle. Le C++ n’autorise toutefois pas la déduction des arguments de modèle de classe pour les membres de données de classe non statiques. Pour faire de QRangeModelAdapter un membre de données d’une classe, utilisez le modèle suivant :

class Backend
{
    using Adapter = decltype(QRangeModelAdapter(std::vector<Book>{}));
    Adapter adapter = Adapter(std::vector<Book>{});

Cela crée un QRangeModelAdapter agissant sur un vecteur anonyme (c'est-à-dire une référence rvalue) de Books. Pour que l'adaptateur agisse sur un wrapper de référence vers une liste de Books, utilisez plutôt ceci :

    QList<Book> books = { /* ... */ };
    using Adapter = decltype(QRangeModelAdapter(std::ref(books)));
    Adapter adapter = Adapter(std::ref(books));
};

La construction de l’adaptateur à partir d’une plage construit implicitement une instance d’ QRangeModel à partir de cette même plage. Utilisez ` model()` pour l’obtenir, puis transmettez-la aux vues d’éléments ` Qt Widgets ` ou ` Qt Quick ` comme d’habitude.

QListView listView;
listView.setModel(adapter.model());

L’adaptateur est propriétaire du modèle. QRangeModelAdapter est un type de valeur, il peut donc être copié et déplacé. Toutes les copies partagent le même QRangeModel, qui sera détruit lorsque la dernière copie de l’adaptateur sera détruite.

Si l’adaptateur a été créé à partir d’une référence lvalue ou rvalue, l’adaptateur et le modèle opéreront alors sur une copie de l’objet de plage d’origine. Dans le cas contraire, les modifications effectuées via l’adaptateur ou le modèle seront écrites dans l’objet de plage d’origine. Pour accéder à la plage mise à jour, utilisez ` range()` :

QList<Book> books = {
    // ...
};
QRangeModelAdapter adapter(books);
tableView.setModel(adapter.model());

// show UI and where the user can modify the list

QList<Book> modifiedBooks = adapter.range();

Pour remplacer l’intégralité des données de la plage par celles d’une autre plage (compatible), utilisez la fonction assign() ou l’opérateur d’affectation.

// reset to the original
adapter = books;
// or
adapter.assign(books);

Accès aux données des éléments

L’API QRangeModelAdapter fournit un accès en lecture et en écriture sécurisé au niveau des types à la plage sur laquelle le modèle opère. L’API de l’adaptateur repose sur l’API classique des conteneurs et plages C++, y compris les itérateurs. Pour accéder à des lignes et des éléments individuels, utilisez at(), l’ operator[]-indice correspondant ou data(). Les surcharges disponibles de ces fonctions dépendent de la plage pour laquelle l’adaptateur a été construit.

Lecture des données d’un élément sous forme de QVariant

La fonction data() renvoie toujours un QVariant contenant la valeur stockée à la position et au rôle spécifiés. Dans une liste, on peut accéder à un élément à l’aide d’un simple entier indiquant la ligne :

QVariant listItem = listAdapter.data(row);

Si la plage est un tableau, les éléments sont alors spécifiés par ligne et colonne :

QVariant tableItem = tableAdapter.data(row, column);

Si la plage est une arborescence, les éléments sont localisés à l’aide d’un chemin composé de lignes et d’une seule valeur de colonne :

QVariant treeItem = treeAdapter.data({path, to, branch}, column);

L'utilisation d'un seul entier comme ligne permet d’accéder aux éléments de niveau supérieur de l’arborescence.

QRangeModelAdapter listOfBooks(QList<Book>{
    // ~~~
});
QString bookTitle = listOfBooks.data(0, Book::TitleRole).toString();
Book multiRoleItem = listOfBooks.data(0).value<Book>();

Si aucun rôle n'est spécifié, la fonction « QVariant » conservera l'élément entier à cet emplacement. Utilisez la fonction modèle « QVariant::fromValue() » pour récupérer une copie de l'élément.

Lecture et écriture à l'aide de at()

Le fait que la fonction ` data()` renvoie un ` QVariant ` la rend flexible, mais supprime la sécurité de type. Pour les plages dont tous les éléments sont du même type, la fonction ` at()` offre une alternative sécurisée au niveau du type, plus compatible avec les conteneurs C++ classiques. Comme pour ` data()`, il existe des surcharges de ` at()` permettant d’accéder à un élément à une ligne pour les listes, à une paire ligne/colonne pour les tableaux et à une paire chemin/colonne pour les arbres. Cependant, ` at()` renvoie toujours l’élément entier à la position spécifiée ; il n’est pas possible de lire les valeurs individuelles des champs d’un élément.

Comme on peut s’y attendre d’une API de conteneurs C++, les surcharges const de at() (et l’ operator[]( ) correspondant) fournissent un accès immuable à la valeur, tandis que les surcharges mutables renvoient un objet de référence auquel une nouvelle valeur peut être attribuée. Notez qu’un QRangeModelAdapter opérant sur une plage const se comporte à cet égard comme un QRangeModelAdapter const. Les surcharges mutables sont supprimées de l’ensemble des surcharges ; le compilateur sélectionnera donc toujours la version `const`. Tenter d’appeler une fonction qui modifie une plage entraînera une erreur de compilation, même si l’adaptateur lui-même est mutable :

const QStringList strings = {"On", "Off"};
QRangeModelAdapter adapter(strings);
adapter.at(0) = "Undecided"; // compile error: return value of 'at' is const
adapter.insertRow(0); // compiler error: requirements not satisfied

Les objets de référence renvoyés sont des wrappers qui se convertissent implicitement en type sous-jacent ; ils disposent d’une fonction ` get()` permettant d’accéder explicitement à la valeur sous-jacente, ainsi que d’une fonction ` operator->()` qui offre un accès direct aux fonctions membres `const`. Cependant, afin d’empêcher toute modification accidentelle des données qui contournerait le protocole de notification ` QAbstractItemModel `, ces objets de référence empêchent toute modification directe des éléments.

Remarque : l’accès à l’objet de référence entraîne toujours un appel au modèle pour obtenir une copie de la valeur. Cela peut être coûteux en ressources ; pour les accès aux données où les performances sont critiques, stockez une copie.

Accès aux éléments

Si la plage est représentée sous forme de liste, seules les surcharges prenant une ligne sont disponibles.

QRangeModelAdapter list(std::vector<int>{1, 2, 3, 4, 5});
listView.setModel(list.model());

int firstValue = list.at(0); // == 1
list.at(0) = -1;
list.at(1) = list.at(4);

La surcharge `const` renvoie l'élément situé à cette ligne, tandis que la surcharge `mutable` renvoie un conteneur qui effectue implicitement la conversion vers et depuis le type de valeur de la liste.

QRangeModelAdapter books(QList<Book>{
    // ~~~
});
Book firstBook = books.at(0);
Book newBook = {};
books.at(0) = newBook; // dataChanged() emitted

Attribuez une valeur à l’objet wrapper pour modifier les données de la liste. Le modèle émettra des appels à ` dataChanged()` pour tous les rôles.

Lorsque vous utilisez les surcharges « mutable », vous pouvez également accéder aux membres « const » du type d’élément à l’aide de l’opérateur flèche surchargé.

QString title = books.at(0)->title();

Il n’est pas possible d’accéder aux membres non const de l’élément. De telles modifications contourneraient l’adaptateur, qui ne pourrait pas notifier le modèle de ces changements. Pour modifier la valeur stockée dans le modèle, effectuez une copie, modifiez les propriétés de cette copie, puis réécrivez-la.

// books.at(0)->setRating(5); - not possible even though 'books' is not const
firstBook = books.at(0);
firstBook.setRating(5);
books.at(0) = firstBook; // dataChanged() emitted

Cela provoquera l’émission par le modèle d’un appel à ` dataChanged()` pour cet élément, et pour tous les rôles.

Si la plage est représentée sous forme de tableau, vous pouvez alors accéder à un élément individuel par ligne et par colonne, à l’aide de la surcharge ` at(row, column)`. Pour les arborescences, cette surcharge donne accès aux éléments de niveau supérieur, tandis que la surcharge ` at(path, column)` permet d’accéder aux éléments imbriqués dans l’arborescence.

L'accès à un élément individuel dans un tableau ou une arborescence équivaut à l'accès à un élément dans une liste.

QRangeModelAdapter table(std::vector<std::vector<double>>{
    {1.0, 2.0, 3.0, 4.0, 5.0},
    {6.0, 7.0, 8.0, 9.0, 10.0},
});
tableView.setModel(table.model());

double value = table.at(0, 2); // value == 3.0
table.at(0, 2) = value * 2; // table[0, 2] == 6.0

Si la plage ne stocke pas toutes les colonnes en utilisant le même type de données, alors ` at(row,column) ` renvoie un (objet de référence contenant un) ` QVariant ` contenant l'élément.

QRangeModelAdapter table(std::vector<std::tuple<int, QString>>{
    // ~~~
});
int number = table.at(0, 0)->toInt();
QString text = table.at(0, 1)->toString();

Accès aux lignes dans les tables et les arborescences

Pour les tables et les arborescences, les surcharges de ` at()` et de l'operator[] e d'indice ` ()` sans paramètre de colonne permettent d'accéder à la ligne entière. La valeur renvoyée par les surcharges const sera un type de référence donnant accès aux données de la ligne. Si cette ligne contient des pointeurs, ce type de référence constituera alors une vue de la ligne, donnant accès à des pointeurs vers des éléments const.

Accès aux lignes d'une table

La surcharge ` at(int)` est toujours disponible, mais elle renvoie la ligne de table dans son intégralité. Cela permet de manipuler toutes les valeurs de la ligne en une seule fois.

const auto &constTable = table;
const std::vector<double> &topRow = constTable.at(0);

Comme pour les éléments, la surcharge `const` fournit un accès direct au type de ligne, tandis que la surcharge `mutable` renvoie un wrapper qui fait office de référence à la ligne. Le wrapper permet d'accéder aux fonctions membres `const` à l'aide de l'opérateur flèche surchargé. Pour modifier les valeurs, il suffit de réécrire un type de ligne modifié.

auto lastRow = table.at(table.rowCount() - 1);
lastRow = { 6.5, 7.5, 8.0, 9.0, 10 }; // emits dataChanged() for entire row

Lorsqu’une nouvelle valeur est attribuée à la ligne, le modèle émet le signal ` dataChanged()` pour tous les éléments de la ligne et pour tous les rôles.

Remarque : lorsque vous utilisez un type de ligne dont la taille est déterminée à l’exécution, tel qu’un ` std::vector ` ou un ` QList`, assurez-vous que la nouvelle ligne a la taille correcte.

Accès aux lignes d’arborescence

Les lignes dans les arbres sont spécifiées par une séquence d’entiers, une entrée pour chaque niveau de l’arbre. Notez que dans les extraits de code suivants, l’objet `Tree` est une plage contenant des pointeurs bruts vers les lignes, et que l’adaptateur est créé à l’aide d’une référence rvalue de cette plage. Cela confère à l’ QRangeModel la propriété des données de la ligne.

QRangeModelAdapter tree = QRangeModelAdapter(Tree{
    new TreeRow{"Germany", 357002, Tree{
            new TreeRow("Bavaria", 70550)
        },
    },
    new TreeRow{"France", 632702},
});
treeView.setModel(tree.model());

auto germanyData = tree.at(0);
auto bavariaData = tree.at({0, 0});

La surcharge de la méthode ` at()` prenant une seule valeur de ligne permet d’accéder aux lignes de niveau supérieur, ou aux éléments contenus dans ces lignes.

auto germanyName = tree.at(0, 0);
auto bavariaSize = tree.at({0, 0}, 1);

Le principe de base pour accéder aux lignes et aux éléments d’une arborescence est identique à celui utilisé pour accéder aux lignes et aux éléments d’une table. Cependant, l’adaptateur veillera à ce que la structure arborescente soit préservée lors de la modification de lignes entières.

// deletes the old row - tree was moved in
tree.at({0, 0}) = new TreeRow{"Berlin", 892};

Dans cet exemple, un nouvel objet ligne est créé et affecté au premier enfant du premier élément de niveau supérieur.

API d'itérateur

Utilisez les fonctions `begin()` et `end()` pour obtenir des itérateurs sur les lignes du modèle, ou utilisez la syntaxe `ranged-for`. Si la plage est une liste d'éléments, le déréférencement de l'itérateur donnera accès aux données des éléments.

for (const auto &book: std::as_const(books)) {
    qDebug() << "The book" << book.title()
            <<  « écrit par » << book.author()
             <<  « a » << book.rating() <<  « étoiles »;
}

Comme pour les surcharges const et mutable de la fonction at(), un itérateur mutable sera déréférencé vers un wrapper.

for (auto livre : livres) {
    qDebug() << "The book" << book->title()
            <<  « écrit par » << book->author()
             <<  « a » << book->rating() <<  « étoiles »;

    Book copy = book;
    copy.setRating(copy.rating() + 1);
    book = copy;
}

Utilisez l’opérateur flèche surchargé pour accéder aux membres const du type d’élément, puis effectuez une affectation à l’objet wrapper pour remplacer la valeur.

Si la plage est un tableau ou une arborescence, l'itération sur le modèle donnera accès aux lignes.

QRangeModelAdapter table(std::vector<std::pair<int, QString>>{
    // ~~~
});

for (const auto &row: std::as_const(table)) {
    qDebug() << "Number is" << row->first << "and string is" << row->second;
}

Les itérateurs constants et mutables renvoient tous deux à un type d'encapsulation pour la ligne. Cela garantit que nous pouvons parcourir de manière cohérente chaque élément de la ligne, même si le type de ligne sous-jacent n'est pas une plage (il peut s'agir, par exemple, d'un tuple ou d'un gadget).

for (const auto &row: std::as_const(table)) {
    for (const auto &item: row) {
        qDebug() << item; // item is a QVariant
    }
}

Lorsqu'on itère sur une table modifiable, on peut écraser la ligne entière.

for (auto row : table) {
    qDebug() << "Number is" << row->first << "and string is" << row->second;
    row = std::make_pair(42, u"forty-two"_s);
}

Le modèle émet le signal dataChanged() pour tous les éléments de toutes les lignes, et pour tous les rôles.

for (auto row : table) {
    for (auto item : row) {
        item = 42;
    }
}

Itérer sur les lignes modifiables nous permet de modifier des éléments individuels.

Lorsqu’on parcourt un arbre, le wrapper de ligne dispose de deux fonctions membres supplémentaires, ` hasChildren()` et `children()`, qui permettent de parcourir l’arbre entier à l’aide d’itérateurs.

for (auto row : tree) {
    if (row.hasChildren()) {
        for (auto child : row.children()) {
            // ~~~
        }
    }
}

L'objet renvoyé par `children()` est un `QRangeModelAdapter` fonctionnant sur le même modèle que l'objet appelé, mais toutes les opérations utiliseront l'index de la ligne source comme index parent.

Voir également QRangeModel.

Documentation sur les types de membres

[alias] QRangeModelAdapter::range_type

Documentation sur les fonctions des membres

[implicit] QRangeModelAdapter::QRangeModelAdapter(Range &&range)

[implicit] QRangeModelAdapter::QRangeModelAdapter(Range &&range, Protocol &&protocol)

Crée un objet ` QRangeModelAdapter ` qui opère sur ` range`. Pour les plages d'arbres, le paramètre facultatif ` protocol ` sera utilisé pour le parcours de l'arbre.

Consultez la documentation du constructeur QRangeModel pour plus de détails sur les exigences relatives à Range, et sur la manière dont la catégorie de valeur de range modifie l’interaction entre l’adaptateur, le modèle et la plage.

Voir également QRangeModel.

template < typename InputIterator, typename Sentinel, typename I > requires if_writable<I> void QRangeModelAdapter::assign(InputIterator first, Sentinel last)

Remplace le contenu des modèles par les lignes comprises dans l'intervalle [first, last).

Voir également range(), at et model().

template <typename I> requires if_tree<I> && if_writable<I> auto QRangeModelAdapter::at(QSpan<const int> path)

template <typename I> requires if_tree<I> && if_writable<I> auto QRangeModelAdapter::operator[](QSpan<const int> path)

Renvoie un objet ` mutable wrapper ` contenant une référence à la ligne de l'arborescence spécifiée par ` path`.

Pour modifier la ligne de l'arborescence, attribuez-lui une nouvelle valeur. L’affectation d’une nouvelle ligne d’arborescence définira le parent de cette nouvelle ligne comme étant le parent de l’ancienne ligne d’arborescence. Cependant, ni l’ancienne ni la nouvelle ligne d’arborescence ne doivent comporter de lignes enfants. Pour accéder à la ligne d’arborescence, déréférencez le wrapper à l’aide de ` operator*()`, ou utilisez ` operator->() ` pour accéder aux membres de la ligne d’arborescence.

Remarque : toute modification de la plage invalidera le wrapper.

Contraintes

Ne participe à la résolution de surcharge que si ` Range ` est un arbre.

template <typename I> requires if_list<I> && if_writable<I> auto QRangeModelAdapter::at(int listRow)

template <typename I> requires if_list<I> && if_writable<I> auto QRangeModelAdapter::operator[](int listRow)

Renvoie une référence de type « mutable reference » à la valeur stockée dans « Range ».

Remarque : toute modification apportée à la plage invalidera cette référence. Pour modifier la référence, attribuez-lui une nouvelle valeur. À moins que la valeur stockée dans l’ Range ne soit un pointeur, il n’est pas possible d’accéder aux membres individuels de la valeur stockée.

Contraintes

Ne participe à la résolution des surcharges que si Range est une liste modifiable.

template <typename I> requires if_table<I> && if_writable<I> auto QRangeModelAdapter::at(int tableRow)

template <typename I> requires if_table<I> && if_writable<I> auto QRangeModelAdapter::operator[](int tableRow)

Renvoie un objet ` reference wrapper ` correspondant à la ligne située à l'adresse ` tableRow`, telle qu'elle est stockée dans ` Range`.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est une table modifiable, mais pas un arbre.

template <typename I> requires if_tree<I> && if_writable<I> auto QRangeModelAdapter::at(int treeRow)

template <typename I> requires if_tree<I> && if_writable<I> auto QRangeModelAdapter::operator[](int treeRow)

Renvoie un objet ` reference wrapper ` correspondant à la ligne située à l'adresse ` treeRow`, telle qu'elle est stockée dans ` Range`.

Pour modifier la ligne de l'arborescence, attribuez-lui une nouvelle valeur. L'affectation d'une nouvelle ligne d'arborescence définira le parent de cette nouvelle ligne comme étant le parent de l'ancienne ligne d'arborescence. Cependant, ni l'ancienne ni la nouvelle ligne d'arborescence ne doivent comporter de lignes enfants. Pour accéder à la ligne d'arborescence, déréférencez le wrapper à l'aide de operator*(), ou utilisez operator->() pour accéder aux membres de la ligne d'arborescence.

Remarque : toute modification apportée à la plage invalidera le wrapper.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est un arbre.

template <typename I> requires if_tree<I> decltype(auto) QRangeModelAdapter::at(QSpan<const int> path) const

template <typename I> requires if_tree<I> decltype(auto) QRangeModelAdapter::operator[](QSpan<const int> path) const

Renvoie une référence constante à la ligne spécifiée par ` path`, telle qu'elle est stockée dans ` Range`.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est un arbre.

template <typename I> requires if_list<I> auto QRangeModelAdapter::at(int listRow) const

template <typename I> requires if_list<I> auto QRangeModelAdapter::operator[](int listRow) const

Renvoie la valeur située à l'adresse listRow sous la forme du type stocké à l'adresse Range.

Contraintes

Ne participe à la résolution des surcharges que si Range est une liste.

template <typename I> requires unless_list<I> decltype(auto) QRangeModelAdapter::at(int tableRow) const

template <typename I> requires unless_list<I> decltype(auto) QRangeModelAdapter::operator[](int tableRow) const

Renvoie une référence constante à la ligne située à l'adresse tableRow, telle qu'elle est stockée dans Range.

Contraintes

Ne participe à la résolution des surcharges que si Range est une table ou un arbre.

template <typename I> requires if_tree<I> && if_writable<I> auto QRangeModelAdapter::at(QSpan<const int> path, int column)

Renvoie une référence de type « mutable reference » à la valeur stockée dans l'élément spécifié par « path » et « column ». Si l'élément est un élément à rôles multiples, il s'agira d'une référence à l'élément dans son intégralité. Si les lignes de la « Range » stockent différents types dans différentes colonnes, le type de retour sera un « QVariant ».

Remarque : toute modification apportée à la plage invalidera cette référence. Pour modifier la référence, attribuez-lui une nouvelle valeur. À moins que la valeur stockée dans l’ Range ne soit un pointeur, il n’est pas possible d’accéder aux membres individuels de la valeur stockée.

Contraintes

Ne participe à la résolution de surcharge que si l’ Range est un arbre modifiable.

template <typename I> requires unless_list<I> && if_writable<I> auto QRangeModelAdapter::at(int tableRow, int column)

Renvoie une référence de type « mutable reference » à la valeur stockée sous la forme de l'élément spécifié par « tableRow » et « column ». Si l'élément est un élément à rôles multiples, il s'agira alors d'une référence à l'élément dans son intégralité.

Remarque : toute modification apportée à la plage invalidera cette référence. Pour modifier la référence, attribuez-lui une nouvelle valeur. À moins que la valeur stockée dans l’ Range ne soit un pointeur, il n’est pas possible d’accéder aux membres individuels de la valeur stockée.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est une table modifiable.

template <typename I> requires if_tree<I> auto QRangeModelAdapter::at(QSpan<const int> path, int column) const

Renvoie une copie de la valeur stockée sous la forme de l'élément spécifié par path et column. Si l'élément est un élément à rôles multiples, cette fonction renvoie une copie de l'élément dans son intégralité. Si les lignes de l'Range stockent différents types dans différentes colonnes, le type de retour sera un QVariant.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est un arbre.

template <typename I> requires unless_list<I> auto QRangeModelAdapter::at(int tableRow, int column) const

Renvoie une copie de la valeur stockée sous la forme de l'élément spécifié par tableRow et column. Si l'élément est un élément à rôles multiples, cette fonction renvoie une copie de l'élément dans son intégralité. Si les lignes de l'Range stockent différents types dans différentes colonnes, le type de retour sera un QVariant.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est une table ou un arbre.

[since 6.12] template <typename I> requires if_writable<I> auto QRangeModelAdapter::at(const QModelIndex &index)

Renvoie une référence de type « mutable reference » à la valeur stockée en tant qu’élément à l’adresse index. Si l’élément est un élément à rôles multiples, il s’agira alors d’une référence à l’élément dans son intégralité. Si les lignes de l’ Range stockent différents types dans différentes colonnes, le type de retour sera un « QVariant ».

Remarque : toute modification de la plage invalidera cette référence. Pour modifier la référence, attribuez-lui une nouvelle valeur. À moins que la valeur stockée dans Range ne soit un pointeur, il n’est pas possible d’accéder aux membres individuels de la valeur stockée.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` n’est pas en lecture seule.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.12.

[since 6.12] auto QRangeModelAdapter::at(const QModelIndex &index) const

Renvoie une copie de la valeur stockée en tant qu’élément à l’adresse index. Si l’élément est un élément à rôles multiples, cette fonction renvoie une copie de l’élément dans son intégralité. Si les lignes de l’ Range stockent différents types dans différentes colonnes, le type de retour sera un QVariant.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.12.

int QRangeModelAdapter::columnCount() const

Renvoie le nombre de colonnes. Cette valeur sera égale à 1 si l'Range e une liste ; sinon, elle correspondra au nombre d'éléments dans chaque ligne.

template <typename I> requires if_list<I> QVariant QRangeModelAdapter::data(int listRow) const

template <typename I> requires if_list<I> QVariant QRangeModelAdapter::data(int listRow, int role) const

Renvoie un objet ` QVariant ` contenant les données stockées sous l'role donné pour l'élément situé à l'adresse listRow, ou un objet ` QVariant ` non valide s'il n'existe aucun élément. Si l'adresse role n'est pas spécifiée, renvoie alors un objet ` QVariant ` contenant l'élément complet.

Contraintes

Ne participe à la résolution des surcharges que si Range est une liste.

Voir également setData() et at().

template <typename I> requires if_tree<I> QVariant QRangeModelAdapter::data(QSpan<const int> path, int column) const

template <typename I> requires if_tree<I> QVariant QRangeModelAdapter::data(QSpan<const int> path, int column, int role) const

Renvoie un objet ` QVariant ` contenant les données stockées sous l'role donné pour l'élément référencé par ` path ` et ` column`, ou un objet ` QVariant ` non valide s'il n'y a pas de données stockées pour cette position ou ce rôle. Si ` role ` n'est pas spécifié, renvoie un objet ` QVariant ` contenant l'élément complet.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre.

Voir également setData() et at().

template <typename I> requires unless_list<I> QVariant QRangeModelAdapter::data(int tableRow, int column) const

template <typename I> requires unless_list<I> QVariant QRangeModelAdapter::data(int tableRow, int column, int role) const

Renvoie une instance de ` QVariant ` contenant les données stockées sous l'role spécifié pour l'élément référencé par ` tableRow ` et ` column`, ou une instance de ` QVariant ` non valide s'il n'y a pas de données stockées pour cette position ou ce rôle. Si ` role ` n'est pas spécifié, renvoie une instance de ` QVariant ` contenant l'élément complet.

Contraintes

Ne participe à la résolution des surcharges que si Range est une table ou un arbre.

Voir également setData() et at().

[since 6.12] QVariant QRangeModelAdapter::data(const QModelIndex &index) const

[since 6.12] QVariant QRangeModelAdapter::data(const QModelIndex &index, int role) const

Renvoie un objet ` QVariant ` contenant les données stockées sous l’ role spécifié pour l’élément situé à l’adresse ` index`, ou un objet ` QVariant ` non valide s’il n’y a pas de données stockées pour cette position ou ce rôle. Si ` role ` n’est pas spécifié, renvoie alors un objet ` QVariant ` contenant l’élément complet.

Ces fonctions ont été introduites dans Qt 6.12.

Voir également setData() et at().

[constexpr] template <typename I> requires if_tree<I> bool QRangeModelAdapter::hasChildren(QSpan<const int> row) const

[constexpr] template <typename I> requires if_tree<I> bool QRangeModelAdapter::hasChildren(int row) const

Indique s'il existe des lignes dans la table « row ».

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre.

[constexpr, since 6.12] template <typename I> requires if_tree<I> bool QRangeModelAdapter::hasChildren(const QModelIndex &index) const

Indique s'il existe des lignes sous index.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.12.

template <typename I> requires if_list<I> QModelIndex QRangeModelAdapter::index(int listRow) const

Renvoie l'QModelIndex pour listRow.

Contraintes

Ne participe à la résolution des surcharges que si Range est une liste unidimensionnelle.

Il s'agit d'une fonction surchargée.

template <typename I> requires if_tree<I> QModelIndex QRangeModelAdapter::index(QSpan<const int> path, int column) const

Renvoie l'QModelIndex e de l'élément situé à l'adresse column correspondant à la ligne de l'arborescence spécifiée par path.

Contraintes

Ne participe à la résolution de surcharge que si Range est un arbre.

Il s'agit d'une fonction surchargée.

template <typename I> requires unless_list<I> QModelIndex QRangeModelAdapter::index(int tableRow, int column) const

Renvoie l'QModelIndex s relatives à l'élément disponible à l'adresse tableRow, column.

Contraintes

Ne participe à la résolution des surcharges que si Range est une table ou un arbre.

Il s'agit d'une fonction surchargée.

template <typename I> requires if_canInsertColumns<I> bool QRangeModelAdapter::insertColumn(int before)

Insère une seule colonne vide avant la colonne spécifiée par ` before ` dans toutes les lignes, et renvoie si l'insertion a réussi. Si ` before ` a la même valeur que ` columnCount()`, alors la colonne sera ajoutée à la fin de chaque ligne.

Contraintes

Ne participe à la résolution des surcharges que si Range contient des lignes prenant en charge l’insertion d’éléments.

Il s’agit d’une fonction surchargée.

Voir également removeColumn(), insertColumns() et insertRow().

template <typename D, typename I> requires if_canInsertColumns<I> && if_compatible_column_data<D> bool QRangeModelAdapter::insertColumn(int before, D &&data)

Insère dans toutes les lignes une colonne unique construite à partir de ` data ` avant la colonne spécifiée par ` before `, et renvoie si l'insertion a réussi. Si ` before ` a la même valeur que ` columnCount()` (), alors la colonne sera ajoutée à la fin de chaque ligne.

Si ` data ` est une valeur unique, la nouvelle entrée de toutes les lignes sera construite à partir de cette valeur unique.

Si data est un conteneur, les éléments de ce conteneur seront utilisés séquentiellement pour construire la colonne de chaque ligne suivante. S’il y a moins d’éléments dans data que de lignes, la fonction recommence à partir du premier élément.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` comporte des lignes prenant en charge l'insertion d'éléments, et si les éléments peuvent être construits à partir des entrées de ` data`.

Il s’agit d’une fonction surchargée.

Voir aussi removeColumn(), insertColumns() et insertRow().

template <typename C, typename I> requires if_canInsertColumns<I> && if_compatible_column_range<C> bool QRangeModelAdapter::insertColumns(int before, C &&data)

Insère dans toutes les lignes les colonnes constituées des éléments de ` data ` avant la colonne spécifiée par ` before `, et renvoie si l'insertion a réussi. Si ` before ` a la même valeur que ` columnCount()`, alors la colonne sera ajoutée à la fin de chaque ligne.

Si les éléments de ` data ` sont des valeurs, les nouvelles entrées de toutes les lignes seront alors construites à partir de ces valeurs.

Si les éléments de data sont des conteneurs, les entrées du conteneur externe seront utilisées séquentiellement pour construire les nouvelles entrées de chaque ligne suivante. S’il y a moins d’éléments dans data que de lignes, la fonction revient au début et recommence à partir du premier élément.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` comporte des lignes prenant en charge l’insertion d’éléments, et si ces éléments peuvent être construits à partir des entrées de ` data`.

Voir également removeColumns(), insertColumn() et insertRows().

template <typename I> requires if_canInsertRows<I> && if_tree<I> bool QRangeModelAdapter::insertRow(QSpan<const int> before)

Insère une seule ligne vide avant la ligne située à l'emplacement spécifié par ` before`, et indique si l'insertion a réussi. Si ` before ` a la même valeur que ` rowCount()` (), la nouvelle ligne sera alors ajoutée à la fin.

Contraintes

Ne participe à la résolution de surcharge que si Range est un arbre prenant en charge l’insertion d’éléments.

Il s'agit d'une fonction surchargée.

Voir également insertRows(), removeRow() et insertColumn().

template <typename I> requires if_canInsertRows<I> bool QRangeModelAdapter::insertRow(int before)

Insère une seule ligne vide avant la ligne située à l'adresse before et indique si l'insertion a réussi. Si before a la même valeur que rowCount(), la nouvelle ligne sera alors ajoutée à la fin.

Contraintes

Ne participe à la résolution des surcharges que si Range prend en charge l'insertion d'éléments.

Il s’agit d’une fonction surchargée.

Voir également insertRows(), removeRow() et insertColumn().

template <typename D, typename I> requires if_canInsertRows<I> && if_compatible_row<D> && if_tree<I> bool QRangeModelAdapter::insertRow(QSpan<const int> before, D &&data)

Insère une seule ligne générée à partir de data avant la ligne située à l'adresse before, et renvoie si l'insertion a réussi. Si before a la même valeur que rowCount(), la nouvelle ligne sera alors ajoutée à la fin.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre prenant en charge l’insertion d’éléments, et si une ligne peut être construite à partir de data.

Il s'agit d'une fonction surchargée.

Voir également insertRows(), removeRow() et insertColumn().

template <typename D, typename I> requires if_canInsertRows<I> && if_compatible_row<D> bool QRangeModelAdapter::insertRow(int before, D &&data)

Insère une ligne unique créée à partir de data avant la ligne située à l'adresse before, et indique si l'insertion a réussi. Si before contient la même valeur que rowCount(), la nouvelle ligne sera alors ajoutée à la fin.

Contraintes

Ne participe à la résolution des surcharges que si Range prend en charge l’insertion d’éléments et si une ligne peut être construite à partir de data.

Il s'agit d'une fonction surchargée.

Voir également insertRows(), removeRow() et insertColumn().

template <typename I> requires if_canInsertRows<I> && if_tree<I> bool QRangeModelAdapter::insertRow(int before, const QModelIndex &parent)

Insère une seule ligne vide avant la ligne située à l'adresse before dans l'parent spécifié, et renvoie un indicateur indiquant si l'insertion a réussi. Si before a la même valeur que rowCount(), la nouvelle ligne sera alors ajoutée à la fin.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre prenant en charge l’insertion d’éléments.

Il s'agit d'une fonction surchargée.

Voir également insertRows(), removeRow() et insertColumn().

template <typename D, typename I> requires if_canInsertRows<I> && if_compatible_row<D> && if_tree<I> bool QRangeModelAdapter::insertRow(int before, const QModelIndex &parent, D &&data)

Insère une seule ligne construite à partir de ` data ` avant la ligne située à ` before ` dans la table spécifiée ` parent`, et renvoie si l'insertion a réussi. Si ` before ` a la même valeur que ` rowCount()`, la nouvelle ligne sera alors ajoutée à la fin.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre prenant en charge l’insertion d’éléments, et si une ligne peut être construite à partir de data.

Il s’agit d’une fonction surchargée.

Voir également insertRows(), removeRow() et insertColumn().

template <typename C, typename I> requires if_canInsertRows<I> && if_compatible_row_range<C> && if_tree<I> bool QRangeModelAdapter::insertRows(QSpan<const int> before, C &&data)

Insère des lignes constituées des éléments de ` data ` avant la ligne située à l'adresse ` before`, et indique si l'insertion a réussi. Si ` before ` est identique à la valeur renvoyée par ` rowCount()`, la nouvelle ligne sera alors ajoutée à la fin.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre prenant en charge l’insertion d’éléments et si des lignes peuvent être construites à partir des éléments de data.

Il s'agit d'une fonction surchargée.

Voir également insertRow(), removeRows() et insertColumns().

template <typename C, typename I> requires if_canInsertRows<I> && if_compatible_row_range<C> bool QRangeModelAdapter::insertRows(int before, C &&data)

Insère les lignes constituées des éléments de ` data ` avant la ligne située à l'adresse ` before`, et indique si l'insertion a réussi. Si ` before ` a la même valeur que ` rowCount()` (), la nouvelle ligne sera alors ajoutée à la fin.

Contraintes

Ne participe à la résolution des surcharges que si Range prend en charge l’insertion d’éléments et si des lignes peuvent être construites à partir des éléments de data.

Il s’agit d’une fonction surchargée.

Voir également insertRow(), removeRows() et insertColumns().

template <typename C, typename I> requires if_canInsertRows<I> && if_compatible_row_range<C> && if_tree<I> bool QRangeModelAdapter::insertRows(int before, const QModelIndex &parent, C &&data)

Insère les lignes constituées des éléments de data avant la ligne située à l'adresse before dans la table spécifiée parent, et renvoie si l'insertion a réussi. Si before a la même valeur que rowCount(), alors la nouvelle ligne sera ajoutée à la fin.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre prenant en charge l’insertion d’éléments, et si des lignes peuvent être construites à partir des éléments de data.

Il s'agit d'une fonction surchargée.

Voir également insertRow(), removeRows() et insertColumns().

Model *QRangeModelAdapter::model() const

Renvoie l'instance QRangeModel créée par cet adaptateur.

Voir également range() et at().

template <typename F> requires if_canMoveItems<F> bool QRangeModelAdapter::moveColumn(int from, int to)

Déplace la colonne située à l'adresse from vers celle située à l'adresse to, puis indique si le déplacement s'est déroulé avec succès.

Contraintes

Ne participe à la résolution des surcharges que si Range contient des lignes prenant en charge le déplacement d’éléments.

Voir également insertColumn(), removeColumn(), moveColumns() et moveRow().

template <typename F> requires if_canMoveItems<F> bool QRangeModelAdapter::moveColumns(int from, int count, int to)

Déplace les colonnes de l'count, dont l'adresse de départ est from, vers l'adresse to, puis indique si le déplacement des colonnes s'est déroulé avec succès.

Contraintes

Ne participe à la résolution des surcharges que si Range comporte des lignes prenant en charge le déplacement d’éléments.

Voir également insertColumns(), removeColumns(), moveColumn() et moveRows().

template <typename I, typename F> requires if_canMoveItems<F> && if_tree<I> bool QRangeModelAdapter::moveRow(QSpan<const int> source, QSpan<const int> destination)

Déplace la branche de l'arborescence située à l'adresse source vers la position indiquée à l'adresse destination, puis indique si le déplacement de la branche a réussi.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre prenant en charge le déplacement d'éléments.

Il s’agit d’une fonction surchargée.

Voir également insertRow(), removeRow() et moveColumn().

template <typename F> requires if_canMoveItems<F> bool QRangeModelAdapter::moveRow(int source, int destination)

Déplace la ligne située à l'adresse source vers l'adresse destination et indique si le déplacement de la ligne a réussi.

Contraintes

Ne participe à la résolution des surcharges que si Range prend en charge le déplacement d’éléments.

Il s’agit d’une fonction surchargée.

Voir également insertRow(), removeRow() et moveColumn().

template <typename I, typename F> requires if_canMoveItems<F> && if_tree<I> bool QRangeModelAdapter::moveRow(const QModelIndex &sourceParent, int sourceRow, const QModelIndex &destinationParent, int destinationChild)

Déplace la branche située à l'adresse sourceRow depuis la « sourceParent » vers l'adresse destinationChild dans la « destinationParent », et indique si le déplacement de la branche a réussi.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre prenant en charge le déplacement d’éléments.

Il s’agit d’une fonction surchargée.

Voir également insertRow(), removeRow() et moveColumn().

template <typename I, typename F> requires if_canMoveItems<F> && if_tree<I> bool QRangeModelAdapter::moveRows(QSpan<const int> source, int count, QSpan<const int> destination)

Déplace les branches de l'arborescence « count » commençant à l'adresse source vers la position indiquée à l'adresse destination, puis indique si le déplacement des lignes s'est déroulé avec succès.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre prenant en charge le déplacement d’éléments.

Il s’agit d’une fonction surchargée.

Voir également insertRows(), removeRows() et moveColumns().

template <typename F> requires if_canMoveItems<F> bool QRangeModelAdapter::moveRows(int source, int count, int destination)

Déplace les lignes de la table « count » commençant à l'adresse source vers l'adresse destination, puis indique si le déplacement des lignes s'est déroulé avec succès.

Contraintes

Ne participe à la résolution des surcharges que si Range prend en charge le déplacement d’éléments.

Il s’agit d’une fonction surchargée.

Voir également insertRows(), removeRows() et moveColumns().

template <typename I, typename F> requires if_canMoveItems<F> && if_tree<I> bool QRangeModelAdapter::moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild)

Déplace les branches de count commençant par sourceRow depuis le sourceParent vers l'emplacement indiqué à l'adresse destinationChild dans le destinationParent, et indique si le déplacement de la branche a réussi.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est un arbre prenant en charge le déplacement d'éléments.

Il s’agit d’une fonction surchargée.

Voir également insertRows(), removeRows() et moveColumns().

const QRangeModelAdapter<Range, Protocol, Model>::range_type &QRangeModelAdapter::range() const

Renvoie une référence constante à la plage sur laquelle porte l'adaptateur de modèle.

Voir également assign(), at() et model().

template <typename I> requires if_canRemoveColumns<I> bool QRangeModelAdapter::removeColumn(int column)

Supprime l'column on indiquée de chaque ligne et indique si la suppression a abouti.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` contient des lignes permettant la suppression d’éléments.

Voir également ` insertColumn()`, ` removeColumns()` et ` removeRow()`.

template <typename I> requires if_canRemoveColumns<I> bool QRangeModelAdapter::removeColumns(int column, int count)

Supprime de chaque ligne les colonnes de type « count » commençant par l'column spécifiée, puis indique si la suppression a abouti.

Contraintes

Ne participe à la résolution des surcharges que si Range comporte des lignes prenant en charge la suppression d’éléments.

Voir également insertColumns(), removeColumn() et removeRow().

template <typename I> requires if_canRemoveRows<I> && if_tree<I> bool QRangeModelAdapter::removeRow(QSpan<const int> path)

Supprime la ligne à l'path indiquée, y compris tous ses éléments enfants, et renvoie si la suppression a abouti.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est un arbre prenant en charge la suppression d'éléments.

Il s’agit d’une fonction surchargée.

Voir également removeRows(), removeColumn() et insertRow().

template <typename I> requires if_canRemoveRows<I> bool QRangeModelAdapter::removeRow(int row)

Supprime l'row ion indiquée et indique si la suppression a abouti.

Contraintes

Ne participe à la résolution des surcharges que si Range prend en charge la suppression d'éléments.

Il s'agit d'une fonction surchargée.

Voir également removeRows(), removeColumn() et insertRow().

template <typename I> requires if_canRemoveRows<I> && if_tree<I> bool QRangeModelAdapter::removeRow(int row, const QModelIndex &parent)

Supprime l'row spécifiée de la table parent, y compris tous les éléments enfants de cette ligne, et indique si la suppression a réussi.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est un arbre prenant en charge la suppression d’éléments.

Il s’agit d’une fonction surchargée.

Voir également removeRows(), removeColumn() et insertRow().

template <typename I> requires if_canRemoveRows<I> && if_tree<I> bool QRangeModelAdapter::removeRows(QSpan<const int> path, int count)

Supprime les lignes de la table « count » à partir de la ligne indiquée par « path », et indique si la suppression a abouti.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est un arbre prenant en charge la suppression d'éléments.

Il s’agit d’une fonction surchargée.

Voir également removeRow(), removeColumns() et insertRows().

template <typename I> requires if_canRemoveRows<I> bool QRangeModelAdapter::removeRows(int row, int count)

Supprime les lignes de la table « count » à partir de la ligne « row » et indique si la suppression a réussi.

Contraintes

Ne participe à la résolution des surcharges que si Range prend en charge la suppression d’éléments.

Il s'agit d'une fonction surchargée.

Voir également removeRow(), removeColumns() et insertRows().

template <typename I> requires if_canRemoveRows<I> && if_tree<I> bool QRangeModelAdapter::removeRows(int row, int count, const QModelIndex &parent)

Supprime les lignes « count » de la table « parent » à partir de l'row spécifiée, et indique si la suppression a réussi.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est un arbre prenant en charge la suppression d’éléments.

Il s’agit d’une fonction surchargée.

Voir également removeRow(), removeColumns() et insertRows().

int QRangeModelAdapter::rowCount() const

Renvoie le nombre de lignes. Si l'Range e représente une liste ou un tableau, il s'agit du nombre de lignes. Pour les arborescences, il s'agit du nombre de lignes de niveau supérieur.

Il s'agit d'une fonction surchargée.

template <typename I> requires if_tree<I> int QRangeModelAdapter::rowCount(QSpan<const int> row) const

template <typename I> requires if_tree<I> int QRangeModelAdapter::rowCount(int row) const

Renvoie le nombre de lignes sous row.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre.

[since 6.12] template <typename I> requires if_tree<I> int QRangeModelAdapter::rowCount(const QModelIndex &index) const

Renvoie le nombre de lignes sous index.

Contraintes

Ne participe à la résolution des surcharges que si Range est un arbre.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.12.

template <typename I> requires if_list<I> && if_writable<I> bool QRangeModelAdapter::setData(int listRow, const QVariant &value, int role = Qt::EditRole)

Définit la valeur de la propriété « role » de l'élément situé à l'adresse listRow sur value.

Renvoie « true » en cas de réussite ; sinon, renvoie « false ».

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est une liste modifiable.

Voir également data() et at().

template <typename I> requires if_tree<I> && if_writable<I> bool QRangeModelAdapter::setData(QSpan<const int> path, int column, const QVariant &value, int role = Qt::EditRole)

Définit les données d'role s de l'élément référencé par path et column sur value.

Renvoie true en cas de réussite ; sinon, renvoie false.

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est un arbre modifiable.

Voir aussi data() et at().

template <typename I> requires unless_list<I> && if_writable<I> bool QRangeModelAdapter::setData(int tableRow, int column, const QVariant &value, int role = Qt::EditRole)

Définit les données « role » de l'élément référencé par « tableRow » et « column » sur « value ».

Renvoie « true » en cas de réussite ; sinon, renvoie « false ».

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est mutable et n’est pas une liste.

Voir également data() et at().

[since 6.12] template <typename I> requires if_writable<I> bool QRangeModelAdapter::setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole)

Définit la valeur de la propriété « role » de l'élément situé à l'adresse index sur value.

Renvoie true en cas de réussite ; sinon, renvoie false.

Contraintes

Ne participe à la résolution des surcharges que si Range n’est pas en lecture seule.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.12.

Voir également data() et at().

template <typename NewRange = QRangeModelAdapter<Range, Protocol, Model>::range_type> requires if_assignable_range<NewRange> && unless_adapter<NewRange> QRangeModelAdapter<Range, Protocol, Model> &QRangeModelAdapter::operator=(NewRange &&newRange)

template <typename NewRange = QRangeModelAdapter<Range, Protocol, Model>::range_type> requires if_assignable_range<NewRange> void QRangeModelAdapter::assign(NewRange &&newRange)

Remplace le contenu du modèle par les lignes contenues dans newRange, en utilisant éventuellement la sémantique de déplacement.

Cette fonction fait en sorte que la fonction « model() » émette les signaux « modelAboutToBeReset() » et « modelReset() ».

Contraintes

Ne participe à la résolution des surcharges que si ` Range ` est mutable et si ` newRange ` est d’un type pouvant être assigné à ` Range`, mais pas à ` QRangeModelAdapter`.

Voir également range(), at(), model() et assign().

template <typename Row> requires if_assignable_range<std::initializer_list<Row>> QRangeModelAdapter<Range, Protocol, Model> &QRangeModelAdapter::operator=(std::initializer_list<Row> newRange)

template <typename Row> requires if_assignable_range<std::initializer_list<Row>> void QRangeModelAdapter::assign(std::initializer_list<Row> newRange)

Remplace le contenu du modèle par les lignes du fichier « newRange ».

Contraintes

Ne participe à la résolution des surcharges que si Range est mutable et si newRange peut être affecté à Range.

Voir également range(), at et model().

Éléments non membres associés

[noexcept] bool operator!=(const QRangeModelAdapter<Range, Protocol, Model> &lhs, const QRangeModelAdapter<Range, Protocol, Model> &rhs)

Indique si lhs n'est pas égal à rhs. Deux adaptateurs sont égaux s'ils contiennent tous deux la même instance de model.

[noexcept] bool operator==(const QRangeModelAdapter<Range, Protocol, Model> &lhs, const QRangeModelAdapter<Range, Protocol, Model> &rhs)

Indique si ` lhs ` est égal à ` rhs`. Deux adaptateurs sont égaux s'ils contiennent tous deux la même instance de ` model `.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.