qgeoshape.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 "qgeoshape.h"
#include "qgeoshape_p.h"
#include "qgeorectangle.h"
#include "qgeocircle.h"
#include "qgeopath.h"
#include "qgeopolygon.h"
 
 
#ifndef QT_NO_DEBUG_STREAM
#include <QtCore/QDebug>
#endif
 
#ifndef QT_NO_DATASTREAM
#include <QtCore/QDataStream>
#endif
 
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN(QGeoShape)
 
QGeoShapePrivate::QGeoShapePrivate(QGeoShape::ShapeType type)
:   type(type)
{
}
 
QGeoShapePrivate::~QGeoShapePrivate()
{
}
 
bool QGeoShapePrivate::operator==(const QGeoShapePrivate &other) const
{
    return type == other.type;
}
 
inline QGeoShapePrivate *QGeoShape::d_func()
{
    return static_cast<QGeoShapePrivate *>(d_ptr.data());
}
 
inline const QGeoShapePrivate *QGeoShape::d_func() const
{
    return static_cast<const QGeoShapePrivate *>(d_ptr.constData());
}
 
QGeoShape::QGeoShape()
{
}
 
QGeoShape::QGeoShape(const QGeoShape &other)
:   d_ptr(other.d_ptr)
{
}
 
QGeoShape::QGeoShape(QGeoShapePrivate *d)
:   d_ptr(d)
{
}
 
bool QGeoShape::equals(const QGeoShape &lhs, const QGeoShape &rhs)
{
    if (lhs.d_func() == rhs.d_func())
        return true;
 
    if (!lhs.d_func() || !rhs.d_func())
        return false;
 
    return *lhs.d_func() == *rhs.d_func();
}
 
QGeoShape::~QGeoShape()
{
}
 
QGeoShape::ShapeType QGeoShape::type() const
{
    Q_D(const QGeoShape);
 
    if (d)
        return d->type;
    else
        return UnknownType;
}
 
bool QGeoShape::isValid() const
{
    Q_D(const QGeoShape);
 
    if (d)
        return d->isValid();
    else
        return false;
}
 
bool QGeoShape::isEmpty() const
{
    Q_D(const QGeoShape);
 
    if (d)
        return d->isEmpty();
    else
        return true;
}
 
bool QGeoShape::contains(const QGeoCoordinate &coordinate) const
{
    Q_D(const QGeoShape);
 
    if (d)
        return d->contains(coordinate);
    else
        return false;
}
 
QGeoRectangle QGeoShape::boundingGeoRectangle() const
{
    Q_D(const QGeoShape);
 
    if (d)
        return d->boundingGeoRectangle();
    else
        return QGeoRectangle();
}
 
QGeoCoordinate QGeoShape::center() const
{
    Q_D(const QGeoShape);
 
    if (d)
        return d->center();
    else
        return QGeoCoordinate();
}
 
QGeoShape &QGeoShape::operator=(const QGeoShape &other)
{
    if (this == &other)
        return *this;
 
    d_ptr = other.d_ptr;
    return *this;
}
 
QString QGeoShape::toString() const
{
    return QStringLiteral("QGeoShape(%1)").arg(type());
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug QGeoShape::debugStreaming(QDebug dbg, const QGeoShape &shape)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QGeoShape(";
    switch (shape.type()) {
    case QGeoShape::UnknownType:
        dbg << "Unknown";
        break;
    case QGeoShape::RectangleType:
        dbg << "Rectangle";
        break;
    case QGeoShape::PathType:
        dbg << "Path";
        break;
    case QGeoShape::PolygonType:
        dbg << "Polygon";
        break;
    case QGeoShape::CircleType:
        dbg << "Circle";
    }
 
    dbg << ')';
 
    return dbg;
}
#endif
 
#ifndef QT_NO_DATASTREAM
QDataStream &QGeoShape::dataStreamOut(QDataStream &stream, const QGeoShape &shape)
{
    stream << quint32(shape.type());
    switch (shape.type()) {
    case QGeoShape::UnknownType:
        break;
    case QGeoShape::RectangleType: {
        QGeoRectangle r = shape;
        stream << r.topLeft() << r.bottomRight();
        break;
    }
    case QGeoShape::CircleType: {
        QGeoCircle c = shape;
        stream << c.center() << c.radius();
        break;
    }
    case QGeoShape::PathType: {
        QGeoPath p = shape;
        stream << p.width();
        stream << p.path().size();
        for (const auto &c: p.path())
            stream << c;
        break;
    }
    case QGeoShape::PolygonType: {
        QGeoPolygon p = shape;
        stream << p.perimeter().size();
        for (const auto &c: p.perimeter())
            stream << c;
        break;
    }
    }
 
    return stream;
}
 
QDataStream &QGeoShape::dataStreamIn(QDataStream &stream, QGeoShape &shape)
{
    quint32 type;
    stream >> type;
 
    switch (type) {
    case QGeoShape::UnknownType:
        shape = QGeoShape();
        break;
    case QGeoShape::RectangleType: {
        QGeoCoordinate tl;
        QGeoCoordinate br;
        stream >> tl >> br;
        shape = QGeoRectangle(tl, br);
        break;
    }
    case QGeoShape::CircleType: {
        QGeoCoordinate c;
        qreal r;
        stream >> c >> r;
        shape = QGeoCircle(c, r);
        break;
    }
    case QGeoShape::PathType: {
        QList<QGeoCoordinate> l;
        QGeoCoordinate c;
        qreal width;
        stream >> width;
        qsizetype sz;
        stream >> sz;
        for (qsizetype i = 0; i < sz; i++) {
            stream >> c;
            l.append(c);
        }
        shape = QGeoPath(l, width);
        break;
    }
    case QGeoShape::PolygonType: {
        QList<QGeoCoordinate> l;
        QGeoCoordinate c;
        qsizetype sz;
        stream >> sz;
        for (qsizetype i = 0; i < sz; i++) {
            stream >> c;
            l.append(c);
        }
        shape = QGeoPolygon(l);
        break;
    }
    }
 
    return stream;
}
#endif
 
size_t qHash(const QGeoShape &shape, size_t seed) noexcept
{
    if (shape.d_ptr)
        return shape.d_ptr->hash(seed);
    else
        return qHashMulti(seed, shape.type());
}
 
QT_END_NAMESPACE
 
#include "moc_qgeoshape.cpp"