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

 /*
     SPDX-FileCopyrightText: 2021 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "coveragearea.h"
 #include "datatypes_p.h"
 #include "json_p.h"
 #include "location.h"
 #include "logging.h"
 #include "geo/geojson_p.h"
 
 #include <QFile>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QPolygonF>
 
 using namespace KPublicTransport;
 
 namespace KPublicTransport {
 class CoverageAreaPrivate : public QSharedData {
 public:
     void loadGeometry();
     void recomputeBoundingBox();
 
     CoverageArea::Type type = CoverageArea::Any;
     QStringList regions;
     QStringList uicCompanyCodes;
     QStringList vdvOrganizationIds;
     QString areaFile;
     std::vector<QPolygonF> areas;
     QRectF boundingBox;
 };
 }
 
 void CoverageAreaPrivate::loadGeometry()
 {
     if (areaFile.isEmpty() || !areas.empty()) {
         return;
     }
 
     QFile f(QLatin1String(":/org.kde.kpublictransport/networks/geometry/") + areaFile);
     if (!f.open(QFile::ReadOnly)) {
         qCWarning(Log) << "reading coverage area file failed:" << f.fileName() << f.errorString();
         return;
     }
 
     const auto doc = QJsonDocument::fromJson(f.readAll());
     areas = GeoJson::readOuterPolygons(doc.object());
     recomputeBoundingBox();
 }
 
 void CoverageAreaPrivate::recomputeBoundingBox()
 {
     for (const auto &area : areas) {
         boundingBox |= area.boundingRect();
     }
 }
 
 KPUBLICTRANSPORT_MAKE_GADGET(CoverageArea)
 KPUBLICTRANSPORT_MAKE_PROPERTY(CoverageArea, CoverageArea::Type, type, setType)
 KPUBLICTRANSPORT_MAKE_PROPERTY(CoverageArea, QStringList, regions, setRegions)
 KPUBLICTRANSPORT_MAKE_PROPERTY(CoverageArea, QStringList, uicCompanyCodes, setUicCompanyCodes)
 KPUBLICTRANSPORT_MAKE_PROPERTY(CoverageArea, QStringList, vdvOrganizationIds, setVdvOrganizationIds)
 
 bool CoverageArea::isEmpty() const
 {
     return d->regions.isEmpty() && d->areas.empty();
 }
 
 bool CoverageArea::isGlobal() const
 {
     if (d->regions.size() == 1 && d->regions.at(0) == QLatin1String("UN")) {
         return true;
     }
 
     return d->boundingBox.topLeft() == QPointF(-180.0, -90.0) && d->boundingBox.bottomRight() == QPointF(180.0, 90.0);
 }
 
 static QStringView countryCode(QStringView isoCode)
 {
     return isoCode.size() < 2 ? QStringView() : isoCode.left(2);
 }
 
 bool CoverageArea::coversLocation(const Location &loc) const
 {
     if (loc.hasCoordinate()) {
         d->loadGeometry();
         if (!d->areas.empty()) {
             if (d->boundingBox.contains({loc.longitude(), loc.latitude()})) {
                 return std::any_of(d->areas.begin(), d->areas.end(), [&loc](const auto &area) {
                     return area.containsPoint({loc.longitude(), loc.latitude()}, Qt::WindingFill);
                 });
             }
             return false;
         }
     }
 
     // TODO we could do a more precise check for ISO 3166-2 subdivision codes when available
 
     if (loc.country().size() == 2 && !d->regions.empty()) {
         if (d->regions.size() == 1 && d->regions.at(0) == QLatin1String("UN")) { // global coverage
             return true;
         }
         return std::binary_search(d->regions.begin(), d->regions.end(), loc.country(), [](const auto &lhs, const auto &rhs) {
             return countryCode(lhs) < countryCode(rhs);
         });
     }
 
     // if we have nothing to check against, assume the backend can help (otherwise none would trigger)
     return true;
 }
 
 bool CoverageArea::hasNationWideCoverage(const QString &country) const
 {
     return std::binary_search(d->regions.begin(), d->regions.end(), country);
 }
 
 CoverageArea CoverageArea::fromJson(const QJsonObject &obj)
 {
     CoverageArea ca;
     ca.setRegions(Json::toStringList(obj.value(QLatin1String("region"))));
     ca.setUicCompanyCodes(Json::toStringList(obj.value(QLatin1String("uicCompanyCodes"))));
     std::sort(ca.d->regions.begin(), ca.d->regions.end());
 
     ca.d->areaFile = obj.value(QLatin1String("areaFile")).toString();
     if (ca.d->areaFile.isEmpty()) {
         ca.d->areas = GeoJson::readOuterPolygons(obj.value(QLatin1String("area")).toObject());
         ca.d->recomputeBoundingBox();
     }
     return ca;
 }
 
 #include "moc_coveragearea.cpp"