Revision control
++ // Copyright (C) 2022 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
++ // Qt-Security score:significant reason:default
++
++ #include "qdeclarativesearchresultmodel_p.h"
++ #include "qdeclarativeplace_p.h"
++
++ #include <QtQml/QQmlEngine>
++ #include <QtQml/QQmlInfo>
++ #include <QtLocation/QGeoServiceProvider>
++ #include <QtLocation/QPlaceSearchReply>
++ #include <QtLocation/QPlaceManager>
++ #include <QtLocation/QPlaceMatchRequest>
++ #include <QtLocation/QPlaceMatchReply>
++ #include <QtLocation/QPlaceResult>
++ #include <QtLocation/QPlaceProposedSearchResult>
++ #include <QtLocation/private/qplacesearchrequest_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \qmltype PlaceSearchModel
++ \nativetype QDeclarativeSearchResultModel
++ \inqmlmodule QtLocation
++ \ingroup qml-QtLocation5-places
++ \ingroup qml-QtLocation5-places-models
++ \since QtLocation 5.5
++
++ \brief Provides access to place search results.
++
++ PlaceSearchModel provides a model of place search results within the \l searchArea. The
++ \l searchTerm and \l categories properties can be set to restrict the search results to
++ places matching those criteria.
++
++ The PlaceSearchModel returns both sponsored and
++ \l {http://en.wikipedia.org/wiki/Organic_search}{organic search results}. Sponsored search
++ results will have the \c sponsored role set to true.
++
++ \target PlaceSearchModel Roles
++ The model returns data for the following roles:
++
++ \table
++ \header
++ \li Role
++ \li Type
++ \li Description
++ \row
++ \li type
++ \li enum
++ \li The type of search result.
++ \row
++ \li title
++ \li string
++ \li A string describing the search result.
++ \row
++ \li icon
++ \li PlaceIcon
++ \li Icon representing the search result.
++ \row
++ \li distance
++ \li real
++ \li Valid only when the \c type role is \c PlaceResult, the distance to the place
++ from the center of the \l searchArea. If no \l searchArea
++ has been specified, the distance is NaN.
++ \row
++ \li place
++ \li \l Place
++ \li Valid only when the \c type role is \c PlaceResult, an object representing the
++ place.
++ \row
++ \li sponsored
++ \li bool
++ \li Valid only when the \c type role is \c PlaceResult, true if the search result is a
++ sponsored result.
++ \endtable
++
++ \section2 Search Result Types
++
++ The \c type role can take on the following values:
++
++ \table
++ \row
++ \li PlaceSearchModel.UnknownSearchResult
++ \li The contents of the search result are unknown.
++ \row
++ \li PlaceSearchModel.PlaceResult
++ \li The search result contains a place.
++ \row
++ \li PlaceSearchModel.ProposedSearchResult
++ \li The search result contains a proposed search which may be relevant.
++ \endtable
++
++
++ It can often be helpful to use a \l Loader to create a delegate
++ that will choose different \l {Component}s based on the search result type.
++
++ \snippet declarative/places_loader.qml Handle Result Types
++
++ \section1 Detection of Updated and Removed Places
++
++ The PlaceSearchModel listens for places that have been updated or removed from its plugin's backend.
++ If it detects that a place has been updated and that place is currently present in the model, then
++ it will call \l Place::getDetails to refresh the details. If it detects that a place has been
++ removed, then correspondingly the place will be removed from the model if it is currently
++ present.
++
++ \section1 Example
++
++ The following example shows how to use the PlaceSearchModel to search for Pizza restaurants in
++ close proximity of a given position. A \l searchTerm and \l searchArea are provided to the model
++ and \l update() is used to perform a lookup query. Note that the model does not incrementally
++ fetch search results, but rather performs a single fetch when \l update() is run. The \l count
++ is set to the number of search results returned during the fetch.
++
++ \snippet places_list/places_list.qml Imports
++ \codeline
++ \snippet places_list/places_list.qml PlaceSearchModel
++
++ \sa CategoryModel, {QPlaceManager}
++
++ \section1 Paging
++ The PlaceSearchModel API has some limited support
++ for paging. The \l nextPage() and \l previousPage() functions as well as
++ the \l limit property can be used to access
++ paged search results. When the \l limit property is set
++ the search result page contains at most \l limit entries (of type place result).
++ For example, if the backend has 5 search results in total
++ [a,b,c,d,e], and assuming the first page is shown and limit of 3 has been set
++ then a,b,c is returned. The \l nextPage() would return d,e. The
++ \l nextPagesAvailable and \l previousPagesAvailable properties
++ can be used to check for further pages. At the moment the API does not
++ support the means to retrieve the total number of items available from the
++ backed. Note that support for \l nextPage(), previousPage() and \l limit can vary
++ according to the \l plugin.
++ */
++
++ /*!
++ \qmlproperty Plugin PlaceSearchModel::plugin
++
++ This property holds the \l Plugin which will be used to perform the search.
++ */
++
++ /*!
++ \qmlproperty Plugin PlaceSearchModel::favoritesPlugin
++
++ This property holds the \l Plugin which will be used to search for favorites.
++ Any places from the search which can be cross-referenced or matched
++ in the favoritesPlugin will have their \l {Place::favorite}{favorite} property
++ set to the corresponding \l Place from the favoritesPlugin.
++
++ If the favoritesPlugin is not set, the \l {Place::favorite}{favorite} property
++ of the places in the results will always be null.
++
++ \sa Favorites
++ */
++
++ /*!
++ \qmlproperty VariantMap PlaceSearchModel::favoritesMatchParameters
++
++ This property holds a set of parameters used to specify how search result places
++ are matched to favorites in the favoritesPlugin.
++
++ By default the parameter map is empty and implies that the favorites plugin
++ matches by \l {Alternative Identifier Cross-Referencing}{alternative identifiers}. Generally,
++ an application developer will not need to set this property.
++
++ In cases where the favorites plugin does not support matching by alternative identifiers,
++ then the \l {Qt Location#Plugin References and Parameters}{plugin documentation} should
++ be consulted to see precisely what key-value parameters to set.
++ */
++
++ /*!
++ \qmlproperty variant PlaceSearchModel::searchArea
++
++ This property holds the search area. The search result returned by the model will be within
++ the search area.
++
++ If this property is set to a \l {geoCircle} its
++ \l {geoCircle}{radius} property may be left unset, in which case the \l Plugin
++ will choose an appropriate radius for the search.
++
++ Support for specifying a search area can vary according to the \l plugin backend
++ implementation. For example, some may support a search center only while others may only
++ support geo rectangles.
++ */
++
++ /*!
++ \qmlproperty int PlaceSearchModel::limit
++
++ This property holds the limit of the number of items that will be returned.
++ */
++
++ /*!
++ \qmlproperty bool PlaceSearchModel::previousPagesAvailable
++
++ This property holds whether there is one or more previous pages of search results available.
++
++ \sa previousPage()
++ */
++
++ /*!
++ \qmlproperty bool PlaceSearchModel::nextPagesAvailable
++
++ This property holds whether there is one or more additional pages of search results available.
++
++ \sa nextPage()
++ */
++
++ /*!
++ \qmlproperty enum PlaceSearchModel::status
++
++ This property holds the status of the model. It can be one of:
++
++ \table
++ \row
++ \li PlaceSearchModel.Null
++ \li No search query has been executed. The model is empty.
++ \row
++ \li PlaceSearchModel.Ready
++ \li The search query has completed, and the results are available.
++ \row
++ \li PlaceSearchModel.Loading
++ \li A search query is currently being executed.
++ \row
++ \li PlaceSearchModel.Error
++ \li An error occurred when executing the previous search query.
++ \endtable
++ */
++
++ /*!
++ \qmlproperty bool PlaceSearchModel::incremental
++
++ This property controls how paging will affect the PlaceSearchModel.
++ If true, calling \l previousPage or \l nextPage will not reset the model,
++ but new results will instead be appended to the model.
++ Default is false.
++
++ \since QtLocation 5.12
++ */
++
++
++ /*!
++ \qmlmethod void PlaceSearchModel::update()
++
++ Updates the model based on the provided query parameters. The model will be populated with a
++ list of places matching the search parameters specified by the type's properties. Search
++ criteria is specified by setting properties such as the \l searchTerm, \l categories, \l searchArea and \l limit.
++ Support for these properties may vary according to \l plugin. \c update() then
++ submits the set of criteria to the \l plugin to process.
++
++ While the model is updating the \l status of the model is set to
++ \c PlaceSearchModel.Loading. If the model is successfully updated the \l status is set to
++ \c PlaceSearchModel.Ready, while if it unsuccessfully completes, the \l status is set to
++ \c PlaceSearchModel.Error and the model cleared.
++
++ \code
++ PlaceSearchModel {
++ id: model
++ plugin: backendPlugin
++ searchArea: QtPositioning.circle(QtPositioning.coordinate(10, 10))
++ ...
++ }
++
++ MouseArea {
++ ...
++ onClicked: {
++ model.searchTerm = "pizza";
++ model.categories = null; //not searching by any category
++ model.searchArea.center.latitude = -27.5;
++ model.searchArea.center.longitude = 153;
++ model.update();
++ }
++ }
++ \endcode
++
++ \sa cancel(), status
++ */
++
++ /*!
++ \qmlmethod void PlaceSearchModel::cancel()
++
++ Cancels an ongoing search operation immediately and sets the model
++ status to PlaceSearchModel.Ready. The model retains any search
++ results it had before the operation was started.
++
++ If an operation is not ongoing, invoking cancel() has no effect.
++
++ \sa update(), status
++ */
++
++ /*!
++ \qmlmethod void PlaceSearchModel::reset()
++
++ Resets the model. All search results are cleared, any outstanding requests are aborted and
++ possible errors are cleared. Model status will be set to PlaceSearchModel.Null.
++ */
++
++ /*!
++ \qmlmethod string PlaceSearchModel::errorString()
++
++ This read-only property holds the textual presentation of the latest place search model error.
++ If no error has occurred or if the model was cleared, an empty string is returned.
++
++ An empty string may also be returned if an error occurred which has no associated
++ textual representation.
++ */
++
++ /*!
++ \qmlmethod void PlaceSearchModel::previousPage()
++
++ Updates the model to display the previous page of search results. If there is no previous page
++ then this method does nothing.
++ */
++
++ /*!
++ \qmlmethod void PlaceSearchModel::nextPage()
++
++ Updates the model to display the next page of search results. If there is no next page then
++ this method does nothing.
++ */
++
++ QDeclarativeSearchResultModel::QDeclarativeSearchResultModel(QObject *parent)
++ : QDeclarativeSearchModelBase(parent)
++ {
++ }
++
++ QDeclarativeSearchResultModel::~QDeclarativeSearchResultModel()
++ {
++ }
++
++ /*!
++ \qmlproperty string PlaceSearchModel::searchTerm
++
++ This property holds search term used in query. The search term is a free-form text string.
++ */
++ QString QDeclarativeSearchResultModel::searchTerm() const
++ {
++ return m_request.searchTerm();
++ }
++
++ void QDeclarativeSearchResultModel::setSearchTerm(const QString &searchTerm)
++ {
++ m_request.setSearchContext(QVariant());
++
++ if (m_request.searchTerm() == searchTerm)
++ return;
++
++ m_request.setSearchTerm(searchTerm);
++ emit searchTermChanged();
++ }
++
++ /*!
++ \qmlproperty list<Category> PlaceSearchModel::categories
++
++ This property holds a list of categories to be used when searching. Returned search results
++ will be for places that match at least one of the categories.
++ */
++ QQmlListProperty<QDeclarativeCategory> QDeclarativeSearchResultModel::categories()
++ {
++ return QQmlListProperty<QDeclarativeCategory>(this,
++ 0, // opaque data parameter
++ categories_append,
++ categories_count,
++ category_at,
++ categories_clear);
++ }
++
++ void QDeclarativeSearchResultModel::categories_append(QQmlListProperty<QDeclarativeCategory> *list,
++ QDeclarativeCategory *declCategory)
++ {
++ QDeclarativeSearchResultModel *searchModel = qobject_cast<QDeclarativeSearchResultModel *>(list->object);
++ if (searchModel && declCategory) {
++ searchModel->m_request.setSearchContext(QVariant());
++ searchModel->m_categories.append(declCategory);
++ QList<QPlaceCategory> categories = searchModel->m_request.categories();
++ categories.append(declCategory->category());
++ searchModel->m_request.setCategories(categories);
++ emit searchModel->categoriesChanged();
++ }
++ }
++
++ qsizetype QDeclarativeSearchResultModel::categories_count(QQmlListProperty<QDeclarativeCategory> *list)
++ {
++ QDeclarativeSearchResultModel *searchModel = qobject_cast<QDeclarativeSearchResultModel *>(list->object);
++ if (searchModel)
++ return searchModel->m_categories.count();
++ else
++ return -1;
++ }
++
++ QDeclarativeCategory *QDeclarativeSearchResultModel::category_at(QQmlListProperty<QDeclarativeCategory> *list,
++ qsizetype index)
++ {
++ QDeclarativeSearchResultModel *searchModel = qobject_cast<QDeclarativeSearchResultModel *>(list->object);
++ if (searchModel && (searchModel->m_categories.count() > index) && (index > -1))
++ return searchModel->m_categories.at(index);
++ return nullptr;
++ }
++
++ void QDeclarativeSearchResultModel::categories_clear(QQmlListProperty<QDeclarativeCategory> *list)
++ {
++ QDeclarativeSearchResultModel *searchModel = qobject_cast<QDeclarativeSearchResultModel *>(list->object);
++ if (searchModel) {
++ //note: we do not need to delete each of the objects in m_categories since the search model
++ //should never be the parent of the categories anyway.
++ searchModel->m_request.setSearchContext(QVariant());
++ searchModel->m_categories.clear();
++ searchModel->m_request.setCategories(QList<QPlaceCategory>());
++ emit searchModel->categoriesChanged();
++ }
++ }
++
++ /*!
++ \qmlproperty string PlaceSearchModel::recommendationId
++
++ This property holds the placeId to be used in order to find recommendations
++ for similar places.
++ */
++ QString QDeclarativeSearchResultModel::recommendationId() const
++ {
++ return m_request.recommendationId();
++ }
++
++ void QDeclarativeSearchResultModel::setRecommendationId(const QString &placeId)
++ {
++ if (m_request.recommendationId() == placeId)
++ return;
++
++ m_request.setRecommendationId(placeId);
++ emit recommendationIdChanged();
++ }
++
++ /*!
++ \qmlproperty enumeration PlaceSearchModel::relevanceHint
++
++ This property holds a relevance hint used in the search query. The hint is given to the
++ provider to help but not dictate the ranking of results. For example, the distance hint may
++ give closer places a higher ranking but it does not necessarily mean the results will be
++ strictly ordered according to distance. A provider may ignore the hint altogether.
++
++ \table
++ \row
++ \li SearchResultModel.UnspecifiedHint
++ \li No relevance hint is given to the provider.
++ \row
++ \li SearchResultModel.DistanceHint
++ \li The distance of the place from the user's current location is important to the user.
++ This hint is only meaningful when a circular search area is used.
++ \row
++ \li SearchResultModel.LexicalPlaceNameHint
++ \li The lexical ordering of place names (in ascending alphabetical order) is relevant to
++ the user. This hint is useful for providers based on a local data store.
++ \endtable
++ */
++ QDeclarativeSearchResultModel::RelevanceHint QDeclarativeSearchResultModel::relevanceHint() const
++ {
++ return static_cast<QDeclarativeSearchResultModel::RelevanceHint>(m_request.relevanceHint());
++ }
++
++ void QDeclarativeSearchResultModel::setRelevanceHint(QDeclarativeSearchResultModel::RelevanceHint hint)
++ {
++ if (m_request.relevanceHint() != static_cast<QPlaceSearchRequest::RelevanceHint>(hint)) {
++ m_request.setRelevanceHint(static_cast<QPlaceSearchRequest::RelevanceHint>(hint));
++ emit relevanceHintChanged();
++ }
++ }
++
++ /*!
++ \qmlproperty enum PlaceSearchModel::visibilityScope
++
++ This property holds the visibility scope of the places to search. Only places with the
++ specified visibility will be returned in the search results.
++
++ The visibility scope can be one of:
++
++ \table
++ \row
++ \li Place.UnspecifiedVisibility
++ \li No explicit visibility scope specified, places with any visibility may be part of
++ search results.
++ \row
++ \li Place.DeviceVisibility
++ \li Only places stored on the local device will be part of the search results.
++ \row
++ \li Place.PrivateVisibility
++ \li Only places that are private to the current user will be part of the search results.
++ \row
++ \li Place.PublicVisibility
++ \li Only places that are public will be part of the search results.
++ \endtable
++ */
++ QDeclarativePlace::Visibility QDeclarativeSearchResultModel::visibilityScope() const
++ {
++ return QDeclarativePlace::Visibility(int(m_visibilityScope));
++ }
++
++ void QDeclarativeSearchResultModel::setVisibilityScope(QDeclarativePlace::Visibility visibilityScope)
++ {
++ QLocation::VisibilityScope scope = QLocation::VisibilityScope(visibilityScope);
++
++ if (m_visibilityScope == scope)
++ return;
++
++ m_visibilityScope = scope;
++ emit visibilityScopeChanged();
++ }
++
++ /*!
++ \internal
++ */
++ QDeclarativeGeoServiceProvider *QDeclarativeSearchResultModel::favoritesPlugin() const
++ {
++ return m_favoritesPlugin;
++ }
++
++ /*!
++ \internal
++ */
++ void QDeclarativeSearchResultModel::setFavoritesPlugin(QDeclarativeGeoServiceProvider *plugin)
++ {
++
++ if (m_favoritesPlugin == plugin)
++ return;
++
++ m_favoritesPlugin = plugin;
++
++ if (m_favoritesPlugin) {
++ QGeoServiceProvider *serviceProvider = m_favoritesPlugin->sharedGeoServiceProvider();
++ if (serviceProvider) {
++ QPlaceManager *placeManager = serviceProvider->placeManager();
++ if (placeManager) {
++ if (placeManager->childCategoryIds().isEmpty()) {
++ QPlaceReply *reply = placeManager->initializeCategories();
++ connect(reply, &QPlaceReply::finished, reply, &QObject::deleteLater);
++ }
++ }
++ }
++ }
++
++ emit favoritesPluginChanged();
++ }
++
++ /*!
++ \internal
++ */
++ QVariantMap QDeclarativeSearchResultModel::favoritesMatchParameters() const
++ {
++ return m_matchParameters;
++ }
++
++ /*!
++ \internal
++ */
++ void QDeclarativeSearchResultModel::setFavoritesMatchParameters(const QVariantMap ¶meters)
++ {
++ if (m_matchParameters == parameters)
++ return;
++
++ m_matchParameters = parameters;
++ emit favoritesMatchParametersChanged();
++ }
++
++ /*!
++ \internal
++ */
++ int QDeclarativeSearchResultModel::rowCount(const QModelIndex &parent) const
++ {
++ Q_UNUSED(parent);
++
++ return m_results.count();
++ }
++
++ void QDeclarativeSearchResultModel::clearData(bool suppressSignal)
++ {
++ QDeclarativeSearchModelBase::clearData(suppressSignal);
++
++ qDeleteAll(m_places);
++ m_places.clear();
++ m_icons.clear();
++ if (!m_results.isEmpty()) {
++ m_results.clear();
++
++ if (!suppressSignal)
++ emit rowCountChanged();
++ }
++ }
++
++ QVariant QDeclarativeSearchResultModel::data(const QModelIndex &index, int role) const
++ {
++ if (index.row() > m_results.count())
++ return QVariant();
++
++ const QPlaceSearchResult &result = m_results.at(index.row());
++
++ switch (role) {
++ case SearchResultTypeRole:
++ return result.type();
++ case Qt::DisplayRole:
++ case TitleRole:
++ return result.title();
++ case IconRole:
++ return QVariant::fromValue(m_icons.at(index.row()));
++ case DistanceRole:
++ if (result.type() == QPlaceSearchResult::PlaceResult) {
++ QPlaceResult placeResult = result;
++ return placeResult.distance();
++ }
++ break;
++ case PlaceRole:
++ if (result.type() == QPlaceSearchResult::PlaceResult)
++ return QVariant::fromValue(static_cast<QObject *>(m_places.at(index.row())));
++ break;
++ case SponsoredRole:
++ if (result.type() == QPlaceSearchResult::PlaceResult) {
++ QPlaceResult placeResult = result;
++ return placeResult.isSponsored();
++ }
++ break;
++ }
++ return QVariant();
++ }
++
++ /*!
++ \internal
++ */
++ QVariant QDeclarativeSearchResultModel::data(int index, const QString &role) const
++ {
++ QModelIndex modelIndex = createIndex(index, 0);
++ return data(modelIndex, roleNames().key(role.toLatin1()));
++ }
++
++ QHash<int, QByteArray> QDeclarativeSearchResultModel::roleNames() const
++ {
++ QHash<int, QByteArray> roles = QDeclarativeSearchModelBase::roleNames();
++ roles.insert(SearchResultTypeRole, "type");
++ roles.insert(TitleRole, "title");
++ roles.insert(IconRole, "icon");
++ roles.insert(DistanceRole, "distance");
++ roles.insert(PlaceRole, "place");
++ roles.insert(SponsoredRole, "sponsored");
++
++ return roles;
++ }
++
++ /*!
++ \qmlmethod void PlaceSearchModel::updateWith(int proposedSearchIndex)
++
++ Updates the model based on the ProposedSearchResult at index \a proposedSearchIndex. The model
++ will be populated with a list of places matching the proposed search. Model status will be set
++ to PlaceSearchModel.Loading. If the model is updated successfully status will be set to
++ PlaceSearchModel.Ready. If an error occurs status will be set to PlaceSearchModel.Error and the
++ model cleared.
++
++ If \a proposedSearchIndex does not reference a ProposedSearchResult this method does nothing.
++ */
++ void QDeclarativeSearchResultModel::updateWith(int proposedSearchIndex)
++ {
++ if (m_results.at(proposedSearchIndex).type() != QPlaceSearchResult::ProposedSearchResult)
++ return;
++
++ m_request = QPlaceProposedSearchResult(m_results.at(proposedSearchIndex)).searchRequest();
++ update();
++ }
++
++ QPlaceReply *QDeclarativeSearchResultModel::sendQuery(QPlaceManager *manager,
++ const QPlaceSearchRequest &request)
++ {
++ Q_ASSERT(manager);
++ return manager->search(request);
++ }
++
++ /*!
++ \internal
++ */
++ void QDeclarativeSearchResultModel::initializePlugin(QDeclarativeGeoServiceProvider *plugin)
++ {
++ //disconnect the manager of the old plugin if we have one
++ if (m_plugin) {
++ QGeoServiceProvider *serviceProvider = m_plugin->sharedGeoServiceProvider();
++ if (serviceProvider) {
++ QPlaceManager *placeManager = serviceProvider->placeManager();
++ if (placeManager) {
++ disconnect(placeManager, &QPlaceManager::placeUpdated,
++ this, &QDeclarativeSearchResultModel::placeUpdated);
++ disconnect(placeManager, &QPlaceManager::placeRemoved,
++ this, &QDeclarativeSearchResultModel::placeRemoved);
++ connect(placeManager, &QPlaceManager::dataChanged,
++ this, &QDeclarativeSearchResultModel::dataChanged);
++ }
++ }
++ }
++
++ //connect to the manager of the new plugin.
++ if (plugin) {
++ QGeoServiceProvider *serviceProvider = plugin->sharedGeoServiceProvider();
++ if (serviceProvider) {
++ QPlaceManager *placeManager = serviceProvider->placeManager();
++ if (placeManager) {
++ connect(placeManager, &QPlaceManager::placeUpdated,
++ this, &QDeclarativeSearchResultModel::placeUpdated);
++ connect(placeManager, &QPlaceManager::placeRemoved,
++ this, &QDeclarativeSearchResultModel::placeRemoved);
++ disconnect(placeManager, &QPlaceManager::dataChanged,
++ this, &QDeclarativeSearchResultModel::dataChanged);
++ }
++ }
++ }
++ QDeclarativeSearchModelBase::initializePlugin(plugin);
++ }
++
++ /*!
++ \internal
++ */
++ void QDeclarativeSearchResultModel::queryFinished()
++ {
++ if (!m_reply)
++ return;
++ QPlaceReply *reply = m_reply;
++ m_reply = nullptr;
++ reply->deleteLater();
++
++ if (!m_incremental)
++ m_pages.clear();
++
++ if (reply->error() != QPlaceReply::NoError) {
++ m_resultsBuffer.clear();
++ updateLayout();
++ setStatus(Error, reply->errorString());
++ return;
++ }
++
++ if (reply->type() == QPlaceReply::SearchReply) {
++ QPlaceSearchReply *searchReply = qobject_cast<QPlaceSearchReply *>(reply);
++ Q_ASSERT(searchReply);
++
++ const QPlaceSearchRequestPrivate *rpimpl = QPlaceSearchRequestPrivate::get(searchReply->request());
++ if (!rpimpl->related || !m_incremental)
++ m_pages.clear();
++ m_resultsBuffer = searchReply->results();
++ bool alreadyLoaded = false;
++ if (m_pages.contains(rpimpl->page) && m_resultsBuffer == m_pages.value(rpimpl->page))
++ alreadyLoaded = true;
++ m_pages.insert(rpimpl->page, m_resultsBuffer);
++ setPreviousPageRequest(searchReply->previousPageRequest());
++ setNextPageRequest(searchReply->nextPageRequest());
++
++ // Performing favorite matching only upon finished()
++ if (!m_favoritesPlugin) {
++ updateLayout();
++ setStatus(Ready);
++ } else {
++ QGeoServiceProvider *serviceProvider = m_favoritesPlugin->sharedGeoServiceProvider();
++ if (!serviceProvider) {
++ updateLayout();
++ setStatus(Error, QStringLiteral("Favorites plugin returns a null QGeoServiceProvider instance"));
++ return;
++ }
++
++ QPlaceManager *favoritesManager = serviceProvider->placeManager();
++ if (!favoritesManager) {
++ updateLayout();
++ setStatus(Error, QStringLiteral("Favorites plugin returns a null QPlaceManager"));
++ return;
++ }
++
++ QPlaceMatchRequest request;
++ if (m_matchParameters.isEmpty()) {
++ if (!m_plugin) {
++ setStatus(Error, QStringLiteral("Plugin not assigned"));
++ return;
++ }
++
++ QVariantMap params;
++ params.insert(QPlaceMatchRequest::AlternativeId, QVariant(QString::fromLatin1("x_id_") + m_plugin->name()));
++ request.setParameters(params);
++ } else {
++ request.setParameters(m_matchParameters);
++ }
++
++ request.setResults(m_resultsBuffer);
++ if (alreadyLoaded)
++ m_resultsBuffer.clear();
++ m_reply = favoritesManager->matchingPlaces(request);
++ connect(m_reply, &QPlaceReply::finished,
++ this, &QDeclarativeSearchResultModel::queryFinished);
++ connect(m_reply, &QPlaceReply::contentUpdated,
++ this, &QDeclarativeSearchResultModel::onContentUpdated);
++ }
++ } else if (reply->type() == QPlaceReply::MatchReply) {
++ QPlaceMatchReply *matchReply = qobject_cast<QPlaceMatchReply *>(reply);
++ Q_ASSERT(matchReply);
++ updateLayout(matchReply->places());
++ setStatus(Ready);
++ } else {
++ setStatus(Error, QStringLiteral("Unknown reply type"));
++ }
++ }
++
++ void QDeclarativeSearchResultModel::onContentUpdated()
++ {
++ if (!m_reply)
++ return;
++
++ QPlaceReply *reply = m_reply; // not finished, don't delete.
++
++ if (!m_incremental)
++ m_pages.clear();
++
++ if (reply->error() != QPlaceReply::NoError) {
++ m_resultsBuffer.clear();
++ updateLayout();
++ setStatus(Error, reply->errorString());
++ return;
++ }
++
++ if (reply->type() == QPlaceReply::SearchReply) {
++ QPlaceSearchReply *searchReply = qobject_cast<QPlaceSearchReply *>(reply);
++ Q_ASSERT(searchReply);
++
++ const QPlaceSearchRequestPrivate *rpimpl = QPlaceSearchRequestPrivate::get(searchReply->request());
++ if (!rpimpl->related || !m_incremental)
++ m_pages.clear();
++ m_resultsBuffer = searchReply->results();
++ if (!(m_pages.contains(rpimpl->page) && m_resultsBuffer == m_pages.value(rpimpl->page))) {
++ m_pages.insert(rpimpl->page, m_resultsBuffer);
++ updateLayout();
++ }
++ } else if (reply->type() == QPlaceReply::MatchReply) {
++ // ToDo: handle incremental match replies
++ } else {
++ setStatus(Error, QStringLiteral("Unknown reply type"));
++ }
++ }
++
++ /*!
++ \qmlmethod Variant PlaceSearchModel::data(int index, string role)
++
++ Returns the data for a given \a role at the specified row \a index.
++ */
++
++ /*!
++ \qmlproperty int PlaceSearchModel::count
++
++ This property holds the number of results the model has.
++
++ Note that it does not refer to the total number of search results
++ available in the backend. The total number of search results
++ is not currently supported by the API.
++ */
++
++ /*!
++ \internal
++ Note: m_results buffer should be correctly populated before
++ calling this function
++ */
++ void QDeclarativeSearchResultModel::updateLayout(const QList<QPlace> &favoritePlaces)
++ {
++ const int oldRowCount = rowCount();
++ int start = 0;
++
++ if (m_incremental) {
++ if (!m_resultsBuffer.size())
++ return;
++
++ beginInsertRows(QModelIndex(), oldRowCount , oldRowCount + m_resultsBuffer.size() - 1);
++ m_results = resultsFromPages();
++ start = oldRowCount;
++ } else {
++ beginResetModel();
++ clearData(true);
++ m_results = m_resultsBuffer;
++ }
++
++ m_resultsBuffer.clear();
++ for (qsizetype i = start; i < m_results.count(); ++i) {
++ const QPlaceSearchResult &result = m_results.at(i);
++
++ if (result.type() == QPlaceSearchResult::PlaceResult) {
++ QPlaceResult placeResult = result;
++ QDeclarativePlace *place = new QDeclarativePlace(placeResult.place(), plugin(), this);
++ m_places.append(place);
++
++ if ((favoritePlaces.count() == m_results.count()) && favoritePlaces.at(i) != QPlace())
++ m_places[i]->setFavorite(new QDeclarativePlace(favoritePlaces.at(i),
++ m_favoritesPlugin, m_places[i]));
++ } else if (result.type() == QPlaceSearchResult::ProposedSearchResult) {
++ m_places.append(0);
++ }
++
++ if (!result.icon().isEmpty())
++ m_icons.append(result.icon());
++ }
++
++ if (m_incremental)
++ endInsertRows();
++ else
++ endResetModel();
++ if (m_results.count() != oldRowCount)
++ emit rowCountChanged();
++ }
++
++ /*!
++ \internal
++ */
++ void QDeclarativeSearchResultModel::placeUpdated(const QString &placeId)
++ {
++ int row = getRow(placeId);
++ if (row < 0 || row > m_places.count())
++ return;
++
++ if (m_places.at(row))
++ m_places.at(row)->getDetails();
++ }
++
++ /*!
++ \internal
++ */
++ void QDeclarativeSearchResultModel::placeRemoved(const QString &placeId)
++ {
++ int row = getRow(placeId);
++ if (row < 0 || row > m_places.count())
++ return;
++
++ beginRemoveRows(QModelIndex(), row, row);
++ delete m_places.at(row);
++ m_places.removeAt(row);
++ m_results.removeAt(row);
++ removePageRow(row);
++ endRemoveRows();
++
++ emit rowCountChanged();
++ }
++
++ QList<QPlaceSearchResult> QDeclarativeSearchResultModel::resultsFromPages() const
++ {
++ QList<QPlaceSearchResult> res;
++ for (const auto &e : m_pages)
++ res.append(e);
++ return res;
++ }
++
++ void QDeclarativeSearchResultModel::removePageRow(int row)
++ {
++ int scanned = 0;
++ for (auto i = m_pages.begin(), end = m_pages.end(); i != end; ++i) {
++ QList<QPlaceSearchResult> &page = i.value();
++ scanned += page.size();
++ if (row >= scanned)
++ continue;
++ page.removeAt(row - scanned + page.size());
++ return;
++ }
++ }
++
++ /*!
++ \internal
++ */
++ int QDeclarativeSearchResultModel::getRow(const QString &placeId) const
++ {
++ for (qsizetype i = 0; i < m_places.count(); ++i) {
++ if (!m_places.at(i))
++ continue;
++ else if (m_places.at(i)->placeId() == placeId)
++ return i;
++ }
++
++ return -1;
++ }
++
++ /*!
++ \qmlsignal PlaceSearchModel::dataChanged()
++
++ This signal is emitted when significant changes have been made to the underlying datastore.
++
++ Applications should act on this signal at their own discretion. The data
++ provided by the model could be out of date and so the model should be reupdated
++ sometime, however an immediate reupdate may be disconcerting to users if the results
++ change without any action on their part.
++
++ The corresponding handler is \c onDataChanged.
++ */
++
++ QT_END_NAMESPACE