File indexing completed on 2025-01-05 03:59:00

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2017 Dennis Nienhüser <nienhueser@kde.org>
 
 #include "GeoDataRelation.h"
 
 #include "GeoDataTypes.h"
 #include "OsmPlacemarkData.h"
 
 #include <QSet>
 
 namespace Marble
 {
 
 class GeoDataRelationPrivate
 {
 public:
     QSet<const GeoDataFeature*> m_features;
     OsmPlacemarkData m_osmData;
     QSet<qint64> m_memberIds;
 
     mutable GeoDataRelation::RelationType m_relationType = GeoDataRelation::UnknownType;
     mutable bool m_relationTypeDirty = true;
     static QHash<QString, GeoDataRelation::RelationType> s_relationTypes;
 };
 
 QHash<QString, GeoDataRelation::RelationType> GeoDataRelationPrivate::s_relationTypes;
 
 GeoDataRelation::GeoDataRelation() :
     GeoDataFeature(),
     d_ptr(new GeoDataRelationPrivate)
 {
     // nothing to do
 }
 
 GeoDataRelation::~GeoDataRelation()
 {
     delete d_ptr;
 }
 
 GeoDataRelation::GeoDataRelation(const GeoDataRelation &other) :
     GeoDataFeature(other),
     d_ptr(new GeoDataRelationPrivate)
 {
     Q_D(GeoDataRelation);
     d->m_features = other.d_func()->m_features;
     d->m_osmData = other.d_func()->m_osmData;
     d->m_memberIds = other.d_func()->m_memberIds;
     d->m_relationType = other.d_func()->m_relationType;
     d->m_relationTypeDirty = other.d_func()->m_relationTypeDirty;
 }
 
 GeoDataRelation &GeoDataRelation::operator=(GeoDataRelation other) // passed by value
 {
     GeoDataFeature::operator=(other);
     std::swap(*this->d_ptr, *other.d_ptr);
     return *this;
 }
 
 bool GeoDataRelation::operator<(const GeoDataRelation &other) const
 {
     if (relationType() == other.relationType()) {
         Q_D(const GeoDataRelation);
         auto const refA = d->m_osmData.tagValue(QStringLiteral("ref"));
         auto const refB = other.osmData().tagValue(QStringLiteral("ref"));
         if (refA == refB) {
             return name() < other.name();
         }
         return refA < refB;
     }
     return relationType() < other.relationType();
 }
 
 const char *GeoDataRelation::nodeType() const
 {
     return GeoDataTypes::GeoDataRelationType;
 }
 
 GeoDataFeature *GeoDataRelation::clone() const
 {
     return new GeoDataRelation(*this);
 }
 
 void GeoDataRelation::addMember(const GeoDataFeature *feature, qint64 id, OsmType type, const QString &role)
 {
     Q_D(GeoDataRelation);
     d->m_features << feature;
     d->m_osmData.addRelation(id, type, role);
     d->m_memberIds << id;
 }
 
 QSet<const GeoDataFeature *> GeoDataRelation::members() const
 {
     Q_D(const GeoDataRelation);
     return d->m_features;
 }
 
 OsmPlacemarkData &GeoDataRelation::osmData()
 {
     Q_D(GeoDataRelation);
     d->m_relationTypeDirty = true;
     return d->m_osmData;
 }
 
 const OsmPlacemarkData &GeoDataRelation::osmData() const
 {
     Q_D(const GeoDataRelation);
     return d->m_osmData;
 }
 
 GeoDataRelation::RelationType GeoDataRelation::relationType() const
 {
     Q_D(const GeoDataRelation);
     if (!d->m_relationTypeDirty) {
         return d->m_relationType;
     }
 
     if (GeoDataRelationPrivate::s_relationTypes.isEmpty()) {
         auto &map = GeoDataRelationPrivate::s_relationTypes;
         map[QStringLiteral("road")] = RouteRoad;
         map[QStringLiteral("detour")] = RouteDetour;
         map[QStringLiteral("ferry")] = RouteFerry;
         map[QStringLiteral("train")] = RouteTrain;
         map[QStringLiteral("subway")] = RouteSubway;
         map[QStringLiteral("tram")] = RouteTram;
         map[QStringLiteral("bus")] = RouteBus;
         map[QStringLiteral("trolleybus")] = RouteTrolleyBus;
         map[QStringLiteral("bicycle")] = RouteBicycle;
         map[QStringLiteral("mtb")] = RouteMountainbike;
         map[QStringLiteral("foot")] = RouteFoot;
         map[QStringLiteral("hiking")] = GeoDataRelation::RouteHiking;
         map[QStringLiteral("horse")] = RouteHorse;
         map[QStringLiteral("inline_skates")] = RouteInlineSkates;
     }
 
     d->m_relationType = GeoDataRelation::UnknownType;
     d->m_relationTypeDirty = false;
     if (d->m_osmData.containsTag(QStringLiteral("type"), QStringLiteral("route"))) {
         auto const route = d->m_osmData.tagValue(QStringLiteral("route"));
         if (route == QStringLiteral("piste")) {
             auto const piste = d->m_osmData.tagValue(QStringLiteral("piste:type"));
             if (piste == QStringLiteral("downhill")) {
                 d->m_relationType = RouteSkiDownhill;
             } else if (piste == QStringLiteral("nordic")) {
                 d->m_relationType = RouteSkiNordic;
             } else if (piste == QStringLiteral("skitour")) {
                 d->m_relationType = RouteSkitour;
             } else if (piste == QStringLiteral("sled")) {
                 d->m_relationType = RouteSled;
             }
         } else {
             d->m_relationType = GeoDataRelationPrivate::s_relationTypes.value(route, UnknownType);
         }
     }
 
     return d->m_relationType;
 }
 
 QSet<qint64> GeoDataRelation::memberIds() const
 {
     Q_D(const GeoDataRelation);
     return d->m_memberIds;
 }
 
 bool GeoDataRelation::containsAnyOf(const QSet<qint64> &memberIds) const
 {
     Q_D(const GeoDataRelation);
     return d->m_memberIds.intersects(memberIds);
 }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(GeoDataRelation::RelationTypes)
 
 }