Auf dieser Seite

QRangeModelAdapter Class

QRangeModelAdapter bietet einen „ QAbstractItemModel “-konformen Zugriff auf beliebige C++-Bereiche. Mehr...

Header: #include <QRangeModelAdapter>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Seit: Qt 6.11
Status: Technologievorschau

Diese Klasse befindet sich in der Technologievorschau und kann sich noch ändern.

QRangeModelAdapter-Vergleiche

KategorieVergleichbare Typen
GleichheitQRangeModelAdapter
GleichheitBereich.

Öffentliche Typen

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

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

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)

Ausführliche Beschreibung

QRangeModelAdapter stellt eine typsichere und strukturbewusste C++-API für einen C++-Bereich und ein „ QRangeModel “ bereit. Änderungen, die mithilfe des Adapters am C++-Bereich vorgenommen werden, informieren die Clients des „ QRangeModel “ über die Änderungen. Dadurch wird sichergestellt, dass Elementansichten aktualisiert, Caches geleert und persistente Elementindizes ungültig gemacht und korrekt angepasst werden.

Konstruktion und Modellbesitz

QRangeModelAdapter muss aus einem C++-Bereich instanziiert werden. Wie bei QRangeModel kann der Bereich als L- oder R-Wert-Referenz, als Referenz-Wrapper sowie als Raw- oder Smart-Pointer übergeben werden.

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

Der genaue Typ, der instanziiert wird, wird vom Compiler anhand der Konstruktorargumente 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 Klassen-Template-Argumenten für nicht-statische Klassendatenelemente. Um QRangeModelAdapter zu einem Datenelement einer Klasse zu machen, verwenden Sie das folgende Muster:

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

Dadurch wird ein `QRangeModelAdapter` erstellt, der auf einem unbenannten (d. h. einer `rvalue`-Referenz) Vektor von `Books` operiert. Damit der Adapter auf einem Referenz-Wrapper für eine Liste von `Books` operiert, verwenden Sie stattdessen Folgendes:

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

Die Erstellung des Adapters aus einem Bereich konstruiert implizit eine „ QRangeModel “-Instanz aus demselben Bereich. Verwenden Sie „ model()“, um diese abzurufen, und übergeben Sie sie wie gewohnt an „ Qt Widgets “ oder „ Qt Quick “-Elementansichten.

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

Der Adapter ist Eigentümer des Modells. „QRangeModelAdapter“ ist ein Werttyp und kann daher kopiert und verschoben werden. Alle Kopien teilen sich dasselbe „ QRangeModel “, das zerstört wird, sobald die letzte Kopie des Adapters zerstört wird.

Wurde der Adapter aus einer L-Value- oder R-Value-Referenz erstellt, arbeiten Adapter und Modell mit einer Kopie des ursprünglichen Bereichsobjekts. Andernfalls werden über den Adapter oder das Modell vorgenommene Änderungen 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 Elementdaten

Die QRangeModelAdapter-API bietet typsicheren Lese- und Schreibzugriff auf den Bereich, auf den das Modell angewendet wird. 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()`, den entsprechenden Index operator[]` oder ` data()`. Welche Überladungen dieser Funktionen verfügbar sind, hängt von dem Bereich ab, für den der Adapter erstellt wurde.

Auslesen von Elementdaten als `QVariant`

Die Funktion ` data()` gibt immer ein ` QVariant ` mit dem Wert zurück, der an der angegebenen Position und Rolle gespeichert ist. In einer Liste kann auf ein Element über einen einzelnen ganzzahligen Wert zugegriffen werden, der die Zeile angibt:

QVariant listItem = listAdapter.data(row);

Ist der Bereich eine Tabelle, werden Elemente durch Zeile und Spalte angegeben:

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

Ist der Bereich ein Baum, werden Elemente über einen Pfad aus Zeilen und einem einzelnen Spaltenwert lokalisiert:

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 die „ QVariant “ das gesamte Element an dieser Position. Verwenden Sie die Vorlagenfunktion „ QVariant::fromValue()“, um eine Kopie des Elements abzurufen.

Lesen und Schreiben mit `at()`

Die Tatsache, dass die Funktion ` data()` einen ` QVariant ` zurückgibt, macht sie zwar flexibel, führt jedoch zum Verlust der Typsicherheit. Für Bereiche, in denen alle Elemente denselben Typ haben, 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 an einer Zeile bei Listen, an einem Zeilen-/Spaltenpaar bei Tabellen und an einem Pfad-/Spaltenpaar bei Bäumen. Allerdings gibt ` at()` immer das gesamte Element an der angegebenen Position zurück; es ist nicht möglich, einzelne Rollenwerte eines Elements auszulesen.

Wie von einer C++-Container-API zu erwarten, bieten die const-Überladungen von ` at()` (und die entsprechenden Index- operator[]()) einen unveränderlichen Zugriff auf den Wert, während die veränderbaren Überladungen ein Referenzobjekt zurückgeben, dem ein neuer Wert zugewiesen werden kann. Beachten Sie, dass sich ein QRangeModelAdapter, der auf einem const-Bereich arbeitet, in dieser Hinsicht wie ein const-QRangeModelAdapter verhält. Die veränderbare Überladungen werden aus dem Überladungssatz entfernt, sodass der Compiler immer die `const`-Version auswählt. Der Versuch, eine Funktion aufzurufen, die einen Bereich verändert, 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 zugrunde liegenden Typ konvertiert werden, über eine Funktion ` get()` zum expliziten Zugriff auf den zugrunde liegenden Wert verfügen und eine Funktion ` operator->()`, die direkten Zugriff auf `const`-Memberfunktionen ermöglicht. Um jedoch versehentliche Datenänderungen zu verhindern, die das Benachrichtigungsprotokoll ` QAbstractItemModel ` umgehen würden, verhindern diese Referenzobjekte direkte Änderungen an den Elementen.

Hinweis: Beim Zugriff auf das Referenzobjekt wird immer ein Aufruf an das Modell gesendet, um eine Kopie des Werts abzurufen. Dies kann rechenintensiv sein; für leistungskritische Datenzugriffe sollten Sie eine Kopie speichern.

Zugriff auf Elemente

Wenn der Bereich als Liste dargestellt wird, stehen nur die Überladungen zur Verfügung, die eine Zeile als Argument entgegennehmen.

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 an dieser Zeile zurück, während die `mutable`-Überladung einen Wrapper zurückgibt, der implizit in den Werttyp der Liste konvertiert und umgekehrt.

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 gibt für alle Rollen ` dataChanged()` aus.

Bei Verwendung der „mutable“-Überladungen können Sie mithilfe des überladenen Pfeiloperators auch auf die „const“-Mitglieder des Elementtyps zugreifen.

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

Es ist nicht möglich, auf nicht-const-Mitglieder 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 anschließend 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 löst das Modell für dieses Element und für alle Rollen die Methode ` dataChanged()` aus.

Wird der Bereich als Tabelle dargestellt, können Sie mithilfe der Überladung ` at(row, column)` auf einzelne Elemente über Zeile und Spalte zugreifen. Bei Bäumen ermöglicht diese Überladung den Zugriff auf Elemente der obersten Ebene, während die Überladung ` at(path, column)` den Zugriff auf im Baum verschachtelte Elemente ermöglicht.

Der Zugriff auf ein einzelnes Element in einer Tabelle oder einem Baum entspricht 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 ausschließlich Spalten desselben Datentyps enthält, 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 Baumstrukturen

Bei Tabellen und Bäumen ermöglichen die Überladungen von ` at()` und die Indizierung mit ` operator[]()` ohne den Spaltenparameter den Zugriff auf die gesamte Zeile. Der von den const-Überladungen zurückgegebene Wert ist ein Referenztyp, der Zugriff auf die Zeilendaten gewährt. Enthält diese Zeile Zeiger, so ist dieser Referenztyp eine Ansicht der Zeile, die Zugriff auf Zeiger auf const-Elemente gewährt.

Zugriff auf Tabellenzeilen

Die Überladung ` at(int)` ist weiterhin verfügbar, gibt jedoch die gesamte Tabellenzeile zurück. Dies ermöglicht es, mit allen Werten der Zeile gleichzeitig zu arbeiten.

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

Wie bei den Elementen bietet die „const“-Überladung direkten Zugriff auf den Zeilentyp, während die „mutable“-Überladung einen Wrapper zurückgibt, der als Referenz auf die Zeile dient. Der Wrapper ermöglicht den Zugriff auf „const“-Memberfunktionen mithilfe 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, sendet das Modell das Signal „ dataChanged()“ für alle Elemente in der Zeile und für alle Rollen aus.

Hinweis: Bei der Verwendung eines Zeilentyps mit Laufzeittypen, 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, wobei jeder Eintrag einer Ebene im Baum entspricht. Beachten Sie, dass in den folgenden Codeausschnitten der `Tree` ein Bereich ist, der rohe Zeilenzeiger enthält, und dass der Adapter mit einer rvalue-Referenz dieses Bereichs erstellt wird. Dadurch erhält der ` QRangeModel ` die Eigentumsrechte an den 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 Zeilen der obersten Ebene oder auf Elemente in den Zeilen der obersten Ebene.

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 einer Baumstruktur entspricht dem Zugriff auf Zeilen und Elemente in einer Tabelle. Der Adapter stellt jedoch sicher, dass die Baumstruktur beim Ändern ganzer Zeilen erhalten bleibt.

// 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 untergeordneten Element des ersten Elements der obersten Ebene 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, erhalten Sie durch Dereferenzierung des Iterators 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 Überladungen „const“ und „mutable“ von ` at()` wird bei einem veränderbaren Iterator auf einen Wrapper verwiesen.

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 `const`-Mitglieder des Elementtyps zuzugreifen, und weisen Sie dem Wrapper einen neuen Wert zu, um diesen zu ersetzen.

Ist der Bereich eine Tabelle oder ein Baum, erhalten Sie durch Iteration über das Modell Zugriff auf die Zeilen.

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 konstante als auch der veränderbare Iterator verweisen auf einen Wrapper-Typ für die Zeile. Dadurch wird sichergestellt, dass wir konsistent über jedes Element in der Zeile iterieren können, selbst 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 Durchlaufen einer veränderbaren 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 aus.

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

Durch das Durchlaufen der veränderbaren Zeilen können wir einzelne Elemente ändern.

Beim Durchlaufen eines Baums verfügt der Zeilen-Wrapper über zwei zusätzliche Mitgliedsfunktionen, ` hasChildren()` und `children()`, mit denen wir den gesamten Baum mithilfe von Iteratoren durchlaufen können.

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

Das von `children()` zurückgegebene Objekt ist ein `QRangeModelAdapter`, der auf demselben Modell wie der Aufrufer arbeitet, wobei jedoch bei allen Operationen der Index der Quellzeile als übergeordneter Index verwendet wird.

Siehe auch QRangeModel.

Dokumentation zu Mitgliedstypen

[alias] QRangeModelAdapter::range_type

Dokumentation zu Member-Funktionen

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

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

Erstellt ein „ QRangeModelAdapter “, das auf „ range “ arbeitet. Bei Baumbereichen wird der optionale „ protocol “ für die Baumdurchquerung verwendet.

Einzelheiten zu den Anforderungen an ` Range` sowie dazu, wie die Wertkategorie von ` range ` die Interaktion zwischen Adapter, Modell und Bereich beeinflusst, finden Sie in der Dokumentation zum Konstruktor ` QRangeModel `.

Siehe auch „ QRangeModel “.

template < typename InputIterator, typename Sentinel, typename I > requires if_writable<I> 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> requires if_tree<I> && if_writable<I> auto QRangeModelAdapter::at(QSpan<const int> path)

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

Gibt ein ` mutable wrapper ` zurück, das einen Verweis auf die durch ` path` angegebene Baumzeile enthält.

Um die Baumzeile zu ändern, weisen Sie ihr einen neuen Wert zu. Durch die Zuweisung einer neuen Baumzeile wird der übergeordnete Knoten der neuen Baumzeile zum übergeordneten Knoten der alten Baumzeile gesetzt. Allerdings darf weder die alte noch die neue Baumzeile untergeordnete Zeilen haben. Um auf die Baumzeile zuzugreifen, dereferenzieren Sie den Wrapper mithilfe von ` operator*()` oder verwenden Sie ` operator->() `, um auf die Elemente der Baumzeile zuzugreifen.

Hinweis: Änderungen am Bereich führen zur Ungültigkeit des Wrappers.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn ` Range ` ein Baum ist.

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

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

Gibt ein ` mutable reference ` mit dem in ` Range` gespeicherten Wert zurück.

Hinweis: Änderungen am Bereich machen diese Referenz ungültig. Um die Referenz zu ändern, weisen Sie ihr einen neuen Wert zu. Sofern der in „ Range “ gespeicherte Wert kein Zeiger ist, ist es nicht möglich, auf einzelne Elemente des gespeicherten Werts zuzugreifen.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ eine veränderbare Liste ist.

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

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

Gibt einen „ reference wrapper “ für die Zeile unter „ tableRow “ zurück, wie in „ Range “ gespeichert.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ eine veränderbare Tabelle ist, jedoch kein Baum.

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

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

Gibt einen „ reference wrapper “ für die Zeile unter „ treeRow “ zurück, wie in „ Range “ gespeichert.

Um die Baumzeile zu ändern, weisen Sie ihr einen neuen Wert zu. Durch die Zuweisung einer neuen Baumzeile wird das übergeordnete Element der neuen Baumzeile zum übergeordneten Element der alten Baumzeile gesetzt. Allerdings darf weder die alte noch die neue Baumzeile Kinderzeilen enthalten. Um auf die Baumzeile zuzugreifen, dereferenzieren Sie den Wrapper mithilfe von „ operator*() “ oder verwenden Sie „ operator->() “, um auf die Elemente der Baumzeile zuzugreifen.

Hinweis: Änderungen am Bereich führen zur Ungültigkeit des Wrappers.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ ein Baum ist.

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

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

Gibt eine konstante Referenz auf die durch ` path` angegebene Zeile zurück, wie sie in ` Range` gespeichert ist.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ ein Baum ist.

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

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

Gibt den Wert unter listRow als den in Range gespeicherten Typ zurück.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn Range eine Liste ist.

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

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

Gibt eine konstante Referenz auf die Zeile unter tableRow zurück, wie sie unter Range gespeichert ist.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn Range eine Tabelle oder ein Baum ist.

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

Gibt ein „ mutable reference “ zurück, dessen Wert dem Element entspricht, das durch „ path “ und „ column “ angegeben ist. Handelt es sich bei dem Element um ein Multi-Role-Element, so handelt es sich hierbei um eine Referenz auf das gesamte Element. Wenn die Zeilen in „ Range “ in verschiedenen Spalten unterschiedliche Typen enthalten, ist der Rückgabetyp ein „ QVariant “.

Hinweis: Änderungen am Bereich machen diese Referenz ungültig. Um die Referenz zu ändern, weisen Sie ihr einen neuen Wert zu. Sofern der in „ Range “ gespeicherte Wert kein Zeiger ist, ist es nicht möglich, auf einzelne Elemente des gespeicherten Werts zuzugreifen.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn ` Range ` ein veränderbare Baumstruktur ist.

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

Gibt ein „ mutable reference “ auf den Wert zurück, der als das durch „ tableRow “ und „ column “ angegebene Element gespeichert ist. Handelt es sich bei dem Element um ein Element mit mehreren Rollen, so handelt es sich hierbei um eine Referenz auf das gesamte Element.

Hinweis: Änderungen am Bereich machen diese Referenz ungültig. Um die Referenz zu ändern, weisen Sie ihr einen neuen Wert zu. Sofern der in der ` Range ` gespeicherte Wert kein Zeiger ist, ist es nicht möglich, auf einzelne Elemente des gespeicherten Werts zuzugreifen.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ eine veränderbare Tabelle ist.

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

Gibt eine Kopie des Werts zurück, der als das durch „ path “ und „ column “ angegebene Element gespeichert ist. Handelt es sich bei dem Element um ein Multi-Role-Element, wird eine Kopie des gesamten Elements zurückgegeben. Wenn die Zeilen in „ Range “ in verschiedenen Spalten unterschiedliche Typen speichern, ist der Rückgabetyp ein „ QVariant “.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ ein Baum ist.

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

Gibt eine Kopie des Werts zurück, der als das durch ` tableRow ` und ` column` angegebene Element gespeichert ist. Handelt es sich bei dem Element um ein Multi-Role-Element, wird eine Kopie des gesamten Elements zurückgegeben. Wenn die Zeilen in der ` Range ` in verschiedenen Spalten unterschiedliche Typen enthalten, ist der Rückgabetyp ein ` QVariant`.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ eine Tabelle oder ein Baum ist.

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

Gibt ein ` mutable reference ` auf den Wert zurück, der als Element unter ` index` gespeichert ist. Handelt es sich bei dem Element um ein Multi-Role-Element, so ist dies eine Referenz auf das gesamte Element. Wenn die Zeilen in der ` Range ` unterschiedliche Typen in verschiedenen Spalten speichern, ist der Rückgabetyp ein ` QVariant`.

Hinweis: Änderungen am Bereich machen diese Referenz ungültig. Um die Referenz zu ändern, weisen Sie ihr einen neuen Wert zu. Sofern der unter Range gespeicherte Wert kein Zeiger ist, ist es nicht möglich, auf einzelne Elemente des gespeicherten Werts zuzugreifen.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ nicht schreibgeschützt ist.

Dies ist eine überladene Funktion.

Diese Funktion wurde in Qt 6.12 eingeführt.

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

Gibt eine Kopie des Werts zurück, der als Element unter index gespeichert ist. Handelt es sich bei dem Element um ein Multi-Role-Element, wird eine Kopie des gesamten Elements zurückgegeben. Wenn die Zeilen in der Range in verschiedenen Spalten unterschiedliche Typen enthalten, ist der Rückgabetyp ein QVariant.

Dies ist eine überladene Funktion.

Diese Funktion wurde in Qt 6.12 eingeführt.

int QRangeModelAdapter::columnCount() const

Gibt die Anzahl der Spalten zurück. Diese beträgt eins, wenn das „ Range “ eine Liste darstellt; andernfalls entspricht sie der Anzahl der Elemente in jeder Zeile.

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

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

Gibt ein ` QVariant ` zurück, das die unter der angegebenen ` role ` gespeicherten Daten für das Element unter ` listRow` enthält, oder ein ungültiges ` QVariant `, falls kein Element vorhanden ist. Wenn ` role ` nicht angegeben ist, wird ein ` QVariant ` zurückgegeben, das das gesamte Element enthält.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ eine Liste ist.

Siehe auch setData() und at().

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

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

Gibt ein ` QVariant ` zurück, das die unter der angegebenen ` role ` gespeicherten Daten für das Element enthält, auf das sich ` path ` und ` column` beziehen, oder ein ungültiges ` QVariant `, wenn für diese Position oder Rolle keine Daten gespeichert sind. Wenn ` role ` nicht angegeben ist, wird ein ` QVariant ` zurückgegeben, das das gesamte Element enthält.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ ein Baum ist.

Siehe auch „ setData()“ und „ at()“.

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

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

Gibt ein ` QVariant ` zurück, das die unter dem angegebenen ` role ` gespeicherten Daten für das Element enthält, auf das sich ` tableRow ` und ` column` beziehen, oder ein ungültiges ` QVariant `, falls für diese Position oder Rolle keine Daten gespeichert sind. Wenn ` role ` nicht angegeben ist, wird ein ` QVariant ` zurückgegeben, das das gesamte Element enthält.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ eine Tabelle oder ein Baum ist.

Siehe auch „ setData()“ und „ at()“.

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

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

Gibt ein ` QVariant ` zurück, das die unter der angegebenen ` role ` gespeicherten Daten für das Element unter ` index` enthält, oder ein ungültiges ` QVariant `, wenn für diese Position oder Rolle keine Daten gespeichert sind. Wenn ` role ` nicht angegeben ist, wird ein ` QVariant ` zurückgegeben, das das gesamte Element enthält.

Diese Funktionen wurden in Qt 6.12 eingeführt.

Siehe auch „ setData()“ und „ at()“.

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

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

Gibt zurück, ob unter „ row “ Zeilen vorhanden sind.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ ein Baum ist.

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

Gibt zurück, ob unter „ index “ Zeilen vorhanden sind.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn Range ein Baum ist.

Dies ist eine überladene Funktion.

Diese Funktion wurde in Qt 6.12 eingeführt.

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

Gibt die „ QModelIndex “ für „ listRow “ zurück.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn ` Range ` eine eindimensionale Liste ist.

Dies ist eine überladene Funktion.

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

Gibt den „ QModelIndex “ für das Element unter „ column “ für die Zeile in der Baumstruktur zurück, die durch „ path “ angegeben ist.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ ein Baum ist.

Dies ist eine überladene Funktion.

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

Gibt die „ QModelIndex “ für das Element unter tableRow und column zurück.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ eine Tabelle oder ein Baum ist.

Dies ist eine überladene Funktion.

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

Fügt in allen Zeilen vor der durch ` before ` angegebenen Spalte eine einzelne leere Spalte ein und gibt zurück, ob der Einfügevorgang erfolgreich war. Wenn ` before ` denselben Wert wie ` columnCount()` hat, wird die Spalte an jede Zeile angehängt.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn Range Zeilen enthält, die das Einfügen von Elementen unterstützen.

Dies ist eine überladene Funktion.

Siehe auch removeColumn(), insertColumns() und insertRow().

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

Fügt in allen Zeilen vor der durch ` before ` angegebenen Spalte eine einzelne Spalte ein, die aus ` data ` gebildet wird, und gibt zurück, ob das Einfügen erfolgreich war. Wenn ` before ` denselben Wert wie ` columnCount()` hat, wird die Spalte an jede Zeile angehängt.

Ist data ein einzelner Wert, wird der neue Eintrag in allen Zeilen aus diesem einzelnen Wert gebildet.

Ist ` data ` ein Container, werden die Elemente dieses Containers nacheinander verwendet, um die Spalte für jede nachfolgende Zeile zu erstellen. Enthält ` data ` weniger Elemente als es Zeilen gibt, springt die Funktion zum ersten Element zurück und beginnt dort erneut.

Einschränkungen

Nimmt nur dann an der Überlastauflösung teil, wenn Range Zeilen enthält, die das Einfügen von Elementen unterstützen, und die Elemente aus den Einträgen in data gebildet werden können.

Dies ist eine überladene Funktion.

Siehe auch ` removeColumn()`, ` insertColumns()` und ` insertRow()`.

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

Fügt Spalten, die aus den Elementen in data gebildet wurden, vor der durch before angegebenen Spalte in alle Zeilen ein und gibt zurück, ob der Einfügevorgang erfolgreich war. Wenn before denselben Wert wie columnCount() hat, wird die Spalte an jede Zeile angehängt.

Sind die Elemente in ` data ` Werte, werden die neuen Einträge in allen Zeilen aus diesen Werten gebildet.

Sind die Elemente in ` data ` Container, werden die Einträge im äußeren Container nacheinander verwendet, um die neuen Einträge für jede nachfolgende Zeile zu erstellen. Enthält ` data ` weniger Elemente als es Zeilen gibt, springt die Funktion zum ersten Element zurück und beginnt dort erneut.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ Zeilen enthält, die das Einfügen von Elementen unterstützen, und die Elemente aus den Einträgen in „ data “ erstellt werden können.

Siehe auch „ removeColumns()“, „ insertColumn()“ und „ insertRows()“.

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

Fügt eine einzelne leere Zeile vor der Zeile ein, deren Pfad durch ` before` angegeben ist, und gibt zurück, ob das Einfügen erfolgreich war. Wenn ` before ` denselben Wert wie ` rowCount()` hat, wird die neue Zeile angehängt.

Einschränkungen

Nimmt nur dann an der Überladungsauflö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> requires if_canInsertRows<I> 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 denselben Wert wie rowCount() hat, wird die neue Zeile angehängt.

Einschränkungen

Nimmt nur dann 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> requires if_canInsertRows<I> && if_compatible_row<D> && if_tree<I> bool QRangeModelAdapter::insertRow(QSpan<const int> before, D &&data)

Fügt eine einzelne Zeile, die aus data erstellt wurde, 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 angehängt.

Einschränkungen

Nimmt nur dann 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> requires if_canInsertRows<I> && if_compatible_row<D> bool QRangeModelAdapter::insertRow(int before, D &&data)

Fügt eine einzelne Zeile, die aus data gebildet wurde, 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 angehängt.

Einschränkungen

Nimmt nur dann 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 I> requires if_canInsertRows<I> && if_tree<I> bool QRangeModelAdapter::insertRow(int before, const QModelIndex &parent)

Fügt eine einzelne leere Zeile vor der Zeile unter der Adresse „ before “ in der angegebenen Tabelle „ parent “ ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn „ before “ denselben Wert wie „ rowCount()“ hat, wird die neue Zeile angehängt.

Einschränkungen

Nimmt nur dann an der Überladungsauflö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 D, typename I> requires if_canInsertRows<I> && if_compatible_row<D> && if_tree<I> bool QRangeModelAdapter::insertRow(int before, const QModelIndex &parent, D &&data)

Fügt eine einzelne Zeile, die anhand von ` data ` erstellt wurde, vor der Zeile unter ` before ` in der angegebenen ` parent` ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn ` before ` denselben Wert wie ` rowCount()` hat, wird die neue Zeile angehängt.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn Range ein Baum ist, der das Einfügen von Elementen unterstützt, und wenn aus data eine Zeile konstruiert werden kann.

Dies ist eine überladene Funktion.

Siehe auch insertRows(), removeRow() und insertColumn().

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

Fügt Zeilen ein, die aus den Elementen in ` data ` gebildet wurden, vor der Zeile unter ` before`, und gibt zurück, ob das Einfügen erfolgreich war. Wenn ` before ` denselben Wert wie ` rowCount()` hat, wird die neue Zeile angehängt.

Einschränkungen

Nimmt nur dann an der Überlastauflö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> requires if_canInsertRows<I> && if_compatible_row_range<C> bool QRangeModelAdapter::insertRows(int before, C &&data)

Fügt Zeilen, die aus den Elementen in „ data “ gebildet wurden, vor der Zeile unter „ before “ ein und gibt zurück, ob der Einfügevorgang erfolgreich war. Wenn „ before “ denselben Wert wie „ rowCount()“ hat, wird die neue Zeile angehängt.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn Range das Einfügen von Elementen unterstützt und wenn aus den Elementen in data Zeilen konstruiert werden können.

Dies ist eine überladene Funktion.

Siehe auch insertRow(), removeRows() und insertColumns().

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

Fügt Zeilen, die aus den Elementen in data gebildet wurden, vor der Zeile unter before in die angegebene parent ein und gibt zurück, ob das Einfügen erfolgreich war. Wenn before denselben Wert wie rowCount() hat, wird die neue Zeile angehängt.

Einschränkungen

Nimmt nur dann 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().

Model *QRangeModelAdapter::model() const

Gibt die von diesem Adapter erstellte „ QRangeModel “-Instanz zurück.

Siehe auch „ range()“ und „ at()“.

template <typename F> requires if_canMoveItems<F> 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 dann an der Überladungsauflösung teil, wenn Range Zeilen enthält, die das Verschieben von Elementen unterstützen.

Siehe auch insertColumn(), removeColumn(), moveColumns() und moveRow().

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

Verschiebt die Spalten „ count “ ab der Adresse from an die Position to und gibt zurück, ob die Spalten erfolgreich verschoben wurden.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ Zeilen enthält, die das Verschieben von Elementen unterstützen.

Siehe auch „ insertColumns()“, „ removeColumns()“, „ moveColumn()“ und „ moveRows()“.

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

Verschiebt den Baumzweig unter source an die Position unter destination und gibt zurück, ob der Zweig erfolgreich verschoben wurde.

Einschränkungen

Nimmt nur dann an der Überladungsauflö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> requires if_canMoveItems<F> bool QRangeModelAdapter::moveRow(int source, int destination)

Verschiebt die Zeile unter source an die Position unter destination und gibt zurück, ob die Zeile erfolgreich verschoben wurde.

Einschränkungen

Nimmt nur dann an der Überladungsauflö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> requires if_canMoveItems<F> && if_tree<I> bool QRangeModelAdapter::moveRow(const QModelIndex &sourceParent, int sourceRow, const QModelIndex &destinationParent, int destinationChild)

Verschiebt den Branch unter sourceRow von der sourceParent an die Position unter destinationChild in der destinationParent und gibt zurück, ob der Branch erfolgreich verschoben wurde.

Einschränkungen

Nimmt nur dann an der Überladungsauflö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 I, typename F> requires if_canMoveItems<F> && if_tree<I> bool QRangeModelAdapter::moveRows(QSpan<const int> source, int count, QSpan<const int> destination)

Verschiebt die Zweige des Baums „ count “ beginnend bei source an die Position destination und gibt zurück, ob die Zeilen erfolgreich verschoben wurden.

Einschränkungen

Nimmt nur dann an der Überladungsauflö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> requires if_canMoveItems<F> bool QRangeModelAdapter::moveRows(int source, int count, int destination)

Verschiebt die Zeilen „ count “ beginnend bei source an die Position destination und gibt zurück, ob die Zeilen erfolgreich verschoben wurden.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ das Verschieben von Elementen unterstützt.

Dies ist eine überladene Funktion.

Siehe auch insertRows(), removeRows() und moveColumns().

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

Verschiebt die Zweige „ count “, beginnend mit „ sourceRow “, von der „ sourceParent “ an die Position „ destinationChild “ in der „ destinationParent “ und gibt zurück, ob der Zweig erfolgreich verschoben wurde.

Einschränkungen

Nimmt nur dann an der Überladungsauflö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()“.

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

Gibt eine konstante Referenz auf den Bereich zurück, auf den der Modelladapter angewendet wird.

Siehe auch assign(), at() und model().

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

Entfernt das angegebene „ column “ aus jeder Zeile und gibt zurück, ob das Entfernen erfolgreich war.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ Zeilen enthält, die das Entfernen von Elementen unterstützen.

Siehe auch „ insertColumn()“, „ removeColumns()“ und „ removeRow()“.

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

Entfernt aus jeder Zeile die Spalten „ count “, die mit dem angegebenen „ column “ beginnen, und gibt zurück, ob das Entfernen erfolgreich war.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ Zeilen enthält, die das Entfernen von Elementen unterstützen.

Siehe auch „ insertColumns()“, „ removeColumn()“ und „ removeRow()“.

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

Entfernt die Zeile an der angegebenen Position path einschließlich aller untergeordneten Elemente dieser Zeile und gibt zurück, ob das Entfernen erfolgreich war.

Einschränkungen

Nimmt nur dann 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> requires if_canRemoveRows<I> bool QRangeModelAdapter::removeRow(int row)

Entfernt das angegebene „ row “ und gibt zurück, ob das Entfernen erfolgreich war.

Einschränkungen

Nimmt nur dann 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> requires if_canRemoveRows<I> && if_tree<I> bool QRangeModelAdapter::removeRow(int row, const QModelIndex &parent)

Entfernt die angegebene „ row “ aus dem „ parent “, einschließlich aller untergeordneten Elemente dieser Zeile, und gibt zurück, ob das Entfernen erfolgreich war.

Einschränkungen

Nimmt nur dann 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> requires if_canRemoveRows<I> && if_tree<I> bool QRangeModelAdapter::removeRows(QSpan<const int> path, int count)

Entfernt die Zeilen „ count “, beginnend mit der durch „ path “ angegebenen Zeile, und gibt zurück, ob das Entfernen erfolgreich war.

Einschränkungen

Nimmt nur dann an der Überladungsauflö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> requires if_canRemoveRows<I> bool QRangeModelAdapter::removeRows(int row, int count)

Entfernt die Zeilen „ count “, beginnend mit „ row “, und gibt zurück, ob das Entfernen erfolgreich war.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn Range das Entfernen von Elementen unterstützt.

Dies ist eine überladene Funktion.

Siehe auch removeRow(), removeColumns() und insertRows().

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

Entfernt „ count “-Zeilen aus der „ parent “, beginnend bei der angegebenen „ row “, und gibt zurück, ob das Entfernen erfolgreich war.

Einschränkungen

Nimmt nur dann an der Überladungsauflö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()`.

int QRangeModelAdapter::rowCount() const

Gibt die Anzahl der Zeilen zurück. Wenn das Argument „ Range “ eine Liste oder Tabelle darstellt, entspricht dies der Anzahl der Zeilen. Bei Bäumen entspricht dies der Anzahl der Zeilen auf der obersten Ebene.

Dies ist eine überladene Funktion.

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

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

Gibt die Anzahl der Zeilen unter row zurück.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ ein Baum ist.

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

Gibt die Anzahl der Zeilen unter index zurück.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn ` Range ` ein Baum ist.

Dies ist eine überladene Funktion.

Diese Funktion wurde in Qt 6.12 eingeführt.

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

Setzt den Wert „ role “ für das Element unter „ listRow “ auf „ value “.

Gibt bei Erfolg „ true “ zurück; andernfalls „ false “.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ eine veränderbare Liste ist.

Siehe auch data() und at().

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

Setzt die Daten „ 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 dann an der Überladungsauflösung teil, wenn ` Range ` ein veränderbare Baum ist.

Siehe auch ` data()` und ` at()`.

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

Setzt die „ role “-Daten für das Element, auf das „ tableRow “ und „ column “ verweisen, auf „ value “.

Gibt bei Erfolg „ true “ zurück; andernfalls „ false “.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn ` Range ` veränderbar ist und keine Liste darstellt.

Siehe auch „ data()“ und „ at()“.

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

Setzt die „ role “-Daten für das Element unter index auf value.

Gibt bei Erfolg „ true “ zurück; andernfalls „ false “.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ nicht schreibgeschützt ist.

Dies ist eine überladene Funktion.

Diese Funktion wurde in Qt 6.12 eingeführt.

Siehe auch data() und at().

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

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

Ersetzt den Inhalt des Modells durch die Zeilen in „ newRange “, gegebenenfalls unter Verwendung der Move-Semantik.

Diese Funktion bewirkt, dass „ model()“ die Signale „ modelAboutToBeReset()“ und „ modelReset()“ ausgibt.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ veränderbar ist und „ newRange “ einen Typ hat, der „ Range “ zugewiesen werden kann, jedoch nicht „ QRangeModelAdapter “.

Siehe auch „ range()“, „ at()“, „ model()“ und „ assign()“.

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

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

Ersetzt den Inhalt des Modells durch die Zeilen in newRange.

Einschränkungen

Nimmt nur dann an der Überladungsauflösung teil, wenn „ Range “ veränderbar ist und „ newRange “ der Variablen „ Range “ zugewiesen werden kann.

Siehe auch ` range()`, ` at` und ` model()`.

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 dieselbe Instanz von „ model “ 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 dieselbe „ 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.