qcborvalue.cpp

Go to the documentation of this file.

// 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
 
#include "qcborvalue.h"
#include "qcborvalue_p.h"
#include "qdatastream.h"
#include "qcborarray.h"
#include "qcbormap.h"
 
#if QT_CONFIG(cborstreamreader)
#include "qcborstreamreader.h"
#endif
 
#if QT_CONFIG(cborstreamwriter)
#include "qcborstreamwriter.h"
#endif
 
#include <QtCore/qdebug.h>
#include <qendian.h>
#include <qlocale.h>
#include <qdatetime.h>
#include <qtimezone.h>
#include <private/qnumeric_p.h>
#include <private/qsimd_p.h>
 
#include <new>
 
QT_BEGIN_NAMESPACE
 
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QCborContainerPrivate)
 
// Worst case memory allocation for a corrupt stream: 256 MB for 32-bit, 1 GB for 64-bit
static constexpr quint64 MaxAcceptableMemoryUse = (sizeof(void*) == 4 ? 256 : 1024) * 1024 * 1024;
 
// Internal limits to ensure we don't blow up the memory when parsing a corrupt
// (possibly crafted to exploit) CBOR stream. The recursion impacts both the
// maps/arrays we'll open when parsing and the thread's stack, as the parser is
// itself recursive. If someone really needs more than 1024 layers of nesting,
// they probably have a weird use-case for which custom parsing and
// serialisation code would make sense. The limit on element count is the
// preallocated limit: if the stream does actually have more elements, we will
// grow the container.
Q_DECL_UNUSED static constexpr int MaximumRecursionDepth = 1024;
Q_DECL_UNUSED static constexpr quint64 MaximumPreallocatedElementCount =
        MaxAcceptableMemoryUse / MaximumRecursionDepth / sizeof(QtCbor::Element) - 1;
 
/*!
    \class QCborValue
    \inmodule QtCore
    \ingroup cbor
    \ingroup qtserialization
    \reentrant
    \since 5.12
 
    \brief The QCborValue class encapsulates a value in CBOR.
 
    \compares strong
 
    This class can be used to hold one of the many types available in CBOR.
    CBOR is the Concise Binary Object Representation, a very compact form of
    binary data encoding that is a superset of JSON. It was created by the IETF
    Constrained RESTful Environments (CoRE) WG, which has used it in many
    new RFCs. It is meant to be used alongside the
    \l{RFC 7252}{CoAP protocol}.
 
    CBOR has three groups of built-in types:
 
    \list
      \li Basic types: integers, floating point (double), boolean, null, etc.
      \li String-like types: strings and byte arrays
      \li Containers: arrays and maps
    \endlist
 
    Additionally, CBOR supports a form of type extensibility by associating a
    "tag" to one of the above types to convey more information. For example, a
    UUID is represented by a tag and a byte array containing the 16 bytes of
    the UUID content. QCborValue supports creating and decoding several of those
    extended types directly with Qt classes (like QUuid).
 
    For the complete list, see \l QCborValue::Type. The type of a QCborValue can
    be queried using type() or one of the "isXxxx" functions.
 
    \section1 Extended types and tagged values
 
    A tagged value is a normal QCborValue that is paired with a number that
    is its tag. See \l QCborKnownTags for more information on what tags are in
    the API as well as the full, official list. Such combinations form extended
    types.
 
    QCborValue has support for certain extended types in the API, like URL
    (with \l QUrl) and UUID (with \l QUuid). Other extended types not supported
    in the API are represented by a QCborValue of \l {Type}{Tag} type. The tag
    can later be retrieved by tag() and the tagged value using taggedValue().
 
    In order to support future compatibility, QCborValues containing extended
    Qt types compare equal to the tag type of the same contents. In other
    words, the following expression is true:
 
    \snippet code/src_corelib_serialization_qcborvalue.cpp 0
 
    \section1 Undefined and null values
 
    QCborValue can contain a value of "null", which is not of any specific type.
    It resembles the C++ \c {std::nullptr_t} type, whose only possible value is
    \nullptr. QCborValue has a constructor taking such a type and creates a
    null QCborValue.
 
    Null values are used to indicate that an optional value is not present. In
    that aspect, it is similar to the C++ Standard Library type \c
    {std::optional} when that is disengaged. Unlike the C++ type, CBOR nulls
    are simply of type "Null" and it is not possible to determine what concrete
    type it is replacing.
 
    QCborValue can also be of the undefined type, which represents a value of
    "undefined". In fact, that is what the QCborValue default constructor
    creates.
 
    Undefined values are different from null values. While nulls are used to
    indicate an optional value that is not provided, Undefined is usually
    used to indicate that an expected value could not be provided, usually due
    to an error or a precondition that could not be satisfied.
 
    Such values are completely valid and may appear in CBOR streams, unlike
    JSON content and QJsonValue's undefined bit. But like QJsonValue's
    Undefined, it is returned by a CBOR container's value() or read-only
    operator[] for invalid look-ups (index out of range for QCborArray, or key
    not found for QCborMap). It is not possible to tell such a case apart from
    the value of Undefined, so if that is required, check the QCborArray size
    and use the QCborMap iterator API.
 
    \section1 Simple types
 
    CBOR supports additional simple types that, like Null and Undefined, carry
    no other value. They are called interchangeably "Simple Types" and "Simple
    Values". CBOR encodes booleans as two distinct types (one for \c true and
    one for \c false), but QCborValue has a convenience API for them.
 
    There are currently no other defined CBOR simple types. QCborValue supports
    them simply by their number with API like isSimpleType() and
    toSimpleType(), available for compatibility with future specifications
    before the Qt API can be updated. Their use before such a specification is
    discouraged, as other CBOR implementations may not support them fully.
 
    \section1 CBOR support
 
    QCborValue supports all CBOR features required to create canonical and
    strict streams. It implements almost all of the features specified in \l
    {RFC 7049}.
 
    The following table lists the CBOR features that QCborValue supports.
 
    \table
      \header \li Feature                        \li Support
      \row   \li Unsigned numbers                \li Yes (\l qint64 range)
      \row   \li Negative numbers                \li Yes (\l qint64 range)
      \row   \li Byte strings                    \li Yes
      \row   \li Text strings                    \li Yes
      \row   \li Chunked strings                 \li See below
      \row   \li Tags                            \li Yes (arbitrary)
      \row   \li Booleans                        \li Yes
      \row   \li Null                            \li Yes
      \row   \li Undefined                       \li Yes
      \row   \li Arbitrary simple values         \li Yes
      \row   \li Half-precision float (16-bit)   \li Yes
      \row   \li Single-precision float (32-bit) \li Yes
      \row   \li Double-precision float (64-bit) \li Yes
      \row   \li Infinities and NaN floating point \li Yes
      \row   \li Determinate-length arrays and maps \li Yes
      \row   \li Indeterminate-length arrays and maps \li Yes
      \row   \li Map key types other than strings and integers \li Yes (arbitrary)
    \endtable
 
    Integers in QCborValue are limited to the range of the \l qint64 type. That
    is, from -9,223,372,036,854,775,808 (-2\sup{63}) to
    9,223,372,036,854,775,807 (2\sup{63} - 1). CBOR itself can represent integer
    values outside of this range, which QCborValue does not support. When
    decoding a stream using fromCbor() containing one of those values,
    QCborValue will convert automatically to \l {Type}{Double}, but that may
    lose up to 11 bits of precision.
 
    fromCbor() is able to decode chunked strings, but will always merge the
    chunks together into a single QCborValue. For that reason, it always writes
    non-chunked strings when using toCbor() (which is required by the Canonical
    format anyway).
 
    QCborValue will always convert half- and single-precision floating point
    values in the CBOR stream to double-precision. The toCbor() function can
    take a parameter indicating to recreate them.
 
    \section1 QCborValueRef
 
    QCborValueRef is a helper class for QCborArray and QCborMap. It is the type
    you get when using one of the mutating APIs in those classes. Unlike
    QCborValue, new values can be assigned to that class. When that is done, the
    array or map it refers to will be modified with the new value. In all other
    aspects, its API is identical to QCborValue.
 
    \sa QCborArray, QCborMap, QCborStreamReader, QCborStreamWriter,
        QJsonValue, QJsonDocument, {Serialization Converter}, {Saving and Loading a Game}
        {Parsing and displaying CBOR data}
 */
 
/*!
    \class QCborParserError
    \inmodule QtCore
    \ingroup cbor
    \reentrant
    \since 5.12
 
    \brief The QCborParserError is used by QCborValue to report a parsing error.
 
    This class is used by \l {QCborValue::fromCbor(const QByteArray &ba,
    QCborParserError *error)} to report a parser error and the byte offset
    where the error was detected.
 
    \sa QCborValue, QCborError
 */
 
/*!
    \variable QCborParserError::offset
 
    This field contains the offset from the beginning of the data where the
    error was detected. The offset should point to the beginning of the item
    that contained the error, even if the error itself was elsewhere (for
    example, for UTF-8 decoding issues).
 
    \sa QCborValue::fromCbor()
 */
 
/*!
    \variable QCborParserError::error
 
    This field contains the error code that indicates what decoding problem was
    found.
 
    \sa QCborValue::fromCbor()
 */
 
/*!
    \fn QString QCborParserError::errorString() const
 
    Returns a string representation of the error code. This string is not
    translated.
 
    \sa QCborError::toString(), QCborValue::fromCbor()
 */
 
/*!
    \enum QCborValue::EncodingOption
 
    This enum is used in the options argument to toCbor(), modifying the
    behavior of the encoder.
 
    \omitvalue SortKeysInMaps
    \value NoTransformation (Default) Performs no transformations.
    \value UseFloat         Tells the encoder to use IEEE 754 single-precision floating point
                            (that is, \c float) whenever possible.
    \value UseFloat16       Tells the encoder to use IEEE 754 half-precision floating point
                            (that is, \c qfloat16), whenever possible. Implies \c UseFloat.
    \value UseIntegers      Tells the encoder to use integers whenever a value of type \l
                            {Type}{Double} contains an integer.
 
    The use of \c UseFloat16 is required to encode the stream in Canonical
    Format, but is not otherwise necessary.
 
    \sa toCbor()
 */
 
/*!
    \enum QCborValue::DiagnosticNotationOption
 
    This enum is used in the option argument to toDiagnosticNotation(), to
    modify the output format.
 
    \value Compact          Does not use any line-breaks, producing a compact representation.
    \value LineWrapped      Uses line-breaks, one QCborValue per line.
    \value ExtendedFormat   Uses some different options to represent values, not found in
                            RFC 7049. Those options are subject to change.
 
    Currently, \c ExtendedFormat will change how byte arrays are represented.
    Without it, they are always hex-encoded and without spaces. With it,
    QCborValue::toCbor() will either use hex with spaces, base64 or base64url
    encoding, depending on the context.
 
    \sa toDiagnosticNotation()
 */
 
/*!
    \enum QCborValue::Type
 
    This enum represents the QCborValue type. It is returned by the type()
    function.
 
    The CBOR built-in types are:
 
    \value Integer              \c qint64: An integer value
    \value ByteArray            \l QByteArray: a byte array ("byte string")
    \value String               \l QString: a Unicode string ("text string")
    \value Array                \l QCborArray: an array of QCborValues
    \value Map                  \l QCborMap: an associative container of QCborValues
    \value SimpleType           \l QCborSimpleType: one of several simple types/values
    \value False                \c bool: the simple type for value \c false
    \value True                 \c bool: the simple type for value \c true
    \value Null                 \c std::nullptr_t: the simple type for the null value
    \value Undefined            (no type) the simple type for the undefined value
    \value Double               \c double: a double-precision floating point
    \value Invalid              Not a valid value, this usually indicates a CBOR decoding error
 
    Additionally, QCborValue can represent extended types:
 
    \value Tag                  An unknown or unrecognized extended type, represented by its
                                tag (a \l QCborTag) and the tagged value (a QCborValue)
    \value DateTime             \l QDateTime: a date and time stamp
    \value Url                  \l QUrl: a URL or URI
    \value RegularExpression    \l QRegularExpression: the pattern of a regular expression
    \value Uuid                 \l QUuid: a UUID
 
    \sa type()
 */
 
/*!
    \fn QCborValue::QCborValue()
 
    Creates a QCborValue of the \l {Type}{Undefined} type.
 
    CBOR undefined values are used to indicate missing information, usually as
    a result of a previous operation that did not complete as expected. They
    are also used by the QCborArray and QCborMap API to indicate the searched
    item was not found.
 
    Undefined values are represented by the \l {QCborSimpleType}{Undefined
    simple type}. Because of that, QCborValues with undefined values will also
    return true for isSimpleType() and
    \c{isSimpleType(QCborSimpleType::Undefined)}.
 
    Undefined values are different from null values.
 
    QCborValue objects with undefined values are also different from invalid
    QCborValue objects. The API will not create invalid QCborValues, but they
    may exist as a result of a parsing error.
 
    \sa isUndefined(), isNull(), isSimpleType()
 */
 
/*!
    \fn QCborValue::QCborValue(Type t_)
 
    Creates a QCborValue of type \a t_. The value associated with such a type
    (if any) will be default constructed.
 
    \sa type()
 */
 
/*!
    \fn QCborValue::QCborValue(std::nullptr_t)
 
    Creates a QCborValue of the \l {Type}{Null} type.
 
    CBOR null values are used to indicate optional values that were not
    provided. They are distinct from undefined values, in that null values are
    usually not the result of an earlier error or problem.
 
    \sa isNull(), isUndefined(), isSimpleType()
 */
 
/*!
    \fn QCborValue::QCborValue(bool b)
 
    Creates a QCborValue with boolean value \a b. The value can later be
    retrieved using toBool().
 
    Internally, CBOR booleans are represented by a pair of types, one for true
    and one for false. For that reason, boolean QCborValues will return true
    for isSimpleType() and one of \c{isSimpleType(QCborSimpleType::False)} or
    \c{isSimpleType(QCborSimpleType::True)}.
 
    \sa toBool(), isBool(), isTrue(), isFalse(), isSimpleType()
 */
 
/*!
    \fn QCborValue::QCborValue(qint64 i)
 
    Creates a QCborValue with integer value \a i. The value can later be
    retrieved using toInteger().
 
    CBOR integer values are distinct from floating point values. Therefore,
    QCborValue objects with integers will compare differently to QCborValue
    objects containing floating-point, even if the values contained in the
    objects are equivalent.
 
    \sa toInteger(), isInteger(), isDouble()
 */
 
/*!
    \fn QCborValue::QCborValue(double d)
 
    Creates a QCborValue with floating point value \a d. The value can later be
    retrieved using toDouble().
 
    CBOR floating point values are distinct from integer values. Therefore,
    QCborValue objects with integers will compare differently to QCborValue
    objects containing floating-point, even if the values contained in the
    objects are equivalent.
 
    \sa toDouble(), isDouble(), isInteger()
 */
 
/*!
    \fn QCborValue::QCborValue(QCborSimpleType st)
 
    Creates a QCborValue of simple type \a st. The type can later be retrieved
    using toSimpleType() as well as isSimpleType(st).
 
    CBOR simple types are types that do not have any associated value, like
    C++'s \c{std::nullptr_t} type, whose only possible value is \nullptr.
 
    If \a st is \c{QCborSimpleType::Null}, the resulting QCborValue will be of
    the \l{Type}{Null} type and similarly for \c{QCborSimpleType::Undefined}.
    If \a st is \c{QCborSimpleType::False} or \c{QCborSimpleType::True}, the
    created QCborValue will be a boolean containing a value of false or true,
    respectively.
 
    This function can be used with simple types not defined in the API. For
    example, to create a QCborValue with simple type 12, one could write:
 
    \snippet code/src_corelib_serialization_qcborvalue.cpp 1
 
    Simple types should not be used until a specification for them has been
    published, since other implementations may not support them properly.
    Simple type values 24 to 31 are reserved and must not be used.
 
    isSimpleType(), isNull(), isUndefined(), isTrue(), isFalse()
 */
 
/*!
    \fn QCborValue::QCborValue(QCborKnownTags tag, const QCborValue &taggedValue)
    \overload
 
    Creates a QCborValue for the extended type represented by the tag value \a
    tag, tagging value \a taggedValue. The tag can later be retrieved using
    tag() and the tagged value using taggedValue().
 
    \sa isTag(), tag(), taggedValue(), QCborKnownTags
 */
 
/*!
    \fn QCborValue::~QCborValue()
 
    Disposes of the current QCborValue object and frees any associated resources.
 */
 
/*!
    \fn QCborValue::QCborValue(QCborValue &&other)
    \overload
 
    Moves the contents of the \a other QCborValue object into this one and frees
    the resources of this one.
 */
 
/*!
    \fn QCborValue &&QCborValue::operator=(QCborValue &&other)
    \overload
 
    Moves the contents of the \a other QCborValue object into this one and frees
    the resources of this one. Returns a reference to this object.
 */
 
/*!
    \fn void QCborValue::swap(QCborValue &other)
    \memberswap{value}
 */
 
/*!
    \fn QCborValue::Type QCborValue::type() const
 
    Returns the type of this QCborValue. The type can also later be retrieved by one
    of the "isXxx" functions.
 
    \sa isInteger(), isByteArray(), isString(), isArray(), isMap(),
        isTag(), isFalse(), isTrue(), isBool(), isNull(), isUndefined, isDouble(),
        isDateTime(), isUrl(), isRegularExpression(), isUuid()
 */
 
/*!
    \fn bool QCborValue::isInteger() const
 
    Returns true if this QCborValue is of the integer type. The integer value
    can be retrieved using toInteger().
 
    \sa type(), toInteger()
 */
 
/*!
    \fn bool QCborValue::isByteArray() const
 
    Returns true if this QCborValue is of the byte array type. The byte array
    value can be retrieved using toByteArray().
 
    \sa type(), toByteArray()
 */
 
/*!
    \fn bool QCborValue::isString() const
 
    Returns true if this QCborValue is of the string type. The string value
    can be retrieved using toString().
 
    \sa type(), toString()
 */
 
/*!
    \fn bool QCborValue::isArray() const
 
    Returns true if this QCborValue is of the array type. The array value can
    be retrieved using toArray().
 
    \sa type(), toArray()
 */
 
/*!
    \fn bool QCborValue::isMap() const
 
    Returns true if this QCborValue is of the map type. The map value can be
    retrieved using toMap().
 
    \sa type(), toMap()
 */
 
/*!
    \fn bool QCborValue::isTag() const
 
    Returns true if this QCborValue is of the tag type. The tag value can be
    retrieved using tag() and the tagged value using taggedValue().
 
    This function also returns true for extended types that the API
    recognizes. For code that handles extended types directly before the Qt API
    is updated to support them, it is possible to recreate the tag + tagged
    value pair by using taggedValue().
 
    \sa type(), tag(), taggedValue()
 */
 
/*!
    \fn bool QCborValue::isFalse() const
 
    Returns true if this QCborValue is a boolean with false value. This
    function exists because, internally, CBOR booleans are stored as two
    separate types, one for true and one for false.
 
    \sa type(), isBool(), isTrue(), toBool()
 */
 
/*!
    \fn bool QCborValue::isTrue() const
 
    Returns true if this QCborValue is a boolean with true value. This
    function exists because, internally, CBOR booleans are stored as two
    separate types, one for false and one for true.
 
    \sa type(), isBool(), isFalse(), toBool()
 */
 
/*!
    \fn bool QCborValue::isBool() const
 
    Returns true if this QCborValue is a boolean. The value can be retrieved
    using toBool().
 
    \sa type(), toBool(), isTrue(), isFalse()
 */
 
/*!
    \fn bool QCborValue::isUndefined() const
 
    Returns true if this QCborValue is of the undefined type.
 
    CBOR undefined values are used to indicate missing information, usually as
    a result of a previous operation that did not complete as expected. They
    are also used by the QCborArray and QCborMap API to indicate the searched
    item was not found.
 
    Undefined values are distinct from null values.
 
    QCborValue objects with undefined values are also different from invalid
    QCborValue objects. The API will not create invalid QCborValues, but they
    may exist as a result of a parsing error.
 
    \sa type(), isNull(), isInvalid()
 */
 
/*!
    \fn bool QCborValue::isNull() const
 
    Returns true if this QCborValue is of the null type.
 
    CBOR null values are used to indicate optional values that were not
    provided. They are distinct from undefined values, in that null values are
    usually not the result of an earlier error or problem.
 
    Null values are distinct from undefined values and from invalid QCborValue
    objects. The API will not create invalid QCborValues, but they may exist as
    a result of a parsing error.
 
    \sa type(), isUndefined(), isInvalid()
 */
 
/*!
    \fn bool QCborValue::isDouble() const
 
    Returns true if this QCborValue is of the floating-point type. The value
    can be retrieved using toDouble().
 
    \sa type(), toDouble()
 */
 
/*!
    \fn bool QCborValue::isDateTime() const
 
    Returns true if this QCborValue is of the date/time type. The value can be
    retrieved using toDateTime(). Date/times are extended types that use the
    tag \l{QCborKnownTags}{DateTime}.
 
    Additionally, when decoding from a CBOR stream, QCborValue will interpret
    tags of value \l{QCborKnownTags}{UnixTime_t} and convert them to the
    equivalent date/time.
 
    \sa type(), toDateTime()
 */
 
/*!
    \fn bool QCborValue::isUrl() const
 
    Returns true if this QCborValue is of the URL type. The URL value
    can be retrieved using toUrl().
 
    \sa type(), toUrl()
 */
 
/*!
    \fn bool QCborValue::isRegularExpression() const
 
    Returns true if this QCborValue contains a regular expression's pattern.
    The pattern can be retrieved using toRegularExpression().
 
    \sa type(), toRegularExpression()
 */
 
/*!
    \fn bool QCborValue::isUuid() const
 
    Returns true if this QCborValue contains a UUID. The value can be retrieved
    using toUuid().
 
    \sa type(), toUuid()
 */
 
/*!
    \fn bool QCborValue::isInvalid() const
 
    Returns true if this QCborValue is not of any valid type. Invalid
    QCborValues are distinct from those with undefined values and they usually
    represent a decoding error.
 
    \sa isUndefined(), isNull()
 */
 
/*!
    \fn bool QCborValue::isContainer() const
 
    This convenience function returns true if the QCborValue is either an array
    or a map.
 
    \sa isArray(), isMap()
 */
 
/*!
    \fn bool QCborValue::isSimpleType() const
 
    Returns true if this QCborValue is of one of the CBOR simple types. The
    type itself can later be retrieved using type(), even for types that don't have an
    enumeration in the API. They can also be checked with the
    \l{isSimpleType(QCborSimpleType)} overload.
 
    \sa QCborSimpleType, isSimpleType(QCborSimpleType), toSimpleType()
 */
 
/*!
    \fn bool QCborValue::isSimpleType(QCborSimpleType st) const
    \overload
 
    Returns true if this QCborValue is of a simple type and toSimpleType()
    would return \a st, false otherwise. This function can be used to check for
    any CBOR simple type, even those for which there is no enumeration in the
    API. For example, for the simple type of value 12, you could write:
 
    \snippet code/src_corelib_serialization_qcborvalue.cpp 2
 
    \sa QCborValue::QCborValue(QCborSimpleType), isSimpleType(), isFalse(),
        isTrue(), isNull, isUndefined(), toSimpleType()
 */
 
/*!
    \fn QCborSimpleType QCborValue::toSimpleType(QCborSimpleType defaultValue) const
 
    Returns the simple type this QCborValue is of, if it is a simple type. If
    it is not a simple type, it returns \a defaultValue.
 
    The following types are simple types and this function will return the
    listed values:
 
    \table
      \row \li QCborValue::False        \li QCborSimpleType::False
      \row \li QCborValue::True         \li QCborSimpleType::True
      \row \li QCborValue::Null         \li QCborSimpleType::Null
      \row \li QCborValue::Undefined    \li QCborSimpleType::Undefined
    \endtable
 
    \sa type(), isSimpleType(), isBool(), isTrue(), isFalse(), isTrue(),
        isNull(), isUndefined()
 */
 
/*!
    \fn qint64 QCborValue::toInteger(qint64 defaultValue) const
 
    Returns the integer value stored in this QCborValue, if it is of the
    integer type. If it is of the Double type, this function returns the
    floating point value converted to integer. In any other case, it returns \a
    defaultValue.
 
    \sa isInteger(), isDouble(), toDouble()
 */
 
/*!
    \fn bool QCborValue::toBool(bool defaultValue) const
 
    Returns the boolean value stored in this QCborValue, if it is of a boolean
    type. Otherwise, it returns \a defaultValue.
 
    \sa isBool(), isTrue(), isFalse()
 */
 
/*!
    \fn double QCborValue::toDouble(double defaultValue) const
 
    Returns the floating point value stored in this QCborValue, if it is of the
    Double type. If it is of the Integer type, this function returns the
    integer value converted to double. In any other case, it returns \a
    defaultValue.
 
    \sa isDouble(), isInteger(), toInteger()
 */
 
using namespace QtCbor;
static QCborValue::Type setToExtendedDateTimeType(QCborContainerPrivate *d, QStringView dtString);
 
static QCborContainerPrivate *assignContainer(QCborContainerPrivate *&d, QCborContainerPrivate *x)
{
    if (d == x)
        return d;
    if (d)
        d->deref();
    if (x)
        x->ref.ref();
    return d = x;
}
 
static QCborValue::Type convertToExtendedType(QCborContainerPrivate *d)
{
    qint64 tag = d->elements.at(0).value;
    auto &e = d->elements[1];
    const ByteData *b = d->byteData(e);
 
    auto replaceByteData = [&](const char *buf, qsizetype len, Element::ValueFlags f) {
        d->data.clear();
        d->usedData = 0;
        e.flags = Element::HasByteData | f;
        e.value = d->addByteData(buf, len);
    };
 
    switch (tag) {
#if QT_CONFIG(datestring)
    case qint64(QCborKnownTags::DateTimeString):
    case qint64(QCborKnownTags::UnixTime_t): {
        QDateTime dt;
        if (tag == qint64(QCborKnownTags::DateTimeString) && b &&
            e.type == QCborValue::String && (e.flags & Element::StringIsUtf16) == 0) {
            // The data is supposed to be US-ASCII. If it isn't (contains UTF-8),
            // QDateTime::fromString will fail anyway.
            dt = QDateTime::fromString(b->asLatin1(), Qt::ISODateWithMs);
        } else if (tag == qint64(QCborKnownTags::UnixTime_t)) {
            qint64 msecs;
            bool ok = false;
            if (e.type == QCborValue::Integer) {
                ok = !qMulOverflow<1000>(e.value, &msecs);
            } else if (e.type == QCborValue::Double) {
                ok = convertDoubleTo(round(e.fpvalue() * 1000), &msecs);
            }
            if (ok)
                dt = QDateTime::fromMSecsSinceEpoch(msecs, QTimeZone::UTC);
            else
                break;
        }
        if (QString dtString = dt.toString(Qt::ISODateWithMs); !dtString.isEmpty())
            return setToExtendedDateTimeType(d, dtString);
        break;
    }
#endif
 
#ifndef QT_BOOTSTRAPPED
    case qint64(QCborKnownTags::Url):
        if (e.type == QCborValue::String) {
            if (b) {
                // normalize to a short (decoded) form, so as to save space
                QUrl url(e.flags & Element::StringIsUtf16 ?
                             b->asQStringRaw() :
                             b->toUtf8String(), QUrl::StrictMode);
                if (url.isValid()) {
                    QByteArray encoded = url.toString(QUrl::DecodeReserved).toUtf8();
                    replaceByteData(encoded, encoded.size(), {});
                }
            }
            return QCborValue::Url;
        }
        break;
#endif // QT_BOOTSTRAPPED
 
#if QT_CONFIG(regularexpression)
    case quint64(QCborKnownTags::RegularExpression):
        if (e.type == QCborValue::String) {
            // no normalization is necessary
            return QCborValue::RegularExpression;
        }
        break;
#endif // QT_CONFIG(regularexpression)
 
    case qint64(QCborKnownTags::Uuid):
        if (e.type == QCborValue::ByteArray) {
            // force the size to 16
            char buf[sizeof(QUuid)] = {};
            if (b)
                memcpy(buf, b->byte(), qMin(sizeof(buf), size_t(b->len)));
            replaceByteData(buf, sizeof(buf), {});
 
            return QCborValue::Uuid;
        }
        break;
    }
 
    // no enriching happened
    return QCborValue::Tag;
}
 
#if QT_CONFIG(cborstreamwriter) && !defined(QT_BOOTSTRAPPED)
static void writeDoubleToCbor(QCborStreamWriter &writer, double d, QCborValue::EncodingOptions opt)
{
    if (qt_is_nan(d)) {
        if (opt & QCborValue::UseFloat) {
            if ((opt & QCborValue::UseFloat16) == QCborValue::UseFloat16)
                return writer.append(std::numeric_limits<qfloat16>::quiet_NaN());
            return writer.append(std::numeric_limits<float>::quiet_NaN());
        }
        return writer.append(qt_qnan());
    }
 
    if (qt_is_inf(d)) {
        d = d > 0 ? qt_inf() : -qt_inf();
    } else if (opt & QCborValue::UseIntegers) {
        quint64 i;
        if (convertDoubleTo(d, &i)) {
            if (d < 0)
                return writer.append(QCborNegativeInteger(i));
            return writer.append(i);
        }
    }
 
    if (opt & QCborValue::UseFloat) {
        float f = float(d);
        if (f == d) {
            // no data loss, we could use float
            if ((opt & QCborValue::UseFloat16) == QCborValue::UseFloat16) {
                qfloat16 f16 = qfloat16(f);
                if (f16 == f)
                    return writer.append(f16);
            }
 
            return writer.append(f);
        }
    }
 
    writer.append(d);
}
#endif // QT_CONFIG(cborstreamwriter) && !QT_BOOTSTRAPPED
 
static inline int typeOrder(QCborValue::Type e1, QCborValue::Type  e2)
{
    auto comparable = [](QCborValue::Type type) {
        if (type >= 0x10000)        // see QCborValue::isTag_helper()
            return QCborValue::Tag;
        return type;
    };
    return comparable(e1) - comparable(e2);
}
 
QCborContainerPrivate::~QCborContainerPrivate()
{
    // Do the depth-first search of all containers, and delete them
    // bottom-to-top, so that the d-tor never recurses.
    // We cannot use an approach with storing the elements to be removed in
    // a container, because the container itself may throw on reallocation, and
    // we do not want it in the d-tor.
    // So, use the nextToDelete member of QCborContainerPrivate to first create
    // a linked list of containers to be checked, and then build another linked
    // list of the elements to be removed.
    QCborContainerPrivate *pendingContainers = nullptr;
    QCborContainerPrivate *toBeDeleted = nullptr;
 
    auto appendNestedContainers = [&pendingContainers](QCborContainerPrivate *priv) {
        for (const Element &e : std::as_const(priv->elements)) {
            // only append if it actually has to be deleted
            if ((e.flags & Element::IsContainer) == 0)
                continue; // not a container
            if (e.container->ref.deref())
                continue; // still referenced
            if (e.container->elements.isEmpty()) {
                // empty container - delete immediately
                delete e.container;
            } else {
                e.container->nextToDelete = pendingContainers;
                pendingContainers = e.container;
            }
        }
    };
 
    // first, add our nested containers
    appendNestedContainers(this);
 
    // then try do descend deeper into the tree
    while (pendingContainers) {
        QCborContainerPrivate *priv = pendingContainers;
        pendingContainers = priv->nextToDelete;
 
        // Move priv into the list of containers that can now be deleted.
        priv->nextToDelete = toBeDeleted;
        toBeDeleted = priv;
 
        // collect priv's children
        appendNestedContainers(priv);
    }
 
    // Now actually delete everything
    while (toBeDeleted) {
        QCborContainerPrivate *priv = toBeDeleted;
        toBeDeleted = priv->nextToDelete;
 
        // Clear the elements, so that we do not recurse again.
        // We cannot use QList::clear(), because it might allocate.
        // Use move-assignment instead.
        priv->elements = QList<Element>();
 
        delete priv;
    }
}
 
void QCborContainerPrivate::compact()
{
    if (usedData > data.size() / 2)
        return;
 
    // 50% savings if we recreate the byte data
    QByteArray newData;
    QByteArray::size_type newUsedData = 0;
    // Compact only elements that have byte data.
    // Nested containers will be compacted when their data changes.
    for (auto &e : elements) {
        if (e.flags & Element::HasByteData) {
            if (const ByteData *b = byteData(e))
                e.value = addByteDataImpl(newData, newUsedData, b->byte(), b->len);
        }
    }
    data = newData;
    usedData = newUsedData;
}
 
QCborContainerPrivate *QCborContainerPrivate::clone(QCborContainerPrivate *d, qsizetype reserved)
{
    if (!d) {
        d = new QCborContainerPrivate;
    } else {
        // in case QList::reserve throws
        QExplicitlySharedDataPointer u(new QCborContainerPrivate(*d));
        if (reserved >= 0) {
            u->elements.reserve(reserved);
            u->compact();
        }
 
        d = u.take();
        d->ref.storeRelaxed(0);
 
        for (auto &e : std::as_const(d->elements)) {
            if (e.flags & Element::IsContainer)
                e.container->ref.ref();
        }
    }
    return d;
}
 
QCborContainerPrivate *QCborContainerPrivate::detach(QCborContainerPrivate *d, qsizetype reserved)
{
    if (!d || d->ref.loadRelaxed() != 1)
        return clone(d, reserved);
    return d;
}
 
/*!
  \internal
  Prepare for an insertion at position \a index
 
  Detaches and ensures there are at least index entries in the array, padding
  with Undefined as needed.
*/
QCborContainerPrivate *QCborContainerPrivate::grow(QCborContainerPrivate *d, qsizetype index)
{
    Q_ASSERT(index >= 0);
    d = detach(d, index + 1);
    Q_ASSERT(d);
    qsizetype j = d->elements.size();
    while (j++ < index)
        d->append(Undefined());
    return d;
}
 
// Copies or moves \a value into element at position \a e. If \a disp is
// CopyContainer, then this function increases the reference count of the
// container, but otherwise leaves it unmodified. If \a disp is MoveContainer,
// then it transfers ownership (move semantics) and the caller must set
// value.container back to nullptr.
void QCborContainerPrivate::replaceAt_complex(Element &e, const QCborValue &value, ContainerDisposition disp)
{
    if (value.n < 0) {
        // This QCborValue is an array, map, or tagged value (container points
        // to itself).
 
        // detect self-assignment
        if (Q_UNLIKELY(this == value.container)) {
            Q_ASSERT(ref.loadRelaxed() >= 2);
            if (disp == MoveContainer)
                ref.deref();    // not deref() because it can't drop to 0
            QCborContainerPrivate *d = QCborContainerPrivate::clone(this);
            d->elements.detach();
            d->ref.storeRelaxed(1);
            e.container = d;
        } else {
            e.container = value.container;
            if (disp == CopyContainer)
                e.container->ref.ref();
        }
 
        e.type = value.type();
        e.flags = Element::IsContainer;
    } else {
        // String data, copy contents
        e = value.container->elements.at(value.n);
 
        // Copy string data, if any
        if (const ByteData *b = value.container->byteData(value.n)) {
            const auto flags = e.flags;
            // The element e has an invalid e.value, because it is copied from
            // value. It means that calling compact() will trigger an assertion
            // or just silently corrupt the data.
            // Temporarily unset the Element::HasByteData flag in order to skip
            // the element e in the call to compact().
            e.flags = e.flags & ~Element::HasByteData;
            if (this == value.container) {
                const QByteArray valueData = b->toByteArray();
                compact();
                e.value = addByteData(valueData, valueData.size());
            } else {
                compact();
                e.value = addByteData(b->byte(), b->len);
            }
            // restore the flags
            e.flags = flags;
        }
 
        if (disp == MoveContainer)
            value.container->deref();
    }
}
 
// in qstring.cpp
void qt_to_latin1_unchecked(uchar *dst, const char16_t *uc, qsizetype len);
 
Q_NEVER_INLINE void QCborContainerPrivate::appendAsciiString(QStringView s)
{
    qsizetype len = s.size();
    QtCbor::Element e;
    e.value = addByteData(nullptr, len);
    e.type = QCborValue::String;
    e.flags = Element::HasByteData | Element::StringIsAscii;
    elements.append(e);
 
    char *ptr = data.data() + e.value + sizeof(ByteData);
    uchar *l = reinterpret_cast<uchar *>(ptr);
    qt_to_latin1_unchecked(l, s.utf16(), len);
}
 
void QCborContainerPrivate::appendNonAsciiString(QStringView s)
{
    appendByteData(reinterpret_cast<const char *>(s.utf16()), s.size() * 2,
                   QCborValue::String, QtCbor::Element::StringIsUtf16);
}
 
QCborValue QCborContainerPrivate::extractAt_complex(Element e)
{
    // create a new container for the returned value, containing the byte data
    // from this element, if it's worth it
    Q_ASSERT(e.flags & Element::HasByteData);
    auto b = byteData(e);
    auto container = new QCborContainerPrivate;
 
    if (b->len + qsizetype(sizeof(*b)) < data.size() / 4) {
        // make a shallow copy of the byte data
        container->appendByteData(b->byte(), b->len, e.type, e.flags);
        usedData -= b->len + qsizetype(sizeof(*b));
        compact();
    } else {
        // just share with the original byte data
        container->data = data;
        container->elements.reserve(1);
        container->elements.append(e);
    }
 
    return makeValue(e.type, 0, container);
}
 
// Similar to QStringIterator::next() but returns malformed surrogate pair
// itself when one is detected, and returns the length in UTF-8.
static auto nextUtf32Character(const char16_t *&ptr, const char16_t *end) noexcept
{
    Q_ASSERT(ptr != end);
    struct R {
        char32_t c;
        qsizetype len;  // in UTF-8 code units (bytes)
    };
 
    const char16_t c = *ptr++;
 
    if (c < 0x0800) {
        if (c < 0x0080)
            return R{c, 1};
        return R{c, 2};
    } else if (!QChar::isHighSurrogate(c) || ptr == end) {
        return R{c, 3};
    } else {
        return R{QChar::surrogateToUcs4(c, *ptr++), 4};
    }
}
 
static qsizetype stringLengthInUtf8(const char16_t *ptr, const char16_t *end) noexcept
{
    qsizetype len = 0;
    while (ptr < end)
        len += nextUtf32Character(ptr, end).len;
    return len;
}
 
static int compareStringsInUtf8(QStringView lhs, QStringView rhs, Comparison mode) noexcept
{
    if (mode == Comparison::ForEquality)
        return lhs == rhs ? 0 : 1;
 
    // The UTF-16 length is *usually* comparable, but not always. There are
    // pathological cases where they can be wrong, so we need to compare as if
    // we were doing it in UTF-8. That includes the case of UTF-16 surrogate
    // pairs, because qstring.cpp sorts them before U+E000-U+FFFF.
    int diff = 0;
    qsizetype len1 = 0;
    qsizetype len2 = 0;
    const char16_t *src1 = lhs.utf16();
    const char16_t *src2 = rhs.utf16();
    const char16_t *end1 = src1 + lhs.size();
    const char16_t *end2 = src2 + rhs.size();
 
    // first, scan until we find a difference (if any)
    do {
        auto r1 = nextUtf32Character(src1, end1);
        auto r2 = nextUtf32Character(src2, end2);
        len1 += r1.len;
        len2 += r2.len;
        diff = int(r1.c) - int(r2.c);       // no underflow due to limited range
    } while (src1 < end1 && src2 < end2 && diff == 0);
 
    // compute the full length past this first difference
    len1 += stringLengthInUtf8(src1, end1);
    len2 += stringLengthInUtf8(src2, end2);
    if (len1 == len2)
        return diff;
    return len1 < len2 ? -1 : 1;
}
 
static int compareStringsInUtf8(QUtf8StringView lhs, QStringView rhs, Comparison mode) noexcept
{
    // CBOR requires that the shortest of the two strings be sorted first, so
    // we have to calculate the UTF-8 length of the UTF-16 string while
    // comparing. Unlike the UTF-32 comparison above, we convert the UTF-16
    // string to UTF-8 so we only need to decode one string.
 
    const qsizetype len1 = lhs.size();
    const auto src1 = reinterpret_cast<const uchar *>(lhs.data());
    const char16_t *src2 = rhs.utf16();
    const char16_t *const end2 = src2 + rhs.size();
 
    // Compare the two strings until we find a difference.
    int diff = 0;
    qptrdiff idx1 = 0;
    qsizetype len2 = 0;
    do {
        uchar utf8[4];      // longest possible Unicode character in UTF-8
        uchar *ptr = utf8;
        char16_t uc = *src2++;
        int r = QUtf8Functions::toUtf8<QUtf8BaseTraits>(uc, ptr, src2, end2);
        Q_UNUSED(r);    // ignore failure to encode proper UTF-16 surrogates
 
        qptrdiff n = ptr - utf8;
        len2 += n;
        if (len1 - idx1 < n)
            return -1;      // lhs is definitely shorter
        diff = memcmp(src1 + idx1, utf8, n);
        idx1 += n;
    } while (diff == 0 && idx1 < len1 && src2 < end2);
 
    if (mode == Comparison::ForEquality && diff)
        return diff;
    if ((idx1 == len1) != (src2 == end2)) {
        // One of the strings ended earlier than the other
        return idx1 == len1 ? -1 : 1;
    }
 
    // We found a difference and neither string ended, so continue calculating
    // the UTF-8 length of rhs.
    len2 += stringLengthInUtf8(src2, end2);
 
    if (len1 != len2)
        return len1 < len2 ? -1 : 1;
    return diff;
}
 
static int compareStringsInUtf8(QStringView lhs, QUtf8StringView rhs, Comparison mode) noexcept
{
    return -compareStringsInUtf8(rhs, lhs, mode);
}
 
QT_WARNING_DISABLE_MSVC(4146)   // unary minus operator applied to unsigned type, result still unsigned
static int compareContainer(const QCborContainerPrivate *c1, const QCborContainerPrivate *c2,
                            Comparison mode) noexcept;
static int compareElementNoData(const Element &e1, const Element &e2) noexcept
{
    Q_ASSERT(e1.type == e2.type);
 
    if (e1.type == QCborValue::Integer) {
        // CBOR sorting order is 0, 1, 2, ..., INT64_MAX, -1, -2, -3, ... INT64_MIN
        // So we transform:
        //  0           ->      0
        //  1           ->      1
        //  INT64_MAX   ->      INT64_MAX
        //  -1          ->      INT64_MAX + 1 = INT64_MAX - (-1)
        //  -2          ->      INT64_MAX + 2 = INT64_MAX - (-2)
        //  INT64_MIN   ->      UINT64_MAX = INT64_MAX - INT64_MIN
        // Note how the unsigned arithmetic is well defined in C++ (it's
        // always performed modulo 2^64).
        auto makeSortable = [](qint64 v) {
            quint64 u = quint64(v);
            if (v < 0)
                return quint64(std::numeric_limits<qint64>::max()) + (-u);
            return u;
        };
        quint64 u1 = makeSortable(e1.value);
        quint64 u2 = makeSortable(e2.value);
        if (u1 < u2)
            return -1;
        if (u1 > u2)
            return 1;
    }
 
    if (e1.type == QCborValue::Tag || e1.type == QCborValue::Double) {
        // Perform unsigned comparisons for the tag value and floating point
        quint64 u1 = quint64(e1.value);
        quint64 u2 = quint64(e2.value);
        if (u1 != u2)
            return u1 < u2 ? -1 : 1;
    }
 
    // Any other type is equal at this point:
    // - simple types carry no value
    // - empty strings, arrays and maps
    return 0;
}
 
static int compareElementRecursive(const QCborContainerPrivate *c1, const Element &e1,
                                   const QCborContainerPrivate *c2, const Element &e2,
                                   Comparison mode) noexcept
{
    int cmp = typeOrder(e1.type, e2.type);
    if (cmp != 0)
        return cmp;
 
    if ((e1.flags & Element::IsContainer) || (e2.flags & Element::IsContainer))
        return compareContainer(e1.flags & Element::IsContainer ? e1.container : nullptr,
                                e2.flags & Element::IsContainer ? e2.container : nullptr, mode);
 
    // string data?
    const ByteData *b1 = c1 ? c1->byteData(e1) : nullptr;
    const ByteData *b2 = c2 ? c2->byteData(e2) : nullptr;
    if (b1 || b2) {
        auto len1 = b1 ? b1->len : 0;
        auto len2 = b2 ? b2->len : 0;
        if (len1 == 0 || len2 == 0)
            return len1 < len2 ? -1 : len1 == len2 ? 0 : 1;
 
        // we definitely have data from this point forward
        Q_ASSERT(b1);
        Q_ASSERT(b2);
 
        // Officially with CBOR, we sort first the string with the shortest
        // UTF-8 length. Since US-ASCII is just a subset of UTF-8, its length
        // is the UTF-8 length. But the UTF-16 length may not be directly
        // comparable.
        if ((e1.flags & Element::StringIsUtf16) && (e2.flags & Element::StringIsUtf16))
            return compareStringsInUtf8(b1->asStringView(), b2->asStringView(), mode);
 
        if (!(e1.flags & Element::StringIsUtf16) && !(e2.flags & Element::StringIsUtf16)) {
            // Neither is UTF-16, so lengths are comparable too
            // (this case includes byte arrays too)
            if (len1 == len2) {
                if (mode == Comparison::ForEquality) {
                    // GCC optimizes this to __memcmpeq(); Clang to bcmp()
                    return memcmp(b1->byte(), b2->byte(), size_t(len1)) == 0 ? 0 : 1;
                }
                return memcmp(b1->byte(), b2->byte(), size_t(len1));
            }
            return len1 < len2 ? -1 : 1;
        }
 
        // Only one is UTF-16
        if (e1.flags & Element::StringIsUtf16)
            return compareStringsInUtf8(b1->asStringView(), b2->asUtf8StringView(), mode);
        else
            return compareStringsInUtf8(b1->asUtf8StringView(), b2->asStringView(), mode);
    }
 
    return compareElementNoData(e1, e2);
}
 
static int compareContainer(const QCborContainerPrivate *c1, const QCborContainerPrivate *c2,
                            Comparison mode) noexcept
{
    auto len1 = c1 ? c1->elements.size() : 0;
    auto len2 = c2 ? c2->elements.size() : 0;
    if (len1 != len2) {
        // sort the shorter container first
        return len1 < len2 ? -1 : 1;
    }
 
    for (qsizetype i = 0; i < len1; ++i) {
        const Element &e1 = c1->elements.at(i);
        const Element &e2 = c2->elements.at(i);
        int cmp = compareElementRecursive(c1, e1, c2, e2, mode);
        if (cmp)
            return cmp;
    }
 
    return 0;
}
 
inline int QCborContainerPrivate::compareElement_helper(const QCborContainerPrivate *c1, Element e1,
                                                        const QCborContainerPrivate *c2, Element e2,
                                                        Comparison mode) noexcept
{
    return compareElementRecursive(c1, e1, c2, e2, mode);
}
 
/*!
    \fn bool QCborValue::operator==(const QCborValue &lhs, const QCborValue &rhs)
 
    Compares \a lhs and \a rhs, and returns true if they hold the same
    contents, false otherwise. If each QCborValue contains an array or map, the
    comparison is recursive to elements contained in them.
 
    For more information on CBOR equality in Qt, see, compare().
 
    \sa compare(), QCborMap::operator==(), operator!=(), operator<()
 */
 
/*!
    \fn bool QCborValue::operator!=(const QCborValue &lhs, const QCborValue &rhs)
 
    Compares \a lhs and \a rhs, and returns true if contents differ,
    false otherwise. If each QCborValue contains an array or map, the comparison
    is recursive to elements contained in them.
 
    For more information on CBOR equality in Qt, see, QCborValue::compare().
 
    \sa compare(), QCborMap::operator==(), operator==(), operator<()
 */
bool comparesEqual(const QCborValue &lhs,
                   const QCborValue &rhs) noexcept
{
    Element e1 = QCborContainerPrivate::elementFromValue(lhs);
    Element e2 = QCborContainerPrivate::elementFromValue(rhs);
    return compareElementRecursive(lhs.container, e1, rhs.container, e2,
                                   Comparison::ForEquality) == 0;
}
 
/*!
    \fn bool QCborValue::operator<(const QCborValue &lhs, const QCborValue &rhs)
 
    Compares \a lhs and \a rhs, and returns true if \a lhs should be
    sorted before \a rhs, false otherwise. If each QCborValue contains an
    array or map, the comparison is recursive to elements contained in them.
 
    For more information on CBOR sorting order, see QCborValue::compare().
 
    \sa compare(), QCborValue::operator==(), QCborMap::operator==(),
        operator==(), operator!=()
 */
 
/*!
    \fn bool QCborValue::operator<=(const QCborValue &lhs, const QCborValue &rhs)
 
    Compares \a lhs and \a rhs, and returns true if \a lhs should be
    sorted before \a rhs or is being equal to \a rhs, false otherwise.
    If each QCborValue contains an array or map, the comparison is recursive
    to elements contained in them.
 
    For more information on CBOR sorting order, see QCborValue::compare().
 
    \sa compare(), QCborValue::operator<(), QCborMap::operator==(),
        operator==(), operator!=()
*/
 
/*!
    \fn bool QCborValue::operator>(const QCborValue &lhs, const QCborValue &rhs)
 
    Compares \a lhs and \a rhs, and returns true if \a lhs should be
    sorted after \a rhs, false otherwise. If each QCborValue contains an
    array or map, the comparison is recursive to elements contained in them.
 
    For more information on CBOR sorting order, see QCborValue::compare().
 
    \sa compare(), QCborValue::operator>=(), QCborMap::operator==(),
        operator==(), operator!=()
*/
 
/*!
    \fn bool QCborValue::operator>=(const QCborValue &lhs, const QCborValue &rhs)
 
    Compares \a lhs and \a rhs, and returns true if \a lhs should be
    sorted after \a rhs or is being equal to \a rhs, false otherwise.
    If each QCborValue contains an array or map, the comparison is recursive
    to elements contained in them.
 
    For more information on CBOR sorting order, see QCborValue::compare().
 
    \sa compare(), QCborValue::operator>(), QCborMap::operator==(),
        operator==(), operator!=()
*/
 
/*!
    Compares this value and \a other, and returns an integer that indicates
    whether this value should be sorted prior to (if the result is negative) or
    after \a other (if the result is positive). If this function returns 0, the
    two values are equal and hold the same contents.
 
    If each QCborValue contains an array or map, the comparison is recursive to
    elements contained in them.
 
    \section3 Extended types
 
    QCborValue compares equal a QCborValue containing an extended type, like
    \l{Type}{Url} and \l{Type}{Url} and its equivalent tagged representation.
    So, for example, the following expression is true:
 
    \snippet code/src_corelib_serialization_qcborvalue.cpp 3
 
    Do note that Qt types like \l QUrl and \l QDateTime will normalize and
    otherwise modify their arguments. The expression above is true only because
    the string on the right side is the normalized value that the QCborValue on
    the left would take. If, for example, the "https" part were uppercase in
    both sides, the comparison would fail. For information on normalizations
    performed by QCborValue, please consult the documentation of the
    constructor taking the Qt type in question.
 
    \section3 Sorting order
 
    Sorting order in CBOR is defined in
    \l{RFC 7049, section 3.9}, which
    discusses the sorting of keys in a map when following the Canonical
    encoding. According to the specification, "sorting is performed on the
    bytes of the representation of the key data items" and lists as
    consequences that:
 
    \list
      \li "If two keys have different lengths, the shorter one sorts earlier;"
      \li "If two keys have the same length, the one with the lower value in
          (byte-wise) lexical order sorts earlier."
    \endlist
 
    This results in surprising sorting of QCborValues, where the result of this
    function is different from that which would later be retrieved by comparing the
    contained elements. For example, the QCborValue containing string "zzz"
    sorts before the QCborValue with string "foobar", even though when
    comparing as \l{QString::compare()}{QStrings} or
    \l{QByteArray}{QByteArrays} the "zzz" sorts after "foobar"
    (dictionary order).
 
    The specification does not clearly indicate what sorting order should be
    done for values of different types (it says sorting should not pay
    "attention to the 3/5 bit splitting for major types"). QCborValue makes the
    assumption that types should be sorted too. The numeric values of the
    QCborValue::Type enumeration are in that order, with the exception of the
    extended types, which compare as their tagged equivalents.
 
    \note Sorting order is preliminary and is subject to change. Applications
    should not depend on the order returned by this function for the time
    being.
 
    \sa QCborArray::compare(), QCborMap::compare(), operator==()
 */
int QCborValue::compare(const QCborValue &other) const
{
    Element e1 = QCborContainerPrivate::elementFromValue(*this);
    Element e2 = QCborContainerPrivate::elementFromValue(other);
    return compareElementRecursive(container, e1, other.container, e2, Comparison::ForOrdering);
}
 
bool comparesEqual(const QCborArray &lhs, const QCborArray &rhs) noexcept
{
    return compareContainer(lhs.d.constData(), rhs.d.constData(), Comparison::ForEquality) == 0;
}
 
int QCborArray::compare(const QCborArray &other) const noexcept
{
    return compareContainer(d.data(), other.d.data(), Comparison::ForOrdering);
}
 
bool QCborArray::comparesEqual_helper(const QCborArray &lhs, const QCborValue &rhs) noexcept
{
    if (typeOrder(QCborValue::Array, rhs.type()))
        return false;
    return compareContainer(lhs.d.constData(), rhs.container, Comparison::ForEquality) == 0;
}
 
Qt::strong_ordering
QCborArray::compareThreeWay_helper(const QCborArray &lhs, const QCborValue &rhs) noexcept
{
    int c = typeOrder(QCborValue::Array, rhs.type());
    if (c == 0)
        c = compareContainer(lhs.d.constData(), rhs.container, Comparison::ForOrdering);
    return Qt::compareThreeWay(c, 0);
}
 
bool comparesEqual(const QCborMap &lhs, const QCborMap &rhs) noexcept
{
    return compareContainer(lhs.d.constData(), rhs.d.constData(), Comparison::ForEquality) == 0;
}
 
int QCborMap::compare(const QCborMap &other) const noexcept
{
    return compareContainer(d.data(), other.d.data(), Comparison::ForOrdering);
}
 
bool QCborMap::comparesEqual_helper(const QCborMap &lhs, const QCborValue &rhs) noexcept
{
    if (typeOrder(QCborValue::Map, rhs.type()))
        return false;
    return compareContainer(lhs.d.constData(), rhs.container, Comparison::ForEquality) == 0;
}
 
Qt::strong_ordering
QCborMap::compareThreeWay_helper(const QCborMap &lhs, const QCborValue &rhs) noexcept
{
    int c = typeOrder(QCborValue::Map, rhs.type());
    if (c == 0)
        c = compareContainer(lhs.d.constData(), rhs.container, Comparison::ForOrdering);
    return Qt::compareThreeWay(c, 0);
}
 
#if QT_CONFIG(cborstreamwriter) && !defined(QT_BOOTSTRAPPED)
static void encodeToCbor(QCborStreamWriter &writer, const QCborContainerPrivate *d, qsizetype idx,
                         QCborValue::EncodingOptions opt)
{
    if (idx == -QCborValue::Array || idx == -QCborValue::Map) {
        bool isArray = (idx == -QCborValue::Array);
        qsizetype len = d ? d->elements.size() : 0;
        if (isArray)
            writer.startArray(quint64(len));
        else
            writer.startMap(quint64(len) / 2);
 
        for (idx = 0; idx < len; ++idx)
            encodeToCbor(writer, d, idx, opt);
 
        if (isArray)
            writer.endArray();
        else
            writer.endMap();
    } else if (idx < 0) {
        Q_ASSERT_X(d != nullptr, "QCborValue", "Unexpected null container");
        if (d->elements.size() != 2) {
            // invalid state!
            qWarning("QCborValue: invalid tag state; are you encoding something that was improperly decoded?");
            return;
        }
 
        // write the tag and the tagged element
        writer.append(QCborTag(d->elements.at(0).value));
        encodeToCbor(writer, d, 1, opt);
    } else {
        Q_ASSERT_X(d != nullptr, "QCborValue", "Unexpected null container");
        // just one element
        auto e = d->elements.at(idx);
        const ByteData *b = d->byteData(idx);
        switch (e.type) {
        case QCborValue::Integer:
            return writer.append(qint64(e.value));
 
        case QCborValue::ByteArray:
            if (b)
                return writer.appendByteString(b->byte(), b->len);
            return writer.appendByteString("", 0);
 
        case QCborValue::String:
            if (b) {
                if (e.flags & Element::StringIsUtf16)
                    return writer.append(b->asStringView());
                return writer.appendTextString(b->byte(), b->len);
            }
            return writer.append(QLatin1StringView());
 
        case QCborValue::Array:
        case QCborValue::Map:
        case QCborValue::Tag:
            // recurse
            return encodeToCbor(writer,
                                e.flags & Element::IsContainer ? e.container : nullptr,
                                -qsizetype(e.type), opt);
 
        case QCborValue::SimpleType:
        case QCborValue::False:
        case QCborValue::True:
        case QCborValue::Null:
        case QCborValue::Undefined:
            break;
 
        case QCborValue::Double:
            return writeDoubleToCbor(writer, e.fpvalue(), opt);
 
        case QCborValue::Invalid:
            return;
 
        case QCborValue::DateTime:
        case QCborValue::Url:
        case QCborValue::RegularExpression:
        case QCborValue::Uuid:
            // recurse as tag
            return encodeToCbor(writer, e.container, -QCborValue::Tag, opt);
        }
 
        // maybe it's a simple type
        int simpleType = e.type - QCborValue::SimpleType;
        if (unsigned(simpleType) < 0x100)
            return writer.append(QCborSimpleType(simpleType));
 
        // if we got here, we've got an unknown type
        qWarning("QCborValue: found unknown type 0x%x", e.type);
    }
}
#endif // QT_CONFIG(cborstreamwriter) && !QT_BOOTSTRAPPED
 
#if QT_CONFIG(cborstreamreader)
// confirm that our basic Types match QCborStreamReader::Types
static_assert(int(QCborValue::Integer) == int(QCborStreamReader::UnsignedInteger));
static_assert(int(QCborValue::ByteArray) == int(QCborStreamReader::ByteArray));
static_assert(int(QCborValue::String) == int(QCborStreamReader::String));
static_assert(int(QCborValue::Array) == int(QCborStreamReader::Array));
static_assert(int(QCborValue::Map) == int(QCborStreamReader::Map));
static_assert(int(QCborValue::Tag) == int(QCborStreamReader::Tag));
 
static inline double integerOutOfRange(const QCborStreamReader &reader)
{
    Q_ASSERT(reader.isInteger());
    if (reader.isUnsignedInteger()) {
        quint64 v = reader.toUnsignedInteger();
        if (qint64(v) < 0)
            return double(v);
    } else {
        quint64 v = quint64(reader.toNegativeInteger());
        if (qint64(v - 1) < 0)
            return -double(v);
    }
 
    // result is in range
    return 0;
}
 
static Element decodeBasicValueFromCbor(QCborStreamReader &reader)
{
    Element e = {};
 
    switch (reader.type()) {
    case QCborStreamReader::UnsignedInteger:
    case QCborStreamReader::NegativeInteger:
        if (double d = integerOutOfRange(reader)) {
            e.type = QCborValue::Double;
            qToUnaligned(d, &e.value);
        } else {
            e.type = QCborValue::Integer;
            e.value = reader.toInteger();
        }
        break;
    case QCborStreamReader::SimpleType:
        e.type = QCborValue::Type(quint8(reader.toSimpleType()) + 0x100);
        break;
    case QCborStreamReader::Float16:
        e.type = QCborValue::Double;
        qToUnaligned(double(reader.toFloat16()), &e.value);
        break;
    case QCborStreamReader::Float:
        e.type = QCborValue::Double;
        qToUnaligned(double(reader.toFloat()), &e.value);
        break;
    case QCborStreamReader::Double:
        e.type = QCborValue::Double;
        qToUnaligned(reader.toDouble(), &e.value);
        break;
 
    default:
        Q_UNREACHABLE();
    }
 
    reader.next();
    return e;
}
 
// Clamp allocation to avoid crashing due to corrupt stream. This also
// ensures we never overflow qsizetype. The returned length is doubled for Map
// entries to account for key-value pairs.
static qsizetype clampedContainerLength(const QCborStreamReader &reader)
{
    if (!reader.isLengthKnown())
        return 0;
    int mapShift = reader.isMap() ? 1 : 0;
    quint64 shiftedMaxElements = MaximumPreallocatedElementCount >> mapShift;
    qsizetype len = qsizetype(qMin(reader.length(), shiftedMaxElements));
    return len << mapShift;
}
 
static inline QCborContainerPrivate *createContainerFromCbor(QCborStreamReader &reader, int remainingRecursionDepth)
{
    if (Q_UNLIKELY(remainingRecursionDepth == 0)) {
        QCborContainerPrivate::setErrorInReader(reader, { QCborError::NestingTooDeep });
        return nullptr;
    }
 
    QCborContainerPrivate *d = nullptr;
    {
        // in case QList::reserve throws
        QExplicitlySharedDataPointer u(new QCborContainerPrivate);
        if (qsizetype len = clampedContainerLength(reader))
            u->elements.reserve(len);
        d = u.take();
    }
 
    reader.enterContainer();
    if (reader.lastError() != QCborError::NoError) {
        d->elements.clear();
        return d;
    }
 
    while (reader.hasNext() && reader.lastError() == QCborError::NoError)
        d->decodeValueFromCbor(reader, remainingRecursionDepth - 1);
 
    if (reader.lastError() == QCborError::NoError)
        reader.leaveContainer();
    else
        d->elements.squeeze();
 
    return d;
}
 
static QCborValue taggedValueFromCbor(QCborStreamReader &reader, int remainingRecursionDepth)
{
    if (Q_UNLIKELY(remainingRecursionDepth == 0)) {
        QCborContainerPrivate::setErrorInReader(reader, { QCborError::NestingTooDeep });
        return QCborValue::Invalid;
    }
 
    auto d = new QCborContainerPrivate;
    d->append(reader.toTag());
    reader.next();
 
    if (reader.lastError() == QCborError::NoError) {
        // decode tagged value
        d->decodeValueFromCbor(reader, remainingRecursionDepth - 1);
    }
 
    QCborValue::Type type;
    if (reader.lastError() == QCborError::NoError) {
        // post-process to create our extended types
        type = convertToExtendedType(d);
    } else {
        // decoding error
        type = QCborValue::Invalid;
    }
 
    // note: may return invalid state!
    return QCborContainerPrivate::makeValue(type, -1, d);
}
 
// in qcborstream.cpp
extern void qt_cbor_stream_set_error(QCborStreamReaderPrivate *d, QCborError error);
inline void QCborContainerPrivate::setErrorInReader(QCborStreamReader &reader, QCborError error)
{
    qt_cbor_stream_set_error(reader.d.get(), error);
}
 
extern QCborStreamReader::StringResultCode qt_cbor_append_string_chunk(QCborStreamReader &reader, QByteArray *data);
 
void QCborContainerPrivate::decodeStringFromCbor(QCborStreamReader &reader)
{
    if (reader.lastError() != QCborError::NoError)
        return;
 
    qsizetype rawlen = reader.currentStringChunkSize();
    QByteArray::size_type len = rawlen;
    if (rawlen < 0)
        return;                     // error
    if (len != rawlen) {
        // truncation
        setErrorInReader(reader, { QCborError::DataTooLarge });
        return;
    }
 
    auto resetSize = qScopeGuard([this, oldSize = data.size()] {
        data.resize(oldSize);
        if (oldSize < data.capacity() / 2)
            data.squeeze();
    });
 
    Element e = {};
    e.type = QCborValue::Type(reader.type());
    if (len || !reader.isLengthKnown()) {
        // The use of size_t means none of the operations here can overflow because
        // all inputs are less than half SIZE_MAX.
        constexpr size_t EstimatedOverhead = 16;
        constexpr size_t MaxMemoryIncrement = 16384;
        size_t offset = data.size();
 
        // add space for aligned ByteData (this can't overflow)
        offset += sizeof(QtCbor::ByteData) + alignof(QtCbor::ByteData);
        offset &= ~(alignof(QtCbor::ByteData) - 1);
        if (offset > size_t(QByteArray::maxSize())) {
            // overflow
            setErrorInReader(reader, { QCborError::DataTooLarge });
            return;
        }
 
        // and calculate the size we want to have
        size_t newCapacity = offset + len;          // can't overflow
        if (size_t(len) > MaxMemoryIncrement - EstimatedOverhead) {
            // there's a non-zero chance that we won't need this memory at all,
            // so capa how much we allocate
            newCapacity = offset + MaxMemoryIncrement - EstimatedOverhead;
        }
        if (newCapacity > size_t(QByteArray::maxSize())) {
            // this may cause an allocation failure
            newCapacity = QByteArray::maxSize();
        }
        if (newCapacity > size_t(data.capacity()))
            data.reserve(newCapacity);
        data.resize(offset + sizeof(QtCbor::ByteData));
        e.value = offset;
        e.flags = Element::HasByteData;
    }
 
    // read chunks
    bool isAscii = (e.type == QCborValue::String);
    QCborStreamReader::StringResultCode status = qt_cbor_append_string_chunk(reader, &data);
    while (status == QCborStreamReader::Ok) {
        if (e.type == QCborValue::String && len) {
            // verify UTF-8 string validity
            auto utf8result = QUtf8::isValidUtf8(QByteArrayView(data).last(len));
            if (!utf8result.isValidUtf8) {
                setErrorInReader(reader, { QCborError::InvalidUtf8String });
                return;
            }
            isAscii = isAscii && utf8result.isValidAscii;
        }
 
        rawlen = reader.currentStringChunkSize();
        len = rawlen;
        if (len == rawlen) {
            status = qt_cbor_append_string_chunk(reader, &data);
        } else {
            // error
            setErrorInReader(reader, { QCborError::DataTooLarge });
            return;
        }
    }
 
    // update size
    if (status == QCborStreamReader::EndOfString && e.flags & Element::HasByteData) {
        Q_ASSERT(data.isDetached());
        const char *ptr = data.constData() + e.value;
        auto b = new (const_cast<char *>(ptr)) ByteData;
        b->len = data.size() - e.value - int(sizeof(*b));
        usedData += b->len;
 
        if (isAscii) {
            // set the flag if it is US-ASCII only (as it often is)
            Q_ASSERT(e.type == QCborValue::String);
            e.flags |= Element::StringIsAscii;
        }
 
        // check that this UTF-8 text string can be loaded onto a QString
        if (e.type == QCborValue::String) {
            if (Q_UNLIKELY(b->len > QString::maxSize())) {
                setErrorInReader(reader, { QCborError::DataTooLarge });
                return;
            }
        }
    }
 
    if (status == QCborStreamReader::EndOfString) {
        elements.append(e);
        resetSize.dismiss();
    }
}
 
void QCborContainerPrivate::decodeValueFromCbor(QCborStreamReader &reader, int remainingRecursionDepth)
{
    QCborStreamReader::Type t = reader.type();
    switch (t) {
    case QCborStreamReader::UnsignedInteger:
    case QCborStreamReader::NegativeInteger:
    case QCborStreamReader::SimpleType:
    case QCborStreamReader::Float16:
    case QCborStreamReader::Float:
    case QCborStreamReader::Double:
        elements.append(decodeBasicValueFromCbor(reader));
        break;
 
    case QCborStreamReader::ByteArray:
    case QCborStreamReader::String:
        decodeStringFromCbor(reader);
        break;
 
    case QCborStreamReader::Array:
    case QCborStreamReader::Map:
        return append(makeValue(t == QCborStreamReader::Array ? QCborValue::Array : QCborValue::Map, -1,
                                createContainerFromCbor(reader, remainingRecursionDepth),
                                MoveContainer));
 
    case QCborStreamReader::Tag:
        return append(taggedValueFromCbor(reader, remainingRecursionDepth));
 
    case QCborStreamReader::Invalid:
        return;                 // probably a decode error
    }
}
#endif // QT_CONFIG(cborstreamreader)
 
/*!
    Creates a QCborValue with byte array value \a ba. The value can later be
    retrieved using toByteArray().
 
    \sa toByteArray(), isByteArray(), isString()
 */
QCborValue::QCborValue(const QByteArray &ba)
    : n(0), container(new QCborContainerPrivate), t(ByteArray)
{
    container->appendByteData(ba.constData(), ba.size(), t);
    container->ref.storeRelaxed(1);
}
 
/*!
    Creates a QCborValue with string value \a s. The value can later be
    retrieved using toString().
 
    \sa toString(), isString(), isByteArray()
 */
QCborValue::QCborValue(const QString &s) : QCborValue(qToStringViewIgnoringNull(s)) {}
 
/*!
    Creates a QCborValue with string value \a s. The value can later be
    retrieved using toString().
 
    \sa toString(), isString(), isByteArray()
*/
QCborValue::QCborValue(QStringView s)
    : n(0), container(new QCborContainerPrivate), t(String)
{
    container->append(s);
    container->ref.storeRelaxed(1);
}
 
/*!
    \overload
 
    Creates a QCborValue with the Latin-1 string viewed by \a s.
    The value can later be retrieved using toString().
 
    \sa toString(), isString(), isByteArray()
 */
QCborValue::QCborValue(QLatin1StringView s)
    : n(0), container(new QCborContainerPrivate), t(String)
{
    container->append(s);
    container->ref.storeRelaxed(1);
}
 
/*!
    \fn QCborValue::QCborValue(const QCborArray &a)
    \fn QCborValue::QCborValue(QCborArray &&a)
 
    Creates a QCborValue with the array \a a. The array can later be retrieved
    using toArray().
 
    \sa toArray(), isArray(), isMap()
 */
QCborValue::QCborValue(const QCborArray &a)
    : n(-1), container(a.d.data()), t(Array)
{
    if (container)
        container->ref.ref();
}
 
/*!
    \fn QCborValue::QCborValue(const QCborMap &m)
    \fn QCborValue::QCborValue(QCborMap &&m)
 
    Creates a QCborValue with the map \a m. The map can later be retrieved
    using toMap().
 
    \sa toMap(), isMap(), isArray()
 */
QCborValue::QCborValue(const QCborMap &m)
    : n(-1), container(m.d.data()), t(Map)
{
    if (container)
        container->ref.ref();
}
 
/*!
    \fn QCborValue::QCborValue(QCborTag tag, const QCborValue &tv)
    \fn QCborValue::QCborValue(QCborKnownTags tag, const QCborValue &tv)
 
    Creates a QCborValue for the extended type represented by the tag value \a
    tag, tagging value \a tv. The tag can later be retrieved using tag() and
    the tagged value using taggedValue().
 
    \sa isTag(), tag(), taggedValue(), QCborKnownTags
 */
QCborValue::QCborValue(QCborTag tag, const QCborValue &tv)
    : n(-1), container(new QCborContainerPrivate), t(Tag)
{
    container->ref.storeRelaxed(1);
    container->append(tag);
    container->append(tv);
    t = convertToExtendedType(container);
}
 
/*!
    Copies the contents of \a other into this object.
 */
QCborValue::QCborValue(const QCborValue &other) noexcept
    : n(other.n), container(other.container), t(other.t)
{
    if (container)
        container->ref.ref();
}
 
#if QT_CONFIG(datestring)
static QCborValue::Type setToExtendedDateTimeType(QCborContainerPrivate *d, QStringView text)
{
    // when called from convertToExtendedType(), *d isn't pristine
    d->data.resize(0);
    d->elements.resize(0);
    d->elements.reserve(2);
 
    d->append(QCborTag(QCborKnownTags::DateTimeString));
    d->appendAsciiString(text);
    return text.isEmpty() ? QCborValue::Tag : QCborValue::DateTime;
}
 
/*!
    Creates a QCborValue object of the date/time extended type and containing
    the value represented by \a dt. The value can later be retrieved using
    toDateTime().
 
    The CBOR date/time types are extension types using tags: either a string
    (in ISO date format) tagged as a \l{QCborKnownTags}{DateTime} or a number
    (of seconds since the start of 1970, UTC) tagged as a
    \l{QCborKnownTags}{UnixTime_t}. When parsing CBOR streams, QCborValue will
    convert \l{QCborKnownTags}{UnixTime_t} to the string-based type.
 
    \sa toDateTime(), isDateTime(), taggedValue()
 */
QCborValue::QCborValue(const QDateTime &dt)
    : n(-1), container(new QCborContainerPrivate),
      t(setToExtendedDateTimeType(container, dt.toString(Qt::ISODateWithMs)))
{
    container->ref.storeRelaxed(1);
}
#endif
 
#ifndef QT_BOOTSTRAPPED
/*!
    Creates a QCborValue object of the URL extended type and containing the
    value represented by \a url. The value can later be retrieved using toUrl().
 
    The CBOR URL type is an extended type represented by a string tagged as an
    \l{QCborKnownTags}{Url}.
 
    \sa toUrl(), isUrl(), taggedValue()
 */
QCborValue::QCborValue(const QUrl &url)
    : QCborValue(QCborKnownTags::Url, url.toString(QUrl::DecodeReserved).toUtf8())
{
    // change types
    t = Url;
    container->elements[1].type = String;
}
 
#if QT_CONFIG(regularexpression)
/*!
    Creates a QCborValue object of the regular expression pattern extended type
    and containing the value represented by \a rx. The value can later be retrieved
    using toRegularExpression().
 
    The CBOR regular expression type is an extended type represented by a
    string tagged as an \l{QCborKnownTags}{RegularExpression}. Note that CBOR
    regular expressions only store the patterns, so any flags that the
    QRegularExpression object may carry will be lost.
 
    \sa toRegularExpression(), isRegularExpression(), taggedValue()
 */
QCborValue::QCborValue(const QRegularExpression &rx)
    : QCborValue(QCborKnownTags::RegularExpression, rx.pattern())
{
    // change type
    t = RegularExpression;
}
#endif // QT_CONFIG(regularexpression)
 
/*!
    Creates a QCborValue object of the UUID extended type and containing the
    value represented by \a uuid. The value can later be retrieved using
    toUuid().
 
    The CBOR UUID type is an extended type represented by a byte array tagged
    as an \l{QCborKnownTags}{Uuid}.
 
    \sa toUuid(), isUuid(), taggedValue()
 */
QCborValue::QCborValue(const QUuid &uuid)
    : QCborValue(QCborKnownTags::Uuid, uuid.toRfc4122())
{
    // change our type
    t = Uuid;
}
#endif
 
// destructor
void QCborValue::dispose()
{
    container->deref();
}
 
/*!
    Replaces the contents of this QCborObject with a copy of \a other.
 */
QCborValue &QCborValue::operator=(const QCborValue &other) noexcept
{
    n = other.n;
    assignContainer(container, other.container);
    t = other.t;
    return *this;
}
 
/*!
    Returns the tag of this extended QCborValue object, if it is of the tag
    type, \a defaultValue otherwise.
 
    CBOR represents extended types by associating a number (the tag) with a
    stored representation. This function returns that number. To retrieve the
    representation, use taggedValue().
 
    \sa isTag(), taggedValue(), isDateTime(), isUrl(), isRegularExpression(), isUuid()
 */
QCborTag QCborValue::tag(QCborTag defaultValue) const
{
    return isTag() && container && container->elements.size() == 2 ?
                QCborTag(container->elements.at(0).value) : defaultValue;
}
 
/*!
    Returns the tagged value of this extended QCborValue object, if it is of
    the tag type, \a defaultValue otherwise.
 
    CBOR represents extended types by associating a number (the tag) with a
    stored representation. This function returns that representation. To
    retrieve the tag, use tag().
 
    \sa isTag(), tag(), isDateTime(), isUrl(), isRegularExpression(), isUuid()
 */
QCborValue QCborValue::taggedValue(const QCborValue &defaultValue) const
{
    return isTag() && container && container->elements.size() == 2 ?
                container->valueAt(1) : defaultValue;
}
 
/*!
    Returns the byte array value stored in this QCborValue, if it is of the byte
    array type. Otherwise, it returns \a defaultValue.
 
    Note that this function performs no conversion from other types to
    QByteArray.
 
    \sa isByteArray(), isString(), toString()
 */
QByteArray QCborValue::toByteArray(const QByteArray &defaultValue) const
{
    if (!container || !isByteArray())
        return defaultValue;
 
    Q_ASSERT(n >= 0);
    return container->byteArrayAt(n);
}
 
/*!
    Returns the string value stored in this QCborValue, if it is of the string
    type. Otherwise, it returns \a defaultValue.
 
    Note that this function performs no conversion from other types to
    QString.
 
    \sa toStringView(), isString(), isByteArray(), toByteArray()
 */
QString QCborValue::toString(const QString &defaultValue) const
{
    if (!container || !isString())
        return defaultValue;
 
    Q_ASSERT(n >= 0);
    return container->stringAt(n);
}
 
/*!
    \since 6.10
 
    Returns the string value stored in this QCborValue, if it is of the string
    type. Otherwise, it returns \a defaultValue. Since QCborValue stores
    strings in either US-ASCII, UTF-8 or UTF-16, the returned QAnyStringView
    may be in any of these encodings.
 
    This function does not allocate memory. The return value is valid until the
    next call to a non-const member function on this object. If this object goes
    out of scope, the return value is valid until the next call to a non-const
    member function on the parent CBOR object (map or array).
 
    Note that this function performs no conversion from other types to
    QString.
 
    \sa toString(), isString(), isByteArray(), toByteArray()
*/
QAnyStringView QCborValue::toStringView(QAnyStringView defaultValue) const
{
    if (!container || !isString())
        return defaultValue;
 
    Q_ASSERT(n >= 0);
    return container->anyStringViewAt(n);
}
 
#if QT_CONFIG(datestring)
/*!
    Returns the date/time value stored in this QCborValue, if it is of the
    date/time extended type. Otherwise, it returns \a defaultValue.
 
    Note that this function performs no conversion from other types to
    QDateTime.
 
    \sa isDateTime(), isTag(), taggedValue()
 */
QDateTime QCborValue::toDateTime(const QDateTime &defaultValue) const
{
    if (!container || !isDateTime() || container->elements.size() != 2)
        return defaultValue;
 
    Q_ASSERT(n == -1);
    const ByteData *byteData = container->byteData(1);
    if (!byteData)
        return defaultValue; // date/times are never empty, so this must be invalid
 
    // Our data must be US-ASCII.
    Q_ASSERT((container->elements.at(1).flags & Element::StringIsUtf16) == 0);
    return QDateTime::fromString(byteData->asLatin1(), Qt::ISODateWithMs);
}
#endif
 
#ifndef QT_BOOTSTRAPPED
/*!
    Returns the URL value stored in this QCborValue, if it is of the URL
    extended type. Otherwise, it returns \a defaultValue.
 
    Note that this function performs no conversion from other types to QUrl.
 
    \sa isUrl(), isTag(), taggedValue()
 */
QUrl QCborValue::toUrl(const QUrl &defaultValue) const
{
    if (!container || !isUrl() || container->elements.size() != 2)
        return defaultValue;
 
    Q_ASSERT(n == -1);
    const ByteData *byteData = container->byteData(1);
    if (!byteData)
        return QUrl();  // valid, empty URL
 
    return QUrl::fromEncoded(byteData->asByteArrayView());
}
 
#if QT_CONFIG(regularexpression)
/*!
    Returns the regular expression value stored in this QCborValue, if it is of
    the regular expression pattern extended type. Otherwise, it returns \a
    defaultValue.
 
    Note that this function performs no conversion from other types to
    QRegularExpression.
 
    \sa isRegularExpression(), isTag(), taggedValue()
 */
QRegularExpression QCborValue::toRegularExpression(const QRegularExpression &defaultValue) const
{
    if (!container || !isRegularExpression() || container->elements.size() != 2)
        return defaultValue;
 
    Q_ASSERT(n == -1);
    return QRegularExpression(container->stringAt(1));
}
#endif // QT_CONFIG(regularexpression)
 
/*!
    Returns the UUID value stored in this QCborValue, if it is of the UUID
    extended type. Otherwise, it returns \a defaultValue.
 
    Note that this function performs no conversion from other types to QUuid.
 
    \sa isUuid(), isTag(), taggedValue()
 */
QUuid QCborValue::toUuid(const QUuid &defaultValue) const
{
    if (!container || !isUuid() || container->elements.size() != 2)
        return defaultValue;
 
    Q_ASSERT(n == -1);
    const ByteData *byteData = container->byteData(1);
    if (!byteData)
        return defaultValue; // UUIDs must always be 16 bytes, so this must be invalid
 
    return QUuid::fromRfc4122(byteData->asByteArrayView());
}
#endif
 
/*!
    \fn QCborArray QCborValue::toArray() const
    \fn QCborArray QCborValue::toArray(const QCborArray &defaultValue) const
 
    Returns the array value stored in this QCborValue, if it is of the array
    type. Otherwise, it returns \a defaultValue.
 
    Note that this function performs no conversion from other types to
    QCborArray.
 
    \sa isArray(), isByteArray(), isMap(), isContainer(), toMap()
 */
 
/*!
    \fn QCborArray QCborValueRef::toArray() const
    \fn QCborArray QCborValueRef::toArray(const QCborArray &defaultValue) const
    \internal
 
    Returns the array value stored in this QCborValue, if it is of the array
    type. Otherwise, it returns \a defaultValue.
 
    Note that this function performs no conversion from other types to
    QCborArray.
 
    \sa isArray(), isByteArray(), isMap(), isContainer(), toMap()
 */
QCborArray QCborValue::toArray() const
{
    return toArray(QCborArray());
}
 
QCborArray QCborValue::toArray(const QCborArray &defaultValue) const
{
    if (!isArray())
        return defaultValue;
    QCborContainerPrivate *dd = nullptr;
    Q_ASSERT(n == -1 || container == nullptr);
    if (n < 0)
        dd = container;
    // return QCborArray(*dd); but that's UB if dd is nullptr
    return dd ? QCborArray(*dd) : QCborArray();
}
 
/*!
    \fn QCborMap QCborValue::toMap() const
    \fn QCborMap QCborValue::toMap(const QCborMap &defaultValue) const
 
    Returns the map value stored in this QCborValue, if it is of the map type.
    Otherwise, it returns \a defaultValue.
 
    Note that this function performs no conversion from other types to
    QCborMap.
 
    \sa isMap(), isArray(), isContainer(), toArray()
 */
 
/*!
    \fn QCborMap QCborValueRef::toMap() const
    \fn QCborMap QCborValueRef::toMap(const QCborMap &defaultValue) const
    \internal
 
    Returns the map value stored in this QCborValue, if it is of the map type.
    Otherwise, it returns \a defaultValue.
 
    Note that this function performs no conversion from other types to
    QCborMap.
 
    \sa isMap(), isArray(), isContainer(), toArray()
 */
QCborMap QCborValue::toMap() const
{
    return toMap(QCborMap());
}
 
QCborMap QCborValue::toMap(const QCborMap &defaultValue) const
{
    if (!isMap())
        return defaultValue;
    QCborContainerPrivate *dd = nullptr;
    Q_ASSERT(n == -1 || container == nullptr);
    if (n < 0)
        dd = container;
    // return QCborMap(*dd); but that's UB if dd is nullptr
    return dd ? QCborMap(*dd) : QCborMap();
}
 
/*!
    If this QCborValue is a QCborMap, searches elements for the value whose key
    matches \a key. If there's no key matching \a key in the map or if this
    QCborValue object is not a map, returns the undefined value.
 
    This function is equivalent to:
 
    \snippet code/src_corelib_serialization_qcborvalue.cpp 4
 
    \sa operator[](qint64), QCborMap::operator[], QCborMap::value(),
        QCborMap::find()
 */
const QCborValue QCborValue::operator[](const QString &key) const
{
    return QCborContainerPrivate::findCborMapKey(*this, qToStringViewIgnoringNull(key));
}
 
/*!
    \overload
 
    If this QCborValue is a QCborMap, searches elements for the value whose key
    matches \a key. If there's no key matching \a key in the map or if this
    QCborValue object is not a map, returns the undefined value.
 
    This function is equivalent to:
 
    \snippet code/src_corelib_serialization_qcborvalue.cpp 5
 
    \sa operator[](qint64), QCborMap::operator[], QCborMap::value(),
        QCborMap::find()
 */
const QCborValue QCborValue::operator[](QLatin1StringView key) const
{
    return QCborContainerPrivate::findCborMapKey(*this, key);
}
 
/*!
    \overload
 
    If this QCborValue is a QCborMap, searches elements for the value whose key
    matches \a key. If this is a QCborArray, returns the element whose index is
    \a key. If there's no matching value in the array or map, or if this
    QCborValue object is not an array or map, returns the undefined value.
 
    \sa operator[], QCborMap::operator[], QCborMap::value(),
        QCborMap::find(), QCborArray::operator[], QCborArray::at()
 */
const QCborValue QCborValue::operator[](qint64 key) const
{
    if (isArray() && container && quint64(key) < quint64(container->elements.size()))
        return container->valueAt(key);
    return QCborContainerPrivate::findCborMapKey(*this, key);
}
 
static bool shouldArrayRemainArray(qint64 key, QCborValue::Type t, QCborContainerPrivate *container)
{
    constexpr qint64 LargeKey = 0x10000;
    if (t != QCborValue::Array)
        return false;
    if (key < 0)
        return false;           // negative keys can't be an array index
    if (key < LargeKey)
        return true;
 
    // Only convert to map if key is greater than array size + 1
    qsizetype currentSize = container ? container->elements.size() : 0;
    return key <= currentSize;
}
 
/*!
  \internal
 */
static void convertArrayToMap(QCborContainerPrivate *&array)
{
    if (Q_LIKELY(!array || array->elements.isEmpty()))
        return;
 
    // The Q_LIKELY and the qWarning mark the rest of this function as unlikely
    qWarning("Using CBOR array as map forced conversion");
 
    qsizetype size = array->elements.size();
    QCborContainerPrivate *map = QCborContainerPrivate::detach(array, size * 2);
    map->elements.resize(size * 2);
 
    // this may be an in-place copy, so we have to do it from the end
    auto dst = map->elements.begin();
    auto src = array->elements.constBegin();
    for (qsizetype i = size - 1; i >= 0; --i) {
        Q_ASSERT(src->type != QCborValue::Invalid);
        dst[i * 2 + 1] = src[i];
    }
    for (qsizetype i = 0; i < size; ++i)
        dst[i * 2] = { i, QCborValue::Integer };
 
    // update reference counts
    assignContainer(array, map);
}
 
/*!
  \internal
 */
static QCborContainerPrivate *maybeGrow(QCborContainerPrivate *container, qsizetype index)
{
    auto replace = QCborContainerPrivate::grow(container, index);
    Q_ASSERT(replace);
    if (replace->elements.size() == index)
        replace->append(Undefined());
    else
        Q_ASSERT(replace->elements.size() > index);
    return assignContainer(container, replace);
}
 
template <typename KeyType> inline QCborValueRef
QCborContainerPrivate::findOrAddMapKey(QCborValue &self, KeyType key)
{
    // we need a map, so convert if necessary
    if (self.isArray())
        convertArrayToMap(self.container);
    else if (!self.isMap())
        self = QCborValue(QCborValue::Map);
    self.t = QCborValue::Map;
    self.n = -1;
 
    QCborValueRef result = findOrAddMapKey<KeyType>(self.container, key);
    assignContainer(self.container, result.d);
    return result;
}
 
template<typename KeyType> QCborValueRef
QCborContainerPrivate::findOrAddMapKey(QCborValueRef self, KeyType key)
{
    auto &e = self.d->elements[self.i];
 
    // we need a map, so convert if necessary
    if (e.type == QCborValue::Array) {
        convertArrayToMap(e.container);
    } else if (e.type != QCborValue::Map) {
        if (e.flags & QtCbor::Element::IsContainer)
            e.container->deref();
        e.container = nullptr;
    }
    e.flags = QtCbor::Element::IsContainer;
    e.type = QCborValue::Map;
 
    QCborValueRef result = findOrAddMapKey<KeyType>(e.container, key);
    assignContainer(e.container, result.d);
    return result;
}
 
/*!
    Returns a QCborValueRef that can be used to read or modify the entry in
    this, as a map, with the given \a key. When this QCborValue is a QCborMap,
    this function is equivalent to the matching operator[] on that map.
 
    Before returning the reference: if this QCborValue was an array, it is first
    converted to a map (so that \c{map[i]} is \c{array[i]} for each index, \c i,
    with valid \c{array[i]}); otherwise, if it was not a map it will be
    over-written with an empty map.
 
    \sa operator[](qint64), QCborMap::operator[], QCborMap::value(),
        QCborMap::find()
 */
QCborValueRef QCborValue::operator[](const QString &key)
{
    return QCborContainerPrivate::findOrAddMapKey(*this, qToStringViewIgnoringNull(key));
}
 
/*!
    \overload
 
    Returns a QCborValueRef that can be used to read or modify the entry in
    this, as a map, with the given \a key. When this QCborValue is a QCborMap,
    this function is equivalent to the matching operator[] on that map.
 
    Before returning the reference: if this QCborValue was an array, it is first
    converted to a map (so that \c{map[i]} is \c{array[i]} for each index, \c i,
    with valid \c{array[i]}); otherwise, if it was not a map it will be
    over-written with an empty map.
 
    \sa operator[](qint64), QCborMap::operator[], QCborMap::value(),
        QCborMap::find()
 */
QCborValueRef QCborValue::operator[](QLatin1StringView key)
{
    return QCborContainerPrivate::findOrAddMapKey(*this, key);
}
 
/*!
    \overload
 
    Returns a QCborValueRef that can be used to read or modify the entry in
    this, as a map or array, with the given \a key. When this QCborValue is a
    QCborMap or, for 0 <= key < 0x10000, a QCborArray, this function is
    equivalent to the matching operator[] on that map or array.
 
    Before returning the reference: if this QCborValue was an array but the key
    is out of range, the array is first converted to a map (so that \c{map[i]}
    is \c{array[i]} for each index, \c i, with valid \c{array[i]}); otherwise,
    if it was not a map it will be over-written with an empty map.
 
    \sa operator[], QCborMap::operator[], QCborMap::value(),
        QCborMap::find(), QCborArray::operator[], QCborArray::at()
 */
QCborValueRef QCborValue::operator[](qint64 key)
{
    if (shouldArrayRemainArray(key, t, container)) {
        container = maybeGrow(container, key);
        return { container, qsizetype(key) };
    }
    return QCborContainerPrivate::findOrAddMapKey(*this, key);
}
 
#if QT_CONFIG(cborstreamreader)
/*!
    Decodes one item from the CBOR stream found in \a reader and returns the
    equivalent representation. This function is recursive: if the item is a map
    or array, it will decode all items found in that map or array, until the
    outermost object is finished.
 
    This function need not be used on the root element of a \l
    QCborStreamReader. For example, the following code illustrates how to skip
    the CBOR signature tag from the beginning of a file:
 
    \snippet code/src_corelib_serialization_qcborvalue.cpp 6
 
    The returned value may be partially complete and indistinguishable from a
    valid QCborValue even if the decoding failed. To determine if there was an
    error, check if \l{QCborStreamReader::lastError()}{reader.lastError()} is
    indicating an error condition. This function stops decoding immediately
    after the first error.
 
    \sa toCbor(), toDiagnosticNotation(), toVariant(), toJsonValue()
 */
QCborValue QCborValue::fromCbor(QCborStreamReader &reader)
{
    QCborValue result;
    auto t = reader.type();
    if (reader.lastError() != QCborError::NoError)
        t = QCborStreamReader::Invalid;
 
    switch (t) {
    // basic types, no container needed:
    case QCborStreamReader::UnsignedInteger:
    case QCborStreamReader::NegativeInteger:
    case QCborStreamReader::SimpleType:
    case QCborStreamReader::Float16:
    case QCborStreamReader::Float:
    case QCborStreamReader::Double: {
        Element e = decodeBasicValueFromCbor(reader);
        result.n = e.value;
        result.t = e.type;
        break;
    }
 
    case QCborStreamReader::Invalid:
        result.t = QCborValue::Invalid;
        break;              // probably a decode error
 
    // strings
    case QCborStreamReader::ByteArray:
    case QCborStreamReader::String:
        result.n = 0;
        result.t = reader.isString() ? String : ByteArray;
        result.container = new QCborContainerPrivate;
        result.container->ref.ref();
        result.container->decodeStringFromCbor(reader);
        break;
 
    // containers
    case QCborStreamReader::Array:
    case QCborStreamReader::Map:
        result.n = -1;
        result.t = reader.isArray() ? Array : Map;
        result.container = createContainerFromCbor(reader, MaximumRecursionDepth);
        break;
 
    // tag
    case QCborStreamReader::Tag:
        result = taggedValueFromCbor(reader, MaximumRecursionDepth);
        break;
    }
 
    return result;
}
 
/*!
    \overload
 
    Decodes one item from the CBOR stream found in the byte array \a ba and
    returns the equivalent representation. This function is recursive: if the
    item is a map or array, it will decode all items found in that map or
    array, until the outermost object is finished.
 
    This function stores the error state, if any, in the object pointed to by
    \a error, along with the offset of where the error occurred. If no error
    happened, it stores \l{QCborError}{NoError} in the error state and the
    number of bytes that it consumed (that is, it stores the offset for the
    first unused byte). Using that information makes it possible to parse
    further data that may exist in the same byte array.
 
    The returned value may be partially complete and indistinguishable from a
    valid QCborValue even if the decoding failed. To determine if there was an
    error, check if there was an error stored in \a error. This function stops
    decoding immediately after the first error.
 
    \sa toCbor(), toDiagnosticNotation(), toVariant(), toJsonValue()
 */
QCborValue QCborValue::fromCbor(const QByteArray &ba, QCborParserError *error)
{
    QCborStreamReader reader(ba);
    QCborValue result = fromCbor(reader);
    if (error) {
        error->error = reader.lastError();
        error->offset = reader.currentOffset();
    }
    return result;
}
 
/*!
    \fn QCborValue QCborValue::fromCbor(const char *data, qsizetype len, QCborParserError *error)
    \fn QCborValue QCborValue::fromCbor(const quint8 *data, qsizetype len, QCborParserError *error)
    \overload
 
    Converts \a len bytes of \a data to a QByteArray and then calls the
    overload of this function that accepts a QByteArray, also passing \a error,
    if provided.
*/
#endif // QT_CONFIG(cborstreamreader)
 
#if QT_CONFIG(cborstreamwriter) && !defined(QT_BOOTSTRAPPED)
/*!
    Encodes this QCborValue object to its CBOR representation, using the
    options specified in \a opt, and return the byte array containing that
    representation.
 
    This function will not fail, except if this QCborValue or any of the
    contained items, if this is a map or array, are invalid. Invalid types are
    not produced normally by the API, but can result from decoding errors.
 
    By default, this function performs no transformation on the values in the
    QCborValue, writing all floating point directly as double-precision (\c
    double) types. If the \l{EncodingOption}{UseFloat} option is specified, it
    will use single precision (\c float) for any floating point value for which
    there's no loss of precision in using that representation. That includes
    infinities and NaN values.
 
    Similarly, if \l{EncodingOption}{UseFloat16} is specified, this function
    will try to use half-precision (\c qfloat16) floating point if the
    conversion to that results in no loss of precision. This is always true for
    infinities and NaN.
 
    If \l{EncodingOption}{UseIntegers} is specified, it will use integers for
    any floating point value that contains an actual integer.
 
    \sa fromCbor(), fromVariant(), fromJsonValue()
 */
QByteArray QCborValue::toCbor(EncodingOptions opt) const
{
    QByteArray result;
    QCborStreamWriter writer(&result);
    toCbor(writer, opt);
    return result;
}
 
/*!
    \overload
 
    Encodes this QCborValue object to its CBOR representation, using the
    options specified in \a opt, to the writer specified by \a writer. The same
    writer can be used by multiple QCborValues, for example, in order to encode
    different elements in a larger array.
 
    This function will not fail, except if this QCborValue or any of the
    contained items, if this is a map or array, are invalid. Invalid types are
    not produced normally by the API, but can result from decoding errors.
 
    By default, this function performs no transformation on the values in the
    QCborValue, writing all floating point directly as double-precision
    (binary64) types. If the \l{EncodingOption}{UseFloat} option is
    specified, it will use single precision (binary32) for any floating point
    value for which there's no loss of precision in using that representation.
    That includes infinities and NaN values.
 
    Similarly, if \l{EncodingOption}{UseFloat16} is specified, this function
    will try to use half-precision (binary16) floating point if the conversion
    to that results in no loss of precision. This is always true for infinities
    and NaN.
 
    If \l{EncodingOption}{UseIntegers} is specified, it will use integers
    for any floating point value that contains an actual integer.
 
    \sa fromCbor(), fromVariant(), fromJsonValue()
 */
Q_NEVER_INLINE void QCborValue::toCbor(QCborStreamWriter &writer, EncodingOptions opt) const
{
    if (isContainer() || isTag())
        return encodeToCbor(writer, container, -type(), opt);
    if (container)
        return encodeToCbor(writer, container, n, opt);
 
    // very simple types
    if (isSimpleType())
        return writer.append(toSimpleType());
 
    switch (type()) {
    case Integer:
        return writer.append(n);
 
    case Double:
        return writeDoubleToCbor(writer, fp_helper(), opt);
 
    case Invalid:
        return;
 
    case SimpleType:
    case False:
    case True:
    case Null:
    case Undefined:
        // handled by "if (isSimpleType())"
        Q_UNREACHABLE();
        break;
 
    case ByteArray:
        // Byte array with no container is empty
        return writer.appendByteString("", 0);
 
    case String:
        // String with no container is empty
        return writer.appendTextString("", 0);
 
    case Array:
    case Map:
    case Tag:
        // handled by "if (isContainer() || isTag())"
        Q_UNREACHABLE();
        break;
 
    case DateTime:
    case Url:
    case RegularExpression:
    case Uuid:
        // not possible
        Q_UNREACHABLE();
        break;
    }
}
 
#  if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
void QCborValueRef::toCbor(QCborStreamWriter &writer, QCborValue::EncodingOptions opt)
{
    concrete().toCbor(writer, opt);
}
#  endif
#endif // QT_CONFIG(cborstreamwriter) && !QT_BOOTSTRAPPED
 
void QCborValueRef::assign(QCborValueRef that, const QCborValue &other)
{
    that.d->replaceAt(that.i, other);
}
 
void QCborValueRef::assign(QCborValueRef that, QCborValue &&other)
{
    that.d->replaceAt(that.i, other, QCborContainerPrivate::MoveContainer);
}
 
void QCborValueRef::assign(QCborValueRef that, const QCborValueRef other)
{
    // ### optimize?
    that = other.concrete();
}
 
bool QCborValueConstRef::concreteBoolean(QCborValueConstRef self, bool defaultValue) noexcept
{
    QtCbor::Element e = self.d->elements.at(self.i);
    if (e.type != QCborValue::False && e.type != QCborValue::True)
        return defaultValue;
    return e.type == QCborValue::True;
}
 
double QCborValueConstRef::concreteDouble(QCborValueConstRef self, double defaultValue) noexcept
{
    QtCbor::Element e = self.d->elements.at(self.i);
    if (e.type == QCborValue::Integer)
        return e.value;
    if (e.type != QCborValue::Double)
        return defaultValue;
    return e.fpvalue();
}
 
qint64 QCborValueConstRef::concreteIntegral(QCborValueConstRef self, qint64 defaultValue) noexcept
{
    QtCbor::Element e = self.d->elements.at(self.i);
    QCborValue::Type t = e.type;
    if (t == QCborValue::Double)
        return e.fpvalue();
    if (t != QCborValue::Integer)
        return defaultValue;
    return e.value;
}
 
QByteArray QCborValueConstRef::concreteByteArray(QCborValueConstRef self,
                                                 const QByteArray &defaultValue)
{
    QtCbor::Element e = self.d->elements.at(self.i);
    if (e.type != QCborValue::ByteArray)
        return defaultValue;
    return self.d->byteArrayAt(self.i);
}
 
QString QCborValueConstRef::concreteString(QCborValueConstRef self, const QString &defaultValue)
{
    QtCbor::Element e = self.d->elements.at(self.i);
    if (e.type != QCborValue::String)
        return defaultValue;
    return self.d->stringAt(self.i);
}
 
QAnyStringView QCborValueConstRef::concreteStringView(QCborValueConstRef self, QAnyStringView defaultValue)
{
    QtCbor::Element e = self.d->elements.at(self.i);
    if (e.type != QCborValue::String)
        return defaultValue;
    return self.d->anyStringViewAt(self.i);
}
 
bool
QCborValueConstRef::comparesEqual_helper(QCborValueConstRef lhs, QCborValueConstRef rhs) noexcept
{
    QtCbor::Element e1 = lhs.d->elements.at(lhs.i);
    QtCbor::Element e2 = rhs.d->elements.at(rhs.i);
    return compareElementRecursive(lhs.d, e1, rhs.d, e2, Comparison::ForEquality) == 0;
}
 
Qt::strong_ordering
QCborValueConstRef::compareThreeWay_helper(QCborValueConstRef lhs, QCborValueConstRef rhs) noexcept
{
    QtCbor::Element e1 = lhs.d->elements.at(lhs.i);
    QtCbor::Element e2 = rhs.d->elements.at(rhs.i);
    int c = compareElementRecursive(lhs.d, e1, rhs.d, e2, Comparison::ForOrdering);
    return Qt::compareThreeWay(c, 0);
}
 
bool
QCborValueConstRef::comparesEqual_helper(QCborValueConstRef lhs, const QCborValue &rhs) noexcept
{
    QtCbor::Element e1 = lhs.d->elements.at(lhs.i);
    QtCbor::Element e2 = QCborContainerPrivate::elementFromValue(rhs);
    return compareElementRecursive(lhs.d, e1, rhs.container, e2, Comparison::ForEquality) == 0;
}
 
Qt::strong_ordering
QCborValueConstRef::compareThreeWay_helper(QCborValueConstRef lhs, const QCborValue &rhs) noexcept
{
    QtCbor::Element e1 = lhs.d->elements.at(lhs.i);
    QtCbor::Element e2 = QCborContainerPrivate::elementFromValue(rhs);
    int c = compareElementRecursive(lhs.d, e1, rhs.container, e2, Comparison::ForOrdering);
    return Qt::compareThreeWay(c, 0);
}
 
bool QCborArray::comparesEqual_helper(const QCborArray &lhs, QCborValueConstRef rhs) noexcept
{
    QtCbor::Element e2 = rhs.d->elements.at(rhs.i);
    if (typeOrder(QCborValue::Array, e2.type))
        return false;
    return compareContainer(lhs.d.constData(), e2.container, Comparison::ForEquality) == 0;
}
 
Qt::strong_ordering
QCborArray::compareThreeWay_helper(const QCborArray &lhs, QCborValueConstRef rhs) noexcept
{
    QtCbor::Element e2 = rhs.d->elements.at(rhs.i);
    int c = typeOrder(QCborValue::Array, e2.type);
    if (c == 0)
        c = compareContainer(lhs.d.constData(), e2.container, Comparison::ForOrdering);
    return Qt::compareThreeWay(c, 0);
}
 
bool QCborMap::comparesEqual_helper(const QCborMap &lhs, QCborValueConstRef rhs) noexcept
{
    QtCbor::Element e2 = rhs.d->elements.at(rhs.i);
    if (typeOrder(QCborValue::Array, e2.type))
        return false;
    return compareContainer(lhs.d.constData(), e2.container, Comparison::ForEquality) == 0;
}
 
Qt::strong_ordering
QCborMap::compareThreeWay_helper(const QCborMap &lhs, QCborValueConstRef rhs) noexcept
{
    QtCbor::Element e2 = rhs.d->elements.at(rhs.i);
    int c = typeOrder(QCborValue::Map, e2.type);
    if (c == 0)
        c = compareContainer(lhs.d.constData(), e2.container, Comparison::ForOrdering);
    return Qt::compareThreeWay(c, 0);
}
 
QCborValue QCborValueConstRef::concrete(QCborValueConstRef self) noexcept
{
    return self.d->valueAt(self.i);
}
 
QCborValue::Type QCborValueConstRef::concreteType(QCborValueConstRef self) noexcept
{
    return self.d->elements.at(self.i).type;
}
 
const QCborValue QCborValueConstRef::operator[](const QString &key) const
{
    const QCborValue item = d->valueAt(i);
    return item[key];
}
 
const QCborValue QCborValueConstRef::operator[](const QLatin1StringView key) const
{
    const QCborValue item = d->valueAt(i);
    return item[key];
}
 
const QCborValue QCborValueConstRef::operator[](qint64 key) const
{
    const QCborValue item = d->valueAt(i);
    return item[key];
}
 
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)
QCborValue QCborValueRef::concrete(QCborValueRef self) noexcept
{
    return self.d->valueAt(self.i);
}
 
QCborValue::Type QCborValueRef::concreteType(QCborValueRef self) noexcept
{
    return self.d->elements.at(self.i).type;
}
 
/*!
    If this QCborValueRef refers to a QCborMap, searches elements for the value
    whose key matches \a key. If there's no key matching \a key in the map or if
    this QCborValueRef object is not a map, returns the undefined value.
 
    This function is equivalent to:
 
    \code
      value.toMap().value(key);
    \endcode
 
    \sa operator[](qint64), QCborMap::operator[], QCborMap::value(),
        QCborMap::find()
 */
const QCborValue QCborValueRef::operator[](const QString &key) const
{
    return QCborValueConstRef::operator[](key);
}
 
/*!
    \overload
 
    If this QCborValueRef refers to a QCborMap, searches elements for the value
    whose key matches \a key. If there's no key matching \a key in the map or if
    this QCborValueRef object is not a map, returns the undefined value.
 
    This function is equivalent to:
 
    \code
      value.toMap().value(key);
    \endcode
 
    \sa operator[](qint64), QCborMap::operator[], QCborMap::value(),
        QCborMap::find()
 */
const QCborValue QCborValueRef::operator[](QLatin1StringView key) const
{
    return QCborValueConstRef::operator[](key);
}
 
/*!
   \overload
 
    If this QCborValueRef refers to a QCborMap, searches elements for the value
    whose key matches \a key. If this is a QCborArray, returns the element whose
    index is \a key. If there's no matching value in the array or map, or if
    this QCborValueRef object is not an array or map, returns the undefined
    value.
 
    \sa operator[], QCborMap::operator[], QCborMap::value(),
        QCborMap::find(), QCborArray::operator[], QCborArray::at()
 */
const QCborValue QCborValueRef::operator[](qint64 key) const
{
    return QCborValueConstRef::operator[](key);
}
 
/*!
    Returns a QCborValueRef that can be used to read or modify the entry in
    this, as a map, with the given \a key. When this QCborValueRef refers to a
    QCborMap, this function is equivalent to the matching operator[] on that
    map.
 
    Before returning the reference: if the QCborValue referenced was an array,
    it is first converted to a map (so that \c{map[i]} is \c{array[i]} for each
    index, \c i, with valid \c{array[i]}); otherwise, if it was not a map it
    will be over-written with an empty map.
 
    \sa operator[](qint64), QCborMap::operator[], QCborMap::value(),
        QCborMap::find()
 */
QCborValueRef QCborValueRef::operator[](const QString &key)
{
    return QCborContainerPrivate::findOrAddMapKey(*this, qToStringViewIgnoringNull(key));
}
 
/*!
    \overload
 
    Returns a QCborValueRef that can be used to read or modify the entry in
    this, as a map, with the given \a key. When this QCborValue is a QCborMap,
    this function is equivalent to the matching operator[] on that map.
 
    Before returning the reference: if the QCborValue referenced was an array,
    it is first converted to a map (so that \c{map[i]} is \c{array[i]} for each
    index, \c i, with valid \c{array[i]}); otherwise, if it was not a map it
    will be over-written with an empty map.
 
    \sa operator[](qint64), QCborMap::operator[], QCborMap::value(),
        QCborMap::find()
 */
QCborValueRef QCborValueRef::operator[](QLatin1StringView key)
{
    return QCborContainerPrivate::findOrAddMapKey(*this, key);
}
 
/*!
    \overload
 
    Returns a QCborValueRef that can be used to read or modify the entry in
    this, as a map or array, with the given \a key. When this QCborValue is a
    QCborMap or, for 0 <= key < 0x10000, a QCborArray, this function is
    equivalent to the matching operator[] on that map or array.
 
    Before returning the reference: if the QCborValue referenced was an array
    but the key is out of range, the array is first converted to a map (so that
    \c{map[i]} is \c{array[i]} for each index, \c i, with valid \c{array[i]});
    otherwise, if it was not a map it will be over-written with an empty map.
 
    \sa operator[], QCborMap::operator[], QCborMap::value(),
        QCborMap::find(), QCborArray::operator[], QCborArray::at()
 */
QCborValueRef QCborValueRef::operator[](qint64 key)
{
    auto &e = d->elements[i];
    if (shouldArrayRemainArray(key, e.type, e.container)) {
        e.container = maybeGrow(e.container, key);
        e.flags |= QtCbor::Element::IsContainer;
        return { e.container, qsizetype(key) };
    }
    return QCborContainerPrivate::findOrAddMapKey(*this, key);
}
#endif // < Qt 7
 
inline QCborArray::QCborArray(QCborContainerPrivate &dd) noexcept
    : d(&dd)
{
}
 
inline QCborMap::QCborMap(QCborContainerPrivate &dd) noexcept
    : d(&dd)
{
}
 
size_t qHash(const QCborValue &value, size_t seed)
{
    switch (value.type()) {
    case QCborValue::Integer:
        return qHash(value.toInteger(), seed);
    case QCborValue::ByteArray:
        return qHash(value.toByteArray(), seed);
    case QCborValue::String:
        return qHash(value.toString(), seed);
    case QCborValue::Array:
        return qHash(value.toArray(), seed);
    case QCborValue::Map:
        return qHash(value.toMap(), seed);
    case QCborValue::Tag:
        return qHashMulti(seed, value.tag(), value.taggedValue());
    case QCborValue::SimpleType:
        break;
    case QCborValue::False:
        return qHash(false, seed);
    case QCborValue::True:
        return qHash(true, seed);
    case QCborValue::Null:
        return qHash(nullptr, seed);
    case QCborValue::Undefined:
        return seed;
    case QCborValue::Double:
        return qHash(value.toDouble(), seed);
#if QT_CONFIG(datestring)
    case QCborValue::DateTime:
        return qHash(value.toDateTime(), seed);
#endif
#ifndef QT_BOOTSTRAPPED
    case QCborValue::Url:
        return qHash(value.toUrl(), seed);
#  if QT_CONFIG(regularexpression)
    case QCborValue::RegularExpression:
        return qHash(value.toRegularExpression(), seed);
#  endif
    case QCborValue::Uuid:
        return qHash(value.toUuid(), seed);
#endif
    case QCborValue::Invalid:
        return seed;
    default:
        break;
    }
 
    Q_ASSERT(value.isSimpleType());
    return qHash(value.toSimpleType(), seed);
}
 
Q_CORE_EXPORT const char *qt_cbor_simpletype_id(QCborSimpleType st)
{
    switch (st) {
    case QCborSimpleType::False:
        return "False";
    case QCborSimpleType::True:
        return "True";
    case QCborSimpleType::Null:
        return "Null";
    case QCborSimpleType::Undefined:
        return "Undefined";
    }
    return nullptr;
}
 
Q_CORE_EXPORT const char *qt_cbor_tag_id(QCborTag tag)
{
    // Casting to QCborKnownTags's underlying type will make the comparison
    // below fail if the tag value is out of range.
    auto n = std::underlying_type<QCborKnownTags>::type(tag);
    if (QCborTag(n) == tag) {
        switch (QCborKnownTags(n)) {
        case QCborKnownTags::DateTimeString:
            return "DateTimeString";
        case QCborKnownTags::UnixTime_t:
            return "UnixTime_t";
        case QCborKnownTags::PositiveBignum:
            return "PositiveBignum";
        case QCborKnownTags::NegativeBignum:
            return "NegativeBignum";
        case QCborKnownTags::Decimal:
            return "Decimal";
        case QCborKnownTags::Bigfloat:
            return "Bigfloat";
        case QCborKnownTags::COSE_Encrypt0:
            return "COSE_Encrypt0";
        case QCborKnownTags::COSE_Mac0:
            return "COSE_Mac0";
        case QCborKnownTags::COSE_Sign1:
            return "COSE_Sign1";
        case QCborKnownTags::ExpectedBase64url:
            return "ExpectedBase64url";
        case QCborKnownTags::ExpectedBase64:
            return "ExpectedBase64";
        case QCborKnownTags::ExpectedBase16:
            return "ExpectedBase16";
        case QCborKnownTags::EncodedCbor:
            return "EncodedCbor";
        case QCborKnownTags::Url:
            return "Url";
        case QCborKnownTags::Base64url:
            return "Base64url";
        case QCborKnownTags::Base64:
            return "Base64";
        case QCborKnownTags::RegularExpression:
            return "RegularExpression";
        case QCborKnownTags::MimeMessage:
            return "MimeMessage";
        case QCborKnownTags::Uuid:
            return "Uuid";
        case QCborKnownTags::COSE_Encrypt:
            return "COSE_Encrypt";
        case QCborKnownTags::COSE_Mac:
            return "COSE_Mac";
        case QCborKnownTags::COSE_Sign:
            return "COSE_Sign";
        case QCborKnownTags::Signature:
            return "Signature";
        }
    }
    return nullptr;
}
 
#if !defined(QT_NO_DEBUG_STREAM)
static QDebug debugContents(QDebug &dbg, const QCborValue &v)
{
    switch (v.type()) {
    case QCborValue::Integer:
        return dbg << v.toInteger();
    case QCborValue::ByteArray:
        return dbg << "QByteArray(" << v.toByteArray() << ')';
    case QCborValue::String:
        return dbg << v.toString();
    case QCborValue::Array:
        return dbg << v.toArray();
    case QCborValue::Map:
        return dbg << v.toMap();
    case QCborValue::Tag: {
        QCborTag tag = v.tag();
        const char *id = qt_cbor_tag_id(tag);
        if (id)
            dbg.nospace() << "QCborKnownTags::" << id << ", ";
        else
            dbg.nospace() << "QCborTag(" << quint64(tag) << "), ";
        return dbg << v.taggedValue();
    }
    case QCborValue::SimpleType:
        break;
    case QCborValue::True:
        return dbg << true;
    case QCborValue::False:
        return dbg << false;
    case QCborValue::Null:
        return dbg << "nullptr";
    case QCborValue::Undefined:
        return dbg;
    case QCborValue::Double: {
        qint64 i;
        if (convertDoubleTo(v.toDouble(), &i))
            return dbg << i << ".0";
        else
            return dbg << v.toDouble();
    }
#if QT_CONFIG(datestring)
    case QCborValue::DateTime:
        return dbg << v.toDateTime();
#endif
#ifndef QT_BOOTSTRAPPED
    case QCborValue::Url:
        return dbg << v.toUrl();
#if QT_CONFIG(regularexpression)
    case QCborValue::RegularExpression:
        return dbg << v.toRegularExpression();
#endif
    case QCborValue::Uuid:
        return dbg << v.toUuid();
#endif
    case QCborValue::Invalid:
        return dbg << "<invalid>";
    default:
        break;
    }
    if (v.isSimpleType())
        return dbg << v.toSimpleType();
    return dbg << "<unknown type 0x" << Qt::hex << int(v.type()) << Qt::dec << '>';
}
QDebug operator<<(QDebug dbg, const QCborValue &v)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QCborValue(";
    return debugContents(dbg, v) << ')';
}
 
QDebug operator<<(QDebug dbg, QCborSimpleType st)
{
    QDebugStateSaver saver(dbg);
    const char *id = qt_cbor_simpletype_id(st);
    if (id)
        return dbg.nospace() << "QCborSimpleType::" << id;
 
    return dbg.nospace() << "QCborSimpleType(" << uint(st) << ')';
}
 
QDebug operator<<(QDebug dbg, QCborTag tag)
{
    QDebugStateSaver saver(dbg);
    const char *id = qt_cbor_tag_id(tag);
    dbg.nospace() << "QCborTag(";
    if (id)
        dbg.nospace() << "QCborKnownTags::" << id;
    else
        dbg.nospace() << quint64(tag);
 
    return dbg << ')';
}
 
QDebug operator<<(QDebug dbg, QCborKnownTags tag)
{
    QDebugStateSaver saver(dbg);
    const char *id = qt_cbor_tag_id(QCborTag(int(tag)));
    if (id)
        return dbg.nospace() << "QCborKnownTags::" << id;
 
    return dbg.nospace() << "QCborKnownTags(" << int(tag) << ')';
}
#endif
 
#ifndef QT_NO_DATASTREAM
#if QT_CONFIG(cborstreamwriter)
QDataStream &operator<<(QDataStream &stream, const QCborValue &value)
{
    stream << QCborValue(value).toCbor();
    return stream;
}
#endif
 
#if QT_CONFIG(cborstreamreader)
QDataStream &operator>>(QDataStream &stream, QCborValue &value)
{
    QByteArray buffer;
    stream >> buffer;
    QCborParserError parseError{};
    value = QCborValue::fromCbor(buffer, &parseError);
    if (parseError.error)
        stream.setStatus(QDataStream::ReadCorruptData);
    return stream;
}
#endif
#endif // QT_NO_DATASTREAM
 
 
QT_END_NAMESPACE
 
#include "qcborarray.cpp"
#include "qcbormap.cpp"
 
#ifndef QT_NO_QOBJECT
#include "moc_qcborvalue.cpp"
#endif