qdatastream.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 "qdatastream.h"
#include "qdatastream_p.h"
 
#if !defined(QT_NO_DATASTREAM) || defined(QT_BOOTSTRAPPED)
#include "qbuffer.h"
#include "qfloat16.h"
#include "qstring.h"
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include "qendian.h"
 
QT_BEGIN_NAMESPACE
 
constexpr quint32 QDataStream::NullCode;
constexpr quint32 QDataStream::ExtendedSize;
 
/*****************************************************************************
  QDataStream member functions
 *****************************************************************************/
 
#define Q_VOID
 
#undef  CHECK_STREAM_PRECOND
#ifndef QT_NO_DEBUG
#define CHECK_STREAM_PRECOND(retVal) \
    if (!dev) { \
        qWarning("QDataStream: No device"); \
        return retVal; \
    }
#else
#define CHECK_STREAM_PRECOND(retVal) \
    if (!dev) { \
        return retVal; \
    }
#endif
 
#define CHECK_STREAM_WRITE_PRECOND(retVal) \
    CHECK_STREAM_PRECOND(retVal) \
    if (q_status != Ok) \
        return retVal;
 
#define CHECK_STREAM_TRANSACTION_PRECOND(retVal) \
    if (transactionDepth == 0) { \
        qWarning("QDataStream: No transaction in progress"); \
        return retVal; \
    }
 
QDataStream::QDataStream()
{
}
 
QDataStream::QDataStream(QIODevice *d)
{
    dev = d;                                // set device
}
 
QDataStream::QDataStream(QByteArray *a, OpenMode flags)
{
    QBuffer *buf = new QBuffer(a);
#ifndef QT_NO_QOBJECT
    buf->blockSignals(true);
#endif
    buf->open(flags);
    dev = buf;
    owndev = true;
}
 
QDataStream::QDataStream(const QByteArray &a)
{
    QBuffer *buf = new QBuffer;
#ifndef QT_NO_QOBJECT
    buf->blockSignals(true);
#endif
    buf->setData(a);
    buf->open(QIODevice::ReadOnly);
    dev = buf;
    owndev = true;
}
 
QDataStream::~QDataStream()
{
    if (owndev)
        delete dev;
}
 
 
void QDataStream::setDevice(QIODevice *d)
{
    if (owndev) {
        delete dev;
        owndev = false;
    }
    dev = d;
}
 
bool QDataStream::atEnd() const
{
    return dev ? dev->atEnd() : true;
}
 
void QDataStream::setFloatingPointPrecision(QDataStream::FloatingPointPrecision precision)
{
    fpPrecision = precision;
}
 
void QDataStream::resetStatus()
{
    q_status = Ok;
}
 
void QDataStream::setStatus(Status status)
{
    if (q_status == Ok)
        q_status = status;
}
 
void QDataStream::setByteOrder(ByteOrder bo)
{
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)
    // accessed by inline byteOrder() prior to Qt 6.8
    byteorder = bo;
#endif
    if (QSysInfo::ByteOrder == QSysInfo::BigEndian)
        noswap = (bo == BigEndian);
    else
        noswap = (bo == LittleEndian);
}
 
 
void QDataStream::startTransaction()
{
    CHECK_STREAM_PRECOND(Q_VOID)
 
    if (++transactionDepth == 1) {
        dev->startTransaction();
        resetStatus();
    }
}
 
bool QDataStream::commitTransaction()
{
    CHECK_STREAM_TRANSACTION_PRECOND(false)
    if (--transactionDepth == 0) {
        CHECK_STREAM_PRECOND(false)
 
        if (q_status == ReadPastEnd) {
            dev->rollbackTransaction();
            return false;
        }
        dev->commitTransaction();
    }
    return q_status == Ok;
}
 
void QDataStream::rollbackTransaction()
{
    setStatus(ReadPastEnd);
 
    CHECK_STREAM_TRANSACTION_PRECOND(Q_VOID)
    if (--transactionDepth != 0)
        return;
 
    CHECK_STREAM_PRECOND(Q_VOID)
    if (q_status == ReadPastEnd)
        dev->rollbackTransaction();
    else
        dev->commitTransaction();
}
 
void QDataStream::abortTransaction()
{
    q_status = ReadCorruptData;
 
    CHECK_STREAM_TRANSACTION_PRECOND(Q_VOID)
    if (--transactionDepth != 0)
        return;
 
    CHECK_STREAM_PRECOND(Q_VOID)
    dev->commitTransaction();
}
 
bool QDataStream::isDeviceTransactionStarted() const
{
   return dev && dev->isTransactionStarted();
}
 
/*****************************************************************************
  QDataStream read functions
 *****************************************************************************/
 
qint64 QDataStream::readBlock(char *data, qint64 len)
{
    // Disable reads on failure in transacted stream
    if (q_status != Ok && dev->isTransactionStarted())
        return -1;
 
    const qint64 readResult = dev->read(data, len);
    if (readResult != len)
        setStatus(ReadPastEnd);
    return readResult;
}
 
QDataStream &QDataStream::operator>>(qint8 &i)
{
    i = 0;
    CHECK_STREAM_PRECOND(*this)
    char c;
    if (readBlock(&c, 1) == 1)
        i = qint8(c);
    return *this;
}
 
 
QDataStream &QDataStream::operator>>(qint16 &i)
{
    i = 0;
    CHECK_STREAM_PRECOND(*this)
    if (readBlock(reinterpret_cast<char *>(&i), 2) != 2) {
        i = 0;
    } else {
        if (!noswap) {
            i = qbswap(i);
        }
    }
    return *this;
}
 
 
QDataStream &QDataStream::operator>>(qint32 &i)
{
    i = 0;
    CHECK_STREAM_PRECOND(*this)
    if (readBlock(reinterpret_cast<char *>(&i), 4) != 4) {
        i = 0;
    } else {
        if (!noswap) {
            i = qbswap(i);
        }
    }
    return *this;
}
 
QDataStream &QDataStream::operator>>(qint64 &i)
{
    i = qint64(0);
    CHECK_STREAM_PRECOND(*this)
    if (version() < 6) {
        quint32 i1, i2;
        *this >> i2 >> i1;
        i = ((quint64)i1 << 32) + i2;
    } else {
        if (readBlock(reinterpret_cast<char *>(&i), 8) != 8) {
            i = qint64(0);
        } else {
            if (!noswap) {
                i = qbswap(i);
            }
        }
    }
    return *this;
}
 
QDataStream &QDataStream::operator>>(bool &i)
{
    qint8 v;
    *this >> v;
    i = !!v;
    return *this;
}
 
QDataStream &QDataStream::operator>>(float &f)
{
    if (version() >= QDataStream::Qt_4_6
        && floatingPointPrecision() == QDataStream::DoublePrecision) {
        double d;
        *this >> d;
        f = d;
        return *this;
    }
 
    f = 0.0f;
    CHECK_STREAM_PRECOND(*this)
    if (readBlock(reinterpret_cast<char *>(&f), 4) != 4) {
        f = 0.0f;
    } else {
        if (!noswap) {
            union {
                float val1;
                quint32 val2;
            } x;
            x.val2 = qbswap(*reinterpret_cast<quint32 *>(&f));
            f = x.val1;
        }
    }
    return *this;
}
 
QDataStream &QDataStream::operator>>(double &f)
{
    if (version() >= QDataStream::Qt_4_6
        && floatingPointPrecision() == QDataStream::SinglePrecision) {
        float d;
        *this >> d;
        f = d;
        return *this;
    }
 
    f = 0.0;
    CHECK_STREAM_PRECOND(*this)
    if (readBlock(reinterpret_cast<char *>(&f), 8) != 8) {
        f = 0.0;
    } else {
        if (!noswap) {
            union {
                double val1;
                quint64 val2;
            } x;
            x.val2 = qbswap(*reinterpret_cast<quint64 *>(&f));
            f = x.val1;
        }
    }
    return *this;
}
 
 
QDataStream &QDataStream::operator>>(char *&s)
{
    qint64 len = 0;
    return readBytes(s, len);
}
 
QDataStream &QDataStream::operator>>(char16_t &c)
{
    quint16 u;
    *this >> u;
    c = char16_t(u);
    return *this;
}
 
QDataStream &QDataStream::operator>>(char32_t &c)
{
    quint32 u;
    *this >> u;
    c = char32_t(u);
    return *this;
}
 
#if QT_DEPRECATED_SINCE(6, 11)
 
/*
    \deprecated [6.11] Use an overload that takes qint64 length instead.
*/
QDataStream &QDataStream::readBytes(char *&s, uint &l)
{
    qint64 length = 0;
    (void)readBytes(s, length);
    if (length != qint64(uint(length))) {
        setStatus(SizeLimitExceeded); // Cannot store length in l
        delete[] s;
        l = 0;
        return *this;
    }
    l = uint(length);
    return *this;
}
 
#endif // QT_DEPRECATED_SINCE(6, 11)
 
QDataStream &QDataStream::readBytes(char *&s, qint64 &l)
{
    s = nullptr;
    l = 0;
    CHECK_STREAM_PRECOND(*this)
 
    qint64 length = readQSizeType(*this);
    if (length == 0)
        return *this;
 
    qsizetype len = qsizetype(length);
    if (length != len || length < 0) {
        setStatus(SizeLimitExceeded); // Cannot store len
        return *this;
    }
 
    qsizetype step = (dev->bytesAvailable() >= len) ? len : 1024 * 1024;
    qsizetype allocated = 0;
    std::unique_ptr<char[]> curBuf = nullptr;
 
    constexpr qsizetype StepIncreaseThreshold = std::numeric_limits<qsizetype>::max() / 2;
    do {
        qsizetype blockSize = qMin(step, len - allocated);
        const qsizetype n = allocated + blockSize + 1;
        if (const auto prevBuf = std::exchange(curBuf, std::make_unique<char[]>(n)))
            memcpy(curBuf.get(), prevBuf.get(), allocated);
        if (readBlock(curBuf.get() + allocated, blockSize) != blockSize)
            return *this;
        allocated += blockSize;
        if (step <= StepIncreaseThreshold)
            step *= 2;
    } while (allocated < len);
 
    s = curBuf.release();
    s[len] = '\0';
    l = len;
    return *this;
}
 
qint64 QDataStream::readRawData(char *s, qint64 len)
{
    CHECK_STREAM_PRECOND(-1)
    return readBlock(s, len);
}
 
/*****************************************************************************
  QDataStream write functions
 *****************************************************************************/
 
QDataStream &QDataStream::operator<<(qint8 i)
{
    CHECK_STREAM_WRITE_PRECOND(*this)
    if (!dev->putChar(i))
        q_status = WriteFailed;
    return *this;
}
 
 
QDataStream &QDataStream::operator<<(qint16 i)
{
    CHECK_STREAM_WRITE_PRECOND(*this)
    if (!noswap) {
        i = qbswap(i);
    }
    if (dev->write((char *)&i, sizeof(qint16)) != sizeof(qint16))
        q_status = WriteFailed;
    return *this;
}
 
QDataStream &QDataStream::operator<<(qint32 i)
{
    CHECK_STREAM_WRITE_PRECOND(*this)
    if (!noswap) {
        i = qbswap(i);
    }
    if (dev->write((char *)&i, sizeof(qint32)) != sizeof(qint32))
        q_status = WriteFailed;
    return *this;
}
 
QDataStream &QDataStream::operator<<(qint64 i)
{
    CHECK_STREAM_WRITE_PRECOND(*this)
    if (version() < 6) {
        quint32 i1 = i & 0xffffffff;
        quint32 i2 = i >> 32;
        *this << i2 << i1;
    } else {
        if (!noswap) {
            i = qbswap(i);
        }
        if (dev->write((char *)&i, sizeof(qint64)) != sizeof(qint64))
            q_status = WriteFailed;
    }
    return *this;
}
 
QDataStream &QDataStream::operator<<(float f)
{
    if (version() >= QDataStream::Qt_4_6
        && floatingPointPrecision() == QDataStream::DoublePrecision) {
        *this << double(f);
        return *this;
    }
 
    CHECK_STREAM_WRITE_PRECOND(*this)
    float g = f;                                // fixes float-on-stack problem
    if (!noswap) {
        union {
            float val1;
            quint32 val2;
        } x;
        x.val1 = g;
        x.val2 = qbswap(x.val2);
 
        if (dev->write((char *)&x.val2, sizeof(float)) != sizeof(float))
            q_status = WriteFailed;
        return *this;
    }
 
    if (dev->write((char *)&g, sizeof(float)) != sizeof(float))
        q_status = WriteFailed;
    return *this;
}
 
 
QDataStream &QDataStream::operator<<(double f)
{
    if (version() >= QDataStream::Qt_4_6
        && floatingPointPrecision() == QDataStream::SinglePrecision) {
        *this << float(f);
        return *this;
    }
 
    CHECK_STREAM_WRITE_PRECOND(*this)
    if (noswap) {
        if (dev->write((char *)&f, sizeof(double)) != sizeof(double))
            q_status = WriteFailed;
    } else {
        union {
            double val1;
            quint64 val2;
        } x;
        x.val1 = f;
        x.val2 = qbswap(x.val2);
        if (dev->write((char *)&x.val2, sizeof(double)) != sizeof(double))
            q_status = WriteFailed;
    }
    return *this;
}
 
 
QDataStream &QDataStream::operator<<(const char *s)
{
    // Include null terminator, unless s itself is null
    const qint64 len = s ? qint64(qstrlen(s)) + 1 : 0;
    writeBytes(s, len);
    return *this;
}
 
QDataStream &QDataStream::operator<<(char16_t c)
{
    return *this << qint16(c);
}
 
QDataStream &QDataStream::operator<<(char32_t c)
{
    return *this << qint32(c);
}
 
QDataStream &QDataStream::writeBytes(const char *s, qint64 len)
{
    if (len < 0) {
        q_status = WriteFailed;
        return *this;
    }
    CHECK_STREAM_WRITE_PRECOND(*this)
    // Write length then, if any, content
    if (writeQSizeType(*this, len) && len > 0)
        writeRawData(s, len);
    return *this;
}
 
qint64 QDataStream::writeRawData(const char *s, qint64 len)
{
    CHECK_STREAM_WRITE_PRECOND(-1)
    qint64 ret = dev->write(s, len);
    if (ret != len)
        q_status = WriteFailed;
    return ret;
}
 
qint64 QDataStream::skipRawData(qint64 len)
{
    CHECK_STREAM_PRECOND(-1)
    if (q_status != Ok && dev->isTransactionStarted())
        return -1;
 
    const qint64 skipResult = dev->skip(len);
    if (skipResult != len)
        setStatus(ReadPastEnd);
    return skipResult;
}
 
QT_END_NAMESPACE
 
#endif // QT_NO_DATASTREAM