Revision control
++ // Copyright (C) 2021 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qqmlxmllistmodel_p.h"
++
++ #include <QtQml/qqmlcontext.h>
++ #include <QtQml/qqmlengine.h>
++ #include <QtQml/qqmlinfo.h>
++ #include <QtQml/qqmlfile.h>
++
++ #include <QtCore/qcoreapplication.h>
++ #include <QtCore/qfile.h>
++ #include <QtCore/qfuturewatcher.h>
++ #include <QtCore/qtimer.h>
++ #include <QtCore/qxmlstream.h>
++
++ #if QT_CONFIG(qml_network)
++ #include <QtNetwork/qnetworkreply.h>
++ #include <QtNetwork/qnetworkrequest.h>
++ #endif
++
++ Q_DECLARE_METATYPE(QQmlXmlListModelQueryResult)
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \qmlmodule QtQml.XmlListModel
++ \title Qt Qml XmlListModel QML Types
++ \keyword Qt Qml XmlListModel QML Types
++ \ingroup qmlmodules
++ \brief Provides QML types for creating models from XML data.
++
++ This QML module contains types for creating models from XML data.
++
++ To use the types in this module, import the module with the following line:
++
++ \qml
++ import QtQml.XmlListModel
++ \endqml
++ */
++
++ /*!
++ \qmltype XmlListModelRole
++ \nativetype QQmlXmlListModelRole
++ \inqmlmodule QtQml.XmlListModel
++ \brief For specifying a role to an \l XmlListModel.
++
++ \sa {All QML Types}{Qt Qml}
++ */
++
++ /*!
++ \qmlproperty string QtQml.XmlListModel::XmlListModelRole::name
++
++ The name for the role. This name is used to access the model data for this
++ role.
++
++ For example, the following model has a role named "title", which can be
++ accessed from the view's delegate:
++
++ \qml
++ XmlListModel {
++ id: xmlModel
++ source: "file.xml"
++ query: "/documents/document"
++ XmlListModelRole { name: "title"; elementName: "title" }
++ }
++ \endqml
++
++ \qml
++ ListView {
++ model: xmlModel
++ delegate: Text { text: title }
++ }
++ \endqml
++ */
++ QString QQmlXmlListModelRole::name() const
++ {
++ return m_name;
++ }
++
++ void QQmlXmlListModelRole::setName(const QString &name)
++ {
++ if (name == m_name)
++ return;
++ m_name = name;
++ Q_EMIT nameChanged();
++ }
++
++ /*!
++ \qmlproperty string QtQml.XmlListModel::XmlListModelRole::elementName
++
++ The name of the XML element, or a path to the XML element, that will be
++ used to read the data. The element must actually contain text.
++
++ Optionally the \l attributeName property can be specified to extract
++ the data.
++
++ //! [basic-example]
++ For example, the following model has a role named "title", which reads the
++ data from the XML element \c {<title>}. It also has another role named
++ "timestamp", which uses the same XML element \c {<title>}, but reads its
++ "created" attribute to extract the actual value.
++
++ \qml
++ XmlListModel {
++ id: xmlModel
++ source: "file.xml"
++ query: "/documents/document"
++ XmlListModelRole { name: "title"; elementName: "title" }
++ XmlListModelRole {
++ name: "timestamp"
++ elementName: "title"
++ attributeName: "created"
++ }
++ }
++
++ ListView {
++ anchors.fill: parent
++ model: xmlModel
++ delegate: Text { text: title + " created on " + timestamp }
++ }
++ \endqml
++ //! [basic-example]
++
++ //! [empty-elementName-example]
++ When the \l attributeName is specified, the \l elementName can be left
++ empty. In this case the attribute of the top level XML element of the query
++ will be read.
++
++ For example, if you have the following xml document:
++
++ \code
++ <documents>
++ <document title="Title1"/>
++ <document title="Title2"/>
++ </documents>
++ \endcode
++
++ To extract the document titles you need the following model:
++
++ \qml
++ XmlListModel {
++ id: xmlModel
++ source: "file.xml"
++ query: "/documents/document"
++ XmlListModelRole {
++ name: "title"
++ elementName: ""
++ attributeName: "title"
++ }
++ }
++ \endqml
++ //! [empty-elementName-example]
++
++ The elementName property can actually contain a path to the nested xml
++ element. All the elements in the path must be joined with the \c {'/'}
++ character.
++
++ For example, if you have the following xml document:
++ \code
++ <documents>
++ <document>
++ <title>Title1</title>
++ <info>
++ <num_pages>10</num_pages>
++ </info>
++ </document>
++ <document>
++ <title>Title2</title>
++ <info>
++ <num_pages>20</num_pages>
++ </info>
++ </document>
++ </documents>
++ \endcode
++
++ You can extract the number of pages with the following role:
++
++ \qml
++ XmlListModel {
++ id: xmlModel
++ source: "file.xml"
++ query: "/documents/document"
++ // ...
++ XmlListModelRole {
++ name: "pages"
++ elementName: "info/num_pages"
++ }
++ }
++ \endqml
++
++ \note The path to the element must not start or end with \c {'/'}.
++
++ \sa attributeName
++ */
++ QString QQmlXmlListModelRole::elementName() const
++ {
++ return m_elementName;
++ }
++
++ void QQmlXmlListModelRole::setElementName(const QString &name)
++ {
++ if (name.startsWith(QLatin1Char('/'))) {
++ qmlWarning(this) << tr("An XML element must not start with '/'");
++ return;
++ } else if (name.endsWith(QLatin1Char('/'))) {
++ qmlWarning(this) << tr("An XML element must not end with '/'");
++ return;
++ } else if (name.contains(QStringLiteral("//"))) {
++ qmlWarning(this) << tr("An XML element must not contain \"//\"");
++ return;
++ }
++
++ if (name == m_elementName)
++ return;
++ m_elementName = name;
++ Q_EMIT elementNameChanged();
++ }
++
++ /*!
++ \qmlproperty string QtQml.XmlListModel::XmlListModelRole::attributeName
++
++ The attribute of the XML element that will be used to read the data.
++ The XML element is specified by \l elementName property.
++
++ \include qqmlxmllistmodel.cpp basic-example
++
++ \include qqmlxmllistmodel.cpp empty-elementName-example
++
++ If you do not need to parse any attributes for the specified XML element,
++ simply leave this property blank.
++
++ \sa elementName
++ */
++ QString QQmlXmlListModelRole::attributeName() const
++ {
++ return m_attributeName;
++ }
++
++ void QQmlXmlListModelRole::setAttributeName(const QString &attributeName)
++ {
++ if (m_attributeName == attributeName)
++ return;
++ m_attributeName = attributeName;
++ Q_EMIT attributeNameChanged();
++ }
++
++ bool QQmlXmlListModelRole::isValid() const
++ {
++ return !m_name.isEmpty();
++ }
++
++ /*!
++ \qmltype XmlListModel
++ \nativetype QQmlXmlListModel
++ \inqmlmodule QtQml.XmlListModel
++ \brief For specifying a read-only model using XML data.
++
++ To use this element, you will need to import the module with the following line:
++ \code
++ import QtQml.XmlListModel
++ \endcode
++
++ XmlListModel is used to create a read-only model from XML data. It can be
++ used as a data source for view elements (such as ListView, PathView,
++ GridView) and other elements that interact with model data (such as
++ Repeater).
++
++ \note This model \b {does not} support the XPath queries. It supports simple
++ slash-separated paths and, optionally, one attribute for each element.
++
++ For example, if there is an XML document at https://www.qt.io/blog/rss.xml
++ like this:
++
++ \code
++ <?xml version="1.0" encoding="UTF-8"?>
++ <rss version="2.0">
++ ...
++ <channel>
++ <item>
++ <title>Qt 6.0.2 Released</title>
++ <pubDate>Wed, 03 Mar 2021 12:40:43 GMT</pubDate>
++ </item>
++ <item>
++ <title>Qt 6.1 Beta Released</title>
++ <pubDate>Tue, 02 Mar 2021 13:05:47 GMT</pubDate>
++ </item>
++ <item>
++ <title>Qt Creator 4.14.1 released</title>
++ <pubDate>Wed, 24 Feb 2021 13:53:21 GMT</pubDate>
++ </item>
++ </channel>
++ </rss>
++ \endcode
++
++ A XmlListModel could create a model from this data, like this:
++
++ \qml
++ import QtQml.XmlListModel
++
++ XmlListModel {
++ id: xmlModel
++ source: "https://www.qt.io/blog/rss.xml"
++ query: "/rss/channel/item"
++
++ XmlListModelRole { name: "title"; elementName: "title" }
++ XmlListModelRole { name: "pubDate"; elementName: "pubDate" }
++ XmlListModelRole { name: "link"; elementName: "link" }
++ }
++ \endqml
++
++ The \l {XmlListModel::query}{query} value of "/rss/channel/item" specifies
++ that the XmlListModel should generate a model item for each \c {<item>} in
++ the XML document.
++
++ The \l [QML] {XmlListModelRole} objects define the model item attributes.
++ Here, each model item will have \c title, \c pubDate and \c link attributes
++ that match the \c title, \c pubDate and \c link values of its corresponding
++ \c {<item>}.
++ (See \l [QML] {XmlListModelRole} documentation for more examples.)
++
++ The model could be used in a ListView, like this:
++
++ \qml
++ ListView {
++ width: 180; height: 300
++ model: xmlModel
++ delegate: Text { text: title + ": " + pubDate + "; link: " + link }
++ }
++ \endqml
++
++ The \l XmlListModel data is loaded asynchronously, and \l status
++ is set to \c XmlListModel.Ready when loading is complete.
++ Note this means when \l XmlListModel is used for a view, the view is not
++ populated until the model is loaded.
++ */
++
++ QQmlXmlListModel::QQmlXmlListModel(QObject *parent) : QAbstractListModel(parent) { }
++
++ QQmlXmlListModel::~QQmlXmlListModel()
++ {
++ // Cancel all objects
++ for (auto &w : m_watchers.values())
++ w->cancel();
++ // Wait until all objects are finished
++ while (!m_watchers.isEmpty()) {
++ auto it = m_watchers.begin();
++ it.value()->waitForFinished();
++ // Explicitly delete the watcher here, because the connected lambda
++ // would not be called until processEvents() is called
++ delete it.value();
++ m_watchers.erase(it);
++ }
++ }
++
++ QModelIndex QQmlXmlListModel::index(int row, int column, const QModelIndex &parent) const
++ {
++ return !parent.isValid() && column == 0 && row >= 0 && m_size ? createIndex(row, column)
++ : QModelIndex();
++ }
++
++ int QQmlXmlListModel::rowCount(const QModelIndex &parent) const
++ {
++ return !parent.isValid() ? m_size : 0;
++ }
++
++ QVariant QQmlXmlListModel::data(const QModelIndex &index, int role) const
++ {
++ const int roleIndex = m_roles.indexOf(role);
++ return (roleIndex == -1 || !index.isValid()) ? QVariant()
++ : m_data.value(index.row()).value(roleIndex);
++ }
++
++ QHash<int, QByteArray> QQmlXmlListModel::roleNames() const
++ {
++ QHash<int, QByteArray> roleNames;
++ for (int i = 0; i < m_roles.size(); ++i)
++ roleNames.insert(m_roles.at(i), m_roleNames.at(i).toUtf8());
++ return roleNames;
++ }
++
++ /*!
++ \qmlproperty int QtQml.XmlListModel::XmlListModel::count
++ The number of data entries in the model.
++ */
++ int QQmlXmlListModel::count() const
++ {
++ return m_size;
++ }
++
++ /*!
++ \qmlproperty url QtQml.XmlListModel::XmlListModel::source
++ The location of the XML data source.
++ */
++ QUrl QQmlXmlListModel::source() const
++ {
++ return m_source;
++ }
++
++ void QQmlXmlListModel::setSource(const QUrl &src)
++ {
++ if (m_source != src) {
++ m_source = src;
++ reload();
++ Q_EMIT sourceChanged();
++ }
++ }
++
++ /*!
++ \qmlproperty string QtQml.XmlListModel::XmlListModel::query
++ A string representing the base path for creating model items from this
++ model's \l [QML] {XmlListModelRole} objects. The query should start with
++ \c {'/'}.
++ */
++ QString QQmlXmlListModel::query() const
++ {
++ return m_query;
++ }
++
++ void QQmlXmlListModel::setQuery(const QString &query)
++ {
++ if (!query.startsWith(QLatin1Char('/'))) {
++ qmlWarning(this) << QCoreApplication::translate(
++ "XmlListModelRoleList", "An XmlListModel query must start with '/'");
++ return;
++ }
++
++ if (m_query != query) {
++ m_query = query;
++ reload();
++ Q_EMIT queryChanged();
++ }
++ }
++
++ /*!
++ \qmlproperty list<XmlListModelRole> QtQml.XmlListModel::XmlListModel::roles
++
++ The roles to make available for this model.
++ */
++ QQmlListProperty<QQmlXmlListModelRole> QQmlXmlListModel::roleObjects()
++ {
++ QQmlListProperty<QQmlXmlListModelRole> list(this, &m_roleObjects);
++ list.append = &QQmlXmlListModel::appendRole;
++ list.clear = &QQmlXmlListModel::clearRole;
++ return list;
++ }
++
++ void QQmlXmlListModel::appendRole(QQmlXmlListModelRole *role)
++ {
++ if (role) {
++ int i = m_roleObjects.size();
++ m_roleObjects.append(role);
++ if (m_roleNames.contains(role->name())) {
++ qmlWarning(role)
++ << QQmlXmlListModel::tr(
++ "\"%1\" duplicates a previous role name and will be disabled.")
++ .arg(role->name());
++ return;
++ }
++ m_roles.insert(i, m_highestRole);
++ m_roleNames.insert(i, role->name());
++ ++m_highestRole;
++ }
++ }
++
++ void QQmlXmlListModel::clearRole()
++ {
++ m_roles.clear();
++ m_roleNames.clear();
++ m_roleObjects.clear();
++ }
++
++ void QQmlXmlListModel::appendRole(QQmlListProperty<QQmlXmlListModelRole> *list,
++ QQmlXmlListModelRole *role)
++ {
++ auto object = qobject_cast<QQmlXmlListModel *>(list->object);
++ if (object) // role is checked inside appendRole
++ object->appendRole(role);
++ }
++
++ void QQmlXmlListModel::clearRole(QQmlListProperty<QQmlXmlListModelRole> *list)
++ {
++ auto object = qobject_cast<QQmlXmlListModel *>(list->object);
++ if (object)
++ object->clearRole();
++ }
++
++ void QQmlXmlListModel::tryExecuteQuery(const QByteArray &data)
++ {
++ auto job = createJob(data);
++ m_queryId = job.queryId;
++ QQmlXmlListModelQueryRunnable *runnable = new QQmlXmlListModelQueryRunnable(std::move(job));
++ if (runnable) {
++ auto future = runnable->future();
++ auto *watcher = new ResultFutureWatcher();
++ // No need to connect to canceled signal, because it just notifies that
++ // QFuture::cancel() was called. We will get the finished() signal in
++ // both cases.
++ connect(watcher, &ResultFutureWatcher::finished, this, [id = m_queryId, this]() {
++ auto *watcher = static_cast<ResultFutureWatcher *>(sender());
++ if (watcher) {
++ if (!watcher->isCanceled()) {
++ QQmlXmlListModelQueryResult result = watcher->result();
++ // handle errors
++ for (const auto &errorInfo : result.errors)
++ queryError(errorInfo.first, errorInfo.second);
++ // fill results
++ queryCompleted(result);
++ }
++ // remove from watchers
++ m_watchers.remove(id);
++ watcher->deleteLater();
++ }
++ });
++ m_watchers[m_queryId] = watcher;
++ watcher->setFuture(future);
++ QThreadPool::globalInstance()->start(runnable);
++ } else {
++ m_errorString = tr("Failed to create an instance of QRunnable query object");
++ m_status = QQmlXmlListModel::Error;
++ m_queryId = -1;
++ Q_EMIT statusChanged(m_status);
++ }
++ }
++
++ QQmlXmlListModelQueryJob QQmlXmlListModel::createJob(const QByteArray &data)
++ {
++ QQmlXmlListModelQueryJob job;
++ job.queryId = nextQueryId();
++ job.data = data;
++ job.query = m_query;
++
++ for (int i = 0; i < m_roleObjects.size(); i++) {
++ if (!m_roleObjects.at(i)->isValid()) {
++ job.roleNames << QString();
++ job.elementNames << QString();
++ job.elementAttributes << QString();
++ continue;
++ }
++ job.roleNames << m_roleObjects.at(i)->name();
++ job.elementNames << m_roleObjects.at(i)->elementName();
++ job.elementAttributes << m_roleObjects.at(i)->attributeName();
++ job.roleQueryErrorId << static_cast<void *>(m_roleObjects.at(i));
++ }
++
++ return job;
++ }
++
++ int QQmlXmlListModel::nextQueryId()
++ {
++ m_nextQueryIdGenerator++;
++ if (m_nextQueryIdGenerator <= 0)
++ m_nextQueryIdGenerator = 1;
++ return m_nextQueryIdGenerator;
++ }
++
++ /*!
++ \qmlproperty enumeration QtQml.XmlListModel::XmlListModel::status
++ Specifies the model loading status, which can be one of the following:
++
++ \value XmlListModel.Null No XML data has been set for this model.
++ \value XmlListModel.Ready The XML data has been loaded into the model.
++ \value XmlListModel.Loading The model is in the process of reading and
++ loading XML data.
++ \value XmlListModel.Error An error occurred while the model was loading. See
++ \l errorString() for details about the error.
++
++ \sa progress
++ */
++ QQmlXmlListModel::Status QQmlXmlListModel::status() const
++ {
++ return m_status;
++ }
++
++ /*!
++ \qmlproperty real QtQml.XmlListModel::XmlListModel::progress
++
++ This indicates the current progress of the downloading of the XML data
++ source. This value ranges from 0.0 (no data downloaded) to
++ 1.0 (all data downloaded). If the XML data is not from a remote source,
++ the progress becomes 1.0 as soon as the data is read.
++
++ Note that when the progress is 1.0, the XML data has been downloaded, but
++ it is yet to be loaded into the model at this point. Use the status
++ property to find out when the XML data has been read and loaded into
++ the model.
++
++ \sa status, source
++ */
++ qreal QQmlXmlListModel::progress() const
++ {
++ return m_progress;
++ }
++
++ /*!
++ \qmlmethod string QtQml.XmlListModel::XmlListModel::errorString()
++
++ Returns a string description of the last error that occurred
++ if \l status is \l {XmlListModel}.Error.
++ */
++ QString QQmlXmlListModel::errorString() const
++ {
++ return m_errorString;
++ }
++
++ void QQmlXmlListModel::classBegin()
++ {
++ m_isComponentComplete = false;
++ }
++
++ void QQmlXmlListModel::componentComplete()
++ {
++ m_isComponentComplete = true;
++ reload();
++ }
++
++ /*!
++ \qmlmethod void QtQml.XmlListModel::XmlListModel::reload()
++
++ Reloads the model.
++ */
++ void QQmlXmlListModel::reload()
++ {
++ if (!m_isComponentComplete)
++ return;
++
++ if (m_queryId > 0 && m_watchers.contains(m_queryId))
++ m_watchers[m_queryId]->cancel();
++
++ m_queryId = -1;
++
++ if (m_size < 0)
++ m_size = 0;
++
++ #if QT_CONFIG(qml_network)
++ if (m_reply) {
++ m_reply->abort();
++ deleteReply();
++ }
++ #endif
++
++ const QQmlContext *context = qmlContext(this);
++ const auto resolvedSource = context ? context->resolvedUrl(m_source) : m_source;
++
++ if (resolvedSource.isEmpty()) {
++ m_queryId = 0;
++ notifyQueryStarted(false);
++ QTimer::singleShot(0, this, &QQmlXmlListModel::dataCleared);
++ } else if (QQmlFile::isLocalFile(resolvedSource)) {
++ QFile file(QQmlFile::urlToLocalFileOrQrc(resolvedSource));
++ const bool opened = file.open(QIODevice::ReadOnly);
++ if (!opened)
++ qWarning("Failed to open file %s: %s", qPrintable(file.fileName()),
++ qPrintable(file.errorString()));
++ QByteArray data = opened ? file.readAll() : QByteArray();
++ notifyQueryStarted(false);
++ if (data.isEmpty()) {
++ m_queryId = 0;
++ QTimer::singleShot(0, this, &QQmlXmlListModel::dataCleared);
++ } else {
++ tryExecuteQuery(data);
++ }
++ } else {
++ #if QT_CONFIG(qml_network)
++ notifyQueryStarted(true);
++ QNetworkRequest req(resolvedSource);
++ req.setRawHeader("Accept", "application/xml,*/*");
++ m_reply = qmlContext(this)->engine()->networkAccessManager()->get(req);
++
++ QObject::connect(m_reply, &QNetworkReply::finished, this,
++ &QQmlXmlListModel::requestFinished);
++ QObject::connect(m_reply, &QNetworkReply::downloadProgress, this,
++ &QQmlXmlListModel::requestProgress);
++ #else
++ m_queryId = 0;
++ notifyQueryStarted(false);
++ QTimer::singleShot(0, this, &QQmlXmlListModel::dataCleared);
++ #endif
++ }
++ }
++
++ #if QT_CONFIG(qml_network)
++ void QQmlXmlListModel::requestFinished()
++ {
++ if (m_reply->error() != QNetworkReply::NoError) {
++ m_errorString = m_reply->errorString();
++ deleteReply();
++
++ if (m_size > 0) {
++ beginRemoveRows(QModelIndex(), 0, m_size - 1);
++ m_data.clear();
++ m_size = 0;
++ endRemoveRows();
++ Q_EMIT countChanged();
++ }
++
++ m_status = Error;
++ m_queryId = -1;
++ Q_EMIT statusChanged(m_status);
++ } else {
++ QByteArray data = m_reply->readAll();
++ if (data.isEmpty()) {
++ m_queryId = 0;
++ QTimer::singleShot(0, this, &QQmlXmlListModel::dataCleared);
++ } else {
++ tryExecuteQuery(data);
++ }
++ deleteReply();
++
++ m_progress = 1.0;
++ Q_EMIT progressChanged(m_progress);
++ }
++ }
++
++ void QQmlXmlListModel::deleteReply()
++ {
++ if (m_reply) {
++ QObject::disconnect(m_reply, 0, this, 0);
++ m_reply->deleteLater();
++ m_reply = nullptr;
++ }
++ }
++ #endif
++
++ void QQmlXmlListModel::requestProgress(qint64 received, qint64 total)
++ {
++ if (m_status == Loading && total > 0) {
++ m_progress = qreal(received) / total;
++ Q_EMIT progressChanged(m_progress);
++ }
++ }
++
++ void QQmlXmlListModel::dataCleared()
++ {
++ QQmlXmlListModelQueryResult r;
++ r.queryId = 0;
++ queryCompleted(r);
++ }
++
++ void QQmlXmlListModel::queryError(void *object, const QString &error)
++ {
++ for (int i = 0; i < m_roleObjects.size(); i++) {
++ if (m_roleObjects.at(i) == static_cast<QQmlXmlListModelRole *>(object)) {
++ qmlWarning(m_roleObjects.at(i))
++ << QQmlXmlListModel::tr("Query error: \"%1\"").arg(error);
++ return;
++ }
++ }
++ qmlWarning(this) << QQmlXmlListModel::tr("Query error: \"%1\"").arg(error);
++ }
++
++ void QQmlXmlListModel::queryCompleted(const QQmlXmlListModelQueryResult &result)
++ {
++ if (result.queryId != m_queryId)
++ return;
++
++ int origCount = m_size;
++ bool sizeChanged = result.data.size() != m_size;
++
++ if (m_source.isEmpty())
++ m_status = Null;
++ else
++ m_status = Ready;
++ m_errorString.clear();
++ m_queryId = -1;
++
++ if (origCount > 0) {
++ beginRemoveRows(QModelIndex(), 0, origCount - 1);
++ endRemoveRows();
++ }
++ m_size = result.data.size();
++ m_data = result.data;
++
++ if (m_size > 0) {
++ beginInsertRows(QModelIndex(), 0, m_size - 1);
++ endInsertRows();
++ }
++
++ if (sizeChanged)
++ Q_EMIT countChanged();
++
++ Q_EMIT statusChanged(m_status);
++ }
++
++ void QQmlXmlListModel::notifyQueryStarted(bool remoteSource)
++ {
++ m_progress = remoteSource ? 0.0 : 1.0;
++ m_status = QQmlXmlListModel::Loading;
++ m_errorString.clear();
++ Q_EMIT progressChanged(m_progress);
++ Q_EMIT statusChanged(m_status);
++ }
++
++ static qsizetype findIndexOfName(const QStringList &elementNames, const QStringView &name,
++ qsizetype startIndex = 0)
++ {
++ for (auto idx = startIndex; idx < elementNames.size(); ++idx) {
++ if (elementNames[idx].startsWith(name))
++ return idx;
++ }
++ return -1;
++ }
++
++ QQmlXmlListModelQueryRunnable::QQmlXmlListModelQueryRunnable(QQmlXmlListModelQueryJob &&job)
++ : m_job(std::move(job))
++ {
++ setAutoDelete(true);
++ }
++
++ void QQmlXmlListModelQueryRunnable::run()
++ {
++ m_promise.start();
++ if (!m_promise.isCanceled()) {
++ QQmlXmlListModelQueryResult result;
++ result.queryId = m_job.queryId;
++ doQueryJob(&result);
++ m_promise.addResult(std::move(result));
++ }
++ m_promise.finish();
++ }
++
++ QFuture<QQmlXmlListModelQueryResult> QQmlXmlListModelQueryRunnable::future() const
++ {
++ return m_promise.future();
++ }
++
++ void QQmlXmlListModelQueryRunnable::doQueryJob(QQmlXmlListModelQueryResult *currentResult)
++ {
++ Q_ASSERT(m_job.queryId != -1);
++
++ QByteArray data(m_job.data);
++ QXmlStreamReader reader;
++ reader.addData(data);
++
++ QStringList items = m_job.query.split(QLatin1Char('/'), Qt::SkipEmptyParts);
++
++ while (!reader.atEnd() && !m_promise.isCanceled()) {
++ int i = 0;
++ while (i < items.size()) {
++ if (reader.readNextStartElement()) {
++ if (reader.name() == items.at(i)) {
++ if (i != items.size() - 1) {
++ i++;
++ continue;
++ } else {
++ processElement(currentResult, items.at(i), reader);
++ }
++ } else {
++ reader.skipCurrentElement();
++ }
++ }
++ if (reader.tokenType() == QXmlStreamReader::Invalid) {
++ reader.readNext();
++ break;
++ } else if (reader.hasError()) {
++ reader.raiseError();
++ break;
++ }
++ }
++ }
++ }
++
++ void QQmlXmlListModelQueryRunnable::processElement(QQmlXmlListModelQueryResult *currentResult,
++ const QString &element, QXmlStreamReader &reader)
++ {
++ if (!reader.isStartElement() || reader.name() != element)
++ return;
++
++ const QStringList &elementNames = m_job.elementNames;
++ const QStringList &attributes = m_job.elementAttributes;
++ QFlatMap<int, QString> results;
++
++ // First of all check all the empty element names. They might have
++ // attributes to be read from the current element
++ if (!reader.attributes().isEmpty()) {
++ for (auto index = 0; index < elementNames.size(); ++index) {
++ if (elementNames.at(index).isEmpty() && !attributes.at(index).isEmpty()) {
++ const QString &attribute = attributes.at(index);
++ if (reader.attributes().hasAttribute(attribute))
++ results[index] = reader.attributes().value(attribute).toString();
++ }
++ }
++ }
++
++ // After that we recursively search for the elements, considering that we
++ // can have nested element names in our model, and that the same element
++ // can be used multiple types (with different attributes, for example)
++ readSubTree(QString(), reader, results, ¤tResult->errors);
++
++ if (reader.hasError())
++ currentResult->errors.push_back(std::make_pair(this, reader.errorString()));
++
++ currentResult->data << results;
++ }
++
++ void QQmlXmlListModelQueryRunnable::readSubTree(const QString &prefix, QXmlStreamReader &reader,
++ QFlatMap<int, QString> &results,
++ QList<std::pair<void *, QString>> *errors)
++ {
++ const QStringList &elementNames = m_job.elementNames;
++ const QStringList &attributes = m_job.elementAttributes;
++ while (reader.readNextStartElement()) {
++ const auto name = reader.name();
++ const QString fullName =
++ prefix.isEmpty() ? name.toString() : (prefix + QLatin1Char('/') + name.toString());
++ qsizetype index = name.isEmpty() ? -1 : findIndexOfName(elementNames, fullName);
++ if (index >= 0) {
++ // We can have multiple roles with the same element name, but
++ // different attributes, so we need to cache the attributes and
++ // element text.
++ const auto elementAttributes = reader.attributes();
++ // We can read text only when the element actually contains it,
++ // otherwise it will be an error. It can also be used to check that
++ // we've reached the bottom level.
++ QString elementText;
++ bool elementTextRead = false;
++ while (index >= 0) {
++ // if the path matches completely, not just starts with, we
++ // need to actually extract value
++ if (elementNames[index] == fullName) {
++ QString roleResult;
++ const QString &attribute = attributes.at(index);
++ if (!attribute.isEmpty()) {
++ if (elementAttributes.hasAttribute(attribute)) {
++ roleResult = elementAttributes.value(attributes.at(index)).toString();
++ } else {
++ errors->push_back(std::make_pair(m_job.roleQueryErrorId.at(index),
++ QLatin1String("Attribute %1 not found")
++ .arg(attributes[index])));
++ }
++ } else if (!elementNames.at(index).isEmpty()) {
++ if (!elementTextRead) {
++ elementText =
++ reader.readElementText(QXmlStreamReader::IncludeChildElements);
++ elementTextRead = true;
++ }
++ roleResult = elementText;
++ }
++ results[index] = roleResult;
++ }
++ // search for the next role with the same element name
++ index = findIndexOfName(elementNames, fullName, index + 1);
++ }
++ if (!elementTextRead)
++ readSubTree(fullName, reader, results, errors);
++ } else {
++ reader.skipCurrentElement();
++ }
++ }
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qqmlxmllistmodel_p.cpp"