qabstractnetworkcache.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 "qabstractnetworkcache.h"
#include "qabstractnetworkcache_p.h"
#include "qnetworkrequest_p.h"
#include "qhttpheadershelper_p.h"
 
#include <qdatastream.h>
#include <qdatetime.h>
#include <qurl.h>
#include <qhash.h>
 
#include <qdebug.h>
 
QT_BEGIN_NAMESPACE
 
class QNetworkCacheMetaDataPrivate : public QSharedData
{
 
public:
    QNetworkCacheMetaDataPrivate()
        : QSharedData()
        , saveToDisk(true)
    {}
 
    bool operator==(const QNetworkCacheMetaDataPrivate &other) const
    {
        return
            url == other.url
            && lastModified == other.lastModified
            && expirationDate == other.expirationDate
            && saveToDisk == other.saveToDisk
            && QHttpHeadersHelper::compareStrict(headers, other.headers);
    }
 
    QUrl url;
    QDateTime lastModified;
    QDateTime expirationDate;
    QHttpHeaders headers;
    QNetworkCacheMetaData::AttributesMap attributes;
    bool saveToDisk;
 
    static void save(QDataStream &out, const QNetworkCacheMetaData &metaData);
    static void load(QDataStream &in, QNetworkCacheMetaData &metaData);
};
Q_GLOBAL_STATIC(QNetworkCacheMetaDataPrivate, metadata_shared_invalid)
 
 
QNetworkCacheMetaData::QNetworkCacheMetaData()
    : d(new QNetworkCacheMetaDataPrivate)
{
}
 
QNetworkCacheMetaData::~QNetworkCacheMetaData()
{
    // QSharedDataPointer takes care of freeing d
}
 
QNetworkCacheMetaData::QNetworkCacheMetaData(const QNetworkCacheMetaData &other)
    : d(other.d)
{
}
 
QNetworkCacheMetaData &QNetworkCacheMetaData::operator=(const QNetworkCacheMetaData &other)
{
    d = other.d;
    return *this;
}
 
bool QNetworkCacheMetaData::operator==(const QNetworkCacheMetaData &other) const
{
    if (d == other.d)
        return true;
    if (d && other.d)
        return *d == *other.d;
    return false;
}
 
bool QNetworkCacheMetaData::isValid() const
{
    return !(*d == *metadata_shared_invalid());
}
 
bool QNetworkCacheMetaData::saveToDisk() const
{
    return d->saveToDisk;
}
 
void QNetworkCacheMetaData::setSaveToDisk(bool allow)
{
    d->saveToDisk = allow;
}
 
QUrl QNetworkCacheMetaData::url() const
{
    return d->url;
}
 
void QNetworkCacheMetaData::setUrl(const QUrl &url)
{
    auto *p = d.data();
    p->url = url;
    p->url.setPassword(QString());
    p->url.setFragment(QString());
}
 
QNetworkCacheMetaData::RawHeaderList QNetworkCacheMetaData::rawHeaders() const
{
    return QNetworkHeadersPrivate::fromHttpToRaw(d->headers);
}
 
void QNetworkCacheMetaData::setRawHeaders(const RawHeaderList &list)
{
    d->headers = QNetworkHeadersPrivate::fromRawToHttp(list);
}
 
QHttpHeaders QNetworkCacheMetaData::headers() const
{
    return d->headers;
}
 
void QNetworkCacheMetaData::setHeaders(const QHttpHeaders &headers)
{
    d->headers = headers;
}
 
QDateTime QNetworkCacheMetaData::lastModified() const
{
    return d->lastModified;
}
 
void QNetworkCacheMetaData::setLastModified(const QDateTime &dateTime)
{
    d->lastModified = dateTime;
}
 
QDateTime QNetworkCacheMetaData::expirationDate() const
{
    return d->expirationDate;
}
 
void QNetworkCacheMetaData::setExpirationDate(const QDateTime &dateTime)
{
    d->expirationDate = dateTime;
}
 
QNetworkCacheMetaData::AttributesMap QNetworkCacheMetaData::attributes() const
{
    return d->attributes;
}
 
void QNetworkCacheMetaData::setAttributes(const AttributesMap &attributes)
{
    d->attributes = attributes;
}
 
QDataStream &operator<<(QDataStream &out, const QNetworkCacheMetaData &metaData)
{
    QNetworkCacheMetaDataPrivate::save(out, metaData);
    return out;
}
 
static inline QDataStream &operator<<(QDataStream &out, const QNetworkCacheMetaData::AttributesMap &hash)
{
    out << quint32(hash.size());
    QNetworkCacheMetaData::AttributesMap::ConstIterator it = hash.begin();
    QNetworkCacheMetaData::AttributesMap::ConstIterator end = hash.end();
    while (it != end) {
        out << int(it.key()) << it.value();
        ++it;
    }
    return out;
}
 
void QNetworkCacheMetaDataPrivate::save(QDataStream &out, const QNetworkCacheMetaData &metaData)
{
    // note: if you change the contents of the meta data here
    // remember to bump the cache version in qnetworkdiskcache.cpp CurrentCacheVersion
    out << metaData.url();
    out << metaData.expirationDate();
    out << metaData.lastModified();
    out << metaData.saveToDisk();
    out << metaData.attributes();
    out << metaData.rawHeaders();
}
 
QDataStream &operator>>(QDataStream &in, QNetworkCacheMetaData &metaData)
{
    QNetworkCacheMetaDataPrivate::load(in, metaData);
    return in;
}
 
static inline QDataStream &operator>>(QDataStream &in, QNetworkCacheMetaData::AttributesMap &hash)
{
    hash.clear();
    QDataStream::Status oldStatus = in.status();
    in.resetStatus();
    hash.clear();
 
    quint32 n;
    in >> n;
 
    for (quint32 i = 0; i < n; ++i) {
        if (in.status() != QDataStream::Ok)
            break;
 
        int k;
        QVariant t;
        in >> k >> t;
        hash.insert(QNetworkRequest::Attribute(k), t);
    }
 
    if (in.status() != QDataStream::Ok)
        hash.clear();
    if (oldStatus != QDataStream::Ok)
        in.setStatus(oldStatus);
    return in;
}
 
void QNetworkCacheMetaDataPrivate::load(QDataStream &in, QNetworkCacheMetaData &metaData)
{
    auto *p = metaData.d.data();
    in >> p->url;
    in >> p->expirationDate;
    in >> p->lastModified;
    in >> p->saveToDisk;
    in >> p->attributes;
    QNetworkCacheMetaData::RawHeaderList list; in >> list;
    metaData.setRawHeaders(list);
}
 
QAbstractNetworkCache::QAbstractNetworkCache(QObject *parent)
    : QObject(*new QAbstractNetworkCachePrivate, parent)
{
}
 
QAbstractNetworkCache::QAbstractNetworkCache(QAbstractNetworkCachePrivate &dd, QObject *parent)
    : QObject(dd, parent)
{
}
 
QAbstractNetworkCache::~QAbstractNetworkCache()
{
}
 
QT_END_NAMESPACE
 
#include "moc_qabstractnetworkcache.cpp"