QRangeModelAdapter Class
QRangeModelAdapter bietet QAbstractItemModel-konformen Zugriff auf jeden C++-Bereich. Mehr...
| Kopfzeile: | #include <QRangeModelAdapter> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core)target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Seit: | Qt 6.11 |
| Status: | Vorläufig |
Diese Klasse befindet sich in der Entwicklung und kann sich noch ändern.
Diese Klasse ist gleichsetzbar.
Diese Klasse ist gleichsetzbar mit Range.
Öffentliche Funktionen
| 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 |
Private Typen
Verwandte Nicht-Mitglieder
| 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) |
Detaillierte Beschreibung
QRangeModelAdapter bietet eine typsichere und strukturbewusste C++-API um einen C++-Bereich und eine QRangeModel. Änderungen, die mit Hilfe des Adapters an dem C++-Bereich vorgenommen werden, informieren die Clients der QRangeModel über die Änderungen. Dadurch wird sichergestellt, dass Elementansichten aktualisiert, Caches bereinigt und persistente Elementindizes ungültig gemacht und korrekt angepasst werden.
Konstruktion und Modellbesitz
QRangeModelAdapter muss aus einem C++-Bereich konstruiert werden. Wie bei QRangeModel kann der Bereich als lvalue- oder rvalue-Referenz, als Referenz-Wrapper und als Raw- oder Smart-Pointer bereitgestellt werden.
std::vector<int> data = {1, 2, 3, 4, 5}; QRangeModelAdapter adapter(&data);
Der genaue Typ, der konstruiert wird, wird vom Compiler anhand des/der Konstruktorarguments/e abgeleitet, und die Unterschiede zwischen den Wertkategorien können zu unterschiedlichem Verhalten führen. Daher sollten Sie die Template-Parameter nicht explizit angeben. C++ erlaubt jedoch keine Ableitung von Klassenvorlagenargumenten für nicht-statische Klassendatenmitglieder. Um QRangeModelAdapter zu einem Datenmitglied einer Klasse zu machen, verwenden Sie das folgende Muster:
class Backend { using Adapter = decltype(QRangeModelAdapter(std::vector<Book>{})); Adapter adapter = Adapter(std::vector<Book>{});
Dies erzeugt einen QRangeModelAdapter, der auf einem unbenannten (d.h. rvalue-Referenz) Vektor von Books arbeitet. Um den Adapter auf einen Referenz Wrapper auf eine Liste von Büchern arbeiten zu lassen, verwenden Sie stattdessen dies:
QList<Book> books = { /* ... */ }; using Adapter = decltype(QRangeModelAdapter(std::ref(books))); Adapter adapter = Adapter(std::ref(books)); };
Das Konstruieren des Adapters aus einem Bereich konstruiert implizit eine QRangeModel Instanz aus dem gleichen Bereich. Verwenden Sie model() um diese zu erhalten, und übergeben Sie diese an Qt Widgets oder Qt Quick item views wie üblich.
QListView listView; listView.setModel(adapter.model());
Der Adapter besitzt das Model. QRangeModelAdapter ist ein Wertetyp, daher kann er kopiert und verschoben werden. Alle Kopien teilen sich die gleiche QRangeModel, die zerstört wird wenn die letzte Kopie des Adapters zerstört wird.
Wenn der Adapter aus einer lvalue- oder rvalue-Referenz erstellt wurde, dann arbeiten der Adapter und das Modell mit einer Kopie des ursprünglichen Bereichsobjekts. Andernfalls werden Änderungen, die durch den Adapter oder das Modell vorgenommen werden, in das ursprüngliche Bereichsobjekt geschrieben. Um auf den aktualisierten Bereich zuzugreifen, verwenden Sie 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();
Um die gesamten Bereichsdaten durch Daten aus einem anderen (kompatiblen) Bereich zu ersetzen, verwenden Sie die Funktion assign() oder den Zuweisungsoperator.
// reset to the original adapter = books; // or adapter.assign(books);
Zugriff auf Positionsdaten
Die QRangeModelAdapter API bietet einen typsicheren Lese- und Schreibzugriff auf den Bereich, mit dem das Modell arbeitet. Die Adapter-API basiert auf der typischen API für C++ Container und Bereiche, einschließlich Iteratoren. Um auf einzelne Zeilen und Elemente zuzugreifen, verwenden Sie at(), das entsprechende Subscript operator[] oder data(). Welche Überladungen dieser Funktionen verfügbar sind, hängt von dem Bereich ab, für den der Adapter konstruiert wurde.
Lesen von Item Daten als QVariant
Die Funktion data() gibt immer eine QVariant mit dem Wert zurück, der an der angegebenen Position und Rolle gespeichert ist. In einer Liste kann auf ein Element durch einen einzelnen Integer Wert zugegriffen werden, der die Zeile angibt:
QVariant listItem = listAdapter.data(row);
Handelt es sich bei dem Bereich um eine Tabelle, so werden die Elemente durch Zeile und Spalte angegeben:
QVariant tableItem = tableAdapter.data(row, column);
Handelt es sich bei dem Bereich um einen Baum, so werden die Elemente über einen Zeilenpfad und einen einzelnen Spaltenwert gefunden:
QVariant treeItem = treeAdapter.data({path, to, branch}, column);
Die Verwendung einer einzelnen Ganzzahl als Zeile ermöglicht den Zugriff auf die Elemente der obersten Ebene des Baums.
QRangeModelAdapter listOfBooks(QList<Book>{ // ~~~ }); QString bookTitle = listOfBooks.data(0, Book::TitleRole).toString(); Book multiRoleItem = listOfBooks.data(0).value<Book>();
Wenn keine Rolle angegeben wird, enthält QVariant das gesamte Element an der Position. Verwenden Sie die Vorlagenfunktion QVariant::fromValue(), um eine Kopie des Elements abzurufen.
Lesen und Schreiben mit at()
Die Tatsache, dass die Funktion data() eine QVariant zurückgibt, macht sie flexibel, hebt aber die Typsicherheit auf. Für Bereiche, in denen alle Elemente vom gleichen Typ sind, bietet die Funktion at() eine typsichere Alternative, die besser mit regulären C++-Containern kompatibel ist. Wie bei data() gibt es auch bei at() Überladungen für den Zugriff auf ein Element in einer Zeile für Listen, in einem Zeilen/Spalten-Paar für Tabellen und in einem Pfad/Spalten-Paar für Bäume. at () gibt jedoch immer das gesamte Element an der angegebenen Position zurück; es ist nicht möglich, einen einzelnen Rollenwert für ein Element zu lesen.
Wie von einer C++-Container-API erwartet, bieten die const-Überladungen von at() (und das entsprechende tiefgestellte operator[]) unveränderlichen Zugriff auf den Wert, während die veränderlichen Überladungen ein Referenzobjekt zurückgeben, dem ein neuer Wert zugewiesen werden kann. Beachten Sie, dass ein QRangeModelAdapter, der auf einem const-Bereich arbeitet, sich in dieser Hinsicht wie ein const QRangeModelAdapter verhält. Die veränderbaren Überladungen werden aus dem Überladungssatz entfernt, so dass der Compiler immer die const-Version auswählt. Der Versuch, eine Funktion aufzurufen, die einen Bereich modifiziert, führt zu einem Compilerfehler, selbst wenn der Adapter selbst veränderbar ist:
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
Die zurückgegebenen Referenzobjekte sind Wrapper, die implizit in den zugrundeliegenden Typ konvertieren, eine get() Funktion haben, um explizit auf den zugrundeliegenden Wert zuzugreifen, und eine operator->(), die direkten Zugriff auf const Memberfunktionen bietet. Um jedoch versehentliche Datenänderungen zu verhindern, die das QAbstractItemModel Benachrichtigungsprotokoll umgehen würden, verhindern diese Referenzobjekte direkte Änderungen der Elemente.
Hinweis: Der Zugriff auf das Referenzobjekt führt immer zu einem Aufruf des Modells, um eine Kopie des Wertes zu erhalten. Dies kann kostspielig sein; für einen leistungsrelevanten Zugriff auf Daten sollte eine Kopie gespeichert werden.
Item-Zugriff
Wenn der Bereich als Liste dargestellt wird, sind nur die Überladungen verfügbar, die eine Zeile nehmen.
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);
Die const-Überladung gibt das Element in dieser Zeile zurück, während die mutable-Überladung einen Wrapper zurückgibt, der implizit in und aus dem Wertetyp der Liste konvertiert.
QRangeModelAdapter books(QList<Book>{ // ~~~ }); Book firstBook = books.at(0); Book newBook = {}; books.at(0) = newBook; // dataChanged() emitted
Weisen Sie dem Wrapper einen Wert zu, um die Daten in der Liste zu ändern. Das Modell wird dataChanged() für alle Rollen ausgeben.
Bei Verwendung der mutable Überladungen können Sie auch auf die const Mitglieder des Elementtyps zugreifen, indem Sie den überladenen Pfeiloperator verwenden.
QString title = books.at(0)->title();
Es ist nicht möglich, auf nicht-konstante Elemente des Elements zuzugreifen. Solche Änderungen würden den Adapter umgehen, der das Modell nicht über die Änderungen informieren könnte. Um den im Modell gespeicherten Wert zu ändern, erstellen Sie eine Kopie, ändern Sie die Eigenschaften der Kopie und schreiben Sie diese Kopie dann zurück.
// 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
Dadurch wird das Modell dataChanged() für dieses Element und für alle Rollen ausgeben.
Wenn der Bereich als Tabelle dargestellt wird, können Sie mit der Überladung at(Zeile, Spalte) auf ein einzelnes Element nach Zeilen und Spalten zugreifen. Bei Bäumen ermöglicht diese Überladung den Zugriff auf die Elemente der obersten Ebene, während die Überladung at(path, column) den Zugriff auf die im Baum verschachtelten Elemente ermöglicht.
Der Zugriff auf ein einzelnes Element in einer Tabelle oder einem Baum ist gleichbedeutend mit dem Zugriff auf ein Element in einer 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
Wenn der Bereich nicht alle Spalten mit dem gleichen Datentyp speichert, gibt at(row,column) einen (Referenz-Wrapper mit einem) QVariant zurück, der das Element enthält.
QRangeModelAdapter table(std::vector<std::tuple<int, QString>>{ // ~~~ }); int number = table.at(0, 0)->toInt(); QString text = table.at(0, 1)->toString();
Zugriff auf Zeilen in Tabellen und Bäumen
Bei Tabellen und Bäumen bieten die Überladungen von at() und subscript operator[] ohne den Spaltenparameter Zugriff auf die gesamte Zeile. Der Wert, der von den const-Überladungen zurückgegeben wird, ist ein Referenztyp, der Zugriff auf die Zeilendaten ermöglicht. Wenn diese Zeile Zeiger enthält, dann ist dieser Referenztyp eine Ansicht der Zeile, die Zugriff auf Zeiger auf const-Elemente ermöglicht.
Zugriff auf Tabellenzeilen
Die Überladung at(int) ist immer noch verfügbar, aber sie gibt die gesamte Tabellenzeile zurück. Dadurch ist es möglich, mit allen Werten in der Zeile auf einmal zu arbeiten.
const auto &constTable = table; const std::vector<double> &topRow = constTable.at(0);
Wie bei items bietet die const-Überladung direkten Zugriff auf den Zeilentyp, während die mutable-Überladung einen Wrapper zurückgibt, der als Referenz auf die Zeile fungiert. Der Wrapper ermöglicht den Zugriff auf const-Mitgliedsfunktionen unter Verwendung des überladenen Pfeiloperators. Um die Werte zu ändern, schreiben Sie einen geänderten Zeilentyp zurück.
auto lastRow = table.at(table.rowCount() - 1); lastRow = { 6.5, 7.5, 8.0, 9.0, 10 }; // emits dataChanged() for entire row
Wenn der Zeile ein neuer Wert zugewiesen wird, gibt das Modell das Signal dataChanged() für alle Elemente in der Zeile und für alle Rollen aus.
Hinweis: Wenn Sie einen Zeilentyp mit Laufzeitgrößen verwenden, wie z. B. std::vector oder QList, stellen Sie sicher, dass die neue Zeile die richtige Größe hat.
Zugriff auf Baumzeilen
Zeilen in Bäumen werden durch eine Folge von Ganzzahlen angegeben, ein Eintrag für jede Ebene im Baum. Beachten Sie, dass in den folgenden Schnipseln der Tree ein Bereich ist, der rohe Zeilenzeiger enthält, und dass der Adapter mit einer rvalue-Referenz dieses Bereichs erstellt wird. Dies gibt der QRangeModel die Eigentümerschaft über die Zeilendaten.
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});
Die Überladung von at() mit einem einzelnen Zeilenwert ermöglicht den Zugriff auf die obersten Zeilen oder Elemente in den obersten Zeilen.
auto germanyName = tree.at(0, 0); auto bavariaSize = tree.at({0, 0}, 1);
Das grundlegende Muster für den Zugriff auf Zeilen und Elemente in einem Baum ist identisch mit dem Zugriff auf Zeilen und Elemente in einer Tabelle. Der Adapter stellt jedoch sicher, dass die Baumstruktur beibehalten wird, wenn ganze Zeilen verändert werden.
// deletes the old row - tree was moved in tree.at({0, 0}) = new TreeRow{"Berlin", 892};
In diesem Beispiel wird ein neues Zeilenobjekt erstellt und dem ersten Kind des ersten Top-Level Items zugewiesen.
Iterator API
Verwenden Sie begin() und end(), um Iteratoren über die Zeilen des Modells zu erhalten, oder verwenden Sie ranged-for. Wenn der Bereich eine Liste von Elementen ist, ermöglicht die Dereferenzierung des Iterators den Zugriff auf die Elementdaten.
for(const auto &book: std::as_const(books)) { qDebug() << "The book" << book.title() << "geschrieben von"<< book.author()<< "hat"<< book.rating()<< "Sterne"; }
Wie bei den const und mutable Überladungen von at() wird ein mutable Iterator auf einen Wrapper dereferenzieren.
for(auto book : books) { qDebug() << "The book" << book->title() << "geschrieben von"<< book->author()<< "hat"<< book->rating()<< "Sterne"; Book copy = book; copy.setRating(copy.rating() + 1); book = copy; }
Verwenden Sie den überladenen Pfeiloperator, um auf Konstanten des Elementtyps zuzugreifen, und weisen Sie dem Wrapper zu, um den Wert zu ersetzen.
Handelt es sich bei dem Bereich um eine Tabelle oder einen Baum, dann kann durch Iteration über das Modell auf die Zeilen zugegriffen werden.
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; }
Sowohl der const als auch der mutable Iterator dereferenzieren auf einen Wrapper-Typ für die Zeile. Dadurch wird sichergestellt, dass wir konsistent über jede Spalte iterieren können, auch wenn der zugrunde liegende Zeilentyp kein Bereich ist (z. B. könnte es sich um ein Tupel oder ein Gadget handeln).
for(const auto &row: std::as_const(table)) { for(const auto &item: row) { qDebug() << item; // item is a QVariant } }
Beim Iterieren über eine veränderbare Tabelle können wir die gesamte Zeile überschreiben.
for(auto row : table) { qDebug() << "Number is" << row->first << "and string is" << row->second; row = std::make_pair(42, u"forty-two"_s); }
Das Modell sendet das Signal dataChanged() für alle Elemente in allen Zeilen und für alle Rollen.
for (auto row : table) { for (auto item : row) { item = 42; } }
Durch Iteration über die veränderbaren Zeilen können wir einzelne Elemente ändern.
Bei der Iteration über einen Baum verfügt die Zeilenumhüllung über zwei zusätzliche Mitgliedsfunktionen, hasChildren() und children(), die es uns ermöglichen, den gesamten Baum mit Iteratoren zu durchlaufen.
for (auto row : tree) { if (row.hasChildren()) { for (auto child : row.children()) { // ~~~ } } }
Das von children() zurückgegebene Objekt ist ein QRangeModelAdapter, der mit demselben Modell wie der Aufrufer arbeitet, aber alle Operationen verwenden den Index der Quellzeile als übergeordneten Index.
Siehe auch QRangeModel.
Dokumentation der Mitgliederfunktionen
[default] QRangeModelAdapter::QRangeModelAdapter(Range &&range, Protocol &&protocol)
[default] QRangeModelAdapter::QRangeModelAdapter(Range &&range)
Konstruiert eine QRangeModelAdapter, die auf range arbeitet. Für Baumbereiche wird die optionale protocol für die Baumdurchquerung verwendet.
Siehe die QRangeModel Konstruktor Dokumentation für Details über die Anforderungen an Range, und wie die Wertekategorie von range die Interaktion zwischen Adapter, Modell und Bereich ändert.
Siehe auch 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)
Ersetzt den Inhalt des Modells durch die Zeilen in newRange, möglicherweise unter Verwendung der Move-Semantik.
Diese Funktion bewirkt, dass model() die Signale modelAboutToBeReset() und modelReset() ausgibt.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range veränderbar ist und newRange von einem Typ ist, der Range zugewiesen werden kann, aber nicht QRangeModelAdapter.
Siehe auch range(), at(), model(), und 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)
Ersetzt den Inhalt des Modells durch die Zeilen in newRange.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range veränderbar ist und newRange an Range zugewiesen werden kann.
Siehe auch range(), at, und model().
template < typename InputIterator, typename Sentinel, typename I, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > void QRangeModelAdapter::assign(InputIterator first, Sentinel last)
Ersetzt den Inhalt der Modelle durch die Zeilen im Bereich [first, last).
Siehe auch range(), at, und 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)
Gibt einen veränderbaren Wrapper zurück, der einen Verweis auf die durch path angegebene Baumreihe enthält.
Um die Baumreihe zu ändern, weisen Sie ihr einen neuen Wert zu. Durch die Zuweisung einer neuen Baumzeile wird die neue Baumzeile als Elternteil der alten Baumzeile festgelegt. Allerdings dürfen weder die alte noch die neue Baumzeile Kindzeilen haben. Um auf die Baumreihe zuzugreifen, muss die Verschalung mit operator*() dereferenziert werden, oder es muss operator->() verwendet werden, um auf die Mitglieder der Baumreihe zuzugreifen.
Hinweis: Änderungen am Bereich machen die Verschalung ungültig.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist.
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)
Gibt den Wert unter row zurück, der in eine veränderbare Referenz auf den in Range gespeicherten Typ verpackt ist.
Hinweis: Änderungen am Bereich machen diesen Verweis ungültig. Um den Verweis zu ändern, weisen Sie ihm einen neuen Wert zu. Sofern es sich bei dem in Range gespeicherten Wert nicht um einen Zeiger handelt, ist es nicht möglich, auf einzelne Member des gespeicherten Wertes zuzugreifen.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range eine veränderbare Liste ist.
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)
Gibt eine veränderbare Referenz auf die Zeile row zurück, die in Range gespeichert ist.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range eine veränderbare Tabelle, aber kein Baum ist.
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)
Gibt einen veränderbaren Wrapper zurück, der einen Verweis auf die durch row angegebene Baumreihe enthält.
Um die Baumreihe zu ändern, weisen Sie ihr einen neuen Wert zu. Durch die Zuweisung einer neuen Baumreihe wird die neue Baumreihe als Elternteil der alten Baumreihe festgelegt. Allerdings dürfen weder die alte noch die neue Baumzeile Kindzeilen haben. Um auf die Baumreihe zuzugreifen, muss die Verschalung mit operator*() dereferenziert werden, oder es muss operator->() verwendet werden, um auf die Mitglieder der Baumreihe zuzugreifen.
Hinweis: Änderungen am Bereich machen die Verschalung ungültig.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist.
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
Gibt einen konstanten Verweis auf die durch path angegebene Zeile zurück, die in Range gespeichert ist.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist.
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
Gibt den Wert unter row als den in Range gespeicherten Typ zurück.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range eine Liste ist.
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
Gibt eine konstante Referenz auf die Zeile row zurück, die in Range gespeichert ist.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range eine Tabelle oder ein Baum ist.
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)
Gibt einen veränderbaren Verweis auf den Wert zurück, der als das durch path und column angegebene Element gespeichert ist. Handelt es sich bei dem Element um ein Multi-Role-Element, so ist dies ein Verweis auf das gesamte Element. Wenn die Zeilen in Range verschiedene Typen in verschiedenen Spalten speichern, dann ist der Rückgabetyp QVariant.
Hinweis: Änderungen an dem Bereich machen den Verweis ungültig. Um den Verweis zu ändern, weisen Sie ihm einen neuen Wert zu. Sofern es sich bei dem in Range gespeicherten Wert nicht um einen Zeiger handelt, ist es nicht möglich, auf einzelne Elemente des gespeicherten Wertes zuzugreifen.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein veränderbarer Baum ist.
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)
Gibt einen veränderbaren Verweis auf den Wert zurück, der als das durch row und column angegebene Element gespeichert ist. Handelt es sich bei dem Element um ein Element mit mehreren Rollen, ist dies ein Verweis auf das gesamte Element.
Hinweis: Änderungen am Bereich machen diesen Verweis ungültig. Um die Referenz zu ändern, weisen Sie ihr einen neuen Wert zu. Sofern es sich bei dem in Range gespeicherten Wert nicht um einen Zeiger handelt, ist es nicht möglich, auf einzelne Elemente des gespeicherten Wertes zuzugreifen.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range eine veränderbare Tabelle ist.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> auto QRangeModelAdapter::at(QSpan<const int> path, int column) const
Gibt eine Kopie des Wertes zurück, der als das durch path und column angegebene Element gespeichert ist. Handelt es sich bei dem Element um ein Element mit mehreren Rollen, wird eine Kopie des gesamten Elements zurückgegeben. Wenn die Zeilen in Range verschiedene Typen in verschiedenen Spalten speichern, dann ist der Rückgabetyp QVariant.
Beschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> auto QRangeModelAdapter::at(int row, int column) const
Gibt eine Kopie des Wertes zurück, der als das durch row und column angegebene Element gespeichert ist. Handelt es sich bei dem Element um ein Element mit mehreren Rollen, wird eine Kopie des gesamten Elements zurückgegeben. Wenn die Zeilen in Range verschiedene Typen in verschiedenen Spalten speichern, dann ist der Rückgabetyp QVariant.
Beschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range eine Tabelle oder ein Baum ist.
int QRangeModelAdapter::columnCount() const
Gibt die Anzahl der Spalten zurück. Dies ist eins, wenn Range eine Liste darstellt, andernfalls wird die Anzahl der Elemente in jeder Zeile zurückgegeben.
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
Gibt ein QVariant zurück, das die Daten enthält, die unter dem angegebenen role für das Element unter row gespeichert sind, oder ein ungültiges QVariant, wenn es kein Element gibt. Wenn role nicht angegeben ist, wird QVariant zurückgegeben, das den vollständigen Eintrag enthält.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range eine Liste ist.
Siehe auch setData() und at().
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
Gibt ein QVariant mit den Daten zurück, die unter dem angegebenen role für die Position gespeichert sind, auf die path und column verweisen, oder ein ungültiges QVariant, wenn für diese Position oder Rolle keine Daten gespeichert sind. Wenn role nicht angegeben ist, wird QVariant zurückgegeben, das die vollständige Position enthält.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist.
Siehe auch setData() und at().
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
Gibt ein QVariant mit den Daten zurück, die unter dem angegebenen role für die Position gespeichert sind, auf die row und column verweisen, oder ein ungültiges QVariant, wenn für diese Position oder Rolle keine Daten gespeichert sind. Wenn role nicht angegeben ist, wird QVariant zurückgegeben, das die vollständige Position enthält.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range eine Tabelle oder ein Baum ist.
Siehe auch setData() und 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
Gibt zurück, ob es Zeilen unter row gibt.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> QModelIndex QRangeModelAdapter::index(int row) const
Gibt die QModelIndex für row zurück.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range eine eindimensionale Liste ist.
Dies ist eine überladene Funktion.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> QModelIndex QRangeModelAdapter::index(QSpan<const int> path, int column) const
Gibt die QModelIndex für das Element unter column für die durch path angegebene Zeile im Baum zurück.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range ein Baum ist.
Dies ist eine überladene Funktion.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> QModelIndex QRangeModelAdapter::index(int row, int column) const
Gibt die QModelIndex für das Element row, column zurück.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range eine Tabelle oder ein Baum ist.
Dies ist eine überladene Funktion.
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I> = true> bool QRangeModelAdapter::insertColumn(int before)
Fügt eine einzelne leere Spalte vor der durch before angegebenen Spalte in alle Zeilen ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn before den gleichen Wert wie columnCount() hat, wird die Spalte an jede Zeile angehängt.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range Zeilen hat, die das Einfügen von Elementen unterstützen.
Dies ist eine überladene Funktion.
Siehe auch removeColumn(), insertColumns(), und 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)
Fügt eine einzelne, aus data konstruierte Spalte vor der durch before angegebenen Spalte in alle Zeilen ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn before derselbe Wert wie columnCount() ist, wird die Spalte an jede Zeile angehängt.
Wenn data ein Einzelwert ist, wird der neue Eintrag in allen Zeilen aus diesem Einzelwert gebildet.
Wenn data ein Container ist, werden die Elemente in diesem Container nacheinander verwendet, um die Spalte für jede nachfolgende Zeile zu konstruieren. Wenn data weniger Elemente als Zeilen enthält, beginnt die Funktion wieder mit dem ersten Element.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range Zeilen hat, die das Einfügen von Elementen unterstützen, und die Elemente aus den Einträgen in data konstruiert werden können.
Dies ist eine überladene Funktion.
Siehe auch removeColumn(), insertColumns(), und 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)
Fügt in alle Zeilen Spalten ein, die aus den Elementen in data vor der durch before angegebenen Spalte gebildet wurden, und gibt zurück, ob das Einfügen erfolgreich war. Wenn before derselbe Wert wie columnCount() ist, wird die Spalte an jede Zeile angehängt.
Handelt es sich bei den Elementen in data um Werte, so werden die neuen Einträge in allen Zeilen aus diesen Werten gebildet.
Wenn es sich bei den Elementen in data um Container handelt, werden die Einträge im äußeren Container nacheinander verwendet, um die neuen Einträge für jede nachfolgende Zeile zu erstellen. Gibt es in data weniger Elemente als Zeilen, so wird die Funktion umgeschlagen und beginnt wieder beim ersten Element.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range Zeilen hat, die das Einfügen von Elementen unterstützen, und die Elemente aus den Einträgen in data konstruiert werden können.
Siehe auch removeColumns(), insertColumn(), und 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)
Fügt eine einzelne leere Zeile vor der Zeile an dem durch before angegebenen Pfad ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn before den gleichen Wert wie rowCount() hat, wird die neue Zeile angefügt.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist, der das Einfügen von Elementen unterstützt.
Dies ist eine überladene Funktion.
Siehe auch insertRows(), removeRow(), und insertColumn().
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true> bool QRangeModelAdapter::insertRow(int before)
Fügt eine einzelne leere Zeile vor der Zeile unter before ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn before den gleichen Wert wie rowCount() hat, wird die neue Zeile angefügt.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range das Einfügen von Elementen unterstützt.
Dies ist eine überladene Funktion.
Siehe auch insertRows(), removeRow(), und 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)
Fügt eine einzelne Zeile aus data vor der Zeile unter before ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn before denselben Wert wie rowCount() hat, wird die neue Zeile angefügt.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range ein Baum ist, der das Einfügen von Elementen unterstützt, und wenn eine Zeile aus data konstruiert werden kann.
Dies ist eine überladene Funktion.
Siehe auch insertRows(), removeRow(), und 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)
Fügt eine einzelne Zeile aus data vor der Zeile unter before ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn before denselben Wert wie rowCount() hat, wird die neue Zeile angefügt.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range das Einfügen von Elementen unterstützt und wenn eine Zeile aus data konstruiert werden kann.
Dies ist eine überladene Funktion.
Siehe auch insertRows(), removeRow(), und 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)
Fügt aus den Elementen in data konstruierte Zeilen vor der Zeile unter before ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn before den gleichen Wert wie rowCount() hat, wird die neue Zeile angefügt.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range ein Baum ist, der das Einfügen von Elementen unterstützt, und wenn Zeilen aus den Elementen in data konstruiert werden können.
Dies ist eine überladene Funktion.
Siehe auch insertRow(), removeRows(), und 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)
Fügt aus den Elementen in data konstruierte Zeilen vor der Zeile unter before ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn before den gleichen Wert wie rowCount() hat, wird die neue Zeile angefügt.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range das Einfügen von Elementen unterstützt und wenn Zeilen aus den Elementen in data konstruiert werden können.
Dies ist eine überladene Funktion.
Siehe auch insertRow(), removeRows(), und insertColumns().
Model *QRangeModelAdapter::model() const
Gibt die QRangeModel Instanz zurück die von diesem Adapter erstellt wurde.
template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveColumn(int from, int to)
Verschiebt die Spalte unter from in die Spalte unter to und gibt zurück, ob die Spalte erfolgreich verschoben wurde.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range Zeilen hat, die das Verschieben von Elementen unterstützen.
Siehe auch insertColumn(), removeColumn(), moveColumns(), und moveRow().
template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveColumns(int from, int count, int to)
Verschiebt count Spalten ab from an die Position to und gibt zurück, ob die Spalten erfolgreich verschoben wurden.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range Zeilen hat, die das Verschieben von Elementen unterstützen.
Siehe auch insertColumns(), removeColumns(), moveColumn(), und 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)
Verschiebt den Baumzweig auf source an die Position auf destination und gibt zurück, ob der Zweig erfolgreich verschoben wurde.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist, der das Verschieben von Elementen unterstützt.
Dies ist eine überladene Funktion.
Siehe auch insertRow(), removeRow(), und moveColumn().
template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveRow(int source, int destination)
Verschiebt die Zeile source an die Position destination und gibt zurück, ob die Zeile erfolgreich verschoben wurde.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range das Verschieben von Elementen unterstützt.
Dies ist eine überladene Funktion.
Siehe auch insertRow(), removeRow(), und 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)
Verschiebt die Zweige des Baums count ab source an die Position destination und gibt zurück, ob die Zeilen erfolgreich verschoben wurden.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist, der das Verschieben von Elementen unterstützt.
Dies ist eine überladene Funktion.
Siehe auch insertRows(), removeRows(), und moveColumns().
template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveRows(int source, int count, int destination)
Verschiebt count Zeilen ab source an die Position destination und gibt zurück, ob die Zeilen erfolgreich verschoben wurden.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range das Verschieben von Elementen unterstützt.
Dies ist eine überladene Funktion.
Siehe auch insertRows(), removeRows(), und moveColumns().
const QRangeModelAdapter<Range, Protocol, Model>::range_type &QRangeModelAdapter::range() const
Gibt eine konstante Referenz auf den Bereich zurück, auf den der Modeladapter wirkt.
Siehe auch assign(), at(), und model().
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveColumns<I> = true> bool QRangeModelAdapter::removeColumn(int column)
Entfernt die angegebene column aus jeder Zeile und gibt zurück, ob das Entfernen erfolgreich war.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range Zeilen hat, die das Entfernen von Elementen unterstützen.
Siehe auch insertColumn(), removeColumns(), und removeRow().
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveColumns<I> = true> bool QRangeModelAdapter::removeColumns(int column, int count)
Entfernt count Spalten, die mit dem angegebenen column beginnen, aus jeder Zeile und gibt zurück, ob das Entfernen erfolgreich war.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range Zeilen hat, die das Entfernen von Elementen unterstützen.
Siehe auch insertColumns(), removeColumn(), und 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)
Entfernt die Zeile an der angegebenen Adresse path, einschließlich aller untergeordneten Zeilen, und gibt zurück, ob die Entfernung erfolgreich war.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range ein Baum ist, der das Entfernen von Elementen unterstützt.
Dies ist eine überladene Funktion.
Siehe auch removeRows(), removeColumn(), und insertRow().
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveRows<I> = true> bool QRangeModelAdapter::removeRow(int row)
Entfernt die angegebene row und gibt zurück, ob das Entfernen erfolgreich war.
Einschränkungen
Nimmt nur an der Überladungsauflösung teil, wenn Range das Entfernen von Elementen unterstützt.
Dies ist eine überladene Funktion.
Siehe auch removeRows(), removeColumn(), und 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)
Entfernt count Zeilen, beginnend mit der durch path angegebenen Zeile, und gibt zurück, ob das Entfernen erfolgreich war.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist, der das Entfernen von Elementen unterstützt.
Dies ist eine überladene Funktion.
Siehe auch removeRow(), removeColumns(), und insertRows().
template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveRows<I> = true> bool QRangeModelAdapter::removeRows(int row, int count)
Entfernt count Zeilen, beginnend mit row, und gibt zurück, ob das Entfernen erfolgreich war.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range das Entfernen von Elementen unterstützt.
Dies ist eine überladene Funktion.
Siehe auch removeRow(), removeColumns(), und insertRows().
int QRangeModelAdapter::rowCount() const
Gibt die Anzahl der Zeilen zurück. Wenn Range eine Liste oder Tabelle darstellt, ist dies die Anzahl der Zeilen. Bei Bäumen ist dies die Anzahl der Zeilen der obersten Ebene.
Dies ist eine überladene Funktion.
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
Gibt die Anzahl der Zeilen unter row zurück.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein Baum ist.
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)
Setzt die Daten von role für das Element unter row auf value.
Gibt bei Erfolg true zurück, andernfalls false.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range eine veränderbare Liste ist.
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)
Setzt die Daten von role für das Element, auf das path und column verweisen, auf value.
Gibt bei Erfolg true zurück, andernfalls false.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range ein veränderbarer Baum ist.
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)
Setzt die Daten von role für das Element, auf das row und column verweisen, auf value.
Gibt bei Erfolg true zurück, andernfalls false.
Einschränkungen
Nimmt nur an der Überlastauflösung teil, wenn Range veränderbar und keine Liste ist.
Verwandte Nicht-Mitglieder
[noexcept] bool operator!=(const QRangeModelAdapter<Range, Protocol, Model> &lhs, const QRangeModelAdapter<Range, Protocol, Model> &rhs)
Gibt zurück, ob lhs nicht gleich rhs ist. Zwei Adapter sind gleich, wenn sie beide die gleiche model Instanz enthalten.
[noexcept] bool operator==(const QRangeModelAdapter<Range, Protocol, Model> &lhs, const QRangeModelAdapter<Range, Protocol, Model> &rhs)
Gibt zurück, ob lhs gleich rhs ist. Zwei Adapter sind gleich, wenn sie beide die gleiche model Instanz enthalten.
© 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.