qplace.cpp

Go to the documentation of this file.

// Copyright (C) 2022 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 "qplace.h"
#include "qplace_p.h"
 
#include <QtPositioning/QGeoLocation>
 
#ifdef QPLACE_DEBUG
#include <QDebug>
#endif
 
#include <QStringList>
 
QT_BEGIN_NAMESPACE
 
template<>
QPlacePrivate *QSharedDataPointer<QPlacePrivate>::clone()
{
    return d->clone();
}
 
QT_DEFINE_QSDP_SPECIALIZATION_DTOR(QPlacePrivate)
 
 
QPlace::QPlace()
    : d_ptr(new QPlacePrivateDefault())
{
}
 
QPlace::QPlace(const QSharedDataPointer<QPlacePrivate> &dd): d_ptr(dd)
{
}
 
 
QPlace::QPlace(const QPlace &other) noexcept = default;
 
QPlace::~QPlace() = default;
 
QPlace &QPlace::operator= (const QPlace & other) noexcept
{
    if (this == &other)
        return *this;
 
    d_ptr = other.d_ptr;
    return *this;
}
 
inline QPlacePrivate *QPlace::d_func()
{
    return static_cast<QPlacePrivate *>(d_ptr.data());
}
 
inline const QPlacePrivate *QPlace::d_func() const
{
    return static_cast<const QPlacePrivate *>(d_ptr.constData());
}
 
bool QPlace::isEqual(const QPlace &other) const noexcept
{
    return ( (d_ptr.constData() == other.d_ptr.constData())
             || (*d_ptr) == (*other.d_ptr));
}
 
QList<QPlaceCategory> QPlace::categories() const
{
    return d_ptr->categories();
}
 
void QPlace::setCategory(const QPlaceCategory &category)
{
    d_ptr->setCategories(QList<QPlaceCategory>());
    d_ptr->setCategories(QList<QPlaceCategory>() << category);
}
 
void QPlace::setCategories(const QList<QPlaceCategory> &categories)
{
     d_ptr->setCategories(categories);
}
 
QGeoLocation QPlace::location() const
{
    return d_ptr->location();
}
 
void QPlace::setLocation(const QGeoLocation &location)
{
    d_ptr->setLocation(location);
}
 
QPlaceRatings QPlace::ratings() const
{
    return d_ptr->ratings();
}
 
void QPlace::setRatings(const QPlaceRatings &rating)
{
    d_ptr->setRatings(rating);
}
 
QPlaceSupplier QPlace::supplier() const
{
    return d_ptr->supplier();
}
 
void QPlace::setSupplier(const QPlaceSupplier &supplier)
{
    d_ptr->setSupplier(supplier);
}
 
QPlaceContent::Collection QPlace::content(QPlaceContent::Type type) const
{
    return d_ptr->m_contentCollections.value(type);
}
 
void QPlace::setContent(QPlaceContent::Type type, const QPlaceContent::Collection &content)
{
    d_ptr->m_contentCollections.insert(type, content);
}
 
void QPlace::insertContent(QPlaceContent::Type type, const QPlaceContent::Collection &content)
{
    for (auto iter = content.cbegin(), end = content.cend(); iter != end; ++iter)
        d_ptr->m_contentCollections[type].insert(iter.key(), iter.value());
}
 
int QPlace::totalContentCount(QPlaceContent::Type type) const
{
    return d_ptr->m_contentCounts.value(type, 0);
}
 
void QPlace::setTotalContentCount(QPlaceContent::Type type, int totalCount)
{
    d_ptr->m_contentCounts.insert(type, totalCount);
}
 
QString QPlace::name() const
{
    return d_ptr->name();
}
 
void QPlace::setName(const QString &name)
{
    d_ptr->setName(name);
}
 
QString QPlace::placeId() const
{
    return d_ptr->placeId();
}
 
void QPlace::setPlaceId(const QString &identifier)
{
    d_ptr->setPlaceId(identifier);
}
 
QString QPlace::attribution() const
{
    return d_ptr->attribution();
}
 
void QPlace::setAttribution(const QString &attribution)
{
    d_ptr->setAttribution(attribution);
}
 
QPlaceIcon QPlace::icon() const
{
    return d_ptr->icon();
}
 
void QPlace::setIcon(const QPlaceIcon &icon)
{
    d_ptr->setIcon(icon);
}
 
QString QPlace::primaryPhone() const
{
    QList<QPlaceContactDetail> phoneNumbers = d_ptr->contacts().value(QPlaceContactDetail::Phone);
    if (!phoneNumbers.isEmpty())
        return phoneNumbers.at(0).value();
    else
        return QString();
}
 
QString QPlace::primaryFax() const
{
    QList<QPlaceContactDetail> faxNumbers = d_ptr->contacts().value(QPlaceContactDetail::Fax);
    if (!faxNumbers.isEmpty())
        return faxNumbers.at(0).value();
    else
        return QString();
}
 
QString QPlace::primaryEmail() const
{
    QList<QPlaceContactDetail> emailAddresses = d_ptr->contacts().value(QPlaceContactDetail::Email);
    if (!emailAddresses.isEmpty())
        return emailAddresses.at(0).value();
    else
        return QString();
}
 
QUrl QPlace::primaryWebsite() const
{
    QList<QPlaceContactDetail> websites = d_ptr->contacts().value(QPlaceContactDetail::Website);
    if (!websites.isEmpty())
        return QUrl(websites.at(0).value());
    else
        return QString();
}
 
bool QPlace::detailsFetched() const
{
    return d_ptr->detailsFetched();
}
 
void QPlace::setDetailsFetched(bool fetched)
{
    d_ptr->setDetailsFetched(fetched);
}
 
QStringList QPlace::extendedAttributeTypes() const
{
    return d_ptr->extendedAttributes().keys();
}
 
QPlaceAttribute QPlace::extendedAttribute(const QString &attributeType) const
{
    return d_ptr->extendedAttribute(attributeType);
}
 
void QPlace::setExtendedAttribute(const QString &attributeType,
                                    const QPlaceAttribute &attribute)
{
    if (attribute == QPlaceAttribute())
        d_ptr->extendedAttributes().remove(attributeType);
    else
        d_ptr->extendedAttributes().insert(attributeType, attribute);
}
 
void QPlace::removeExtendedAttribute(const QString &attributeType)
{
    setExtendedAttribute(attributeType, QPlaceAttribute());
}
 
QStringList QPlace::contactTypes() const
{
    return d_ptr->contacts().keys();
}
 
QList<QPlaceContactDetail> QPlace::contactDetails(const QString &contactType) const
{
    return d_ptr->contacts().value(contactType);
}
 
void QPlace::setContactDetails(const QString &contactType, QList<QPlaceContactDetail> details)
{
    if (details.isEmpty())
        d_ptr->contacts().remove(contactType);
    else
        d_ptr->contacts().insert(contactType, details);
}
 
void QPlace::appendContactDetail(const QString &contactType, const QPlaceContactDetail &detail)
{
    QList<QPlaceContactDetail> details = d_ptr->contacts().value(contactType);
    details.append(detail);
    d_ptr->contacts().insert(contactType, details);
}
 
void QPlace::removeContactDetails(const QString &contactType)
{
    d_ptr->contacts().remove(contactType);
}
 
void QPlace::setVisibility(QLocation::Visibility visibility)
{
    d_ptr->setVisibility(visibility);
}
 
QLocation::Visibility QPlace::visibility() const
{
    return d_ptr->visibility();
}
 
bool QPlace::isEmpty() const
{
    return d_ptr->isEmpty();
}
 
/*******************************************************************************
*******************************************************************************/
 
QPlacePrivate::QPlacePrivate()
:   QSharedData()
{
}
 
QPlacePrivate::QPlacePrivate(const QPlacePrivate &other)
        : QSharedData(other),
        m_contentCollections(other.m_contentCollections),
        m_contentCounts(other.m_contentCounts)
{
}
 
QPlacePrivate::~QPlacePrivate() {}
 
bool QPlacePrivate::operator== (const QPlacePrivate &other) const
{
    return (categories() == other.categories()
            && location() == other.location()
            && ratings() == other.ratings()
            && supplier() == other.supplier()
            && m_contentCollections == other.m_contentCollections
            && m_contentCounts == other.m_contentCounts
            && name() == other.name()
            && placeId() == other.placeId()
            && attribution() == other.attribution()
            && contacts() == other.contacts()
            && extendedAttributes() == other.extendedAttributes()
            && visibility() == other.visibility()
            && icon() == other.icon()
            );
}
 
 
bool QPlacePrivate::isEmpty() const
{
    return (categories().isEmpty()
            && location().isEmpty()
            && ratings().isEmpty()
            && supplier().isEmpty()
            && m_contentCollections.isEmpty()
            && m_contentCounts.isEmpty()
            && name().isEmpty()
            && placeId().isEmpty()
            && attribution().isEmpty()
            && contacts().isEmpty()
            && extendedAttributes().isEmpty()
            && QLocation::UnspecifiedVisibility == visibility()
            && icon().isEmpty()
            );
}
 
QPlaceAttribute QPlacePrivate::extendedAttribute(const QString &attributeType) const
{
    return extendedAttributes().value(attributeType);
}
 
 
 
//
//  Default implementation
//
 
QPlacePrivateDefault::QPlacePrivateDefault()
    : QPlacePrivate(), m_visibility(QLocation::UnspecifiedVisibility), m_detailsFetched(false)
{
}
 
QPlacePrivateDefault::QPlacePrivateDefault(const QPlacePrivateDefault &other)
    : QPlacePrivate(other),
    m_categories(other.m_categories),
    m_location(other.m_location),
    m_ratings(other.m_ratings),
    m_supplier(other.m_supplier),
    m_name(other.m_name),
    m_placeId(other.m_placeId),
    m_attribution(other.m_attribution),
    m_extendedAttributes(other.m_extendedAttributes),
    m_contacts(other.m_contacts),
    m_visibility(other.m_visibility),
    m_icon(other.m_icon),
    m_detailsFetched(other.m_detailsFetched)
{
}
 
QPlacePrivateDefault::~QPlacePrivateDefault()
{
}
 
QPlacePrivate *QPlacePrivateDefault::clone()
{
    return new QPlacePrivateDefault(*this);
}
 
QList<QPlaceCategory> QPlacePrivateDefault::categories() const
{
    return m_categories;
}
 
void QPlacePrivateDefault::setCategories(const QList<QPlaceCategory> &categories)
{
    m_categories = categories;
}
 
QGeoLocation QPlacePrivateDefault::location() const
{
    return m_location;
}
 
void QPlacePrivateDefault::setLocation(const QGeoLocation &location)
{
    m_location = location;
}
 
QPlaceRatings QPlacePrivateDefault::ratings() const
{
    return m_ratings;
}
 
void QPlacePrivateDefault::setRatings(const QPlaceRatings &ratings)
{
    m_ratings = ratings;
}
 
QPlaceSupplier QPlacePrivateDefault::supplier() const
{
    return m_supplier;
}
 
void QPlacePrivateDefault::setSupplier(const QPlaceSupplier &supplier)
{
    m_supplier = supplier;
}
 
QString QPlacePrivateDefault::name() const
{
    return m_name;
}
 
void QPlacePrivateDefault::setName(const QString &name)
{
    m_name = name;
}
 
QString QPlacePrivateDefault::placeId() const
{
    return m_placeId;
}
 
void QPlacePrivateDefault::setPlaceId(const QString &placeIdentifier)
{
    m_placeId = placeIdentifier;
}
 
QString QPlacePrivateDefault::attribution() const
{
    return m_attribution;
}
 
void QPlacePrivateDefault::setAttribution(const QString &attribution)
{
    m_attribution = attribution;
}
 
QLocation::Visibility QPlacePrivateDefault::visibility() const
{
    return m_visibility;
}
 
void QPlacePrivateDefault::setVisibility(QLocation::Visibility visibility)
{
    m_visibility = visibility;
}
 
QPlaceIcon QPlacePrivateDefault::icon() const
{
    return m_icon;
}
 
void QPlacePrivateDefault::setIcon(const QPlaceIcon &icon)
{
    m_icon = icon;
}
 
bool QPlacePrivateDefault::detailsFetched() const
{
    return m_detailsFetched;
}
 
void QPlacePrivateDefault::setDetailsFetched(bool fetched)
{
    m_detailsFetched = fetched;
}
 
QMap<QString, QPlaceAttribute> QPlacePrivateDefault::extendedAttributes() const
{
    return m_extendedAttributes;
}
 
QMap<QString, QPlaceAttribute> &QPlacePrivateDefault::extendedAttributes()
{
    return m_extendedAttributes;
}
 
QMap<QString, QList<QPlaceContactDetail> > QPlacePrivateDefault::contacts() const
{
    return m_contacts;
}
 
QMap<QString, QList<QPlaceContactDetail> > &QPlacePrivateDefault::contacts()
{
    return m_contacts;
}
 
 
 
QT_END_NAMESPACE