qbuffer.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 "qbuffer.h"
#include <QtCore/qmetaobject.h>
#include "private/qiodevice_p.h"
 
#include <limits>
 
QT_BEGIN_NAMESPACE
 
class QBufferPrivate : public QIODevicePrivate
{
    Q_DECLARE_PUBLIC(QBuffer)
 
public:
    QBufferPrivate() = default;
 
    QByteArray *buf = nullptr;
    QByteArray defaultBuf;
 
    qint64 peek(char *data, qint64 maxSize) override;
    QByteArray peek(qint64 maxSize) override;
 
#ifndef QT_NO_QOBJECT
    // private slots
    void _q_emitSignals();
 
    qint64 writtenSinceLastEmit = 0;
    int signalConnectionCount = 0;
    bool signalsEmitted = false;
#endif
};
 
#ifndef QT_NO_QOBJECT
void QBufferPrivate::_q_emitSignals()
{
    Q_Q(QBuffer);
    emit q->bytesWritten(writtenSinceLastEmit);
    writtenSinceLastEmit = 0;
    emit q->readyRead();
    signalsEmitted = false;
}
#endif
 
qint64 QBufferPrivate::peek(char *data, qint64 maxSize)
{
    qint64 readBytes = qMin(maxSize, static_cast<qint64>(buf->size()) - pos);
    memcpy(data, buf->constData() + pos, readBytes);
    return readBytes;
}
 
QByteArray QBufferPrivate::peek(qint64 maxSize)
{
    qint64 readBytes = qMin(maxSize, static_cast<qint64>(buf->size()) - pos);
    if (pos == 0 && maxSize >= buf->size())
        return *buf;
    return QByteArray(buf->constData() + pos, readBytes);
}
 
#ifdef QT_NO_QOBJECT
QBuffer::QBuffer()
    : QIODevice(*new QBufferPrivate)
{
    Q_D(QBuffer);
    d->buf = &d->defaultBuf;
}
QBuffer::QBuffer(QByteArray *buf)
    : QIODevice(*new QBufferPrivate)
{
    Q_D(QBuffer);
    d->buf = buf ? buf : &d->defaultBuf;
    d->defaultBuf.clear();
}
#else
QBuffer::QBuffer(QObject *parent)
    : QIODevice(*new QBufferPrivate, parent)
{
    Q_D(QBuffer);
    d->buf = &d->defaultBuf;
}
 
QBuffer::QBuffer(QByteArray *byteArray, QObject *parent)
    : QIODevice(*new QBufferPrivate, parent)
{
    Q_D(QBuffer);
    d->buf = byteArray ? byteArray : &d->defaultBuf;
    d->defaultBuf.clear();
}
#endif
 
QBuffer::~QBuffer()
{
}
 
void QBuffer::setBuffer(QByteArray *byteArray)
{
    Q_D(QBuffer);
    if (isOpen()) {
        qWarning("QBuffer::setBuffer: Buffer is open");
        return;
    }
    if (byteArray) {
        d->buf = byteArray;
    } else {
        d->buf = &d->defaultBuf;
    }
    d->defaultBuf.clear();
}
 
QByteArray &QBuffer::buffer()
{
    Q_D(QBuffer);
    return *d->buf;
}
 
const QByteArray &QBuffer::buffer() const
{
    Q_D(const QBuffer);
    return *d->buf;
}
 
 
const QByteArray &QBuffer::data() const
{
    Q_D(const QBuffer);
    return *d->buf;
}
 
void QBuffer::setData(const QByteArray &data)
{
    Q_D(QBuffer);
    if (isOpen()) {
        qWarning("QBuffer::setData: Buffer is open");
        return;
    }
    *d->buf = data;
}
 
void QBuffer::setData(const char *data, qsizetype size)
{
    Q_D(QBuffer);
    if (isOpen()) {
        qWarning("QBuffer::setData: Buffer is open");
        return;
    }
    d->buf->assign(data, data + size);
}
 
bool QBuffer::open(OpenMode flags)
{
    Q_D(QBuffer);
 
    if ((flags & (Append | Truncate)) != 0)
        flags |= WriteOnly;
    if ((flags & (ReadOnly | WriteOnly)) == 0) {
        qWarning("QBuffer::open: Buffer access not specified");
        return false;
    }
 
    if ((flags & Truncate) == Truncate)
        d->buf->resize(0);
 
    return QIODevice::open(flags | QIODevice::Unbuffered);
}
 
void QBuffer::close()
{
    QIODevice::close();
}
 
qint64 QBuffer::pos() const
{
    return QIODevice::pos();
}
 
qint64 QBuffer::size() const
{
    Q_D(const QBuffer);
    return qint64(d->buf->size());
}
 
bool QBuffer::seek(qint64 pos)
{
    Q_D(QBuffer);
    const auto oldBufSize = d->buf->size();
    constexpr qint64 MaxSeekPos = (std::numeric_limits<decltype(oldBufSize)>::max)();
    if (pos <= MaxSeekPos && pos > oldBufSize && isWritable()) {
        QT_TRY {
            d->buf->resize(qsizetype(pos), '\0');
        } QT_CATCH(const std::bad_alloc &) {} // swallow, failure case is handled below
        if (d->buf->size() != pos) {
            qWarning("QBuffer::seek: Unable to fill gap");
            return false;
        }
    }
    if (pos > d->buf->size() || pos < 0) {
        qWarning("QBuffer::seek: Invalid pos: %lld", pos);
        return false;
    }
    return QIODevice::seek(pos);
}
 
bool QBuffer::atEnd() const
{
    return QIODevice::atEnd();
}
 
bool QBuffer::canReadLine() const
{
    Q_D(const QBuffer);
    if (!isOpen())
        return false;
 
    return d->buf->indexOf('\n', int(pos())) != -1 || QIODevice::canReadLine();
}
 
qint64 QBuffer::readData(char *data, qint64 len)
{
    Q_D(QBuffer);
    if ((len = qMin(len, qint64(d->buf->size()) - pos())) <= 0)
        return qint64(0);
    memcpy(data, d->buf->constData() + pos(), len);
    return len;
}
 
qint64 QBuffer::writeData(const char *data, qint64 len)
{
    Q_D(QBuffer);
    const quint64 required = quint64(pos()) + quint64(len); // cannot overflow (pos() ≥ 0, len ≥ 0)
 
    if (required > quint64(d->buf->size())) { // capacity exceeded
        // The following must hold, since qsizetype covers half the virtual address space:
        Q_ASSERT(required <= quint64((std::numeric_limits<qsizetype>::max)()));
        d->buf->resize(qsizetype(required));
        if (quint64(d->buf->size()) != required) { // could not resize
            qWarning("QBuffer::writeData: Memory allocation error");
            return -1;
        }
    }
 
    memcpy(d->buf->data() + pos(), data, size_t(len));
 
#ifndef QT_NO_QOBJECT
    d->writtenSinceLastEmit += len;
    if (d->signalConnectionCount && !d->signalsEmitted && !signalsBlocked()) {
        d->signalsEmitted = true;
        QMetaObject::invokeMethod(this, "_q_emitSignals", Qt::QueuedConnection);
    }
#endif
    return len;
}
 
#ifndef QT_NO_QOBJECT
static bool is_tracked_signal(const QMetaMethod &signal)
{
    // dynamic initialization: minimize the number of guard variables:
    static const struct {
        QMetaMethod readyReadSignal = QMetaMethod::fromSignal(&QBuffer::readyRead);
        QMetaMethod bytesWrittenSignal = QMetaMethod::fromSignal(&QBuffer::bytesWritten);
    } sigs;
    return signal == sigs.readyReadSignal || signal == sigs.bytesWrittenSignal;
}
void QBuffer::connectNotify(const QMetaMethod &signal)
{
    if (is_tracked_signal(signal))
        d_func()->signalConnectionCount++;
}
 
void QBuffer::disconnectNotify(const QMetaMethod &signal)
{
    if (signal.isValid()) {
        if (is_tracked_signal(signal))
            d_func()->signalConnectionCount--;
    } else {
        d_func()->signalConnectionCount = 0;
    }
}
#endif
 
QT_END_NAMESPACE
 
#ifndef QT_NO_QOBJECT
# include "moc_qbuffer.cpp"
#endif