qcborstreamwriter.cpp

Go to the documentation of this file.

// Copyright (C) 2018 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qcborstreamwriter.h"
 
#define CBOR_NO_PARSER_API
#include <private/qcborcommon_p.h>
 
#include <private/qnumeric_p.h>
#include <private/qstringconverter_p.h>
#include <qbuffer.h>
#include <qdebug.h>
#include <qstack.h>
#include <qvarlengtharray.h>
 
QT_BEGIN_NAMESPACE
 
static CborError qt_cbor_encoder_write_callback(void *token, const void *data, size_t len, CborEncoderAppendType);
#define CBOR_ENCODER_WRITER_CONTROL     1
#define CBOR_ENCODER_WRITE_FUNCTION     qt_cbor_encoder_write_callback
#define CBOR_ENCODER_NO_CHECK_USER
 
QT_WARNING_PUSH
QT_WARNING_DISABLE_MSVC(4334) // '<<': result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)
 
#include <cborencoder.c>
 
QT_WARNING_POP
 
// silence compilers that complain about this being a static function declared
// but never defined
[[maybe_unused]] static CborError cbor_encoder_close_container_checked(CborEncoder*, const CborEncoder*)
{
    Q_UNREACHABLE_RETURN(CborErrorInternalError);
}
 
[[maybe_unused]] static CborError cbor_encode_float_as_half_float(CborEncoder *, float)
{
    Q_UNREACHABLE_RETURN(CborErrorInternalError);
}
 
Q_DECLARE_TYPEINFO(CborEncoder, Q_PRIMITIVE_TYPE);
 
class QCborStreamWriterPrivate
{
public:
    static constexpr quint64 IndefiniteLength = (std::numeric_limits<quint64>::max)();
 
    QIODevice *device;
    CborEncoder encoder;
    QStack<CborEncoder> containerStack;
    bool deleteDevice = false;
 
    QCborStreamWriterPrivate(QIODevice *device)
        : device(device)
    {
        cbor_encoder_init_writer(&encoder, qt_cbor_encoder_write_callback, this);
    }
 
    ~QCborStreamWriterPrivate()
    {
        if (deleteDevice)
            delete device;
    }
 
    template <typename... Args> void executeAppend(CborError (*f)(CborEncoder *, Args...), Args... args)
    {
        f(&encoder, std::forward<Args>(args)...);
    }
 
    void createContainer(CborError (*f)(CborEncoder *, CborEncoder *, size_t), quint64 len = IndefiniteLength)
    {
        static_assert(size_t(IndefiniteLength) == CborIndefiniteLength);
        if (sizeof(len) != sizeof(size_t) && len != IndefiniteLength) {
            if (Q_UNLIKELY(len >= CborIndefiniteLength)) {
                // TinyCBOR can't do this in 32-bit mode
                qWarning("QCborStreamWriter: container of size %llu is too big for a 32-bit build; "
                         "will use indeterminate length instead", len);
                len = CborIndefiniteLength;
            }
        }
 
        containerStack.push(encoder);
        f(&containerStack.top(), &encoder, len);
    }
 
    bool closeContainer()
    {
        if (containerStack.isEmpty()) {
            qWarning("QCborStreamWriter: closing map or array that wasn't open");
            return false;
        }
 
        CborEncoder container = containerStack.pop();
        CborError err = cbor_encoder_close_container(&container, &encoder);
        encoder = container;
 
        if (Q_UNLIKELY(err)) {
            if (err == CborErrorTooFewItems)
                qWarning("QCborStreamWriter: not enough items added to array or map");
            else if (err == CborErrorTooManyItems)
                qWarning("QCborStreamWriter: too many items added to array or map");
            return false;
        }
 
        return true;
    }
};
 
static CborError qt_cbor_encoder_write_callback(void *self, const void *data, size_t len, CborEncoderAppendType)
{
    auto that = static_cast<QCborStreamWriterPrivate *>(self);
    if (!that->device)
        return CborNoError;
    qint64 written = that->device->write(static_cast<const char *>(data), len);
    return (written == qsizetype(len) ? CborNoError : CborErrorIO);
}
 
QCborStreamWriter::QCborStreamWriter(QIODevice *device)
    : d(new QCborStreamWriterPrivate(device))
{
}
 
QCborStreamWriter::QCborStreamWriter(QByteArray *data)
    : d(new QCborStreamWriterPrivate(new QBuffer(data)))
{
    d->deleteDevice = true;
    d->device->open(QIODevice::WriteOnly | QIODevice::Unbuffered);
}
 
QCborStreamWriter::~QCborStreamWriter()
{
}
 
void QCborStreamWriter::setDevice(QIODevice *device)
{
    if (d->deleteDevice)
        delete d->device;
    d->device = device;
    d->deleteDevice = false;
}
 
QIODevice *QCborStreamWriter::device() const
{
    return d->device;
}
 
void QCborStreamWriter::append(quint64 u)
{
    d->executeAppend(cbor_encode_uint, uint64_t(u));
}
 
void QCborStreamWriter::append(qint64 i)
{
    d->executeAppend(cbor_encode_int, int64_t(i));
}
 
void QCborStreamWriter::append(QCborNegativeInteger n)
{
    d->executeAppend(cbor_encode_negative_int, uint64_t(n));
}
 
void QCborStreamWriter::append(QLatin1StringView str)
{
    // We've got Latin-1 but CBOR wants UTF-8, so check if the string is the
    // common subset (US-ASCII).
    if (QtPrivate::isAscii(str)) {
        // it is plain US-ASCII
        appendTextString(str.latin1(), str.size());
    } else {
        // non-ASCII, convert:
        QVarLengthArray<char> utf8(str.size() * 2); // each L1 char gives at most two U8 units
        const qsizetype written = QUtf8::convertFromLatin1(utf8.data(), str) - utf8.data();
        appendTextString(utf8.data(), written);
    }
}
 
void QCborStreamWriter::append(QStringView str)
{
    QByteArray utf8 = str.toUtf8();
    appendTextString(utf8.constData(), utf8.size());
}
 
void QCborStreamWriter::append(QCborTag tag)
{
    d->executeAppend(cbor_encode_tag, CborTag(tag));
}
 
void QCborStreamWriter::append(QCborSimpleType st)
{
    d->executeAppend(cbor_encode_simple_value, uint8_t(st));
}
 
#ifndef QT_BOOTSTRAPPED
void QCborStreamWriter::append(qfloat16 f)
{
    d->executeAppend(cbor_encode_half_float, static_cast<const void *>(&f));
}
#endif // QT_BOOTSTRAPPED
 
void QCborStreamWriter::append(float f)
{
    d->executeAppend(cbor_encode_float, f);
}
 
void QCborStreamWriter::append(double d)
{
    this->d->executeAppend(cbor_encode_double, d);
}
 
void QCborStreamWriter::appendByteString(const char *data, qsizetype len)
{
    d->executeAppend(cbor_encode_byte_string, reinterpret_cast<const uint8_t *>(data), size_t(len));
}
 
void QCborStreamWriter::appendTextString(const char *utf8, qsizetype len)
{
    d->executeAppend(cbor_encode_text_string, utf8, size_t(len));
}
 
void QCborStreamWriter::startArray()
{
    d->createContainer(cbor_encoder_create_array);
}
 
void QCborStreamWriter::startArray(quint64 count)
{
    d->createContainer(cbor_encoder_create_array, count);
}
 
bool QCborStreamWriter::endArray()
{
    return d->closeContainer();
}
 
void QCborStreamWriter::startMap()
{
    d->createContainer(cbor_encoder_create_map);
}
 
void QCborStreamWriter::startMap(quint64 count)
{
    d->createContainer(cbor_encoder_create_map, count);
}
 
bool QCborStreamWriter::endMap()
{
    return d->closeContainer();
}
 
QT_END_NAMESPACE
 
#undef CBOR_ENCODER_WRITER_CONTROL
#undef CBOR_ENCODER_WRITE_FUNCTION
#undef CBOR_ENCODER_NO_CHECK_USER