QCborStreamWriter Class

Dokumentation zu den Member-Funktionen

[explicit] QCborStreamWriter::QCborStreamWriter(QByteArray *data)

Erstellt ein QCborStreamWriter-Objekt, das den Stream an data anhängt. Die gesamte Datenübertragung erfolgt sofort in das Byte-Array, ohne dass Puffer geleert werden müssen.

Das folgende Beispiel schreibt eine Zahl in ein Byte-Array und gibt diese anschließend zurück.

QByteArray encodedNumber(qint64 value)
{
    QByteArray ba;
    QCborStreamWriter writer(&ba);
    writer.append(value);
    return ba;
}

QCborStreamWriter übernimmt nicht die Eigentumsrechte an data.

[explicit] QCborStreamWriter::QCborStreamWriter(QIODevice *device)

Erstellt ein QCborStreamWriter-Objekt, das den Stream in „ device “ schreibt. Das Gerät muss geöffnet sein, bevor der erste Aufruf von „ append()“ erfolgt. Dieser Konstruktor kann mit jeder Klasse verwendet werden, die von „ QIODevice “ abgeleitet ist, wie beispielsweise „ QFile “, „ QProcess “ oder „ QTcpSocket “.

QCborStreamWriter verfügt über keine Pufferung, sodass jeder Aufruf von ` append()` zu einem oder mehreren Aufrufen der Methode ` write()` des Geräts führt.

Das folgende Beispiel schreibt eine leere Map in eine Datei:

QFile f("output");
QCborStreamWriter writer(&f);
writer.startMap(0);
writer.endMap();

QCborStreamWriter übernimmt nicht die Verantwortung für device.

Siehe auch device() und setDevice().

[delete] QCborStreamWriter::QCborStreamWriter(const QCborStreamWriter &)

Erstellt eine Instanz von „ QCborStreamWriter “ durch Kopieren. Diese Funktion wird gelöscht.

[noexcept] QCborStreamWriter::~QCborStreamWriter()

Löscht dieses „ QCborStreamWriter “-Objekt und gibt alle damit verbundenen Ressourcen frei.

QCborStreamWriter Es wird keine Fehlerprüfung durchgeführt, um festzustellen, ob alle erforderlichen Elemente vor der Löschung des Objekts in den Stream geschrieben wurden. Es liegt in der Verantwortung des Programmierers, sicherzustellen, dass dies geschehen ist.

Fügt das Byte-Array „ ba “ an den Stream an und erstellt dabei einen CBOR-Byte-String-Wert. „ QCborStreamWriter “ versucht, den gesamten String in einem einzigen Block zu schreiben.

Das folgende Beispiel lädt den Inhalt einer Datei und hängt ihn an den Stream an:

void writeFile(QCborStreamWriter &writer, const QString &fileName)
{
    QFile f(fileName);
    if (f.open(QIODevice::ReadOnly))
        writer.append(f.readAll());
}

Wie das Beispiel zeigt, erfordert CBOR im Gegensatz zu JSON keine Escape-Zeichen für binäre Inhalte.

Siehe auch „ appendByteString()“, „ QCborStreamReader::isByteArray()“ und „ QCborStreamReader::readByteArray()“.

void QCborStreamWriter::append(QCborKnownTags tag)

Fügt das CBOR-Tag „ tag “ an den Stream an und erstellt so einen CBOR-Tag-Wert. Auf alle Tags muss ein weiterer Typ folgen, dem sie eine Bedeutung verleihen.

Im folgenden Beispiel fügen wir dem Stream ein CBOR-Tag 1 (Unix- time_t) sowie eine Ganzzahl hinzu, die die aktuelle Uhrzeit angibt und mit der Funktion ` time() ` ermittelt wurde:

void writeCurrentTime(QCborStreamWriter &writer)
{
    writer.append(QCborKnownTags::UnixTime_t);
    writer.append(qint64(time(nullptr)));
}

Siehe auch ` QCborStreamReader::isTag()` und ` QCborStreamReader::toTag()`.

void QCborStreamWriter::append(QCborNegativeInteger n)

Fügt den negativen 64-Bit-Wert „ n “ an den CBOR-Stream an. „QCborNegativeInteger“ ist eine 64-Bit-Enumeration, die den Absolutwert der negativen Zahl enthält, die geschrieben werden soll. Ist n gleich Null, entspricht der geschriebene Wert^2⁶⁴ (das heißt -18.446.744.073.709.551.616).

Im folgenden Beispiel schreiben wir die Werte -1,^-232 und INT64_MIN:

writer.append(QCborNegativeInteger(1));
writer.append(QCborNegativeInteger(Q_INT64_C(4294967296)));
writer.append(QCborNegativeInteger(-quint64(std::numeric_limits<qint64>::min())));

Beachten Sie, wie diese Funktion verwendet werden kann, um Zahlen zu kodieren, die nicht in eine vorzeichenbehaftete 64-Bit-Ganzzahl eines Standardcomputers passen, wie z. B. qint64. Das heißt, wenn n größer als std::numeric_limits<qint64>::max() ist oder 0 ist, stellt dies eine negative Zahl dar, die kleiner als std::numeric_limits<qint64>::min() ist.

Siehe auch QCborStreamReader::isNegativeInteger() und QCborStreamReader::toNegativeInteger().

void QCborStreamWriter::append(QCborSimpleType st)

Fügt den CBOR-Einfachtyp „ st “ an den Stream an und erstellt dabei einen CBOR-Einfachtyp-Wert. Im folgenden Beispiel schreiben wir den Einfachtyp sowohl für „Null“ als auch für den Typ 32, den Qt nicht unterstützt.

writer.append(QCborSimpleType::Null);
writer.append(QCborSimpleType(32));

Siehe auch QCborStreamReader::isSimpleType() und QCborStreamReader::toSimpleType().

void QCborStreamWriter::append(QCborTag tag)

Fügt das CBOR-Tag „ tag “ an den Stream an und erstellt dabei einen CBOR-Tag-Wert. Auf alle Tags muss ein weiterer Typ folgen, dem sie eine Bedeutung verleihen.

Im folgenden Beispiel fügen wir dem Stream ein CBOR-Tag 36 (Regulärer Ausdruck) und das Muster von QRegularExpression hinzu:

void writeRxPattern(QCborStreamWriter &writer, const QRegularExpression &rx)
{
    writer.append(QCborTag(36));
    writer.append(rx.pattern());
}

Siehe auch „ QCborStreamReader::isTag()“ und „ QCborStreamReader::toTag()“.

void QCborStreamWriter::append(QLatin1StringView str)

Fügt die von ` str ` angezeigte Latin-1-Zeichenkette an den Stream an und erstellt dabei einen CBOR-Text-String-Wert. ` QCborStreamWriter ` versucht, die gesamte Zeichenkette in einem Block zu schreiben.

Das folgende Beispiel hängt ein einfaches Latin-1-Zeichenfolgenliteral an den Stream an:

using namespace Qt::StringLiterals;
// ...
writer.append("Hello, World"_L1);

Hinweis zur Leistung: CBOR erfordert, dass alle Text-Strings in UTF-8 kodiert sind. Daher durchläuft diese Funktion die Zeichen im String, um festzustellen, ob der Inhalt US-ASCII entspricht oder nicht. Wird festgestellt, dass die Zeichenfolge Zeichen außerhalb des US-ASCII-Zeichensatzes enthält, wird Speicher zugewiesen und die Zeichenfolge in UTF-8 konvertiert. Ist diese Überprüfung nicht erforderlich, verwenden Sie stattdessen ` appendTextString()` oder die Überladung, die ` QUtf8StringView` akzeptiert.

Siehe auch QCborStreamReader::isString() und QCborStreamReader::readString().

void QCborStreamWriter::append(QStringView str)

Fügt die Textzeichenfolge „ str “ an den Stream an und erstellt dabei einen CBOR-Textzeichenfolgenwert. „ QCborStreamWriter “ versucht, die gesamte Zeichenfolge in einem Block zu schreiben.

Das folgende Beispiel schreibt eine beliebige Zeichenfolge „ QString “ in den Stream:

void writeString(QCborStreamWriter &writer, const QString &str)
{
    writer.append(str);
}

Siehe auch „ QCborStreamReader::isString()“ und „ QCborStreamReader::readString()“.

[since 6.10] void QCborStreamWriter::append(QUtf8StringView str)

Fügt die von „ str “ angezeigte UTF-8-Zeichenkette an den Stream an und erstellt dabei einen CBOR-Text-String-Wert. „ QCborStreamWriter “ versucht, die gesamte Zeichenkette in einem Block zu schreiben.

Diese Funktion wurde in Qt 6.10 eingeführt.

Siehe auch appendTextString(), QCborStreamReader::isString() und QCborStreamReader::readString().

void QCborStreamWriter::append(bool b)

Fügt den booleschen Wert „ b “ an den Stream an und erzeugt dabei entweder einen CBOR-False-Wert oder einen CBOR-True-Wert. Diese Funktion entspricht folgendem Ausdruck (und ist entsprechend implementiert):

writer.append(b ? QCborSimpleType::True : QCborSimpleType::False);

Siehe auch „ appendNull()“, „ appendUndefined()“, „ QCborStreamReader::isBool()“ und „ QCborStreamReader::toBool()“.

void QCborStreamWriter::append(double d)

Fügt die Gleitkommazahl d an den Stream an und erzeugt dabei einen CBOR-Wert mit 64-Bit-Doppelpräzision. „ QCborStreamWriter “ fügt die Zahl immer unverändert an, ohne zu prüfen, ob es sich um die kanonische Form für NaN oder eine Unendlichkeit handelt, ob sie denormalisiert ist oder ob sie in einem kürzeren Format geschrieben werden könnte.

Der folgende Code führt alle diese Prüfungen durch, mit Ausnahme der Prüfung auf denormalisierte Werte, von der erwartet wird, dass sie direkt von der System-FPU oder der Gleitkommaemulation berücksichtigt wird.

void writeDouble(QCborStreamWriter &writer, double d)
{
    float f;
    if (qIsNaN(d)) {
        writer.append(qfloat16(qQNaN()));
    } else if (qIsInf(d)) {
        writer.append(d < 0 ? -qInf() : qInf());
    } else if ((f = d) == d) {
        qfloat16 f16 = qfloat16(f);
        if (f16 == f)
            writer.append(f16);
        else
            writer.append(f);
    } else {
        writer.append(d);
    }
}

Die Feststellung, ob ein Double-Wert ohne Genauigkeitsverlust in einen ganzzahligen Wert konvertiert werden kann, bleibt dem Leser als Übung überlassen.

Siehe auch QCborStreamReader::isDouble() und QCborStreamReader::toDouble().

void QCborStreamWriter::append(float f)

Fügt die Gleitkommazahl „ f “ an den Stream an und erzeugt dabei einen CBOR-Wert mit 32-Bit-Gleitkomma (einfache Genauigkeit). Der folgende Code kann verwendet werden, um ein C++- double, in „ float “ zu konvertieren, sofern kein Genauigkeitsverlust auftritt, und es anzuhängen, oder stattdessen das „ double “ anzuhängen.

void writeFloat(QCborStreamWriter &writer, double d)
{
    float f = d;
    if (qIsNaN(d) || d == f)
        writer.append(f);
    else
        writer.append(d);
}

Siehe auch „ QCborStreamReader::isFloat()“ und „ QCborStreamReader::toFloat()“.

void QCborStreamWriter::append(qfloat16 f)

Fügt die Gleitkommazahl ` f ` an den Stream an und erzeugt dabei einen CBOR-Wert mit 16-Bit-Halbpräzisions-Gleitkomma. Der folgende Code kann verwendet werden, um eine C++- float -Zahl in ` qfloat16 ` zu konvertieren, sofern kein Präzisionsverlust auftritt, und sie anzuhängen, oder stattdessen die ` float` anzuhängen.

void writeFloat(QCborStreamWriter &writer, float f)
{
    qfloat16 f16 = qfloat16(f);
    if (qIsNaN(f) || f16 == f)
        writer.append(f16);
    else
        writer.append(f);
}

Siehe auch „ QCborStreamReader::isFloat16()“ und „ QCborStreamReader::toFloat16()“.

void QCborStreamWriter::append(qint64 i)

Fügt den 64-Bit-Wert „ i “ mit Vorzeichen an den CBOR-Stream an. Je nach Vorzeichen des Parameters wird dabei entweder ein CBOR-Wert vom Typ „Unsigned Integer“ oder „NegativeInteger“ erzeugt. Im folgenden Beispiel schreiben wir die Werte 0, -1,²³² und „ INT64_MAX “ :

writer.append(0);
writer.append(-1);
writer.append(Q_INT64_C(4294967296));
writer.append(std::numeric_limits<qint64>::max());

Siehe auch ` QCborStreamReader::isInteger()` und ` QCborStreamReader::toInteger()`.

void QCborStreamWriter::append(quint64 u)

Fügt den 64-Bit-Wert „ u “ (ohne Vorzeichen) an den CBOR-Stream an und erzeugt so einen CBOR-Wert vom Typ „Unsigned Integer“. Im folgenden Beispiel schreiben wir die Werte 0,²³² und „ UINT64_MAX “ (ohne Vorzeichen) :

writer.append(0U);
writer.append(Q_UINT64_C(4294967296));
writer.append(std::numeric_limits<quint64>::max());

Siehe auch QCborStreamReader::isUnsignedInteger() und QCborStreamReader::toUnsignedInteger().

void QCborStreamWriter::append(std::nullptr_t)

Fügt dem Stream einen CBOR-Nullwert an. Diese Funktion entspricht (und ist implementiert als): Der Parameter wird ignoriert.

writer.append(QCborSimpleType::Null);

Siehe auch appendNull(), append(QCborSimpleType) und QCborStreamReader::isNull().

void QCborStreamWriter::append(const char *str, qsizetype size = -1)

Fügt size Bytes Text, beginnend bei str, an den Stream an und erstellt dabei einen CBOR-Text-String-Wert. QCborStreamWriter versucht, die gesamte Zeichenfolge in einem Block zu schreiben. Ist size gleich -1, schreibt diese Funktion strlen(\a str) Bytes.

Es wird erwartet, dass die Zeichenkette, auf die str verweist, korrekt in UTF-8 kodiert ist. QCborStreamWriter führt keine Überprüfung durch, ob dies der Fall ist.

Siehe auch append(QLatin1StringView), append(QStringView), QCborStreamReader::isString() und QCborStreamReader::readString().

void QCborStreamWriter::appendByteString(const char *data, qsizetype len)

Fügt len Bytes an Daten, beginnend bei data, an den Stream an und erzeugt dabei einen CBOR-Byte-String-Wert. QCborStreamWriter versucht, den gesamten String in einem einzigen Block zu schreiben.

Siehe auch append(), appendTextString(), QCborStreamReader::isByteArray() und QCborStreamReader::readByteArray().

void QCborStreamWriter::appendNull()

Fügt dem Stream einen CBOR-Null-Wert an. Diese Funktion entspricht folgender Funktion (und ist als diese implementiert):

writer.append(QCborSimpleType::Null);

Siehe auch append(std::nullptr_t), append(QCborSimpleType) und QCborStreamReader::isNull().

void QCborStreamWriter::appendTextString(const char *utf8, qsizetype len)

Fügt len Bytes Text, beginnend bei utf8, an den Stream an und erstellt dabei einen CBOR-Text-String-Wert. QCborStreamWriter versucht, die gesamte Zeichenkette in einem Block zu schreiben.

Es wird erwartet, dass die Zeichenkette, auf die utf8 verweist, korrekt in UTF-8 kodiert ist. QCborStreamWriter führt keine Überprüfung durch, ob dies der Fall ist.

Siehe auch append(QLatin1StringView), append(QStringView), QCborStreamReader::isString() und QCborStreamReader::readString().

void QCborStreamWriter::appendUndefined()

Fügt dem Stream einen undefinierten CBOR-Wert hinzu. Diese Funktion entspricht (und ist implementiert als):

writer.append(QCborSimpleType::Undefined);

Siehe auch append(QCborSimpleType) und QCborStreamReader::isUndefined().

QIODevice *QCborStreamWriter::device() const

Gibt die „ QIODevice “ zurück, in die dieses „ QCborStreamWriter “-Objekt schreibt. Das Gerät muss zuvor entweder über den Konstruktor oder mit „ setDevice()“ festgelegt worden sein.

Wenn dieses Objekt durch das Schreiben in eine ` QByteArray` erstellt wurde, gibt diese Funktion eine interne Instanz von ` QBuffer` zurück, die sich im Besitz von ` QCborStreamWriter` befindet.

Siehe auch ` setDevice()`.

bool QCborStreamWriter::endArray()

Beendet das Array, das durch eine der beiden Überladungen von ` startArray()` angelegt wurde, und gibt `true` zurück, wenn die richtige Anzahl von Elementen zum Array hinzugefügt wurde. Diese Funktion muss für jeden Aufruf von ` startArray()` aufgerufen werden.

Der Rückgabewert „false“ weist auf einen Fehler in der Anwendung und einen nicht behebbaren Fehler in diesem Stream hin. In diesem Fall gibt „ QCborStreamWriter “ zudem über „ qWarning()“ eine Warnung aus.

Der Aufruf dieser Funktion, wenn der aktuelle Container kein Array ist, stellt ebenfalls einen Fehler dar, obwohl „ QCborStreamWriter “ diesen Zustand derzeit nicht erkennen kann.

Siehe auch startArray(), startArray(quint64) und endMap().

bool QCborStreamWriter::endMap()

Beendet die durch eine der beiden Überladungen von ` startMap()` gestartete Zuordnung und gibt `true` zurück, wenn die richtige Anzahl an Elementen zum Array hinzugefügt wurde. Diese Funktion muss für jede verwendete ` startMap()` aufgerufen werden.

Die Rückgabe von `false` weist auf einen Fehler in der Anwendung und einen nicht behebbaren Fehler in diesem Stream hin. In diesem Fall gibt ` QCborStreamWriter ` über ` qWarning()` zudem eine Warnung aus.

Der Aufruf dieser Funktion, wenn der aktuelle Container keine Map ist, stellt ebenfalls einen Fehler dar, obwohl „ QCborStreamWriter “ diesen Zustand derzeit nicht erkennen kann.

Siehe auch „ startMap()“, „ startMap(quint64)“ und „ endArray()“.

void QCborStreamWriter::setDevice(QIODevice *device)

Ersetzt das Gerät oder das Byte-Array, in das dieses „ QCborStreamWriter “-Objekt schreibt, durch „ device “.

Siehe auch ` device()`.

void QCborStreamWriter::startArray()

Erzeugt ein CBOR-Array mit unbestimmter Länge im CBOR-Stream. Jeder Aufruf von `startArray()` muss mit einem Aufruf von ` endArray()` gepaart werden, und das aktuelle CBOR-Element erstreckt sich bis zum Ende des Arrays.

Das durch diese Funktion erstellte Array hat keine explizite Länge. Stattdessen ergibt sich seine Länge implizit aus den darin enthaltenen Elementen. Beachten Sie jedoch, dass die Verwendung von Arrays mit unbestimmter Länge nicht mit der kanonischen CBOR-Kodierung konform ist.

Das folgende Beispiel hängt Elemente aus der als Eingabe übergebenen Liste von Zeichenketten an:

void appendList(QCborStreamWriter &writer, const QList<QString> &values)
{
    writer.startArray();
    for (const QString &s : values)
        writer.append(s);
    writer.endArray();
}

Siehe auch „ startArray“ (quint64), „ endArray “ (), „ startMap “ (), „ QCborStreamReader::isArray “ () und „ QCborStreamReader::isLengthKnown “ ().

void QCborStreamWriter::startArray(quint64 count)

Erzeugt ein CBOR-Array mit einer expliziten Länge von count Elementen im CBOR-Stream. Jeder Aufruf von `startArray` muss mit einem Aufruf von ` endArray()` gepaart werden, und das aktuelle CBOR-Element erstreckt sich bis zum Ende des Arrays.

Das durch diese Funktion erstellte Array hat eine explizite Länge, weshalb genau count Elemente zum CBOR-Stream hinzugefügt werden müssen. Das Hinzufügen von weniger oder mehr Elementen führt zu einem Fehler bei endArray() und der CBOR-Stream wird beschädigt. Arrays mit expliziter Länge sind jedoch für die kanonische CBOR-Kodierung erforderlich.

Das folgende Beispiel hängt alle Zeichenfolgen an, die in dem als Eingabe übergebenen ` QStringList ` gefunden werden:

void appendList(QCborStreamWriter &writer, const QStringList &list)
{
    writer.startArray(list.size());
    for (const QString &s : list)
        writer.append(s);
    writer.endArray();
}

Größenbeschränkungen: Der Parameter dieser Funktion ist vom Typ „quint64“, was theoretisch bis zu^2⁶⁴–1 Elemente im Array zulassen würde. Allerdings sind sowohl „ QCborStreamWriter “ als auch „ QCborStreamReader “ derzeit auf^2³²–2 Elemente auf 32-Bit-Systemen und auf^2⁶⁴–2 Elemente auf 64-Bit-Systemen beschränkt. Beachten Sie außerdem, dass „ QCborArray “ derzeit auf²²⁷ Elemente auf 32-Bit-Plattformen und auf²⁵⁹ Elemente auf 64-Bit-Plattformen begrenzt ist.

Siehe auch startArray(), endArray(), startMap(), QCborStreamReader::isArray() und QCborStreamReader::isLengthKnown().

void QCborStreamWriter::startMap()

Startet eine CBOR-Map mit unbestimmter Länge im CBOR-Stream. Jeder Aufruf von `startMap()` muss mit einem Aufruf von ` endMap()` gepaart sein, und das aktuelle CBOR-Element erstreckt sich bis zum Ende der Map.

Die durch diese Funktion erstellte Map hat keine explizite Länge. Stattdessen ergibt sich ihre Länge aus den darin enthaltenen Elementen. Beachten Sie jedoch, dass die Verwendung von Maps mit unbestimmter Länge nicht mit der kanonischen CBOR-Kodierung konform ist (die kanonische Kodierung erfordert zudem, dass Schlüssel eindeutig sind und in sortierter Reihenfolge vorliegen).

Das folgende Beispiel hängt Elemente aus der als Eingabe übergebenen Liste von int- und string-Paaren an:

void appendMap(QCborStreamWriter &writer, const QList<std::pair<int, QString>> &values)
{
    writer.startMap();
    for (const auto pair : values) {
        writer.append(pair.first);
        writer.append(pair.second);
    }
    writer.endMap();
}

Siehe auch startMap(quint64), endMap(), startArray(), QCborStreamReader::isMap() und QCborStreamReader::isLengthKnown().

void QCborStreamWriter::startMap(quint64 count)

Startet eine CBOR-Map mit einer expliziten Länge von count Elementen im CBOR-Stream. Jeder Aufruf von `startMap` muss mit einem Aufruf von ` endMap()` gepaart sein, und das aktuelle CBOR-Element erstreckt sich bis zum Ende der Map.

Die durch diese Funktion erstellte Map hat eine explizite Länge, weshalb genau count Elementpaare zum CBOR-Stream hinzugefügt werden müssen. Das Hinzufügen von weniger oder mehr Elementen führt zu einem Fehler während des Aufrufs von ` endMap()` und der CBOR-Stream wird beschädigt. Maps mit expliziter Länge sind jedoch für die kanonische CBOR-Kodierung erforderlich.

Das folgende Beispiel hängt alle Zeichenketten an, die in der als Eingabe übergebenen ` QMap ` gefunden werden:

void appendMap(QCborStreamWriter &writer, const QMap<int, QString> &map)
{
    writer.startMap(map.size());
    for (auto it = map.cbegin(), end = map.cend(); it != end; ++it) {
        writer.append(it.key());
        writer.append(it.value());
    }
    writer.endMap();
}

Größenbeschränkungen: Der Parameter dieser Funktion ist vom Typ `quint64`, was theoretisch bis zu^2⁶⁴-1 Paare in der Map zulassen würde. Allerdings sind sowohl ` QCborStreamWriter ` als auch ` QCborStreamReader ` derzeit auf^2³¹-1 Elemente auf 32-Bit-Systemen und^2⁶³-1 Elemente auf 64-Bit-Systemen beschränkt. Beachten Sie außerdem, dass „ QCborMap “ derzeit auf²²⁶ Elemente auf 32-Bit-Plattformen und auf²⁵⁸ Elemente auf 64-Bit-Plattformen begrenzt ist.

Siehe auch startMap(), endMap(), startArray(), QCborStreamReader::isMap() und QCborStreamReader::isLengthKnown().

[delete] QCborStreamWriter &QCborStreamWriter::operator=(const QCborStreamWriter &)

other Weist dieser Instanz von „ QCborStreamWriter “ den Wert „ “ zu. Diese Funktion wird gelöscht.