de/d7c/qcborvalue_8h_source.html

// Copyright (C) 2022 Intel Corporation.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:critical reason:data-parser


#ifndef QCBORVALUE_H

#define QCBORVALUE_H


#include <QtCore/qbytearray.h>

#include <QtCore/qcborcommon.h>

#include <QtCore/qcompare.h>

#include <QtCore/qdatetime.h>

#if QT_CONFIG(regularexpression)

#  include <QtCore/qregularexpression.h>

#endif

#include <QtCore/qstring.h>

#include <QtCore/qstringview.h>

#include <QtCore/qurl.h>

#include <QtCore/quuid.h>

#include <QtCore/qvariant.h>


/* X11 headers use these values too, but as defines */

#if defined(False) && defined(True)

#  undef True

#  undef False

#endif


QT_BEGIN_NAMESPACE


class QCborArray;

class QCborMap;

class QCborStreamReader;

class QCborStreamWriter;

class QDataStream;


namespace QJsonPrivate { class Value; }


struct QCborParserError

{

    qint64 offset = 0;

    QCborError error = { QCborError::NoError };


    QString errorString() const { return error.toString(); }

};


class QCborValueRef;

class QCborContainerPrivate;


class Q_CORE_EXPORT QCborValue

{

    Q_GADGET

public:


    enum EncodingOption {

        SortKeysInMaps = 0x01,

        UseFloat = 0x02,

#ifndef QT_BOOTSTRAPPED

        UseFloat16 = UseFloat | 0x04,

#endif

        UseIntegers = 0x08,


        NoTransformation = 0

    };


    Q_DECLARE_FLAGS(EncodingOptions, EncodingOption)


    enum DiagnosticNotationOption {

        Compact         = 0x00,

        LineWrapped     = 0x01,

        ExtendedFormat  = 0x02

    };


    Q_DECLARE_FLAGS(DiagnosticNotationOptions, DiagnosticNotationOption)


    // different from QCborStreamReader::Type because we have more types


    enum Type : int {

        Integer         = 0x00,

        ByteArray       = 0x40,

        String          = 0x60,

        Array           = 0x80,

        Map             = 0xa0,

        Tag             = 0xc0,


        // range 0x100 - 0x1ff for Simple Types

        SimpleType      = 0x100,

        False           = SimpleType + int(QCborSimpleType::False),

        True            = SimpleType + int(QCborSimpleType::True),

        Null            = SimpleType + int(QCborSimpleType::Null),

        Undefined       = SimpleType + int(QCborSimpleType::Undefined),


        Double          = 0x202,


        // extended (tagged) types

        DateTime        = 0x10000,

        Url             = 0x10020,

        RegularExpression = 0x10023,

        Uuid            = 0x10025,


        Invalid         = -1

    };


    Q_ENUM(Type)


    QCborValue() {}

    QCborValue(Type t_) : t(t_) {}

    QCborValue(std::nullptr_t) : t(Null) {}

    QCborValue(bool b_) : t(b_ ? True : False) {}

#ifndef Q_QDOC

    QCborValue(int i) : QCborValue(qint64(i)) {}

    QCborValue(unsigned u) : QCborValue(qint64(u)) {}

#endif

    QCborValue(qint64 i) : n(i), t(Integer) {}

    QCborValue(double v) : t(Double) { memcpy(&n, &v, sizeof(n)); }

    QCborValue(QCborSimpleType st) : t(type_helper(st)) {}


    QCborValue(const QByteArray &ba);

    QCborValue(const QString &s);

    QCborValue(QStringView s);

    QCborValue(QLatin1StringView s);

#ifndef QT_NO_CAST_FROM_ASCII

    QT_ASCII_CAST_WARN QCborValue(const char *s) : QCborValue(QString::fromUtf8(s)) {}

#endif

    QCborValue(const QCborArray &a);

    QCborValue(QCborArray &&a);

    QCborValue(const QCborMap &m);

    QCborValue(QCborMap &&m);

    QCborValue(QCborTag tag, const QCborValue &taggedValue = QCborValue());


    QCborValue(QCborKnownTags t_, const QCborValue &tv = QCborValue())

        : QCborValue(QCborTag(t_), tv)

    {}


#if QT_CONFIG(datestring)

    explicit QCborValue(const QDateTime &dt);

#endif

#ifndef QT_BOOTSTRAPPED

    explicit QCborValue(const QUrl &url);

#  if QT_CONFIG(regularexpression)

    explicit QCborValue(const QRegularExpression &rx);

#  endif

    explicit QCborValue(const QUuid &uuid);

#endif


    ~QCborValue() { if (container) dispose(); }


    // make sure const char* doesn't go call the bool constructor

    QCborValue(const void *) = delete;


    QCborValue(const QCborValue &other) noexcept;


    QCborValue(QCborValue &&other) noexcept

        : n(other.n), container(std::exchange(other.container, nullptr)), t(std::exchange(other.t, Undefined))

    {

    }


    QCborValue &operator=(const QCborValue &other) noexcept;

    QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_MOVE_AND_SWAP(QCborValue)


    void swap(QCborValue &other) noexcept

    {

        std::swap(n, other.n);

        qt_ptr_swap(container, other.container);

        std::swap(t, other.t);

    }


    Type type() const           { return t; }

    bool isInteger() const      { return type() == Integer; }

    bool isByteArray() const    { return type() == ByteArray; }

    bool isString() const       { return type() == String; }

    bool isArray() const        { return type() == Array; }

    bool isMap() const          { return type() == Map; }

    bool isTag() const          { return isTag_helper(type()); }

    bool isFalse() const        { return type() == False; }

    bool isTrue() const         { return type() == True; }

    bool isBool() const         { return isFalse() || isTrue(); }

    bool isNull() const         { return type() == Null; }

    bool isUndefined() const    { return type() == Undefined; }

    bool isDouble() const       { return type() == Double; }

    bool isDateTime() const     { return type() == DateTime; }

    bool isUrl() const          { return type() == Url; }

    bool isRegularExpression() const { return type() == RegularExpression; }

    bool isUuid() const         { return type() == Uuid; }

    bool isInvalid() const      { return type() == Invalid; }

    bool isContainer() const    { return isMap() || isArray(); }


    bool isSimpleType() const

    {

        return int(type()) >> 8 == int(SimpleType) >> 8;

    }


    bool isSimpleType(QCborSimpleType st) const

    {

        return type() == type_helper(st);

    }


    QCborSimpleType toSimpleType(QCborSimpleType defaultValue = QCborSimpleType::Undefined) const

    {

        return isSimpleType() ? QCborSimpleType(type() & 0xff) : defaultValue;

    }


    qint64 toInteger(qint64 defaultValue = 0) const

    { return isInteger() ? value_helper() : isDouble() ? qint64(fp_helper()) : defaultValue; }


    bool toBool(bool defaultValue = false) const

    { return isBool() ? isTrue() : defaultValue; }


    double toDouble(double defaultValue = 0) const

    { return isDouble() ? fp_helper() : isInteger() ? double(value_helper()) : defaultValue; }


    QCborTag tag(QCborTag defaultValue = QCborTag(-1)) const;

    QCborValue taggedValue(const QCborValue &defaultValue = QCborValue()) const;


    QByteArray toByteArray(const QByteArray &defaultValue = {}) const;

    QString toString(const QString &defaultValue = {}) const;

    QAnyStringView toStringView(QAnyStringView defaultValue = {}) const;

#if QT_CONFIG(datestring)

    QDateTime toDateTime(const QDateTime &defaultValue = {}) const;

#endif

#ifndef QT_BOOTSTRAPPED

    QUrl toUrl(const QUrl &defaultValue = {}) const;

#  if QT_CONFIG(regularexpression)

    QRegularExpression toRegularExpression(const QRegularExpression &defaultValue = {}) const;

#  endif

    QUuid toUuid(const QUuid &defaultValue = {}) const;

#endif


    // only forward-declared, need split functions

    QCborArray toArray() const;

    QCborArray toArray(const QCborArray &defaultValue) const;

    QCborMap toMap() const;

    QCborMap toMap(const QCborMap &defaultValue) const;


    const QCborValue operator[](const QString &key) const;

    const QCborValue operator[](QLatin1StringView key) const;

    const QCborValue operator[](qint64 key) const;

    QCborValueRef operator[](qint64 key);

    QCborValueRef operator[](QLatin1StringView key);

    QCborValueRef operator[](const QString & key);


    int compare(const QCborValue &other) const;

#if QT_CORE_REMOVED_SINCE(6, 8)

    bool operator==(const QCborValue &other) const noexcept

    { return compare(other) == 0; }

    bool operator!=(const QCborValue &other) const noexcept

    { return !operator==(other); }

    bool operator<(const QCborValue &other) const

    { return compare(other) < 0; }

#endif


    static QCborValue fromVariant(const QVariant &variant);

    QVariant toVariant() const;

    static QCborValue fromJsonValue(const QJsonValue &v);

    QJsonValue toJsonValue() const;


#if QT_CONFIG(cborstreamreader)

    static QCborValue fromCbor(QCborStreamReader &reader);

    static QCborValue fromCbor(const QByteArray &ba, QCborParserError *error = nullptr);

    static QCborValue fromCbor(const char *data, qsizetype len, QCborParserError *error = nullptr)

    { return fromCbor(QByteArray(data, int(len)), error); }

    static QCborValue fromCbor(const quint8 *data, qsizetype len, QCborParserError *error = nullptr)

    { return fromCbor(QByteArray(reinterpret_cast<const char *>(data), int(len)), error); }

#endif // QT_CONFIG(cborstreamreader)

#if QT_CONFIG(cborstreamwriter)

    QByteArray toCbor(EncodingOptions opt = NoTransformation) const;

    void toCbor(QCborStreamWriter &writer, EncodingOptions opt = NoTransformation) const;

#endif


    QString toDiagnosticNotation(DiagnosticNotationOptions opts = Compact) const;


private:

    friend Q_CORE_EXPORT Q_DECL_PURE_FUNCTION

    bool comparesEqual(const QCborValue &lhs, const QCborValue &rhs) noexcept;


    friend Qt::strong_ordering compareThreeWay(const QCborValue &lhs,

                                               const QCborValue &rhs) noexcept

    {

        int c = lhs.compare(rhs);

        return Qt::compareThreeWay(c, 0);

    }


    Q_DECLARE_STRONGLY_ORDERED(QCborValue)

    friend class QCborArray;

    friend class QCborMap;

    friend class QCborValueConstRef;

    friend class QCborValueRef;

    friend class QCborContainerPrivate;

    friend class QJsonPrivate::Value;


    qint64 n = 0;

    QCborContainerPrivate *container = nullptr;

    Type t = Undefined;


    void dispose();

    qint64 value_helper() const

    {

        return n;

    }


    double fp_helper() const

    {

        static_assert(sizeof(double) == sizeof(n));

        double d;

        memcpy(&d, &n, sizeof(d));

        return d;

    }


    constexpr static Type type_helper(QCborSimpleType st)

    {

        return Type(quint8(st) | SimpleType);

    }


    constexpr static bool isTag_helper(Type tt)

    {

        return tt == Tag || tt >= 0x10000;

    }

};


Q_DECLARE_SHARED(QCborValue)


Q_CORE_EXPORT size_t qHash(const QCborValue &value, size_t seed = 0);


class QCborValueConstRef

{

public:

    QCborValueConstRef(const QCborValueConstRef &) = default;

    QCborValueConstRef &operator=(const QCborValueConstRef &) = delete;

    operator QCborValue() const     { return concrete(); }


    QCborValue::Type type() const   { return concreteType(*this); }

    bool isInteger() const          { return type() == QCborValue::Integer; }

    bool isByteArray() const        { return type() == QCborValue::ByteArray; }

    bool isString() const           { return type() == QCborValue::String; }

    bool isArray() const            { return type() == QCborValue::Array; }

    bool isMap() const              { return type() == QCborValue::Map; }

    bool isTag() const              { return concrete().isTag(); }

    bool isFalse() const            { return type() == QCborValue::False; }

    bool isTrue() const             { return type() == QCborValue::True; }

    bool isBool() const             { return isFalse() || isTrue(); }

    bool isNull() const             { return type() == QCborValue::Null; }

    bool isUndefined() const        { return type() == QCborValue::Undefined; }

    bool isDouble() const           { return type() == QCborValue::Double; }

    bool isDateTime() const         { return type() == QCborValue::DateTime; }

    bool isUrl() const              { return type() == QCborValue::Url; }

    bool isRegularExpression() const { return type() == QCborValue::RegularExpression; }

    bool isUuid() const             { return type() == QCborValue::Uuid; }

    bool isInvalid() const          { return type() == QCborValue::Invalid; }

    bool isContainer() const        { return isMap() || isArray(); }

    bool isSimpleType() const       { return concrete().isSimpleType(); }

    bool isSimpleType(QCborSimpleType st) const { return concrete().isSimpleType(st); }


    QCborSimpleType toSimpleType(QCborSimpleType defaultValue = QCborSimpleType::Undefined) const

    {

        return concrete().toSimpleType(defaultValue);

    }


    QCborTag tag(QCborTag defaultValue = QCborTag(-1)) const

    { return concrete().tag(defaultValue); }


    QCborValue taggedValue(const QCborValue &defaultValue = QCborValue()) const

    { return concrete().taggedValue(defaultValue); }


    qint64 toInteger(qint64 defaultValue = 0) const

    { return concrete().toInteger(defaultValue); }


    bool toBool(bool defaultValue = false) const

    { return concrete().toBool(defaultValue); }


    double toDouble(double defaultValue = 0) const

    { return concrete().toDouble(defaultValue); }


    QByteArray toByteArray(const QByteArray &defaultValue = {}) const

    { return concrete().toByteArray(defaultValue); }


    QString toString(const QString &defaultValue = {}) const

    { return concrete().toString(defaultValue); }


    QAnyStringView toStringView(QAnyStringView defaultValue = {}) const

    { return concreteStringView(*this, defaultValue); }


#if QT_CONFIG(datestring)

    QDateTime toDateTime(const QDateTime &defaultValue = {}) const

    { return concrete().toDateTime(defaultValue); }

#endif

#ifndef QT_BOOTSTRAPPED


    QUrl toUrl(const QUrl &defaultValue = {}) const

    { return concrete().toUrl(defaultValue); }


#  if QT_CONFIG(regularexpression)

    QRegularExpression toRegularExpression(const QRegularExpression &defaultValue = {}) const

    { return concrete().toRegularExpression(defaultValue); }

#  endif


    QUuid toUuid(const QUuid &defaultValue = {}) const

    { return concrete().toUuid(defaultValue); }


#endif


    // only forward-declared, need split functions. Implemented in qcbor{array,map}.h

    inline QCborArray toArray() const;

    inline QCborArray toArray(const QCborArray &a) const;

    inline QCborMap toMap() const;

    inline QCborMap toMap(const QCborMap &m) const;


    Q_CORE_EXPORT const QCborValue operator[](const QString &key) const;

    Q_CORE_EXPORT const QCborValue operator[](QLatin1StringView key) const;

    Q_CORE_EXPORT const QCborValue operator[](qint64 key) const;


    int compare(const QCborValue &other) const

    { return concrete().compare(other); }


    QVariant toVariant() const                  { return concrete().toVariant(); }

    inline QJsonValue toJsonValue() const;      // in qjsonvalue.h


#if QT_CONFIG(cborstreamwriter)

    QByteArray toCbor(QCborValue::EncodingOptions opt = QCborValue::NoTransformation) const

    { return concrete().toCbor(opt); }

    void toCbor(QCborStreamWriter &writer, QCborValue::EncodingOptions opt = QCborValue::NoTransformation) const

    { return concrete().toCbor(writer, opt); }

#endif


    QString toDiagnosticNotation(QCborValue::DiagnosticNotationOptions opt = QCborValue::Compact) const

    { return concrete().toDiagnosticNotation(opt); }


protected:

    friend class QCborValue;

    friend class QCborArray;

    friend class QCborMap;

    friend class QCborContainerPrivate;


    QCborValue concrete() const noexcept  { return concrete(*this); }


    friend size_t qHash(const QCborValueConstRef &key, size_t seed = 0) noexcept

    { return QHashPrivate::ex1to2arg(key.concrete(), seed); }


    static Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool

    comparesEqual_helper(QCborValueConstRef lhs, QCborValueConstRef rhs) noexcept;

    static Q_CORE_EXPORT Q_DECL_PURE_FUNCTION Qt::strong_ordering

    compareThreeWay_helper(QCborValueConstRef lhs, QCborValueConstRef rhs) noexcept;


    friend bool comparesEqual(const QCborValueConstRef &lhs,

                              const QCborValueConstRef &rhs) noexcept

    {

        return comparesEqual_helper(lhs, rhs);

    }


    friend Qt::strong_ordering compareThreeWay(const QCborValueConstRef &lhs,

                                               const QCborValueConstRef &rhs) noexcept

    {

        return compareThreeWay_helper(lhs, rhs);

    }


    Q_DECLARE_STRONGLY_ORDERED(QCborValueConstRef)


    static Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool

    comparesEqual_helper(QCborValueConstRef lhs, const QCborValue &rhs) noexcept;

    static Q_CORE_EXPORT Q_DECL_PURE_FUNCTION Qt::strong_ordering

    compareThreeWay_helper(QCborValueConstRef lhs, const QCborValue &rhs) noexcept;


    friend bool comparesEqual(const QCborValueConstRef &lhs,

                              const QCborValue &rhs) noexcept

    {

        return comparesEqual_helper(lhs, rhs);

    }


    friend Qt::strong_ordering compareThreeWay(const QCborValueConstRef &lhs,

                                               const QCborValue &rhs) noexcept

    {

        return compareThreeWay_helper(lhs, rhs);

    }


    Q_DECLARE_STRONGLY_ORDERED(QCborValueConstRef, QCborValue)


    static Q_CORE_EXPORT QCborValue concrete(QCborValueConstRef that) noexcept;

    Q_DECL_PURE_FUNCTION static Q_CORE_EXPORT QCborValue::Type concreteType(QCborValueConstRef that) noexcept;

    static Q_CORE_EXPORT bool

    Q_DECL_PURE_FUNCTION concreteBoolean(QCborValueConstRef that, bool defaultValue) noexcept;

    static Q_CORE_EXPORT double

    Q_DECL_PURE_FUNCTION concreteDouble(QCborValueConstRef that, double defaultValue) noexcept;

    static Q_CORE_EXPORT qint64

    Q_DECL_PURE_FUNCTION concreteIntegral(QCborValueConstRef that, qint64 defaultValue) noexcept;

    static Q_CORE_EXPORT QByteArray

    concreteByteArray(QCborValueConstRef that, const QByteArray &defaultValue);

    static Q_CORE_EXPORT QString

    concreteString(QCborValueConstRef that, const QString &defaultValue);

    static Q_CORE_EXPORT QAnyStringView

    concreteStringView(QCborValueConstRef that, QAnyStringView defaultValue);


    constexpr QCborValueConstRef() : d(nullptr), i(0) {} // this will actually be invalid


    constexpr QCborValueConstRef(QCborContainerPrivate *dd, qsizetype ii)

        : d(dd), i(ii)

    {}


    QCborContainerPrivate *d;

    qsizetype i;

};


QT_WARNING_PUSH

QT6_ONLY(QT_WARNING_DISABLE_MSVC(4275)) // non dll-interface class 'QJsonValueConstRef' used as base for dll-interface class 'QJsonValueRef'

class QT6_ONLY(Q_CORE_EXPORT) QCborValueRef : public QCborValueConstRef

{

public:

    QCborValueRef(const QCborValueRef &) noexcept = default;

    QCborValueRef(QCborValueRef &&) noexcept = default;

    QCborValueRef &operator=(const QCborValue &other)

    { assign(*this, other); return *this; }

    QCborValueRef &operator=(QCborValue &&other)

    { assign(*this, std::move(other)); other.container = nullptr; return *this; }

    QCborValueRef &operator=(const QCborValueRef &other)

    { assign(*this, other); return *this; }


    QT7_ONLY(Q_CORE_EXPORT) QCborValueRef operator[](qint64 key);

    QT7_ONLY(Q_CORE_EXPORT) QCborValueRef operator[](QLatin1StringView key);

    QT7_ONLY(Q_CORE_EXPORT) QCborValueRef operator[](const QString & key);


#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)

    // retained for binary compatibility (due to the Q_CORE_EXPORT) because at

    // least one compiler emits and exports all inlines in an exported class


    operator QCborValue() const     { return concrete(); }

    QCborValue::Type type() const   { return concreteType(); }

    bool isInteger() const          { return type() == QCborValue::Integer; }

    bool isByteArray() const        { return type() == QCborValue::ByteArray; }

    bool isString() const           { return type() == QCborValue::String; }

    bool isArray() const            { return type() == QCborValue::Array; }

    bool isMap() const              { return type() == QCborValue::Map; }

    bool isTag() const              { return QCborValue::isTag_helper(type()); }

    bool isFalse() const            { return type() == QCborValue::False; }

    bool isTrue() const             { return type() == QCborValue::True; }

    bool isBool() const             { return isFalse() || isTrue(); }

    bool isNull() const             { return type() == QCborValue::Null; }

    bool isUndefined() const        { return type() == QCborValue::Undefined; }

    bool isDouble() const           { return type() == QCborValue::Double; }

    bool isDateTime() const         { return type() == QCborValue::DateTime; }

    bool isUrl() const              { return type() == QCborValue::Url; }

    bool isRegularExpression() const { return type() == QCborValue::RegularExpression; }

    bool isUuid() const             { return type() == QCborValue::Uuid; }

    bool isInvalid() const          { return type() == QCborValue::Invalid; }

    bool isContainer() const        { return isMap() || isArray(); }

    bool isSimpleType() const

    {

        return type() >= QCborValue::SimpleType && type() < QCborValue::SimpleType + 0x100;

    }

    bool isSimpleType(QCborSimpleType st) const

    {

        return type() == QCborValue::type_helper(st);

    }

    QCborSimpleType toSimpleType(QCborSimpleType defaultValue = QCborSimpleType::Undefined) const

    {

        return isSimpleType() ? QCborSimpleType(type() & 0xff) : defaultValue;

    }


    QCborTag tag(QCborTag defaultValue = QCborTag(-1)) const

    { return concrete().tag(defaultValue); }

    QCborValue taggedValue(const QCborValue &defaultValue = QCborValue()) const

    { return concrete().taggedValue(defaultValue); }


    qint64 toInteger(qint64 defaultValue = 0) const

    { return concreteIntegral(*this, defaultValue); }

    bool toBool(bool defaultValue = false) const

    { return concreteBoolean(*this, defaultValue); }

    double toDouble(double defaultValue = 0) const

    { return concreteDouble(*this, defaultValue); }


    QByteArray toByteArray(const QByteArray &defaultValue = {}) const

    { return concreteByteArray(*this, defaultValue); }

    QString toString(const QString &defaultValue = {}) const

    { return concreteString(*this, defaultValue); }

#if QT_CONFIG(datestring)

    QDateTime toDateTime(const QDateTime &defaultValue = {}) const

    { return concrete().toDateTime(defaultValue); }

#endif

#ifndef QT_BOOTSTRAPPED

    QUrl toUrl(const QUrl &defaultValue = {}) const

    { return concrete().toUrl(defaultValue); }

#  if QT_CONFIG(regularexpression)

    QRegularExpression toRegularExpression(const QRegularExpression &defaultValue = {}) const

    { return concrete().toRegularExpression(defaultValue); }

#  endif

    QUuid toUuid(const QUuid &defaultValue = {}) const

    { return concrete().toUuid(defaultValue); }

#endif


    // only forward-declared, need split functions. Implemented in qcbor{array,map}.h

    QCborArray toArray() const;

    QCborArray toArray(const QCborArray &a) const;

    QCborMap toMap() const;

    QCborMap toMap(const QCborMap &m) const;


    const QCborValue operator[](const QString &key) const;

    const QCborValue operator[](QLatin1StringView key) const;

    const QCborValue operator[](qint64 key) const;


    int compare(const QCborValue &other) const

    { return concrete().compare(other); }

#if QT_CORE_REMOVED_SINCE(6, 8)

    bool operator==(const QCborValue &other) const

    { return compare(other) == 0; }

    bool operator!=(const QCborValue &other) const

    { return !operator==(other); }

    bool operator<(const QCborValue &other) const

    { return compare(other) < 0; }

#endif


    QVariant toVariant() const                  { return concrete().toVariant(); }

    QJsonValue toJsonValue() const;


#if QT_CONFIG(cborstreamwriter)

    using QCborValueConstRef::toCbor;

    QByteArray toCbor(QCborValue::EncodingOptions opt = QCborValue::NoTransformation)

    { return std::as_const(*this).toCbor(opt); }

    void toCbor(QCborStreamWriter &writer, QCborValue::EncodingOptions opt = QCborValue::NoTransformation);

#endif


    using QCborValueConstRef::toDiagnosticNotation;

    QString toDiagnosticNotation(QCborValue::DiagnosticNotationOptions opt = QCborValue::Compact)

    { return std::as_const(*this).toDiagnosticNotation(opt); }


private:

    static QCborValue concrete(QCborValueRef that) noexcept;

    QCborValue concrete() const noexcept  { return concrete(*this); }


    Q_DECL_PURE_FUNCTION static QCborValue::Type concreteType(QCborValueRef self) noexcept;

    QCborValue::Type concreteType() const noexcept { return concreteType(*this); }


    // this will actually be invalid...

    constexpr QCborValueRef() : QCborValueConstRef(nullptr, 0) {}


    QCborValueRef(QCborContainerPrivate *dd, qsizetype ii)

        : QCborValueConstRef(dd, ii)

    {}

#else

private:

    using QCborValueConstRef::QCborValueConstRef;

#endif // < Qt 7


    friend class QCborValue;

    friend class QCborArray;

    friend class QCborMap;

    friend class QCborContainerPrivate;

    friend class QCborValueConstRef;


    // static so we can pass this by value

    QT7_ONLY(Q_CORE_EXPORT) static void assign(QCborValueRef that, const QCborValue &other);

    QT7_ONLY(Q_CORE_EXPORT) static void assign(QCborValueRef that, QCborValue &&other);

    QT7_ONLY(Q_CORE_EXPORT) static void assign(QCborValueRef that, const QCborValueRef other);

};

QT_WARNING_POP

Q_DECLARE_OPERATORS_FOR_FLAGS(QCborValue::EncodingOptions)

Q_DECLARE_OPERATORS_FOR_FLAGS(QCborValue::DiagnosticNotationOptions)


#if !defined(QT_NO_DEBUG_STREAM)

Q_CORE_EXPORT QDebug operator<<(QDebug, const QCborValue &v);

#endif


#ifndef QT_NO_DATASTREAM

#if QT_CONFIG(cborstreamwriter)

Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QCborValue &);

#endif

Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QCborValue &);

#endif


QT_END_NAMESPACE


#endif // QCBORVALUE_H

QByteArray::FromBase64Result
\inmodule QtCore
Definition qbytearray.h:785

QCborArray
\inmodule QtCore\reentrant
Definition qcborarray.h:21

QCborContainerPrivate
Definition qcborvalue_p.h:101

QCborMap
\inmodule QtCore\reentrant
Definition qcbormap.h:35

QCborValueConstRef
Definition qcborvalue.h:308

QCborValueConstRef::isBool
bool isBool() const
Definition qcborvalue.h:323

QCborValueConstRef::toArray
QCborArray toArray(const QCborArray &a) const
Definition qcborarray.h:384

QCborValueConstRef::toMap
QCborMap toMap(const QCborMap &m) const
Definition qcbormap.h:495

QCborValueConstRef::toMap
QCborMap toMap() const
Definition qcbormap.h:490

QCborValueConstRef::toVariant
QVariant toVariant() const
Definition qcborvalue.h:387

QCborValueConstRef::isInteger
bool isInteger() const
Definition qcborvalue.h:315

QCborValueConstRef::isDateTime
bool isDateTime() const
Definition qcborvalue.h:327

QCborValueConstRef::isDouble
bool isDouble() const
Definition qcborvalue.h:326

QCborValueConstRef::isString
bool isString() const
Definition qcborvalue.h:317

QCborValueConstRef::operator=
QCborValueConstRef & operator=(const QCborValueConstRef &)=delete

QCborValueConstRef::isUrl
bool isUrl() const
Definition qcborvalue.h:328

QCborValueConstRef::isNull
bool isNull() const
Definition qcborvalue.h:324

QCborValueConstRef::toArray
QCborArray toArray() const
Definition qcborarray.h:379

QCborValueConstRef::isContainer
bool isContainer() const
Definition qcborvalue.h:332

QCborValueConstRef::toBool
bool toBool(bool defaultValue=false) const
Definition qcborvalue.h:348

QCborValueConstRef::taggedValue
QCborValue taggedValue(const QCborValue &defaultValue=QCborValue()) const
Definition qcborvalue.h:343

QCborValueConstRef::isByteArray
bool isByteArray() const
Definition qcborvalue.h:316

QCborValueConstRef::toSimpleType
QCborSimpleType toSimpleType(QCborSimpleType defaultValue=QCborSimpleType::Undefined) const
Definition qcborvalue.h:336

QCborValueConstRef::isMap
bool isMap() const
Definition qcborvalue.h:319

QCborValueConstRef::isSimpleType
bool isSimpleType() const
Definition qcborvalue.h:333

QCborValueConstRef::isRegularExpression
bool isRegularExpression() const
Definition qcborvalue.h:329

QCborValueConstRef::isUndefined
bool isUndefined() const
Definition qcborvalue.h:325

QCborValueConstRef::type
QCborValue::Type type() const
Definition qcborvalue.h:314

QCborValueConstRef::isInvalid
bool isInvalid() const
Definition qcborvalue.h:331

QCborValueConstRef::QCborValueConstRef
QCborValueConstRef(const QCborValueConstRef &)=default

QCborValueConstRef::isUuid
bool isUuid() const
Definition qcborvalue.h:330

QCborValueConstRef::tag
QCborTag tag(QCborTag defaultValue=QCborTag(-1)) const
Definition qcborvalue.h:341

QCborValueConstRef::QCborValueConstRef
constexpr QCborValueConstRef()
Definition qcborvalue.h:458

QCborValueConstRef::toByteArray
QByteArray toByteArray(const QByteArray &defaultValue={}) const
Definition qcborvalue.h:353

QCborValueConstRef::toInteger
qint64 toInteger(qint64 defaultValue=0) const
Definition qcborvalue.h:346

QCborValueConstRef::isSimpleType
bool isSimpleType(QCborSimpleType st) const
Definition qcborvalue.h:334

QCborValueConstRef::isTrue
bool isTrue() const
Definition qcborvalue.h:322

QCborValueConstRef::toUuid
QUuid toUuid(const QUuid &defaultValue={}) const
Definition qcborvalue.h:370

QCborValueConstRef::d
QCborContainerPrivate * d
Definition qcborvalue.h:462

QCborValueConstRef::isFalse
bool isFalse() const
Definition qcborvalue.h:321

QCborValueConstRef::toStringView
QAnyStringView toStringView(QAnyStringView defaultValue={}) const
Definition qcborvalue.h:357

QCborValueConstRef::comparesEqual
friend bool comparesEqual(const QCborValueConstRef &lhs, const QCborValueConstRef &rhs) noexcept
Definition qcborvalue.h:415

QCborValueConstRef::isTag
bool isTag() const
Definition qcborvalue.h:320

QCborValueConstRef::comparesEqual
friend bool comparesEqual(const QCborValueConstRef &lhs, const QCborValue &rhs) noexcept
Definition qcborvalue.h:431

QCborValueConstRef::toDiagnosticNotation
QString toDiagnosticNotation(QCborValue::DiagnosticNotationOptions opt=QCborValue::Compact) const
Definition qcborvalue.h:397

QCborValueConstRef::isArray
bool isArray() const
Definition qcborvalue.h:318

QCborValueConstRef::compare
int compare(const QCborValue &other) const
Definition qcborvalue.h:384

QCborValueConstRef::compareThreeWay
friend Qt::strong_ordering compareThreeWay(const QCborValueConstRef &lhs, const QCborValue &rhs) noexcept
Definition qcborvalue.h:436

QCborValueConstRef::operator QCborValue
operator QCborValue() const
Definition qcborvalue.h:312

QCborValueConstRef::compareThreeWay
friend Qt::strong_ordering compareThreeWay(const QCborValueConstRef &lhs, const QCborValueConstRef &rhs) noexcept
Definition qcborvalue.h:420

QCborValueConstRef::QCborValueConstRef
constexpr QCborValueConstRef(QCborContainerPrivate *dd, qsizetype ii)
Definition qcborvalue.h:459

QCborValueConstRef::concrete
QCborValue concrete() const noexcept
Definition qcborvalue.h:406

QCborValueConstRef::toString
QString toString(const QString &defaultValue={}) const
Definition qcborvalue.h:355

QCborValueConstRef::toUrl
QUrl toUrl(const QUrl &defaultValue={}) const
Definition qcborvalue.h:364

QCborValueConstRef::toJsonValue
QJsonValue toJsonValue() const

QCborValueConstRef::qHash
friend size_t qHash(const QCborValueConstRef &key, size_t seed=0) noexcept
Definition qcborvalue.h:408

QCborValueConstRef::i
qsizetype i
Definition qcborvalue.h:463

QCborValueConstRef::toDouble
double toDouble(double defaultValue=0) const
Definition qcborvalue.h:350

QCborValue
\inmodule QtCore\reentrant
Definition qcborvalue.h:48

QDataStream
\inmodule QtCore\reentrant
Definition qdatastream.h:50

QHash
\inmodule QtCore
Definition qhash.h:843

QJsonPrivate::Value
Definition qjson_p.h:173

QJsonPrivate::Variant
Definition qjson_p.h:210

QList
Definition qlist.h:81

QMetaTypeFunctionRegistry
Definition qmetatype.cpp:1787

QMetaTypeFunctionRegistry::remove
void remove(int from, int to)
Definition qmetatype.cpp:1815

QMetaTypeFunctionRegistry::insertIfNotContains
bool insertIfNotContains(Key k, const T &f)
Definition qmetatype.cpp:1801

QMetaTypeFunctionRegistry::~QMetaTypeFunctionRegistry
~QMetaTypeFunctionRegistry()
Definition qmetatype.cpp:1789

QMetaTypeFunctionRegistry::contains
bool contains(Key k) const
Definition qmetatype.cpp:1795

QMetaTypeFunctionRegistry::function
const T * function(Key k) const
Definition qmetatype.cpp:1808

QPointF
\inmodule QtCore\reentrant
Definition qpoint.h:232

QPoint
\inmodule QtCore\reentrant
Definition qpoint.h:30

QTaggedPointer
Definition qtaggedpointer.h:39

QtMetaTypePrivate::QPairVariantInterfaceImpl
Definition qmetatype.h:864

QtMetaTypePrivate::QPairVariantInterfaceImpl::second
void second(void *dataPtr) const
Definition qmetatype.h:900

QtMetaTypePrivate::QPairVariantInterfaceImpl::first
void first(void *dataPtr) const
Definition qmetatype.h:899

QtPrivate::QMetaTypeInterface
Definition qmetatype.h:273

QtPrivate::QMetaTypeInterface::legacyRegisterOp
LegacyRegisterOp legacyRegisterOp
Definition qmetatype.h:313

qfloat16
\keyword 16-bit Floating Point Support\inmodule QtCore \inheaderfile QFloat16
Definition qfloat16.h:57

QJsonPrivate
Definition qcborarray.h:17

QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qrandomaccessasyncfile_darwin.mm:17

QtMetaTypePrivate
Definition qmetatype.h:861

QtPrivate
Definition qalloc.h:29

std
[33]
Definition src_corelib_tools_qhash.cpp:421

QMutableByteArrayListIterator
QMutableListIterator< QByteArray > QMutableByteArrayListIterator
Definition qbytearraylist.h:20

QCborSimpleType
QCborSimpleType
Definition qcborcommon.h:29

operator<<
Q_CORE_EXPORT QDebug operator<<(QDebug debug, QDir::Filters filters)
Definition qdir.cpp:2582

QVariantList
QList< QVariant > QVariantList
Definition qjsonarray.h:16

qCWarning
#define qCWarning(category,...)
Definition qloggingcategory.h:164

Q_STATIC_LOGGING_CATEGORY
#define Q_STATIC_LOGGING_CATEGORY(name,...)
Definition qloggingcategory.h:154

CONVERT_CBOR_AND_JSON
#define CONVERT_CBOR_AND_JSON(To)

NS
#define NS(x)
Definition qmetatype.cpp:73

QMETATYPE_CONVERTER_ASSIGN_QCHAR
#define QMETATYPE_CONVERTER_ASSIGN_QCHAR(From)

QMETATYPE_CONVERTER_ASSIGN_DOUBLE
#define QMETATYPE_CONVERTER_ASSIGN_DOUBLE(To, From)

INTEGRAL_CONVERTER
#define INTEGRAL_CONVERTER(To)

tryConvertBuiltinTypes
static bool tryConvertBuiltinTypes(const void *from, int fromTypeId, void *to, int toTypeId)
Definition qmetatype.cpp:1773

QMETATYPE_CONVERTER_ASSIGN_NUMBER
#define QMETATYPE_CONVERTER_ASSIGN_NUMBER(To, From)

qIntegerConversionFromFPHelper
static bool qIntegerConversionFromFPHelper(From from, To *to)
Definition qmetatype.cpp:1039

FLOAT_CONVERTER
#define FLOAT_CONVERTER(To)

QT_FOR_EACH_STATIC_CORE_POINTER
#define QT_FOR_EACH_STATIC_CORE_POINTER(F)
Definition qmetatype.h:138

QT_FOR_EACH_STATIC_PRIMITIVE_TYPE
#define QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(F)
Definition qmetatype.h:71

QT_FOR_EACH_STATIC_PRIMITIVE_NON_VOID_TYPE
#define QT_FOR_EACH_STATIC_PRIMITIVE_NON_VOID_TYPE(F)
Definition qmetatype.h:51

QT_FOR_EACH_STATIC_CORE_TEMPLATE
#define QT_FOR_EACH_STATIC_CORE_TEMPLATE(F)
Definition qmetatype.h:152

QT_FOR_EACH_STATIC_PRIMITIVE_POINTER
#define QT_FOR_EACH_STATIC_PRIMITIVE_POINTER(F)
Definition qmetatype.h:75

QT_IMPL_METATYPE_EXTERN_TAGGED
#define QT_IMPL_METATYPE_EXTERN_TAGGED(TYPE, TAG)
Definition qmetatype.h:1375

QT_FOR_EACH_STATIC_CORE_CLASS
#define QT_FOR_EACH_STATIC_CORE_CLASS(F)
Definition qmetatype.h:106

QT_FOR_EACH_STATIC_ALIAS_TYPE
#define QT_FOR_EACH_STATIC_ALIAS_TYPE(F)
Definition qmetatype.h:194

QT_FOR_EACH_STATIC_TYPE
#define QT_FOR_EACH_STATIC_TYPE(F)
Definition qmetatype.h:224

QMETATYPE_CONVERTER
#define QMETATYPE_CONVERTER(To, From, assign_and_return)
Definition qmetatype_p.h:24

QMETATYPE_CONVERTER_ASSIGN
#define QMETATYPE_CONVERTER_ASSIGN(To, From)
Definition qmetatype_p.h:35

QStringLiteral
#define QStringLiteral(str)
Definition qstring.h:1825

QCborParserError
\inmodule QtCore\reentrant
Definition qcborvalue.h:38

QCborParserError::offset
qint64 offset
Definition qcborvalue.h:39

QCborParserError::errorString
QString errorString() const
\variable QCborParserError::offset
Definition qcborvalue.h:42

QCborParserError::error
QCborError error
Definition qcborvalue.h:40

QListSpecialMethodsBase
Definition qlist.h:33

QListSpecialMethods< QByteArray >
Definition qbytearraylist.h:38

QListSpecialMethods< QByteArray >::~QListSpecialMethods
~QListSpecialMethods()=default

QListSpecialMethods< QByteArray >::operator=
QListSpecialMethods & operator=(const QListSpecialMethods &)=default

QListSpecialMethods< QByteArray >::QListSpecialMethods
QListSpecialMethods(QListSpecialMethods &&)=default

QListSpecialMethods< QByteArray >::operator=
QListSpecialMethods & operator=(QListSpecialMethods &&)=default

QListSpecialMethods< QByteArray >::QListSpecialMethods
QListSpecialMethods()=default

QListSpecialMethods< QByteArray >::QListSpecialMethods
QListSpecialMethods(const QListSpecialMethods &)=default

QListSpecialMethods< QByteArray >::join
QByteArray join(QByteArrayView sep={}) const
Definition qbytearraylist.h:53

QListSpecialMethods
Definition qlist.h:55

QMetaTypeModuleHelper
Definition qmetatype_p.h:45

QtPrivate::QCborMapKeyValues
Definition qcbormap.h:24

QtPrivate::QCborMapKeyValues::value
static T value(const Iterator &it)
Definition qcbormap.h:27

QtPrivate::QCborMapKeyValues::value
static T value(Iterator &it)
Definition qcbormap.h:28

QtPrivate::QCborMapKeyValues::key
static QCborValueConstRef key(Iterator &it)
Definition qcbormap.h:26

QtPrivate::QCborMapKeyValues::key
static QCborValueConstRef key(const Iterator &it)
Definition qcbormap.h:25