QRangeModelAdapter Class
QRangeModelAdapter proporciona un acceso compatible con « QAbstractItemModel » a cualquier rango de C++. Más información...
| Encabezado: | #include <QRangeModelAdapter> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Desde: | Qt 6.11 |
| Estado: | Versión preliminar |
Esta clase se encuentra en fase de vista previa tecnológica y está sujeta a cambios.
Comparaciones de QRangeModelAdapter
| Categoría | Tipos comparables |
|---|---|
| igualdad | QRangeModelAdapter |
| igualdad | Rango. |
Tipos públicos
(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 |
Funciones públicas
| 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 |
Tipos privados
Elementos no miembros relacionados
| 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) |
Descripción detallada
QRangeModelAdapter proporciona una API de C++ segura en cuanto a tipos y que tiene en cuenta la estructura, en torno a un rango de C++ y un ` QRangeModel`. Las modificaciones realizadas en el rango de C++ mediante el adaptador informarán a los clientes del ` QRangeModel ` sobre los cambios. Esto garantiza que se actualicen las vistas de los elementos, se limpien las cachés y se invaliden y adapten correctamente los índices de elementos persistentes.
Construcción y propiedad del modelo
QRangeModelAdapter debe construirse a partir de un rango de C++. Al igual que con QRangeModel, el rango puede proporcionarse mediante una referencia lvalue o rvalue, como un envoltorio de referencia y como un puntero sin formato o inteligente.
std::vector<int> data = {1, 2, 3, 4, 5};
QRangeModelAdapter adapter(&data);El compilador deduce el tipo exacto que se construye a partir de los argumentos del constructor, y las diferencias entre las categorías de valores pueden dar lugar a un comportamiento distinto. Por lo tanto, no debes especificar explícitamente los parámetros de la plantilla. Sin embargo, C++ no permite la deducción de argumentos de plantillas de clase para miembros de datos de clase no estáticos. Para convertir QRangeModelAdapter en un miembro de datos de una clase, utiliza el siguiente patrón:
class Backend
{
using Adapter = decltype(QRangeModelAdapter(std::vector<Book>{}));
Adapter adapter = Adapter(std::vector<Book>{});Esto crea un QRangeModelAdapter que opera sobre un vector sin nombre (es decir, una referencia rvalue) de Books. Para que el adaptador opere sobre un envoltorio de referencia a una lista de Books, utiliza esto en su lugar:
QList<Book> books = { /* ... */ };
using Adapter = decltype(QRangeModelAdapter(std::ref(books)));
Adapter adapter = Adapter(std::ref(books));
};Al construir el adaptador a partir de un rango, se construye implícitamente una instancia de ` QRangeModel ` a partir de ese mismo rango. Utiliza ` model()` para obtenerla y pásala a las vistas de elementos ` Qt Widgets ` o ` Qt Quick ` como de costumbre.
QListView listView;
listView.setModel(adapter.model());El adaptador es propietario del modelo. QRangeModelAdapter es un tipo de valor, por lo que se puede copiar y mover. Todas las copias comparten el mismo ` QRangeModel`, que se destruirá cuando se destruya la última copia del adaptador.
Si el adaptador se ha creado a partir de una referencia lvalue o rvalue, tanto el adaptador como el modelo operarán sobre una copia del objeto de rango original. De lo contrario, las modificaciones realizadas a través del adaptador o del modelo se escribirán en el objeto de rango original. Para acceder al rango actualizado, utiliza 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();Para sustituir todos los datos del rango por datos de otro rango (compatible), utilice la función ` assign()` o el operador de asignación.
// reset to the original
adapter = books;
// or
adapter.assign(books);Acceso a los datos de los elementos
La API de QRangeModelAdapter proporciona acceso de lectura y escritura seguro en cuanto al tipo al rango sobre el que opera el modelo. La API del adaptador se basa en la API típica para contenedores y rangos de C++, incluidos los iteradores. Para acceder a filas y elementos individuales, utiliza at(), el subíndice correspondiente operator[] o data(). Las sobrecargas disponibles de estas funciones dependen del rango para el que se haya construido el adaptador.
Lectura de datos de elementos como QVariant
La función data() siempre devuelve un QVariant con el valor almacenado en la posición y el rol especificados. En una lista, se puede acceder a un elemento mediante un único valor entero que especifique la fila:
QVariant listItem = listAdapter.data(row);Si el rango es una tabla, los elementos se especifican mediante fila y columna:
QVariant tableItem = tableAdapter.data(row, column);Si el rango es un árbol, los elementos se localizan mediante una ruta de filas y un único valor de columna:
QVariant treeItem = treeAdapter.data({path, to, branch}, column);El uso de un único número entero como fila permite acceder a los elementos de nivel superior del árbol.
QRangeModelAdapter listOfBooks(QList<Book>{
// ~~~
});
QString bookTitle = listOfBooks.data(0, Book::TitleRole).toString();
Book multiRoleItem = listOfBooks.data(0).value<Book>();Si no se especifica ningún rol, el objeto « QVariant » contendrá el elemento completo en esa posición. Utiliza la función de plantilla « QVariant::fromValue()» para obtener una copia del elemento.
Lectura y escritura mediante at()
El hecho de que la función ` data()` devuelva un ` QVariant ` la hace flexible, pero elimina la seguridad de tipos. Para rangos en los que todos los elementos son del mismo tipo, la función ` at()` ofrece una alternativa segura en cuanto a tipos que es más compatible con los contenedores habituales de C++. Al igual que con ` data()`, existen sobrecargas de ` at()` para acceder a un elemento en una fila en el caso de las listas, en un par de fila y columna en el caso de las tablas, y en un par de ruta y columna en el caso de los árboles. Sin embargo, ` at()` siempre devuelve el elemento completo en la posición especificada; no es posible leer valores de roles individuales de un elemento.
Como cabe esperar de una API de contenedores de C++, las sobrecargas const de at() (y el subíndice correspondiente operator[]()) proporcionan acceso inmutable al valor, mientras que las sobrecargas mutables devuelven un objeto de referencia al que se le puede asignar un nuevo valor. Ten en cuenta que un `QRangeModelAdapter` que opera sobre un rango `const` se comporta, a ese respecto, como un `QRangeModelAdapter` `const`. Las sobrecargas mutables se eliminan del conjunto de sobrecargas, por lo que el compilador siempre seleccionará la versión const. Intentar llamar a una función que modifique un rango dará lugar a un error de compilación, incluso si el propio adaptador es mutable:
const QStringList strings = {"On", "Off"};
QRangeModelAdapter adapter(strings);
adapter.at(0) = "Undecided"; // compile error: return value of 'at' is const
adapter.insertRow(0); // compiler error: requirements not satisfiedLos objetos de referencia devueltos son envoltorios que se convierten implícitamente al tipo subyacente, disponen de una función ` get()` para acceder explícitamente al valor subyacente y de una función ` operator->()` que proporciona acceso directo a las funciones miembro `const`. Sin embargo, para evitar cambios accidentales en los datos que eludirían el protocolo de notificación ` QAbstractItemModel `, dichos objetos de referencia impiden la modificación directa de los elementos.
Nota: Al acceder al objeto de referencia, siempre se realiza una llamada al modelo para obtener una copia del valor. Esto puede resultar costoso; para accesos a datos en los que el rendimiento sea crítico, almacena una copia.
Acceso a los elementos
Si el rango se representa como una lista, solo estarán disponibles las sobrecargas que aceptan una fila.
QRangeModelAdapter list(std::vector<int>{1, 2, 3, 4, 5});
listView.setModel(list.model());
int firstValue = list.at(0); // == 1
list.at(0) = -1;
list.at(1) = list.at(4);La sobrecarga `const` devuelve el elemento de esa fila, mientras que la sobrecarga `mutable` devuelve un envoltorio que se convierte implícitamente al tipo de valor de la lista y viceversa.
QRangeModelAdapter books(QList<Book>{
// ~~~
});
Book firstBook = books.at(0);
Book newBook = {};
books.at(0) = newBook; // dataChanged() emittedAsigna un valor al contenedor para modificar los datos de la lista. El modelo emitirá ` dataChanged()` para todos los roles.
Al utilizar las sobrecargas mutables, también puedes acceder a los miembros «const» del tipo del elemento mediante el operador de flecha sobrecargado.
QString title = books.at(0)->title();No es posible acceder a los miembros no const del elemento. Dichas modificaciones eludirían el adaptador, que no podría notificar al modelo los cambios. Para modificar el valor almacenado en el modelo, haz una copia, modifica las propiedades de la copia y, a continuación, vuelve a escribir esa copia.
// 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() emittedEsto hará que el modelo emita un ` dataChanged()` para este elemento y para todos los roles.
Si el rango se representa como una tabla, puedes acceder a un elemento concreto por fila y columna, utilizando la sobrecarga ` at(row, column)`. En el caso de los árboles, esa sobrecarga permite acceder a los elementos de nivel superior, mientras que la sobrecarga ` at(path, column)` permite acceder a los elementos anidados dentro del árbol.
Acceder a un elemento concreto de una tabla o un árbol equivale a acceder a un elemento de una lista.
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.0Si el rango no almacena todas las columnas con el mismo tipo de datos, entonces at(row,column) devuelve un (envoltorio de referencia con un) QVariant que contiene el elemento.
QRangeModelAdapter table(std::vector<std::tuple<int, QString>>{
// ~~~
});
int number = table.at(0, 0)->toInt();
QString text = table.at(0, 1)->toString();Acceso a filas en tablas y árboles
En el caso de las tablas y los árboles, las sobrecargas de ` at()` y la subíndice ` operator[]()` sin el parámetro de columna proporcionan acceso a toda la fila. El valor devuelto por las sobrecargas const será un tipo de referencia que da acceso a los datos de la fila. Si esa fila contiene punteros, dicho tipo de referencia será una vista de la fila, que dará acceso a punteros a elementos const.
Acceso a las filas de una tabla
La sobrecarga ` at(int)` sigue estando disponible, pero devuelve la fila completa de la tabla. Esto permite trabajar con todos los valores de la fila a la vez.
const auto &constTable = table;
const std::vector<double> &topRow = constTable.at(0);Al igual que con los elementos, la sobrecarga const proporciona acceso directo al tipo de fila, mientras que la sobrecarga mutable devuelve un envoltorio que actúa como referencia a la fila. El envoltorio permite acceder a las funciones miembro const mediante el operador de flecha sobrecargado. Para modificar los valores, hay que volver a escribir un tipo de fila modificado.
auto lastRow = table.at(table.rowCount() - 1);
lastRow = { 6.5, 7.5, 8.0, 9.0, 10 }; // emits dataChanged() for entire rowAl asignar un nuevo valor a la fila, el modelo emite la señal « dataChanged()» para todos los elementos de la fila y para todos los roles.
Nota: Al utilizar un tipo de fila con tamaños en tiempo de ejecución, como un ` std::vector ` o un ` QList`, asegúrate de que la nueva fila tenga el tamaño correcto.
Acceso a filas de árbol
Las filas de los árboles se especifican mediante una secuencia de números enteros, una entrada por cada nivel del árbol. Ten en cuenta que, en los siguientes fragmentos de código, el `Tree` es un rango que contiene punteros de fila sin procesar, y que el adaptador se crea con una referencia de valor de ese rango. Esto otorga al ` QRangeModel ` la propiedad sobre los datos de la fila.
QRangeModelAdapter tree = QRangeModelAdapter(Tree{
new TreeRow{"Germany", 357002, Tree{
new TreeRow("Bavaria", 70550)
},
},
new TreeRow{"France", 632702},
});
treeView.setModel(tree.model());
auto germanyData = tree.at(0);
auto bavariaData = tree.at({0, 0});La sobrecarga de ` at()` que toma un único valor de fila proporciona acceso a las filas de nivel superior o a los elementos de dichas filas.
auto germanyName = tree.at(0, 0);
auto bavariaSize = tree.at({0, 0}, 1);El patrón básico para acceder a las filas y a los elementos de un árbol es idéntico al utilizado para acceder a las filas y a los elementos de una tabla. Sin embargo, el adaptador se asegurará de que se mantenga la estructura del árbol al modificar filas completas.
// deletes the old row - tree was moved in
tree.at({0, 0}) = new TreeRow{"Berlin", 892};En este ejemplo, se crea un nuevo objeto de fila y se le asigna al primer elemento secundario del primer elemento de nivel superior.
API del iterador
Utiliza begin() y end() para obtener iteradores sobre las filas del modelo, o bien utiliza ranged-for. Si el rango es una lista de elementos, al desreferenciar el iterador se accederá a los datos de los elementos.
for (const auto &book: std::as_const(books)) {
qDebug() << "The book" << book.title()
<< "escrito por" << book.author()
<< "tiene" << book.rating() << "estrellas";
}Al igual que con las sobrecargas const y mutable de at(), un iterador mutable se desreferenciará a un contenedor.
for (auto libro : libros) {
qDebug() << "The book" << book->title()
<< «escrito por» << libro->autor()
<< «tiene» << libro->puntuación() << «estrellas»;
Libro copia = libro;
copia.setPuntuación(copia.puntuación() + 1);
libro = copia;
}Utiliza el operador de flecha sobrecargado para acceder a los miembros const del tipo item y asigna el valor al envoltorio para sustituirlo.
Si el rango es una tabla o un árbol, al iterar sobre el modelo se podrá acceder a las filas.
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;
}Tanto el iterador «const» como el «mutable» se desreferenciarán a un tipo contenedor de la fila. Esto garantiza que podamos iterar de forma coherente sobre cada elemento de la fila, incluso si el tipo de fila subyacente no es un rango (por ejemplo, podría ser una tupla o un gadget).
for (const auto &row: std::as_const(table)) {
for (const auto &item: row) {
qDebug() << item; // item is a QVariant
}
}Al iterar sobre una tabla mutable, podemos sobrescribir toda la fila.
for (auto fila : tabla) {
qDebug() << "Number is" << row->first << "and string is" << row->second;
row = std::make_pair(42, u"forty-two"_s);
}El modelo emite la señal dataChanged() para todos los elementos de todas las filas y para todos los roles.
for (auto row : table) {
for (auto item : row) {
item = 42;
}
}Iterar sobre las filas mutables nos permite modificar elementos individuales.
Al iterar sobre un árbol, el envoltorio de fila dispone de dos funciones miembro adicionales, hasChildren() y children(), que nos permiten recorrer todo el árbol utilizando iteradores.
for (auto row : tree) {
if (row.hasChildren()) {
for (auto child : row.children()) {
// ~~~
}
}
}El objeto devuelto por children() es un QRangeModelAdapter que opera sobre el mismo modelo que el objeto llamado, pero todas las operaciones utilizarán el índice de la fila de origen como índice padre.
Véase también QRangeModel.
Documentación sobre funciones de miembro
[implicit] QRangeModelAdapter::QRangeModelAdapter(Range &&range)
[implicit] QRangeModelAdapter::QRangeModelAdapter(Range &&range, Protocol &&protocol)
Crea un objeto ` QRangeModelAdapter ` que opera sobre un ` range`. En el caso de rangos de árbol, se utilizará el parámetro opcional ` protocol ` para el recorrido del árbol.
Consulte la documentación del constructor de ` QRangeModel ` para obtener más detalles sobre los requisitos de ` Range` y sobre cómo la categoría de valor de ` range ` modifica la interacción entre el adaptador, el modelo y el rango.
Véase también QRangeModel.
template < typename InputIterator, typename Sentinel, typename I > requires if_writable<I> void QRangeModelAdapter::assign(InputIterator first, Sentinel last)
Sustituye el contenido de los modelos por las filas del rango [first, last).
Véanse también range(), at y 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)
Devuelve un objeto ` mutable wrapper ` que contiene una referencia a la fila del árbol especificada por ` path`.
Para modificar la fila del árbol, asígnale un nuevo valor. Al asignar una nueva fila del árbol, se establecerá el padre de la nueva fila como padre de la antigua. Sin embargo, ni la antigua ni la nueva fila deben tener filas hijas. Para acceder a la fila del árbol, desreferencia el envoltorio utilizando ` operator*()`, o utiliza ` operator->() ` para acceder a los miembros de la fila del árbol.
Nota: Las modificaciones en el rango invalidarán el envoltorio.
Restricciones
Participa en la resolución de sobrecargas solo si Range es un árbol.
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)
Devuelve un ` mutable reference ` con el valor almacenado en ` Range`.
Nota: Las modificaciones en el rango invalidarán dicha referencia. Para modificar la referencia, asígnale un nuevo valor. A menos que el valor almacenado en ` Range ` sea un puntero, no es posible acceder a los miembros individuales del valor almacenado.
Restricciones
Participa en la resolución de sobrecargas solo si ` Range ` es una lista mutable.
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)
Devuelve un objeto ` reference wrapper ` correspondiente a la fila en ` tableRow`, tal y como está almacenada en ` Range`.
Restricciones
Participa en la resolución de sobrecargas únicamente si ` Range ` es una tabla mutable, pero no un árbol.
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)
Devuelve un ` reference wrapper ` correspondiente a la fila en ` treeRow`, tal y como está almacenada en ` Range`.
Para modificar la fila del árbol, asígnale un nuevo valor. Al asignar una nueva fila del árbol, se establecerá que el padre de la nueva fila sea el padre de la antigua fila del árbol. Sin embargo, ni la antigua ni la nueva fila del árbol deben tener filas secundarias. Para acceder a la fila del árbol, desreferencia el contenedor utilizando operator*(), o utiliza operator->() para acceder a los miembros de la fila del árbol.
Nota: Las modificaciones en el rango invalidarán el envoltorio.
Restricciones
Participa en la resolución de sobrecargas únicamente si Range es un árbol.
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
Devuelve una referencia constante a la fila especificada por ` path`, tal y como está almacenada en ` Range`.
Restricciones
Participa en la resolución de sobrecargas solo si Range es un árbol.
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
Devuelve el valor de « listRow » como el tipo almacenado en « Range ».
Restricciones
Participa en la resolución de sobrecarga solo si Range es una lista.
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
Devuelve una referencia constante a la fila situada en tableRow, tal y como está almacenada en Range.
Restricciones
Participa en la resolución de sobrecargas solo si Range es una tabla o un árbol.
template <typename I> requires if_tree<I> && if_writable<I> auto QRangeModelAdapter::at(QSpan<const int> path, int column)
Devuelve un ` mutable reference ` con el valor almacenado en el elemento especificado por ` path ` y ` column`. Si el elemento es de roles múltiples, se tratará de una referencia al elemento completo. Si las filas de ` Range ` almacenan tipos diferentes en columnas distintas, el tipo de retorno será un ` QVariant`.
Nota: Las modificaciones en el rango invalidarán dicha referencia. Para modificar la referencia, asígnale un nuevo valor. A menos que el valor almacenado en Range sea un puntero, no es posible acceder a los miembros individuales del valor almacenado.
Restricciones
Participa en la resolución de sobrecargas solo si Range es un árbol mutable.
template <typename I> requires unless_list<I> && if_writable<I> auto QRangeModelAdapter::at(int tableRow, int column)
Devuelve un objeto ` mutable reference ` con el valor almacenado como el elemento especificado por ` tableRow ` y ` column`. Si el elemento es un elemento con múltiples roles, esta será una referencia al elemento completo.
Nota: Las modificaciones en el rango invalidarán dicha referencia. Para modificar la referencia, asígnele un nuevo valor. A menos que el valor almacenado en el ` Range ` sea un puntero, no es posible acceder a los miembros individuales del valor almacenado.
Restricciones
Participa en la resolución de sobrecargas solo si Range es una tabla mutable.
template <typename I> requires if_tree<I> auto QRangeModelAdapter::at(QSpan<const int> path, int column) const
Devuelve una copia del valor almacenado como el elemento especificado por path y column. Si el elemento es un elemento con múltiples roles, devuelve una copia del elemento completo. Si las filas de Range almacenan diferentes tipos en diferentes columnas, el tipo de retorno será un QVariant.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol.
template <typename I> requires unless_list<I> auto QRangeModelAdapter::at(int tableRow, int column) const
Devuelve una copia del valor almacenado como el elemento especificado por tableRow y column. Si el elemento es un elemento de múltiples roles, devuelve una copia del elemento completo. Si las filas de Range almacenan diferentes tipos en diferentes columnas, el tipo de retorno será un QVariant.
Restricciones
Participa en la resolución de sobrecarga solo si Range es una tabla o un árbol.
[since 6.12] template <typename I> requires if_writable<I> auto QRangeModelAdapter::at(const QModelIndex &index)
Devuelve un ` mutable reference ` con el valor almacenado como elemento en ` index`. Si el elemento es un elemento con múltiples roles, se tratará de una referencia al elemento completo. Si las filas de ` Range ` almacenan diferentes tipos en diferentes columnas, el tipo de retorno será un ` QVariant`.
Nota: Las modificaciones en el rango invalidarán dicha referencia. Para modificar la referencia, asígnale un nuevo valor. A menos que el valor almacenado en Range sea un puntero, no es posible acceder a miembros individuales del valor almacenado.
Restricciones
Participa en la resolución de sobrecarga solo si ` Range ` no es de solo lectura.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.12.
[since 6.12] auto QRangeModelAdapter::at(const QModelIndex &index) const
Devuelve una copia del valor almacenado como elemento en index. Si el elemento es un elemento de roles múltiples, devuelve una copia del elemento completo. Si las filas de Range almacenan diferentes tipos en diferentes columnas, el tipo de retorno será un QVariant.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.12.
int QRangeModelAdapter::columnCount() const
Devuelve el número de columnas. Este valor será 1 si el objeto ` Range ` representa una lista; en caso contrario, devolverá el número de elementos de cada fila.
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
Devuelve un objeto ` QVariant ` que contiene los datos almacenados en la dirección ` role ` especificada para el elemento de ` listRow`, o un objeto ` QVariant ` no válido si no existe ningún elemento. Si no se especifica ` role `, devuelve un objeto ` QVariant ` que contiene el elemento completo.
Restricciones
Participa en la resolución de sobrecarga solo si Range es una lista.
Véase también setData() y 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
Devuelve un ` QVariant ` que contiene los datos almacenados en la posición ` role ` para el elemento al que hacen referencia ` path ` y ` column`, o un ` QVariant ` no válido si no hay datos almacenados para esa posición o función. Si no se especifica ` role `, devuelve un ` QVariant ` que contiene el elemento completo.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol.
Véase también setData() y 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
Devuelve un ` QVariant ` que contiene los datos almacenados en la posición ` role ` especificada para el elemento al que hacen referencia ` tableRow ` y ` column`, o un ` QVariant ` no válido si no hay datos almacenados para esa posición o función. Si no se especifica ` role `, devuelve un ` QVariant ` que contiene el elemento completo.
Restricciones
Participa en la resolución de sobrecarga únicamente si Range es una tabla o un árbol.
Véase también setData() y at().
[since 6.12] QVariant QRangeModelAdapter::data(const QModelIndex &index) const
[since 6.12] QVariant QRangeModelAdapter::data(const QModelIndex &index, int role) const
Devuelve un objeto ` QVariant ` que contiene los datos almacenados bajo el ` role ` indicado para el elemento en ` index`, o un ` QVariant ` no válido si no hay datos almacenados para esa posición o función. Si no se especifica ` role `, devuelve un ` QVariant ` que contiene el elemento completo.
Estas funciones se introdujeron en Qt 6.12.
Véase también setData() y 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
Devuelve si hay alguna fila en « row ».
Restricciones
Participa en la resolución de sobrecarga solo si ` Range ` es un árbol.
[constexpr, since 6.12] template <typename I> requires if_tree<I> bool QRangeModelAdapter::hasChildren(const QModelIndex &index) const
Devuelve si hay alguna fila en « index ».
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.12.
template <typename I> requires if_list<I> QModelIndex QRangeModelAdapter::index(int listRow) const
Devuelve el objeto ` QModelIndex ` correspondiente a ` listRow`.
Restricciones
Participa en la resolución de sobrecarga solo si ` Range ` es una lista unidimensional.
Esta es una función sobrecargada.
template <typename I> requires if_tree<I> QModelIndex QRangeModelAdapter::index(QSpan<const int> path, int column) const
Devuelve el « QModelIndex » del elemento situado en « column » correspondiente a la fila del árbol especificada por « path ».
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol.
Esta es una función sobrecargada.
template <typename I> requires unless_list<I> QModelIndex QRangeModelAdapter::index(int tableRow, int column) const
Devuelve el objeto « QModelIndex » correspondiente al elemento de tableRow, column.
Restricciones
Participa en la resolución de sobrecargas solo si « Range » es una tabla o un árbol.
Esta es una función sobrecargada.
template <typename I> requires if_canInsertColumns<I> bool QRangeModelAdapter::insertColumn(int before)
Inserta una única columna vacía antes de la columna especificada por ` before ` en todas las filas y devuelve si la inserción se ha realizado correctamente. Si ` before ` tiene el mismo valor que ` columnCount()`, la columna se añadirá al final de cada fila.
Restricciones
Participa en la resolución de sobrecarga solo si Range tiene filas que admiten la inserción de elementos.
Esta es una función sobrecargada.
Véase también removeColumn(), insertColumns() y insertRow().
template <typename D, typename I> requires if_canInsertColumns<I> && if_compatible_column_data<D> bool QRangeModelAdapter::insertColumn(int before, D &&data)
Inserta en todas las filas una única columna construida a partir de ` data ` antes de la columna especificada por ` before `, y devuelve si la inserción se ha realizado correctamente. Si ` before ` tiene el mismo valor que ` columnCount()` (), la columna se añadirá al final de cada fila.
Si data es un valor único, la nueva entrada de todas las filas se construirá a partir de ese valor único.
Si data es un contenedor, los elementos de dicho contenedor se utilizarán secuencialmente para construir la columna de cada fila sucesiva. Si hay menos elementos en data que filas, la función vuelve al principio y comienza de nuevo desde el primer elemento.
Restricciones
Participa en la resolución de sobrecargas solo si Range tiene filas que admitan la inserción de elementos, y los elementos pueden construirse a partir de las entradas de data.
Esta es una función sobrecargada.
Véase también removeColumn(), insertColumns() y insertRow().
template <typename C, typename I> requires if_canInsertColumns<I> && if_compatible_column_range<C> bool QRangeModelAdapter::insertColumns(int before, C &&data)
Inserta en todas las filas las columnas creadas a partir de los elementos de data antes de la columna especificada por before, y devuelve si la inserción se ha realizado correctamente. Si before tiene el mismo valor que columnCount(), la columna se añadirá al final de cada fila.
Si los elementos de ` data ` son valores, las nuevas entradas de todas las filas se construirán a partir de dichos valores.
Si los elementos de data son contenedores, se utilizarán secuencialmente las entradas del contenedor exterior para construir las nuevas entradas de cada fila sucesiva. Si hay menos elementos en data que filas, la función vuelve al principio y comienza de nuevo desde el primer elemento.
Restricciones
Participa en la resolución de sobrecargas solo si Range tiene filas que admitan la inserción de elementos, y los elementos pueden construirse a partir de las entradas de data.
Véase también removeColumns(), insertColumn() y insertRows().
template <typename I> requires if_canInsertRows<I> && if_tree<I> bool QRangeModelAdapter::insertRow(QSpan<const int> before)
Inserta una única fila vacía antes de la fila situada en la ruta especificada por ` before`, y devuelve si la inserción se ha realizado correctamente. Si ` before ` tiene el mismo valor que ` rowCount()`, la nueva fila se añadirá al final.
Restricciones
Participa en la resolución de sobrecarga solo si ` Range ` es un árbol que admite la inserción de elementos.
Esta es una función sobrecargada.
Véase también insertRows(), removeRow() y insertColumn().
template <typename I> requires if_canInsertRows<I> bool QRangeModelAdapter::insertRow(int before)
Inserta una única fila vacía antes de la fila situada en before y devuelve si la inserción se ha realizado correctamente. Si before tiene el mismo valor que rowCount(), la nueva fila se añadirá al final.
Restricciones
Participa en la resolución de sobrecarga solo si Range admite la inserción de elementos.
Esta es una función sobrecargada.
Véase también insertRows(), removeRow() y 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)
Inserta una sola fila generada a partir de ` data ` antes de la fila situada en ` before`, y devuelve si la inserción se ha realizado correctamente. Si ` before ` tiene el mismo valor que ` rowCount()` (), la nueva fila se añadirá al final.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol que admite la inserción de elementos y si se puede construir una fila a partir de data.
Esta es una función sobrecargada.
Véase también insertRows(), removeRow() y insertColumn().
template <typename D, typename I> requires if_canInsertRows<I> && if_compatible_row<D> bool QRangeModelAdapter::insertRow(int before, D &&data)
Inserta una sola fila generada a partir de ` data ` antes de la fila situada en ` before`, y devuelve si la inserción se ha realizado correctamente. Si ` before ` tiene el mismo valor que ` rowCount()`, la nueva fila se añadirá al final.
Restricciones
Participa en la resolución de sobrecargas solo si Range admite la inserción de elementos y si se puede construir una fila a partir de data.
Esta es una función sobrecargada.
Véase también insertRows(), removeRow() y insertColumn().
template <typename I> requires if_canInsertRows<I> && if_tree<I> bool QRangeModelAdapter::insertRow(int before, const QModelIndex &parent)
Inserta una única fila vacía antes de la fila situada en before en la tabla especificada parent, y devuelve si la inserción se ha realizado correctamente. Si before tiene el mismo valor que rowCount(), la nueva fila se añadirá al final.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol que admite la inserción de elementos.
Esta es una función sobrecargada.
Véase también insertRows(), removeRow() y 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)
Inserta una sola fila generada a partir de ` data ` antes de la fila situada en ` before ` en la tabla especificada ` parent`, y devuelve si la inserción se ha realizado correctamente. Si ` before ` tiene el mismo valor que ` rowCount()`, la nueva fila se añadirá al final.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol que admite la inserción de elementos y si se puede construir una fila a partir de data.
Esta es una función sobrecargada.
Véanse también insertRows(), removeRow() y 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)
Inserta filas creadas a partir de los elementos de data antes de la fila situada en before y devuelve si la inserción se ha realizado correctamente. Si before tiene el mismo valor que rowCount(), la nueva fila se añadirá al final.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol que admite la inserción de elementos y si se pueden construir filas a partir de los elementos de data.
Esta es una función sobrecargada.
Véase también insertRow(), removeRows() y insertColumns().
template <typename C, typename I> requires if_canInsertRows<I> && if_compatible_row_range<C> bool QRangeModelAdapter::insertRows(int before, C &&data)
Inserta filas creadas a partir de los elementos de data antes de la fila situada en before y devuelve si la inserción se ha realizado correctamente. Si before tiene el mismo valor que rowCount(), la nueva fila se añadirá al final.
Restricciones
Participa en la resolución de sobrecarga solo si Range admite la inserción de elementos y si se pueden construir filas a partir de los elementos de data.
Esta es una función sobrecargada.
Véase también insertRow(), removeRows() y 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)
Inserta filas creadas a partir de los elementos de data antes de la fila situada en before en la tabla especificada parent, y devuelve si la inserción se ha realizado correctamente. Si before tiene el mismo valor que rowCount(), la nueva fila se añadirá al final.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol que admite la inserción de elementos y si las filas pueden construirse a partir de los elementos de data.
Esta es una función sobrecargada.
Véase también insertRow(), removeRows() y insertColumns().
Model *QRangeModelAdapter::model() const
Devuelve la instancia de ` QRangeModel ` creada por este adaptador.
template <typename F> requires if_canMoveItems<F> bool QRangeModelAdapter::moveColumn(int from, int to)
Mueve la columna situada en from a la columna situada en to y devuelve si la columna se ha movido correctamente.
Restricciones
Solo participa en la resolución de sobrecargas si Range contiene filas que admiten el desplazamiento de elementos.
Véase también insertColumn(), removeColumn(), moveColumns() y moveRow().
template <typename F> requires if_canMoveItems<F> bool QRangeModelAdapter::moveColumns(int from, int count, int to)
Traslada las columnas « count » que comienzan en from a la posición to y devuelve si las columnas se han trasladado correctamente.
Restricciones
Participa en la resolución de sobrecarga solo si Range tiene filas que admitan el desplazamiento de elementos.
Véase también insertColumns(), removeColumns(), moveColumn() y moveRows().
template <typename I, typename F> requires if_canMoveItems<F> && if_tree<I> bool QRangeModelAdapter::moveRow(QSpan<const int> source, QSpan<const int> destination)
Mueve la rama del árbol situada en source a la posición destination y devuelve si la rama se ha movido correctamente.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol que admite el desplazamiento de elementos.
Esta es una función sobrecargada.
Véase también insertRow(), removeRow() y moveColumn().
template <typename F> requires if_canMoveItems<F> bool QRangeModelAdapter::moveRow(int source, int destination)
Mueve la fila situada en source a la posición destination y devuelve si la fila se ha movido correctamente.
Restricciones
Participa en la resolución de sobrecarga solo si Range admite el desplazamiento de elementos.
Esta es una función sobrecargada.
Véase también insertRow(), removeRow() y 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)
Mueve la rama situada en sourceRow desde el sourceParent a la posición destinationChild en el destinationParent, y devuelve si la rama se ha movido correctamente.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol que admite el desplazamiento de elementos.
Esta es una función sobrecargada.
Véase también insertRow(), removeRow() y 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)
Mueve las ramas del árbol « count », que comienzan en source, a la posición destination, y devuelve si las filas se han movido correctamente.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol que admite el desplazamiento de elementos.
Esta es una función sobrecargada.
Véase también insertRows(), removeRows() y moveColumns().
template <typename F> requires if_canMoveItems<F> bool QRangeModelAdapter::moveRows(int source, int count, int destination)
Traslada las filas d count, empezando por source, a la posición destination, y devuelve si las filas se han trasladado correctamente.
Restricciones
Participa en la resolución de sobrecarga solo si Range admite el desplazamiento de elementos.
Esta es una función sobrecargada.
Véase también insertRows(), removeRows() y 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)
Traslada las ramas de count, empezando por sourceRow, desde sourceParent a la posición indicada en destinationChild dentro de destinationParent, y devuelve si la rama se ha trasladado correctamente.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol que admite el desplazamiento de elementos.
Esta es una función sobrecargada.
Véase también insertRows(), removeRows() y moveColumns().
const QRangeModelAdapter<Range, Protocol, Model>::range_type &QRangeModelAdapter::range() const
Devuelve una referencia const al rango sobre el que opera el adaptador de modelo.
Véase también assign(), at() y model().
template <typename I> requires if_canRemoveColumns<I> bool QRangeModelAdapter::removeColumn(int column)
Elimina el elemento « column » especificado de cada fila y devuelve si la eliminación se ha realizado correctamente.
Restricciones
Participa en la resolución de sobrecargas solo si Range contiene filas que admiten la eliminación de elementos.
Véase también insertColumn(), removeColumns() y removeRow().
template <typename I> requires if_canRemoveColumns<I> bool QRangeModelAdapter::removeColumns(int column, int count)
Elimina de cada fila de « count » las columnas que empiezan por el valor dado « column » y devuelve si la eliminación se ha realizado correctamente.
Restricciones
Participa en la resolución de sobrecarga solo si Range contiene filas que admiten la eliminación de elementos.
Véase también insertColumns(), removeColumn() y removeRow().
template <typename I> requires if_canRemoveRows<I> && if_tree<I> bool QRangeModelAdapter::removeRow(QSpan<const int> path)
Elimina la fila en la posición indicada path, incluidos todos los elementos secundarios de dicha fila, y devuelve si la eliminación se ha realizado correctamente.
Restricciones
Participa en la resolución de sobrecarga solo si Range es un árbol que admite la eliminación de elementos.
Esta es una función sobrecargada.
Véase también removeRows(), removeColumn() y insertRow().
template <typename I> requires if_canRemoveRows<I> bool QRangeModelAdapter::removeRow(int row)
Elimina el objeto « row » indicado y devuelve si la eliminación se ha realizado correctamente.
Restricciones
Participa en la resolución de sobrecarga solo si Range admite la eliminación de elementos.
Esta es una función sobrecargada.
Véase también ` removeRows()`, ` removeColumn()` y ` insertRow()`.
template <typename I> requires if_canRemoveRows<I> && if_tree<I> bool QRangeModelAdapter::removeRow(int row, const QModelIndex &parent)
Elimina el « row » especificado de « parent », incluyendo todos los elementos secundarios de esa fila, y devuelve si la eliminación se ha realizado correctamente.
Restricciones
Participa en la resolución de sobrecarga únicamente si ` Range ` es un árbol que admite la eliminación de elementos.
Esta es una función sobrecargada.
Véase también ` removeRows()`, ` removeColumn()` y ` insertRow()`.
template <typename I> requires if_canRemoveRows<I> && if_tree<I> bool QRangeModelAdapter::removeRows(QSpan<const int> path, int count)
Elimina las filas de « count » a partir de la fila especificada por « path » y devuelve si la eliminación se ha realizado correctamente.
Restricciones
Participa en la resolución de sobrecarga únicamente si ` Range ` es un árbol que admite la eliminación de elementos.
Esta es una función sobrecargada.
Véase también removeRow(), removeColumns() y insertRows().
template <typename I> requires if_canRemoveRows<I> bool QRangeModelAdapter::removeRows(int row, int count)
Elimina las filas de « count » a partir de « row » y devuelve si la eliminación se ha realizado correctamente.
Restricciones
Participa en la resolución de sobrecarga únicamente si Range admite la eliminación de elementos.
Esta es una función sobrecargada.
Véase también removeRow(), removeColumns() y insertRows().
template <typename I> requires if_canRemoveRows<I> && if_tree<I> bool QRangeModelAdapter::removeRows(int row, int count, const QModelIndex &parent)
Elimina las filas « count » de la tabla « parent » a partir de la columna especificada « row », y devuelve si la eliminación se ha realizado correctamente.
Restricciones
Participa en la resolución de sobrecargas solo si Range es un árbol que admite la eliminación de elementos.
Esta es una función sobrecargada.
Véase también removeRow(), removeColumns() y insertRows().
int QRangeModelAdapter::rowCount() const
Devuelve el número de filas. Si el objeto ` Range ` representa una lista o una tabla, este es el número de filas. En el caso de los árboles, se trata del número de filas de nivel superior.
Esta es una función sobrecargada.
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
Devuelve el número de filas que hay en row.
Restricciones
Participa en la resolución de sobrecarga solo si ` Range ` es un árbol.
[since 6.12] template <typename I> requires if_tree<I> int QRangeModelAdapter::rowCount(const QModelIndex &index) const
Devuelve el número de filas que hay en « index ».
Restricciones
Participa en la resolución de sobrecarga solo si ` Range ` es un árbol.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.12.
template <typename I> requires if_list<I> && if_writable<I> bool QRangeModelAdapter::setData(int listRow, const QVariant &value, int role = Qt::EditRole)
Establece el dato « role » del elemento situado en listRow en value.
Devuelve « true » si se realiza correctamente; en caso contrario, devuelve « false ».
Restricciones
Participa en la resolución de sobrecarga solo si Range es una lista mutable.
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)
Establece el valor de « role » del elemento al que hacen referencia « path » y « column » en « value ».
Devuelve true si se realiza correctamente; en caso contrario, devuelve false.
Restricciones
Participa en la resolución de sobrecarga solo si ` Range ` es un árbol mutable.
template <typename I> requires unless_list<I> && if_writable<I> bool QRangeModelAdapter::setData(int tableRow, int column, const QVariant &value, int role = Qt::EditRole)
Establece el dato « role » del elemento al que hacen referencia « tableRow » y « column » en « value ».
Devuelve true si se realiza correctamente; en caso contrario, devuelve false.
Restricciones
Participa en la resolución de sobrecarga solo si ` Range ` es mutable y no es una lista.
[since 6.12] template <typename I> requires if_writable<I> bool QRangeModelAdapter::setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole)
Establece el dato « role » del elemento situado en « index » en « value ».
Devuelve « true » si se realiza correctamente; en caso contrario, devuelve « false ».
Restricciones
Participa en la resolución de sobrecarga solo si Range no es de solo lectura.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.12.
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)
Sustituye el contenido del modelo por las filas de newRange, utilizando, en su caso, la semántica de desplazamiento.
Esta función hace que model() emita las señales modelAboutToBeReset() y modelReset().
Restricciones
Participa en la resolución de sobrecargas únicamente si ` Range ` es mutable y ` newRange ` es de un tipo que se pueda asignar a ` Range`, pero no a ` QRangeModelAdapter`.
Véase también range(), at(), model() y 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)
Sustituye el contenido del modelo por las filas de newRange.
Restricciones
Participa en la resolución de sobrecarga solo si Range es mutable y newRange puede asignarse a Range.
Elementos no miembros relacionados
[noexcept] bool operator!=(const QRangeModelAdapter<Range, Protocol, Model> &lhs, const QRangeModelAdapter<Range, Protocol, Model> &rhs)
Devuelve si lhs no es igual a rhs. Dos adaptadores son iguales si ambos contienen la misma instancia de model.
[noexcept] bool operator==(const QRangeModelAdapter<Range, Protocol, Model> &lhs, const QRangeModelAdapter<Range, Protocol, Model> &rhs)
Devuelve si ` lhs ` es igual a ` rhs`. Dos adaptadores son iguales si ambos contienen la misma instancia de ` model `.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.