switch everything to non-deprecated functions
diff --git a/README.md b/README.md
index b4d777f..46a2168 100644
--- a/README.md
+++ b/README.md
@@ -88,9 +88,9 @@
/* Encode */
QCBOREncode_Init(&EncodeCtx, Buffer);
QCBOREncode_OpenMap(&EncodeCtx);
- QCBOREncode_AddTextToMap(&EncodeCtx, "Manufacturer", pE->Manufacturer);
- QCBOREncode_AddInt64ToMap(&EncodeCtx, "Displacement", pE->uDisplacement);
- QCBOREncode_AddInt64ToMap(&EncodeCtx, "Horsepower", pE->uHorsePower);
+ QCBOREncode_AddTextToMapSZ(&EncodeCtx, "Manufacturer", pE->Manufacturer);
+ QCBOREncode_AddInt64ToMapSZ(&EncodeCtx, "Displacement", pE->uDisplacement);
+ QCBOREncode_AddInt64ToMapSZ(&EncodeCtx, "Horsepower", pE->uHorsePower);
QCBOREncode_CloseMap(&EncodeCtx);
uErr = QCBOREncode_Finish(&EncodeCtx, &EncodedEngine);
diff --git a/example.c b/example.c
index ed5d597..a6a0a13 100644
--- a/example.c
+++ b/example.c
@@ -162,14 +162,14 @@
/* Proceed to output all the items, letting the internal error
* tracking do its work */
QCBOREncode_OpenMap(&EncodeCtx);
- QCBOREncode_AddTextToMap(&EncodeCtx, "Manufacturer", pEngine->Manufacturer);
- QCBOREncode_AddInt64ToMap(&EncodeCtx, "NumCylinders", pEngine->uNumCylinders);
- QCBOREncode_AddInt64ToMap(&EncodeCtx, "Displacement", pEngine->uDisplacement);
- QCBOREncode_AddInt64ToMap(&EncodeCtx, "Horsepower", pEngine->uHorsePower);
+ QCBOREncode_AddTextToMapSZ(&EncodeCtx, "Manufacturer", pEngine->Manufacturer);
+ QCBOREncode_AddInt64ToMapSZ(&EncodeCtx, "NumCylinders", pEngine->uNumCylinders);
+ QCBOREncode_AddInt64ToMapSZ(&EncodeCtx, "Displacement", pEngine->uDisplacement);
+ QCBOREncode_AddInt64ToMapSZ(&EncodeCtx, "Horsepower", pEngine->uHorsePower);
#ifndef USEFULBUF_DISABLE_ALL_FLOAT
- QCBOREncode_AddDoubleToMap(&EncodeCtx, "DesignedCompression", pEngine->dDesignedCompresion);
+ QCBOREncode_AddDoubleToMapSZ(&EncodeCtx, "DesignedCompression", pEngine->dDesignedCompresion);
#endif /* USEFULBUF_DISABLE_ALL_FLOAT */
- QCBOREncode_OpenArrayInMap(&EncodeCtx, "Cylinders");
+ QCBOREncode_OpenArrayInMapSZ(&EncodeCtx, "Cylinders");
#ifndef USEFULBUF_DISABLE_ALL_FLOAT
for(int64_t i = 0 ; i < pEngine->uNumCylinders; i++) {
QCBOREncode_AddDouble(&EncodeCtx,
@@ -177,7 +177,7 @@
}
#endif /* USEFULBUF_DISABLE_ALL_FLOAT */
QCBOREncode_CloseArray(&EncodeCtx);
- QCBOREncode_AddBoolToMap(&EncodeCtx, "Turbo", pEngine->bTurboCharged);
+ QCBOREncode_AddBoolToMapSZ(&EncodeCtx, "Turbo", pEngine->bTurboCharged);
QCBOREncode_CloseMap(&EncodeCtx);
/* Get the pointer and length of the encoded output. If there was
diff --git a/inc/qcbor/qcbor_common.h b/inc/qcbor/qcbor_common.h
index 1ebfb7b..4208c53 100644
--- a/inc/qcbor/qcbor_common.h
+++ b/inc/qcbor/qcbor_common.h
@@ -30,7 +30,7 @@
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* ========================================================================= */
-
+//#define USEFULBUF_DISABLE_ALL_FLOAT
#ifndef qcbor_common_h
#define qcbor_common_h
@@ -173,17 +173,17 @@
#define CBOR_TAG_ENC_AS_B16 23
/** See QCBORDecode_EnterBstrWrapped()). */
#define CBOR_TAG_CBOR 24
-/** See QCBOREncode_AddURI(). */
+/** See QCBOREncode_AddTURI(). */
#define CBOR_TAG_URI 32
-/** See QCBOREncode_AddB64URLText(). */
+/** See QCBOREncode_AddTB64URLText(). */
#define CBOR_TAG_B64URL 33
/** See QCBOREncode_AddB64Text(). */
#define CBOR_TAG_B64 34
-/** See QCBOREncode_AddRegex(). */
+/** See QCBOREncode_AddTRegex(). */
#define CBOR_TAG_REGEX 35
/** See QCBOREncode_AddMIMEData(). */
#define CBOR_TAG_MIME 36
-/** See QCBOREncode_AddBinaryUUID(). */
+/** See QCBOREncode_AddTBinaryUUID(). */
#define CBOR_TAG_BIN_UUID 37
/** The data is a CBOR Web Token per [RFC 8392]
* (https://www.rfc-editor.org/rfc/rfc8392.html). No API is provided for this
diff --git a/inc/qcbor/qcbor_decode.h b/inc/qcbor/qcbor_decode.h
index 69e93e7..7df9094 100644
--- a/inc/qcbor/qcbor_decode.h
+++ b/inc/qcbor/qcbor_decode.h
@@ -270,32 +270,32 @@
#define QCBOR_TYPE_UKNOWN_SIMPLE 13
/** A decimal fraction made of decimal exponent and integer mantissa.
- * See @ref expAndMantissa and QCBOREncode_AddDecimalFraction(). */
+ * See @ref expAndMantissa and QCBOREncode_AddTDecimalFraction(). */
#define QCBOR_TYPE_DECIMAL_FRACTION 14
/** A decimal fraction made of decimal exponent and positive big
* number mantissa. See @ref expAndMantissa and
- * QCBOREncode_AddDecimalFractionBigNum(). */
+ * QCBOREncode_AddTDecimalFractionBigNum(). */
#define QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM 15
/** A decimal fraction made of decimal exponent and negative big
* number mantissa. See @ref expAndMantissa and
- * QCBOREncode_AddDecimalFractionBigNum(). */
+ * QCBOREncode_AddTDecimalFractionBigNum(). */
#define QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM 16
/** A floating-point number made of base-2 exponent and integer
* mantissa. See @ref expAndMantissa and
- * QCBOREncode_AddBigFloat(). */
+ * QCBOREncode_AddTBigFloat(). */
#define QCBOR_TYPE_BIGFLOAT 17
/** A floating-point number made of base-2 exponent and positive big
* number mantissa. See @ref expAndMantissa and
- * QCBOREncode_AddBigFloatBigNum(). */
+ * QCBOREncode_AddTBigFloatBigNum(). */
#define QCBOR_TYPE_BIGFLOAT_POS_BIGNUM 18
/** A floating-point number made of base-2 exponent and negative big
* number mantissa. See @ref expAndMantissa and
- * QCBOREncode_AddBigFloatBigNum(). */
+ * QCBOREncode_AddTBigFloatBigNum(). */
#define QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM 19
/** Type for the simple value false. */
diff --git a/inc/qcbor/qcbor_encode.h b/inc/qcbor/qcbor_encode.h
index 64ddf1e..27d1dd5 100644
--- a/inc/qcbor/qcbor_encode.h
+++ b/inc/qcbor/qcbor_encode.h
@@ -259,7 +259,7 @@
* support should be adequate.
*
* For example, the registered epoch date tag is supported in encoding
- * by QCBOREncode_AddDateEpoch() and in decoding by @ref
+ * by QCBOREncode_AddTDateEpoch() and in decoding by @ref
* QCBOR_TYPE_DATE_EPOCH and the @c epochDate member of @ref
* QCBORItem. This is typical of the built-in tag support. There is an
* API to encode data for it and a @c QCBOR_TYPE_XXX when it is decoded.
@@ -742,7 +742,7 @@
*
* For many of the common standard tags, a function to encode data
* using it is provided and this is not needed. For example,
- * QCBOREncode_AddDateEpoch() already exists to output integers
+ * QCBOREncode_AddTDateEpoch() already exists to output integers
* representing dates with the right tag.
*
* The tag is applied to the next data item added to the encoded
@@ -1077,9 +1077,9 @@
* CBOR Preferred serialization of the integers is used, thus they
* will be encoded in the smallest number of bytes possible.
*
- * See also QCBOREncode_AddDecimalFractionBigNum() for a decimal
+ * See also QCBOREncode_AddTDecimalFractionBigNum() for a decimal
* fraction with arbitrarily large precision and
- * QCBOREncode_AddBigFloat().
+ * QCBOREncode_AddTBigFloat().
*
* There is no representation of positive or negative infinity or NaN
* (Not a Number). Use QCBOREncode_AddDouble() to encode them.
@@ -1117,8 +1117,8 @@
* @param[in] bIsNegative false if mantissa is positive, true if negative.
* @param[in] nBase10Exponent The exponent.
*
- * This is the same as QCBOREncode_AddDecimalFraction() except the
- * mantissa is a big number (See QCBOREncode_AddPositiveBignum())
+ * This is the same as QCBOREncode_AddTDecimalFraction() except the
+ * mantissa is a big number (See QCBOREncode_AddTPositiveBignum())
* allowing for arbitrarily large precision.
*
* See @ref expAndMantissa for decoded representation.
@@ -1164,7 +1164,7 @@
* 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_AddBigFloatBigNum() for even more precision.
+ * QCBOREncode_AddTBigFloatBigNum() for even more precision.
*
* For example, 1.5 would be represented by a mantissa of 3 and an
* exponent of -1.
@@ -1215,8 +1215,8 @@
* @param[in] bIsNegative false if mantissa is positive, true if negative.
* @param[in] nBase2Exponent The exponent.
*
- * This is the same as QCBOREncode_AddBigFloat() except the mantissa
- * is a big number (See QCBOREncode_AddPositiveBignum()) allowing for
+ * This is the same as QCBOREncode_AddTBigFloat() except the mantissa
+ * is a big number (See QCBOREncode_AddTPositiveBignum()) allowing for
* arbitrary precision.
*
* See @ref expAndMantissa for decoded representation.
@@ -1264,7 +1264,7 @@
* A URI in a NULL-terminated string, @c szURI, can be easily added with
* this code:
*
- * QCBOREncode_AddURI(pCtx, UsefulBuf_FromSZ(szURI));
+ * QCBOREncode_AddTURI(pCtx, QCBOR_ENCODE_AS_TAG, UsefulBuf_FromSZ(szURI));
*/
static void
QCBOREncode_AddTURI(QCBOREncodeContext *pCtx,
@@ -1907,7 +1907,7 @@
* This cancels QCBOREncode_BstrWrap() making the encoding as if it
* were never called.
*
- * WARNING: This does not work on QCBOREncode_BstrWrapInMap()
+ * WARNING: This does not work on QCBOREncode_BstrWrapInMapSZ()
* or QCBOREncode_BstrWrapInMapN() and there is no error detection
* of an attempt at their use.
*
@@ -2199,108 +2199,127 @@
* They just have been replaced by something better. *
* ========================================================================= */
+/* Use QCBOREncode_AddInt64ToMapSZ() instead */
static void
QCBOREncode_AddInt64ToMap(QCBOREncodeContext *pCtx, const char *szLabel, int64_t nNum);
+/* Use QCBOREncode_AddUInt64ToMapSZ() instead */
static void
QCBOREncode_AddUInt64ToMap(QCBOREncodeContext *pCtx, const char *szLabel, uint64_t uNum);
+/* Use QCBOREncode_AddTextToMapSZ() instead */
static void
QCBOREncode_AddTextToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Text);
+/* Use QCBOREncode_AddSZStringToMapSZ() instead */
static void
QCBOREncode_AddSZStringToMap(QCBOREncodeContext *pCtx, const char *szLabel, const char *szString);
+#ifndef USEFULBUF_DISABLE_ALL_FLOAT
+/* Use QCBOREncode_AddDoubleToMapSZ() instead */
static void
QCBOREncode_AddDoubleToMap(QCBOREncodeContext *pCtx, const char *szLabel, double dNum);
+/* Use QCBOREncode_AddFloatToMapSZ() instead */
static void
QCBOREncode_AddFloatToMap(QCBOREncodeContext *pCtx, const char *szLabel, float fNum);
+/* Use QCBOREncode_AddDoubleNoPreferredToMapSZ() instead */
static void
QCBOREncode_AddDoubleNoPreferredToMap(QCBOREncodeContext *pCtx, const char *szLabel, double dNum);
+/* Use QCBOREncode_AddFloatNoPreferredToMapSZ() instead */
static void
QCBOREncode_AddFloatNoPreferredToMap(QCBOREncodeContext *pCtx, const char *szLabel, float fNum);
+#endif /* ! USEFULBUF_DISABLE_ALL_FLOAT */
+/* Use QCBOREncode_AddTDateEpoch() instead */
static void
-QCBOREncode_AddDateEpoch(QCBOREncodeContext *pCtx,
- int64_t nDate);
+QCBOREncode_AddDateEpoch(QCBOREncodeContext *pCtx, int64_t nDate);
+/* Use QCBOREncode_AddTDateEpochToMapSZ() instead */
static void
-QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pCtx,
- const char *szLabel,
- int64_t nDate);
+QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pCtx, const char *szLabel, int64_t nDate);
+/* Use QCBOREncode_AddTDateEpochToMapN() instead */
static void
-QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pCtx,
- int64_t nLabel,
- int64_t nDate);
+QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, int64_t nDate);
+/* Use QCBOREncode_AddBytesToMapSZ() instead */
static void
QCBOREncode_AddBytesToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Bytes);
+/* Use QCBOREncode_AddTBinaryUUID() instead */
static void
QCBOREncode_AddBinaryUUID(QCBOREncodeContext *pCtx, UsefulBufC Bytes);
+/* Use QCBOREncode_AddTBinaryUUIDToMapSZ() instead */
static void
QCBOREncode_AddBinaryUUIDToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Bytes);
+/* Use QCBOREncode_AddTBinaryUUIDToMapN() instead */
static void
QCBOREncode_AddBinaryUUIDToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Bytes);
+/* Use QCBOREncode_AddTPositiveBignum() instead */
static void
-QCBOREncode_AddPositiveBignum(QCBOREncodeContext *pCtx,
- UsefulBufC BigNumber);
+QCBOREncode_AddPositiveBignum(QCBOREncodeContext *pCtx, UsefulBufC BigNumber);
+/* QCBOREncode_AddTPositiveBignumToMapSZ() instead */
static void
QCBOREncode_AddPositiveBignumToMap(QCBOREncodeContext *pCtx,
const char *szLabel,
UsefulBufC BigNumber);
+/* Use QCBOREncode_AddTPositiveBignumToMapN() instead */
static void
QCBOREncode_AddPositiveBignumToMapN(QCBOREncodeContext *pCtx,
int64_t nLabel,
UsefulBufC BigNumber);
+/* Use QCBOREncode_AddTNegativeBignum() instead */
static void
-QCBOREncode_AddNegativeBignum(QCBOREncodeContext *pCtx,
- UsefulBufC BigNumber);
+QCBOREncode_AddNegativeBignum(QCBOREncodeContext *pCtx, UsefulBufC BigNumber);
+/* Use QCBOREncode_AddTNegativeBignumToMapSZ() instead */
static void
-QCBOREncode_AddNegativeBignumToMap(QCBOREncodeContext *pCtx,
- const char *szLabel,
- UsefulBufC BigNumber);
+QCBOREncode_AddNegativeBignumToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC BigNumber);
+/* Use QCBOREncode_AddTNegativeBignumToMapN() instead */
static void
-QCBOREncode_AddNegativeBignumToMapN(QCBOREncodeContext *pCtx,
- int64_t nLabel,
- UsefulBufC BigNumber);
+QCBOREncode_AddNegativeBignumToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC BigNumber);
+
+#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
+
+/* Use QCBOREncode_AddTDecimalFraction() instead */
static void
QCBOREncode_AddDecimalFraction(QCBOREncodeContext *pCtx,
int64_t nMantissa,
int64_t nBase10Exponent);
+/* Use QCBOREncode_AddTDecimalFractionToMapSZ() instead */
static void
QCBOREncode_AddDecimalFractionToMap(QCBOREncodeContext *pCtx,
const char *szLabel,
int64_t nMantissa,
int64_t nBase10Exponent);
+/* Use QCBOREncode_AddTDecimalFractionToMapN() instead */
static void
QCBOREncode_AddDecimalFractionToMapN(QCBOREncodeContext *pCtx,
int64_t nLabel,
int64_t nMantissa,
int64_t nBase10Exponent);
-
+/* Use QCBOREncode_AddTDecimalFractionBigNum() instead */
static void
QCBOREncode_AddDecimalFractionBigNum(QCBOREncodeContext *pCtx,
UsefulBufC Mantissa,
bool bIsNegative,
int64_t nBase10Exponent);
+/* Use QCBOREncode_AddTDecimalFractionBigNumToMapSZ() instead */
static void
QCBOREncode_AddDecimalFractionBigNumToMapSZ(QCBOREncodeContext *pCtx,
const char *szLabel,
@@ -2308,6 +2327,7 @@
bool bIsNegative,
int64_t nBase10Exponent);
+/* Use QCBOREncode_AddTDecimalFractionBigNumToMapN() instead */
static void
QCBOREncode_AddDecimalFractionBigNumToMapN(QCBOREncodeContext *pCtx,
int64_t nLabel,
@@ -2315,29 +2335,34 @@
bool bIsNegative,
int64_t nBase10Exponent);
+/* Use QCBOREncode_AddTBigFloat() instead */
static void
QCBOREncode_AddBigFloat(QCBOREncodeContext *pCtx,
int64_t nMantissa,
int64_t nBase2Exponent);
+/* Use QCBOREncode_AddTBigFloatToMapSZ() instead */
static void
QCBOREncode_AddBigFloatToMap(QCBOREncodeContext *pCtx,
const char *szLabel,
int64_t nMantissa,
int64_t nBase2Exponent);
+/* Use QCBOREncode_AddTBigFloatToMapN() instead */
static void
QCBOREncode_AddBigFloatToMapN(QCBOREncodeContext *pCtx,
int64_t nLabel,
int64_t nMantissa,
int64_t nBase2Exponent);
+/* Use QCBOREncode_AddTBigFloatBigNum() instead */
static void
QCBOREncode_AddBigFloatBigNum(QCBOREncodeContext *pCtx,
UsefulBufC Mantissa,
bool bIsNegative,
int64_t nBase2Exponent);
+/* Use QCBOREncode_AddTBigFloatBigNumToMapSZ() instead */
static void
QCBOREncode_AddBigFloatBigNumToMap(QCBOREncodeContext *pCtx,
const char *szLabel,
@@ -2345,128 +2370,144 @@
bool bIsNegative,
int64_t nBase2Exponent);
+/* Use QCBOREncode_AddTBigFloatBigNumToMapN() instead */
static void
QCBOREncode_AddBigFloatBigNumToMapN(QCBOREncodeContext *pCtx,
int64_t nLabel,
UsefulBufC Mantissa,
bool bIsNegative,
int64_t nBase2Exponent);
+#endif /* ! QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
+/* Use QCBOREncode_AddTURI() instead */
static void
-QCBOREncode_AddURI(QCBOREncodeContext *pCtx,
- UsefulBufC URI);
+QCBOREncode_AddURI(QCBOREncodeContext *pCtx, UsefulBufC URI);
+/* Use QCBOREncode_AddTURIToMapSZ() instead */
static void
-QCBOREncode_AddURIToMap(QCBOREncodeContext *pCtx,
- const char *szLabel,
- UsefulBufC URI);
+QCBOREncode_AddURIToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC URI);
+/* Use QCBOREncode_AddTURIToMapN() instead */
static void
-QCBOREncode_AddURIToMapN(QCBOREncodeContext *pCtx,
- int64_t nLabel,
- UsefulBufC URI);
+QCBOREncode_AddURIToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC URI);
+/* Use QCBOREncode_AddTB64Text() instead */
static void
-QCBOREncode_AddB64Text(QCBOREncodeContext *pCtx,
- UsefulBufC B64Text);
+QCBOREncode_AddB64Text(QCBOREncodeContext *pCtx, UsefulBufC B64Text);
+/* Use QCBOREncode_AddTB64TextToMapSZ() instead */
static void
-QCBOREncode_AddB64TextToMap(QCBOREncodeContext *pCtx,
- const char *szLabel,
- UsefulBufC B64Text);
+QCBOREncode_AddB64TextToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC B64Text);
+/* Use QCBOREncode_AddTB64TextToMapN() instead */
static void
-QCBOREncode_AddB64TextToMapN(QCBOREncodeContext *pCtx,
- int64_t nLabel,
- UsefulBufC B64Text);
+QCBOREncode_AddB64TextToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC B64Text);
+/* Use QCBOREncode_AddTB64URLText() instead */
static void
-QCBOREncode_AddB64URLText(QCBOREncodeContext *pCtx,
- UsefulBufC B64Text);
+QCBOREncode_AddB64URLText(QCBOREncodeContext *pCtx, UsefulBufC B64Text);
+/* Use QCBOREncode_AddTB64URLTextToMapSZ() instead */
static void
QCBOREncode_AddB64URLTextToMap(QCBOREncodeContext *pCtx,
const char *szLabel,
UsefulBufC B64Text);
+/* Use QCBOREncode_AddTB64URLTextToMapN() instead */
static void
QCBOREncode_AddB64URLTextToMapN(QCBOREncodeContext *pCtx,
int64_t nLabel,
UsefulBufC B64Text);
+/* Use QCBOREncode_AddTRegex() instead */
static void
-QCBOREncode_AddRegex(QCBOREncodeContext *pCtx,
- UsefulBufC Regex);
+QCBOREncode_AddRegex(QCBOREncodeContext *pCtx, UsefulBufC Regex);
+/* Use QCBOREncode_AddTRegexToMapSZ() instead */
static void
QCBOREncode_AddRegexToMap(QCBOREncodeContext *pCtx,
const char *szLabel,
UsefulBufC Regex);
+/* Use QCBOREncode_AddTRegexToMapN() instead */
static void
QCBOREncode_AddRegexToMapN(QCBOREncodeContext *pCtx,
int64_t nLabel,
UsefulBufC Regex);
+/* Use QCBOREncode_AddTMIMEData() instead */
static void
-QCBOREncode_AddMIMEData(QCBOREncodeContext *pCtx,
- UsefulBufC MIMEData);
+QCBOREncode_AddMIMEData(QCBOREncodeContext *pCtx, UsefulBufC MIMEData);
+/* Use QCBOREncode_AddTMIMEDataToMapSZ() instead */
static void
QCBOREncode_AddMIMEDataToMap(QCBOREncodeContext *pCtx,
const char *szLabel,
UsefulBufC MIMEData);
+/* Use QCBOREncode_AddTMIMEDataToMapN() instead */
static void
QCBOREncode_AddMIMEDataToMapN(QCBOREncodeContext *pCtx,
int64_t nLabel,
UsefulBufC MIMEData);
+/* Use QCBOREncode_AddTDateString() instead */
static void
-QCBOREncode_AddDateString(QCBOREncodeContext *pCtx,
- const char *szDate);
+QCBOREncode_AddDateString(QCBOREncodeContext *pCtx, const char *szDate);
+/* Use QCBOREncode_AddTDateStringToMapSZ() instead */
static void
QCBOREncode_AddDateStringToMap(QCBOREncodeContext *pCtx,
const char *szLabel,
const char *szDate);
+/* Use QCBOREncode_AddTDateStringToMapN instead */
static void
QCBOREncode_AddDateStringToMapN(QCBOREncodeContext *pCtx,
int64_t nLabel,
const char *szDate);
+/* Use QCBOREncode_AddBoolToMapSZ() instead */
static void
QCBOREncode_AddBoolToMap(QCBOREncodeContext *pCtx, const char *szLabel, bool b);
+/* Use QCBOREncode_AddNULLToMapSZ() instead */
static void
QCBOREncode_AddNULLToMap(QCBOREncodeContext *pCtx, const char *szLabel);
+/* Use QCBOREncode_AddUndefToMapSZ() instead */
static void
QCBOREncode_AddUndefToMap(QCBOREncodeContext *pCtx, const char *szLabel);
+/* Use QCBOREncode_AddSimpleToMapSZ instead */
static void
QCBOREncode_AddSimpleToMap(QCBOREncodeContext *pCtx,
const char *szLabel,
const uint8_t uSimple);
+/* Use QCBOREncode_OpenArrayInMapSZ() instead */
static void
QCBOREncode_OpenArrayInMap(QCBOREncodeContext *pCtx, const char *szLabel);
+/* Use QCBOREncode_OpenMapInMapSZ() instead */
static void
QCBOREncode_OpenMapInMap(QCBOREncodeContext *pCtx, const char *szLabel);
+/* Use QCBOREncode_OpenArrayIndefiniteLengthInMapSZ() instead */
static void
QCBOREncode_OpenArrayIndefiniteLengthInMap(QCBOREncodeContext *pCtx,
const char *szLabel);
+/* Use QCBOREncode_OpenMapIndefiniteLengthInMapSZ() instead */
static void
QCBOREncode_OpenMapIndefiniteLengthInMap(QCBOREncodeContext *pCtx,
const char *szLabel);
+/* Use QCBOREncode_BstrWrapInMapSZ() instead */
static void
QCBOREncode_BstrWrapInMap(QCBOREncodeContext *pCtx, const char *szLabel);
+/* Use QCBOREncode_AddEncodedToMapSZ() instead */
static void
QCBOREncode_AddEncodedToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Encoded);
diff --git a/inc/qcbor/qcbor_spiffy_decode.h b/inc/qcbor/qcbor_spiffy_decode.h
index fd2b0e5..e5ea0a9 100644
--- a/inc/qcbor/qcbor_spiffy_decode.h
+++ b/inc/qcbor/qcbor_spiffy_decode.h
@@ -1336,7 +1336,7 @@
*
* See @ref Tag-Usage for discussion on tag requirements.
*
- * See also @ref CBOR_TAG_DATE_EPOCH, QCBOREncode_AddDateEpoch() and
+ * See also @ref CBOR_TAG_DATE_EPOCH, QCBOREncode_AddTDateEpoch() and
* @ref QCBOR_TYPE_DATE_EPOCH.
*/
void
@@ -1435,7 +1435,7 @@
* QCBORDecode_GetDoubleConvertAll() which can convert big numbers.
*
* See also @ref CBOR_TAG_POS_BIGNUM, @ref CBOR_TAG_NEG_BIGNUM,
- * QCBOREncode_AddPositiveBignum(), QCBOREncode_AddNegativeBignum(),
+ * QCBOREncode_AddTPositiveBignum(), QCBOREncode_AddTNegativeBignum(),
* @ref QCBOR_TYPE_POSBIGNUM and @ref QCBOR_TYPE_NEGBIGNUM.
*/
// Improvement: Add function that converts integers and other to big nums
@@ -1502,7 +1502,7 @@
* QCBORDecode_GetDoubleConvertAll() which can convert big numbers.
*
* See also @ref CBOR_TAG_DECIMAL_FRACTION,
- * QCBOREncode_AddDecimalFraction(), @ref QCBOR_TYPE_DECIMAL_FRACTION
+ * QCBOREncode_AddTDecimalFraction(), @ref QCBOR_TYPE_DECIMAL_FRACTION
* and QCBORDecode_GetDecimalFractionBig().
*
* If QCBOR_DISABLE_TAGS is set, the only input this will decode is an
@@ -1555,7 +1555,7 @@
* fractions.
*
* See also @ref CBOR_TAG_DECIMAL_FRACTION,
- * QCBOREncode_AddDecimalFraction(), @ref QCBOR_TYPE_DECIMAL_FRACTION
+ * QCBOREncode_AddTDecimalFraction(), @ref QCBOR_TYPE_DECIMAL_FRACTION
* and QCBORDecode_GetDecimalFraction().
*/
void
@@ -1609,7 +1609,7 @@
* QCBORDecode_GetUInt64ConvertAll() and
* QCBORDecode_GetDoubleConvertAll() which can convert big floats.
*
- * See also @ref CBOR_TAG_BIGFLOAT, QCBOREncode_AddBigFloat(), @ref
+ * See also @ref CBOR_TAG_BIGFLOAT, QCBOREncode_AddTBigFloat(), @ref
* QCBOR_TYPE_BIGFLOAT and QCBORDecode_GetBigFloatBig().
*/
void
@@ -1652,7 +1652,7 @@
* QCBORDecode_GetUInt64ConvertAll() and
* QCBORDecode_GetDoubleConvertAll() which can convert big floats.
*
- * See also @ref CBOR_TAG_BIGFLOAT, QCBOREncode_AddBigFloat(),
+ * See also @ref CBOR_TAG_BIGFLOAT, QCBOREncode_AddTBigFloat(),
* @ref QCBOR_TYPE_BIGFLOAT and QCBORDecode_GetBigFloat().
*/
void
@@ -1700,7 +1700,7 @@
*
* See @ref Tag-Usage for discussion on tag requirements.
*
- * See also @ref CBOR_TAG_URI, QCBOREncode_AddURI() and
+ * See also @ref CBOR_TAG_URI, QCBOREncode_AddTURI() and
* @ref QCBOR_TYPE_URI.
*/
static void
@@ -1775,7 +1775,7 @@
*
* Note that this does not actually remove the base64url encoding.
*
- * See also @ref CBOR_TAG_B64URL, QCBOREncode_AddB64URLText() and
+ * See also @ref CBOR_TAG_B64URL, QCBOREncode_AddTB64URLText() and
* @ref QCBOR_TYPE_BASE64URL.
*/
static void
@@ -1810,7 +1810,7 @@
*
* See @ref Tag-Usage for discussion on tag requirements.
*
- * See also @ref CBOR_TAG_REGEX, QCBOREncode_AddRegex() and
+ * See also @ref CBOR_TAG_REGEX, QCBOREncode_AddTRegex() and
* @ref QCBOR_TYPE_REGEX.
*/
static void
@@ -1898,7 +1898,7 @@
*
* See @ref Tag-Usage for discussion on tag requirements.
*
- * See also @ref CBOR_TAG_BIN_UUID, QCBOREncode_AddBinaryUUID() and
+ * See also @ref CBOR_TAG_BIN_UUID, QCBOREncode_AddTBinaryUUID() and
* @ref QCBOR_TYPE_UUID.
*/
static void
diff --git a/src/qcbor_encode.c b/src/qcbor_encode.c
index 7657303..c30cbce 100644
--- a/src/qcbor_encode.c
+++ b/src/qcbor_encode.c
@@ -693,8 +693,8 @@
* To output a mantissa that is between INT64_MAX and UINT64_MAX from 0,
* it must be as a big number.
*
- * Typically, QCBOREncode_AddDecimalFraction(), QCBOREncode_AddBigFloat(),
- * QCBOREncode_AddDecimalFractionBigNum() or QCBOREncode_AddBigFloatBigNum()
+ * Typically, QCBOREncode_AddTDecimalFraction(), QCBOREncode_AddTBigFloat(),
+ * QCBOREncode_AddTDecimalFractionBigNum() or QCBOREncode_AddTBigFloatBigNum()
* is called instead of this.
*/
void
@@ -718,9 +718,9 @@
QCBOREncode_AddInt64(pMe, nExponent);
if(!UsefulBuf_IsNULLC(BigNumMantissa)) {
if(bBigNumIsNegative) {
- QCBOREncode_AddNegativeBignum(pMe, BigNumMantissa);
+ QCBOREncode_AddTNegativeBignum(pMe, QCBOR_ENCODE_AS_TAG, BigNumMantissa);
} else {
- QCBOREncode_AddPositiveBignum(pMe, BigNumMantissa);
+ QCBOREncode_AddTPositiveBignum(pMe, QCBOR_ENCODE_AS_TAG, BigNumMantissa);
}
} else {
QCBOREncode_AddInt64(pMe, nMantissa);
@@ -968,7 +968,7 @@
return;
}
/* QCBOREncode_CancelBstrWrap() can't correctly undo
- * QCBOREncode_BstrWrapInMap() or QCBOREncode_BstrWrapInMapN(). It
+ * QCBOREncode_BstrWrapInMapSZ() or QCBOREncode_BstrWrapInMapN(). It
* can't undo the labels they add. It also doesn't catch the error
* of using it this way. QCBOREncode_CancelBstrWrap() is used
* infrequently and the the result is incorrect CBOR, not a
diff --git a/test/qcbor_decode_tests.c b/test/qcbor_decode_tests.c
index 9f16668..e9745e3 100644
--- a/test/qcbor_decode_tests.c
+++ b/test/qcbor_decode_tests.c
@@ -6264,8 +6264,8 @@
QCBOREncode_Init(&EC, UsefulBuf_FROM_BYTE_ARRAY(pBuf));
QCBOREncode_OpenArray(&EC);
QCBOREncode_AddDecimalFraction(&EC, 999, 1000); // 999 * (10 ^ 1000)
- QCBOREncode_AddBigFloat(&EC, 100, INT32_MIN);
- QCBOREncode_AddDecimalFractionBigNum(&EC, BN, false, INT32_MAX);
+ QCBOREncode_AddTBigFloat(&EC, QCBOR_ENCODE_AS_TAG, 100, INT32_MIN);
+ QCBOREncode_AddTDecimalFractionBigNum(&EC, QCBOR_ENCODE_AS_TAG, BN, false, INT32_MAX);
QCBOREncode_CloseArray(&EC);
QCBOREncode_Finish(&EC, &Encoded);
diff --git a/test/qcbor_encode_tests.c b/test/qcbor_encode_tests.c
index 3e8ec2f..14bcc63 100644
--- a/test/qcbor_encode_tests.c
+++ b/test/qcbor_encode_tests.c
@@ -681,7 +681,7 @@
QCBOREncode_AddBool(pECtx, true);
QCBOREncode_AddBool(pECtx, false);
QCBOREncode_OpenMap(pECtx);
- QCBOREncode_AddBoolToMap(pECtx, "George is the man", true);
+ QCBOREncode_AddBoolToMapSZ(pECtx, "George is the man", true);
QCBOREncode_AddBoolToMapN(pECtx, 010101, true);
QCBOREncode_CloseMap(pECtx);
@@ -929,7 +929,7 @@
QCBOREncode_OpenMap(&ECtx);
- QCBOREncode_AddUndefToMap(&ECtx, "UNDef");
+ QCBOREncode_AddUndefToMapSZ(&ECtx, "UNDef");
QCBOREncode_CloseMap(&ECtx);
QCBOREncode_CloseArray(&ECtx);
@@ -1191,32 +1191,32 @@
QCBOREncode_OpenMap(&ECtx);
// add array with 31 items
- QCBOREncode_OpenArrayInMap(&ECtx, "arr");
+ QCBOREncode_OpenArrayInMapSZ(&ECtx, "arr");
for (size_t ix = 0; ix < 31; ix++) {
QCBOREncode_AddInt64(&ECtx, (int64_t)ix);
}
QCBOREncode_CloseArray(&ECtx);
// add map with 31 items
- QCBOREncode_OpenMapInMap(&ECtx, "map");
+ QCBOREncode_OpenMapInMapSZ(&ECtx, "map");
for (int ix = 0; ix < 31; ix++) {
// make sure we have unique keys in the map (a-z then follow by A-Z)
int c = 'a';
if (ix < 26) c = c + ix;
else c = 'A' + (ix - 26);
char buffer[2] = { (char)c, 0 };
- QCBOREncode_AddInt64ToMap(&ECtx, buffer, ix);
+ QCBOREncode_AddInt64ToMapSZ(&ECtx, buffer, ix);
}
QCBOREncode_CloseMap(&ECtx);
// add -31 and +31
- QCBOREncode_AddInt64ToMap(&ECtx, "min31", -31);
- QCBOREncode_AddInt64ToMap(&ECtx, "plus31", 31);
+ QCBOREncode_AddInt64ToMapSZ(&ECtx, "min31", -31);
+ QCBOREncode_AddInt64ToMapSZ(&ECtx, "plus31", 31);
// add string with length 31
const char *str = "testtesttesttesttesttestqcbor11";
UsefulBufC str_b = { str, 31 };
- QCBOREncode_AddTextToMap(&ECtx, "str", str_b);
+ QCBOREncode_AddTextToMapSZ(&ECtx, "str", str_b);
QCBOREncode_CloseMap(&ECtx);
@@ -1295,9 +1295,10 @@
QCBOREncode_OpenMap(&ECtx);
- QCBOREncode_AddDateStringToMap(&ECtx,
- "Sample Date from RFC 3339",
- "1985-04-12T23:20:50.52Z");
+ QCBOREncode_AddTDateStringToMapSZ(&ECtx,
+ "Sample Date from RFC 3339",
+ QCBOR_ENCODE_AS_TAG,
+ "1985-04-12T23:20:50.52Z");
QCBOREncode_AddDateEpochToMap(&ECtx, "SD", 999);
QCBOREncode_AddTDaysStringToMapSZ(&ECtx,
"Sample Date from RFC 8943",
@@ -1537,16 +1538,16 @@
do {
QCBOREncode_Init(&ECtx, (UsefulBuf){*pEncoded, *pEncodedLen});
QCBOREncode_OpenMap(&ECtx);
- QCBOREncode_AddInt64ToMap(&ECtx, "first integer", 42);
- QCBOREncode_OpenArrayInMap(&ECtx, "an array of two strings");
+ QCBOREncode_AddInt64ToMapSZ(&ECtx, "first integer", 42);
+ QCBOREncode_OpenArrayInMapSZ(&ECtx, "an array of two strings");
QCBOREncode_AddText(&ECtx, ((UsefulBufC) {"string1", 7}));
QCBOREncode_AddText(&ECtx, ((UsefulBufC) {"string2", 7}));
QCBOREncode_CloseArray(&ECtx);
- QCBOREncode_OpenMapInMap(&ECtx, "map in a map");
+ QCBOREncode_OpenMapInMapSZ(&ECtx, "map in a map");
QCBOREncode_AddBytesToMap(&ECtx,"bytes 1", ((UsefulBufC) { "xxxx", 4}));
- QCBOREncode_AddBytesToMap(&ECtx, "bytes 2",((UsefulBufC) { "yyyy", 4}));
- QCBOREncode_AddInt64ToMap(&ECtx, "another int", 98);
- QCBOREncode_AddTextToMap(&ECtx, "text 2", ((UsefulBufC) {"lies, damn lies and statistics", 30}));
+ QCBOREncode_AddBytesToMapSZ(&ECtx, "bytes 2",((UsefulBufC) { "yyyy", 4}));
+ QCBOREncode_AddInt64ToMapSZ(&ECtx, "another int", 98);
+ QCBOREncode_AddTextToMapSZ(&ECtx, "text 2", ((UsefulBufC) {"lies, damn lies and statistics", 30}));
QCBOREncode_CloseMap(&ECtx);
QCBOREncode_CloseMap(&ECtx);
@@ -1683,10 +1684,10 @@
// The result: 0 if scan happened and found nothing; 1 if it happened and
// found something wrong; 2 if it didn't happen
- QCBOREncode_AddSimpleToMap(&ECtx, "integrity", uRResult);
+ QCBOREncode_AddSimpleToMapSZ(&ECtx, "integrity", uRResult);
// Add the diagnostic code
- QCBOREncode_AddSZStringToMap(&ECtx, "type", szType);
+ QCBOREncode_AddSZStringToMapSZ(&ECtx, "type", szType);
// Add a time stamp
if(time) {
@@ -1694,24 +1695,24 @@
}
// Add the diagnostic code
- QCBOREncode_AddSZStringToMap(&ECtx, "diag", szAlexString);
+ QCBOREncode_AddSZStringToMapSZ(&ECtx, "diag", szAlexString);
// Open a subordinate map for telemtry data
- QCBOREncode_OpenMapInMap(&ECtx, "telemetry");
+ QCBOREncode_OpenMapInMapSZ(&ECtx, "telemetry");
{ // Brace / indention just to show CBOR encoding nesting
// Add a few fake integers and buffers for now.
- QCBOREncode_AddInt64ToMap(&ECtx, "Shoe Size", 12);
+ QCBOREncode_AddInt64ToMapSZ(&ECtx, "Shoe Size", 12);
// Add a few fake integers and buffers for now.
- QCBOREncode_AddInt64ToMap(&ECtx, "IQ", 0xffffffff);
+ QCBOREncode_AddInt64ToMapSZ(&ECtx, "IQ", 0xffffffff);
// Add a few fake integers and buffers for now.
static const uint8_t pPV[] = {0x66, 0x67, 0x00, 0x56, 0xaa, 0xbb, 0x01, 0x01};
const UsefulBufC WSPV = {pPV, sizeof(pPV)};
- QCBOREncode_AddBytesToMap(&ECtx, "WhaleSharkPatternVector", WSPV);
+ QCBOREncode_AddBytesToMapSZ(&ECtx, "WhaleSharkPatternVector", WSPV);
}
}
@@ -2914,12 +2915,12 @@
QCBOREncode_AddTDecimalFraction(&EC, QCBOR_ENCODE_AS_BORROWED, 4, -1); // 3 * (10 ^ -1)
QCBOREncode_AddDecimalFractionBigNum(&EC, BigNum , false, -20);
QCBOREncode_AddTDecimalFractionBigNum(&EC, QCBOR_ENCODE_AS_BORROWED, BigNum , false, 2);
- QCBOREncode_AddDecimalFractionBigNum(&EC, BigNum, true, INT64_MAX);
+ QCBOREncode_AddTDecimalFractionBigNum(&EC, QCBOR_ENCODE_AS_TAG, BigNum, true, INT64_MAX);
QCBOREncode_AddBigFloat(&EC, 100, 300);
QCBOREncode_AddTBigFloat(&EC, QCBOR_ENCODE_AS_BORROWED, 200, 600);
QCBOREncode_AddBigFloatBigNum(&EC, BigNum, false, -20);
QCBOREncode_AddTBigFloatBigNum(&EC, QCBOR_ENCODE_AS_BORROWED, BigNum, false, 4);
- QCBOREncode_AddBigFloatBigNum(&EC, BigNum, true, INT64_MIN);
+ QCBOREncode_AddTBigFloatBigNum(&EC, QCBOR_ENCODE_AS_TAG, BigNum, true, INT64_MIN);
QCBOREncode_CloseArray(&EC);
if(QCBOREncode_Finish(&EC, &EncodedExponentAndMantissa)) {
@@ -2952,17 +2953,19 @@
false,
INT32_MAX);
- QCBOREncode_AddDecimalFractionBigNumToMapSZ(&EC,
- "decimal fraction bignum negative",
- BigNum,
- true,
- INT64_MAX);
+ QCBOREncode_AddTDecimalFractionBigNumToMapSZ(&EC,
+ "decimal fraction bignum negative",
+ QCBOR_ENCODE_AS_TAG,
+ BigNum,
+ true,
+ INT64_MAX);
- QCBOREncode_AddDecimalFractionBigNumToMapN(&EC,
- 500,
- BigNum,
- true,
- INT64_MAX);
+ QCBOREncode_AddTDecimalFractionBigNumToMapN(&EC,
+ 500,
+ QCBOR_ENCODE_AS_TAG,
+ BigNum,
+ true,
+ INT64_MAX);
QCBOREncode_AddBigFloatToMap(&EC, "big float", 100, 300);
@@ -2980,17 +2983,19 @@
false,
-20);
- QCBOREncode_AddBigFloatBigNumToMap(&EC,
- "big float bignum negative",
- BigNum,
- true,
- INT64_MIN);
+ QCBOREncode_AddTBigFloatBigNumToMapSZ(&EC,
+ "big float bignum negative",
+ QCBOR_ENCODE_AS_TAG,
+ BigNum,
+ true,
+ INT64_MIN);
- QCBOREncode_AddBigFloatBigNumToMapN(&EC,
- 800,
- BigNum,
- true,
- INT64_MIN);
+ QCBOREncode_AddTBigFloatBigNumToMapN(&EC,
+ 800,
+ QCBOR_ENCODE_AS_TAG,
+ BigNum,
+ true,
+ INT64_MIN);
QCBOREncode_CloseMap(&EC);