En esta página

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íaTipos comparables
igualdadQRangeModelAdapter
igualdadRango.

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

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 satisfied

Los 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() emitted

Asigna 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() emitted

Esto 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.0

Si 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 row

Al 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 los tipos de miembros

[alias] QRangeModelAdapter::range_type

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.

Véase también range() y at().

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.

Véase también data() y 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)

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.

Véase también data() y 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)

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.

Véase también data() y at().

[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.

Véase también data() y 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)

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.

Véase también range(), at y model().

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.