qcbor_number_decode.h File Reference

#include "qcbor/qcbor_main_decode.h"
#include "qcbor/qcbor_tag_decode.h"

Go to the source code of this file.

Macros
#define	QCBOR_Int64UToInt16   QCBOR_Int64ToUInt16

Enumerations
enum	QCBORDecodeNumberConvert {   QCBOR_CONVERT_TYPE_XINT64 = 0x01 , QCBOR_CONVERT_TYPE_FLOAT = 0x02 , QCBOR_CONVERT_TYPE_BIG_NUM = 0x04 , QCBOR_CONVERT_TYPE_DECIMAL_FRACTION = 0x08 ,   QCBOR_CONVERT_TYPE_BIGFLOAT = 0x10 }

Functions
static void	QCBORDecode_GetInt64 (QCBORDecodeContext *pCtx, int64_t *pnValue)
	Decode next item into a signed 64-bit integer.
static void	QCBORDecode_GetInt64InMapN (QCBORDecodeContext *pCtx, int64_t nLabel, int64_t *pnValue)
static void	QCBORDecode_GetInt64InMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, int64_t *pnValue)
static void	QCBORDecode_GetInt64Convert (QCBORDecodeContext *pCtx, enum QCBORDecodeNumberConvert uConvertTypes, int64_t *pnValue)
	Decode next item into a signed 64-bit integer with basic conversions.
static void	QCBORDecode_GetInt64ConvertInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeNumberConvert uConvertTypes, int64_t *pnValue)
static void	QCBORDecode_GetInt64ConvertInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeNumberConvert uConvertTypes, int64_t *pnValue)
void	QCBORDecode_GetInt64ConvertAll (QCBORDecodeContext *pCtx, enum QCBORDecodeNumberConvert uConvertTypes, int64_t *pnValue)
	Decode next item into a signed 64-bit integer with conversions.
void	QCBORDecode_GetInt64ConvertAllInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeNumberConvert uConvertTypes, int64_t *pnValue)
void	QCBORDecode_GetInt64ConvertAllInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeNumberConvert uConvertTypes, int64_t *pnValue)
static void	QCBORDecode_GetUInt64 (QCBORDecodeContext *pCtx, uint64_t *puValue)
	Decode next item into an unsigned 64-bit integer.
static void	QCBORDecode_GetUInt64InMapN (QCBORDecodeContext *pCtx, int64_t nLabel, uint64_t *puValue)
static void	QCBORDecode_GetUInt64InMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, uint64_t *puValue)
static void	QCBORDecode_GetUInt64Convert (QCBORDecodeContext *pCtx, enum QCBORDecodeNumberConvert uConvertTypes, uint64_t *puValue)
	Decode next item as an unsigned 64-bit integer with basic conversions.
static void	QCBORDecode_GetUInt64ConvertInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeNumberConvert uConvertTypes, uint64_t *puValue)
static void	QCBORDecode_GetUInt64ConvertInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeNumberConvert uConvertTypes, uint64_t *puValue)
void	QCBORDecode_GetUInt64ConvertAll (QCBORDecodeContext *pCtx, enum QCBORDecodeNumberConvert uConvertTypes, uint64_t *puValue)
	Decode next item into an unsigned 64-bit integer with conversions.
void	QCBORDecode_GetUInt64ConvertAllInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeNumberConvert uConvertTypes, uint64_t *puValue)
void	QCBORDecode_GetUInt64ConvertAllInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeNumberConvert uConvertTypes, uint64_t *puValue)
static void	QCBORDecode_GetDouble (QCBORDecodeContext *pCtx, double *pValue)
	Decode next item into a double floating-point value.
static void	QCBORDecode_GetDoubleInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, double *pdValue)
static void	QCBORDecode_GetDoubleInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, double *pdValue)
static void	QCBORDecode_GetDoubleConvert (QCBORDecodeContext *pCtx, enum QCBORDecodeNumberConvert uConvertTypes, double *pdValue)
	Decode next item into a double floating-point with basic conversion.
static void	QCBORDecode_GetDoubleConvertInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeNumberConvert uConvertTypes, double *pdValue)
static void	QCBORDecode_GetDoubleConvertInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeNumberConvert uConvertTypes, double *pdValue)
void	QCBORDecode_GetDoubleConvertAll (QCBORDecodeContext *pCtx, const enum QCBORDecodeNumberConvert uConvertTypes, double *pdValue)
	Decode next item as a double floating-point value with conversion.
void	QCBORDecode_GetDoubleConvertAllInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, const enum QCBORDecodeNumberConvert uConvertTypes, double *pdValue)
void	QCBORDecode_GetDoubleConvertAllInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, const enum QCBORDecodeNumberConvert uConvertTypes, double *pdValue)
void	QCBORDecode_GetNumberConvertPrecisely (QCBORDecodeContext *pCtx, QCBORItem *pNumber)
	dCBOR Decode next as a number with precision-preserving conversions.
QCBORError	QCBORDecode_ProcessBigNumber (const QCBORItem Item, UsefulBuf BigNumberBuf, UsefulBufC *pBigNumber, bool *pbIsNegative)
	Decode a preferred serialization big number.
QCBORError	QCBORDecode_ProcessBigNumberNoPreferred (const QCBORItem Item, UsefulBuf BigNumberBuf, UsefulBufC *pBigNumber, bool *pbIsNegative)
	Decode a big number.
void	QCBORDecode_GetTBigNumber (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf BigNumberBuf, UsefulBufC *pBigNumber, bool *pbIsNegative)
	Decode next item as a big number encoded using preferred serialization.
void	QCBORDecode_GetTBigNumberInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf BigNumberBuf, UsefulBufC *pBigNumber, bool *pbIsNegative)
void	QCBORDecode_GetTBigNumberInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf BigNumberBuf, UsefulBufC *pBigNumber, bool *pbIsNegative)
void	QCBORDecode_GetTBigNumberNoPreferred (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf BigNumberBuf, UsefulBufC *pBigNumber, bool *pbIsNegative)
	Decode next item as a big number without preferred serialization.
void	QCBORDecode_GetTBigNumberNoPreferredInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf BigNumberBuf, UsefulBufC *pBigNumber, bool *pbIsNegative)
void	QCBORDecode_GetTBigNumberNoPreferredInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf BigNumberBuf, UsefulBufC *pBigNumber, bool *pbIsNegative)
void	QCBORDecode_GetTBigNumberRaw (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, UsefulBufC *pBigNumber, bool *pbIsNegative)
	Decode the next item as a big number with no processing.
void	QCBORDecode_GetTBigNumberRawInMapN (QCBORDecodeContext *pMe, const int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBufC *pBigNumber, bool *pbIsNegative)
void	QCBORDecode_GetTBigNumberRawInMapSZ (QCBORDecodeContext *pMe, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBufC *pBigNumber, bool *pbIsNegative)
void	QCBORDecode_GetTDecimalFraction (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
	Decode the next item as a decimal fraction.
void	QCBORDecode_GetTDecimalFractionInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
void	QCBORDecode_GetTDecimalFractionInMapSZ (QCBORDecodeContext *pMe, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
void	QCBORDecode_GetTDecimalFractionBigMantissa (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
	Decode the next item as a decimal fraction with a big number mantissa.
void	QCBORDecode_GetTDecimalFractionBigMantissaInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pbMantissaIsNegative, bool *pbIsNegative, int64_t *pnExponent)
void	QCBORDecode_GetTDecimalFractionBigMantissaInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
void	QCBORDecode_GetTDecimalFractionBigMantissaRaw (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
	Decode the next item as a decimal fraction with a big number. mantissa raw.
void	QCBORDecode_GetTDecimalFractionBigMantissaRawInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pbMantissaIsNegative, bool *pbIsNegative, int64_t *pnExponent)
void	QCBORDecode_GetTDecimalFractionBigMantissaRawInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
void	QCBORDecode_GetTBigFloat (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
	Decode the next item as a big float.
void	QCBORDecode_GetTBigFloatInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
void	QCBORDecode_GetTBigFloatInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
void	QCBORDecode_GetTBigFloatBigMantissa (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
	Decode the next item as a big float with a big number mantissa.
void	QCBORDecode_GetTBigFloatBigMantissaInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
void	QCBORDecode_GetTBigFloatBigMantissaInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
void	QCBORDecode_GetTBigFloatBigMantissaRaw (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
	Decode the next item as a big float with a big number mantissa with out offsetting the mantissa.
void	QCBORDecode_GetTBigFloatBigMantissaRawInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
void	QCBORDecode_GetTBigFloatBigMantissaRawInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
static int	QCBOR_Int64ToInt32 (int64_t src, int32_t *dest)
	Convert int64_t to smaller integers safely.
static int	QCBOR_Int64ToInt16 (int64_t src, int16_t *dest)
static int	QCBOR_Int64ToInt8 (int64_t src, int8_t *dest)
static int	QCBOR_Int64ToUInt32 (int64_t src, uint32_t *dest)
static int	QCBOR_Int64ToUInt16 (int64_t src, uint16_t *dest)
static int	QCBOR_Int64ToUInt8 (int64_t src, uint8_t *dest)
static int	QCBOR_Int64ToUInt64 (int64_t src, uint64_t *dest)
static void	QCBORDecode_GetBignum (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, UsefulBufC *pValue, bool *pbIsNegative)
	[Deprecated] Decode big number with no processing.
static void	QCBORDecode_GetBignumInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBufC *pValue, bool *pbIsNegative)
static void	QCBORDecode_GetBignumInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBufC *pValue, bool *pbIsNegative)
static void	QCBORDecode_GetDecimalFraction (QCBORDecodeContext *pCtx, enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
	[Deprecated] Decode a decimal fraction.
static void	QCBORDecode_GetDecimalFractionInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
static void	QCBORDecode_GetDecimalFractionInMapSZ (QCBORDecodeContext *pMe, const char *szLabel, enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
static void	QCBORDecode_GetDecimalFractionBig (QCBORDecodeContext *pCtx, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
	[Deprecated] Decode a decimal fraction with big number mantissa.
static void	QCBORDecode_GetDecimalFractionBigInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pbMantissaIsNegative, bool *pbIsNegative, int64_t *pnExponent)
static void	QCBORDecode_GetDecimalFractionBigInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
static void	QCBORDecode_GetBigFloat (QCBORDecodeContext *pCtx, const enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
	[Deprecated] Decode a big float.
static void	QCBORDecode_GetBigFloatInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, const enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
static void	QCBORDecode_GetBigFloatInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, const enum QCBORDecodeTagReq uTagRequirement, int64_t *pnMantissa, int64_t *pnExponent)
static void	QCBORDecode_GetBigFloatBig (QCBORDecodeContext *pCtx, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
	[Depreacted] Decode big float with a big number mantissa.
static void	QCBORDecode_GetBigFloatBigInMapN (QCBORDecodeContext *pCtx, int64_t nLabel, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)
static void	QCBORDecode_GetBigFloatBigInMapSZ (QCBORDecodeContext *pCtx, const char *szLabel, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC *pMantissa, bool *pbMantissaIsNegative, int64_t *pnExponent)

Macro Definition Documentation

QCBOR_Int64UToInt16

#define QCBOR_Int64UToInt16   QCBOR_Int64ToUInt16

Fix misnaming in previous versions.

Enumeration Type Documentation

QCBORDecodeNumberConvert

enum QCBORDecodeNumberConvert

Bit flags to indicate what types of number conversions should be performed.

Enumerator
QCBOR_CONVERT_TYPE_XINT64	Conversion will proceed if the CBOR item to be decoded is an integer or either type 0 (unsigned) or type 1 (negative).
QCBOR_CONVERT_TYPE_FLOAT	Conversion will proceed if the CBOR item to be decoded is either double, single or half-precision floating-point (major type 7).
QCBOR_CONVERT_TYPE_BIG_NUM	Conversion will proceed if the CBOR item to be decoded is a big number, positive or negative (tag 2 or tag 3).
QCBOR_CONVERT_TYPE_DECIMAL_FRACTION	Conversion will proceed if the CBOR item to be decoded is a decimal fraction (tag 4).
QCBOR_CONVERT_TYPE_BIGFLOAT	Conversion will proceed if the CBOR item to be decoded is a big float (tag 5).

Function Documentation

QCBOR_Int64ToInt32()

static int QCBOR_Int64ToInt32 ( int64_t src, int32_t * dest )

inlinestatic

Convert int64_t to smaller integers safely.

Parameters

[in]	src	An int64_t.
[out]	dest	A smaller sized integer to convert to.

Returns

0 on success -1 if not

When decoding an integer, the CBOR decoder will return the value as an int64_t unless the integer is in the range of INT64_MAX and UINT64_MAX. That is, unless the value is so large that it can only be represented as a uint64_t, it will be an int64_t.

CBOR itself doesn't size the individual integers it carries at all. The only limits it puts on the major integer types is that they are 8 bytes or less in length. Then encoders like this one use the smallest number of 1, 2, 4 or 8 bytes to represent the integer based on its value. There is thus no notion that one data item in CBOR is a 1-byte integer and another is a 4-byte integer.

The interface to this CBOR encoder only uses 64-bit integers. Some CBOR protocols or implementations of CBOR protocols may not want to work with something smaller than a 64-bit integer. Perhaps an array of 1,000 integers needs to be sent and none has a value larger than 50,000 and are represented as uint16_t.

The sending / encoding side is easy. Integers are temporarily widened to 64-bits as a parameter passing through QCBOREncode_AddInt64() and encoded in the smallest way possible for their value, possibly in less than an uint16_t.

On the decoding side the integers will be returned at int64_t even if they are small and were represented by only 1 or 2 bytes in the encoded CBOR. The functions here will convert integers to a small representation with an overflow check.

(The decoder could have support 8 different integer types and represented the integer with the smallest type automatically, but this would have made the decoder more complex and code calling the decoder more complex in most use cases. In most use cases on 64-bit machines it is no burden to carry around even small integers as 64-bit values).

QCBORDecode_GetBigFloat()

static void QCBORDecode_GetBigFloat ( QCBORDecodeContext * pCtx, const enum QCBORDecodeTagReq uTagRequirement, int64_t * pnMantissa, int64_t * pnExponent )

inlinestatic

[Deprecated] Decode a big float.

Deprecated

. Use QCBORDecode_GetTBigFloat() instead.

QCBORDecode_GetBigFloatBig()

static void QCBORDecode_GetBigFloatBig ( QCBORDecodeContext * pCtx, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC * pMantissa, bool * pbMantissaIsNegative, int64_t * pnExponent )

inlinestatic

[Depreacted] Decode big float with a big number mantissa.

Deprecated

. Use QCBORDecode_GetTBigFloatBigMantissaRaw() instead.

QCBORDecode_GetBigFloatBigInMapN()

static void QCBORDecode_GetBigFloatBigInMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC * pMantissa, bool * pbMantissaIsNegative, int64_t * pnExponent )

inlinestatic

Deprecated

. Use QCBORDecode_GetTBigFloatBigMantissaRawInMapN() instead.

QCBORDecode_GetBigFloatBigInMapSZ()

static void QCBORDecode_GetBigFloatBigInMapSZ ( QCBORDecodeContext * pCtx, const char * szLabel, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC * pMantissa, bool * pbMantissaIsNegative, int64_t * pnExponent )

inlinestatic

Deprecated

. Use QCBORDecode_GetTBigFloatBigMantissaRawInMapSZ() instead.

QCBORDecode_GetBigFloatInMapN()

static void QCBORDecode_GetBigFloatInMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, const enum QCBORDecodeTagReq uTagRequirement, int64_t * pnMantissa, int64_t * pnExponent )

inlinestatic

Deprecated

. Use QCBORDecode_GetTBigFloatInMapN() instead.

QCBORDecode_GetBigFloatInMapSZ()

static void QCBORDecode_GetBigFloatInMapSZ ( QCBORDecodeContext * pCtx, const char * szLabel, const enum QCBORDecodeTagReq uTagRequirement, int64_t * pnMantissa, int64_t * pnExponent )

inlinestatic

Deprecated

. Use QCBORDecode_GetTBigFloatInMapSZ() instead.

QCBORDecode_GetBignum()

static void QCBORDecode_GetBignum ( QCBORDecodeContext * pCtx, enum QCBORDecodeTagReq uTagRequirement, UsefulBufC * pValue, bool * pbIsNegative )

inlinestatic

[Deprecated] Decode big number with no processing.

Deprecated

Use QCBORDecode_GetTBigNumberRaw() instead.

QCBORDecode_GetBignumInMapN()

static void QCBORDecode_GetBignumInMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBufC * pValue, bool * pbIsNegative )

inlinestatic

Deprecated

. Use QCBORDecode_GetTBigNumberRawInMapN() instead.

QCBORDecode_GetBignumInMapSZ()

static void QCBORDecode_GetBignumInMapSZ ( QCBORDecodeContext * pCtx, const char * szLabel, enum QCBORDecodeTagReq uTagRequirement, UsefulBufC * pValue, bool * pbIsNegative )

inlinestatic

Deprecated

. Use QCBORDecode_GetTBigNumberRawInMapSZ() instead.

QCBORDecode_GetDecimalFraction()

static void QCBORDecode_GetDecimalFraction ( QCBORDecodeContext * pCtx, enum QCBORDecodeTagReq uTagRequirement, int64_t * pnMantissa, int64_t * pnExponent )

inlinestatic

[Deprecated] Decode a decimal fraction.

Deprecated

. Use QCBORDecode_GetTDecimalFraction() instead.

QCBORDecode_GetDecimalFractionBig()

static void QCBORDecode_GetDecimalFractionBig ( QCBORDecodeContext * pCtx, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC * pMantissa, bool * pbMantissaIsNegative, int64_t * pnExponent )

inlinestatic

[Deprecated] Decode a decimal fraction with big number mantissa.

Deprecated

. Use QCBORDecode_GetTDecimalFractionBigMantissaRaw() instead.

For QCBOR before v1.5, this function had a bug where by the negative mantissa sometimes had the offset of one applied, making this function somewhat usless for negative mantissas. Specifically if the to-be-decode CBOR was a type 1 integer the offset was applied and when it was a tag 3, the offset was not applied. It is possible that a tag 3 could contain a value in the range of a type 1 integer. QCBORExpAndMantissa is correct and can be used instead of this.

QCBORDecode_GetDecimalFractionBigInMapN()

static void QCBORDecode_GetDecimalFractionBigInMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC * pbMantissaIsNegative, bool * pbIsNegative, int64_t * pnExponent )

inlinestatic

Deprecated

. Use QCBORDecode_GetTDecimalFractionBigMantissaRawInMapN()

QCBORDecode_GetDecimalFractionBigInMapSZ()

static void QCBORDecode_GetDecimalFractionBigInMapSZ ( QCBORDecodeContext * pCtx, const char * szLabel, const enum QCBORDecodeTagReq uTagRequirement, UsefulBuf MantissaBuffer, UsefulBufC * pMantissa, bool * pbMantissaIsNegative, int64_t * pnExponent )

inlinestatic

Deprecated

. Use QCBORDecode_GetTDecimalFractionBigMantissaRawInMapSZ()

QCBORDecode_GetDecimalFractionInMapN()

static void QCBORDecode_GetDecimalFractionInMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, enum QCBORDecodeTagReq uTagRequirement, int64_t * pnMantissa, int64_t * pnExponent )

inlinestatic

Deprecated

. Use QCBORDecode_GetTDecimalFractionInMapN() instead.

QCBORDecode_GetDecimalFractionInMapSZ()

static void QCBORDecode_GetDecimalFractionInMapSZ ( QCBORDecodeContext * pMe, const char * szLabel, enum QCBORDecodeTagReq uTagRequirement, int64_t * pnMantissa, int64_t * pnExponent )

inlinestatic

Deprecated

. Use QCBORDecode_GetTDecimalFractionInMapSZ() instead.

QCBORDecode_GetDouble()

static void QCBORDecode_GetDouble ( QCBORDecodeContext * pCtx, double * pValue )

inlinestatic

Decode next item into a double floating-point value.

Parameters

[in]	pCtx	The decode context.
[out]	pValue	The returned floating-point value.

The CBOR data item to decode must be a half-precision, single-precision or double-precision floating-point value. If not QCBOR_ERR_UNEXPECTED_TYPE is set.

If floating-point HW use is disabled this will set QCBOR_ERR_HW_FLOAT_DISABLED if a single-precision number is encountered. If half-precision support is disabled, this will set QCBOR_ERR_HALF_PRECISION_DISABLED if a half-precision number is encountered.

Please see Decode Errors Overview.

See also QCBORDecode_GetDoubleConvert() and QCBORDecode_GetDoubleConvertAll().

QCBORDecode_GetDoubleConvert()

static void QCBORDecode_GetDoubleConvert ( QCBORDecodeContext * pCtx, enum QCBORDecodeNumberConvert uConvertTypes, double * pdValue )

inlinestatic

Decode next item into a double floating-point with basic conversion.

Parameters

[in]	pCtx	The decode context.
[in]	uConvertTypes	See QCBORDecodeNumberConvert.
[out]	pdValue	The returned floating-point value.

This will decode CBOR integer and floating-point numbers, returning them as a double floating-point number. This function supports

QCBOR_CONVERT_TYPE_XINT64 and QCBOR_CONVERT_TYPE_FLOAT conversions. If the encoded CBOR is not one of the requested types or a type not supported by this function, QCBOR_ERR_UNEXPECTED_TYPE is set.

Please see Decode Errors Overview.

If floating-point HW use is disabled this will set QCBOR_ERR_HW_FLOAT_DISABLED if a single-precision number is encountered. If half-precision support is disabled, this will set QCBOR_ERR_HALF_PRECISION_DISABLED if a half-precision number is encountered.

Positive and negative integers can always be converted to floating-point, so this will never error on CBOR major type 0 or 1.

Note that a large 64-bit integer can have more precision (64 bits) than even a double floating-point (52 bits) value, so there is loss of precision in some conversions.

See also QCBORDecode_GetDouble() and QCBORDecode_GetDoubleConvertAll().

QCBORDecode_GetDoubleConvertAll()

void QCBORDecode_GetDoubleConvertAll	(	QCBORDecodeContext *	pCtx,
		const enum QCBORDecodeNumberConvert	uConvertTypes,
		double *	pdValue )

Decode next item as a double floating-point value with conversion.

Parameters

[in]	pCtx	The decode context.
[in]	uConvertTypes	See QCBORDecodeNumberConvert.
[out]	pdValue	The returned floating-point value.

This is the same as QCBORDecode_GetDoubleConvert() but supports many more conversions at the cost of linking in more object code. The conversion types supported are QCBOR_CONVERT_TYPE_XINT64, QCBOR_CONVERT_TYPE_FLOAT, QCBOR_CONVERT_TYPE_BIG_NUM, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION and QCBOR_CONVERT_TYPE_BIGFLOAT.

Big numbers, decimal fractions and big floats that are too small or too large to be reprented as a double floating-point number will be returned as plus or minus zero or infinity rather than setting an under or overflow error.

There is often loss of precision in the conversion.

See also QCBORDecode_GetDoubleConvert() and QCBORDecode_GetDoubleConvert().

QCBORDecode_GetDoubleConvertAllInMapN()

void QCBORDecode_GetDoubleConvertAllInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		const enum QCBORDecodeNumberConvert	uConvertTypes,
		double *	pdValue )

See QCBORDecode_GetDoubleConvertAll().

QCBORDecode_GetDoubleConvertAllInMapSZ()

void QCBORDecode_GetDoubleConvertAllInMapSZ	(	QCBORDecodeContext *	pCtx,
		const char *	szLabel,
		const enum QCBORDecodeNumberConvert	uConvertTypes,
		double *	pdValue )

See QCBORDecode_GetDoubleConvertAll().

QCBORDecode_GetDoubleConvertInMapN()

static void QCBORDecode_GetDoubleConvertInMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, enum QCBORDecodeNumberConvert uConvertTypes, double * pdValue )

inlinestatic

See QCBORDecode_GetDoubleConvert().

QCBORDecode_GetDoubleConvertInMapSZ()

static void QCBORDecode_GetDoubleConvertInMapSZ ( QCBORDecodeContext * pCtx, const char * szLabel, enum QCBORDecodeNumberConvert uConvertTypes, double * pdValue )

inlinestatic

See QCBORDecode_GetDoubleConvert().

QCBORDecode_GetDoubleInMapN()

static void QCBORDecode_GetDoubleInMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, double * pdValue )

inlinestatic

See QCBORDecode_GetDouble().

QCBORDecode_GetDoubleInMapSZ()

static void QCBORDecode_GetDoubleInMapSZ ( QCBORDecodeContext * pCtx, const char * szLabel, double * pdValue )

inlinestatic

See QCBORDecode_GetDouble().

QCBORDecode_GetInt64()

static void QCBORDecode_GetInt64 ( QCBORDecodeContext * pCtx, int64_t * pnValue )

inlinestatic

Decode next item into a signed 64-bit integer.

Parameters

[in]	pCtx	The decode context.
[out]	pnValue	The returned 64-bit signed integer.

The CBOR data item to decode must be a positive or negative integer (CBOR major type 0 or 1). If not QCBOR_ERR_UNEXPECTED_TYPE is set.

If the CBOR integer is either too large or too small to fit in an int64_t, the error QCBOR_ERR_INT_OVERFLOW or QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW is set. Note that type 0 unsigned integers can be larger than will fit in an int64_t and type 1 negative integers can be smaller than will fit in an int64_t.

Please see Decode Errors Overview.

See also QCBORDecode_GetUInt64(), QCBORDecode_GetInt64Convert(), QCBORDecode_GetInt64ConvertAll() and QCBORDecode_GetDoubleConvert()

QCBORDecode_GetInt64Convert()

static void QCBORDecode_GetInt64Convert ( QCBORDecodeContext * pCtx, enum QCBORDecodeNumberConvert uConvertTypes, int64_t * pnValue )

inlinestatic

Decode next item into a signed 64-bit integer with basic conversions.

Parameters

[in]	pCtx	The decode context.
[in]	uConvertTypes	See QCBORDecodeNumberConvert.
[out]	pnValue	The returned 64-bit signed integer.

uConvertTypes controls what conversions this will perform and thus what CBOR types will be decoded. uConvertType is a bit map listing the conversions to be allowed. This function supports QCBOR_CONVERT_TYPE_XINT64 and QCBOR_CONVERT_TYPE_FLOAT conversions.

Please see Decode Errors Overview.

If the CBOR data type can never be convered by this function or the conversion was not selected in uConversionTypes QCBOR_ERR_UNEXPECTED_TYPE is set.

When converting floating-point values, the integer is rounded to the nearest integer using llround(). By default, floating-point suport is enabled for QCBOR.

If floating-point HW use is disabled this will set QCBOR_ERR_HW_FLOAT_DISABLED if a single-precision number is encountered. If half-precision support is disabled, this will set QCBOR_ERR_HALF_PRECISION_DISABLED if a half-precision number is encountered.

If floating-point usage is disabled this will set QCBOR_ERR_ALL_FLOAT_DISABLED if a floating point value is encountered.

See also QCBORDecode_GetInt64ConvertAll() which will perform the same conversions as this and a lot more at the cost of adding more object code to your executable.

QCBORDecode_GetInt64ConvertAll()

void QCBORDecode_GetInt64ConvertAll	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeNumberConvert	uConvertTypes,
		int64_t *	pnValue )

Decode next item into a signed 64-bit integer with conversions.

Parameters

[in]	pCtx	The decode context.
[in]	uConvertTypes	See QCBORDecodeNumberConvert.
[out]	pnValue	The returned 64-bit signed integer.

This is the same as QCBORDecode_GetInt64Convert() but additionally supports conversion from positive and negative bignums, decimal fractions and big floats, including decimal fractions and big floats that use bignums. The conversion types supported are QCBOR_CONVERT_TYPE_XINT64, QCBOR_CONVERT_TYPE_FLOAT, QCBOR_CONVERT_TYPE_BIG_NUM, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION and QCBOR_CONVERT_TYPE_BIGFLOAT.

Please see Decode Errors Overview.

Note that most these types can support numbers much larger that can be represented by in a 64-bit integer, so QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW may often be encountered.

When converting bignums and decimal fractions, QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW will be set if the result is below 1, unless the mantissa is zero, in which case the coversion is successful and the value of 0 is returned.

See also QCBORDecode_GetInt64ConvertAll() which does some of these conversions, but links in much less object code. See also QCBORDecode_GetUInt64ConvertAll().

This relies on CBOR tags to identify big numbers, decimal fractions and big floats. It will not attempt to decode non-tag CBOR that might be one of these. (If QCBOR_DISABLE_TAGS is set, this is effectively the same as QCBORDecode_GetInt64Convert() because all the additional number types this decodes are tags).

QCBORDecode_GetInt64ConvertAllInMapN()

void QCBORDecode_GetInt64ConvertAllInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		enum QCBORDecodeNumberConvert	uConvertTypes,
		int64_t *	pnValue )

See QCBORDecode_GetInt64ConvertAll().

QCBORDecode_GetInt64ConvertAllInMapSZ()

void QCBORDecode_GetInt64ConvertAllInMapSZ	(	QCBORDecodeContext *	pCtx,
		const char *	szLabel,
		enum QCBORDecodeNumberConvert	uConvertTypes,
		int64_t *	pnValue )

See QCBORDecode_GetInt64ConvertAll().

QCBORDecode_GetInt64ConvertInMapN()

static void QCBORDecode_GetInt64ConvertInMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, enum QCBORDecodeNumberConvert uConvertTypes, int64_t * pnValue )

inlinestatic

See QCBORDecode_GetInt64Convert().

QCBORDecode_GetInt64ConvertInMapSZ()

static void QCBORDecode_GetInt64ConvertInMapSZ ( QCBORDecodeContext * pCtx, const char * szLabel, enum QCBORDecodeNumberConvert uConvertTypes, int64_t * pnValue )

inlinestatic

See QCBORDecode_GetInt64Convert().

QCBORDecode_GetInt64InMapN()

static void QCBORDecode_GetInt64InMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, int64_t * pnValue )

inlinestatic

See QCBORDecode_GetInt64().

QCBORDecode_GetInt64InMapSZ()

static void QCBORDecode_GetInt64InMapSZ ( QCBORDecodeContext * pCtx, const char * szLabel, int64_t * pnValue )

inlinestatic

See QCBORDecode_GetInt64().

QCBORDecode_GetNumberConvertPrecisely()

void QCBORDecode_GetNumberConvertPrecisely	(	QCBORDecodeContext *	pCtx,
		QCBORItem *	pNumber )

dCBOR Decode next as a number with precision-preserving conversions.

Parameters

[in]	pCtx	The decode context.
[out]	pNumber	The returned number.

This gets the next item as a number and returns it as a C data type such that no precision is lost.

This is primarily works with integers and floats for both the to-be-decoded CBOR and the decoded types.

The CBOR input can be integers (major type 0 or 1) or floats (major type 7). If not these, QCBOR_ERR_UNEXPECTED_TYPE will be set.

The conversion is as follows.

Whole numbers from INT64_MIN to INT64_MAX will be returned as int64_t indicated as QCBOR_TYPE_INT64. This includes conversion of floating-point values that are whole numbers.

Whole numbers from INT64_MAX +1 to UINT64_MAX will be returned as uint64_t indicated as QCBOR_TYPE_UINT64, again including conversion of floating-point values that are whole numbers.

Most other numbers are returned as a double as indicated by QCBOR_TYPE_DOUBLE floating point with one set of exceptions.

The exception is negative whole numbers in the range of -(2^63 + 1) to -(2^64) that have too much precision to be represented as a double. Doubles have only 52 bits of precision, so they can't precisely represent every whole integer in this range. CBOR can represent these values with 64-bits of precision and when this function encounters them they are returned as QCBOR_TYPE_65BIT_NEG_INT. See the description of this type for instructions to gets its value. Also see QCBORDecode_ProcessBigNumber().

To give an example, the value -18446744073709551616 can't be represented by an int64_t or uint64_t, but can be represented by a double so it is returned by this function as a double. The value -18446744073709551617 however can't be represented by a double because it has too much precision, so it is returned as QCBOR_TYPE_65BIT_NEG_INT.

This is useful for DCBOR which essentially combines floats and integers into one number space.

Please see Decode Errors Overview.

See also QCBORDecode_GetNumberConvertPreciselyBig().

QCBORDecode_GetTBigFloat()

void QCBORDecode_GetTBigFloat	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeTagReq	uTagRequirement,
		int64_t *	pnMantissa,
		int64_t *	pnExponent )

Decode the next item as a big float.

Parameters

[in]	pCtx	The decode context.
[in]	uTagRequirement	See QCBORDecodeTagReq.
[out]	pnMantissa	The mantissa.
[out]	pnExponent	The base 2 exponent.

The input to decode must be a big float defined in [RFC 8949 section 3.4.4] (https://www.rfc-editor.org/rfc/rfc8949.html#section-3.4.4). That is, an array of two numbers, the first of which is the exponent and the second is the mantissa.

Depending on uTagRequirement, the tag number CBOR_TAG_BIGFLOAT (5) may or may not need to be present before the array. See QCBORDecodeTagReq.

The exponent must always be an integer (CBOR type 0 or 1). The mantissa may be an integer or a big number. If it is a big number, the tag number 2 or 3 must be present.

This implementation limits the exponent to between INT64_MIN and INT64_MAX while CBOR allows the range of -UINT64_MAX to UINT64_MAX.

The mantissa is always returned as an int64_t. If the value won't fit, QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW will be set. Use QCBORDecode_GetBigFloastBigNumber() to avoid the limit to int64_t.

mantissa * ( 2 ** exponent )

Various format and type issues will result in QCBOR_ERR_BAD_EXP_AND_MANTISSA being set. See Decode Errors Overview.

See also QCBORDecode_GetInt64ConvertAll(), QCBORDecode_GetUInt64ConvertAll() and QCBORDecode_GetDoubleConvertAll() which can convert big floats.

See also CBOR_TAG_BIGFLOAT, QCBOREncode_AddTBigFloat(), QCBOR_TYPE_BIGFLOAT and QCBORDecode_GetTBigFloatBigMantissa().

If QCBOR_DISABLE_TAGS is set, the only input this will decode is an array of two integers. It will set an error if the the array is preceded by by a tag number or if the mantissa is a big number.

QCBORDecode_GetTBigFloatBigMantissa()

void QCBORDecode_GetTBigFloatBigMantissa	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pMantissa,
		bool *	pbMantissaIsNegative,
		int64_t *	pnExponent )

Decode the next item as a big float with a big number mantissa.

Parameters

[in]	pCtx	The decode context.
[in]	uTagRequirement	See QCBORDecodeTagReq.
[in]	MantissaBuffer	The buffer in which to put the mantissa.
[out]	pMantissa	The big num mantissa.
[out]	pbMantissaIsNegative	Is true if pMantissa is negative.
[out]	pnExponent	The base 2 exponent.

This is the same as QCBORDecode_GetTBigFloat() except the mantissa is returned as a big number. The only limit to precision is the size of MantissaBuffer.

The encoded mantissa may be an integer or a big number. The standard CBOR offset of 1 for negative is applied, so the mantissa can be used as returned.

See also CBOR_TAG_BIGFLOAT, QCBOREncode_AddTBigFloatBigNumber(), QCBOR_TYPE_BIGFLOAT and QCBORDecode_GetTBigFloat().

QCBORDecode_GetTBigFloatBigMantissaInMapN()

void QCBORDecode_GetTBigFloatBigMantissaInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pMantissa,
		bool *	pbMantissaIsNegative,
		int64_t *	pnExponent )

See QCBORDecode_GetTBigFloatBigMantissa().

QCBORDecode_GetTBigFloatBigMantissaInMapSZ()

void QCBORDecode_GetTBigFloatBigMantissaInMapSZ	(	QCBORDecodeContext *	pCtx,
		const char *	szLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pMantissa,
		bool *	pbMantissaIsNegative,
		int64_t *	pnExponent )

See QCBORDecode_GetTBigFloatBigMantissa().

QCBORDecode_GetTBigFloatBigMantissaRaw()

void QCBORDecode_GetTBigFloatBigMantissaRaw	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pMantissa,
		bool *	pbMantissaIsNegative,
		int64_t *	pnExponent )

Decode the next item as a big float with a big number mantissa with out offsetting the mantissa.

Parameters

[in]	pCtx	The decode context.
[in]	uTagRequirement	See QCBORDecodeTagReq.
[in]	MantissaBuffer	The buffer in which to put the mantissa.
[out]	pMantissa	The big num mantissa.
[out]	pbMantissaIsNegative	Is true if pMantissa is negative.
[out]	pnExponent	The base 2 exponent.

This is the same as QCBORDecode_GetBigFloat() except the mantissa is returned as a big number. The only limit to precision is the size of MantissaBuffer.

The encoded mantissa may be an integer or a big number. The standard CBOR offset of 1 for negative is NOT applied. If the ma mantissa is negative, one must be added to get it's actual value.

Because this doesn't offset the negative big numbers, this links in a lot less object code. It is suitable for uses where a big number library is already linked in for other purposes as it can trivially do the increment by one.

See also CBOR_TAG_BIGFLOAT, QCBOREncode_AddTBigFloatBigNumber(), QCBOR_TYPE_BIGFLOAT and QCBORDecode_GetTBigFloat().

QCBORDecode_GetTBigFloatBigMantissaRawInMapN()

void QCBORDecode_GetTBigFloatBigMantissaRawInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pMantissa,
		bool *	pbMantissaIsNegative,
		int64_t *	pnExponent )

See QCBORDecode_GetTBigFloatBigMantissaRaw().

QCBORDecode_GetTBigFloatBigMantissaRawInMapSZ()

void QCBORDecode_GetTBigFloatBigMantissaRawInMapSZ	(	QCBORDecodeContext *	pCtx,
		const char *	szLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pMantissa,
		bool *	pbMantissaIsNegative,
		int64_t *	pnExponent )

See QCBORDecode_GetTBigFloatBigMantissaRaw().

QCBORDecode_GetTBigFloatInMapN()

void QCBORDecode_GetTBigFloatInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		int64_t *	pnMantissa,
		int64_t *	pnExponent )

See QCBORDecode_GetTBigFloat().

QCBORDecode_GetTBigFloatInMapSZ()

void QCBORDecode_GetTBigFloatInMapSZ	(	QCBORDecodeContext *	pCtx,
		const char *	szLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		int64_t *	pnMantissa,
		int64_t *	pnExponent )

See QCBORDecode_GetTBigFloat().

QCBORDecode_GetTBigNumber()

void QCBORDecode_GetTBigNumber	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	BigNumberBuf,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

Decode next item as a big number encoded using preferred serialization.

Parameters

[in]	pCtx	The decode context.
[in]	uTagRequirement	See QCBORDecodeTagReq.
[in]	BigNumberBuf	The buffer to write the result into.
[out]	pBigNumber	The decoded big number, most significant byte first (network byte order).
[in,out]	pbIsNegative	Set to true if the resulting big number is negative.

This decodes CBOR tag numbers 2 and 3, positive and negative big numbers, as defined in [RFC 8949 section 3.4.3] (https://www.rfc-editor.org/rfc/rfc8949.html#section-3.4.3). This decodes preferred serialization described specifically for big numbers.

See QCBORDecode_PreferedBigNumber() which performs the bulk of this.

The type processing rules are as follows.

This always succeeds on type 0 and 1 integers (QCBOR_TYPE_INT64, QCBOR_TYPE_UINT64 and QCBOR_TYPE_65BIT_NEG_INT) no matter what uTagRequirement is. The rest of the rules pertain to what happens if the CBOR is not type 0 or type 1.

If uTagRequirement is QCBOR_TAG_REQUIREMENT_TAG, this expects a full tag 2 or tag 3 big number.

If uTagRequreiement is QCBOR_TAG_REQUIREMENT_NOT_A_TAG then this expects a byte string.

If QCBOR_TAG_REQUIREMENT_OPTIONAL_TAG, then this will succeed on either a byte string or a tag 2 or 3.

If the item is a bare byte string, not a tag 2 or 3, then pbIsNegative is an input parameter that determines the sign of the big number. The sign must be known because the decoding of a positive big number is different than a negative.

This works whether or not QCBORDecode_StringsTagCB() is installed to process tags 2 and 3.

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

Please see Decode Errors Overview.

See QCBORDecodeTagReq for discussion on tag requirements.

QCBORDecode_GetTBigNumberInMapN()

void QCBORDecode_GetTBigNumberInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	BigNumberBuf,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

See QCBORDecode_GetTBigNumber().

QCBORDecode_GetTBigNumberInMapSZ()

void QCBORDecode_GetTBigNumberInMapSZ	(	QCBORDecodeContext *	pCtx,
		const char *	szLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	BigNumberBuf,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

See QCBORDecode_GetTBigNumber().

QCBORDecode_GetTBigNumberNoPreferred()

void QCBORDecode_GetTBigNumberNoPreferred	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	BigNumberBuf,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

Decode next item as a big number without preferred serialization.

Parameters

[in]	pCtx	The decode context.
[in]	uTagRequirement	See QCBORDecodeTagReq.
[in]	BigNumberBuf	The buffer to write the result into.
[out]	pBigNumber	The decoded big number, most significant byte first (network byte order).
[in,out]	pbIsNegative	Set to true if the returned big number is negative.

This is the same as QCBORDecode_GetTBigNumber(), but will error out on type 0 and 1 integers as it doesn't support the preferred serialization specific for big numbers.

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

QCBORDecode_GetTBigNumberNoPreferredInMapN()

void QCBORDecode_GetTBigNumberNoPreferredInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	BigNumberBuf,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

See QCBORDecode_GetTBigNumberNoPreferred().

QCBORDecode_GetTBigNumberNoPreferredInMapSZ()

void QCBORDecode_GetTBigNumberNoPreferredInMapSZ	(	QCBORDecodeContext *	pCtx,
		const char *	szLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	BigNumberBuf,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

See QCBORDecode_GetTBigNumberNoPreferred().

QCBORDecode_GetTBigNumberRaw()

void QCBORDecode_GetTBigNumberRaw	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

Decode the next item as a big number with no processing.

Parameters

[in]	pCtx	The decode context.
[in]	uTagRequirement	See QCBORDecodeTagReq.
[out]	pBigNumber	The decoded big number, most significant byte first (network byte order).
[out]	pbIsNegative	Is true if the big number is negative. This is only valid when uTagRequirement is QCBOR_TAG_REQUIREMENT_TAG.

This decodes CBOR tag numbers 2 and 3, positive and negative big numbers, as defined in [RFC 8949 section 3.4.3] (https://www.rfc-editor.org/rfc/rfc8949.html#section-3.4.3).

This returns the byte string representing the big number directly. It does not apply the required the offset of one for negative big numbers. It will error out big numbers that have been encoded as type 0 and 1 integer because of big number preferred serialization.

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.

This links in much less object code than QCBORDecode_GetTBigNumber() and QCBORDecode_GetTBigNumberNoPreferred().

This does the same minimal processing as installing QCBORDecode_StringsTagCB() installed to handle CBOR_TAG_POS_BIGNUM and CBOR_TAG_NEG_BIGNUM so QCBORDecode_VGetNext() returns a QCBORItem of type QCBOR_TYPE_POSBIGNUM or QCBOR_TYPE_POSBIGNUM

See BigNumbers for a useful overview of CBOR big numbers and QCBOR's support for them. See QCBOREncode_AddTBigNumberRaw() for the encoding counter part. See QCBORDecode_GetTBigNumber() which does perform the offset for negative numbers and handles preferred serialization big numbers.

Please see Decode Errors Overview.

QCBORDecode_GetTBigNumberRawInMapN()

void QCBORDecode_GetTBigNumberRawInMapN	(	QCBORDecodeContext *	pMe,
		const int64_t	nLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

See QCBORDecode_GetTBigNumberRaw().

QCBORDecode_GetTBigNumberRawInMapSZ()

void QCBORDecode_GetTBigNumberRawInMapSZ	(	QCBORDecodeContext *	pMe,
		const char *	szLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

See QCBORDecode_GetTBigNumberRaw().

QCBORDecode_GetTDecimalFraction()

void QCBORDecode_GetTDecimalFraction	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeTagReq	uTagRequirement,
		int64_t *	pnMantissa,
		int64_t *	pnExponent )

Decode the next item as a decimal fraction.

Parameters

[in]	pCtx	The decode context.
[in]	uTagRequirement	See QCBORDecodeTagReq.
[out]	pnMantissa	The mantissa.
[out]	pnExponent	The base 10 exponent.

The input to decode must be a decimal fraction as defined in [RFC 8949 section 3.4.4] (https://www.rfc-editor.org/rfc/rfc8949.html#section-3.4.4). That is, an array of two numbers, the first of which is the exponent and the second is the mantissa.

Depending on uTagRequirement, the tag number CBOR_TAG_DECIMAL_FRACTION (4) may or may not need to be present before the array. See QCBORDecodeTagReq.

The exponent must always be an integer (CBOR type 0 or 1). The mantissa may be an integer or a big number. If it is a big number, the tag number 2 or 3 must be present.

The exponent is limited to between INT64_MIN and INT64_MAX while CBOR allows the range of -UINT64_MAX to UINT64_MAX.

The mantissa is always returned as an int64_t. If the value won't fit, QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW will be set. Use QCBORDecode_GetTDecimalFractionBigMantissa() to avoid the limit to int64_t.

The value of this is computed by:

mantissa * ( 10 ** exponent )

Various format and type issues will result in QCBOR_ERR_BAD_EXP_AND_MANTISSA being set. See Decode Errors Overview.

See also QCBORDecode_GetInt64ConvertAll(), QCBORDecode_GetUInt64ConvertAll() and QCBORDecode_GetDoubleConvertAll() which can also decode decimal fractions.

See also CBOR_TAG_DECIMAL_FRACTION, QCBOREncode_AddTDecimalFraction(), QCBOR_TYPE_DECIMAL_FRACTION.

If QCBOR_DISABLE_TAGS is set, the only input this will decode is an array of two integers. It will set an error if the the array is preceded by by a tag number or if the mantissa is a big number.

QCBORDecode_GetTDecimalFractionBigMantissa()

void QCBORDecode_GetTDecimalFractionBigMantissa	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pMantissa,
		bool *	pbMantissaIsNegative,
		int64_t *	pnExponent )

Decode the next item as a decimal fraction with a big number mantissa.

Parameters

[in]	pCtx	The decode context.
[in]	uTagRequirement	See QCBORDecodeTagReq.
[in]	MantissaBuffer	The buffer in which to put the mantissa.
[out]	pMantissa	The big num mantissa.
[out]	pbMantissaIsNegative	Is true if pMantissa is negative.
[out]	pnExponent	The base 10 exponent.

This is the same as QCBORDecode_GetTDecimalFraction() except the mantissa is returned as a big number.

In the encoded CBOR, the mantissa may be a type 0 (positive integer), type 1 (negative integer), type 2 tag 2 (positive big number) or type 2 tag 3 (negative big number). This implementation will convert all these to a big number. The limit to this conversion is the size of MantissaBuffer.

See also QCBORDecode_GetInt64ConvertAll(), QCBORDecode_GetUInt64ConvertAll() and QCBORDecode_GetDoubleConvertAll() which can convert decimal fractions.

See also CBOR_TAG_DECIMAL_FRACTION, QCBOREncode_AddTDecimalFractionBigMantissa(), QCBOR_TYPE_DECIMAL_FRACTION and QCBORDecode_GetTDecimalFraction().

QCBORDecode_GetTDecimalFractionBigMantissaInMapN()

void QCBORDecode_GetTDecimalFractionBigMantissaInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pbMantissaIsNegative,
		bool *	pbIsNegative,
		int64_t *	pnExponent )

See QCBORDecode_GetTDecimalFractionBigMantissa().

QCBORDecode_GetTDecimalFractionBigMantissaInMapSZ()

void QCBORDecode_GetTDecimalFractionBigMantissaInMapSZ	(	QCBORDecodeContext *	pCtx,
		const char *	szLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pMantissa,
		bool *	pbMantissaIsNegative,
		int64_t *	pnExponent )

See QCBORDecode_GetTDecimalFractionBigMantissa().

QCBORDecode_GetTDecimalFractionBigMantissaRaw()

void QCBORDecode_GetTDecimalFractionBigMantissaRaw	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pMantissa,
		bool *	pbMantissaIsNegative,
		int64_t *	pnExponent )

Decode the next item as a decimal fraction with a big number. mantissa raw.

Parameters

[in]	pCtx	The decode context.
[in]	uTagRequirement	See QCBORDecodeTagReq.
[in]	MantissaBuffer	The buffer in which to put the mantissa.
[out]	pMantissa	The big num mantissa.
[out]	pbMantissaIsNegative	Is true if pMantissa is negative.
[out]	pnExponent	The base 10 exponent.

This is the same as QCBORDecode_GetTDecimalFractionBigMantissa() except the negative mantissas are NOT offset by one and this links in less object code.

In the encoded CBOR, the mantissa may be a type 0 (positive integer), type 1 (negative integer), type 2 tag 2 (positive big number) or type 2 tag 3 (negative big number). This implementation will convert all these to a big number. The limit to this conversion is the size of MantissaBuffer.

See also QCBORDecode_GetInt64ConvertAll(), QCBORDecode_GetUInt64ConvertAll() and QCBORDecode_GetDoubleConvertAll() which can convert decimal fractions.

See also CBOR_TAG_DECIMAL_FRACTION, QCBOREncode_AddTDecimalFractionBigMantissaRaw(), QCBOR_TYPE_DECIMAL_FRACTION and QCBORDecode_GetTDecimalFractionBigMantissa().

QCBORDecode_GetTDecimalFractionBigMantissaRawInMapN()

void QCBORDecode_GetTDecimalFractionBigMantissaRawInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pbMantissaIsNegative,
		bool *	pbIsNegative,
		int64_t *	pnExponent )

See QCBORDecode_GetTDecimalFractionBigMantissaRaw().

QCBORDecode_GetTDecimalFractionBigMantissaRawInMapSZ()

void QCBORDecode_GetTDecimalFractionBigMantissaRawInMapSZ	(	QCBORDecodeContext *	pCtx,
		const char *	szLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		UsefulBuf	MantissaBuffer,
		UsefulBufC *	pMantissa,
		bool *	pbMantissaIsNegative,
		int64_t *	pnExponent )

See QCBORDecode_GetTDecimalFractionBigMantissaRaw().

QCBORDecode_GetTDecimalFractionInMapN()

void QCBORDecode_GetTDecimalFractionInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		int64_t *	pnMantissa,
		int64_t *	pnExponent )

See QCBORDecode_GetTDecimalFraction().

QCBORDecode_GetTDecimalFractionInMapSZ()

void QCBORDecode_GetTDecimalFractionInMapSZ	(	QCBORDecodeContext *	pMe,
		const char *	szLabel,
		enum QCBORDecodeTagReq	uTagRequirement,
		int64_t *	pnMantissa,
		int64_t *	pnExponent )

See QCBORDecode_GetTDecimalFraction().

QCBORDecode_GetUInt64()

static void QCBORDecode_GetUInt64 ( QCBORDecodeContext * pCtx, uint64_t * puValue )

inlinestatic

Decode next item into an unsigned 64-bit integer.

Parameters

[in]	pCtx	The decode context.
[out]	puValue	The returned 64-bit unsigned integer.

This is the same as QCBORDecode_GetInt64(), but returns an unsigned integer and thus can only decode CBOR positive integers. QCBOR_ERR_NUMBER_SIGN_CONVERSION is set if the input is a negative integer.

Please see Decode Errors Overview.

See also QCBORDecode_GetUInt64Convert() and QCBORDecode_GetUInt64ConvertAll().

QCBORDecode_GetUInt64Convert()

static void QCBORDecode_GetUInt64Convert ( QCBORDecodeContext * pCtx, enum QCBORDecodeNumberConvert uConvertTypes, uint64_t * puValue )

inlinestatic

Decode next item as an unsigned 64-bit integer with basic conversions.

Parameters

[in]	pCtx	The decode context.
[in]	uConvertTypes	See QCBORDecodeNumberConvert.
[out]	puValue	The returned 64-bit unsigned integer.

This is the same as QCBORDecode_GetInt64Convert(), but returns an unsigned integer and thus sets QCBOR_ERR_NUMBER_SIGN_CONVERSION if the value to be decoded is negatve.

If floating-point HW use is disabled this will set QCBOR_ERR_HW_FLOAT_DISABLED if a single-precision number is encountered. If half-precision support is disabled, this will set QCBOR_ERR_HALF_PRECISION_DISABLED if a half-precision number is encountered.

If floating-point usage is disabled this will set QCBOR_ERR_ALL_FLOAT_DISABLED if a floating point value is encountered.

See also QCBORDecode_GetUInt64Convert() and QCBORDecode_GetUInt64ConvertAll().

QCBORDecode_GetUInt64ConvertAll()

void QCBORDecode_GetUInt64ConvertAll	(	QCBORDecodeContext *	pCtx,
		enum QCBORDecodeNumberConvert	uConvertTypes,
		uint64_t *	puValue )

Decode next item into an unsigned 64-bit integer with conversions.

Parameters

[in]	pCtx	The decode context.
[in]	uConvertTypes	See QCBORDecodeNumberConvert.
[out]	puValue	The returned 64-bit unsigned integer.

This is the same as QCBORDecode_GetInt64ConvertAll(), but returns an unsigned integer and thus sets QCBOR_ERR_NUMBER_SIGN_CONVERSION if the value to be decoded is negatve.

See also QCBORDecode_GetUInt64() and QCBORDecode_GetUInt64Convert().

QCBORDecode_GetUInt64ConvertAllInMapN()

void QCBORDecode_GetUInt64ConvertAllInMapN	(	QCBORDecodeContext *	pCtx,
		int64_t	nLabel,
		enum QCBORDecodeNumberConvert	uConvertTypes,
		uint64_t *	puValue )

See QCBORDecode_GetUInt64ConvertAll().

QCBORDecode_GetUInt64ConvertAllInMapSZ()

void QCBORDecode_GetUInt64ConvertAllInMapSZ	(	QCBORDecodeContext *	pCtx,
		const char *	szLabel,
		enum QCBORDecodeNumberConvert	uConvertTypes,
		uint64_t *	puValue )

See QCBORDecode_GetUInt64ConvertAll().

QCBORDecode_GetUInt64ConvertInMapN()

static void QCBORDecode_GetUInt64ConvertInMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, enum QCBORDecodeNumberConvert uConvertTypes, uint64_t * puValue )

inlinestatic

See QCBORDecode_GetUInt64Convert().

QCBORDecode_GetUInt64ConvertInMapSZ()

static void QCBORDecode_GetUInt64ConvertInMapSZ ( QCBORDecodeContext * pCtx, const char * szLabel, enum QCBORDecodeNumberConvert uConvertTypes, uint64_t * puValue )

inlinestatic

See QCBORDecode_GetUInt64Convert().

QCBORDecode_GetUInt64InMapN()

static void QCBORDecode_GetUInt64InMapN ( QCBORDecodeContext * pCtx, int64_t nLabel, uint64_t * puValue )

inlinestatic

See QCBORDecode_GetUInt64().

QCBORDecode_GetUInt64InMapSZ()

static void QCBORDecode_GetUInt64InMapSZ ( QCBORDecodeContext * pCtx, const char * szLabel, uint64_t * puValue )

inlinestatic

See QCBORDecode_GetUInt64().

QCBORDecode_ProcessBigNumber()

QCBORError QCBORDecode_ProcessBigNumber	(	const QCBORItem	Item,
		UsefulBuf	BigNumberBuf,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

Decode a preferred serialization big number.

Parameters

[in]	Item	The number to process.
[in]	BigNumberBuf	The buffer to output to.
[out]	pBigNumber	The resulting big number.
[in,out]	pbIsNegative	The sign of the resulting big number.

This exists to process a QCBORItem that is expected to be a big number encoded with preferred serialization. This will turn the types listed in the table below into a big number. In particular it will apply the offset of one needed to get the actual value for QCBOR_TYPE_NEGBIGNUM. Leading zeros are removed. The value 0 is always returned as a one-byte big number with the value 0x00.

Type
QCBOR_TYPE_INT64
QCBOR_TYPE_UINT64
QCBOR_TYPE_65BIT_NEG_INT
QCBOR_TYPE_POSBIGNUM
QCBOR_TYPE_NEGBIGNUM
QCBOR_TYPE_BYTE_STRING
-—

For the type QCBOR_TYPE_BYTE_STRING, pIsNegative becomes an in parameter indicating the sign.

If BigNumberBuf is too small, pBigNum.ptr will be NULL and pBigNum.len reports the required length. Note that the size of the output buffer, *pBigNumberBuf, should be 1 byte larger than the size of the Item.val.bignum when the input Item is QCBOR_TYPE_NEGBIGNUM because the application of the offset of one for negative numbers may have an arithmetic carry. A way to size the output buffer is MIN(9, Item.val.bignum.len + 1). 9 comes from the length of they type QCBOR_TYPE_65BIT_NEG_INT plus the possibility of an arithmetic carry.

The object code for this is surprisingly large at about 1KB. This is to apply the offset of one for the negative values and to operate all the data types used by big number specific preferred serialization.

See BigNumbers for a useful overview of CBOR big numbers and QCBOR's support for them. See also QCBORDecode_ProcessBigNumberNoPreferred(), QCBORDecode_GetTBigNumber() and QCBOREncode_AddTBigNumber().

QCBORDecode_ProcessBigNumberNoPreferred()

QCBORError QCBORDecode_ProcessBigNumberNoPreferred	(	const QCBORItem	Item,
		UsefulBuf	BigNumberBuf,
		UsefulBufC *	pBigNumber,
		bool *	pbIsNegative )

Decode a big number.

Parameters

[in]	Item	The number to process.
[in]	BigNumberBuf	The buffer to output to.
[out]	pBigNumber	The resulting big number.
[out]	pbIsNegative	The sign of the resulting big number.

This is the same as QCBORDecode_ProcessBigNumber(), but doesn't allow QCBOR_TYPE_INT64, QCBOR_TYPE_UINT64 and QCBOR_TYPE_65BIT_NEG_INT.