Back to Qt.io
Contact Us Blog Download Qt
En esta página

QRangeModelAdapter Class

QRangeModelAdapter proporciona acceso compatible con QAbstractItemModel a cualquier rango C++. Más...

Cabecera: #include <QRangeModelAdapter>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Desde: Qt 6.11
Estado: Preliminar

Esta clase está en desarrollo y está sujeta a cambios.

Esta clase es comparable con Equality.

Esta clase es comparable con Range.

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

Tipos privados

range_type
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 C++ segura en cuanto a tipos y estructuras en torno a un rango C++ y a QRangeModel. Las modificaciones realizadas en el rango C++ utilizando el adaptador informarán a los clientes de QRangeModel sobre los cambios. Esto garantiza que las vistas de elementos se actualicen, las cachés se limpien y los índices de elementos persistentes se invaliden y adapten correctamente.

Construcción y propiedad del modelo

QRangeModelAdapter debe construirse a partir de un rango C++. Al igual que en QRangeModel, el rango puede proporcionarse por referencia lvalue o rvalue, como envoltorio de referencia y como puntero bruto o inteligente.

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

El tipo exacto que se construye lo deduce el compilador basándose en el argumento o argumentos del constructor, y las diferencias entre categorías de valores pueden dar lugar a comportamientos diferentes. Por lo tanto, no debe especificar explícitamente los parámetros de plantilla. Sin embargo, C++ no permite la deducción de argumentos de plantilla de clase para miembros de datos de clase no estáticos. Para hacer de QRangeModelAdapter un miembro de datos de una clase, utilice 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 de Libros sin nombre (es decir, referencia rvalue). Para hacer que el adaptador opere sobre una envoltura de referencia a una lista de Libros, utilice 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. Utilice model() para obtenerla y pásela a las vistas de elementos Qt Widgets o Qt Quick como de costumbre.

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

El adaptador es el 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 creó a partir de una referencia lvalue o rvalue, entonces el adaptador y el modelo operarán sobre una copia del objeto range original. En caso contrario, las modificaciones realizadas a través del adaptador o el modelo se escribirán en el objeto range original. Para acceder al rango actualizado, utilice 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 QRangeModelAdapter proporciona acceso de lectura y escritura seguro al rango sobre el que opera el modelo. La API del adaptador se basa en la API típica de los contenedores y rangos de C++, incluidos los iteradores. Para acceder a filas y elementos individuales, utilice at(), el subíndice correspondiente operator[], o data(). Las sobrecargas de estas funciones dependerán del rango para el que se haya construido el adaptador.

Lectura de datos de ítems como QVariant

La función data() siempre devuelve un QVariant con el valor almacenado en la posición y rol especificados. En una lista, se puede acceder a un elemento mediante un único valor entero que especifica la fila:

QVariant listItem = listAdapter.data(row);

Si el rango es una tabla, entonces los elementos se especifican por 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);

Si se utiliza un único número entero como fila, se accede a los elementos del árbol de nivel superior.

QRangeModelAdapter listOfBooks(QList<Book>{
    // ~~~
});
QString bookTitle = listOfBooks.data(0, Book::TitleRole).toString();
Book multiRoleItem = listOfBooks.data(0).value<Book>();

Si no se especifica ninguna función, entonces QVariant contendrá el elemento completo en la posición. Utilice la función de plantilla QVariant::fromValue() para recuperar una copia del elemento.

Lectura y escritura con at()

El hecho de que la función data() devuelva un QVariant la hace flexible, pero elimina la seguridad de tipo. Para rangos en los que todos los elementos son del mismo tipo, la función at() proporciona una alternativa de tipo seguro que es más compatible con los contenedores C++ normales. Al igual que data(), existen sobrecargas de at() para acceder a un elemento en una fila en el caso de las listas, en un par fila/columna en el caso de las tablas y en un par ruta/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 función individuales para un elemento.

Como era de esperar de una API de contenedores de C++, las sobrecargas const de at() (y el correspondiente subíndice operator[]) proporcionan acceso inmutable al valor, mientras que las sobrecargas mutables devuelven un objeto de referencia al que se puede asignar un nuevo valor. Nótese que un QRangeModelAdapter que opera sobre un rango const se comporta en ese aspecto como un QRangeModelAdapter const. Las sobrecargas mutables se eliminan del conjunto de sobrecargas, por lo que el compilador siempre seleccionará la versión const. Si se intenta llamar a una función que modifica un rango, se producirá 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 convierten implícitamente al tipo subyacente, tienen una función get() para acceder explícitamente al valor subyacente y un 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, estos objetos de referencia impiden la modificación directa de los elementos.

Nota: El acceso al objeto de referencia siempre realiza una llamada al modelo para obtener una copia del valor. Esto puede ser costoso; para un acceso a los datos crítico para el rendimiento, almacena una copia.

Acceso a los elementos

Si el rango se representa como una lista, sólo están disponibles las sobrecargas que toman 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 en esa fila, mientras que la sobrecarga mutable devuelve una envoltura que convierte implícitamente hacia y desde el tipo de valor de la lista.

QRangeModelAdapter books(QList<Book>{
    // ~~~
});
Book firstBook = books.at(0);
Book newBook = {};
books.at(0) = newBook; // dataChanged() emitted

Asigne un valor a la envoltura para modificar los datos de la lista. El modelo emitirá dataChanged() para todos los roles.

Cuando se utilizan las sobrecargas mutables, también se puede acceder a los miembros const del tipo de elemento utilizando el operador de flecha sobrecargado.

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

No es posible acceder a miembros no-const del elemento. Tales modificaciones eludirían el adaptador, que no podría notificar los cambios al modelo. Para modificar el valor almacenado en el modelo, haga una copia, modifique las propiedades de la copia y, a continuación, vuelva 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 dataChanged() para este elemento, y para todos los roles.

Si el rango se representa como una tabla, entonces puedes acceder a un elemento individual por fila y columnas, utilizando la sobrecarga at(fila, columna). Para los árboles, esa sobrecarga da acceso a los elementos de nivel superior, mientras que la sobrecarga at(ruta, columna) da acceso a los elementos anidados dentro del árbol.

Acceder a un elemento individual 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 utilizando el mismo tipo de datos, entonces at(row,column) devuelve una (una envoltura 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

Para tablas y árboles, las sobrecargas de at() y el 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, entonces ese tipo de referencia será una vista de la fila, dando acceso a punteros a elementos const.

Acceso a filas de tabla

La sobrecarga at(int) sigue estando disponible, pero devuelve todo el wor 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 una envoltura que actúa como referencia a la fila. La envoltura proporciona acceso a las funciones miembro const mediante el operador de flecha sobrecargado. Para modificar los valores, vuelva 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: Cuando se utiliza un tipo de fila con tamaños en tiempo de ejecución, como std::vector o QList, asegúrese de que la nueva fila tiene el tamaño correcto.

Acceso a filas de árbol

Las filas de los árboles se especifican mediante una secuencia de enteros, una entrada por cada nivel del árbol. Observe que en los siguientes fragmentos, el árbol es un rango que contiene punteros a filas sin procesar, y que el adaptador se crea con una referencia rvalue de ese rango. Esto da a QRangeModel la propiedad sobre los datos de las filas.

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 las filas de nivel superior.

auto germanyName = tree.at(0, 0);
auto bavariaSize = tree.at({0, 0}, 1);

El patrón básico para acceder a filas y elementos de un árbol es idéntico al de acceder a filas y elementos de una tabla. Sin embargo, el adaptador se asegurará de que se mantenga la estructura de árbol cuando se modifiquen filas enteras.

// deletes the old row - tree was moved in
tree.at({0, 0}) = new TreeRow{"Berlin", 892};

En este ejemplo, se crea un nuevo objeto fila y se asigna al primer hijo del primer elemento de nivel superior.

API del iterador

Utilice begin() y end() para obtener iteradores sobre las filas del modelo, o utilice ranged-for. Si el rango es una lista de elementos, la desreferencia al iterador dará acceso a los datos del elemento.

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 hará referencia a una envoltura.

for(auto libro : libros) {    qDebug() << "The book" << book->title()
            << "escrito por"<<  book->author()<< "tiene"<<  book->rating()<< "estrellas"; Book copy = book; copy.setRating(copy.rating() + 1); book = copy; }

Utilice el operador de flecha sobrecargado para acceder a los miembros const del tipo de elemento, y asignar a la envoltura para reemplazar el valor.

Si el rango es una tabla o un árbol, iterar sobre el modelo dará acceso a las filas.

QRangeModelAdapter table(std::vector<std::pair<int, QString>>{ // ~~~});for(const auto &row: std::as_const(tabla)) {    qDebug() << "Number is" << row->first << "and string is" << row->second;
}

Tanto el iterador const como el mutable harán referencia a un tipo envolvente para la fila. Esto asegura que podemos iterar consistentemente sobre cada columna, incluso si el tipo de fila subyacente no es un rango (por ejemplo, podría ser una tupla o gadget).

for(const auto &row: std::as_const(table)) { for(const auto &item: row) {        qDebug() << item; // item is a QVariant
    } }

Cuando iteramos sobre una tabla mutable podemos sobreescribir la fila completa.

for(auto fila : tabla) {    qDebug() << "Number is" << row->first << "and string is" << row->second;
    row = std::make_pair(42, u"cuarenta y dos"_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.

Cuando se itera sobre un árbol, la envoltura de fila tiene 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 llamadoe, pero todas las operaciones utilizarán el índice de la fila de origen como índice padre.

Véase también QRangeModel.

Documentación de tipos de miembros

[alias] QRangeModelAdapter::range_type

Documentación de las funciones miembro

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

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

Construye un QRangeModelAdapter que opera sobre range. Para los rangos de árbol, se utilizará el opcional protocol para recorrer el árbol.

Consulte la documentación del constructor QRangeModel para obtener más información sobre los requisitos de Range, y cómo la categoría de valor de range cambia la interacción entre el adaptador, el modelo y el rango.

Véase también QRangeModel.

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

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

Sustituye el contenido del modelo por las filas de newRange, posiblemente utilizando la semántica move.

Esta función hace que model() emita las señales modelAboutToBeReset() y modelReset().

Restricciones

Participa en la resolución de sobrecargas sólo si Range es mutable, y newRange es de un tipo que puede asignarse a Range, pero no a QRangeModelAdapter.

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

template <typename Row, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<std::initializer_list<Row>> = true> void QRangeModelAdapter::assign(std::initializer_list<Row> newRange)

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

Sustituye el contenido del modelo por las filas de newRange.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es mutable, y newRange puede asignarse a Range.

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

template < typename InputIterator, typename Sentinel, typename I, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > void QRangeModelAdapter::assign(InputIterator first, Sentinel last)

Sustituye el contenido de los modelos por las filas del rango [first, last).

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

template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(QSpan<const int> path)

template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::operator[](QSpan<const int> path)

Devuelve una envoltura mutable que contiene una referencia a la fila del árbol especificada por path.

Para modificar la fila del árbol, asígnele un nuevo valor. Al asignar una nueva fila al árbol, el padre de la nueva fila será el padre de la fila anterior. Sin embargo, ni la fila antigua ni la nueva deben tener filas secundarias. Para acceder a la fila del árbol, desreferencie la envoltura utilizando operator*(), o utilice operator->() para acceder a los miembros de la fila del árbol.

Nota: Las modificaciones del rango invalidarán la envoltura.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es un árbol.

template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(int row)

template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::operator[](int row)

Devuelve el valor en row envuelto en una referencia mutable al tipo almacenado en Range.

Nota: Las modificaciones del rango invalidarán esa referencia. Para modificar la referencia, asígnele 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 sobrecargas sólo si Range es una lista mutable.

template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_table<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(int row)

template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_table<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::operator[](int row)

Devuelve una referencia mutable a la fila en row, tal y como se almacena en Range.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es una tabla mutable, pero no un árbol.

template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(int row)

template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::operator[](int row)

Devuelve una envoltura mutable que contiene una referencia a la fila del árbol especificada por row.

Para modificar la fila del árbol, asígnele un nuevo valor. Al asignar una nueva fila al árbol, el padre de la nueva fila será el padre de la fila anterior. Sin embargo, ni la fila antigua ni la nueva deben tener filas secundarias. Para acceder a la fila del árbol, desreferencie la envoltura utilizando operator*(), o utilice operator->() para acceder a los miembros de la fila del árbol.

Nota: Las modificaciones del rango invalidarán la envoltura.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es un árbol.

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> decltype(auto) QRangeModelAdapter::at(QSpan<const int> path) const

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> decltype(auto) QRangeModelAdapter::operator[](QSpan<const int> path) const

Devuelve una referencia constante a la fila especificada por path, almacenada en Range.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es un árbol.

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> auto QRangeModelAdapter::at(int row) const

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> auto QRangeModelAdapter::operator[](int row) const

Devuelve el valor en row como el tipo almacenado en Range.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es una lista.

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> decltype(auto) QRangeModelAdapter::at(int row) const

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> decltype(auto) QRangeModelAdapter::operator[](int row) const

Devuelve una referencia constante a la fila en row, tal y como se almacena en Range.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es una tabla o un árbol.

template < typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(QSpan<const int> path, int column)

Devuelve una referencia mutable al valor almacenado como el ítem especificado por path y column. Si el ítem es un ítem multi-rol, entonces esto será una referencia al ítem completo. Si las filas en el Range almacenan diferentes tipos en diferentes columnas, entonces el tipo de retorno será un QVariant.

Nota: Las modificaciones en el rango invalidarán esa referencia. Para modificar la referencia, asígnele 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 sobrecargas sólo si Range es un árbol mutable.

template < typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true > auto QRangeModelAdapter::at(int row, int column)

Devuelve una referencia mutable al valor almacenado como el ítem especificado por row y column. Si el ítem es un ítem multi-rol, entonces esto será una referencia al ítem completo.

Nota: Las modificaciones del rango invalidarán esa referencia. Para modificar la referencia, asígnele 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 sobrecargas sólo si Range es una tabla mutable.

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> auto QRangeModelAdapter::at(QSpan<const int> path, int column) const

Devuelve una copia del valor almacenado como el ítem especificado por path y column. Si el ítem es un ítem multi-rol, entonces esto devuelve una copia del ítem completo. Si las filas de Range almacenan diferentes tipos en diferentes columnas, entonces el tipo devuelto será un QVariant.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es un árbol.

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> auto QRangeModelAdapter::at(int row, int column) const

Devuelve una copia del valor almacenado como el ítem especificado por row y column. Si el ítem es un ítem multi-rol, entonces esto devuelve una copia del ítem completo. Si las filas de Range almacenan diferentes tipos en diferentes columnas, entonces el tipo devuelto será un QVariant.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es una tabla o un árbol.

int QRangeModelAdapter::columnCount() const

Devuelve el número de columnas. Será uno si Range representa una lista; en caso contrario, devuelve el número de elementos de cada fila.

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> QVariant QRangeModelAdapter::data(int row) const

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> QVariant QRangeModelAdapter::data(int row, int role) const

Devuelve un QVariant con los datos almacenados en el role dado para el elemento en row, o un QVariant inválido si no hay ningún elemento. Si no se especifica role, devuelve un QVariant con el elemento completo.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es una lista.

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

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> QVariant QRangeModelAdapter::data(QSpan<const int> path, int column) const

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> QVariant QRangeModelAdapter::data(QSpan<const int> path, int column, int role) const

Devuelve un QVariant con los datos almacenados en el role dado para el elemento al que se refieren 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 con el elemento completo.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es un árbol.

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

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> QVariant QRangeModelAdapter::data(int row, int column) const

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> QVariant QRangeModelAdapter::data(int row, int column, int role) const

Devuelve un QVariant con los datos almacenados en el role dado para el elemento al que se hace referencia en row 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 con el elemento completo.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es una tabla o un árbol.

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

[constexpr] template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> bool QRangeModelAdapter::hasChildren(int row) const

[constexpr] template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> bool QRangeModelAdapter::hasChildren(QSpan<const int> row) const

Devuelve si hay alguna fila en row.

Restricciones

Participa en la resolución de la sobrecarga sólo si Range es un árbol.

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true> QModelIndex QRangeModelAdapter::index(int row) const

Devuelve el QModelIndex para row.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es una lista unidimensional.

Se trata de una función sobrecargada.

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> QModelIndex QRangeModelAdapter::index(QSpan<const int> path, int column) const

Devuelve el QModelIndex para el elemento en column para la fila en el árbol especificado por path.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es un árbol.

Se trata de una función sobrecargada.

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true> QModelIndex QRangeModelAdapter::index(int row, int column) const

Devuelve el QModelIndex para el elemento en row, column.

Restricciones

Participa en la resolución de sobrecargas sólo si Range es una tabla o un árbol.

Se trata de una función sobrecargada.

template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I> = true> 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 es el mismo valor que columnCount(), la columna se añadirá a cada fila.

Restricciones

Participa en la resolución de la sobrecarga sólo si Range tiene filas que admitan la inserción de elementos.

Se trata de una función sobrecargada.

Véase también removeColumn(), insertColumns() y insertRow().

template < typename D, typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I> = true, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_column_data<D> = true > bool QRangeModelAdapter::insertColumn(int before, D &&data)

Inserta una única columna construida a partir de data antes de la columna especificada por before en todas las filas, y devuelve si la inserción se ha realizado correctamente. Si before es el mismo valor que columnCount(), entonces la columna se añadirá a cada fila.

Si data es un valor único, entonces la nueva entrada en todas las filas se construirá a partir de ese valor único.

Si data es un contenedor, los elementos de ese contenedor se utilizarán secuencialmente para construir la columna de cada fila posterior. Si hay menos elementos en data que filas, la función vuelve a empezar desde el primer elemento.



Restricciones


Participa en la resolución de la sobrecarga sólo si Range tiene filas que admiten la inserción de elementos, y los elementos pueden construirse a partir de las entradas en data.


Se trata de una función sobrecargada.


Véase también removeColumn(), insertColumns(), y insertRow().




template <
    typename C,
    typename I,
    QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_compatible_column_range<C> = true
>
bool QRangeModelAdapter::insertColumns(int before, C &&data)


Inserta columnas construidas a partir de los elementos de data antes de la columna especificada por before en todas las filas, y devuelve si la inserción se ha realizado correctamente. Si before es el mismo valor que columnCount(), entonces la columna se añadirá a cada fila.


Si los elementos en data son valores, entonces las nuevas entradas en todas las filas se construirán a partir de esos valores.


Si los elementos de data son contenedores, las entradas del contenedor exterior se utilizarán secuencialmente para construir las nuevas entradas de cada fila posterior. Si hay menos elementos en data que filas, la función da la vuelta y comienza de nuevo desde el primer elemento.




Restricciones


Participa en la resolución de sobrecargas sólo si Range tiene filas que admitan la inserción de elementos, y los elementos pueden construirse a partir de las entradas en data.


Véase también removeColumns(), insertColumn(), y insertRows().




template <
    typename I,
    QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true
>
bool QRangeModelAdapter::insertRow(QSpan<const int> before)


Inserta una única fila vacía antes de la fila en la ruta especificada por before, y devuelve si la inserción se ha realizado correctamente. Si before tiene el mismo valor que rowCount(), se añadirá la nueva fila.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range es un árbol que admite la inserción de elementos.


Se trata de una función sobrecargada.


Véase también insertRows(), removeRow() y insertColumn().




template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true> bool QRangeModelAdapter::insertRow(int before)


Inserta una única fila vacía antes de la fila en before, y devuelve si la inserción se ha realizado correctamente. Si before tiene el mismo valor que rowCount(), se añadirá la nueva fila.


Restricciones


Participa en la resolución de sobrecargas sólo si Range admite la inserción de elementos.


Se trata de una función sobrecargada.


Véase también insertRows(), removeRow() y insertColumn().




template <
    typename D,
    typename I,
    QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_compatible_row<D> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true
>
bool QRangeModelAdapter::insertRow(QSpan<const int> before, D &&data)


Inserta una única fila construida a partir de data antes de la fila en before, y devuelve si la inserción ha tenido éxito. Si before tiene el mismo valor que rowCount(), se añadirá la nueva fila.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range es un árbol que admite la inserción de elementos, y si se puede construir una fila a partir de data.


Se trata de una función sobrecargada.


Véase también insertRows(), removeRow(), y insertColumn().




template <
    typename D,
    typename I,
    QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_compatible_row<D> = true
>
bool QRangeModelAdapter::insertRow(int before, D &&data)


Inserta una única fila construida a partir de data antes de la fila en before, y devuelve si la inserción ha tenido éxito. Si before tiene el mismo valor que rowCount(), se añadirá la nueva fila.


Restricciones


Participa en la resolución de sobrecargas sólo si Range admite la inserción de elementos, y si se puede construir una fila a partir de data.


Se trata de una función sobrecargada.


Véase también insertRows(), removeRow(), y insertColumn().




template <
    typename C,
    typename I,
    QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_compatible_row_range<C> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true
>
bool QRangeModelAdapter::insertRows(QSpan<const int> before, C &&data)


Inserta filas construidas a partir de los elementos en data antes de la fila en before, y devuelve si la inserción tuvo éxito. Si before tiene el mismo valor que rowCount(), se añadirá la nueva fila.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range es un árbol que admite la inserción de elementos, y si se pueden construir filas a partir de los elementos en data.


Se trata de una función sobrecargada.


Véase también insertRow(), removeRows(), y insertColumns().




template <
    typename C,
    typename I,
    QRangeModelAdapter<Range, Protocol, Model>::if_canInsertRows<I> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_compatible_row_range<C> = true
>
bool QRangeModelAdapter::insertRows(int before, C &&data)


Inserta filas construidas a partir de los elementos en data antes de la fila en before, y devuelve si la inserción tuvo éxito. Si before tiene el mismo valor que rowCount(), se añadirá la nueva fila.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range admite la inserción de elemnetos, y si se pueden construir filas a partir de los elementos de data.


Se trata de una función sobrecargada.


Véase también insertRow(), removeRows(), y insertColumns().




Model *QRangeModelAdapter::model() const


Devuelve la instancia QRangeModel creada por este adaptador.


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




template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveColumn(int from, int to)


Mueve la columna de from a la columna de to, y devuelve si la columna se ha movido correctamente.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range tiene filas que admitan el movimiento de elementos.


Véase también insertColumn(), removeColumn(), moveColumns(), y moveRow().




template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveColumns(int from, int count, int to)


Mueve las columnas de count empezando en from a la posición en to, y devuelve si las columnas se han movido con éxito.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range tiene filas que admitan el movimiento de elementos.


Véase también insertColumns(), removeColumns(), moveColumn(), y moveRows().




template <
    typename I,
    typename F,
    QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true
>
bool QRangeModelAdapter::moveRow(QSpan<const int> source, QSpan<const int> destination)


Mueve la rama del árbol en source a la posición en destination, y devuelve si la rama se ha movido con éxito.


Restricciones


Participa en la resolución de sobrecargas sólo si Range es un árbol que soporta el movimiento de elementos.


Se trata de una función sobrecargada.


Véase también insertRow(), removeRow(), y moveColumn().




template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveRow(int source, int destination)


Mueve la fila en source a la posición en destination, y devuelve si la fila se ha movido con éxito.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range admite el desplazamiento de elementos.


Se trata de una función sobrecargada.


Véase también insertRow(), removeRow(), y moveColumn().




template <
    typename I,
    typename F,
    QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true
>
bool QRangeModelAdapter::moveRows(QSpan<const int> source, int count, QSpan<const int> destination)


Mueve las ramas del árbol count empezando en source a la posición en destination, y devuelve si las filas se han movido con éxito.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range es un árbol que soporta el movimiento de elementos.


Se trata de una función sobrecargada.


Véase también insertRows(), removeRows(), y moveColumns().




template <typename F, QRangeModelAdapter<Range, Protocol, Model>::if_canMoveItems<F> = true> bool QRangeModelAdapter::moveRows(int source, int count, int destination)


Mueve las filas de count empezando en source a la posición en destination, y devuelve si las filas se han movido con éxito.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range soporta el movimiento de elementos.


Se trata de 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 constante al rango sobre el que opera el adaptador del modelo.


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




template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveColumns<I> = true> bool QRangeModelAdapter::removeColumn(int column)


Elimina la dirección column de cada fila y devuelve si la eliminación se ha realizado correctamente.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range tiene filas que admitan la eliminación de elementos.


Véase también insertColumn(), removeColumns() y removeRow().




template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveColumns<I> = true> bool QRangeModelAdapter::removeColumns(int column, int count)


Elimina de cada fila las columnas de count que comienzan por column y devuelve si la eliminación se ha realizado correctamente.


Restricciones


Participa en la resolución de la sobrecarga sólo si Range tiene filas que admitan la eliminación de elementos.


Véase también insertColumns(), removeColumn(), y removeRow().




template <
    typename I,
    QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveRows<I> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true
>
bool QRangeModelAdapter::removeRow(QSpan<const int> path)


Elimina la fila en la dirección path, incluidos todos los hijos de esa fila, y devuelve si la eliminación se ha realizado correctamente.


Restricciones


Participa en la resolución de sobrecargas sólo si Range es un árbol que admite la eliminación de elementos.


Se trata de una función sobrecargada.


Véase también removeRows(), removeColumn(), y insertRow().




template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveRows<I> = true> bool QRangeModelAdapter::removeRow(int row)


Elimina la dirección row indicada y devuelve si la eliminación se ha realizado correctamente.


Restricciones


Participa en la resolución de sobrecargas sólo si Range admite la eliminación de elementos.


Se trata de una función sobrecargada.


Véase también removeRows(), removeColumn() y insertRow().




template <
    typename I,
    QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveRows<I> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true
>
bool QRangeModelAdapter::removeRows(QSpan<const int> path, int count)


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 sobrecargas sólo si Range es un árbol que admite la eliminación de elementos.


Se trata de una función sobrecargada.


Véase también removeRow(), removeColumns(), y insertRows().




template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canRemoveRows<I> = true> 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 sobrecargas sólo si Range admite la eliminación de elementos.


Se trata de una función sobrecargada.


Véase también removeRow(), removeColumns(), y insertRows().




int QRangeModelAdapter::rowCount() const


Devuelve el número de filas. Si Range representa una lista o una tabla, se trata del número de filas. Para los árboles, es el número de filas del nivel superior.


Se trata de una función sobrecargada.







template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> int QRangeModelAdapter::rowCount(int row) const


template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I> = true> int QRangeModelAdapter::rowCount(QSpan<const int> row) const




Devuelve el número de filas en row.


Restricciones


Participa en la resolución de sobrecargas sólo si Range es un árbol.




template <
    typename I,
    QRangeModelAdapter<Range, Protocol, Model>::if_list<I> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true
>
bool QRangeModelAdapter::setData(int row, const QVariant &value, int role = Qt::EditRole)


Establece los datos de role para el elemento en row a value.


Devuelve true si se ha realizado correctamente; en caso contrario, devuelve false.


Restricciones


Participa en la resolución de sobrecargas sólo si Range es una lista mutable.


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




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


Establece los datos de role para el elemento al que hacen referencia path y column en value.


Devuelve true si se ha realizado correctamente; en caso contrario, devuelve false.


Restricciones


Participa en la resolución de sobrecargas sólo si Range es un árbol mutable.


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




template <
    typename I,
    QRangeModelAdapter<Range, Protocol, Model>::unless_list<I> = true,
    QRangeModelAdapter<Range, Protocol, Model>::if_writable<I> = true
>
bool QRangeModelAdapter::setData(int row, int column, const QVariant &value, int role = Qt::EditRole)


Establece los datos de role para el elemento al que hacen referencia row y column en value.


Devuelve true si se ha realizado correctamente; en caso contrario, devuelve false.


Restricciones


Participa en la resolución de sobrecargas sólo si Range es mutable, y no una lista.


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







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