path: root/src/location/maps/qgeoroutesegment.cpp

/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the QtLocation module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL3$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPLv3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or later as published by the Free
** Software Foundation and appearing in the file LICENSE.GPL included in
** the packaging of this file. Please review the following information to
** ensure the GNU General Public License version 2.0 requirements will be
** met: http://www.gnu.org/licenses/gpl-2.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qgeoroutesegment.h"
#include "qgeoroutesegment_p.h"

#include "qgeocoordinate.h"
#include <QDateTime>

QT_BEGIN_NAMESPACE

template<>
QGeoRouteSegmentPrivate *QExplicitlySharedDataPointer<QGeoRouteSegmentPrivate>::clone()
{
    return d->clone();
}

/*!
    \class QGeoRouteSegment
    \inmodule QtLocation
    \ingroup QtLocation-routing
    \since 5.6

    \brief The QGeoRouteSegment class represents a segment of a route.

    A QGeoRouteSegment instance has information about the physical layout
    of the route segment, the length of the route and estimated time required
    to traverse the route segment and an optional QGeoManeuver associated with
    the beginning of the route segment.

    QGeoRouteSegment instances can be thought of as edges on a routing
    graph, with QGeoManeuver instances as optional labels attached to the
    vertices of the graph.
*/

/*!
    Constructs an invalid route segment object.

    The route segment will remain invalid until one of setNextRouteSegment(),
    setTravelTime(), setDistance(), setPath() or setManeuver() is called.
*/
QGeoRouteSegment::QGeoRouteSegment()
    : d_ptr(new QGeoRouteSegmentPrivateDefault()) {}

/*!
    Constructs a route segment object from the contents of \a other.
*/
QGeoRouteSegment::QGeoRouteSegment(const QGeoRouteSegment &other)
    : d_ptr(other.d_ptr) {}

/*!
    \internal
*/
QGeoRouteSegment::QGeoRouteSegment(const QExplicitlySharedDataPointer<QGeoRouteSegmentPrivate> &dd)
    : d_ptr(dd) {}

/*!
    Returns the private implementation.
*/
QExplicitlySharedDataPointer<QGeoRouteSegmentPrivate> &QGeoRouteSegment::d()
{
    return d_ptr;
}

/*!
    Destroys this route segment object.
*/
QGeoRouteSegment::~QGeoRouteSegment() {}


/*!
    Assigns \a other to this route segment object and then returns a
    reference to this route segment object.
*/
QGeoRouteSegment &QGeoRouteSegment::operator= (const QGeoRouteSegment & other)
{
    if (this == &other)
        return *this;

    d_ptr = other.d_ptr;
    return *this;
}

/*!
    Returns whether this route segment and \a other are equal.

    The value of nextRouteSegment() is not considered in the comparison.
*/
bool QGeoRouteSegment::operator ==(const QGeoRouteSegment &other) const
{
    return ( (d_ptr.constData() == other.d_ptr.constData())
            || (*d_ptr) == (*other.d_ptr));
}

/*!
    Returns whether this route segment and \a other are not equal.

    The value of nextRouteSegment() is not considered in the comparison.
*/
bool QGeoRouteSegment::operator !=(const QGeoRouteSegment &other) const
{
    return !(operator==(other));
}

/*!
    Returns whether this route segment is valid or not.

    If nextRouteSegment() is called on the last route segment of a route, the
    returned value will be an invalid route segment.
*/
bool QGeoRouteSegment::isValid() const
{
    return d_ptr->valid();
}

/*!
    Returns whether this route segment is the last segment of a route leg.

    \since 5.12
*/
bool QGeoRouteSegment::isLegLastSegment() const
{
    if (!d_ptr->valid())
        return false;

    if (!d_ptr->nextRouteSegment())
        return true;
    return d_ptr->isLegLastSegment();
}

/*!
    Sets the next route segment in the route to \a routeSegment.
*/
void QGeoRouteSegment::setNextRouteSegment(const QGeoRouteSegment &routeSegment)
{
    d_ptr->setValid(true);
    d_ptr->setNextRouteSegment(routeSegment.d_ptr);
}

/*!
    Returns the next route segment in the route.

    Will return an invalid route segment if this is the last route
    segment in the route.
*/
QGeoRouteSegment QGeoRouteSegment::nextRouteSegment() const
{
    if (d_ptr->valid() && d_ptr->nextRouteSegment())
        return QGeoRouteSegment(d_ptr->nextRouteSegment());

    return QGeoRouteSegment();
}

/*!
    Sets the estimated amount of time it will take to traverse this segment of
    the route, in seconds, to \a secs.
*/
void QGeoRouteSegment::setTravelTime(int secs)
{
    d_ptr->setValid(true);
    d_ptr->setTravelTime(secs);
}

/*!
    Returns the estimated amount of time it will take to traverse this segment
    of the route, in seconds.
*/
int QGeoRouteSegment::travelTime() const
{
    return d_ptr->travelTime();
}

/*!
    Sets the distance covered by this segment of the route, in meters, to \a distance.
*/
void QGeoRouteSegment::setDistance(qreal distance)
{
    d_ptr->setValid(true);
    d_ptr->setDistance(distance);
}

/*!
    Returns the distance covered by this segment of the route, in meters.
*/
qreal QGeoRouteSegment::distance() const
{
    return d_ptr->distance();
}

/*!
    Sets the geometric shape of this segment of the route to \a path.

    The coordinates in \a path should be listed in the order in which they
    would be traversed by someone traveling along this segment of the route.
*/
void QGeoRouteSegment::setPath(const QList<QGeoCoordinate> &path)
{
    d_ptr->setValid(true);
    d_ptr->setPath(path);
}

/*!
    Returns the geometric shape of this route segment of the route.

    The coordinates should be listed in the order in which they
    would be traversed by someone traveling along this segment of the route.
*/

QList<QGeoCoordinate> QGeoRouteSegment::path() const
{
    return d_ptr->path();
}

/*!
    Sets the maneuver for this route segment to \a maneuver.
*/
void QGeoRouteSegment::setManeuver(const QGeoManeuver &maneuver)
{
    d_ptr->setValid(true);
    d_ptr->setManeuver(maneuver);
}

/*!
    Returns the maneuver for this route segment.

    Will return an invalid QGeoManeuver if no information has been attached
    to the starting point of this route segment.
*/
QGeoManeuver QGeoRouteSegment::maneuver() const
{
    return d_ptr->maneuver();
}

/*******************************************************************************
*******************************************************************************/

QGeoRouteSegmentPrivate::QGeoRouteSegmentPrivate() {}

QGeoRouteSegmentPrivate::QGeoRouteSegmentPrivate(const QGeoRouteSegmentPrivate &other)
    : QSharedData(other), m_nextSegment(other.m_nextSegment) {}

QGeoRouteSegmentPrivate::~QGeoRouteSegmentPrivate()
{
    m_nextSegment.reset();
}

bool QGeoRouteSegmentPrivate::operator ==(const QGeoRouteSegmentPrivate &other) const
{
    return equals(other);
}

bool QGeoRouteSegmentPrivate::equals(const QGeoRouteSegmentPrivate &other) const
{
    return ((valid() == other.valid())
            && (travelTime() == other.travelTime())
            && (distance() == other.distance())
            && (path() == other.path())
            && (maneuver() == other.maneuver()));
}

bool QGeoRouteSegmentPrivate::valid() const
{
    return false;
}

void QGeoRouteSegmentPrivate::setValid(bool valid)
{
    Q_UNUSED(valid);
}

bool QGeoRouteSegmentPrivate::isLegLastSegment() const
{
    return false;
}

void QGeoRouteSegmentPrivate::setLegLastSegment(bool lastSegment)
{
    Q_UNUSED(lastSegment);
}

int QGeoRouteSegmentPrivate::travelTime() const
{
    return 0;
}

void QGeoRouteSegmentPrivate::setTravelTime(int travelTime)
{
    Q_UNUSED(travelTime);
}

qreal QGeoRouteSegmentPrivate::distance() const
{
    return 0;
}

void QGeoRouteSegmentPrivate::setDistance(qreal distance)
{
    Q_UNUSED(distance);
}

QList<QGeoCoordinate> QGeoRouteSegmentPrivate::path() const
{
    return QList<QGeoCoordinate>();
}

void QGeoRouteSegmentPrivate::setPath(const QList<QGeoCoordinate> &path)
{
    Q_UNUSED(path);
}

QGeoManeuver QGeoRouteSegmentPrivate::maneuver() const
{
    return QGeoManeuver();
}

void QGeoRouteSegmentPrivate::setManeuver(const QGeoManeuver &maneuver)
{
    Q_UNUSED(maneuver);
}

QExplicitlySharedDataPointer<QGeoRouteSegmentPrivate> QGeoRouteSegmentPrivate::nextRouteSegment() const
{
    return m_nextSegment;
}

void QGeoRouteSegmentPrivate::setNextRouteSegment(const QExplicitlySharedDataPointer<QGeoRouteSegmentPrivate> &next)
{
    m_nextSegment = next;
}

QGeoRouteSegmentPrivate *QGeoRouteSegmentPrivate::get(QGeoRouteSegment &segment)
{
    return segment.d_ptr.data();
}

/*******************************************************************************
*******************************************************************************/

QGeoRouteSegmentPrivateDefault::QGeoRouteSegmentPrivateDefault()
    : m_valid(false),
      m_travelTime(0),
      m_distance(0.0)
{

}

QGeoRouteSegmentPrivateDefault::QGeoRouteSegmentPrivateDefault(const QGeoRouteSegmentPrivateDefault &other)
    : QGeoRouteSegmentPrivate(other),
      m_valid(other.m_valid),
      m_travelTime(other.m_travelTime),
      m_distance(other.m_distance),
      m_path(other.m_path),
      m_maneuver(other.m_maneuver)
{

}

QGeoRouteSegmentPrivateDefault::~QGeoRouteSegmentPrivateDefault()
{

}

QGeoRouteSegmentPrivate *QGeoRouteSegmentPrivateDefault::clone()
{
    return new QGeoRouteSegmentPrivateDefault(*this);
}

bool QGeoRouteSegmentPrivateDefault::operator ==(const QGeoRouteSegmentPrivateDefault &other) const
{
    return QGeoRouteSegmentPrivate::operator ==(other);
}

bool QGeoRouteSegmentPrivateDefault::valid() const
{
    return m_valid;
}

void QGeoRouteSegmentPrivateDefault::setValid(bool valid)
{
    m_valid = valid;
}

bool QGeoRouteSegmentPrivateDefault::isLegLastSegment() const
{
    return m_legLastSegment;
}

void QGeoRouteSegmentPrivateDefault::setLegLastSegment(bool lastSegment)
{
    m_legLastSegment = lastSegment;
}

int QGeoRouteSegmentPrivateDefault::travelTime() const
{
    return m_travelTime;
}

void QGeoRouteSegmentPrivateDefault::setTravelTime(int travelTime)
{
    m_travelTime = travelTime;
}

qreal QGeoRouteSegmentPrivateDefault::distance() const
{
    return m_distance;
}

void QGeoRouteSegmentPrivateDefault::setDistance(qreal distance)
{
    m_distance = distance;
}

QList<QGeoCoordinate> QGeoRouteSegmentPrivateDefault::path() const
{
    return m_path;
}

void QGeoRouteSegmentPrivateDefault::setPath(const QList<QGeoCoordinate> &path)
{
    m_path = path;
}

QGeoManeuver QGeoRouteSegmentPrivateDefault::maneuver() const
{
    return m_maneuver;
}

void QGeoRouteSegmentPrivateDefault::setManeuver(const QGeoManeuver &maneuver)
{
    m_maneuver = maneuver;
}

/*******************************************************************************
*******************************************************************************/

QT_END_NAMESPACE