Auf dieser Seite

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

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 Mitgliedstypen

[alias] QRangeModelAdapter::range_type

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.

Siehe auch range() und at().

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.

Siehe auch data() und at().

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.

Siehe auch data() und at().

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.

Siehe auch data() und at().

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.