File indexing completed on 2024-05-12 04:42:52

 /*
     SPDX-FileCopyrightText: 2019 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "locationquerymodel.h"
 #include "abstractquerymodel_p.h"
 #include "logging.h"
 #include "../datatypes/locationutil_p.h"
 
 #include <KPublicTransport/Attribution>
 #include <KPublicTransport/Location>
 #include <KPublicTransport/LocationReply>
 #include <KPublicTransport/Manager>
 
 #include <QDebug>
 
 using namespace KPublicTransport;
 
 namespace KPublicTransport {
 class LocationQueryModelPrivate : public AbstractQueryModelPrivate
 {
 public:
     void doQuery() override;
     void doClearResults() override;
     void mergeResults(const std::vector<Location> &newLocations);
     bool isFiltered(const Location &loc) const;
 
     std::vector<Location> m_locations;
 
     LocationRequest m_request;
 
     Q_DECLARE_PUBLIC(LocationQueryModel)
 };
 }
 
 void LocationQueryModelPrivate::doQuery()
 {
     Q_Q(LocationQueryModel);
     if (!m_manager || !m_request.isValid()) {
         return;
     }
 
     setLoading(true);
     auto reply = m_manager->queryLocation(m_request);
     monitorReply(reply);
     QObject::connect(reply, &KPublicTransport::LocationReply::updated, q, [reply, this]() {
         mergeResults(reply->takeResult());
     });
 }
 
 void LocationQueryModelPrivate::doClearResults()
 {
     m_locations.clear();
 }
 
 bool LocationQueryModelPrivate::isFiltered(const Location &loc) const
 {
     if (m_request.types() != Location::Place && loc.type() != Location::Place && (loc.type() & m_request.types()) == 0) {
         return true;
     }
 
     if (m_request.hasCoordinate() && m_request.maximumDistance() > 0) {
         return Location::distance(m_request.latitude(), m_request.longitude(), loc.latitude(), loc.longitude()) > m_request.maximumDistance();
     }
 
     return false;
 }
 
 void LocationQueryModelPrivate::mergeResults(const std::vector<Location> &newLocations)
 {
     Q_Q(LocationQueryModel);
 
     for (const auto &loc : newLocations) {
         if (isFiltered(loc)) {
             continue;
         }
 
         // lacking an actual useful ordering, we need to do a full search for merging
         // LocationUtil::sortLessThan provides an order, but proximity there does not imply
         // always all merge candidates are nearby unfortunately (e.g. in cases of native
         // language vs. English spelling in case of name searches).
         bool found = false;
         for (auto it = m_locations.begin(); it != m_locations.end(); ++it) {
             if (Location::isSame(*it, loc)) {
                 *it = Location::merge(loc, *it);
                 found = true;
                 const auto row = std::distance(m_locations.begin(), it);
                 const auto idx = q->index(row, 0);
                 Q_EMIT q->dataChanged(idx, idx);
                 break;
             }
         }
         if (found) {
             continue;
         }
 
         auto it = std::lower_bound(m_locations.begin(), m_locations.end(), loc, [this](const auto &lhs, const auto &rhs) {
             return LocationUtil::sortLessThan(m_request, lhs, rhs);
         });
 
         const auto row = std::distance(m_locations.begin(), it);
         q->beginInsertRows({}, row, row);
         m_locations.insert(it, loc);
         q->endInsertRows();
     }
 }
 
 
 LocationQueryModel::LocationQueryModel(QObject* parent)
     : AbstractQueryModel(new LocationQueryModelPrivate, parent)
 {
 }
 
 LocationQueryModel::~LocationQueryModel() = default;
 
 LocationRequest LocationQueryModel::request() const
 {
     Q_D(const LocationQueryModel);
     return d->m_request;
 }
 
 void LocationQueryModel::setRequest(const LocationRequest &req)
 {
     Q_D(LocationQueryModel);
     d->m_request = req;
     Q_EMIT requestChanged();
     d->query();
 }
 
 int LocationQueryModel::queryDelay() const
 {
     Q_D(const LocationQueryModel);
     return d->m_queryDelay.count();
 }
 
 void LocationQueryModel::setQueryDelay(int ms)
 {
     Q_D(LocationQueryModel);
     if (d->m_queryDelay == std::chrono::milliseconds(ms)) {
         return;
     }
 
     d->m_queryDelay = std::chrono::milliseconds(ms);
     Q_EMIT queryDelayChanged();
 }
 
 int LocationQueryModel::rowCount(const QModelIndex &parent) const
 {
     Q_D(const LocationQueryModel);
     if (parent.isValid()) {
         return 0;
     }
     return d->m_locations.size();
 }
 
 QVariant LocationQueryModel::data(const QModelIndex &index, int role) const
 {
     Q_D(const LocationQueryModel);
     if (!index.isValid()) {
         return {};
     }
 
     switch (role) {
         case Qt::DisplayRole:
             return d->m_locations[index.row()].name();
         case LocationRole:
             return QVariant::fromValue(d->m_locations[index.row()]);
     }
 
     return {};
 }
 
 QHash<int, QByteArray> LocationQueryModel::roleNames() const
 {
     auto r = QAbstractListModel::roleNames();
     r.insert(LocationRole, "location");
     return r;
 }
 
 const std::vector<Location>& LocationQueryModel::locations() const
 {
     Q_D(const LocationQueryModel);
     return d->m_locations;
 }
 
 #include "moc_locationquerymodel.moc"