QCborMap Class

See also https://, https://, https://, https://

A synonym for https://

A synonym for https://.

The key type for this map. Since https:// keys can be any CBOR type, this is a https://.

The type that is mapped to (the value), that is, a https://.

The type that https:// uses for sizes.

The value that is stored in this container: a pair of QCborValues

QCborMap::const_iterator QCborMap::find(qint64 key) const

Returns a map iterator to the key-value pair whose key is key, if the map contains such a pair. If it doesn't, this function returns https://().

CBOR recommends using integer keys, since they occupy less space and are simpler to encode and decode.

If the map contains more than one key equal to key, it is undefined which one this function will find. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(https://), value(const https:// &), value(const https:// &)

See Also▲

QCborMap::const_iterator QCborMap::find(QLatin1String key) const

This is an overloaded function.

Returns a map iterator to the key-value pair whose key is key, if the map contains such a pair. If it doesn't, this function returns https://().

If the map contains more than one key equal to key, it is undefined which one this function will find. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(qint64), value(const https:// &), value(const https:// &)

See Also▲

QCborMap::const_iterator QCborMap::find(const QString &key) const

This is an overloaded function.

Returns a map iterator to the key-value pair whose key is key, if the map contains such a pair. If it doesn't, this function returns https://().

If the map contains more than one key equal to key, it is undefined which one this function will find. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(qint64), value(https://), value(const https:// &)

See Also▲

QCborMap::const_iterator QCborMap::find(const QCborValue &key) const

This is an overloaded function.

Returns a map iterator to the key-value pair whose key is key, if the map contains such a pair. If it doesn't, this function returns https://().

If the map contains more than one key equal to key, it is undefined which one this function will find. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(qint64), value(https://), value(const https:// &)

See Also▲

QCborValue QCborMap::extract(QCborMap::iterator it)

Extracts a value from the map at the position indicated by iterator it and returns the value so extracted.

See Also▲

Constructs an empty CBOR Map object.

See Also▲

Constructs a https:// with items from a brace-initialization list found in args, as in the following example:

QCborMap map = {
    {0, "Hello"},
    {1, "World"},
    {"foo", nullptr},
    {"bar", QCborArray{0, 1, 2, 3, 4}}
};

Creates a https:// object that is a copy of other.

Destroys this https:// object and frees any associated resources it owns.

Returns a map iterator pointing to the first key-value pair of this map. If this map is empty, the returned iterator will be the same as https://().

See Also▲

Returns a map iterator pointing to the first key-value pair of this map. If this map is empty, the returned iterator will be the same as https://().

See Also▲

Returns a map iterator pointing to the first key-value pair of this map. If this map is empty, the returned iterator will be the same as https://().

See Also▲

Returns a map iterator representing an element just past the last element in the map.

See Also▲

Empties this map.

See Also▲

Compares this map and other, comparing each element in sequence, and returns an integer that indicates whether this map should be sorted prior to (if the result is negative) or after other (if the result is positive). If this function returns 0, the two maps are equal and contain the same elements.

Note that CBOR maps are unordered, which means that two maps containing the very same pairs but in different order will still compare differently. To avoid this, it is recommended to insert elements into the map in a predictable order, such as by ascending key value. In fact, maps with keys in sorted order are required for Canonical CBOR representation.

For more information on CBOR sorting order, see https://().

See Also▲

Returns a map iterator pointing to the first key-value pair of this map. If this map is empty, the returned iterator will be the same as https://().

See Also▲

Returns a map iterator representing an element just past the last element in the map.

See Also▲

Returns a map iterator to the key-value pair whose key is key, if the map contains such a pair. If it doesn't, this function returns https://().

CBOR recommends using integer keys, since they occupy less space and are simpler to encode and decode.

If the map contains more than one key equal to key, it is undefined which one this function will find. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(https://), value(const https:// &), value(const https:// &)

See Also▲

This is an overloaded function.

Returns a map iterator to the key-value pair whose key is key, if the map contains such a pair. If it doesn't, this function returns https://().

If the map contains more than one key equal to key, it is undefined which one this function will find. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(qint64), value(const https:// &), value(const https:// &)

See Also▲

This is an overloaded function.

Returns a map iterator to the key-value pair whose key is key, if the map contains such a pair. If it doesn't, this function returns https://().

If the map contains more than one key equal to key, it is undefined which one this function will find. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(qint64), value(https://), value(const https:// &)

See Also▲

This is an overloaded function.

Returns a map iterator to the key-value pair whose key is key, if the map contains such a pair. If it doesn't, this function returns https://().

If the map contains more than one key equal to key, it is undefined which one this function will find. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

See Also▲

Returns true if this map contains a key-value pair identified by key key. CBOR recommends using integer keys, since they occupy less space and are simpler to encode and decode.

See Also▲

This is an overloaded function.

Returns true if this map contains a key-value pair identified by key key.

See Also▲

This is an overloaded function.

Returns true if this map contains a key-value pair identified by key key.

See Also▲

Returns true if this map contains a key-value pair identified by key key.

See Also▲

Synonym for https://(). This function is provided for compatibility with generic code that uses the Standard Library API.

Returns true if this map is empty (https://() == 0).

See Also▲

Returns a map iterator representing an element just past the last element in the map.

See Also▲

Returns a map iterator representing an element just past the last element in the map.

See Also▲

Removes the key-value pair pointed to by the map iterator it and returns a pointer to the next element, after removal.

See Also▲

This is an overloaded function.

Removes the key-value pair pointed to by the map iterator it and returns a pointer to the next element, after removal.

See Also▲

Converts all JSON items found in the obj object to CBOR using QCborValue::fromJson(), and returns the map composed of those elements.

This conversion is lossless, as the CBOR type system is a superset of JSON's. Moreover, the map returned by this function can be converted back to the original obj by using https://().

See Also▲

Converts all the items in hash to CBOR using https://() and returns the map composed of those elements.

Conversion from https:// is not completely lossless. Please see the documentation in https://() for more information.

See Also▲

Converts all the items in map to CBOR using https://() and returns the map composed of those elements.

Conversion from https:// is not completely lossless. Please see the documentation in https://() for more information.

See Also▲

This is an overloaded function.

Inserts the key key and value value into this map and returns a map iterator pointing to the newly inserted pair.

If the map already had a key equal to key, its value will be overwritten by value.

See Also▲

This is an overloaded function.

Inserts the key key and value value into this map and returns a map iterator pointing to the newly inserted pair.

If the map already had a key equal to key, its value will be overwritten by value.

See Also▲

This is an overloaded function.

Inserts the key key and value value into this map and returns a map iterator pointing to the newly inserted pair.

If the map already had a key equal to key, its value will be overwritten by value.

See Also▲

This is an overloaded function.

Inserts the key key and value value into this map and returns a map iterator pointing to the newly inserted pair.

If the map already had a key equal to key, its value will be overwritten by value.

See Also▲

This is an overloaded function.

Inserts the key-value pair in v into this map and returns a map iterator pointing to the newly inserted pair.

If the map already had a key equal to v.first, its value will be overwritten by v.second.

See Also▲

Returns true if this map is empty (that is, https://() is 0).

See Also▲

Returns a list of all keys in this map.

See Also▲

Removes the key key and the corresponding value from the map, if it is found. If the map contains no such key, this function does nothing.

If the map contains more than one key equal to key, it is undefined which one this function will remove. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

remove(https://), remove(const https:// &), remove(const https:// &)

See Also▲

This is an overloaded function.

Removes the key key and the corresponding value from the map, if it is found. If the map contains no such key, this function does nothing.

If the map contains more than one key equal to key, it is undefined which one this function will remove. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

remove(qint64), remove(const https:// &), remove(const https:// &)

See Also▲

This is an overloaded function.

Removes the key key and the corresponding value from the map, if it is found. If the map contains no such key, this function does nothing.

If the map contains more than one key equal to key, it is undefined which one this function will remove. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

remove(qint64), remove(https://), remove(const https:// &)

See Also▲

Removes the key key and the corresponding value from the map, if it is found. If the map contains no such key, this function does nothing.

If the map contains more than one key equal to key, it is undefined which one this function will remove. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

remove(qint64), remove(https://), remove(const https:// &)

See Also▲

Returns the number of elements in this map.

See Also▲

Swaps the contents of this map and other.

Removes the key key and the corresponding value from the map and returns the value, if it is found. If the map contains no such key, this function does nothing.

If the map contains more than one key equal to key, it is undefined which one this function will remove. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

See Also▲

Removes the key key and the corresponding value from the map and returns the value, if it is found. If the map contains no such key, this function does nothing.

If the map contains more than one key equal to key, it is undefined which one this function will remove. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

See Also▲

Removes the key key and the corresponding value from the map and returns the value, if it is found. If the map contains no such key, this function does nothing.

If the map contains more than one key equal to key, it is undefined which one this function will remove. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

See Also▲

Removes the key key and the corresponding value from the map and returns the value, if it is found. If the map contains no such key, this function does nothing.

If the map contains more than one key equal to key, it is undefined which one this function will remove. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

See Also▲

Explicitly constructs a https:// object that represents this map. This function is usually not necessary since https:// has a constructor for https://, so the conversion is implicit.

Converting https:// to https:// allows it to be used in any context where QCborValues can be used, including as keys and mapped types in https://, as well as https://().

See Also▲

Recursively converts every https:// value in this map to JSON using https://() and creates a string key for all keys that aren't strings, then returns the corresponding https:// composed of those associations.

Please note that CBOR contains a richer and wider type set than JSON, so some information may be lost in this conversion. For more details on what conversions are applied, see https://().

Map key conversion to string▲

Notes▲

See Also▲

Converts the CBOR values to https:// using https://() and "stringifies" all the CBOR keys in this map, returning the https:// that results from that association list.

QVariantMaps have string keys, unlike CBOR, so the conversion of a https:// to https:// will imply a step of "stringification" of the key values. See https://() for details.

In addition, the conversion to https:// is not completely lossless. Please see the documentation in https://() for more information.

See Also▲

Converts the CBOR values to https:// using https://() and "stringifies" all the CBOR keys in this map, returning the https:// that results from that association list.

QVariantMaps have string keys, unlike CBOR, so the conversion of a https:// to https:// will imply a step of "stringification" of the key values. See https://() for details.

In addition, the conversion to https:// is not completely lossless. Please see the documentation in https://() for more information.

See Also▲

Returns the https:// element in this map that corresponds to key key, if there is one. CBOR recommends using integer keys, since they occupy less space and are simpler to encode and decode.

If the map does not contain key key, this function returns a https:// containing an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one the return from function will reference. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(https://), value(const https:// &), value(const https:// &)

See Also▲

This is an overloaded function.

Returns the https:// element in this map that corresponds to key key, if there is one.

If the map does not contain key key, this function returns a https:// containing an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one this function will return. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(qint64), value(const https:// &), value(const https:// &)

See Also▲

This is an overloaded function.

Returns the https:// element in this map that corresponds to key key, if there is one.

If the map does not contain key key, this function returns a https:// containing an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one this function will return. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(qint64), value(https://), value(const https:// &)

See Also▲

Returns the https:// element in this map that corresponds to key key, if there is one.

If the map does not contain key key, this function returns a https:// containing an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one this function will return. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

value(qint64), value(https://), value(const https:// &)

See Also▲

Compares this map and other, comparing each element in sequence, and returns true if the two maps contains any different elements or elements in different orders, false otherwise.

Note that CBOR maps are unordered, which means that two maps containing the very same pairs but in different order will still compare differently. To avoid this, it is recommended to insert elements into the map in a predictable order, such as by ascending key value. In fact, maps with keys in sorted order are required for Canonical CBOR representation.

For more information on CBOR equality in Qt, see, https://().

See Also▲

Compares this map and other, comparing each element in sequence, and returns true if this map should be sorted before other, false otherwise.

Note that CBOR maps are unordered, which means that two maps containing the very same pairs but in different order will still compare differently. To avoid this, it is recommended to insert elements into the map in a predictable order, such as by ascending key value. In fact, maps with keys in sorted order are required for Canonical CBOR representation.

For more information on CBOR sorting order, see https://().

See Also▲

Replaces the contents of this object with a copy of other, then returns a reference to this object.

Compares this map and other, comparing each element in sequence, and returns true if the two maps contains the same elements in the same order, false otherwise.

Note that CBOR maps are unordered, which means that two maps containing the very same pairs but in different order will still compare differently. To avoid this, it is recommended to insert elements into the map in a predictable order, such as by ascending key value. In fact, maps with keys in sorted order are required for Canonical CBOR representation.

For more information on CBOR equality in Qt, see, https://().

See Also▲

Returns the https:// element in this map that corresponds to key key, if there is one. CBOR recommends using integer keys, since they occupy less space and are simpler to encode and decode.

If the map does not contain key key, this function returns a https:// containing an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one this function will return. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

operator[](https://), operator[](const https:// &), operator[](const QCborOperator[] &)

See Also▲

This is an overloaded function.

Returns the https:// element in this map that corresponds to key key, if there is one.

If the map does not contain key key, this function returns a https:// containing an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one this function will return. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

operator[](qint64), operator[](const https:// &), operator[](const QCborOperator[] &)

See Also▲

This is an overloaded function.

Returns the https:// element in this map that corresponds to key key, if there is one.

If the map does not contain key key, this function returns a https:// containing an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one this function will return. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

operator[](qint64), operator[](https://), operator[](const QCborOperator[] &)

See Also▲

Returns the https:// element in this map that corresponds to key key, if there is one.

If the map does not contain key key, this function returns a https:// containing an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one this function will return. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

operator[](qint64), operator[](https://), operator[](const QCborOperator[] &)

See Also▲

Returns a QCborValueRef to the value in this map that corresponds to key key. CBOR recommends using integer keys, since they occupy less space and are simpler to encode and decode.

QCborValueRef has the exact same API as https://, with one important difference: if you assign new values to it, this map will be updated with that new value.

If the map did not have a key equal to key, one is inserted and this function returns a reference to the new value, which will be a https:// with an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one the return will reference. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

See Also▲

This is an overloaded function.

Returns a QCborValueRef to the value in this map that corresponds to key key.

QCborValueRef has the exact same API as https://, with one important difference: if you assign new values to it, this map will be updated with that new value.

If the map did not have a key equal to key, one is inserted and this function returns a reference to the new value, which will be a https:// with an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one the return will reference. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

See Also▲

This is an overloaded function.

Returns a QCborValueRef to the value in this map that corresponds to key key.

QCborValueRef has the exact same API as https://, with one important difference: if you assign new values to it, this map will be updated with that new value.

If the map did not have a key equal to key, one is inserted and this function returns a reference to the new value, which will be a https:// with an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one the return will reference. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

See Also▲

This is an overloaded function.

Returns a QCborValueRef to the value in this map that corresponds to key key.

QCborValueRef has the exact same API as https://, with one important difference: if you assign new values to it, this map will be updated with that new value.

If the map did not have a key equal to key, one is inserted and this function returns a reference to the new value, which will be a https:// with an undefined value. For that reason, it is not possible with this function to tell apart the situation where the key was not present from the situation where the key was mapped to an undefined value.

If the map contains more than one key equal to key, it is undefined which one the return will reference. https:// does not allow inserting duplicate keys, but it is possible to create such a map by decoding a CBOR stream with them. They are usually not permitted and having duplicate keys is usually an indication of a problem in the sender.

See Also▲