QRangeModelAdapter Class
QRangeModelAdapter fournit un accès conforme à QAbstractItemModel à n'importe quelle plage C++. Plus d'informations...
| 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 : | Préliminaire |
Cette classe est en cours de développement et peut être modifiée.
Cette classe est comparable à l 'égalité.
Cette classe est comparable à Range.
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 row) |
| auto | at(int row) |
| auto | at(int row) |
| decltype(auto) | at(QSpan<const int> path) const |
| auto | at(int row) const |
| decltype(auto) | at(int row) const |
| auto | at(QSpan<const int> path, int column) |
| auto | at(int row, int column) |
| auto | at(QSpan<const int> path, int column) const |
| auto | at(int row, int column) const |
| int | columnCount() const |
| QVariant | data(int row) const |
| QVariant | data(QSpan<const int> path, int column) const |
| QVariant | data(int row, int role) const |
| QVariant | data(int row, int column) const |
| QVariant | data(QSpan<const int> path, int column, int role) const |
| QVariant | data(int row, int column, int role) const |
| bool | hasChildren(QSpan<const int> row) const |
| bool | hasChildren(int row) const |
| QModelIndex | index(int row) const |
| QModelIndex | index(QSpan<const int> path, int column) const |
| QModelIndex | index(int row, 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 | insertRows(QSpan<const int> before, C &&data) |
| bool | insertRows(int before, 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 | moveRows(QSpan<const int> source, int count, QSpan<const int> destination) |
| bool | moveRows(int source, int count, int destination) |
| 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 | removeRows(QSpan<const int> path, int count) |
| bool | removeRows(int row, int count) |
| int | rowCount() const |
| int | rowCount(QSpan<const int> row) const |
| int | rowCount(int row) const |
| bool | setData(int row, 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 row, int column, 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 row) |
| auto | operator[](int row) |
| auto | operator[](int row) |
| decltype(auto) | operator[](QSpan<const int> path) const |
| auto | operator[](int row) const |
| decltype(auto) | operator[](int row) const |
Types privés
Non-membres apparentés
| 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ûre au niveau du type et de la structure autour d'une plage C++ et d'un site QRangeModel. Les modifications apportées à la plage C++ à l'aide de l'adaptateur informent les clients du site QRangeModel des changements. Cela permet de s'assurer que les vues des éléments sont mises à jour, que les caches sont nettoyé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 construit à partir d'une plage C++. Comme pour QRangeModel, la plage peut être fournie par une référence lvalue ou rvalue, en tant qu'enveloppe de référence, et en tant que pointeur brut ou intelligent.
std::vector<int> data = {1, 2, 3, 4, 5}; QRangeModelAdapter adapter(&data);
Le type exact qui est construit est déduit par le compilateur sur la base 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 du modèle de classe pour les membres de données non statiques de la classe. 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>{});
Ceci crée un QRangeModelAdapter opérant sur un vecteur de Livres sans nom (c'est-à-dire une référence rvalue). Pour que l'adaptateur fonctionne sur une référence à une liste de livres, utilisez plutôt ceci :
QList<Book> books = { /* ... */ }; using Adapter = decltype(QRangeModelAdapter(std::ref(books))); Adapter adapter = Adapter(std::ref(books)); };
Construire l'adaptateur à partir d'une plage construit implicitement une instance QRangeModel à partir de cette même plage. Utilisez model() pour l'obtenir, et passez-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, alors l'adaptateur et le modèle fonctionneront sur une copie de l'objet range original. Dans le cas contraire, les modifications apportées par l'adaptateur ou le modèle seront écrites sur l'objet 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'ensemble des données de la plage par les données 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é à la plage sur laquelle le modèle opère. L'API de l'adaptateur est basée sur l'API typique des conteneurs et des plages C++, y compris les itérateurs. Pour accéder à des lignes et à des éléments individuels, utilisez at(), l'indice correspondant operator[] ou data(). Les surcharges de ces fonctions disponibles dépendent de la plage pour laquelle l'adaptateur a été construit.
Lecture des données d'éléments en tant que QVariant
La fonction data() renvoie toujours un QVariant avec la valeur stockée à la position et au rôle spécifiés. Dans une liste, il est possible d'accéder à un élément par une seule valeur entière spécifiant la ligne :
QVariant listItem = listAdapter.data(row);
Si la plage est un tableau, les éléments sont spécifiés par la ligne et la colonne :
QVariant tableItem = tableAdapter.data(row, column);
Si la plage est un arbre, les éléments sont localisés à l'aide d'un chemin de lignes et d'une valeur de colonne unique :
QVariant treeItem = treeAdapter.data({path, to, branch}, column);
L'utilisation d'un seul entier comme ligne permet d'accéder aux éléments de l'arbre de premier niveau.
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é, le site QVariant contiendra l'élément entier à la position. 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 où tous les éléments sont du même type, la fonction at() fournit une alternative de sécurité de type qui est plus compatible avec les conteneurs C++ ordinaires. Comme pour data(), il existe des surcharges de at() pour accéder à un élément sur une ligne pour les listes, sur une paire ligne/colonne pour les tableaux et sur 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 d'un rôle individuel pour un élément.
Comme on peut s'y attendre dans une API de conteneur C++, les surcharges const de at() (et l'indice correspondant operator[]) fournissent un accès immuable à la valeur, tandis que les surcharges mutable 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, de sorte que le compilateur sélectionnera toujours la version const. Essayer d'appeler une fonction qui modifie une plage entraînera une erreur du compilateur, 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 enveloppes qui se convertissent implicitement au type sous-jacent, disposent d'une fonction get() pour accéder explicitement à la valeur sous-jacente et d'une operator->() qui fournit un accès direct aux fonctions membres constantes. Toutefois, pour éviter des modifications accidentelles des données qui contourneraient le protocole de notification QAbstractItemModel, ces objets de référence empêchent les modifications directes des éléments.
Remarque : l'accès à l'objet de référence nécessite toujours un appel au modèle pour obtenir une copie de la valeur. Cela peut s'avérer coûteux ; pour un accès critique aux données, stockez une copie.
Accès aux éléments
Si la plage est représentée sous la forme d'une 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 de cette ligne, tandis que la surcharge mutable renvoie une enveloppe qui convertit implicitement 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'enveloppe pour modifier les données de la liste. Le modèle émettra dataChanged() pour tous les rôles.
Lorsque vous utilisez les surcharges mutables, vous pouvez également accéder aux membres const du type d'élément à l'aide de l'opérateur de 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 des changements. Pour modifier la valeur stockée dans le modèle, il faut en faire une copie, modifier les propriétés de la copie, puis réécrire cette copie.
// 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
Le modèle émettra alors dataChanged() pour cet élément et pour tous les rôles.
Si la plage est représentée sous la forme d'un tableau, vous pouvez accéder à un élément individuel par ligne et par colonne, en utilisant la surcharge at(row, column). Pour les arbres, cette surcharge permet d'accéder aux éléments de premier niveau, tandis que la surcharge at(path, column) permet d'accéder aux éléments imbriqués dans l'arbre.
L'accès à un élément individuel d'un tableau ou d'un arbre est équivalent à l'accès à un élément d'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, at(row,column) renvoie une (enveloppe de référence avec une) 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 tableaux et les arbres
Pour les tableaux et les arbres, les surcharges de at() et l'indice operator[] sans le 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 sera une vue de la ligne, donnant accès aux pointeurs des éléments const.
Accès aux lignes d'un tableau
La surcharge at(int) est toujours disponible, mais elle renvoie l'intégralité du tableau. Cela permet de travailler avec 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 une enveloppe qui agit comme une référence à la ligne. L'enveloppe permet d'accéder aux fonctions membres const à l'aide de l'opérateur de flèche surchargé. Pour modifier les valeurs, il faut 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
Lors de l'attribution d'une nouvelle valeur à la ligne, le modèle émet le signal dataChanged() pour tous les éléments de la ligne et pour tous les rôles.
Note : Lors de l'utilisation d'un type de ligne avec des tailles d'exécution, comme un std::vector ou un QList, assurez-vous que la nouvelle ligne a la taille correcte.
Accès aux rangées de l'arbre
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 suivants, l'arbre est une plage contenant des pointeurs de ligne bruts, et que l'adaptateur est créé avec une référence rvalue de cette plage. Cela donne à 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 at() prenant une seule valeur de ligne permet d'accéder aux lignes de premier niveau ou aux éléments des lignes de premier niveau.
auto germanyName = tree.at(0, 0); auto bavariaSize = tree.at({0, 0}, 1);
Le modèle de base pour accéder aux lignes et aux éléments d'un arbre est identique à l'accès aux lignes et aux éléments d'un tableau. Cependant, l'adaptateur s'assurera que la structure de l'arbre est maintenue 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 assigné au premier enfant du premier élément de niveau supérieur.
API de l'itérateur
Utilisez begin() et end() pour obtenir des itérateurs sur les lignes du modèle, ou utilisez ranged-for. Si la plage est une liste d'éléments, le déréférencement de l'itérateur permet d'accéder aux données de l'élément.
for(const auto &book: std::as_const(books)) { qDebug() << "The book" << book.title() << "écrit par"<< book.author()<< "a"<< book.rating()<< "stars"; }
Comme pour les surcharges const et mutable de at(), un itérateur mutable sera déréférencé vers un wrapper.
for(auto book : books) { 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 de flèche surchargé pour accéder aux membres constants du type d'élément, et assignez au wrapper pour remplacer la valeur.
Si la plage est une table ou un arbre, l'itération sur le modèle permet d'accéder 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; }
L'itérateur const et l'itérateur mutable déréférenceront un type d'enveloppe pour la ligne. Cela permet de s'assurer que nous pouvons itérer de manière cohérente sur chaque colonne, même si le type de ligne sous-jacent n'est pas un intervalle (par exemple, il peut s'agir 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 } }
Lors de l'itération sur une table mutable, nous pouvons é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"quarante-deux"_s) ; }
Le modèle émet le signal dataChanged() pour tous les éléments de toutes les rangées et pour tous les rôles.
for (auto row : table) { for (auto item : row) { item = 42; } }
L'itération sur les rangées mutables nous permet de modifier des éléments individuels.
Lors de l'itération sur un arbre, le wrapper de ligne possède deux fonctions membres supplémentaires, hasChildren() et children(), qui nous permettent de parcourir l'ensemble de l'arbre à 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'appelant, mais toutes les opérations utiliseront l'index de la ligne source comme index parent.
Voir aussi QRangeModel.
Documentation des fonctions membres
[default] QRangeModelAdapter::QRangeModelAdapter(Range &&range, Protocol &&protocol)
[default] QRangeModelAdapter::QRangeModelAdapter(Range &&range)
Construit un QRangeModelAdapter qui opère sur range. Pour les plages d'arbres, l'option protocol sera utilisée pour la traversée de l'arbre.
Voir la documentation du constructeur QRangeModel pour plus de détails sur les conditions requises pour Range, et sur la façon dont la catégorie de valeur de range modifie l'interaction entre l'adaptateur, le modèle et la plage.
Voir aussi QRangeModel.
template <typename NewRange = QRangeModelAdapter<Range, Protocol, Model>::range_type, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<NewRange> = true> void QRangeModelAdapter::assign(NewRange &&newRange)
template < typename NewRange = QRangeModelAdapter<Range, Protocol, Model>::range_type, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<NewRange> = true, QRangeModelAdapter<Range, Protocol, Model>::unless_adapter<NewRange> = true > QRangeModelAdapter<Range, Protocol, Model> &QRangeModelAdapter::operator=(NewRange &&newRange)
Remplace le contenu du modèle par les lignes de newRange, éventuellement en utilisant la sémantique de déplacement.
Cette fonction fait en sorte que model() émette les signaux modelAboutToBeReset() et modelReset().
Contraintes
Participe à la résolution de surcharge uniquement si Range est mutable et si newRange est d'un type qui peut être assigné à Range, mais pas à QRangeModelAdapter.
Voir également range(), at(), model() et assign().
template <typename Row, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<std::initializer_list<Row>> = true> void QRangeModelAdapter::assign(std::initializer_list<Row> newRange)
template <typename Row, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<std::initializer_list<Row>> = true> QRangeModelAdapter<Range, Protocol, Model> &QRangeModelAdapter::operator=(std::initializer_list<Row> newRange)
Remplace le contenu du modèle par les lignes de newRange.
Contraintes
Participe à la résolution de surcharge uniquement si Range est mutable et si newRange peut être assigné à Range.
Voir aussi range(), at, et model().
template < typename InputIterator, typename Sentinel, typename I, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > void QRangeModelAdapter::assign(InputIterator first, Sentinel last)
Remplace le contenu des modèles par les lignes de l'intervalle [first, last).
Voir aussi range(), at, et model().
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(QSpan<const int> path)
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::operator[](QSpan<const int> path)
Renvoie une enveloppe mutable contenant une référence à la ligne d'arbre spécifiée par path.
Pour modifier la ligne d'arbre, attribuez-lui une nouvelle valeur. L'attribution d'une nouvelle ligne d'arbre fera du parent de la nouvelle ligne d'arbre le parent de l'ancienne ligne d'arbre. Toutefois, ni l'ancienne ni la nouvelle ligne d'arbre ne doivent avoir de ligne enfant. Pour accéder à la ligne d'arbre, déréférencer le wrapper en utilisant operator*(), ou utiliser operator->() pour accéder aux membres de la ligne d'arbre.
Remarque : les modifications apportées à l'intervalle invalideront le wrapper.
Contraintes
Ne participe à la résolution des surcharges que si Range est un arbre.
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(int row)
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::operator[](int row)
Renvoie la valeur à row enveloppée dans une référence mutable au type stocké à Range.
Remarque : les modifications apportées à la plage invalideront cette référence. Pour modifier la référence, il faut lui attribuer 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
Participe à la résolution des surcharges uniquement si Range est une liste mutable.
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_table<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(int row)
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_table<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::operator[](int row)
Renvoie une référence mutable à la ligne row, telle qu'elle est stockée dans Range.
Contraintes
Ne participe à la résolution de surcharge que si Range est une table mutable, mais pas un arbre.
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(int row)
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::operator[](int row)
Renvoie une enveloppe mutable contenant une référence à la ligne d'arbre spécifiée par row.
Pour modifier la ligne d'arbre, attribuez-lui une nouvelle valeur. L'attribution d'une nouvelle ligne d'arbre fera du parent de la nouvelle ligne d'arbre le parent de l'ancienne ligne d'arbre. Cependant, ni l'ancienne ni la nouvelle ligne d'arbre ne doivent avoir de ligne enfant. Pour accéder à la ligne d'arbre, déréférencer le wrapper en utilisant operator*(), ou utiliser operator->() pour accéder aux membres de la ligne d'arbre.
Remarque : les modifications apportées à l'intervalle invalideront le wrapper.
Contraintes
Ne participe à la résolution des surcharges que si Range est un arbre.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> decltype(auto) QRangeModelAdapter::at(QSpan<const int> path) const
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> 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, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> auto QRangeModelAdapter::at(int row) const
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> auto QRangeModelAdapter::operator[](int row) const
Renvoie la valeur à l'adresse row 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, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> decltype(auto) QRangeModelAdapter::at(int row) const
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> decltype(auto) QRangeModelAdapter::operator[](int row) const
Renvoie une référence constante à la ligne row, telle qu'elle est stockée dans Range.
Contraintes
Participe à la résolution des surcharges uniquement si Range est une table ou un arbre.
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(QSpan<const int> path, int column)
Renvoie une référence mutable à la valeur stockée en tant qu'élément spécifié par path et column. Si l'élément est un élément multirôle, il s'agira d'une référence à l'ensemble de l'élément. Si les lignes de Range stockent des types différents sur des colonnes différentes, le type de retour sera QVariant.
Remarque : les modifications apportées à la plage invalideront cette référence. Pour modifier la référence, il faut lui attribuer 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
Participe à la résolution des surcharges uniquement si Range est un arbre mutable.
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(int row, int column)
Renvoie une référence mutable à la valeur stockée en tant qu'élément spécifié par row et column. Si l'élément est un élément multirôle, il s'agira d'une référence à l'élément entier.
Remarque : les modifications apportées à la plage invalideront cette référence. Pour modifier la référence, attribuez-lui une nouvelle valeur. À moins que la valeur stockée dans le site 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 mutable.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> auto QRangeModelAdapter::at(QSpan<const int> path, int column) const
Renvoie une copie de la valeur stockée en tant qu'élément spécifié par path et column. Si l'élément est un élément multirôle, une copie de l'élément entier est renvoyée. Si les lignes de Range stockent des types différents sur des colonnes différentes, le type de retour sera un QVariant.
Contraintes
Ne participe à la résolution des surcharges que si Range est un arbre.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> auto QRangeModelAdapter::at(int row, int column) const
Renvoie une copie de la valeur stockée en tant qu'élément spécifié par row et column. Si l'élément est un élément multirôle, une copie de l'élément entier est renvoyée. Si les lignes de Range stockent des types différents sur des colonnes différentes, le type de retour sera un QVariant.
Contraintes
Participe à la résolution des surcharges uniquement si Range est une table ou un arbre.
int QRangeModelAdapter::columnCount() const
Renvoie le nombre de colonnes. Ce nombre sera égal à un si le site Range représente une liste, sinon il correspondra au nombre d'éléments de chaque ligne.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> QVariant QRangeModelAdapter::data(int row) const
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> QVariant QRangeModelAdapter::data(int row, int role) const
Renvoie une adresse QVariant contenant les données stockées sous l'adresse role donnée pour l'élément à row, ou une adresse QVariant invalide s'il n'y a pas d'élément. Si role n'est pas spécifié, il renvoie un QVariant contenant l'élément complet.
Contraintes
Ne participe à la résolution des surcharges que si Range est une liste.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> QVariant QRangeModelAdapter::data(QSpan<const int> path, int column) const
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> QVariant QRangeModelAdapter::data(QSpan<const int> path, int column, int role) const
Renvoie une adresse QVariant contenant les données stockées sous l'adresse role pour l'élément visé par path et column, ou une adresse QVariant invalide s'il n'y a pas de données stockées pour ce poste ou ce rôle. Si role n'est pas spécifié, il renvoie un QVariant contenant l'élément complet.
Contraintes
Ne participe à la résolution des surcharges que si Range est un arbre.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> QVariant QRangeModelAdapter::data(int row, int column) const
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> QVariant QRangeModelAdapter::data(int row, int column, int role) const
Renvoie une adresse QVariant contenant les données stockées sous l'adresse role pour l'élément auquel se réfèrent les adresses row et column, ou une adresse QVariant invalide si aucune donnée n'est stockée pour ce poste ou ce rôle. Si role n'est pas spécifié, il renvoie un QVariant contenant l'élément complet.
Contraintes
Participe à la résolution des surcharges uniquement si Range est une table ou un arbre.
Voir également setData() et at().
[constexpr] template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> bool QRangeModelAdapter::hasChildren(int row) const
[constexpr] template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> bool QRangeModelAdapter::hasChildren(QSpan<const int> row) const
Retourne s'il y a des lignes sous row.
Contraintes
Ne participe à la résolution de surcharge que si Range est un arbre.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> QModelIndex QRangeModelAdapter::index(int row) const
Renvoie l'adresse QModelIndex pour row.
Contraintes
Ne participe à la résolution de surcharge que si Range est une liste unidimensionnelle.
Il s'agit d'une fonction surchargée.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> QModelIndex QRangeModelAdapter::index(QSpan<const int> path, int column) const
Renvoie l'adresse QModelIndex pour l'élément situé à column pour la ligne de l'arbre 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, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> QModelIndex QRangeModelAdapter::index(int row, int column) const
Renvoie l'adresse QModelIndex pour l'article à row, column.
Contraintes
Ne participe à la résolution de surcharge que si Range est une table ou un arbre.
Il s'agit d'une fonction surchargée.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I> = true> 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(), la colonne sera ajoutée à chaque ligne.
Contraintes
Ne participe à la résolution de la surcharge que si Range a des lignes qui prennent 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, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_column_data<D> = true > bool QRangeModelAdapter::insertColumn(int before, D &&data)
Insère une colonne unique construite à partir de data 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(), la colonne sera ajoutée à chaque ligne.
Si data est une valeur unique, la nouvelle entrée dans 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 pour chaque ligne suivante. S'il y a moins d'éléments dans data qu'il n'y a de lignes, la fonction s'enroule autour du premier élément et recommence à partir de celui-ci.
Contraintes
Ne participe à la résolution de la surcharge que si Range possède des lignes qui permettent l'insertion d'éléments et que les éléments peuvent être construits à partir des entrées de data.
Il s'agit d'une fonction surchargée.
Voir également removeColumn(), insertColumns() et insertRow().
template < typename C, typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_column_range<C> = true > bool QRangeModelAdapter::insertColumns(int before, C &&data)
Insère les colonnes construites à partir des éléments de data 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(), la colonne sera ajoutée à chaque ligne.
Si les éléments de data sont des valeurs, les nouvelles entrées de toutes les lignes seront construites à partir de ces valeurs.
Si les éléments de data sont des conteneurs, les entrées du conteneur extérieur 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 qu'il n'y a de lignes, la fonction s'arrête et recommence à partir du premier élément.
Contraintes
Ne participe à la résolution de surcharge que si Range a des lignes qui permettent l'insertion d'éléments, et que les éléments peuvent être construits à partir des entrées de data.
Voir également removeColumns(), insertColumn() et insertRows().
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true > bool QRangeModelAdapter::insertRow(QSpan<const int> before)
Insère une seule ligne vide avant la ligne au chemin spécifié par before, et renvoie si l'insertion a réussi. Si before a la même valeur que rowCount(), la nouvelle ligne sera ajoutée.
Contraintes
Ne participe à la résolution de surcharge que si Range est un arbre qui prend en charge l'insertion d'éléments.
Il s'agit d'une fonction surchargée.
Voir également insertRows(), removeRow() et insertColumn().
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true> bool QRangeModelAdapter::insertRow(int before)
Insère une seule ligne vide avant la ligne à before, et renvoie si l'insertion a réussi. Si before a la même valeur que rowCount(), la nouvelle ligne sera ajoutée.
Contraintes
Ne participe à la résolution de surcharge 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, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_row<D> = true, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true > bool QRangeModelAdapter::insertRow(QSpan<const int> before, D &&data)
Insère une ligne unique construite à partir de data avant la ligne à before, et renvoie si l'insertion a réussi. Si before a la même valeur que rowCount(), la nouvelle ligne sera ajoutée.
Contraintes
Ne participe à la résolution de surcharge que si Range est un arbre qui supporte 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, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_row<D> = true > bool QRangeModelAdapter::insertRow(int before, D &&data)
Insère une ligne unique construite à partir de data avant la ligne à before, et renvoie si l'insertion a réussi. Si before a la même valeur que rowCount(), la nouvelle ligne sera ajoutée.
Contraintes
Ne participe à la résolution de surcharge que si Range supporte 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, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_row_range<C> = true, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true > bool QRangeModelAdapter::insertRows(QSpan<const int> before, C &&data)
Insère des lignes construites à partir des éléments de data avant la ligne de before, et indique si l'insertion a réussi. Si before a la même valeur que rowCount(), la nouvelle ligne sera ajoutée.
Contraintes
Ne participe à la résolution de surcharge que si Range est un arbre qui supporte 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 aussi insertRow(), removeRows() et insertColumns().
template < typename C, typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_row_range<C> = true > bool QRangeModelAdapter::insertRows(int before, C &&data)
Insère des lignes construites à partir des éléments de data avant la ligne de before, et indique si l'insertion a réussi. Si before a la même valeur que rowCount(), la nouvelle ligne sera ajoutée.
Contraintes
Ne participe à la résolution de surcharge que si Range supporte 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.
template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveColumn(int from, int to)
Déplace la colonne à from vers la colonne à to, et renvoie si la colonne a été déplacée avec succès.
Contraintes
Ne participe à la résolution de surcharge que si Range a des lignes qui supportent le déplacement d'éléments.
Voir aussi insertColumn(), removeColumn(), moveColumns() et moveRow().
template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveColumns(int from, int count, int to)
Déplace les colonnes de count à partir de from vers la position to, et indique si les colonnes ont été déplacées avec succès.
Contraintes
Ne participe à la résolution de la surcharge que si Range a des lignes qui supportent le déplacement d'éléments.
Voir aussi insertColumns(), removeColumns(), moveColumn() et moveRows().
template < typename I, typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true > bool QRangeModelAdapter::moveRow(QSpan<const int> source, QSpan<const int> destination)
Déplace la branche de l'arbre à source vers la position à destination, et renvoie si la branche a été déplacée avec succès.
Contraintes
Ne participe à la résolution de surcharge que si Range est un arbre qui supporte le déplacement d'éléments.
Il s'agit d'une fonction surchargée.
Voir aussi insertRow(), removeRow() et moveColumn().
template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveRow(int source, int destination)
Déplace la ligne située à l'adresse source vers la position située à l'adresse destination, et indique si le déplacement de la ligne a été effectué avec succès.
Contraintes
Ne participe à la résolution de surcharge 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, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true > bool QRangeModelAdapter::moveRows(QSpan<const int> source, int count, QSpan<const int> destination)
Déplace les branches de l'arbre count commençant à source vers la position destination, et renvoie si les lignes ont été déplacées avec succès.
Contraintes
Ne participe à la résolution de la surcharge que si Range est un arbre qui supporte le déplacement d'éléments.
Il s'agit d'une fonction surchargée.
Voir aussi insertRows(), removeRows() et moveColumns().
template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveRows(int source, int count, int destination)
Déplace les lignes de count commençant à source vers la position destination, et renvoie si les lignes ont été déplacées avec succès.
Contraintes
Ne participe à la résolution de surcharge 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().
const QRangeModelAdapter<Range, Protocol, Model>::range_type &QRangeModelAdapter::range() const
Renvoie une référence constante à la plage sur laquelle l'adaptateur de modèle opère.
Voir aussi assign(), at(), et model().
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveColumns<I> = true> bool QRangeModelAdapter::removeColumn(int column)
Supprime le site column de chaque ligne et indique si la suppression a été effectuée avec succès.
Contraintes
Ne participe à la résolution de surcharge que si Range a des lignes qui supportent le retrait d'éléments.
Voir aussi insertColumn(), removeColumns() et removeRow().
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveColumns<I> = true> bool QRangeModelAdapter::removeColumns(int column, int count)
Supprime de chaque ligne count les colonnes commençant par l'adresse column donnée, et indique si la suppression a réussi.
Contraintes
Ne participe à la résolution de surcharge que si Range a des lignes qui supportent la suppression d'éléments.
Voir aussi insertColumns(), removeColumn() et removeRow().
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveRows<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true > bool QRangeModelAdapter::removeRow(QSpan<const int> path)
Supprime la ligne à l'adresse path, y compris tous les enfants de cette ligne, et indique si la suppression a réussi.
Contraintes
Ne participe à la résolution de surcharge que si Range est un arbre qui prend en charge la suppression d'éléments.
Il s'agit d'une fonction surchargée.
Voir aussi removeRows(), removeColumn() et insertRow().
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveRows<I> = true> bool QRangeModelAdapter::removeRow(int row)
Supprime le site row et indique si la suppression a été effectuée avec succès.
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 aussi removeRows(), removeColumn() et insertRow().
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveRows<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true > bool QRangeModelAdapter::removeRows(QSpan<const int> path, int count)
Supprime les lignes de count à partir de la ligne spécifiée par path, et indique si la suppression a réussi.
Contraintes
Ne participe à la résolution de surcharge que si Range est un arbre qui supporte la suppression d'éléments.
Il s'agit d'une fonction surchargée.
Voir également removeRow(), removeColumns() et insertRows().
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveRows<I> = true> bool QRangeModelAdapter::removeRows(int row, int count)
Supprime les lignes de count à partir de 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().
int QRangeModelAdapter::rowCount() const
Renvoie le nombre de lignes. Si le site Range représente une liste ou un tableau, il s'agit du nombre de lignes. Pour les arbres, il s'agit du nombre de lignes de premier niveau.
Il s'agit d'une fonction surchargée.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> int QRangeModelAdapter::rowCount(int row) const
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> int QRangeModelAdapter::rowCount(QSpan<const int> row) const
Renvoie le nombre de lignes sous row.
Contraintes
Ne participe à la résolution des surcharges que si Range est un arbre.
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > bool QRangeModelAdapter::setData(int row, const QVariant &value, int role = Qt::EditRole)
Définit les données de role pour l'élément à row à value.
Renvoie true en cas de succès ; sinon, renvoie false.
Contraintes
Ne participe à la résolution de surcharge que si Range est une liste mutable.
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > bool QRangeModelAdapter::setData(QSpan<const int> path, int column, const QVariant &value, int role = Qt::EditRole)
Définit les données de role pour l'élément auquel se réfèrent path et column à value.
Renvoie true en cas de succès ; sinon, renvoie false.
Contraintes
Ne participe à la résolution de surcharge que si Range est un arbre mutable.
template < typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > bool QRangeModelAdapter::setData(int row, int column, const QVariant &value, int role = Qt::EditRole)
Définit les données de role pour l'élément auquel se réfèrent row et column à value.
Renvoie true en cas de succès ; sinon, renvoie false.
Contraintes
Ne participe à la résolution de surcharge que si Range est mutable et n'est pas une liste.
Non-membres apparentés
[noexcept] bool operator!=(const QRangeModelAdapter<Range, Protocol, Model> &lhs, const QRangeModelAdapter<Range, Protocol, Model> &rhs)
Retourne si lhs n'est pas égal à rhs. Deux adaptateurs sont égaux s'ils contiennent tous deux la même instance model.
[noexcept] bool operator==(const QRangeModelAdapter<Range, Protocol, Model> &lhs, const QRangeModelAdapter<Range, Protocol, Model> &rhs)
Retourne si lhs est égal à rhs. Deux adaptateurs sont égaux s'ils contiennent tous deux la même instance 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.
