qgeopositioninfo.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 "qgeopositioninfo.h"
#include "private/qgeopositioninfo_p.h"
#include <QHash>
#include <QDebug>
#include <QDataStream>
#include <QtCore/QtNumeric>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN(QGeoPositionInfo)
 
 
QGeoPositionInfo::QGeoPositionInfo()
        : d(new QGeoPositionInfoPrivate)
{
}
 
QGeoPositionInfo::QGeoPositionInfo(const QGeoCoordinate &coordinate, const QDateTime &timestamp)
        : d(new QGeoPositionInfoPrivate)
{
    d->timestamp = timestamp;
    d->coord = coordinate;
}
 
QGeoPositionInfo::QGeoPositionInfo(const QGeoPositionInfo &other)
        : d(other.d)
{
}
 
QGeoPositionInfo::QGeoPositionInfo(QGeoPositionInfoPrivate &dd) : d(&dd)
{
}
 
QGeoPositionInfo::~QGeoPositionInfo()
{
}
 
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QGeoPositionInfoPrivate)
 
 
QGeoPositionInfo &QGeoPositionInfo::operator=(const QGeoPositionInfo & other)
{
    if (this == &other)
        return *this;
 
    d = other.d;
    return *this;
}
 
bool QGeoPositionInfo::isValid() const
{
    return d->timestamp.isValid() && d->coord.isValid();
}
 
void QGeoPositionInfo::setTimestamp(const QDateTime &timestamp)
{
    d.detach();
    d->timestamp = timestamp;
}
 
QDateTime QGeoPositionInfo::timestamp() const
{
    return d->timestamp;
}
 
void QGeoPositionInfo::setCoordinate(const QGeoCoordinate &coordinate)
{
    d.detach();
    d->coord = coordinate;
}
 
QGeoCoordinate QGeoPositionInfo::coordinate() const
{
    return d->coord;
}
 
void QGeoPositionInfo::setAttribute(Attribute attribute, qreal value)
{
    d.detach();
    d->doubleAttribs[attribute] = value;
}
 
qreal QGeoPositionInfo::attribute(Attribute attribute) const
{
    if (d->doubleAttribs.contains(attribute))
        return d->doubleAttribs[attribute];
    return qQNaN();
}
 
void QGeoPositionInfo::removeAttribute(Attribute attribute)
{
    d.detach();
    d->doubleAttribs.remove(attribute);
}
 
bool QGeoPositionInfo::hasAttribute(Attribute attribute) const
{
    return d->doubleAttribs.contains(attribute);
}
 
void QGeoPositionInfo::detach()
{
    if (d)
        d.detach();
    else
        d = new QGeoPositionInfoPrivate;
}
 
bool QGeoPositionInfo::equals(const QGeoPositionInfo &lhs, const QGeoPositionInfo &rhs)
{
    return *lhs.d == *rhs.d;
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug QGeoPositionInfo::debugStreaming(QDebug dbg, const QGeoPositionInfo &info)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QGeoPositionInfo(" << info.d->timestamp;
    dbg.nospace() << ", "; // timestamp force dbg.space() -> reverting here
    dbg << info.d->coord;
 
    QList<QGeoPositionInfo::Attribute> attribs = info.d->doubleAttribs.keys();
    std::stable_sort(attribs.begin(), attribs.end()); // Output a sorted list from an unsorted hash.
    for (int i = 0; i < attribs.size(); ++i) {
        dbg << ", ";
        switch (attribs[i]) {
            case QGeoPositionInfo::Direction:
                dbg << "Direction=";
                break;
            case QGeoPositionInfo::GroundSpeed:
                dbg << "GroundSpeed=";
                break;
            case QGeoPositionInfo::VerticalSpeed:
                dbg << "VerticalSpeed=";
                break;
            case QGeoPositionInfo::MagneticVariation:
                dbg << "MagneticVariation=";
                break;
            case QGeoPositionInfo::HorizontalAccuracy:
                dbg << "HorizontalAccuracy=";
                break;
            case QGeoPositionInfo::VerticalAccuracy:
                dbg << "VerticalAccuracy=";
                break;
            case QGeoPositionInfo::DirectionAccuracy:
                dbg << "DirectionAccuracy=";
                break;
        }
        dbg << info.d->doubleAttribs[attribs[i]];
    }
    dbg << ')';
    return dbg;
}
#endif
 
 
#ifndef QT_NO_DATASTREAM
QDataStream &QGeoPositionInfo::dataStreamOut(QDataStream &stream, QGeoPositionInfo::Attribute attr)
{
    return stream << qint32(attr);
}
 
QDataStream &QGeoPositionInfo::dataStreamIn(QDataStream &stream, QGeoPositionInfo::Attribute &attr)
{
    qint32 a;
    stream >> a;
    attr = static_cast<QGeoPositionInfo::Attribute>(a);
    return stream;
}
 
QDataStream &QGeoPositionInfo::dataStreamOut(QDataStream &stream, const QGeoPositionInfo &info)
{
    stream << info.d->timestamp;
    stream << info.d->coord;
    stream << info.d->doubleAttribs;
    return stream;
}
 
QDataStream &QGeoPositionInfo::dataStreamIn(QDataStream &stream, QGeoPositionInfo &info)
{
    stream >> info.d->timestamp;
    stream >> info.d->coord;
    stream >> info.d->doubleAttribs;
    return stream;
}
#endif
 
QGeoPositionInfoPrivate::QGeoPositionInfoPrivate() : QSharedData()
{
}
 
QGeoPositionInfoPrivate::QGeoPositionInfoPrivate(const QGeoPositionInfoPrivate &other)
    : QSharedData(other),
      timestamp(other.timestamp),
      coord(other.coord),
      doubleAttribs(other.doubleAttribs)
{
}
 
QGeoPositionInfoPrivate::~QGeoPositionInfoPrivate()
{
 
}
 
bool QGeoPositionInfoPrivate::operator==(const QGeoPositionInfoPrivate &other) const
{
    return timestamp == other.timestamp
           && coord == other.coord
            && doubleAttribs == other.doubleAttribs;
}
 
QGeoPositionInfoPrivate *QGeoPositionInfoPrivate::get(const QGeoPositionInfo &info)
{
    return info.d.data();
}
 
size_t qHash(const QGeoPositionInfo &key, size_t seed) noexcept
{
    return qHashMulti(seed, key.d->coord);
}
 
namespace QTest
{
 
char *toString(const QGeoPositionInfo &info)
{
    QString result;
    QDebug dbg(&result);
    dbg << info;
 
    return qstrdup(qPrintable(result));
}
 
} // namespace QTest
 
QT_END_NAMESPACE