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


#ifndef QCBORVALUE_H

#define QCBORVALUE_H


#include <QtCore/qbytearray.h>

#include <QtCore/qdatetime.h>

#include <QtCore/qcborcommon.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


#if 0 && __has_include(<compare>)

#  include <compare>

#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)

    {}


    explicit QCborValue(const QDateTime &dt);

#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;

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

#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 0 && __has_include(<compare>)

    std::strong_ordering operator<=>(const QCborValue &other) const

    {

        int c = compare(other);

        if (c > 0) return std::partial_ordering::greater;

        if (c == 0) return std::partial_ordering::equivalent;

        return std::partial_ordering::less;

    }

#else

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

    { return compare(other) == 0; }

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

    { return !(*this == 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 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)


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); }

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

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

#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); }

#if 0 && __has_include(<compare>)

    std::strong_ordering operator<=>(const QCborValue &other) const

    {

        int c = compare(other);

        if (c > 0) return std::strong_ordering::greater;

        if (c == 0) return std::strong_ordering::equivalent;

        return std::strong_ordering::less;

    }

#else

    bool operator==(const QCborValue &other) const

    { return compare(other) == 0; }

    bool operator!=(const QCborValue &other) const

    { return !(*this == other); }

    bool operator<(const QCborValue &other) const

    { return compare(other) < 0; }

#endif


    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); }


    static Q_CORE_EXPORT QCborValue concrete(QCborValueConstRef that) noexcept;

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

    static Q_CORE_EXPORT bool

    concreteBoolean(QCborValueConstRef that, bool defaultValue) noexcept Q_DECL_PURE_FUNCTION;

    static Q_CORE_EXPORT double

    concreteDouble(QCborValueConstRef that, double defaultValue) noexcept Q_DECL_PURE_FUNCTION;

    static Q_CORE_EXPORT qint64

    concreteIntegral(QCborValueConstRef that, qint64 defaultValue) noexcept Q_DECL_PURE_FUNCTION;

    static Q_CORE_EXPORT QByteArray

    concreteByteArray(QCborValueConstRef that, const QByteArray &defaultValue);

    static Q_CORE_EXPORT QString

    concreteString(QCborValueConstRef that, const QString &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); }

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

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

#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 0 && __has_include(<compare>)

    std::strong_ordering operator<=>(const QCborValue &other) const

    {

        int c = compare(other);

        if (c > 0) return std::strong_ordering::greater;

        if (c == 0) return std::strong_ordering::equivalent;

        return std::strong_ordering::less;

    }

#else

    bool operator==(const QCborValue &other) const

    { return compare(other) == 0; }

    bool operator!=(const QCborValue &other) const

    { return !(*this == 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); }


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

    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)


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


#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


#if defined(QT_X11_DEFINES_FOUND)

#  define True  1

#  define False 0

#endif


#endif // QCBORVALUE_H

QByteArray
\inmodule QtCore
Definition qbytearray.h:57

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

QCborContainerPrivate
Definition qcborvalue_p.h:94

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

QCborStreamReader
\inmodule QtCore\reentrant
Definition qcborstreamreader.h:28

QCborStreamWriter
\inmodule QtCore\reentrant
Definition qcborstreamwriter.h:30

QCborValueConstRef
Definition qcborvalue.h:298

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

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

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

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

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

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

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

QCborValueConstRef::operator!=
bool operator!=(const QCborValue &other) const
Definition qcborvalue.h:383

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

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

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

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

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

QCborValueConstRef::operator<
bool operator<(const QCborValue &other) const
Definition qcborvalue.h:385

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

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

QCborValueConstRef::toDateTime
QDateTime toDateTime(const QDateTime &defaultValue={}) const
Definition qcborvalue.h:347

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QCborValueConstRef::operator==
bool operator==(const QCborValue &other) const
Definition qcborvalue.h:381

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

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

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

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

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

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

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

QCborValueConstRef::toJsonValue
QJsonValue toJsonValue() const

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

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

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

QCborValue::isUndefined
bool isUndefined() const
Returns true if this QCborValue is of the undefined type.
Definition qcborvalue.h:168

QCborValue::isSimpleType
bool isSimpleType() const
Returns true if this QCborValue is of one of the CBOR simple types.
Definition qcborvalue.h:177

QCborValue::isDateTime
bool isDateTime() const
Returns true if this QCborValue is of the date/time type.
Definition qcborvalue.h:170

QCborValue::isString
bool isString() const
Returns true if this QCborValue is of the string type.
Definition qcborvalue.h:160

QCborValue::operator==
bool operator==(const QCborValue &other) const noexcept
Compares this value and other, and returns true if they hold the same contents, false otherwise.
Definition qcborvalue.h:234

QCborValue::EncodingOption
EncodingOption
This enum is used in the options argument to toCbor(), modifying the behavior of the encoder.
Definition qcborvalue.h:53

QCborValue::NoTransformation
@ NoTransformation
Definition qcborvalue.h:61

QCborValue::isNull
bool isNull() const
Returns true if this QCborValue is of the null type.
Definition qcborvalue.h:167

QCborValue::operator!=
bool operator!=(const QCborValue &other) const noexcept
Compares this value and other, and returns true if contents differ, false otherwise.
Definition qcborvalue.h:236

QCborValue::QCborValue
QCborValue(QCborSimpleType st)
Creates a QCborValue of simple type st.
Definition qcborvalue.h:110

QCborValue::QCborValue
QCborValue(QCborKnownTags t_, const QCborValue &tv=QCborValue())
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition qcborvalue.h:124

QCborValue::QCborValue
QCborValue(double v)
Creates a QCborValue with floating point value d.
Definition qcborvalue.h:109

QCborValue::QCborValue
QCborValue(QCborValue &&other) noexcept
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition qcborvalue.h:143

QCborValue::QCborValue
QCborValue(Type t_)
Creates a QCborValue of type t_.
Definition qcborvalue.h:101

QCborValue::isUrl
bool isUrl() const
Returns true if this QCborValue is of the URL type.
Definition qcborvalue.h:171

QCborValue::isByteArray
bool isByteArray() const
Returns true if this QCborValue is of the byte array type.
Definition qcborvalue.h:159

QCborValue::toInteger
qint64 toInteger(qint64 defaultValue=0) const
Returns the integer value stored in this QCborValue, if it is of the integer type.
Definition qcborvalue.h:190

QCborValue::Type
Type
This enum represents the QCborValue type.
Definition qcborvalue.h:73

QCborValue::False
@ False
Definition qcborvalue.h:83

QCborValue::Uuid
@ Uuid
Definition qcborvalue.h:94

QCborValue::Undefined
@ Undefined
Definition qcborvalue.h:86

QCborValue::Invalid
@ Invalid
Definition qcborvalue.h:96

QCborValue::Integer
@ Integer
Definition qcborvalue.h:74

QCborValue::Url
@ Url
Definition qcborvalue.h:92

QCborValue::ByteArray
@ ByteArray
Definition qcborvalue.h:75

QCborValue::DateTime
@ DateTime
Definition qcborvalue.h:91

QCborValue::String
@ String
Definition qcborvalue.h:76

QCborValue::True
@ True
Definition qcborvalue.h:84

QCborValue::Double
@ Double
Definition qcborvalue.h:88

QCborValue::Map
@ Map
Definition qcborvalue.h:78

QCborValue::Array
@ Array
Definition qcborvalue.h:77

QCborValue::SimpleType
@ SimpleType
Definition qcborvalue.h:82

QCborValue::RegularExpression
@ RegularExpression
Definition qcborvalue.h:93

QCborValue::Null
@ Null
Definition qcborvalue.h:85

QCborValue::operator<
bool operator<(const QCborValue &other) const
Compares this value and other, and returns true if this value should be sorted before other,...
Definition qcborvalue.h:238

QCborValue::~QCborValue
~QCborValue()
Disposes of the current QCborValue object and frees any associated resources.
Definition qcborvalue.h:137

QCborValue::isBool
bool isBool() const
Returns true if this QCborValue is a boolean.
Definition qcborvalue.h:166

QCborValue::isRegularExpression
bool isRegularExpression() const
Returns true if this QCborValue contains a regular expression's pattern.
Definition qcborvalue.h:172

QCborValue::isDouble
bool isDouble() const
Returns true if this QCborValue is of the floating-point type.
Definition qcborvalue.h:169

QCborValue::isContainer
bool isContainer() const
This convenience function returns true if the QCborValue is either an array or a map.
Definition qcborvalue.h:175

QCborValue::QCborValue
QCborValue(int i)
Definition qcborvalue.h:105

QCborValue::isInvalid
bool isInvalid() const
Returns true if this QCborValue is not of any valid type.
Definition qcborvalue.h:174

QCborValue::QCborValue
QCborValue(bool b_)
Creates a QCborValue with boolean value b.
Definition qcborvalue.h:103

QCborValue::isInteger
bool isInteger() const
Returns true if this QCborValue is of the integer type.
Definition qcborvalue.h:158

QCborValue::type
Type type() const
Returns the type of this QCborValue.
Definition qcborvalue.h:157

QCborValue::toDouble
double toDouble(double defaultValue=0) const
Returns the floating point value stored in this QCborValue, if it is of the Double type.
Definition qcborvalue.h:194

QCborValue::toSimpleType
QCborSimpleType toSimpleType(QCborSimpleType defaultValue=QCborSimpleType::Undefined) const
Returns the simple type this QCborValue is of, if it is a simple type.
Definition qcborvalue.h:185

QCborValue::isTag
bool isTag() const
Returns true if this QCborValue is of the tag type.
Definition qcborvalue.h:163

QCborValue::isArray
bool isArray() const
Returns true if this QCborValue is of the array type.
Definition qcborvalue.h:161

QCborValue::QCborValue
QCborValue(qint64 i)
Creates a QCborValue with integer value i.
Definition qcborvalue.h:108

QCborValue::isUuid
bool isUuid() const
Returns true if this QCborValue contains a UUID.
Definition qcborvalue.h:173

QCborValue::QCborValue
QCborValue(std::nullptr_t)
Creates a QCborValue of the \l {Type}{Null} type.
Definition qcborvalue.h:102

QCborValue::QCborValue
QCborValue(const void *)=delete

QCborValue::isTrue
bool isTrue() const
Returns true if this QCborValue is a boolean with true value.
Definition qcborvalue.h:165

QCborValue::isFalse
bool isFalse() const
Returns true if this QCborValue is a boolean with false value.
Definition qcborvalue.h:164

QCborValue::isSimpleType
bool isSimpleType(QCborSimpleType st) const
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition qcborvalue.h:181

QCborValue::QCborValue
QT_ASCII_CAST_WARN QCborValue(const char *s)
Definition qcborvalue.h:117

QCborValue::isMap
bool isMap() const
Returns true if this QCborValue is of the map type.
Definition qcborvalue.h:162

QCborValue::DiagnosticNotationOption
DiagnosticNotationOption
This enum is used in the option argument to toDiagnosticNotation(), to modify the output format.
Definition qcborvalue.h:65

QCborValue::Compact
@ Compact
Definition qcborvalue.h:66

QCborValue::taggedValue
QCborValue taggedValue(const QCborValue &defaultValue=QCborValue()) const
Returns the tagged value of this extended QCborValue object, if it is of the tag type,...
Definition qcborvalue.cpp:1940

QCborValue::QCborValue
QCborValue(unsigned u)
Definition qcborvalue.h:106

QCborValue::toBool
bool toBool(bool defaultValue=false) const
Returns the boolean value stored in this QCborValue, if it is of a boolean type.
Definition qcborvalue.h:192

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

QDateTime
\inmodule QtCore\reentrant
Definition qdatetime.h:257

QDebug
\inmodule QtCore

QJsonPrivate::Value
Definition qjson_p.h:172

QJsonValue
\inmodule QtCore\reentrant
Definition qjsonvalue.h:24

QLatin1StringView
Definition qlatin1stringview.h:31

QList< QPair< QString, QString > >

QRegularExpression
\inmodule QtCore \reentrant
Definition qregularexpression.h:31

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

QStringView
\inmodule QtCore
Definition qstringview.h:76

QString
\macro QT_RESTRICTED_CAST_FROM_ASCII
Definition qstring.h:127

QUrl
\inmodule QtCore
Definition qurl.h:94

QUuid
\inmodule QtCore
Definition quuid.h:31

QVariant
\inmodule QtCore
Definition qvariant.h:64

i
i
[1]
Definition doc_src_containers.cpp:167

opt
QStyleOptionButton opt
Definition doc_src_styles.cpp:51

QJsonPrivate
Definition qcborarray.h:16

QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qstandardpaths_haiku.cpp:21

QT_END_NAMESPACE
Definition qsharedpointer.cpp:1545

QV4::ObjectLiteralArgument::Value
@ Value

QtStringBuilder::isNull
bool isNull(const T &t)
Definition qstringbuilder.h:45

trace::toByteArray
void toByteArray(QByteArray &)
Definition qctf_p.h:78

QCborKnownTags
QCborKnownTags
Definition qcborcommon.h:31

QCborKnownTags::Url
@ Url

QCborKnownTags::Uuid
@ Uuid

QCborKnownTags::RegularExpression
@ RegularExpression

QCborTag
QCborTag
Definition qcborcommon.h:30

QCborSimpleType
QCborSimpleType
Definition qcborcommon.h:23

QCborSimpleType::Null
@ Null

QCborSimpleType::Undefined
@ Undefined

QCborSimpleType::True
@ True

QCborSimpleType::False
@ False

qHash
QT_WARNING_PUSH class QT6_ONLY(Q_CORE_EXPORT) QCborValueRef QT_WARNING_POP Q_CORE_EXPORT size_t qHash(const QCborValue &value, size_t seed=0)
Definition qcborvalue.cpp:2854

operator<<
Q_CORE_EXPORT QDebug operator<<(QDebug, const QCborValue &v)
Definition qcborvalue.cpp:3041

operator>>
Q_CORE_EXPORT QDataStream & operator>>(QDataStream &, QCborValue &)
Definition qcborvalue.cpp:3091

Q_DECL_PURE_FUNCTION
#define Q_DECL_PURE_FUNCTION
Definition qcompilerdetection.h:1070

QT_WARNING_POP
#define QT_WARNING_POP
Definition qcompilerdetection.h:1158

QT_WARNING_DISABLE_MSVC
#define QT_WARNING_DISABLE_MSVC(number)
Definition qcompilerdetection.h:1160

QT_WARNING_PUSH
#define QT_WARNING_PUSH
Definition qcompilerdetection.h:1157

operator!=
constexpr bool operator!=(const timespec &t1, const timespec &t2)
Definition qcore_unix_p.h:114

tag
AudioChannelLayoutTag tag
Definition qcoreaudioutils.mm:175

void
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction void DBusFreeFunction return DBusConnection return DBusConnection return const char DBusError return DBusConnection DBusMessage dbus_uint32_t return DBusConnection dbus_bool_t DBusConnection DBusAddWatchFunction DBusRemoveWatchFunction DBusWatchToggledFunction void DBusFreeFunction return DBusConnection DBusDispatchStatusFunction void DBusFreeFunction DBusTimeout return DBusTimeout return DBusWatch return DBusWatch unsigned int return DBusError const DBusError return const DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessageIter int const void return DBusMessageIter DBusMessageIter return DBusMessageIter void DBusMessageIter void int return DBusMessage DBusMessageIter return DBusMessageIter return DBusMessageIter DBusMessageIter const char const char const char const char return DBusMessage return DBusMessage const char return DBusMessage dbus_bool_t return DBusMessage dbus_uint32_t return DBusMessage void
Definition qdbus_symbols_p.h:401

error
DBusConnection const char DBusError * error
Definition qdbus_symbols_p.h:157

value
EGLOutputLayerEXT EGLint EGLAttrib value
[5]
Definition qeglstreamconvenience_p.h:46

Q_DECLARE_FLAGS
#define Q_DECLARE_FLAGS(Flags, Enum)
Definition qflags.h:174

Q_DECLARE_OPERATORS_FOR_FLAGS
#define Q_DECLARE_OPERATORS_FOR_FLAGS(Flags)
Definition qflags.h:194

Invalid
@ Invalid
Definition qmetaobject_p.h:35

v
GLsizei const GLfloat * v
[13]
Definition qopengles2ext.h:788

m
const GLfloat * m
Definition qopengles2ext.h:3203

key
GLuint64 key
Definition qopengles2ext.h:2268

a
GLboolean GLboolean GLboolean GLboolean a
[7]
Definition qopengles2ext.h:337

type
GLenum type
Definition qopengles2ext.h:150

data
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
Definition qopengles2ext.h:206

offset
GLenum GLuint GLintptr offset
Definition qopengles2ext.h:660

n
GLfloat n
Definition qopengles2ext.h:795

c
const GLubyte * c
Definition qopenglext.h:12701

len
GLenum GLsizei len
Definition qopenglext.h:3292

t
GLdouble GLdouble t
Definition qopenglext.h:243

s
GLdouble s
[6]
Definition qopenglext.h:235

seed
static Q_CONSTINIT QBasicAtomicInteger< unsigned > seed
Definition qrandom.cpp:196

operator==
bool operator==(const QRandomGenerator &rng1, const QRandomGenerator &rng2)
Definition qrandom.cpp:1219

QT6_ONLY
QT_BEGIN_NAMESPACE class QT6_ONLY(Q_CORE_EXPORT) QReadWriteLock
Definition qreadwritelock.h:189

operator<
static bool operator<(const QSettingsIniKey &k1, const QSettingsIniKey &k2)
Definition qsettings.cpp:1721

MimerColumnTypes::Double
@ Double

QSSGRenderShaderDataType::Integer
@ Integer

qt_ptr_swap
constexpr void qt_ptr_swap(T *&lhs, T *&rhs) noexcept
Definition qswap.h:43

QT_ASCII_CAST_WARN
#define QT_ASCII_CAST_WARN
Definition qtdeprecationmarkers.h:326

Q_ENUM
#define Q_ENUM(x)
Definition qtmetamacros.h:68

Q_GADGET
#define Q_GADGET
Definition qtmetamacros.h:152

Tag
Tag
Definition qtranslator.cpp:42

compare
static int compare(quint64 a, quint64 b)
Definition qtriangulator.cpp:68

qsizetype
ptrdiff_t qsizetype
Definition qtypes.h:70

qint64
long long qint64
Definition qtypes.h:55

quint8
unsigned char quint8
Definition qtypes.h:41

Map
QList< QPair< QString, QString > > Map
Definition qurlquery.cpp:133

toVariant
static QVariant toVariant(const QV4::Value &value, QMetaType typeHint, bool createJSValueForObjectsAndSymbols, V4ObjectSet *visitedObjects)
Definition qv4engine.cpp:1494

toDouble
static double toDouble(Value v)
Definition qv4typedarray.cpp:31

ba
QByteArray ba
[0]
Definition src_corelib_io_qdebug.cpp:31

url
QUrl url("example.com")
[constructor-url-reference]
Definition src_corelib_io_qurl.cpp:19

nullptr
QObject::connect nullptr
Definition src_corelib_kernel_qobject.cpp:255

variant
QVariant variant
[1]
Definition src_corelib_kernel_qvariant.cpp:30

toMap
value toMap().value(key)
[3]

isSimpleType
value isSimpleType(QCborSimpleType(12))
[1]

d
double d
Definition src_corelib_text_qlocale.cpp:9

rx
p rx()++

other
QSharedPointer< T > other(t)
[5]

toString
char * toString(const MyType &t)
[31]
Definition src_qtestlib_qtestcase_snippet.cpp:115

QCborError
\inmodule QtCore \inheaderfile QtCborCommon \reentrant
Definition qcborcommon.h:63

QCborError::toString
QString toString() const
Returns a text string that matches the error code in this QCborError object.
Definition qcborcommon.cpp:239

QCborError::NoError
@ NoError
Definition qcborcommon.h:84

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

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

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

Type
Definition moc.h:24

toBool
QT_BEGIN_NAMESPACE bool toBool(const QString &str)
Definition utils.h:14