qnetworkreply.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 <QtNetwork/private/qtnetworkglobal_p.h>
 
#include "qnetworkreply.h"
#include "qnetworkreply_p.h"
#include <QtNetwork/qsslconfiguration.h>
 
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN_TAGGED(QNetworkReply::NetworkError, QNetworkReply__NetworkError)
 
const int QNetworkReplyPrivate::progressSignalInterval = 100;
 
QNetworkReplyPrivate::QNetworkReplyPrivate()
    : readBufferMaxSize(0),
      emitAllUploadProgressSignals(false),
      operation(QNetworkAccessManager::UnknownOperation),
      errorCode(QNetworkReply::NoError)
    , isFinished(false)
{
    // set the default attribute values
    attributes.insert(QNetworkRequest::ConnectionEncryptedAttribute, false);
}
 
 
QNetworkReply::QNetworkReply(QObject *parent)
    : QNetworkReply(*new QNetworkReplyPrivate, parent)
{
}
 
QNetworkReply::QNetworkReply(QNetworkReplyPrivate &dd, QObject *parent)
    : QIODevice(dd, parent)
{
}
 
QNetworkReply::~QNetworkReply()
{
}
 
void QNetworkReply::close()
{
    QIODevice::close();
}
 
bool QNetworkReply::isSequential() const
{
    return true;
}
 
qint64 QNetworkReply::readBufferSize() const
{
    return d_func()->readBufferMaxSize;
}
 
void QNetworkReply::setReadBufferSize(qint64 size)
{
    Q_D(QNetworkReply);
    d->readBufferMaxSize = size;
}
 
QNetworkAccessManager *QNetworkReply::manager() const
{
    return d_func()->manager;
}
 
QNetworkRequest QNetworkReply::request() const
{
    return d_func()->originalRequest;
}
 
QNetworkAccessManager::Operation QNetworkReply::operation() const
{
    return d_func()->operation;
}
 
QNetworkReply::NetworkError QNetworkReply::error() const
{
    return d_func()->errorCode;
}
 
bool QNetworkReply::isFinished() const
{
    return d_func()->isFinished;
}
 
bool QNetworkReply::isRunning() const
{
    return !isFinished();
}
 
QUrl QNetworkReply::url() const
{
    return d_func()->url;
}
 
QVariant QNetworkReply::header(QNetworkRequest::KnownHeaders header) const
{
    return d_func()->cookedHeaders.value(header);
}
 
bool QNetworkReply::hasRawHeader(QAnyStringView headerName) const
{
    Q_D(const QNetworkReply);
    return d->headers().contains(headerName);
}
 
QByteArray QNetworkReply::rawHeader(QAnyStringView headerName) const
{
    Q_D(const QNetworkReply);
    return d->rawHeader(headerName);
}
 
const QList<QNetworkReply::RawHeaderPair>& QNetworkReply::rawHeaderPairs() const
{
    Q_D(const QNetworkReply);
    return d->allRawHeaders();
}
 
QHttpHeaders QNetworkReply::headers() const
{
    Q_D(const QNetworkReply);
    return d->headers();
}
 
QList<QByteArray> QNetworkReply::rawHeaderList() const
{
    return d_func()->rawHeadersKeys();
}
 
QVariant QNetworkReply::attribute(QNetworkRequest::Attribute code) const
{
    return d_func()->attributes.value(code);
}
 
#if QT_CONFIG(ssl)
QSslConfiguration QNetworkReply::sslConfiguration() const
{
    QSslConfiguration config;
    sslConfigurationImplementation(config);
    return config;
}
 
void QNetworkReply::setSslConfiguration(const QSslConfiguration &config)
{
    setSslConfigurationImplementation(config);
}
 
void QNetworkReply::ignoreSslErrors(const QList<QSslError> &errors)
{
    ignoreSslErrorsImplementation(errors);
}
 
void QNetworkReply::sslConfigurationImplementation(QSslConfiguration &) const
{
}
 
void QNetworkReply::setSslConfigurationImplementation(const QSslConfiguration &)
{
}
 
void QNetworkReply::ignoreSslErrorsImplementation(const QList<QSslError> &)
{
}
 
#endif // QT_CONFIG(ssl)
 
void QNetworkReply::ignoreSslErrors()
{
}
 
qint64 QNetworkReply::writeData(const char *, qint64)
{
    return -1;                  // you can't write
}
 
void QNetworkReply::setOperation(QNetworkAccessManager::Operation operation)
{
    Q_D(QNetworkReply);
    d->operation = operation;
}
 
void QNetworkReply::setRequest(const QNetworkRequest &request)
{
    Q_D(QNetworkReply);
    d->originalRequest = request;
}
 
void QNetworkReply::setError(NetworkError errorCode, const QString &errorString)
{
    Q_D(QNetworkReply);
    d->errorCode = errorCode;
    setErrorString(errorString); // in QIODevice
}
 
void QNetworkReply::setFinished(bool finished)
{
    Q_D(QNetworkReply);
    d->isFinished = finished;
}
 
 
void QNetworkReply::setUrl(const QUrl &url)
{
    Q_D(QNetworkReply);
    d->url = url;
}
 
void QNetworkReply::setHeaders(const QHttpHeaders &newHeaders)
{
    Q_D(QNetworkReply);
    d->setHeaders(newHeaders);
}
 
void QNetworkReply::setHeaders(QHttpHeaders &&newHeaders)
{
    Q_D(QNetworkReply);
    d->setHeaders(std::move(newHeaders));
}
 
void QNetworkReply::setWellKnownHeader(QHttpHeaders::WellKnownHeader name, const QByteArray &value)
{
    Q_D(QNetworkReply);
    d->setHeader(name, value);
}
 
void QNetworkReply::setHeader(QNetworkRequest::KnownHeaders header, const QVariant &value)
{
    Q_D(QNetworkReply);
    d->setCookedHeader(header, value);
}
 
void QNetworkReply::setRawHeader(const QByteArray &headerName, const QByteArray &value)
{
    Q_D(QNetworkReply);
    d->setRawHeader(headerName, value);
}
 
void QNetworkReply::setAttribute(QNetworkRequest::Attribute code, const QVariant &value)
{
    Q_D(QNetworkReply);
    if (value.isValid())
        d->attributes.insert(code, value);
    else
        d->attributes.remove(code);
}
 
QT_END_NAMESPACE
 
#include "moc_qnetworkreply.cpp"