qgeoroute.cpp

Go to the documentation of this file.

// Copyright (C) 2015 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 "qgeoroute.h"
#include "qgeoroute_p.h"
 
#include "qgeorectangle.h"
#include "qgeoroutesegment.h"
 
#include <QDateTime>
#include <QVariantMap>
 
QT_BEGIN_NAMESPACE
 
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QGeoRoutePrivate)
 
 
QGeoRoute::QGeoRoute()
    : d_ptr(new QGeoRoutePrivate())
{}
 
QExplicitlySharedDataPointer<QGeoRoutePrivate> &QGeoRoute::d()
{
    return d_ptr;
}
 
const QExplicitlySharedDataPointer<QGeoRoutePrivate> &QGeoRoute::const_d() const
{
    return d_ptr;
}
 
QGeoRoute::QGeoRoute(const QGeoRoute &other) noexcept = default;
 
QGeoRoute::~QGeoRoute() = default;
 
QGeoRoute &QGeoRoute::operator=(const QGeoRoute & other) noexcept
{
    if (this == &other)
        return *this;
 
    d_ptr = other.d_ptr;
    return *this;
}
 
bool QGeoRoute::isEqual(const QGeoRoute &other) const noexcept
{
    return ( (d_ptr.constData() == other.d_ptr.constData())
            || (*d_ptr) == (*other.d_ptr));
}
 
 
void QGeoRoute::setRouteId(const QString &id)
{
    d_ptr->setId(id);
}
 
QString QGeoRoute::routeId() const
{
    return d_ptr->id();
}
 
void QGeoRoute::setRequest(const QGeoRouteRequest &request)
{
    d_ptr->setRequest(request);
}
 
QGeoRouteRequest QGeoRoute::request() const
{
    return d_ptr->request();
}
 
void QGeoRoute::setBounds(const QGeoRectangle &bounds)
{
    d_ptr->setBounds(bounds);
}
 
QGeoRectangle QGeoRoute::bounds() const
{
    return d_ptr->bounds();
}
 
void QGeoRoute::setFirstRouteSegment(const QGeoRouteSegment &routeSegment)
{
    d_ptr->setFirstSegment(routeSegment);
}
 
QGeoRouteSegment QGeoRoute::firstRouteSegment() const
{
    return d_ptr->firstSegment();
}
 
qsizetype QGeoRoute::segmentsCount() const
{
    return d_ptr->segmentsCount();
}
 
QList<QGeoRouteSegment> QGeoRoute::segments() const
{
    return d_ptr->segments();
}
 
void QGeoRoute::setTravelTime(int secs)
{
    d_ptr->setTravelTime(secs);
}
 
int QGeoRoute::travelTime() const
{
    return d_ptr->travelTime();
}
 
void QGeoRoute::setDistance(qreal distance)
{
    d_ptr->setDistance(distance);
}
 
qreal QGeoRoute::distance() const
{
    return d_ptr->distance();
}
 
void QGeoRoute::setTravelMode(QGeoRouteRequest::TravelMode mode)
{
    d_ptr->setTravelMode(mode);
}
 
QGeoRouteRequest::TravelMode QGeoRoute::travelMode() const
{
    return d_ptr->travelMode();
}
 
void QGeoRoute::setPath(const QList<QGeoCoordinate> &path)
{
    d_ptr->setPath(path);
}
 
 
QList<QGeoCoordinate> QGeoRoute::path() const
{
    return d_ptr->path();
}
 
void QGeoRoute::setRouteLegs(const QList<QGeoRoute> &legs)
{
    d_ptr->setRouteLegs(legs);
}
 
QList<QGeoRoute> QGeoRoute::routeLegs() const
{
    return d_ptr->routeLegs();
}
 
 
void QGeoRoute::setExtendedAttributes(const QVariantMap &extendedAttributes)
{
    d_ptr->setExtendedAttributes(extendedAttributes);
}
 
QVariantMap QGeoRoute::extendedAttributes() const
{
    return d_ptr->extendedAttributes();
}
 
void QGeoRoute::setLegIndex(int idx)
{
    d()->setLegIndex(idx);
}
 
int QGeoRoute::legIndex() const
{
    return const_d()->legIndex();
}
 
void QGeoRoute::setOverallRoute(const QGeoRoute &route)
{
    d()->setContainingRoute(route);
}
 
QGeoRoute QGeoRoute::overallRoute() const
{
    return const_d()->containingRoute();
}
 
/*******************************************************************************
*******************************************************************************/
 
bool QGeoRoutePrivate::operator ==(const QGeoRoutePrivate &other) const
{
    return equals(other);
}
 
bool QGeoRoutePrivate::equals(const QGeoRoutePrivate &other) const
{
    // here both routes are of type QGeoRoutePrivate
    QGeoRouteSegment s1 = firstSegment();
    QGeoRouteSegment s2 = other.firstSegment();
 
    while (true) {
        if (s1.isValid() != s2.isValid())
            return false;
        if (!s1.isValid())
            break;
        if (s1 != s2)
            return false;
        s1 = s1.nextRouteSegment();
        s2 = s2.nextRouteSegment();
    }
 
    return id() == other.id()
        && request() == other.request()
        && bounds() == other.bounds()
        && travelTime() == other.travelTime()
        && distance() == other.distance()
        && travelMode() == other.travelMode()
        && path() == other.path()
        && routeLegs() == other.routeLegs()
        && extendedAttributes() == other.extendedAttributes();
}
 
void QGeoRoutePrivate::setId(const QString &id)
{
    m_id = id;
}
 
QString QGeoRoutePrivate::id() const
{
    return m_id;
}
 
void QGeoRoutePrivate::setRequest(const QGeoRouteRequest &request)
{
    m_request = request;
}
 
QGeoRouteRequest QGeoRoutePrivate::request() const
{
    return m_request;
}
 
void QGeoRoutePrivate::setBounds(const QGeoRectangle &bounds)
{
    m_bounds = bounds;
}
 
QGeoRectangle QGeoRoutePrivate::bounds() const
{
    return m_bounds;
}
 
void QGeoRoutePrivate::setTravelTime(int travelTime)
{
    m_travelTime = travelTime;
}
 
int QGeoRoutePrivate::travelTime() const
{
    return m_travelTime;
}
 
void QGeoRoutePrivate::setDistance(qreal distance)
{
    m_distance = distance;
}
 
qreal QGeoRoutePrivate::distance() const
{
    return m_distance;
}
 
void QGeoRoutePrivate::setTravelMode(QGeoRouteRequest::TravelMode mode)
{
    m_travelMode = mode;
}
 
QGeoRouteRequest::TravelMode QGeoRoutePrivate::travelMode() const
{
    return m_travelMode;
}
 
void QGeoRoutePrivate::setPath(const QList<QGeoCoordinate> &path)
{
    m_path = path;
}
 
QList<QGeoCoordinate> QGeoRoutePrivate::path() const
{
    return m_path;
}
 
void QGeoRoutePrivate::setFirstSegment(const QGeoRouteSegment &firstSegment)
{
    m_firstSegment = firstSegment;
    m_numSegments = -1;
}
 
QGeoRouteSegment QGeoRoutePrivate::firstSegment() const
{
    return m_firstSegment;
}
 
int QGeoRoutePrivate::segmentsCount() const
{
    if (m_numSegments >= 0)
        return m_numSegments;
 
    int count = 0;
    forEachSegment([&count](const QGeoRouteSegment &){
        ++count;
    });
    m_numSegments = count;
    return count;
}
 
QList<QGeoRouteSegment> QGeoRoutePrivate::segments() const
{
    QList<QGeoRouteSegment> segments;
    forEachSegment([&segments](const QGeoRouteSegment &segment){
        segments.append(segment);
    });
    return segments;
}
 
void QGeoRoutePrivate::setRouteLegs(const QList<QGeoRoute> &legs)
{
    m_legs = legs;
}
 
QList<QGeoRoute> QGeoRoutePrivate::routeLegs() const
{
    return m_legs;
}
 
void QGeoRoutePrivate::setExtendedAttributes(const QVariantMap &extendedAttributes)
{
    m_extendedAttributes = extendedAttributes;
}
 
QVariantMap QGeoRoutePrivate::extendedAttributes() const
{
    return m_extendedAttributes;
}
 
void QGeoRoutePrivate::setLegIndex(int idx)
{
    if (idx >= 0)
        m_legIndex = idx;
}
 
int QGeoRoutePrivate::legIndex() const
{
    return m_legIndex;
}
 
void QGeoRoutePrivate::setContainingRoute(const QGeoRoute &route)
{
    m_containingRoute.reset(new QGeoRoute(route));
}
 
QGeoRoute QGeoRoutePrivate::containingRoute() const
{
    if (m_containingRoute)
        return *m_containingRoute;
    return QGeoRoute();
}
 
QT_END_NAMESPACE
 
#include "moc_qgeoroute.cpp"