#include "qcbor/qcbor_common.h"
#include "qcbor/qcbor_private.h"
#include "qcbor/qcbor_main_encode.h"
#include <stdbool.h>
#include "qcbor/qcbor_tag_encode.h"

Macros
#define	QCBOR_HEAD_BUFFER_SIZE (sizeof(uint64_t) + 2)

Functions
void	QCBOREncode_AddInt64 (QCBOREncodeContext *pCtx, int64_t nNum)
	Add a signed 64-bit integer to the encoded output.

static void	QCBOREncode_AddInt64ToMapSZ (QCBOREncodeContext pCtx, const char szLabel, int64_t nNum)

static void	QCBOREncode_AddInt64ToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, int64_t nNum)

static void	QCBOREncode_AddUInt64 (QCBOREncodeContext *pCtx, uint64_t uNum)
	Add an unsigned 64-bit integer to the encoded output.

static void	QCBOREncode_AddUInt64ToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint64_t uNum)

static void	QCBOREncode_AddUInt64ToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint64_t uNum)

static void	QCBOREncode_AddNegativeUInt64 (QCBOREncodeContext *pCtx, uint64_t uNum)
	Add a negative 64-bit integer to encoded output.

static void	QCBOREncode_AddNegativeUInt64ToMap (QCBOREncodeContext pCtx, const char szLabel, uint64_t uNum)

static void	QCBOREncode_AddNegativeUInt64ToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint64_t uNum)

static void	QCBOREncode_AddDouble (QCBOREncodeContext *pCtx, double dNum)
	Add a double-precision floating-point number to the encoded output.

static void	QCBOREncode_AddDoubleToMapSZ (QCBOREncodeContext pCtx, const char szLabel, double dNum)

static void	QCBOREncode_AddDoubleToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, double dNum)

static void	QCBOREncode_AddFloat (QCBOREncodeContext *pCtx, float fNum)
	Add a single-precision floating-point number to the encoded output.

static void	QCBOREncode_AddFloatToMapSZ (QCBOREncodeContext pCtx, const char szLabel, float fNum)

static void	QCBOREncode_AddFloatToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, float dNum)

static void	QCBOREncode_AddDoubleNoPreferred (QCBOREncodeContext *pCtx, double dNum)
	Add a double-precision floating-point number without preferred encoding.

static void	QCBOREncode_AddDoubleNoPreferredToMapSZ (QCBOREncodeContext pCtx, const char szLabel, double dNum)

static void	QCBOREncode_AddDoubleNoPreferredToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, double dNum)

static void	QCBOREncode_AddFloatNoPreferred (QCBOREncodeContext *pCtx, float fNum)
	Add a single-precision floating-point number without preferred encoding.

static void	QCBOREncode_AddFloatNoPreferredToMapSZ (QCBOREncodeContext pCtx, const char szLabel, float fNum)

static void	QCBOREncode_AddFloatNoPreferredToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, float fNum)

static void	QCBOREncode_AddBytes (QCBOREncodeContext *pCtx, UsefulBufC Bytes)
	Add a byte string to the encoded output.

static void	QCBOREncode_AddBytesToMapSZ (QCBOREncodeContext pCtx, const char szLabel, UsefulBufC Bytes)

static void	QCBOREncode_AddBytesToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Bytes)

void	QCBOREncode_OpenBytes (QCBOREncodeContext pCtx, UsefulBuf pPlace)
	Set up to write a byte string value directly to encoded output.

static void	QCBOREncode_OpenBytesInMapSZ (QCBOREncodeContext pCtx, const char szLabel, UsefulBuf *pPlace)

static void	QCBOREncode_OpenBytesInMapN (QCBOREncodeContext pCtx, int64_t nLabel, UsefulBuf pPlace)

void	QCBOREncode_CloseBytes (QCBOREncodeContext *pCtx, size_t uAmount)
	Close out a byte string written directly to encoded output.

static void	QCBOREncode_AddTBigNumber (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, bool bNegative, UsefulBufC BigNumber)
	Add a big number to encoded output using preferred serialization.

static void	QCBOREncode_AddTBigNumberToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, bool bNegative, UsefulBufC BigNumber)

static void	QCBOREncode_AddTBigNumberToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, bool bNegative, UsefulBufC BigNumber)

static void	QCBOREncode_AddTBigNumberNoPreferred (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, bool bNegative, UsefulBufC BigNumber)
	Add a big number to encoded output without preferred serialization.

static void	QCBOREncode_AddTBigNumberNoPreferredToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, bool bNegative, UsefulBufC BigNumber)

static void	QCBOREncode_AddTBigNumberNoPreferredToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, bool bNegative, UsefulBufC BigNumber)

static void	QCBOREncode_AddTBigNumberRaw (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, bool bNegative, UsefulBufC BigNumber)
	Add a big number to encoded output with no processing.

static void	QCBOREncode_AddTBigNumberRawToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, bool bNegative, UsefulBufC BigNumber)

static void	QCBOREncode_AddTBigNumberRawToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, bool bNegative, UsefulBufC BigNumber)

static void	QCBOREncode_AddTDecimalFraction (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, int64_t nMantissa, int64_t nBase10Exponent)
	Add a decimal fraction.

static void	QCBOREncode_AddTDecimalFractionToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, int64_t nMantissa, int64_t nBase10Exponent)

static void	QCBOREncode_AddTDecimalFractionToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, int64_t nMantissa, int64_t nBase10Exponent)

static void	QCBOREncode_AddTDecimalFractionBigMantissa (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)
	Add a decimal fraction with a big number mantissa..

static void	QCBOREncode_AddTDecimalFractionBigMantissaToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)

static void	QCBOREncode_AddTDecimalFractionBigMantissaToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)

static void	QCBOREncode_AddTDecimalFractionBigMantissaRaw (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)
	Add a decimal fraction with a raw big number mantissa.

static void	QCBOREncode_AddTDecimalFractionBigMantissaRawToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)

static void	QCBOREncode_AddTDecimalFractionBigMantissaRawToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)

static void	QCBOREncode_AddTBigFloat (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, int64_t nMantissa, int64_t nBase2Exponent)
	Add a big floating-point number to the encoded output.

static void	QCBOREncode_AddTBigFloatToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, int64_t nMantissa, int64_t nBase2Exponent)

static void	QCBOREncode_AddTBigFloatToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, int64_t nMantissa, int64_t nBase2Exponent)

static void	QCBOREncode_AddTBigFloatBigMantissa (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)
	Add a big floating-point number with a big number mantissa.

static void	QCBOREncode_AddTBigFloatBigMantissaToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)

static void	QCBOREncode_AddTBigFloatBigMantissaToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)

static void	QCBOREncode_AddTBigFloatBigMantissaRaw (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)
	Add a big floating-point number with a big number mantissa.

static void	QCBOREncode_AddTBigFloatBigMantissaRawToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)

static void	QCBOREncode_AddTBigFloatBigMantissaRawToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)

static void	QCBOREncode_AddInt64ToMap (QCBOREncodeContext pCtx, const char szLabel, int64_t nNum)

static void	QCBOREncode_AddUInt64ToMap (QCBOREncodeContext pCtx, const char szLabel, uint64_t uNum)

static void	QCBOREncode_AddDoubleToMap (QCBOREncodeContext pCtx, const char szLabel, double dNum)

static void	QCBOREncode_AddFloatToMap (QCBOREncodeContext pCtx, const char szLabel, float fNum)

static void	QCBOREncode_AddDoubleNoPreferredToMap (QCBOREncodeContext pCtx, const char szLabel, double dNum)

static void	QCBOREncode_AddFloatNoPreferredToMap (QCBOREncodeContext pCtx, const char szLabel, float fNum)

static void	QCBOREncode_AddTPositiveBignum (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC BigNumber)

static void	QCBOREncode_AddTPositiveBignumToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, UsefulBufC BigNumber)

static void	QCBOREncode_AddTPositiveBignumToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, UsefulBufC BigNumber)

static void	QCBOREncode_AddPositiveBignum (QCBOREncodeContext *pCtx, UsefulBufC BigNumber)

static void	QCBOREncode_AddPositiveBignumToMap (QCBOREncodeContext pCtx, const char szLabel, UsefulBufC BigNumber)

static void	QCBOREncode_AddPositiveBignumToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC BigNumber)

static void	QCBOREncode_AddTNegativeBignum (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC BigNumber)

static void	QCBOREncode_AddTNegativeBignumToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, UsefulBufC BigNumber)

static void	QCBOREncode_AddTNegativeBignumToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, UsefulBufC BigNumber)

static void	QCBOREncode_AddNegativeBignum (QCBOREncodeContext *pCtx, UsefulBufC BigNumber)

static void	QCBOREncode_AddNegativeBignumToMap (QCBOREncodeContext pCtx, const char szLabel, UsefulBufC BigNumber)

static void	QCBOREncode_AddNegativeBignumToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC BigNumber)

static void	QCBOREncode_AddDecimalFraction (QCBOREncodeContext *pCtx, int64_t nMantissa, int64_t nBase10Exponent)

static void	QCBOREncode_AddDecimalFractionToMap (QCBOREncodeContext pCtx, const char szLabel, int64_t nMantissa, int64_t nBase10Exponent)

static void	QCBOREncode_AddDecimalFractionToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, int64_t nMantissa, int64_t nBase10Exponent)

static void	QCBOREncode_AddTDecimalFractionBigNum (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)

static void	QCBOREncode_AddTDecimalFractionBigNumToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)

static void	QCBOREncode_AddTDecimalFractionBigNumToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)

static void	QCBOREncode_AddDecimalFractionBigNum (QCBOREncodeContext *pCtx, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)

static void	QCBOREncode_AddDecimalFractionBigNumToMapSZ (QCBOREncodeContext pCtx, const char szLabel, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)

static void	QCBOREncode_AddDecimalFractionBigNumToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)

static void	QCBOREncode_AddBigFloat (QCBOREncodeContext *pCtx, int64_t nMantissa, int64_t nBase2Exponent)

static void	QCBOREncode_AddBigFloatToMap (QCBOREncodeContext pCtx, const char szLabel, int64_t nMantissa, int64_t nBase2Exponent)

static void	QCBOREncode_AddBigFloatToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, int64_t nMantissa, int64_t nBase2Exponent)

static void	QCBOREncode_AddTBigFloatBigNum (QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)

static void	QCBOREncode_AddTBigFloatBigNumToMapSZ (QCBOREncodeContext pCtx, const char szLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)

static void	QCBOREncode_AddTBigFloatBigNumToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)

static void	QCBOREncode_AddBigFloatBigNum (QCBOREncodeContext *pCtx, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)

static void	QCBOREncode_AddBigFloatBigNumToMap (QCBOREncodeContext pCtx, const char szLabel, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)

static void	QCBOREncode_AddBigFloatBigNumToMapN (QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)

Detailed Description

This file contains functions for encoding numbers.

Floating-Point

By default QCBOR fully supports IEEE 754 floating-point:

Encode/decode of double, single and half-precision
CBOR preferred serialization of floating-point
Floating-point epoch dates

For the most part, the type double is used in the interface for floating-point values. In the default configuration, all decoded floating-point values are returned as a double.

With CBOR preferred serialization, the encoder outputs the smallest representation of the double or float that preserves precision. Zero, NaN and infinity are always output as a half-precision, each taking just 2 bytes. This reduces the number of bytes needed to encode double and single-precision, especially if zero, NaN and infinity are frequently used.

To avoid use of preferred serialization in the standard configuration when encoding, use QCBOREncode_AddDoubleNoPreferred() or QCBOREncode_AddFloatNoPreferred().

This implementation of preferred floating-point serialization and half-precision does not depend on the CPU having floating-point HW or the compiler bringing in a (sometimes large) library to compensate for lack of CPU support. This implementation uses shifts and masks rather than floating-point functions.

To reduce overall object code by about 900 bytes, define QCBOR_DISABLE_PREFERRED_FLOAT. This will eliminate all support for preferred serialization and half-precision. An error will be returned when attempting to decode half-precision. A float will always be encoded and decoded as 32-bits and a double will always be encoded and decoded as 64 bits.

Note that even if QCBOR_DISABLE_PREFERRED_FLOAT is not defined all the float-point encoding object code can be avoided by never calling any functions that encode double or float. Just not calling floating-point functions will reduce object code by about 500 bytes.

On CPUs that have no floating-point hardware, QCBOR_DISABLE_FLOAT_HW_USE should be defined in most cases. If it is not, then the compiler will bring in possibly large software libraries to compensate. Defining QCBOR_DISABLE_FLOAT_HW_USE reduces object code size on CPUs with floating-point hardware by a tiny amount and eliminates the need for <math.h>

When QCBOR_DISABLE_FLOAT_HW_USE is defined, trying to decoding floating-point dates will give error QCBOR_ERR_FLOAT_DATE_DISABLED and decoded single-precision numbers will be returned as QCBOR_TYPE_FLOAT instead of converting them to double as usual.

If both QCBOR_DISABLE_FLOAT_HW_USE and QCBOR_DISABLE_PREFERRED_FLOAT are defined, then the only thing QCBOR can do is encode/decode a C float type as 32-bits and a C double type as 64-bits. Floating-point epoch dates will be unsupported.

If USEFULBUF_DISABLE_ALL_FLOAT is defined, then floating point support is completely disabled. Decoding functions return QCBOR_ERR_ALL_FLOAT_DISABLED if a floating point value is encountered during decoding. Functions that are encoding floating point values are not available.

Macro Definition Documentation

◆ QCBOR_HEAD_BUFFER_SIZE

#define QCBOR_HEAD_BUFFER_SIZE (sizeof(uint64_t) + 2)

The size of the buffer to be passed to QCBOREncode_EncodeHead(). It is one byte larger than sizeof(uint64_t) + 1, the actual maximum size of the head of a CBOR data item because QCBOREncode_EncodeHead() needs one extra byte to work.

Function Documentation

◆ QCBOREncode_AddBigFloat()

static void QCBOREncode_AddBigFloat	(	QCBOREncodeContext *	pCtx,
		int64_t	nMantissa,
		int64_t	nBase2Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigFloat() instead.

◆ QCBOREncode_AddBigFloatBigNum()

static void QCBOREncode_AddBigFloatBigNum	(	QCBOREncodeContext *	pCtx,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigFloatBigMantissaRaw() instead.

◆ QCBOREncode_AddBigFloatBigNumToMap()

static void QCBOREncode_AddBigFloatBigNumToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigFloatBigMantissaRawToMapSZ() instead.

◆ QCBOREncode_AddBigFloatBigNumToMapN()

static void QCBOREncode_AddBigFloatBigNumToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigFloatBigMantissaRawToMapN() instead.

◆ QCBOREncode_AddBigFloatToMap()

static void QCBOREncode_AddBigFloatToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		int64_t	nMantissa,
		int64_t	nBase2Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigFloatToMapSZ() instead.

◆ QCBOREncode_AddBigFloatToMapN()

static void QCBOREncode_AddBigFloatToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		int64_t	nMantissa,
		int64_t	nBase2Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigFloatToMapN() instead.

◆ QCBOREncode_AddBytes()

static void QCBOREncode_AddBytes	(	QCBOREncodeContext *	pCtx,
		UsefulBufC	Bytes )

static

Add a byte string to the encoded output.

Parameters

[in]	pCtx	The encoding context to add the bytes to.
[in]	Bytes	Pointer and length of the input data.

Simply adds the bytes to the encoded output as CBOR major type 2.

If called with Bytes.len equal to 0, an empty string will be added. When Bytes.len is 0, Bytes.ptr may be NULL.

Error handling is the same as QCBOREncode_AddInt64().

◆ QCBOREncode_AddBytesToMapN()

static void QCBOREncode_AddBytesToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		UsefulBufC	Bytes )

static

See QCBOREncode_AddBytes().

◆ QCBOREncode_AddBytesToMapSZ()

static void QCBOREncode_AddBytesToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		UsefulBufC	Bytes )

static

See QCBOREncode_AddBytes().

◆ QCBOREncode_AddDecimalFraction()

static void QCBOREncode_AddDecimalFraction	(	QCBOREncodeContext *	pCtx,
		int64_t	nMantissa,
		int64_t	nBase10Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTDecimalFraction() instead.

◆ QCBOREncode_AddDecimalFractionBigNum()

static void QCBOREncode_AddDecimalFractionBigNum	(	QCBOREncodeContext *	pCtx,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTDecimalFractionBigMantissaRaw() instead.

◆ QCBOREncode_AddDecimalFractionBigNumToMapN()

static void QCBOREncode_AddDecimalFractionBigNumToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTDecimalFractionBigMantissaRawToMapN() instead.

◆ QCBOREncode_AddDecimalFractionBigNumToMapSZ()

static void QCBOREncode_AddDecimalFractionBigNumToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTDecimalFractionBigMantissaRawToMapSZ() instead.

◆ QCBOREncode_AddDecimalFractionToMap()

static void QCBOREncode_AddDecimalFractionToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		int64_t	nMantissa,
		int64_t	nBase10Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTDecimalFractionToMapSZ() instead.

◆ QCBOREncode_AddDecimalFractionToMapN()

static void QCBOREncode_AddDecimalFractionToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		int64_t	nMantissa,
		int64_t	nBase10Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTDecimalFractionToMapN() instead.

◆ QCBOREncode_AddDouble()

static void QCBOREncode_AddDouble	(	QCBOREncodeContext *	pCtx,
		double	dNum )

inlinestatic

Add a double-precision floating-point number to the encoded output.

Parameters

[in]	pCtx	The encoding context to add the double to.
[in]	dNum	The double-precision number to add.

This encodes using preferred serialization, selectively encoding the input floating-point number as either double-precision, single-precision or half-precision. Infinity, NaN and 0 are always encoded as half-precision. The reduction to single-precision or half-precision is only performed if there is no loss or precision.

Half-precision floating-point numbers take up 2 bytes, half that of single-precision, one quarter of double-precision. This can reduce the size of encoded output a lot, especially if the values 0, infinity and NaN occur frequently.

QCBOR decoding returns double-precision reversing this reduction.

Normally this outputs only CBOR major type 7. If QCBOREncode_SerializationdCBOR() is called to enter dCBOR mode, floating-point inputs that are whole integers are further reduced to CBOR type 0 and 1. This is a unification of the floating-point and integer number spaces such that there is only one encoding of any numeric value. Note that this will result in the whole integers from -(2^63+1) to -(2^64) being encode as CBOR major type 1 which can't be directly decoded into an int64_t or uint64_t. See QCBORDecode_GetNumberConvertPrecisely(), a good method to use to decode dCBOR.

Error handling is the same as QCBOREncode_AddInt64().

It is possible that preferred serialization is disabled when the QCBOR library was built. In that case, this functions the same as QCBOREncode_AddDoubleNoPreferred().

By default, this will error out on an attempt to encode a NaN with a payload. See QCBOREncode_Allow() and QCBOR_ENCODE_CONFIG_ALLOW_NAN_PAYLOAD. If preferred serialization is disabled at compliation, this check for for NaN payloads is disabled.

◆ QCBOREncode_AddDoubleNoPreferred()

static void QCBOREncode_AddDoubleNoPreferred	(	QCBOREncodeContext *	pCtx,
		double	dNum )

inlinestatic

Add a double-precision floating-point number without preferred encoding.

Parameters

[in]	pCtx	The encoding context to add the double to.
[in]	dNum	The double-precision number to add.

Output a double-precision float straight-through with no checking or processing for preferred serialization, dCBOR or other.

Error handling is the same as QCBOREncode_AddInt64().

◆ QCBOREncode_AddDoubleNoPreferredToMap()

static void QCBOREncode_AddDoubleNoPreferredToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		double	dNum )

inlinestatic

Deprecated: Use QCBOREncode_AddDoubleNoPreferredToMapSZ() instead.

◆ QCBOREncode_AddDoubleNoPreferredToMapN()

static void QCBOREncode_AddDoubleNoPreferredToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		double	dNum )

inlinestatic

See QCBOREncode_AddDoubleNoPreferred().

◆ QCBOREncode_AddDoubleNoPreferredToMapSZ()

static void QCBOREncode_AddDoubleNoPreferredToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		double	dNum )

inlinestatic

See QCBOREncode_AddDoubleNoPreferred().

◆ QCBOREncode_AddDoubleToMap()

static void QCBOREncode_AddDoubleToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		double	dNum )

inlinestatic

Deprecated: Use QCBOREncode_AddDoubleToMapSZ() instead.

◆ QCBOREncode_AddDoubleToMapN()

static void QCBOREncode_AddDoubleToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		double	dNum )

inlinestatic

See QCBOREncode_AddDouble().

◆ QCBOREncode_AddDoubleToMapSZ()

static void QCBOREncode_AddDoubleToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		double	dNum )

inlinestatic

See QCBOREncode_AddDouble().

◆ QCBOREncode_AddFloat()

static void QCBOREncode_AddFloat	(	QCBOREncodeContext *	pCtx,
		float	fNum )

inlinestatic

Add a single-precision floating-point number to the encoded output.

Parameters

[in]	pCtx	The encoding context to add the single to.
[in]	fNum	The single-precision number to add.

This is identical to QCBOREncode_AddDouble() except the input is single-precision. It also supports dCBOR.

◆ QCBOREncode_AddFloatNoPreferred()

static void QCBOREncode_AddFloatNoPreferred	(	QCBOREncodeContext *	pCtx,
		float	fNum )

inlinestatic

Add a single-precision floating-point number without preferred encoding.

Parameters

[in]	pCtx	The encoding context to add the double to.
[in]	fNum	The single-precision number to add.

Output a single-precision float straight-through with no checking or processing for preferred serializtion, dCBOR or other.

Error handling is the same as QCBOREncode_AddInt64().

◆ QCBOREncode_AddFloatNoPreferredToMap()

static void QCBOREncode_AddFloatNoPreferredToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		float	fNum )

inlinestatic

Deprecated: Use QCBOREncode_AddFloatNoPreferredToMapSZ() instead.

◆ QCBOREncode_AddFloatNoPreferredToMapN()

static void QCBOREncode_AddFloatNoPreferredToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		float	fNum )

inlinestatic

See QCBOREncode_AddFloatNoPreferred().

◆ QCBOREncode_AddFloatNoPreferredToMapSZ()

static void QCBOREncode_AddFloatNoPreferredToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		float	fNum )

inlinestatic

See QCBOREncode_AddFloatNoPreferred().

◆ QCBOREncode_AddFloatToMap()

static void QCBOREncode_AddFloatToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		float	fNum )

inlinestatic

Deprecated: Use QCBOREncode_AddFloatToMapSZ() instead.

◆ QCBOREncode_AddFloatToMapN()

static void QCBOREncode_AddFloatToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		float	dNum )

inlinestatic

See QCBOREncode_AddFloat().

◆ QCBOREncode_AddFloatToMapSZ()

static void QCBOREncode_AddFloatToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		float	fNum )

inlinestatic

See QCBOREncode_AddFloat().

◆ QCBOREncode_AddInt64()

void QCBOREncode_AddInt64	(	QCBOREncodeContext *	pCtx,
		int64_t	nNum )

Add a signed 64-bit integer to the encoded output.

Parameters

[in]	pCtx	The encoding context to add the integer to.
[in]	nNum	The integer to add.

The integer will be encoded and added to the CBOR output.

This function figures out the size and the sign and encodes using CBOR preferred serialization. Specifically, it will select CBOR major type 0 or 1 based on sign and will encode to 1, 2, 4 or 8 bytes depending on the value of the integer. Values less than 24 effectively encode to one byte because they are encoded in with the CBOR major type. This is a neat and efficient characteristic of CBOR that can be taken advantage of when designing CBOR-based protocols. If integers can be kept between -23 and 23 they will be encoded in one byte including the major type.

If you pass a smaller integer, like int16_t or a small value, like 100, the encoding will still be CBOR's most compact that can represent the value. For example, CBOR always encodes the value 0 as one byte, 0x00. The representation as 0x00 includes identification of the type as an integer too as the major type for an integer is 0. See RFC 8949 Appendix A for more examples of CBOR encoding. This compact encoding is preferred serialization CBOR as per RFC 8949 section 4.1

There are no functions to add int16_t or int32_t because they are not necessary because this always encodes to the smallest number of bytes based on the value.

If the encoding context is in an error state, this will do nothing. If an error occurs when adding this integer, the internal error flag will be set, and the error will be returned when QCBOREncode_Finish() is called.

◆ QCBOREncode_AddInt64ToMap()

static void QCBOREncode_AddInt64ToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		int64_t	nNum )

inlinestatic

Deprecated: Use QCBOREncode_AddInt64ToMapSZ() instead.

◆ QCBOREncode_AddInt64ToMapN()

static void QCBOREncode_AddInt64ToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		int64_t	nNum )

inlinestatic

See QCBOREncode_AddInt64().

◆ QCBOREncode_AddInt64ToMapSZ()

static void QCBOREncode_AddInt64ToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		int64_t	nNum )

inlinestatic

See QCBOREncode_AddInt64().

◆ QCBOREncode_AddNegativeBignum()

static void QCBOREncode_AddNegativeBignum	(	QCBOREncodeContext *	pCtx,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRaw() instead.

◆ QCBOREncode_AddNegativeBignumToMap()

static void QCBOREncode_AddNegativeBignumToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRawToMapSZ() instead.

◆ QCBOREncode_AddNegativeBignumToMapN()

static void QCBOREncode_AddNegativeBignumToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRawToMapN() instead.

◆ QCBOREncode_AddNegativeUInt64()

static void QCBOREncode_AddNegativeUInt64	(	QCBOREncodeContext *	pCtx,
		uint64_t	uNum )

inlinestatic

Add a negative 64-bit integer to encoded output.

Parameters

[in]	pCtx	The encoding context to add the integer to.
[in]	uNum	The integer to add.

QCBOREncode_AddInt64() is much better to encode negative integers than this. What this can do is add integers with one more significant bit than an int64_t (a "65-bit" integer if you count the sign as a bit) which is possible because CBOR happens to support such integers.

The actual value encoded is -uNum - 1. That is, give 0 for uNum to transmit -1, give 1 to transmit -2 and give UINT64_MAX to transmit -UINT64_MAX-1 (18446744073709551616). The interface is odd like this so all negative values CBOR can represent can be encoded by QCBOR (making this a complete CBOR implementation).

The most negative value QCBOREncode_AddInt64() can encode is -9223372036854775808 which is -(2^63) or negative 0x800000000000. This can encode from -9223372036854775809 to -18446744073709551616 or -(2^63 +1) to -(2^64). Note that it is not possible to represent positive or negative 18446744073709551616 in any standard C data type.

Negative integers are normally decoded in QCBOR with type QCBOR_TYPE_INT64. Integers in the range of -9223372036854775809 to -18446744073709551616 are returned as QCBOR_TYPE_65BIT_NEG_INT.

WARNING: some CBOR decoders will be unable to decode -(2^63 + 1) to -(2^64). Also, most CPUs do not have registers that can represent this range. If you need 65-bit negative integers, you likely need negative 66, 67 and 68-bit negative integers so it is likely better to use CBOR big numbers where you can have any number of bits. See QCBOREncode_AddTBigNumber() and Serialization.

◆ QCBOREncode_AddNegativeUInt64ToMap()

static void QCBOREncode_AddNegativeUInt64ToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint64_t	uNum )

inlinestatic

See QCBOREncode_AddNegativeUInt64().

◆ QCBOREncode_AddNegativeUInt64ToMapN()

static void QCBOREncode_AddNegativeUInt64ToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint64_t	uNum )

inlinestatic

See QCBOREncode_AddNegativeUInt64().

◆ QCBOREncode_AddPositiveBignum()

static void QCBOREncode_AddPositiveBignum	(	QCBOREncodeContext *	pCtx,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRaw() instead.

◆ QCBOREncode_AddPositiveBignumToMap()

static void QCBOREncode_AddPositiveBignumToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRawToMapSZ() instead.

◆ QCBOREncode_AddPositiveBignumToMapN()

static void QCBOREncode_AddPositiveBignumToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRawToMapN() instead.

◆ QCBOREncode_AddTBigFloat()

static void QCBOREncode_AddTBigFloat	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		int64_t	nMantissa,
		int64_t	nBase2Exponent )

inlinestatic

Add a big floating-point number to the encoded output.

Parameters

[in]	pCtx	The encoding context to add the bigfloat to.
[in]	uTagRequirement	Either QCBOR_ENCODE_AS_TAG or QCBOR_ENCODE_AS_BORROWED.
[in]	nMantissa	The mantissa.
[in]	nBase2Exponent	The exponent.

The value is nMantissa * 2 ^ nBase2Exponent.

"Bigfloats", as CBOR terms them, are similar to IEEE floating-point numbers in having a mantissa and base-2 exponent, but they are not supported by hardware or encoded the same. They explicitly use two CBOR-encoded integers to convey the mantissa and exponent, each of which can be 8, 16, 32 or 64 bits. With both the mantissa and exponent 64 bits they can express more precision and a larger range than an IEEE double floating-point number. See QCBOREncode_AddTBigFloatBigMantissa() for even more precision.

For example, 1.5 would be represented by a mantissa of 3 and an exponent of -1.

The exponent has a range from INT64_MIN to INT64_MAX for both encoding and decoding (CBOR allows -UINT64_MAX to UINT64_MAX, but this implementation doesn't support this range to reduce code size and interface complexity a little).

CBOR preferred serialization of the integers is used, thus they will be encoded in the smallest number of bytes possible.

This can also be used to represent floating-point numbers in environments that don't support IEEE 754.

See expAndMantissa for decoded representation.

◆ QCBOREncode_AddTBigFloatBigMantissa()

static void QCBOREncode_AddTBigFloatBigMantissa	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

Add a big floating-point number with a big number mantissa.

Parameters

[in]	pCtx	The encoding context to add the bigfloat to.
[in]	uTagRequirement	Either QCBOR_ENCODE_AS_TAG or QCBOR_ENCODE_AS_BORROWED.
[in]	Mantissa	The mantissa.
[in]	bIsNegative	false if mantissa is positive, true if negative.
[in]	nBase2Exponent	The exponent.

This is the same as QCBOREncode_AddTBigFloat() except the mantissa is a big number (See QCBOREncode_AddTBigMantissa()) allowing for arbitrary precision.

The big number will be offset by 1 if negative and preferred serialization will be used (tag 0 and 1).

If you want the big number to be copied straight through without the conversion to type 0 and 1 integers and without the offset of 1 (and much smaller objet code) use QCBOREncode_AddTBigFloatBigMantissa().

See expAndMantissa for decoded representation.

◆ QCBOREncode_AddTBigFloatBigMantissaRaw()

static void QCBOREncode_AddTBigFloatBigMantissaRaw	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

Add a big floating-point number with a big number mantissa.

Parameters

[in]	pCtx	The encoding context to add the bigfloat to.
[in]	uTagRequirement	Either QCBOR_ENCODE_AS_TAG or QCBOR_ENCODE_AS_BORROWED.
[in]	Mantissa	The mantissa.
[in]	bIsNegative	false if mantissa is positive, true if negative.
[in]	nBase2Exponent	The exponent.

This is the same as QCBOREncode_AddTBigFloatBigMantissa() except the mantissa is not corrected by one and links in much less object code.

◆ QCBOREncode_AddTBigFloatBigMantissaRawToMapN()

static void QCBOREncode_AddTBigFloatBigMantissaRawToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

See QCBOREncode_AddTBigFloatBigMantissaRaw().

◆ QCBOREncode_AddTBigFloatBigMantissaRawToMapSZ()

static void QCBOREncode_AddTBigFloatBigMantissaRawToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

See QCBOREncode_AddTBigFloatBigMantissaRaw().

◆ QCBOREncode_AddTBigFloatBigMantissaToMapN()

static void QCBOREncode_AddTBigFloatBigMantissaToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

See QCBOREncode_AddTBigFloatBigMantissa().

◆ QCBOREncode_AddTBigFloatBigMantissaToMapSZ()

static void QCBOREncode_AddTBigFloatBigMantissaToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

See QCBOREncode_AddTBigFloatBigMantissa().

◆ QCBOREncode_AddTBigFloatBigNum()

static void QCBOREncode_AddTBigFloatBigNum	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigFloatBigMantissaRaw() instead.

◆ QCBOREncode_AddTBigFloatBigNumToMapN()

static void QCBOREncode_AddTBigFloatBigNumToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigFloatBigMantissaRawToMapN() instead.

◆ QCBOREncode_AddTBigFloatBigNumToMapSZ()

static void QCBOREncode_AddTBigFloatBigNumToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase2Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigFloatBigMantissaRawToMapSZ() instead.

◆ QCBOREncode_AddTBigFloatToMapN()

static void QCBOREncode_AddTBigFloatToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		int64_t	nMantissa,
		int64_t	nBase2Exponent )

inlinestatic

See QCBOREncode_AddTBigFloat().

◆ QCBOREncode_AddTBigFloatToMapSZ()

static void QCBOREncode_AddTBigFloatToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		int64_t	nMantissa,
		int64_t	nBase2Exponent )

inlinestatic

See QCBOREncode_AddTBigFloat().

◆ QCBOREncode_AddTBigNumber()

static void QCBOREncode_AddTBigNumber	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		bool	bNegative,
		UsefulBufC	BigNumber )

inlinestatic

Add a big number to encoded output using preferred serialization.

Parameters

[in]	pCtx	The encoding context to add to.
[in]	uTagRequirement	Either QCBOR_ENCODE_AS_TAG or QCBOR_ENCODE_AS_BORROWED.
[in]	bNegative	If true, `BigNumber` is negative.
[in]	BigNumber	Pointer and length of the big number, most significant byte first (network byte order).

This encodes CBOR tag numbers 2 and 3, positive and negative big numbers, as defined in RFC 8949 section 3.4.3.

This performs the offset of one required when encoding negative numbers.

Leading zeros are not encoded.

This uses preferred serialization described specifically for big numbers. Positive values between 0 and (2^64)-1 are encoded as common type 0 integers. Negative values between -(2^64) and -1 are encoded as common type 1 integers.

See BigNumbers for a useful overview of CBOR big numbers and QCBOR's support for them. See QCBOREncode_AddTBigNumberNoPreferred() to encode without conversion to common integer types 0 and 1. See QCBOREncode_AddTBigNumberRaw() for encoding that is simple pass through as a byte string that links in much less object code. See QCBORDecode_GetTBigNumber() for the decoder counter part.

◆ QCBOREncode_AddTBigNumberNoPreferred()

static void QCBOREncode_AddTBigNumberNoPreferred	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		bool	bNegative,
		UsefulBufC	BigNumber )

inlinestatic

Add a big number to encoded output without preferred serialization.

Parameters

[in]	pCtx	The encoding context to add to.
[in]	uTagRequirement	Either QCBOR_ENCODE_AS_TAG or QCBOR_ENCODE_AS_BORROWED.
[in]	bNegative	If true, `BigNumber` is negative.
[in]	BigNumber	Pointer and length of the big number, most significant byte first (network byte order).

This is the same as QCBOREncode_AddTBigNumber(), without preferred serialization. This always outputs tag 2 or 3, never type 0 or 1 integers.

Leading zeros are removed before encoding.

See BigNumbers for a useful overview of CBOR big numbers and QCBOR's support for them. See also QCBOREncode_AddTBigNumber(). See QCBORDecode_GetTBigNumberNoPreferred(), the decode counter part for this.

◆ QCBOREncode_AddTBigNumberNoPreferredToMapN()

static void QCBOREncode_AddTBigNumberNoPreferredToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		bool	bNegative,
		UsefulBufC	BigNumber )

inlinestatic

See QCBOREncode_AddTBigNumberNoPreferred().

◆ QCBOREncode_AddTBigNumberNoPreferredToMapSZ()

static void QCBOREncode_AddTBigNumberNoPreferredToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		bool	bNegative,
		UsefulBufC	BigNumber )

inlinestatic

See QCBOREncode_AddTBigNumberNoPreferred().

◆ QCBOREncode_AddTBigNumberRaw()

static void QCBOREncode_AddTBigNumberRaw	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		bool	bNegative,
		UsefulBufC	BigNumber )

inlinestatic

Add a big number to encoded output with no processing.

Parameters

[in]	pCtx	The encoding context to add to.
[in]	uTagRequirement	Either QCBOR_ENCODE_AS_TAG or QCBOR_ENCODE_AS_BORROWED.
[in]	bNegative	If true `BigNumber` is negative.
[in]	BigNumber	Pointer and length of the big number, most significant byte first (network byte order).

All this does is output tag number 2 or 3 depending on bNegative and then output BigNumber as a byte string. If uTagRequirement is QCBOR_ENCODE_AS_BORROWED, the tag number is not even output and this equivalent to QCBOREncode_AddBytes().

No leading zeros are removed. No offset of one is performed for negative numbers. There is no conversion to type 0 and type 1 integers.

This is mostly an inline implementation that links in no additional object from the QCBOR library.

This is most useful when a big number library has been linked, and it can be (trivially) used to perform the offset of one for negative numbers.

See BigNumbers for a useful overview of CBOR big numbers and QCBOR's support for them. See QCBORDecode_GetTBigNumberRaw(), the decode counter part for this. See also QCBOREncode_AddTBigNumber().

◆ QCBOREncode_AddTBigNumberRawToMapN()

static void QCBOREncode_AddTBigNumberRawToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		bool	bNegative,
		UsefulBufC	BigNumber )

inlinestatic

See QCBOREncode_AddTBigNumberRaw().

◆ QCBOREncode_AddTBigNumberRawToMapSZ()

static void QCBOREncode_AddTBigNumberRawToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		bool	bNegative,
		UsefulBufC	BigNumber )

inlinestatic

See QCBOREncode_AddTBigNumberRaw().

◆ QCBOREncode_AddTBigNumberToMapN()

static void QCBOREncode_AddTBigNumberToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		bool	bNegative,
		UsefulBufC	BigNumber )

inlinestatic

See QCBOREncode_AddTBigNumber().

◆ QCBOREncode_AddTBigNumberToMapSZ()

static void QCBOREncode_AddTBigNumberToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		bool	bNegative,
		UsefulBufC	BigNumber )

inlinestatic

See QCBOREncode_AddTBigNumber().

◆ QCBOREncode_AddTDecimalFraction()

static void QCBOREncode_AddTDecimalFraction	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		int64_t	nMantissa,
		int64_t	nBase10Exponent )

inlinestatic

Add a decimal fraction.

Parameters

[in]	pCtx	Encoding context to add the decimal fraction to.
[in]	uTagRequirement	Either QCBOR_ENCODE_AS_TAG or QCBOR_ENCODE_AS_BORROWED.
[in]	nMantissa	The mantissa.
[in]	nBase10Exponent	The exponent.

The value is nMantissa * 10 ^ nBase10Exponent.

A decimal fraction is good for exact representation of some values that can't be represented exactly with standard C (IEEE 754) floating-point numbers. Much larger and much smaller numbers can also be represented than floating-point because of the larger number of bits in the exponent.

The decimal fraction is conveyed as two integers, a mantissa and a base-10 scaling factor.

For example, 273.15 is represented by the two integers 27315 and -2.

The exponent and mantissa have the range from INT64_MIN to INT64_MAX for both encoding and decoding (CBOR allows -UINT64_MAX to UINT64_MAX, but this implementation doesn't support this range to reduce code size and interface complexity a little).

CBOR Preferred serialization of the integers is used, thus they will be encoded in the smallest number of bytes possible.

See also QCBOREncode_AddTDecimalFractionBigNumber() for a decimal fraction with arbitrarily large precision and QCBOREncode_AddTBigFloat().

There is no representation of positive or negative infinity or NaN (Not a Number). Use QCBOREncode_AddDouble() to encode them.

See expAndMantissa for decoded representation.

◆ QCBOREncode_AddTDecimalFractionBigMantissa()

static void QCBOREncode_AddTDecimalFractionBigMantissa	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

Add a decimal fraction with a big number mantissa..

Parameters

[in]	pCtx	Encoding context to add the decimal fraction to.
[in]	uTagRequirement	Either QCBOR_ENCODE_AS_TAG or QCBOR_ENCODE_AS_BORROWED.
[in]	Mantissa	The big number mantissa.
[in]	bIsNegative	false if mantissa is positive, true if negative.
[in]	nBase10Exponent	The exponent.

This is the same as QCBOREncode_AddTDecimalFraction() except the mantissa is a big number (See QCBOREncode_AddTBignumber()) allowing for arbitrarily large precision.

Preferred serialization of the big number is used. This means it may be converted to a type 0 or type 1 integers making the result the same as QCBOREncode_AddTDecimalFraction(). This also offsets negative big numbers by one.

If you want the big number to be copied straight through without the conversion to type 0 and 1 integers and without the offset of 1 (and much smaller objet code) use QCBOREncode_AddTBigFloatBigMantissaRaw().

See expAndMantissa for decoded representation.

◆ QCBOREncode_AddTDecimalFractionBigMantissaRaw()

static void QCBOREncode_AddTDecimalFractionBigMantissaRaw	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

Add a decimal fraction with a raw big number mantissa.

Parameters

[in]	pCtx	The encoding context to add the bigfloat to.
[in]	uTagRequirement	Either QCBOR_ENCODE_AS_TAG or QCBOR_ENCODE_AS_BORROWED.
[in]	Mantissa	The mantissa.
[in]	bIsNegative	false if mantissa is positive, true if negative.
[in]	nBase10Exponent	The exponent.

This is the same as QCBOREncode_AddTDecimalFractionBigMantissa() except the mantissa is not corrected by one and links in much less object code.

◆ QCBOREncode_AddTDecimalFractionBigMantissaRawToMapN()

static void QCBOREncode_AddTDecimalFractionBigMantissaRawToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

See QCBOREncode_AddTDecimalFractionBigMantissaRaw().

◆ QCBOREncode_AddTDecimalFractionBigMantissaRawToMapSZ()

static void QCBOREncode_AddTDecimalFractionBigMantissaRawToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

See QCBOREncode_AddTDecimalFractionBigMantissaRaw().

◆ QCBOREncode_AddTDecimalFractionBigMantissaToMapN()

static void QCBOREncode_AddTDecimalFractionBigMantissaToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

See QCBOREncode_AddTDecimalFractionBigMantissa().

◆ QCBOREncode_AddTDecimalFractionBigMantissaToMapSZ()

static void QCBOREncode_AddTDecimalFractionBigMantissaToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

See QCBOREncode_AddTDecimalFractionBigMantissa().

◆ QCBOREncode_AddTDecimalFractionBigNum()

static void QCBOREncode_AddTDecimalFractionBigNum	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTDecimalFractionBigMantissaRaw() instead.

◆ QCBOREncode_AddTDecimalFractionBigNumToMapN()

static void QCBOREncode_AddTDecimalFractionBigNumToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTDecimalFractionBigMantissaRawToMapN() instead.

◆ QCBOREncode_AddTDecimalFractionBigNumToMapSZ()

static void QCBOREncode_AddTDecimalFractionBigNumToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	Mantissa,
		bool	bIsNegative,
		int64_t	nBase10Exponent )

inlinestatic

Deprecated: Use QCBOREncode_AddTDecimalFractionBigMantissaRawToMapSZ() instead.

◆ QCBOREncode_AddTDecimalFractionToMapN()

static void QCBOREncode_AddTDecimalFractionToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		int64_t	nMantissa,
		int64_t	nBase10Exponent )

inlinestatic

See QCBOREncode_AddTDecimalFraction().

◆ QCBOREncode_AddTDecimalFractionToMapSZ()

static void QCBOREncode_AddTDecimalFractionToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		int64_t	nMantissa,
		int64_t	nBase10Exponent )

inlinestatic

See QCBOREncode_AddTDecimalFraction().

◆ QCBOREncode_AddTNegativeBignum()

static void QCBOREncode_AddTNegativeBignum	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRaw() instead.

◆ QCBOREncode_AddTNegativeBignumToMapN()

static void QCBOREncode_AddTNegativeBignumToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRawToMapN() instead.

◆ QCBOREncode_AddTNegativeBignumToMapSZ()

static void QCBOREncode_AddTNegativeBignumToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRawToMapSZ() instead.

◆ QCBOREncode_AddTPositiveBignum()

static void QCBOREncode_AddTPositiveBignum	(	QCBOREncodeContext *	pCtx,
		uint8_t	uTagRequirement,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRaw() instead.

◆ QCBOREncode_AddTPositiveBignumToMapN()

static void QCBOREncode_AddTPositiveBignumToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRawToMapN() instead.

◆ QCBOREncode_AddTPositiveBignumToMapSZ()

static void QCBOREncode_AddTPositiveBignumToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint8_t	uTagRequirement,
		UsefulBufC	BigNumber )

inlinestatic

Deprecated: Use QCBOREncode_AddTBigNumberRawToMapSZ() instead.

◆ QCBOREncode_AddUInt64()

static void QCBOREncode_AddUInt64	(	QCBOREncodeContext *	pCtx,
		uint64_t	uNum )

inlinestatic

Add an unsigned 64-bit integer to the encoded output.

Parameters

[in]	pCtx	The encoding context to add the integer to.
[in]	uNum	The integer to add.

The integer is encoded and added to the CBOR output.

The only reason so use this function is for integers larger than INT64_MAX and smaller than UINT64_MAX. Otherwise QCBOREncode_AddInt64() will work fine.

Error handling is the same as for QCBOREncode_AddInt64().

◆ QCBOREncode_AddUInt64ToMap()

static void QCBOREncode_AddUInt64ToMap	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint64_t	uNum )

inlinestatic

Deprecated: Use QCBOREncode_AddUInt64ToMapSZ() instead.

◆ QCBOREncode_AddUInt64ToMapN()

static void QCBOREncode_AddUInt64ToMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		uint64_t	uNum )

inlinestatic

See QCBOREncode_AddUInt64().

◆ QCBOREncode_AddUInt64ToMapSZ()

static void QCBOREncode_AddUInt64ToMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		uint64_t	uNum )

inlinestatic

See QCBOREncode_AddUInt64().

◆ QCBOREncode_CloseBytes()

void QCBOREncode_CloseBytes	(	QCBOREncodeContext *	pCtx,
		size_t	uAmount )

Close out a byte string written directly to encoded output.

Parameters

[in]	pCtx	The encoding context to add the bytes to.
[out]	uAmount	The number of bytes written, the length of the byte string.

This closes out a call to QCBOREncode_OpenBytes(). This inserts a CBOR header at the front of the byte string value to make it a well-formed byte string.

If there was no call to QCBOREncode_OpenBytes() then QCBOR_ERR_TOO_MANY_CLOSES is set.

◆ QCBOREncode_OpenBytes()

void QCBOREncode_OpenBytes	(	QCBOREncodeContext *	pCtx,
		UsefulBuf *	pPlace )

Set up to write a byte string value directly to encoded output.

Parameters

[in]	pCtx	The encoding context to add the bytes to.
[out]	pPlace	Pointer and length of place to write byte string value.

QCBOREncode_AddBytes() is the normal way to encode a byte string. This is for special cases and by passes some of the pointer safety.

The purpose of this is to output the bytes that make up a byte string value directly to the QCBOR output buffer so you don't need to have a copy of it in memory. This is particularly useful if the byte string is large, for example, the encrypted payload of a COSE_Encrypt message. The payload encryption algorithm can output directly to the encoded CBOR buffer, perhaps by making it the output buffer for some function (e.g. symmetric encryption) or by multiple writes.

The pointer in pPlace is where to start writing. Writing is just copying bytes to the location by the pointer in pPlace. Writing past the length in pPlace will be writing off the end of the output buffer.

If there is no room in the output buffer NULLUsefulBuf will be returned and there is no need to call QCBOREncode_CloseBytes().

The byte string must be closed by calling QCBOREncode_CloseBytes().

Warning: this bypasses some of the usual checks provided by QCBOR against writing off the end of the encoded output buffer.

◆ QCBOREncode_OpenBytesInMapN()

static void QCBOREncode_OpenBytesInMapN	(	QCBOREncodeContext *	pCtx,
		int64_t	nLabel,
		UsefulBuf *	pPlace )

static

See QCBOREncode_OpenBytes().

◆ QCBOREncode_OpenBytesInMapSZ()

static void QCBOREncode_OpenBytesInMapSZ	(	QCBOREncodeContext *	pCtx,
		const char *	szLabel,
		UsefulBuf *	pPlace )

static

See QCBOREncode_OpenBytes().

Macros

Functions

Detailed Description

Floating-Point

Macro Definition Documentation

◆ QCBOR_HEAD_BUFFER_SIZE

Function Documentation

◆ QCBOREncode_AddBigFloat()

◆ QCBOREncode_AddBigFloatBigNum()

◆ QCBOREncode_AddBigFloatBigNumToMap()

◆ QCBOREncode_AddBigFloatBigNumToMapN()

◆ QCBOREncode_AddBigFloatToMap()

◆ QCBOREncode_AddBigFloatToMapN()

◆ QCBOREncode_AddBytes()

◆ QCBOREncode_AddBytesToMapN()

◆ QCBOREncode_AddBytesToMapSZ()

◆ QCBOREncode_AddDecimalFraction()

◆ QCBOREncode_AddDecimalFractionBigNum()

◆ QCBOREncode_AddDecimalFractionBigNumToMapN()

◆ QCBOREncode_AddDecimalFractionBigNumToMapSZ()

◆ QCBOREncode_AddDecimalFractionToMap()

◆ QCBOREncode_AddDecimalFractionToMapN()

◆ QCBOREncode_AddDouble()

◆ QCBOREncode_AddDoubleNoPreferred()

◆ QCBOREncode_AddDoubleNoPreferredToMap()

◆ QCBOREncode_AddDoubleNoPreferredToMapN()

◆ QCBOREncode_AddDoubleNoPreferredToMapSZ()

◆ QCBOREncode_AddDoubleToMap()

◆ QCBOREncode_AddDoubleToMapN()

◆ QCBOREncode_AddDoubleToMapSZ()

◆ QCBOREncode_AddFloat()

◆ QCBOREncode_AddFloatNoPreferred()

◆ QCBOREncode_AddFloatNoPreferredToMap()

◆ QCBOREncode_AddFloatNoPreferredToMapN()

◆ QCBOREncode_AddFloatNoPreferredToMapSZ()

◆ QCBOREncode_AddFloatToMap()

◆ QCBOREncode_AddFloatToMapN()

◆ QCBOREncode_AddFloatToMapSZ()

◆ QCBOREncode_AddInt64()

◆ QCBOREncode_AddInt64ToMap()

◆ QCBOREncode_AddInt64ToMapN()

◆ QCBOREncode_AddInt64ToMapSZ()

◆ QCBOREncode_AddNegativeBignum()

◆ QCBOREncode_AddNegativeBignumToMap()

◆ QCBOREncode_AddNegativeBignumToMapN()

◆ QCBOREncode_AddNegativeUInt64()

◆ QCBOREncode_AddNegativeUInt64ToMap()

◆ QCBOREncode_AddNegativeUInt64ToMapN()

◆ QCBOREncode_AddPositiveBignum()

◆ QCBOREncode_AddPositiveBignumToMap()

◆ QCBOREncode_AddPositiveBignumToMapN()

◆ QCBOREncode_AddTBigFloat()

◆ QCBOREncode_AddTBigFloatBigMantissa()

◆ QCBOREncode_AddTBigFloatBigMantissaRaw()

◆ QCBOREncode_AddTBigFloatBigMantissaRawToMapN()

◆ QCBOREncode_AddTBigFloatBigMantissaRawToMapSZ()

◆ QCBOREncode_AddTBigFloatBigMantissaToMapN()

◆ QCBOREncode_AddTBigFloatBigMantissaToMapSZ()

◆ QCBOREncode_AddTBigFloatBigNum()

◆ QCBOREncode_AddTBigFloatBigNumToMapN()

◆ QCBOREncode_AddTBigFloatBigNumToMapSZ()

◆ QCBOREncode_AddTBigFloatToMapN()

◆ QCBOREncode_AddTBigFloatToMapSZ()

◆ QCBOREncode_AddTBigNumber()

◆ QCBOREncode_AddTBigNumberNoPreferred()

◆ QCBOREncode_AddTBigNumberNoPreferredToMapN()

◆ QCBOREncode_AddTBigNumberNoPreferredToMapSZ()

◆ QCBOREncode_AddTBigNumberRaw()

◆ QCBOREncode_AddTBigNumberRawToMapN()

◆ QCBOREncode_AddTBigNumberRawToMapSZ()

◆ QCBOREncode_AddTBigNumberToMapN()

◆ QCBOREncode_AddTBigNumberToMapSZ()

◆ QCBOREncode_AddTDecimalFraction()

◆ QCBOREncode_AddTDecimalFractionBigMantissa()

◆ QCBOREncode_AddTDecimalFractionBigMantissaRaw()

◆ QCBOREncode_AddTDecimalFractionBigMantissaRawToMapN()

◆ QCBOREncode_AddTDecimalFractionBigMantissaRawToMapSZ()

◆ QCBOREncode_AddTDecimalFractionBigMantissaToMapN()

◆ QCBOREncode_AddTDecimalFractionBigMantissaToMapSZ()

◆ QCBOREncode_AddTDecimalFractionBigNum()