QCborStreamWriter Class
La clase QCborStreamWriter es un sencillo codificador CBOR que opera sobre un flujo unidireccional. Más información...
| Encabezado: | #include <QCborStreamWriter> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
- Lista de todos los miembros, incluidos los heredados
- QCborStreamWriter forma parte del soporte CBOR en Qt.
Nota: Todas las funciones de esta clase son reentrantes.
Funciones públicas
| QCborStreamWriter(QByteArray *data) | |
| QCborStreamWriter(QIODevice *device) | |
| QCborStreamWriter(const QCborStreamWriter &) | |
| ~QCborStreamWriter() | |
| void | append(QByteArrayView ba) |
| void | append(QCborKnownTags tag) |
| void | append(QCborNegativeInteger n) |
| void | append(QCborSimpleType st) |
| void | append(QCborTag tag) |
| void | append(QLatin1StringView str) |
| void | append(QStringView str) |
(since 6.10) void | append(QUtf8StringView str) |
| void | append(bool b) |
| void | append(const QByteArray &ba) |
| void | append(double d) |
| void | append(float f) |
| void | append(qfloat16 f) |
| void | append(qint64 i) |
| void | append(quint64 u) |
| void | append(std::nullptr_t) |
| void | append(const char *str, qsizetype size = -1) |
| void | appendByteString(const char *data, qsizetype len) |
| void | appendNull() |
| void | appendTextString(const char *utf8, qsizetype len) |
| void | appendUndefined() |
| QIODevice * | device() const |
| bool | endArray() |
| bool | endMap() |
| void | setDevice(QIODevice *device) |
| void | startArray() |
| void | startArray(quint64 count) |
| void | startMap() |
| void | startMap(quint64 count) |
| QCborStreamWriter & | operator=(const QCborStreamWriter &) |
Descripción detallada
Esta clase se puede utilizar para codificar rápidamente un flujo de contenido CBOR directamente en un ` QByteArray ` o en un ` QIODevice`. CBOR son las siglas de «Concise Binary Object Representation», una forma muy compacta de codificación de datos binarios compatible con JSON. Fue creado por el Grupo de Trabajo de Entornos RESTful Con restringidos (CoRE) de la IETF, que lo ha utilizado en muchos RFC nuevos. Está pensado para utilizarse junto con el protocolo CoAP.
QCborStreamWriter proporciona una API similar a StAX, parecida a la de QXmlStreamWriter. Es de bajo nivel y requiere ciertos conocimientos sobre la codificación CBOR. Para una API más sencilla, véase QCborValue y, en especial, la función de codificación QCborValue::toCbor().
El uso habitual de QCborStreamWriter consiste en crear el objeto en el destino QByteArray o QIODevice y, a continuación, llamar a una de las sobrecargas de append() con el tipo que se desea codificar. Para crear matrices y mapas, QCborStreamWriter proporciona las sobrecargas startArray() y startMap(), que deben terminarse con las funciones correspondientes endArray() y endMap().
El siguiente ejemplo codifica el equivalente a este contenido JSON:
{ "label": "journald", "autoDetect": false, "condition": "libs.journald", "output": [ "privateFeature" ] }
using namespace Qt::StringLiterals;
// ...
writer.startMap(4); // 4 elements in the map
writer.append("label"_L1);
writer.append("journald"_L1);
writer.append("autoDetect"_L1);
writer.append(false);
writer.append("condition"_L1);
writer.append("libs.journald"_L1);
writer.append("output"_L1);
writer.startArray(1);
writer.append("privateFeature"_L1);
writer.endArray();
writer.endMap();Compatibilidad con CBOR
QCborStreamWriter es compatible con todas las características de CBOR necesarias para crear flujos canónicos y estrictos. Implementa casi todas las características especificadas en el RFC 7049.
La siguiente tabla enumera las características de CBOR que admite QCborStreamWriter.
| Característica | Compatibilidad |
|---|---|
| Números sin signo | Sí (rango completo) |
| Números negativos | Sí (rango completo) |
| Cadenas de bytes | Sí |
| Cadenas de texto | Sí |
| Cadenas fragmentadas | No |
| Etiquetas | Sí (arbitrarias) |
| Valores booleanos | Sí |
| Nulo | Sí |
| Indeterminado | Sí |
| Valores simples arbitrarios | Sí |
| Número flotante de media precisión (16 bits) | Sí |
| Número flotante de precisión simple (32 bits) | Sí |
| Número real de doble precisión (64 bits) | Sí |
| Valores infinitos y NaN en coma flotante | Sí |
| Matrices y mapas de longitud determinada | Sí |
| Matrices y mapas de longitud indeterminada | Sí |
| Tipos de clave de mapa distintos de cadenas e enteros | Sí (arbitrario) |
Codificación CBOR canónica
La codificación canónica CBOR se define en la sección 3.9 del RFC 7049. La codificación canónica no es un requisito para la funcionalidad de decodificación CBOR de Qt, pero puede ser necesaria para algunos protocolos. En concreto, los protocolos que requieren la capacidad de reproducir el mismo flujo de forma idéntica pueden necesitarla.
Para que un flujo CBOR se considere «canónico», debe cumplir los siguientes requisitos:
- Los enteros deben ser lo más cortos posible. QCborStreamWriter siempre lo hace así (no se requiere ninguna acción por parte del usuario y no es posible escribir enteros excesivamente largos).
- Las longitudes de las matrices, los mapas y las cadenas deben ser lo más cortas posible. Al igual que en el caso anterior, QCborStreamWriter lo hace automáticamente.
- Los arrays, los mapas y las cadenas deben utilizar una longitud explícita. QCborStreamWriter siempre lo hace así para las cadenas; en el caso de los arrays y los mapas, asegúrate de llamar a las sobrecargas de startArray() y startMap() con una longitud explícita.
- Las claves de cada mapa deben estar ordenadas en orden ascendente. QCborStreamWriter no ofrece ayuda en este aspecto: el desarrollador debe asegurarse de ello antes de llamar a ` append()` para los pares del mapa.
- Los valores de punto flotante deben ser lo más pequeños posible. QCborStreamWriter no convierte los valores de punto flotante; corresponde al desarrollador realizar esta comprobación antes de llamar a append() (véanse los ejemplos de dichas funciones).
Modo CBOR estricto
El modo estricto se define en la sección 3.10 del RFC 7049. Al igual que con la codificación canónica mencionada anteriormente, QCborStreamWriter permite crear flujos CBOR estrictos, pero no los exige ni valida que la salida lo sea.
- Las claves de un mapa deben ser únicas. QCborStreamWriter no realiza ninguna validación de las claves del mapa.
- Es posible que se exija que las etiquetas se emparejen únicamente con los tipos correctos, de acuerdo con su especificación. QCborStreamWriter no realiza ninguna validación del uso de las etiquetas.
- Las cadenas de texto deben estar correctamente codificadas en UTF-8. QCborStreamWriter siempre escribe UTF-8 correcto para las cadenas añadidas con append(), pero no realiza ninguna validación de las cadenas añadidas con appendTextString().
Flujo CBOR no válido
También es posible utilizar incorrectamente QCborStreamWriter y generar flujos CBOR no válidos que el receptor no podrá decodificar. Las siguientes acciones generarán flujos no válidos:
- Añadir una etiqueta sin añadir el valor etiquetado correspondiente (QCborStreamWriter no genera ningún mensaje de diagnóstico).
- Añadir demasiados o muy pocos elementos a una matriz o un mapa con longitud explícita (endMap() y endArray() devolverán false y QCborStreamWriter registrará un mensaje de error con qWarning()).
{Análisis y visualización de datos CBOR}, {Convertidor de serialización}, {Guardar y cargar una partida}
Véase también QCborStreamReader, QCborValue y QXmlStreamWriter.
Documentación de las funciones miembro
[explicit] QCborStreamWriter::QCborStreamWriter(QByteArray *data)
Crea un objeto QCborStreamWriter que añadirá el flujo a ` data`. Todo el flujo se envía inmediatamente a la matriz de bytes, sin necesidad de vaciar ningún búfer.
El siguiente ejemplo escribe un número en una matriz de bytes y, a continuación, lo devuelve.
QByteArray encodedNumber(qint64 value)
{
QByteArray ba;
QCborStreamWriter writer(&ba);
writer.append(value);
return ba;
}QCborStreamWriter no asume la propiedad de ` data`.
[explicit] QCborStreamWriter::QCborStreamWriter(QIODevice *device)
Crea un objeto QCborStreamWriter que escribirá el flujo en device. El dispositivo debe estar abierto antes de realizar la primera llamada a append(). Este constructor puede utilizarse con cualquier clase que derive de QIODevice, como QFile, QProcess o QTcpSocket.
QCborStreamWriter no dispone de almacenamiento en búfer, por lo que cada llamada a ` append()` dará lugar a una o más llamadas al método ` write()` del dispositivo.
El siguiente ejemplo escribe un mapa vacío en un archivo:
QFile f("output");
QCborStreamWriter writer(&f);
writer.startMap(0);
writer.endMap();QCborStreamWriter no asume la propiedad de device.
Véase también device() y setDevice().
[delete] QCborStreamWriter::QCborStreamWriter(const QCborStreamWriter &)
Crea una instancia de ` QCborStreamWriter` mediante copia. Esta función ha sido eliminada.
[noexcept] QCborStreamWriter::~QCborStreamWriter()
Destruye este objeto ` QCborStreamWriter ` y libera los recursos asociados.
QCborStreamWriter No realiza ninguna comprobación de errores para verificar si todos los elementos necesarios se han escrito en el flujo antes de que se destruya el objeto. Es responsabilidad del programador asegurarse de que así haya sido.
void QCborStreamWriter::append(QByteArrayView ba)
void QCborStreamWriter::append(const QByteArray &ba)
Añade la matriz de bytes ba al flujo, creando un valor de cadena de bytes CBOR. QCborStreamWriter intentará escribir toda la cadena de una sola vez.
El siguiente ejemplo cargará y añadirá el contenido de un archivo al flujo:
void writeFile(QCborStreamWriter &writer, const QString &fileName)
{
QFile f(fileName);
if (f.open(QIODevice::ReadOnly))
writer.append(f.readAll());
}Como muestra el ejemplo, a diferencia de JSON, CBOR no requiere el uso de caracteres de escape para el contenido binario.
Nota: La sobrecarga que admite un QByteArrayView está disponible desde Qt 6.10.
Véanse también appendByteString(), QCborStreamReader::isByteArray() y QCborStreamReader::readByteArray().
void QCborStreamWriter::append(QCborKnownTags tag)
Añade la etiqueta CBOR « tag » al flujo, creando un valor de etiqueta CBOR. Todas las etiquetas deben ir seguidas de otro tipo al que den sentido.
En el siguiente ejemplo, añadimos al flujo una etiqueta CBOR 1 (Unix time_t) y un entero que representa la hora actual, obtenida mediante la función time():
void writeCurrentTime(QCborStreamWriter &writer)
{
writer.append(QCborKnownTags::UnixTime_t);
writer.append(qint64(time(nullptr)));
}Esta es una función sobrecargada.
Véanse también QCborStreamReader::isTag() y QCborStreamReader::toTag().
void QCborStreamWriter::append(QCborNegativeInteger n)
Añade el valor negativo de 64 bits n al flujo CBOR. QCborNegativeInteger es una enumeración de 64 bits que contiene el valor absoluto del número negativo que queremos escribir. Si n es cero, el valor escrito será equivalente a2⁶⁴ (es decir, -18 446 744 073 709 551 616).
En el siguiente ejemplo, escribimos los valores -1,-232 e INT64_MIN:
writer.append(QCborNegativeInteger(1));
writer.append(QCborNegativeInteger(Q_INT64_C(4294967296)));
writer.append(QCborNegativeInteger(-quint64(std::numeric_limits<qint64>::min())));Obsérvese cómo esta función puede utilizarse para codificar números que no caben en un entero con signo de 64 bits de un ordenador estándar, como qint64. Es decir, si n es mayor que std::numeric_limits<qint64>::max() o es 0, esto representará un número negativo menor que std::numeric_limits<qint64>::min().
Esta es una función sobrecargada.
Véanse también QCborStreamReader::isNegativeInteger() y QCborStreamReader::toNegativeInteger().
void QCborStreamWriter::append(QCborSimpleType st)
Añade el tipo simple CBOR « st » al flujo, creando un valor de tipo simple CBOR. En el siguiente ejemplo, escribimos el tipo simple para «Null», así como para el tipo 32, que Qt no admite.
writer.append(QCborSimpleType::Null);
writer.append(QCborSimpleType(32));Nota: El uso de tipos simples para los que no existe especificación puede provocar errores de validación por parte del receptor remoto. Además, los valores de tipo simple del 24 al 31 (ambos inclusive) están reservados y no deben utilizarse.
Esta es una función sobrecargada.
Véase también QCborStreamReader::isSimpleType() y QCborStreamReader::toSimpleType().
void QCborStreamWriter::append(QCborTag tag)
Añade la etiqueta CBOR « tag » al flujo, creando un valor de etiqueta CBOR. Todas las etiquetas deben ir seguidas de otro tipo al que den significado.
En el siguiente ejemplo, añadimos una etiqueta CBOR 36 (expresión regular) y el patrón de « QRegularExpression » al flujo:
void writeRxPattern(QCborStreamWriter &writer, const QRegularExpression &rx)
{
writer.append(QCborTag(36));
writer.append(rx.pattern());
}Esta es una función sobrecargada.
Véase también QCborStreamReader::isTag() y QCborStreamReader::toTag().
void QCborStreamWriter::append(QLatin1StringView str)
Añade al flujo la cadena en Latin-1 interpretada por str, creando un valor de tipo «CBOR Text String». QCborStreamWriter intentará escribir la cadena completa en un solo bloque.
El siguiente ejemplo añade un literal de cadena Latin-1 sencillo al flujo:
using namespace Qt::StringLiterals;
// ...
writer.append("Hello, World"_L1);Nota sobre el rendimiento: CBOR requiere que todas las cadenas de texto estén codificadas en UTF-8, por lo que esta función recorrerá los caracteres de la cadena para determinar si el contenido es US-ASCII o no. Si se detecta que la cadena contiene caracteres ajenos al US-ASCII, se asignará memoria y se convertirá a UTF-8. Si esta comprobación no es necesaria, utiliza en su lugar ` appendTextString()` o la sobrecarga que toma un ` QUtf8StringView`.
Esta es una función sobrecargada.
Véase también QCborStreamReader::isString() y QCborStreamReader::readString().
void QCborStreamWriter::append(QStringView str)
Añade la cadena de texto str al flujo, creando un valor de cadena de texto CBOR. El método ` QCborStreamWriter ` intentará escribir toda la cadena en un solo bloque.
El siguiente ejemplo escribe una cadena arbitraria « QString » en el flujo:
void writeString(QCborStreamWriter &writer, const QString &str)
{
writer.append(str);
}Esta es una función sobrecargada.
Véase también QCborStreamReader::isString() y QCborStreamReader::readString().
[since 6.10] void QCborStreamWriter::append(QUtf8StringView str)
Añade al flujo la cadena UTF-8 visualizada en str, creando un valor de tipo «Cadena de texto CBOR». QCborStreamWriter intentará escribir la cadena completa en un solo bloque.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.10.
Véase también appendTextString(), QCborStreamReader::isString() y QCborStreamReader::readString().
void QCborStreamWriter::append(bool b)
Añade el valor booleano « b » al flujo, creando un valor CBOR «False» o un valor CBOR «True». Esta función es equivalente a (y está implementada como):
writer.append(b ? QCborSimpleType::True : QCborSimpleType::False);Esta es una función sobrecargada.
Véase también appendNull(), appendUndefined(), QCborStreamReader::isBool() y QCborStreamReader::toBool().
void QCborStreamWriter::append(double d)
Añade el número de coma flotante d al flujo, creando un valor CBOR de coma flotante de doble precisión de 64 bits. La función ` QCborStreamWriter ` siempre añade el número tal cual, sin comprobar si el número está en forma canónica para NaN, si es infinito, si es denormalizado o si podría escribirse en un formato más corto.
El siguiente código realiza todas esas comprobaciones, excepto la relativa a los números desnormalizados, que se espera que la FPU del sistema o la emulación de coma flotante tengan en cuenta directamente.
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);
}
}Determinar si un valor de tipo «double» puede convertirse a un entero sin pérdida de precisión se deja como ejercicio para el lector.
Esta es una función sobrecargada.
Véanse también QCborStreamReader::isDouble() y QCborStreamReader::toDouble().
void QCborStreamWriter::append(float f)
Añade el número de coma flotante f al flujo, creando un valor CBOR de coma flotante de precisión simple de 32 bits. Se puede utilizar el siguiente código para convertir un double de C++ en float si no hay pérdida de precisión y añadirlo, o bien añadir el double.
void writeFloat(QCborStreamWriter &writer, double d)
{
float f = d;
if (qIsNaN(d) || d == f)
writer.append(f);
else
writer.append(d);
}Se trata de una función sobrecargada.
Véase también QCborStreamReader::isFloat() y QCborStreamReader::toFloat().
void QCborStreamWriter::append(qfloat16 f)
Añade el número de coma flotante f al flujo, creando un valor CBOR de coma flotante de media precisión de 16 bits. Se puede utilizar el siguiente código para convertir un objeto ` float ` de C++ en un ` qfloat16 ` si no hay pérdida de precisión y añadirlo, o bien añadir directamente el objeto ` float`.
void writeFloat(QCborStreamWriter &writer, float f)
{
qfloat16 f16 = qfloat16(f);
if (qIsNaN(f) || f16 == f)
writer.append(f16);
else
writer.append(f);
}Se trata de una función sobrecargada.
Véase también QCborStreamReader::isFloat16() y QCborStreamReader::toFloat16().
void QCborStreamWriter::append(qint64 i)
Añade el valor con signo de 64 bits i al flujo CBOR. Esto creará un valor CBOR de tipo «Unsigned Integer» o «NegativeInteger», en función del signo del parámetro. En el siguiente ejemplo, escribimos los valores 0, -1,232 y INT64_MAX:
writer.append(0);
writer.append(-1);
writer.append(Q_INT64_C(4294967296));
writer.append(std::numeric_limits<qint64>::max());Esta es una función sobrecargada.
Véanse también QCborStreamReader::isInteger() y QCborStreamReader::toInteger().
void QCborStreamWriter::append(quint64 u)
Añade el valor sin signo de 64 bits u al flujo CBOR, creando un valor entero sin signo CBOR. En el siguiente ejemplo, escribimos los valores 0,232 y UINT64_MAX:
writer.append(0U);
writer.append(Q_UINT64_C(4294967296));
writer.append(std::numeric_limits<quint64>::max());Esta es una función sobrecargada.
Véase también QCborStreamReader::isUnsignedInteger() y QCborStreamReader::toUnsignedInteger().
void QCborStreamWriter::append(std::nullptr_t)
Añade un valor nulo CBOR al flujo. Esta función es equivalente a (y está implementada como): El parámetro se ignora.
writer.append(QCborSimpleType::Null);Esta es una función sobrecargada.
Véase también appendNull(), append(QCborSimpleType) y QCborStreamReader::isNull().
void QCborStreamWriter::append(const char *str, qsizetype size = -1)
Añade size bytes de texto, a partir de str, al flujo, creando un valor de cadena de texto CBOR. QCborStreamWriter intentará escribir la cadena completa en un solo bloque. Si size es -1, esta función escribirá strlen(\a str) bytes.
Se espera que la cadena a la que apunta str esté correctamente codificada en UTF-8. QCborStreamWriter no comprueba que esto sea así.
Esta es una función sobrecargada.
Véase también append(QLatin1StringView), append(QStringView), QCborStreamReader::isString() y QCborStreamReader::readString().
void QCborStreamWriter::appendByteString(const char *data, qsizetype len)
Añade len bytes de datos, a partir de data, al flujo, creando un valor de cadena de bytes CBOR. QCborStreamWriter intentará escribir toda la cadena en un solo bloque.
Véase también append(), appendTextString(), QCborStreamReader::isByteArray() y QCborStreamReader::readByteArray().
void QCborStreamWriter::appendNull()
Añade un valor nulo CBOR al flujo. Esta función es equivalente a (y está implementada como):
writer.append(QCborSimpleType::Null);Véase también append(std::nullptr_t), append(QCborSimpleType) y QCborStreamReader::isNull().
void QCborStreamWriter::appendTextString(const char *utf8, qsizetype len)
Añade len bytes de texto, a partir de utf8, al flujo, creando un valor de cadena de texto CBOR. QCborStreamWriter intentará escribir toda la cadena en un solo bloque.
Se espera que la cadena a la que apunta utf8 esté correctamente codificada en UTF-8. QCborStreamWriter no comprueba que así sea.
Véase también append(QLatin1StringView), append(QStringView), QCborStreamReader::isString() y QCborStreamReader::readString().
void QCborStreamWriter::appendUndefined()
Añade un valor CBOR «Undefined» al flujo. Esta función es equivalente a (y se implementa como):
writer.append(QCborSimpleType::Undefined);Véase también append(QCborSimpleType) y QCborStreamReader::isUndefined().
QIODevice *QCborStreamWriter::device() const
Devuelve el ` QIODevice ` en el que está escribiendo este objeto ` QCborStreamWriter `. El dispositivo debe haberse configurado previamente mediante el constructor o con ` setDevice()`.
Si este objeto se ha creado escribiendo en un ` QByteArray`, esta función devolverá una instancia interna de ` QBuffer`, que es propiedad de ` QCborStreamWriter`.
Véase también ` setDevice()`.
bool QCborStreamWriter::endArray()
Finaliza la matriz iniciada mediante cualquiera de las sobrecargas de ` startArray()` y devuelve `true` si se ha añadido el número correcto de elementos a la matriz. Esta función debe llamarse cada vez que se utilice ` startArray()`.
Un valor de retorno «false» indica un error en la aplicación y un error irrecuperable en este flujo. QCborStreamWriter también escribe una advertencia mediante qWarning() si eso ocurre.
Llamar a esta función cuando el contenedor actual no es una matriz también constituye un error, aunque QCborStreamWriter no puede detectar esta condición por el momento.
Véase también startArray(), startArray(quint64) y endMap().
bool QCborStreamWriter::endMap()
Finaliza el mapa iniciado mediante cualquiera de las sobrecargas de ` startMap()` y devuelve `true` si se ha añadido el número correcto de elementos a la matriz. Esta función debe llamarse cada vez que se utilice ` startMap()`.
Un valor de retorno «false» indica un error en la aplicación y un error irrecuperable en este flujo. QCborStreamWriter también escribe una advertencia mediante qWarning() si eso ocurre.
Llamar a esta función cuando el contenedor actual no es un mapa también constituye un error, aunque QCborStreamWriter no puede detectar esta condición por el momento.
Véase también startMap(), startMap(quint64) y endArray().
void QCborStreamWriter::setDevice(QIODevice *device)
Sustituye el dispositivo o la matriz de bytes en el que está escribiendo este objeto ` QCborStreamWriter ` por ` device`.
Véase también device().
void QCborStreamWriter::startArray()
Inicia una matriz CBOR de longitud indeterminada en el flujo CBOR. Cada llamada a `startArray()` debe ir acompañada de una llamada a ` endArray()`, y el elemento CBOR actual se extiende hasta el final de la matriz.
La matriz creada por esta función no tiene una longitud explícita. En su lugar, su longitud viene determinada por los elementos que contiene. Sin embargo, hay que tener en cuenta que el uso de matrices de longitud indeterminada no cumple con la codificación CBOR canónica.
El siguiente ejemplo añade elementos de la lista de cadenas pasadas como entrada:
void appendList(QCborStreamWriter &writer, const QList<QString> &values)
{
writer.startArray();
for (const QString &s : values)
writer.append(s);
writer.endArray();
}Véase también « startArray» (quint64), « endArray()», « startMap()», « QCborStreamReader::isArray()» y « QCborStreamReader::isLengthKnown()».
void QCborStreamWriter::startArray(quint64 count)
Inicia una matriz CBOR con una longitud explícita de count elementos en el flujo CBOR. Cada llamada a `startArray` debe ir acompañada de una llamada a ` endArray()` y el elemento CBOR actual se extiende hasta el final de la matriz.
El array creado por esta función tiene una longitud explícita y, por lo tanto, deben añadirse exactamente count elementos al flujo CBOR. Añadir menos o más elementos provocará un error durante la llamada a endArray() y el flujo CBOR quedará dañado. No obstante, los arrays de longitud explícita son obligatorios según la codificación canónica de CBOR.
El siguiente ejemplo añade todas las cadenas que se encuentran en el ` QStringList ` pasado como entrada:
void appendList(QCborStreamWriter &writer, const QStringList &list)
{
writer.startArray(list.size());
for (const QString &s : list)
writer.append(s);
writer.endArray();
}Limitaciones de tamaño: El parámetro de esta función es de tipo quint64, lo que en principio permitiría incluir hasta264-1 elementos en la matriz. Sin embargo, tanto QCborStreamWriter como QCborStreamReader están limitados actualmente a232-2 elementos en sistemas de 32 bits y a264-2 elementos en los de 64 bits. Ten en cuenta también que QCborArray está limitado actualmente a227 elementos en plataformas de 32 bits y a259 elementos en las de 64 bits.
Se trata de una función sobrecargada.
Véase también startArray(), endArray(), startMap(), QCborStreamReader::isArray() y QCborStreamReader::isLengthKnown().
void QCborStreamWriter::startMap()
Inicia un mapa CBOR de longitud indeterminada en el flujo CBOR. Cada llamada a `startMap()` debe ir acompañada de una llamada a ` endMap()`, y el elemento CBOR actual se extiende hasta el final del mapa.
El mapa creado por esta función no tiene una longitud explícita. En su lugar, su longitud viene determinada por los elementos que contiene. Sin embargo, hay que tener en cuenta que el uso de mapas de longitud indeterminada no cumple con la codificación canónica de CBOR (la codificación canónica también requiere que las claves sean únicas y estén ordenadas).
El siguiente ejemplo añade elementos de la lista de pares de enteros y cadenas pasada como entrada:
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();
}Véase también startMap(quint64), endMap(), startArray(), QCborStreamReader::isMap() y QCborStreamReader::isLengthKnown().
void QCborStreamWriter::startMap(quint64 count)
Inicia un mapa CBOR con una longitud explícita de count elementos en el flujo CBOR. Cada llamada a `startMap` debe ir acompañada de una llamada a ` endMap()` y el elemento CBOR actual se extiende hasta el final del mapa.
El mapa creado por esta función tiene una longitud explícita y, por lo tanto, deben añadirse exactamente count pares de elementos al flujo CBOR. Si se añaden menos o más elementos, se producirá un error durante la llamada a endMap() y el flujo CBOR quedará dañado. No obstante, los mapas de longitud explícita son obligatorios según la codificación CBOR canónica.
El siguiente ejemplo añade todas las cadenas que se encuentran en el ` QMap ` pasado como entrada:
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();
}Limitaciones de tamaño: El parámetro de esta función es de tipo quint64, lo que aparentemente permitiría hasta2⁶⁴-1 pares en el mapa. Sin embargo, tanto QCborStreamWriter como QCborStreamReader están limitados actualmente a2³¹-1 elementos en sistemas de 32 bits y a2⁶³-1 elementos en los de 64 bits. Ten en cuenta también que QCborMap está limitada actualmente a226 elementos en plataformas de 32 bits y a258 en las de 64 bits.
Se trata de una función sobrecargada.
Véanse también startMap(), endMap(), startArray(), QCborStreamReader::isMap() y QCborStreamReader::isLengthKnown().
[delete] QCborStreamWriter &QCborStreamWriter::operator=(const QCborStreamWriter &)
Asigna por copia other a esta instancia de QCborStreamWriter. Esta función se ha eliminado.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.