QCBOR
qcbor_encode.h
Go to the documentation of this file.
1 /* ===========================================================================
2  * Copyright (c) 2016-2018, The Linux Foundation.
3  * Copyright (c) 2018-2025, Laurence Lundblade.
4  * Copyright (c) 2021, Arm Limited.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are
9  * met:
10  * * Redistributions of source code must retain the above copyright
11  * notice, this list of conditions and the following disclaimer.
12  * * Redistributions in binary form must reproduce the above
13  * copyright notice, this list of conditions and the following
14  * disclaimer in the documentation and/or other materials provided
15  * with the distribution.
16  * * Neither the name of The Linux Foundation nor the names of its
17  * contributors, nor the name "Laurence Lundblade" may be used to
18  * endorse or promote products derived from this software without
19  * specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
22  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
24  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
25  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
30  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
31  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  * ========================================================================= */
33 
34 
35 #ifndef qcbor_encode_h
36 #define qcbor_encode_h
37 
38 
39 #include "qcbor/qcbor_common.h"
40 #include "qcbor/qcbor_private.h"
41 #include <stdbool.h>
42 
43 
44 #ifdef __cplusplus
45 extern "C" {
46 #if 0
47 } // Keep editor indention formatting happy
48 #endif
49 #endif
50 
51 
401 #define QCBOR_HEAD_BUFFER_SIZE (sizeof(uint64_t) + 2)
402 
403 
408 #define QCBOR_ENCODE_AS_TAG 0
409 
414 #define QCBOR_ENCODE_AS_BORROWED 1
415 
416 
424 typedef struct _QCBOREncodeContext QCBOREncodeContext;
425 
426 
482 void
483 QCBOREncode_Init(QCBOREncodeContext *pCtx, UsefulBuf Storage);
484 
485 
526 void
527 QCBOREncode_AddInt64(QCBOREncodeContext *pCtx, int64_t nNum);
528 
529 static void
530 QCBOREncode_AddInt64ToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, int64_t nNum);
531 
532 static void
533 QCBOREncode_AddInt64ToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, int64_t nNum);
534 
535 
550 static void
551 QCBOREncode_AddUInt64(QCBOREncodeContext *pCtx, uint64_t uNum);
552 
553 static void
554 QCBOREncode_AddUInt64ToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, uint64_t uNum);
555 
556 static void
557 QCBOREncode_AddUInt64ToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, uint64_t uNum);
558 
559 
598 static void
599 QCBOREncode_AddText(QCBOREncodeContext *pCtx, UsefulBufC Text);
600 
601 static void
602 QCBOREncode_AddTextToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Text);
603 
604 static void
605 QCBOREncode_AddTextToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Text);
606 
607 
616 static void
617 QCBOREncode_AddSZString(QCBOREncodeContext *pCtx, const char *szString);
618 
619 static void
620 QCBOREncode_AddSZStringToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, const char *szString);
621 
622 static void
623 QCBOREncode_AddSZStringToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, const char *szString);
624 
625 
626 #ifndef USEFULBUF_DISABLE_ALL_FLOAT
663 static void
664 QCBOREncode_AddDouble(QCBOREncodeContext *pCtx, double dNum);
665 
666 static void
667 QCBOREncode_AddDoubleToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, double dNum);
668 
669 static void
670 QCBOREncode_AddDoubleToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, double dNum);
671 
672 
686 static void
687 QCBOREncode_AddFloat(QCBOREncodeContext *pCtx, float fNum);
688 
689 static void
690 QCBOREncode_AddFloatToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, float fNum);
691 
692 static void
693 QCBOREncode_AddFloatToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, float dNum);
694 
695 
710 static void
711 QCBOREncode_AddDoubleNoPreferred(QCBOREncodeContext *pCtx, double dNum);
712 
713 static void
714 QCBOREncode_AddDoubleNoPreferredToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, double dNum);
715 
716 static void
717 QCBOREncode_AddDoubleNoPreferredToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, double dNum);
718 
719 
734 static void
735 QCBOREncode_AddFloatNoPreferred(QCBOREncodeContext *pCtx, float fNum);
736 
737 static void
738 QCBOREncode_AddFloatNoPreferredToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, float fNum);
739 
740 static void
741 QCBOREncode_AddFloatNoPreferredToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, float fNum);
742 #endif /* ! USEFULBUF_DISABLE_ALL_FLOAT */
743 
744 
768 static void
769 QCBOREncode_AddTag(QCBOREncodeContext *pCtx, uint64_t uTag);
770 
771 
806 static void
807 QCBOREncode_AddTDateEpoch(QCBOREncodeContext *pCtx,
808  uint8_t uTagRequirement,
809  int64_t nDate);
810 
811 static void
812 QCBOREncode_AddTDateEpochToMapSZ(QCBOREncodeContext *pCtx,
813  const char *szLabel,
814  uint8_t uTagRequirement,
815  int64_t nDate);
816 
817 static void
818 QCBOREncode_AddTDateEpochToMapN(QCBOREncodeContext *pCtx,
819  int64_t nLabel,
820  uint8_t uTagRequirement,
821  int64_t nDate);
822 
823 
824 
825 
826 
845 static void
846 QCBOREncode_AddTDaysEpoch(QCBOREncodeContext *pCtx,
847  uint8_t uTagRequirement,
848  int64_t nDays);
849 
850 static void
851 QCBOREncode_AddTDaysEpochToMapSZ(QCBOREncodeContext *pCtx,
852  const char *szLabel,
853  uint8_t uTagRequirement,
854  int64_t nDays);
855 
856 static void
857 QCBOREncode_AddTDaysEpochToMapN(QCBOREncodeContext *pCtx,
858  int64_t nLabel,
859  uint8_t uTagRequirement,
860  int64_t nDays);
861 
862 
863 
864 
878 static void
879 QCBOREncode_AddBytes(QCBOREncodeContext *pCtx, UsefulBufC Bytes);
880 
881 static void
882 QCBOREncode_AddBytesToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Bytes);
883 
884 static void
885 QCBOREncode_AddBytesToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Bytes);
886 
887 
919 void
920 QCBOREncode_OpenBytes(QCBOREncodeContext *pCtx, UsefulBuf *pPlace);
921 
922 static void
923 QCBOREncode_OpenBytesInMapSZ(QCBOREncodeContext *pCtx,
924  const char *szLabel,
925  UsefulBuf *pPlace);
926 
927 static void
928 QCBOREncode_OpenBytesInMapN(QCBOREncodeContext *pCtx,
929  int64_t nLabel,
930  UsefulBuf *pPlace);
931 
932 
947 void
948 QCBOREncode_CloseBytes(QCBOREncodeContext *pCtx, size_t uAmount);
949 
950 
966 static void
967 QCBOREncode_AddTBinaryUUID(QCBOREncodeContext *pCtx,
968  uint8_t uTagRequirement,
969  UsefulBufC Bytes);
970 
971 static void
972 QCBOREncode_AddTBinaryUUIDToMapSZ(QCBOREncodeContext *pCtx,
973  const char *szLabel,
974  uint8_t uTagRequirement,
975  UsefulBufC Bytes);
976 
977 static void
978 QCBOREncode_AddTBinaryUUIDToMapN(QCBOREncodeContext *pCtx,
979  int64_t nLabel,
980  uint8_t uTagRequirement,
981  UsefulBufC Bytes);
982 
983 
1005 static void
1006 QCBOREncode_AddTPositiveBignum(QCBOREncodeContext *pCtx,
1007  uint8_t uTagRequirement,
1008  UsefulBufC BigNumber);
1009 
1010 static void
1011 QCBOREncode_AddTPositiveBignumToMapSZ(QCBOREncodeContext *pCtx,
1012  const char *szLabel,
1013  uint8_t uTagRequirement,
1014  UsefulBufC BigNumber);
1015 
1016 static void
1017 QCBOREncode_AddTPositiveBignumToMapN(QCBOREncodeContext *pCtx,
1018  int64_t nLabel,
1019  uint8_t uTagRequirement,
1020  UsefulBufC BigNumber);
1021 
1022 
1045 static void
1046 QCBOREncode_AddTNegativeBignum(QCBOREncodeContext *pCtx,
1047  uint8_t uTagRequirement,
1048  UsefulBufC BigNumber);
1049 
1050 static void
1051 QCBOREncode_AddTNegativeBignumToMapSZ(QCBOREncodeContext *pCtx,
1052  const char *szLabel,
1053  uint8_t uTagRequirement,
1054  UsefulBufC BigNumber);
1055 
1056 static void
1057 QCBOREncode_AddTNegativeBignumToMapN(QCBOREncodeContext *pCtx,
1058  int64_t nLabel,
1059  uint8_t uTagRequirement,
1060  UsefulBufC BigNumber);
1061 
1062 
1063 #ifndef QCBOR_DISABLE_EXP_AND_MANTISSA
1104 static void
1105 QCBOREncode_AddTDecimalFraction(QCBOREncodeContext *pCtx,
1106  uint8_t uTagRequirement,
1107  int64_t nMantissa,
1108  int64_t nBase10Exponent);
1109 
1110 static void
1111 QCBOREncode_AddTDecimalFractionToMapSZ(QCBOREncodeContext *pCtx,
1112  const char *szLabel,
1113  uint8_t uTagRequirement,
1114  int64_t nMantissa,
1115  int64_t nBase10Exponent);
1116 
1117 static void
1118 QCBOREncode_AddTDecimalFractionToMapN(QCBOREncodeContext *pCtx,
1119  int64_t nLabel,
1120  uint8_t uTagRequirement,
1121  int64_t nMantissa,
1122  int64_t nBase10Exponent);
1123 
1124 
1145 static void
1146 QCBOREncode_AddTDecimalFractionBigNum(QCBOREncodeContext *pCtx,
1147  uint8_t uTagRequirement,
1148  UsefulBufC Mantissa,
1149  bool bIsNegative,
1150  int64_t nBase10Exponent);
1151 
1152 static void
1153 QCBOREncode_AddTDecimalFractionBigNumToMapSZ(QCBOREncodeContext *pCtx,
1154  const char *szLabel,
1155  uint8_t uTagRequirement,
1156  UsefulBufC Mantissa,
1157  bool bIsNegative,
1158  int64_t nBase10Exponent);
1159 
1160 static void
1161 QCBOREncode_AddTDecimalFractionBigNumToMapN(QCBOREncodeContext *pCtx,
1162  int64_t nLabel,
1163  uint8_t uTagRequirement,
1164  UsefulBufC Mantissa,
1165  bool bIsNegative,
1166  int64_t nBase10Exponent);
1167 
1205 static void
1206 QCBOREncode_AddTBigFloat(QCBOREncodeContext *pCtx,
1207  uint8_t uTagRequirement,
1208  int64_t nMantissa,
1209  int64_t nBase2Exponent);
1210 
1211 static void
1212 QCBOREncode_AddTBigFloatToMapSZ(QCBOREncodeContext *pCtx,
1213  const char *szLabel,
1214  uint8_t uTagRequirement,
1215  int64_t nMantissa,
1216  int64_t nBase2Exponent);
1217 
1218 static void
1219 QCBOREncode_AddTBigFloatToMapN(QCBOREncodeContext *pCtx,
1220  int64_t nLabel,
1221  uint8_t uTagRequirement,
1222  int64_t nMantissa,
1223  int64_t nBase2Exponent);
1224 
1225 
1247 static void
1248 QCBOREncode_AddTBigFloatBigNum(QCBOREncodeContext *pCtx,
1249  uint8_t uTagRequirement,
1250  UsefulBufC Mantissa,
1251  bool bIsNegative,
1252  int64_t nBase2Exponent);
1253 
1254 static void
1255 QCBOREncode_AddTBigFloatBigNumToMapSZ(QCBOREncodeContext *pCtx,
1256  const char *szLabel,
1257  uint8_t uTagRequirement,
1258  UsefulBufC Mantissa,
1259  bool bIsNegative,
1260  int64_t nBase2Exponent);
1261 
1262 static void
1263 QCBOREncode_AddTBigFloatBigNumToMapN(QCBOREncodeContext *pCtx,
1264  int64_t nLabel,
1265  uint8_t uTagRequirement,
1266  UsefulBufC Mantissa,
1267  bool bIsNegative,
1268  int64_t nBase2Exponent);
1269 
1270 #endif /* ! QCBOR_DISABLE_EXP_AND_MANTISSA */
1271 
1272 
1292 static void
1293 QCBOREncode_AddTURI(QCBOREncodeContext *pCtx,
1294  uint8_t uTagRequirement,
1295  UsefulBufC URI);
1296 
1297 static void
1298 QCBOREncode_AddTURIToMapSZ(QCBOREncodeContext *pCtx,
1299  const char *szLabel,
1300  uint8_t uTagRequirement,
1301  UsefulBufC URI);
1302 
1303 static void
1304 QCBOREncode_AddTURIToMapN(QCBOREncodeContext *pCtx,
1305  int64_t nLabel,
1306  uint8_t uTagRequirement,
1307  UsefulBufC URI);
1308 
1309 
1324 static void
1325 QCBOREncode_AddTB64Text(QCBOREncodeContext *pCtx,
1326  uint8_t uTagRequirement,
1327  UsefulBufC B64Text);
1328 
1329 static void
1330 QCBOREncode_AddTB64TextToMapSZ(QCBOREncodeContext *pCtx,
1331  const char *szLabel,
1332  uint8_t uTagRequirement,
1333  UsefulBufC B64Text);
1334 
1335 static void
1336 QCBOREncode_AddTB64TextToMapN(QCBOREncodeContext *pCtx,
1337  int64_t nLabel,
1338  uint8_t uTagRequirement,
1339  UsefulBufC B64Text);
1340 
1341 
1357 static void
1358 QCBOREncode_AddTB64URLText(QCBOREncodeContext *pCtx,
1359  uint8_t uTagRequirement,
1360  UsefulBufC B64Text);
1361 
1362 static void
1363 QCBOREncode_AddTB64URLTextToMapSZ(QCBOREncodeContext *pCtx,
1364  const char *szLabel,
1365  uint8_t uTagRequirement,
1366  UsefulBufC B64Text);
1367 
1368 static void
1369 QCBOREncode_AddTB64URLTextToMapN(QCBOREncodeContext *pCtx,
1370  int64_t nLabel,
1371  uint8_t uTagRequirement,
1372  UsefulBufC B64Text);
1373 
1374 
1389 static void
1390 QCBOREncode_AddTRegex(QCBOREncodeContext *pCtx,
1391  uint8_t uTagRequirement,
1392  UsefulBufC Regex);
1393 
1394 static void
1395 QCBOREncode_AddTRegexToMapSZ(QCBOREncodeContext *pCtx,
1396  const char *szLabel,
1397  uint8_t uTagRequirement,
1398  UsefulBufC Regex);
1399 
1400 static void
1401 QCBOREncode_AddTRegexToMapN(QCBOREncodeContext *pCtx,
1402  int64_t nLabel,
1403  uint8_t uTagRequirement,
1404  UsefulBufC Regex);
1405 
1406 
1435 static void
1436 QCBOREncode_AddTMIMEData(QCBOREncodeContext *pCtx,
1437  uint8_t uTagRequirement,
1438  UsefulBufC MIMEData);
1439 
1440 static void
1441 QCBOREncode_AddTMIMEDataToMapSZ(QCBOREncodeContext *pCtx,
1442  const char *szLabel,
1443  uint8_t uTagRequirement,
1444  UsefulBufC MIMEData);
1445 
1446 static void
1447 QCBOREncode_AddTMIMEDataToMapN(QCBOREncodeContext *pCtx,
1448  int64_t nLabel,
1449  uint8_t uTagRequirement,
1450  UsefulBufC MIMEData);
1451 
1452 
1476 static void
1477 QCBOREncode_AddTDateString(QCBOREncodeContext *pCtx,
1478  uint8_t uTagRequirement,
1479  const char *szDate);
1480 
1481 static void
1482 QCBOREncode_AddTDateStringToMapSZ(QCBOREncodeContext *pCtx,
1483  const char *szLabel,
1484  uint8_t uTagRequirement,
1485  const char *szDate);
1486 
1487 static void
1488 QCBOREncode_AddTDateStringToMapN(QCBOREncodeContext *pCtx,
1489  int64_t nLabel,
1490  uint8_t uTagRequirement,
1491  const char *szDate);
1492 
1493 
1519 static void
1520 QCBOREncode_AddTDaysString(QCBOREncodeContext *pCtx,
1521  uint8_t uTagRequirement,
1522  const char *szDate);
1523 
1524 static void
1525 QCBOREncode_AddTDaysStringToMapSZ(QCBOREncodeContext *pCtx,
1526  const char *szLabel,
1527  uint8_t uTagRequirement,
1528  const char *szDate);
1529 
1530 static void
1531 QCBOREncode_AddTDaysStringToMapN(QCBOREncodeContext *pCtx,
1532  int64_t nLabel,
1533  uint8_t uTagRequirement,
1534  const char *szDate);
1535 
1536 
1547 static void
1548 QCBOREncode_AddBool(QCBOREncodeContext *pCtx, bool b);
1549 
1550 static void
1551 QCBOREncode_AddBoolToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, bool b);
1552 
1553 static void
1554 QCBOREncode_AddBoolToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, bool b);
1555 
1556 
1569 static void
1570 QCBOREncode_AddNULL(QCBOREncodeContext *pCtx);
1571 
1572 static void
1573 QCBOREncode_AddNULLToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel);
1574 
1575 static void
1576 QCBOREncode_AddNULLToMapN(QCBOREncodeContext *pCtx, int64_t nLabel);
1577 
1578 
1593 static void
1594 QCBOREncode_AddUndef(QCBOREncodeContext *pCtx);
1595 
1596 static void
1597 QCBOREncode_AddUndefToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel);
1598 
1599 static void
1600 QCBOREncode_AddUndefToMapN(QCBOREncodeContext *pCtx, int64_t nLabel);
1601 
1602 
1621 static void
1622 QCBOREncode_AddSimple(QCBOREncodeContext *pCtx, const uint8_t uNum);
1623 
1624 static void
1625 QCBOREncode_AddSimpleToMapSZ(QCBOREncodeContext *pCtx,
1626  const char *szLabel,
1627  const uint8_t uSimple);
1628 
1629 static void
1630 QCBOREncode_AddSimpleToMapN(QCBOREncodeContext *pCtx,
1631  const int64_t nLabel,
1632  const uint8_t uSimple);
1633 
1634 
1668 static void
1669 QCBOREncode_OpenArray(QCBOREncodeContext *pCtx);
1670 
1671 static void
1672 QCBOREncode_OpenArrayInMapSZ(QCBOREncodeContext *pCtx, const char *szLabel);
1673 
1674 static void
1675 QCBOREncode_OpenArrayInMapN(QCBOREncodeContext *pCtx, int64_t nLabel);
1676 
1677 
1699 static void
1700 QCBOREncode_CloseArray(QCBOREncodeContext *pCtx);
1701 
1702 
1703 
1704 
1736 static void
1737 QCBOREncode_OpenMap(QCBOREncodeContext *pCtx);
1738 
1739 static void
1740 QCBOREncode_OpenMapInMapSZ(QCBOREncodeContext *pCtx, const char *szLabel);
1741 
1742 static void
1743 QCBOREncode_OpenMapInMapN(QCBOREncodeContext *pCtx, int64_t nLabel);
1744 
1745 
1766 static void
1767 QCBOREncode_CloseMap(QCBOREncodeContext *pCtx);
1768 
1769 
1780 static void
1781 QCBOREncode_OpenArrayIndefiniteLength(QCBOREncodeContext *pCtx);
1782 
1783 static void
1784 QCBOREncode_OpenArrayIndefiniteLengthInMapSZ(QCBOREncodeContext *pCtx,
1785  const char *szLabel);
1786 
1787 static void
1788 QCBOREncode_OpenArrayIndefiniteLengthInMapN(QCBOREncodeContext *pCtx,
1789  int64_t nLabel);
1790 
1791 
1800 static void
1801 QCBOREncode_CloseArrayIndefiniteLength(QCBOREncodeContext *pCtx);
1802 
1803 
1814 static void
1815 QCBOREncode_OpenMapIndefiniteLength(QCBOREncodeContext *pCtx);
1816 
1817 static void
1818 QCBOREncode_OpenMapIndefiniteLengthInMapSZ(QCBOREncodeContext *pCtx,
1819  const char *szLabel);
1820 
1821 static void
1822 QCBOREncode_OpenMapIndefiniteLengthInMapN(QCBOREncodeContext *pCtx,
1823  int64_t nLabel);
1824 
1825 
1826 
1827 
1836 static void
1837 QCBOREncode_CloseMapIndefiniteLength(QCBOREncodeContext *pCtx);
1838 
1839 
1840 
1841 
1873 static void
1874 QCBOREncode_BstrWrap(QCBOREncodeContext *pCtx);
1875 
1876 static void
1877 QCBOREncode_BstrWrapInMapSZ(QCBOREncodeContext *pCtx, const char *szLabel);
1878 
1879 static void
1880 QCBOREncode_BstrWrapInMapN(QCBOREncodeContext *pCtx, int64_t nLabel);
1881 
1882 
1918 void
1919 QCBOREncode_CloseBstrWrap2(QCBOREncodeContext *pCtx, bool bIncludeCBORHead, UsefulBufC *pWrappedCBOR);
1920 
1921 static void
1922 QCBOREncode_CloseBstrWrap(QCBOREncodeContext *pCtx, UsefulBufC *pWrappedCBOR);
1923 
1924 
1941 void
1942 QCBOREncode_CancelBstrWrap(QCBOREncodeContext *pCtx);
1943 
1944 
1963 void
1964 QCBOREncode_AddEncoded(QCBOREncodeContext *pCtx, UsefulBufC Encoded);
1965 
1966 static void
1967 QCBOREncode_AddEncodedToMapSZ(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Encoded);
1968 
1969 static void
1970 QCBOREncode_AddEncodedToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Encoded);
1971 
1972 
2043 QCBORError
2044 QCBOREncode_Finish(QCBOREncodeContext *pCtx, UsefulBufC *pEncodedCBOR);
2045 
2046 
2059 QCBORError
2060 QCBOREncode_FinishGetSize(QCBOREncodeContext *pCtx, size_t *uEncodedLen);
2061 
2062 
2073 static int
2074 QCBOREncode_IsBufferNULL(QCBOREncodeContext *pCtx);
2075 
2076 
2088 static UsefulBuf
2089 QCBOREncode_RetrieveOutputStorage(QCBOREncodeContext *pCtx);
2090 
2091 
2105 static QCBORError
2106 QCBOREncode_GetErrorState(QCBOREncodeContext *pCtx);
2107 
2108 
2141 static size_t
2142 QCBOREncode_Tell(QCBOREncodeContext *pCtx);
2143 
2144 
2171 UsefulBufC
2172 QCBOREncode_SubString(QCBOREncodeContext *pCtx, const size_t uStart);
2173 
2174 
2209 UsefulBufC
2210 QCBOREncode_EncodeHead(UsefulBuf Buffer,
2211  uint8_t uMajorType,
2212  uint8_t uMinLen,
2213  uint64_t uNumber);
2214 
2215 
2216 
2217 
2218 /* ========================================================================= *
2219  * BEGINNING OF DEPRECATED FUNCTIONS *
2220  * *
2221  * There is no plan to remove these in future versions. *
2222  * They just have been replaced by something better. *
2223  * ========================================================================= */
2224 
2225 /* Use QCBOREncode_AddInt64ToMapSZ() instead */
2226 static void
2227 QCBOREncode_AddInt64ToMap(QCBOREncodeContext *pCtx, const char *szLabel, int64_t nNum);
2228 
2229 /* Use QCBOREncode_AddUInt64ToMapSZ() instead */
2230 static void
2231 QCBOREncode_AddUInt64ToMap(QCBOREncodeContext *pCtx, const char *szLabel, uint64_t uNum);
2232 
2233 /* Use QCBOREncode_AddTextToMapSZ() instead */
2234 static void
2235 QCBOREncode_AddTextToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Text);
2236 
2237 /* Use QCBOREncode_AddSZStringToMapSZ() instead */
2238 static void
2239 QCBOREncode_AddSZStringToMap(QCBOREncodeContext *pCtx, const char *szLabel, const char *szString);
2240 
2241 #ifndef USEFULBUF_DISABLE_ALL_FLOAT
2242 /* Use QCBOREncode_AddDoubleToMapSZ() instead */
2243 static void
2244 QCBOREncode_AddDoubleToMap(QCBOREncodeContext *pCtx, const char *szLabel, double dNum);
2245 
2246 /* Use QCBOREncode_AddFloatToMapSZ() instead */
2247 static void
2248 QCBOREncode_AddFloatToMap(QCBOREncodeContext *pCtx, const char *szLabel, float fNum);
2249 
2250 /* Use QCBOREncode_AddDoubleNoPreferredToMapSZ() instead */
2251 static void
2252 QCBOREncode_AddDoubleNoPreferredToMap(QCBOREncodeContext *pCtx, const char *szLabel, double dNum);
2253 
2254 /* Use QCBOREncode_AddFloatNoPreferredToMapSZ() instead */
2255 static void
2256 QCBOREncode_AddFloatNoPreferredToMap(QCBOREncodeContext *pCtx, const char *szLabel, float fNum);
2257 #endif /* ! USEFULBUF_DISABLE_ALL_FLOAT */
2258 
2259 /* Use QCBOREncode_AddTDateEpoch() instead */
2260 static void
2261 QCBOREncode_AddDateEpoch(QCBOREncodeContext *pCtx, int64_t nDate);
2262 
2263 /* Use QCBOREncode_AddTDateEpochToMapSZ() instead */
2264 static void
2265 QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pCtx, const char *szLabel, int64_t nDate);
2266 
2267 /* Use QCBOREncode_AddTDateEpochToMapN() instead */
2268 static void
2269 QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, int64_t nDate);
2270 
2271 /* Use QCBOREncode_AddBytesToMapSZ() instead */
2272 static void
2273 QCBOREncode_AddBytesToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Bytes);
2274 
2275 /* Use QCBOREncode_AddTBinaryUUID() instead */
2276 static void
2277 QCBOREncode_AddBinaryUUID(QCBOREncodeContext *pCtx, UsefulBufC Bytes);
2278 
2279 /* Use QCBOREncode_AddTBinaryUUIDToMapSZ() instead */
2280 static void
2281 QCBOREncode_AddBinaryUUIDToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Bytes);
2282 
2283 /* Use QCBOREncode_AddTBinaryUUIDToMapN() instead */
2284 static void
2285 QCBOREncode_AddBinaryUUIDToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Bytes);
2286 
2287 /* Use QCBOREncode_AddTPositiveBignum() instead */
2288 static void
2289 QCBOREncode_AddPositiveBignum(QCBOREncodeContext *pCtx, UsefulBufC BigNumber);
2290 
2291 /* QCBOREncode_AddTPositiveBignumToMapSZ() instead */
2292 static void
2293 QCBOREncode_AddPositiveBignumToMap(QCBOREncodeContext *pCtx,
2294  const char *szLabel,
2295  UsefulBufC BigNumber);
2296 
2297 /* Use QCBOREncode_AddTPositiveBignumToMapN() instead */
2298 static void
2299 QCBOREncode_AddPositiveBignumToMapN(QCBOREncodeContext *pCtx,
2300  int64_t nLabel,
2301  UsefulBufC BigNumber);
2302 
2303 /* Use QCBOREncode_AddTNegativeBignum() instead */
2304 static void
2305 QCBOREncode_AddNegativeBignum(QCBOREncodeContext *pCtx, UsefulBufC BigNumber);
2306 
2307 /* Use QCBOREncode_AddTNegativeBignumToMapSZ() instead */
2308 static void
2309 QCBOREncode_AddNegativeBignumToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC BigNumber);
2310 
2311 /* Use QCBOREncode_AddTNegativeBignumToMapN() instead */
2312 static void
2313 QCBOREncode_AddNegativeBignumToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC BigNumber);
2314 
2315 
2316 #ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
2317 
2318 /* Use QCBOREncode_AddTDecimalFraction() instead */
2319 static void
2320 QCBOREncode_AddDecimalFraction(QCBOREncodeContext *pCtx,
2321  int64_t nMantissa,
2322  int64_t nBase10Exponent);
2323 
2324 /* Use QCBOREncode_AddTDecimalFractionToMapSZ() instead */
2325 static void
2326 QCBOREncode_AddDecimalFractionToMap(QCBOREncodeContext *pCtx,
2327  const char *szLabel,
2328  int64_t nMantissa,
2329  int64_t nBase10Exponent);
2330 
2331 /* Use QCBOREncode_AddTDecimalFractionToMapN() instead */
2332 static void
2333 QCBOREncode_AddDecimalFractionToMapN(QCBOREncodeContext *pCtx,
2334  int64_t nLabel,
2335  int64_t nMantissa,
2336  int64_t nBase10Exponent);
2337 
2338 /* Use QCBOREncode_AddTDecimalFractionBigNum() instead */
2339 static void
2340 QCBOREncode_AddDecimalFractionBigNum(QCBOREncodeContext *pCtx,
2341  UsefulBufC Mantissa,
2342  bool bIsNegative,
2343  int64_t nBase10Exponent);
2344 
2345 /* Use QCBOREncode_AddTDecimalFractionBigNumToMapSZ() instead */
2346 static void
2347 QCBOREncode_AddDecimalFractionBigNumToMapSZ(QCBOREncodeContext *pCtx,
2348  const char *szLabel,
2349  UsefulBufC Mantissa,
2350  bool bIsNegative,
2351  int64_t nBase10Exponent);
2352 
2353 /* Use QCBOREncode_AddTDecimalFractionBigNumToMapN() instead */
2354 static void
2355 QCBOREncode_AddDecimalFractionBigNumToMapN(QCBOREncodeContext *pCtx,
2356  int64_t nLabel,
2357  UsefulBufC Mantissa,
2358  bool bIsNegative,
2359  int64_t nBase10Exponent);
2360 
2361 /* Use QCBOREncode_AddTBigFloat() instead */
2362 static void
2363 QCBOREncode_AddBigFloat(QCBOREncodeContext *pCtx,
2364  int64_t nMantissa,
2365  int64_t nBase2Exponent);
2366 
2367 /* Use QCBOREncode_AddTBigFloatToMapSZ() instead */
2368 static void
2369 QCBOREncode_AddBigFloatToMap(QCBOREncodeContext *pCtx,
2370  const char *szLabel,
2371  int64_t nMantissa,
2372  int64_t nBase2Exponent);
2373 
2374 /* Use QCBOREncode_AddTBigFloatToMapN() instead */
2375 static void
2376 QCBOREncode_AddBigFloatToMapN(QCBOREncodeContext *pCtx,
2377  int64_t nLabel,
2378  int64_t nMantissa,
2379  int64_t nBase2Exponent);
2380 
2381 /* Use QCBOREncode_AddTBigFloatBigNum() instead */
2382 static void
2383 QCBOREncode_AddBigFloatBigNum(QCBOREncodeContext *pCtx,
2384  UsefulBufC Mantissa,
2385  bool bIsNegative,
2386  int64_t nBase2Exponent);
2387 
2388 /* Use QCBOREncode_AddTBigFloatBigNumToMapSZ() instead */
2389 static void
2390 QCBOREncode_AddBigFloatBigNumToMap(QCBOREncodeContext *pCtx,
2391  const char *szLabel,
2392  UsefulBufC Mantissa,
2393  bool bIsNegative,
2394  int64_t nBase2Exponent);
2395 
2396 /* Use QCBOREncode_AddTBigFloatBigNumToMapN() instead */
2397 static void
2398 QCBOREncode_AddBigFloatBigNumToMapN(QCBOREncodeContext *pCtx,
2399  int64_t nLabel,
2400  UsefulBufC Mantissa,
2401  bool bIsNegative,
2402  int64_t nBase2Exponent);
2403 #endif /* ! QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
2404 
2405 /* Use QCBOREncode_AddTURI() instead */
2406 static void
2407 QCBOREncode_AddURI(QCBOREncodeContext *pCtx, UsefulBufC URI);
2408 
2409 /* Use QCBOREncode_AddTURIToMapSZ() instead */
2410 static void
2411 QCBOREncode_AddURIToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC URI);
2412 
2413 /* Use QCBOREncode_AddTURIToMapN() instead */
2414 static void
2415 QCBOREncode_AddURIToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC URI);
2416 
2417 /* Use QCBOREncode_AddTB64Text() instead */
2418 static void
2419 QCBOREncode_AddB64Text(QCBOREncodeContext *pCtx, UsefulBufC B64Text);
2420 
2421 /* Use QCBOREncode_AddTB64TextToMapSZ() instead */
2422 static void
2423 QCBOREncode_AddB64TextToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC B64Text);
2424 
2425 /* Use QCBOREncode_AddTB64TextToMapN() instead */
2426 static void
2427 QCBOREncode_AddB64TextToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC B64Text);
2428 
2429 /* Use QCBOREncode_AddTB64URLText() instead */
2430 static void
2431 QCBOREncode_AddB64URLText(QCBOREncodeContext *pCtx, UsefulBufC B64Text);
2432 
2433 /* Use QCBOREncode_AddTB64URLTextToMapSZ() instead */
2434 static void
2435 QCBOREncode_AddB64URLTextToMap(QCBOREncodeContext *pCtx,
2436  const char *szLabel,
2437  UsefulBufC B64Text);
2438 
2439 /* Use QCBOREncode_AddTB64URLTextToMapN() instead */
2440 static void
2441 QCBOREncode_AddB64URLTextToMapN(QCBOREncodeContext *pCtx,
2442  int64_t nLabel,
2443  UsefulBufC B64Text);
2444 
2445 /* Use QCBOREncode_AddTRegex() instead */
2446 static void
2447 QCBOREncode_AddRegex(QCBOREncodeContext *pCtx, UsefulBufC Regex);
2448 
2449 /* Use QCBOREncode_AddTRegexToMapSZ() instead */
2450 static void
2451 QCBOREncode_AddRegexToMap(QCBOREncodeContext *pCtx,
2452  const char *szLabel,
2453  UsefulBufC Regex);
2454 
2455 /* Use QCBOREncode_AddTRegexToMapN() instead */
2456 static void
2457 QCBOREncode_AddRegexToMapN(QCBOREncodeContext *pCtx,
2458  int64_t nLabel,
2459  UsefulBufC Regex);
2460 
2461 /* Use QCBOREncode_AddTMIMEData() instead */
2462 static void
2463 QCBOREncode_AddMIMEData(QCBOREncodeContext *pCtx, UsefulBufC MIMEData);
2464 
2465 /* Use QCBOREncode_AddTMIMEDataToMapSZ() instead */
2466 static void
2467 QCBOREncode_AddMIMEDataToMap(QCBOREncodeContext *pCtx,
2468  const char *szLabel,
2469  UsefulBufC MIMEData);
2470 
2471 /* Use QCBOREncode_AddTMIMEDataToMapN() instead */
2472 static void
2473 QCBOREncode_AddMIMEDataToMapN(QCBOREncodeContext *pCtx,
2474  int64_t nLabel,
2475  UsefulBufC MIMEData);
2476 
2477 /* Use QCBOREncode_AddTDateString() instead */
2478 static void
2479 QCBOREncode_AddDateString(QCBOREncodeContext *pCtx, const char *szDate);
2480 
2481 /* Use QCBOREncode_AddTDateStringToMapSZ() instead */
2482 static void
2483 QCBOREncode_AddDateStringToMap(QCBOREncodeContext *pCtx,
2484  const char *szLabel,
2485  const char *szDate);
2486 
2487 /* Use QCBOREncode_AddTDateStringToMapN instead */
2488 static void
2489 QCBOREncode_AddDateStringToMapN(QCBOREncodeContext *pCtx,
2490  int64_t nLabel,
2491  const char *szDate);
2492 
2493 /* Use QCBOREncode_AddBoolToMapSZ() instead */
2494 static void
2495 QCBOREncode_AddBoolToMap(QCBOREncodeContext *pCtx, const char *szLabel, bool b);
2496 
2497 /* Use QCBOREncode_AddNULLToMapSZ() instead */
2498 static void
2499 QCBOREncode_AddNULLToMap(QCBOREncodeContext *pCtx, const char *szLabel);
2500 
2501 /* Use QCBOREncode_AddUndefToMapSZ() instead */
2502 static void
2503 QCBOREncode_AddUndefToMap(QCBOREncodeContext *pCtx, const char *szLabel);
2504 
2505 /* Use QCBOREncode_AddSimpleToMapSZ instead */
2506 static void
2507 QCBOREncode_AddSimpleToMap(QCBOREncodeContext *pCtx,
2508  const char *szLabel,
2509  const uint8_t uSimple);
2510 
2511 /* Use QCBOREncode_OpenArrayInMapSZ() instead */
2512 static void
2513 QCBOREncode_OpenArrayInMap(QCBOREncodeContext *pCtx, const char *szLabel);
2514 
2515 /* Use QCBOREncode_OpenMapInMapSZ() instead */
2516 static void
2517 QCBOREncode_OpenMapInMap(QCBOREncodeContext *pCtx, const char *szLabel);
2518 
2519 /* Use QCBOREncode_OpenArrayIndefiniteLengthInMapSZ() instead */
2520 static void
2521 QCBOREncode_OpenArrayIndefiniteLengthInMap(QCBOREncodeContext *pCtx,
2522  const char *szLabel);
2523 
2524 /* Use QCBOREncode_OpenMapIndefiniteLengthInMapSZ() instead */
2525 static void
2526 QCBOREncode_OpenMapIndefiniteLengthInMap(QCBOREncodeContext *pCtx,
2527  const char *szLabel);
2528 
2529 /* Use QCBOREncode_BstrWrapInMapSZ() instead */
2530 static void
2531 QCBOREncode_BstrWrapInMap(QCBOREncodeContext *pCtx, const char *szLabel);
2532 
2533 /* Use QCBOREncode_AddEncodedToMapSZ() instead */
2534 static void
2535 QCBOREncode_AddEncodedToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Encoded);
2536 
2537 
2538 /* ========================================================================= *
2539  * END OF DEPRECATED FUNCTIONS *
2540  * ========================================================================= */
2541 
2542 
2543 
2544 
2545 
2546 /* ========================================================================= *
2547  * BEGINNING OF PRIVATE INLINE IMPLEMENTATION *
2548  * ========================================================================= */
2549 
2550 /* Semi-private funcion used by public inline functions. See qcbor_encode.c */
2551 void QCBOREncode_Private_AppendCBORHead(QCBOREncodeContext *pMe,
2552  const uint8_t uMajorType,
2553  const uint64_t uArgument,
2554  const uint8_t uMinLen);
2555 
2556 
2557 /* Semi-private funcion used by public inline functions. See qcbor_encode.c */
2558 void
2559 QCBOREncode_Private_AddBuffer(QCBOREncodeContext *pCtx,
2560  uint8_t uMajorType,
2561  UsefulBufC Bytes);
2562 
2563 
2564 /* Semi-private function for adding a double with preferred encoding. See qcbor_encode.c */
2565 void
2566 QCBOREncode_Private_AddPreferredDouble(QCBOREncodeContext *pMe, const double dNum);
2567 
2568 
2569 /* Semi-private function for adding a float with preferred encoding. See qcbor_encode.c */
2570 void
2571 QCBOREncode_Private_AddPreferredFloat(QCBOREncodeContext *pMe, const float fNum);
2572 
2573 
2574 /* Semi-private funcion used by public inline functions. See qcbor_encode.c */
2575 void
2576 QCBOREncode_Private_OpenMapOrArray(QCBOREncodeContext *pCtx,
2577  uint8_t uMajorType);
2578 
2579 
2580 /* Semi-private funcion used by public inline functions. See qcbor_encode.c */
2581 void
2582 QCBOREncode_Private_OpenMapOrArrayIndefiniteLength(QCBOREncodeContext *pCtx,
2583  uint8_t uMajorType);
2584 
2585 
2586 /* Semi-private funcion used by public inline functions. See qcbor_encode.c */
2587 void
2588 QCBOREncode_Private_CloseMapOrArray(QCBOREncodeContext *pCtx,
2589  uint8_t uMajorType);
2590 
2591 
2592 /* Semi-private funcion used by public inline functions. See qcbor_encode.c */
2593 void
2594 QCBOREncode_Private_CloseMapOrArrayIndefiniteLength(QCBOREncodeContext *pCtx,
2595  uint8_t uMajorType);
2596 
2597 
2598 /* Semi-private funcion used by public inline functions. See qcbor_encode.c */
2599 void
2600 QCBOREncode_Private_AddExpMantissa(QCBOREncodeContext *pCtx,
2601  uint64_t uTag,
2602  UsefulBufC BigNumMantissa,
2603  bool bBigNumIsNegative,
2604  int64_t nMantissa,
2605  int64_t nExponent);
2606 
2607 
2623 static inline void
2624 QCBOREncode_Private_AddType7(QCBOREncodeContext *pMe,
2625  const uint8_t uMinLen,
2626  const uint64_t uArgument)
2627 {
2628  QCBOREncode_Private_AppendCBORHead(pMe, CBOR_MAJOR_TYPE_SIMPLE, uArgument, uMinLen);
2629 }
2630 
2631 
2656 static void
2657 QCBOREncode_AddBytesLenOnly(QCBOREncodeContext *pCtx,
2658  UsefulBufC Bytes);
2659 
2660 static void
2661 QCBOREncode_AddBytesLenOnlyToMap(QCBOREncodeContext *pCtx,
2662  const char *szLabel,
2663  UsefulBufC Bytes);
2664 
2665 static void
2666 QCBOREncode_AddBytesLenOnlyToMapN(QCBOREncodeContext *pCtx,
2667  int64_t nLabel,
2668  UsefulBufC Bytes);
2669 
2670 
2671 /* Forward declaration */
2672 static void
2673 QCBOREncode_AddSZString(QCBOREncodeContext *pMe, const char *szString);
2674 
2675 
2676 
2677 
2678 static inline void
2679 QCBOREncode_AddInt64ToMapSZ(QCBOREncodeContext *pMe,
2680  const char *szLabel,
2681  const int64_t nNum)
2682 {
2683  QCBOREncode_AddSZString(pMe, szLabel);
2684  QCBOREncode_AddInt64(pMe, nNum);
2685 }
2686 
2687 static inline void
2688 QCBOREncode_AddInt64ToMap(QCBOREncodeContext *pMe, const char *szLabel, int64_t nNum)
2689 {
2690  QCBOREncode_AddInt64ToMapSZ(pMe, szLabel, nNum);
2691 }
2692 
2693 static inline void
2694 QCBOREncode_AddInt64ToMapN(QCBOREncodeContext *pMe,
2695  const int64_t nLabel,
2696  const int64_t nNum)
2697 {
2698  QCBOREncode_AddInt64(pMe, nLabel);
2699  QCBOREncode_AddInt64(pMe, nNum);
2700 }
2701 
2702 
2703 static inline void
2704 QCBOREncode_AddUInt64(QCBOREncodeContext *pMe, const uint64_t uValue)
2705 {
2706  QCBOREncode_Private_AppendCBORHead(pMe, CBOR_MAJOR_TYPE_POSITIVE_INT, uValue, 0);
2707 }
2708 
2709 
2710 static inline void
2711 QCBOREncode_AddUInt64ToMapSZ(QCBOREncodeContext *pMe,
2712  const char *szLabel,
2713  const uint64_t uNum)
2714 {
2715  QCBOREncode_AddSZString(pMe, szLabel);
2716  QCBOREncode_AddUInt64(pMe, uNum);
2717 }
2718 
2719 static inline void
2720 QCBOREncode_AddUInt64ToMap(QCBOREncodeContext *pMe, const char *szLabel, uint64_t uNum)
2721 {
2722  QCBOREncode_AddUInt64ToMapSZ(pMe, szLabel, uNum);
2723 }
2724 
2725 static inline void
2726 QCBOREncode_AddUInt64ToMapN(QCBOREncodeContext *pMe,
2727  const int64_t nLabel,
2728  const uint64_t uNum)
2729 {
2730  QCBOREncode_AddInt64(pMe, nLabel);
2731  QCBOREncode_AddUInt64(pMe, uNum);
2732 }
2733 
2734 
2735 static inline void
2736 QCBOREncode_AddText(QCBOREncodeContext *pMe, const UsefulBufC Text)
2737 {
2738  QCBOREncode_Private_AddBuffer(pMe, CBOR_MAJOR_TYPE_TEXT_STRING, Text);
2739 }
2740 
2741 static inline void
2742 QCBOREncode_AddTextToMapSZ(QCBOREncodeContext *pMe,
2743  const char *szLabel,
2744  const UsefulBufC Text)
2745 {
2746  QCBOREncode_AddText(pMe, UsefulBuf_FromSZ(szLabel));
2747  QCBOREncode_AddText(pMe, Text);
2748 }
2749 
2750 static inline void
2751 QCBOREncode_AddTextToMap(QCBOREncodeContext *pMe, const char *szLabel, UsefulBufC Text)
2752 {
2753  QCBOREncode_AddTextToMapSZ(pMe, szLabel, Text);
2754 }
2755 
2756 static inline void
2757 QCBOREncode_AddTextToMapN(QCBOREncodeContext *pMe,
2758  const int64_t nLabel,
2759  const UsefulBufC Text)
2760 {
2761  QCBOREncode_AddInt64(pMe, nLabel);
2762  QCBOREncode_AddText(pMe, Text);
2763 }
2764 
2765 
2766 inline static void
2767 QCBOREncode_AddSZString(QCBOREncodeContext *pMe, const char *szString)
2768 {
2769  QCBOREncode_AddText(pMe, UsefulBuf_FromSZ(szString));
2770 }
2771 
2772 static inline void
2773 QCBOREncode_AddSZStringToMapSZ(QCBOREncodeContext *pMe,
2774  const char *szLabel,
2775  const char *szString)
2776 {
2777  QCBOREncode_AddSZString(pMe, szLabel);
2778  QCBOREncode_AddSZString(pMe, szString);
2779 }
2780 
2781 static inline void
2782 QCBOREncode_AddSZStringToMap(QCBOREncodeContext *pMe, const char *szLabel, const char *szString)
2783 {
2784  QCBOREncode_AddSZStringToMapSZ(pMe, szLabel, szString);
2785 }
2786 
2787 static inline void
2788 QCBOREncode_AddSZStringToMapN(QCBOREncodeContext *pMe,
2789  const int64_t nLabel,
2790  const char *szString)
2791 {
2792  QCBOREncode_AddInt64(pMe, nLabel);
2793  QCBOREncode_AddSZString(pMe, szString);
2794 }
2795 
2796 
2797 static inline void
2798 QCBOREncode_AddTag(QCBOREncodeContext *pMe, const uint64_t uTag)
2799 {
2800  QCBOREncode_Private_AppendCBORHead(pMe, CBOR_MAJOR_TYPE_TAG, uTag, 0);
2801 }
2802 
2803 
2804 
2805 
2806 #ifndef USEFULBUF_DISABLE_ALL_FLOAT
2807 
2808 static inline void
2809 QCBOREncode_AddDoubleNoPreferred(QCBOREncodeContext *pMe, const double dNum)
2810 {
2811  QCBOREncode_Private_AddType7(pMe,
2812  sizeof(uint64_t),
2813  UsefulBufUtil_CopyDoubleToUint64(dNum));
2814 }
2815 
2816 static inline void
2817 QCBOREncode_AddFloatNoPreferred(QCBOREncodeContext *pMe, const float fNum)
2818 {
2819  QCBOREncode_Private_AddType7(pMe,
2820  sizeof(uint32_t),
2821  UsefulBufUtil_CopyFloatToUint32(fNum));
2822 }
2823 
2824 
2825 static inline void
2826 QCBOREncode_AddDouble(QCBOREncodeContext *pMe, const double dNum)
2827 {
2828 #ifndef QCBOR_DISABLE_PREFERRED_FLOAT
2829  QCBOREncode_Private_AddPreferredDouble(pMe, dNum);
2830 #else /* QCBOR_DISABLE_PREFERRED_FLOAT */
2831  QCBOREncode_AddDoubleNoPreferred(pMe, dNum);
2832 #endif /* ! QCBOR_DISABLE_PREFERRED_FLOAT */
2833 }
2834 
2835 static inline void
2836 QCBOREncode_AddDoubleToMapSZ(QCBOREncodeContext *pMe,
2837  const char *szLabel,
2838  const double dNum)
2839 {
2840  QCBOREncode_AddSZString(pMe, szLabel);
2841  QCBOREncode_AddDouble(pMe, dNum);
2842 }
2843 
2844 static inline void
2845 QCBOREncode_AddDoubleToMap(QCBOREncodeContext *pMe, const char *szLabel, double dNum)
2846 {
2847  QCBOREncode_AddDoubleToMapSZ(pMe, szLabel, dNum);
2848 }
2849 
2850 static inline void
2851 QCBOREncode_AddDoubleToMapN(QCBOREncodeContext *pMe,
2852  const int64_t nLabel,
2853  const double dNum)
2854 {
2855  QCBOREncode_AddInt64(pMe, nLabel);
2856  QCBOREncode_AddDouble(pMe, dNum);
2857 }
2858 
2859 
2860 static inline void
2861 QCBOREncode_AddFloat(QCBOREncodeContext *pMe, const float fNum)
2862 {
2863 #ifndef QCBOR_DISABLE_PREFERRED_FLOAT
2864  QCBOREncode_Private_AddPreferredFloat(pMe, fNum);
2865 #else /* QCBOR_DISABLE_PREFERRED_FLOAT */
2866  QCBOREncode_AddFloatNoPreferred(pMe, fNum);
2867 #endif /* ! QCBOR_DISABLE_PREFERRED_FLOAT */
2868 }
2869 
2870 static inline void
2871 QCBOREncode_AddFloatToMapSZ(QCBOREncodeContext *pMe,
2872  const char *szLabel,
2873  const float dNum)
2874 {
2875  QCBOREncode_AddSZString(pMe, szLabel);
2876  QCBOREncode_AddFloat(pMe, dNum);
2877 }
2878 
2879 static inline void
2880 QCBOREncode_AddFloatToMap(QCBOREncodeContext *pMe, const char *szLabel, float fNum)
2881 {
2882  QCBOREncode_AddFloatToMapSZ(pMe, szLabel, fNum);
2883 }
2884 
2885 static inline void
2886 QCBOREncode_AddFloatToMapN(QCBOREncodeContext *pMe,
2887  const int64_t nLabel,
2888  const float fNum)
2889 {
2890  QCBOREncode_AddInt64(pMe, nLabel);
2891  QCBOREncode_AddFloat(pMe, fNum);
2892 }
2893 
2894 static inline void
2895 QCBOREncode_AddDoubleNoPreferredToMapSZ(QCBOREncodeContext *pMe,
2896  const char *szLabel,
2897  const double dNum)
2898 {
2899  QCBOREncode_AddSZString(pMe, szLabel);
2900  QCBOREncode_AddDoubleNoPreferred(pMe, dNum);
2901 }
2902 
2903 static inline void
2904 QCBOREncode_AddDoubleNoPreferredToMap(QCBOREncodeContext *pMe, const char *szLabel, double dNum)
2905 {
2906  QCBOREncode_AddDoubleNoPreferredToMapSZ(pMe, szLabel, dNum);
2907 }
2908 
2909 static inline void
2910 QCBOREncode_AddDoubleNoPreferredToMapN(QCBOREncodeContext *pMe,
2911  const int64_t nLabel,
2912  const double dNum)
2913 {
2914  QCBOREncode_AddInt64(pMe, nLabel);
2915  QCBOREncode_AddDoubleNoPreferred(pMe, dNum);
2916 }
2917 
2918 static inline void
2919 QCBOREncode_AddFloatNoPreferredToMapSZ(QCBOREncodeContext *pMe,
2920  const char *szLabel,
2921  const float dNum)
2922 {
2923  QCBOREncode_AddSZString(pMe, szLabel);
2924  QCBOREncode_AddFloatNoPreferred(pMe, dNum);
2925 }
2926 
2927 static inline void
2928 QCBOREncode_AddFloatNoPreferredToMap(QCBOREncodeContext *pMe, const char *szLabel, float fNum)
2929 {
2930  QCBOREncode_AddFloatNoPreferredToMapSZ(pMe, szLabel, fNum);
2931 }
2932 
2933 static inline void
2934 QCBOREncode_AddFloatNoPreferredToMapN(QCBOREncodeContext *pMe,
2935  const int64_t nLabel,
2936  const float dNum)
2937 {
2938  QCBOREncode_AddInt64(pMe, nLabel);
2939  QCBOREncode_AddFloatNoPreferred(pMe, dNum);
2940 }
2941 #endif /* ! USEFULBUF_DISABLE_ALL_FLOAT */
2942 
2943 
2944 
2945 
2946 
2947 static inline void
2948 QCBOREncode_AddTDateEpoch(QCBOREncodeContext *pMe,
2949  const uint8_t uTag,
2950  const int64_t nDate)
2951 {
2952  if(uTag == QCBOR_ENCODE_AS_TAG) {
2953  QCBOREncode_AddTag(pMe, CBOR_TAG_DATE_EPOCH);
2954  }
2955  QCBOREncode_AddInt64(pMe, nDate);
2956 }
2957 
2958 static inline void
2959 QCBOREncode_AddTDateEpochToMapSZ(QCBOREncodeContext *pMe,
2960  const char *szLabel,
2961  const uint8_t uTag,
2962  const int64_t nDate)
2963 {
2964  QCBOREncode_AddSZString(pMe, szLabel);
2965  QCBOREncode_AddTDateEpoch(pMe, uTag, nDate);
2966 }
2967 
2968 static inline void
2969 QCBOREncode_AddTDateEpochToMapN(QCBOREncodeContext *pMe,
2970  const int64_t nLabel,
2971  const uint8_t uTag,
2972  const int64_t nDate)
2973 {
2974  QCBOREncode_AddInt64(pMe, nLabel);
2975  QCBOREncode_AddTDateEpoch(pMe, uTag, nDate);
2976 }
2977 
2978 static inline void
2979 QCBOREncode_AddDateEpoch(QCBOREncodeContext *pMe,
2980  const int64_t nDate)
2981 {
2982  QCBOREncode_AddTDateEpoch(pMe, QCBOR_ENCODE_AS_TAG, nDate);
2983 }
2984 
2985 static inline void
2986 QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pMe,
2987  const char *szLabel,
2988  const int64_t nDate)
2989 {
2990  QCBOREncode_AddSZString(pMe, szLabel);
2991  QCBOREncode_AddDateEpoch(pMe, nDate);
2992 }
2993 
2994 static inline void
2995 QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pMe,
2996  const int64_t nLabel,
2997  const int64_t nDate)
2998 {
2999  QCBOREncode_AddInt64(pMe, nLabel);
3000  QCBOREncode_AddDateEpoch(pMe, nDate);
3001 }
3002 
3003 
3004 static inline void
3005 QCBOREncode_AddTDaysEpoch(QCBOREncodeContext *pMe,
3006  const uint8_t uTag,
3007  const int64_t nDays)
3008 {
3009  if(uTag == QCBOR_ENCODE_AS_TAG) {
3010  QCBOREncode_AddTag(pMe, CBOR_TAG_DAYS_EPOCH);
3011  }
3012  QCBOREncode_AddInt64(pMe, nDays);
3013 }
3014 
3015 static inline void
3016 QCBOREncode_AddTDaysEpochToMapSZ(QCBOREncodeContext *pMe,
3017  const char *szLabel,
3018  const uint8_t uTag,
3019  const int64_t nDays)
3020 {
3021  QCBOREncode_AddSZString(pMe, szLabel);
3022  QCBOREncode_AddTDaysEpoch(pMe, uTag, nDays);
3023 }
3024 
3025 static inline void
3026 QCBOREncode_AddTDaysEpochToMapN(QCBOREncodeContext *pMe,
3027  const int64_t nLabel,
3028  const uint8_t uTag,
3029  const int64_t nDays)
3030 {
3031  QCBOREncode_AddInt64(pMe, nLabel);
3032  QCBOREncode_AddTDaysEpoch(pMe, uTag, nDays);
3033 }
3034 
3035 
3036 static inline void
3037 QCBOREncode_AddBytes(QCBOREncodeContext *pMe,
3038  const UsefulBufC Bytes)
3039 {
3040  QCBOREncode_Private_AddBuffer(pMe, CBOR_MAJOR_TYPE_BYTE_STRING, Bytes);
3041 }
3042 
3043 static inline void
3044 QCBOREncode_AddBytesToMapSZ(QCBOREncodeContext *pMe,
3045  const char *szLabel,
3046  const UsefulBufC Bytes)
3047 {
3048  QCBOREncode_AddSZString(pMe, szLabel);
3049  QCBOREncode_AddBytes(pMe, Bytes);
3050 }
3051 
3052 static inline void
3053 QCBOREncode_AddBytesToMap(QCBOREncodeContext *pMe, const char *szLabel, UsefulBufC Bytes)
3054 {
3055  QCBOREncode_AddBytesToMapSZ(pMe, szLabel, Bytes);
3056 }
3057 
3058 static inline void
3059 QCBOREncode_AddBytesToMapN(QCBOREncodeContext *pMe,
3060  const int64_t nLabel,
3061  const UsefulBufC Bytes)
3062 {
3063  QCBOREncode_AddInt64(pMe, nLabel);
3064  QCBOREncode_AddBytes(pMe, Bytes);
3065 }
3066 
3067 static inline void
3068 QCBOREncode_OpenBytesInMapSZ(QCBOREncodeContext *pMe,
3069  const char *szLabel,
3070  UsefulBuf *pPlace)
3071 {
3072  QCBOREncode_AddSZString(pMe, szLabel);
3073  QCBOREncode_OpenBytes(pMe, pPlace);
3074 }
3075 
3076 static inline void
3077 QCBOREncode_OpenBytesInMapN(QCBOREncodeContext *pMe,
3078  const int64_t nLabel,
3079  UsefulBuf *pPlace)
3080 {
3081  QCBOREncode_AddInt64(pMe, nLabel);
3082  QCBOREncode_OpenBytes(pMe, pPlace);
3083 }
3084 
3085 
3086 static inline void
3087 QCBOREncode_AddBytesLenOnly(QCBOREncodeContext *pMe, const UsefulBufC Bytes)
3088 {
3089  QCBOREncode_Private_AppendCBORHead(pMe, CBOR_MAJOR_TYPE_BYTE_STRING, Bytes.len, 0);
3090 }
3091 
3092 
3093 static inline void
3094 QCBOREncode_AddBytesLenOnlyToMap(QCBOREncodeContext *pMe,
3095  const char *szLabel,
3096  const UsefulBufC Bytes)
3097 {
3098  QCBOREncode_AddSZString(pMe, szLabel);
3099  QCBOREncode_AddBytesLenOnly(pMe, Bytes);
3100 }
3101 
3102 static inline void
3103 QCBOREncode_AddBytesLenOnlyToMapN(QCBOREncodeContext *pMe,
3104  const int64_t nLabel,
3105  const UsefulBufC Bytes)
3106 {
3107  QCBOREncode_AddInt64(pMe, nLabel);
3108  QCBOREncode_AddBytesLenOnly(pMe, Bytes);
3109 }
3110 
3111 
3112 static inline void
3113 QCBOREncode_AddTBinaryUUID(QCBOREncodeContext *pMe,
3114  const uint8_t uTagRequirement,
3115  const UsefulBufC Bytes)
3116 {
3117  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3118  QCBOREncode_AddTag(pMe, CBOR_TAG_BIN_UUID);
3119  }
3120  QCBOREncode_AddBytes(pMe, Bytes);
3121 }
3122 
3123 static inline void
3124 QCBOREncode_AddTBinaryUUIDToMapSZ(QCBOREncodeContext *pMe,
3125  const char *szLabel,
3126  const uint8_t uTagRequirement,
3127  const UsefulBufC Bytes)
3128 {
3129  QCBOREncode_AddSZString(pMe, szLabel);
3130  QCBOREncode_AddTBinaryUUID(pMe, uTagRequirement, Bytes);
3131 }
3132 
3133 static inline void
3134 QCBOREncode_AddTBinaryUUIDToMapN(QCBOREncodeContext *pMe,
3135  const int64_t nLabel,
3136  const uint8_t uTagRequirement,
3137  const UsefulBufC Bytes)
3138 {
3139  QCBOREncode_AddInt64(pMe, nLabel);
3140  QCBOREncode_AddTBinaryUUID(pMe, uTagRequirement, Bytes);
3141 }
3142 
3143 static inline void
3144 QCBOREncode_AddBinaryUUID(QCBOREncodeContext *pMe, const UsefulBufC Bytes)
3145 {
3146  QCBOREncode_AddTBinaryUUID(pMe, QCBOR_ENCODE_AS_TAG, Bytes);
3147 }
3148 
3149 static inline void
3150 QCBOREncode_AddBinaryUUIDToMap(QCBOREncodeContext *pMe,
3151  const char *szLabel,
3152  const UsefulBufC Bytes)
3153 {
3154  QCBOREncode_AddTBinaryUUIDToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, Bytes);
3155 }
3156 
3157 static inline void
3158 QCBOREncode_AddBinaryUUIDToMapN(QCBOREncodeContext *pMe,
3159  const int64_t nLabel,
3160  const UsefulBufC Bytes)
3161 {
3162  QCBOREncode_AddTBinaryUUIDToMapN(pMe,
3163  nLabel,
3164  QCBOR_ENCODE_AS_TAG,
3165  Bytes);
3166 }
3167 
3168 
3169 static inline void
3170 QCBOREncode_AddTPositiveBignum(QCBOREncodeContext *pMe,
3171  const uint8_t uTagRequirement,
3172  const UsefulBufC Bytes)
3173 {
3174  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3175  QCBOREncode_AddTag(pMe, CBOR_TAG_POS_BIGNUM);
3176  }
3177  QCBOREncode_AddBytes(pMe, Bytes);
3178 }
3179 
3180 static inline void
3181 QCBOREncode_AddTPositiveBignumToMapSZ(QCBOREncodeContext *pMe,
3182  const char *szLabel,
3183  const uint8_t uTagRequirement,
3184  const UsefulBufC Bytes)
3185 {
3186  QCBOREncode_AddSZString(pMe, szLabel);
3187  QCBOREncode_AddTPositiveBignum(pMe, uTagRequirement, Bytes);
3188 }
3189 
3190 static inline void
3191 QCBOREncode_AddTPositiveBignumToMapN(QCBOREncodeContext *pMe,
3192  const int64_t nLabel,
3193  const uint8_t uTagRequirement,
3194  const UsefulBufC Bytes)
3195 {
3196  QCBOREncode_AddInt64(pMe, nLabel);
3197  QCBOREncode_AddTPositiveBignum(pMe, uTagRequirement, Bytes);
3198 }
3199 
3200 static inline void
3201 QCBOREncode_AddPositiveBignum(QCBOREncodeContext *pMe, const UsefulBufC Bytes)
3202 {
3203  QCBOREncode_AddTPositiveBignum(pMe, QCBOR_ENCODE_AS_TAG, Bytes);
3204 }
3205 
3206 static inline void
3207 QCBOREncode_AddPositiveBignumToMap(QCBOREncodeContext *pMe,
3208  const char *szLabel,
3209  const UsefulBufC Bytes)
3210 {
3211  QCBOREncode_AddTPositiveBignumToMapSZ(pMe,
3212  szLabel,
3213  QCBOR_ENCODE_AS_TAG,
3214  Bytes);
3215 }
3216 
3217 static inline void
3218 QCBOREncode_AddPositiveBignumToMapN(QCBOREncodeContext *pMe,
3219  const int64_t nLabel,
3220  const UsefulBufC Bytes)
3221 {
3222  QCBOREncode_AddTPositiveBignumToMapN(pMe,
3223  nLabel,
3224  QCBOR_ENCODE_AS_TAG,
3225  Bytes);
3226 }
3227 
3228 
3229 static inline void
3230 QCBOREncode_AddTNegativeBignum(QCBOREncodeContext *pMe,
3231  const uint8_t uTagRequirement,
3232  const UsefulBufC Bytes)
3233 {
3234  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3235  QCBOREncode_AddTag(pMe, CBOR_TAG_NEG_BIGNUM);
3236  }
3237  QCBOREncode_AddBytes(pMe, Bytes);
3238 }
3239 
3240 static inline void
3241 QCBOREncode_AddTNegativeBignumToMapSZ(QCBOREncodeContext *pMe,
3242  const char *szLabel,
3243  const uint8_t uTagRequirement,
3244  const UsefulBufC Bytes)
3245 {
3246  QCBOREncode_AddSZString(pMe, szLabel);
3247  QCBOREncode_AddTNegativeBignum(pMe, uTagRequirement, Bytes);
3248 }
3249 
3250 static inline void
3251 QCBOREncode_AddTNegativeBignumToMapN(QCBOREncodeContext *pMe,
3252  const int64_t nLabel,
3253  const uint8_t uTagRequirement,
3254  const UsefulBufC Bytes)
3255 {
3256  QCBOREncode_AddInt64(pMe, nLabel);
3257  QCBOREncode_AddTNegativeBignum(pMe, uTagRequirement, Bytes);
3258 }
3259 
3260 static inline void
3261 QCBOREncode_AddNegativeBignum(QCBOREncodeContext *pMe, const UsefulBufC Bytes)
3262 {
3263  QCBOREncode_AddTNegativeBignum(pMe, QCBOR_ENCODE_AS_TAG, Bytes);
3264 }
3265 
3266 static inline void
3267 QCBOREncode_AddNegativeBignumToMap(QCBOREncodeContext *pMe,
3268  const char *szLabel,
3269  const UsefulBufC Bytes)
3270 {
3271  QCBOREncode_AddTNegativeBignumToMapSZ(pMe,
3272  szLabel,
3273  QCBOR_ENCODE_AS_TAG,
3274  Bytes);
3275 }
3276 
3277 static inline void
3278 QCBOREncode_AddNegativeBignumToMapN(QCBOREncodeContext *pMe,
3279  const int64_t nLabel,
3280  const UsefulBufC Bytes)
3281 {
3282  QCBOREncode_AddTNegativeBignumToMapN(pMe,
3283  nLabel,
3284  QCBOR_ENCODE_AS_TAG,
3285  Bytes);
3286 }
3287 
3288 
3289 
3290 #ifndef QCBOR_DISABLE_EXP_AND_MANTISSA
3291 
3292 static inline void
3293 QCBOREncode_AddTDecimalFraction(QCBOREncodeContext *pMe,
3294  const uint8_t uTagRequirement,
3295  const int64_t nMantissa,
3296  const int64_t nBase10Exponent)
3297 {
3298  uint64_t uTag;
3299  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3300  uTag = CBOR_TAG_DECIMAL_FRACTION;
3301  } else {
3302  uTag = CBOR_TAG_INVALID64;
3303  }
3304  QCBOREncode_Private_AddExpMantissa(pMe,
3305  uTag,
3306  NULLUsefulBufC,
3307  false,
3308  nMantissa,
3309  nBase10Exponent);
3310 }
3311 
3312 static inline void
3313 QCBOREncode_AddTDecimalFractionToMapSZ(QCBOREncodeContext *pMe,
3314  const char *szLabel,
3315  const uint8_t uTagRequirement,
3316  const int64_t nMantissa,
3317  const int64_t nBase10Exponent)
3318 {
3319  QCBOREncode_AddSZString(pMe, szLabel);
3320  QCBOREncode_AddTDecimalFraction(pMe,
3321  uTagRequirement,
3322  nMantissa,
3323  nBase10Exponent);
3324 }
3325 
3326 static inline void
3327 QCBOREncode_AddTDecimalFractionToMapN(QCBOREncodeContext *pMe,
3328  const int64_t nLabel,
3329  const uint8_t uTagRequirement,
3330  const int64_t nMantissa,
3331  const int64_t nBase10Exponent)
3332 {
3333  QCBOREncode_AddInt64(pMe, nLabel);
3334  QCBOREncode_AddTDecimalFraction(pMe,
3335  uTagRequirement,
3336  nMantissa,
3337  nBase10Exponent);
3338 }
3339 
3340 static inline void
3341 QCBOREncode_AddDecimalFraction(QCBOREncodeContext *pMe,
3342  const int64_t nMantissa,
3343  const int64_t nBase10Exponent)
3344 {
3345  QCBOREncode_AddTDecimalFraction(pMe,
3346  QCBOR_ENCODE_AS_TAG,
3347  nMantissa,
3348  nBase10Exponent);
3349 }
3350 
3351 static inline void
3352 QCBOREncode_AddDecimalFractionToMap(QCBOREncodeContext *pMe,
3353  const char *szLabel,
3354  const int64_t nMantissa,
3355  const int64_t nBase10Exponent)
3356 {
3357  QCBOREncode_AddTDecimalFractionToMapSZ(pMe,
3358  szLabel,
3359  QCBOR_ENCODE_AS_TAG,
3360  nMantissa,
3361  nBase10Exponent);
3362 }
3363 
3364 static inline void
3365 QCBOREncode_AddDecimalFractionToMapN(QCBOREncodeContext *pMe,
3366  const int64_t nLabel,
3367  const int64_t nMantissa,
3368  const int64_t nBase10Exponent)
3369 {
3370  QCBOREncode_AddTDecimalFractionToMapN(pMe,
3371  nLabel,
3372  QCBOR_ENCODE_AS_TAG,
3373  nMantissa,
3374  nBase10Exponent);
3375 }
3376 
3377 
3378 
3379 static inline void
3380 QCBOREncode_AddTDecimalFractionBigNum(QCBOREncodeContext *pMe,
3381  const uint8_t uTagRequirement,
3382  const UsefulBufC Mantissa,
3383  const bool bIsNegative,
3384  const int64_t nBase10Exponent)
3385 {
3386  uint64_t uTag;
3387  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3388  uTag = CBOR_TAG_DECIMAL_FRACTION;
3389  } else {
3390  uTag = CBOR_TAG_INVALID64;
3391  }
3392  QCBOREncode_Private_AddExpMantissa(pMe,
3393  uTag,
3394  Mantissa,
3395  bIsNegative,
3396  0,
3397  nBase10Exponent);
3398 }
3399 
3400 static inline void
3401 QCBOREncode_AddTDecimalFractionBigNumToMapSZ(QCBOREncodeContext *pMe,
3402  const char *szLabel,
3403  const uint8_t uTagRequirement,
3404  const UsefulBufC Mantissa,
3405  const bool bIsNegative,
3406  const int64_t nBase10Exponent)
3407 {
3408  QCBOREncode_AddSZString(pMe, szLabel);
3409  QCBOREncode_AddTDecimalFractionBigNum(pMe,
3410  uTagRequirement,
3411  Mantissa,
3412  bIsNegative,
3413  nBase10Exponent);
3414 }
3415 
3416 static inline void
3417 QCBOREncode_AddTDecimalFractionBigNumToMapN(QCBOREncodeContext *pMe,
3418  const int64_t nLabel,
3419  const uint8_t uTagRequirement,
3420  const UsefulBufC Mantissa,
3421  const bool bIsNegative,
3422  const int64_t nBase10Exponent)
3423 {
3424  QCBOREncode_AddInt64(pMe, nLabel);
3425  QCBOREncode_AddTDecimalFractionBigNum(pMe,
3426  uTagRequirement,
3427  Mantissa,
3428  bIsNegative,
3429  nBase10Exponent);
3430 }
3431 
3432 static inline void
3433 QCBOREncode_AddDecimalFractionBigNum(QCBOREncodeContext *pMe,
3434  const UsefulBufC Mantissa,
3435  const bool bIsNegative,
3436  const int64_t nBase10Exponent)
3437 {
3438  QCBOREncode_AddTDecimalFractionBigNum(pMe,
3439  QCBOR_ENCODE_AS_TAG,
3440  Mantissa,
3441  bIsNegative,
3442  nBase10Exponent);
3443 }
3444 
3445 static inline void
3446 QCBOREncode_AddDecimalFractionBigNumToMapSZ(QCBOREncodeContext *pMe,
3447  const char *szLabel,
3448  const UsefulBufC Mantissa,
3449  const bool bIsNegative,
3450  const int64_t nBase10Exponent)
3451 {
3452  QCBOREncode_AddTDecimalFractionBigNumToMapSZ(pMe,
3453  szLabel,
3454  QCBOR_ENCODE_AS_TAG,
3455  Mantissa,
3456  bIsNegative,
3457  nBase10Exponent);
3458 }
3459 
3460 static inline void
3461 QCBOREncode_AddDecimalFractionBigNumToMapN(QCBOREncodeContext *pMe,
3462  const int64_t nLabel,
3463  const UsefulBufC Mantissa,
3464  const bool bIsNegative,
3465  const int64_t nBase2Exponent)
3466 {
3467  QCBOREncode_AddTDecimalFractionBigNumToMapN(pMe,
3468  nLabel,
3469  QCBOR_ENCODE_AS_TAG,
3470  Mantissa,
3471  bIsNegative,
3472  nBase2Exponent);
3473 }
3474 
3475 
3476 
3477 
3478 
3479 static inline void
3480 QCBOREncode_AddTBigFloat(QCBOREncodeContext *pMe,
3481  const uint8_t uTagRequirement,
3482  const int64_t nMantissa,
3483  const int64_t nBase2Exponent)
3484 {
3485  uint64_t uTag;
3486  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3487  uTag = CBOR_TAG_BIGFLOAT;
3488  } else {
3489  uTag = CBOR_TAG_INVALID64;
3490  }
3491  QCBOREncode_Private_AddExpMantissa(pMe,
3492  uTag,
3493  NULLUsefulBufC,
3494  false,
3495  nMantissa,
3496  nBase2Exponent);
3497 }
3498 
3499 static inline void
3500 QCBOREncode_AddTBigFloatToMapSZ(QCBOREncodeContext *pMe,
3501  const char *szLabel,
3502  const uint8_t uTagRequirement,
3503  const int64_t nMantissa,
3504  const int64_t nBase2Exponent)
3505 {
3506  QCBOREncode_AddSZString(pMe, szLabel);
3507  QCBOREncode_AddTBigFloat(pMe, uTagRequirement, nMantissa, nBase2Exponent);
3508 }
3509 
3510 static inline void
3511 QCBOREncode_AddTBigFloatToMapN(QCBOREncodeContext *pMe,
3512  const int64_t nLabel,
3513  const uint8_t uTagRequirement,
3514  const int64_t nMantissa,
3515  const int64_t nBase2Exponent)
3516 {
3517  QCBOREncode_AddInt64(pMe, nLabel);
3518  QCBOREncode_AddTBigFloat(pMe, uTagRequirement, nMantissa, nBase2Exponent);
3519 }
3520 
3521 static inline void
3522 QCBOREncode_AddBigFloat(QCBOREncodeContext *pMe,
3523  const int64_t nMantissa,
3524  const int64_t nBase2Exponent)
3525 {
3526  QCBOREncode_AddTBigFloat(pMe,
3527  QCBOR_ENCODE_AS_TAG,
3528  nMantissa,
3529  nBase2Exponent);
3530 }
3531 
3532 static inline void
3533 QCBOREncode_AddBigFloatToMap(QCBOREncodeContext *pMe,
3534  const char *szLabel,
3535  const int64_t nMantissa,
3536  const int64_t nBase2Exponent)
3537 {
3538  QCBOREncode_AddTBigFloatToMapSZ(pMe,
3539  szLabel,
3540  QCBOR_ENCODE_AS_TAG,
3541  nMantissa,
3542  nBase2Exponent);
3543 }
3544 
3545 static inline void
3546 QCBOREncode_AddBigFloatToMapN(QCBOREncodeContext *pMe,
3547  const int64_t nLabel,
3548  const int64_t nMantissa,
3549  const int64_t nBase2Exponent)
3550 {
3551  QCBOREncode_AddTBigFloatToMapN(pMe,
3552  nLabel,
3553  QCBOR_ENCODE_AS_TAG,
3554  nMantissa,
3555  nBase2Exponent);
3556 }
3557 
3558 
3559 
3560 static inline void
3561 QCBOREncode_AddTBigFloatBigNum(QCBOREncodeContext *pMe,
3562  const uint8_t uTagRequirement,
3563  const UsefulBufC Mantissa,
3564  const bool bIsNegative,
3565  const int64_t nBase2Exponent)
3566 {
3567  uint64_t uTag;
3568  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3569  uTag = CBOR_TAG_BIGFLOAT;
3570  } else {
3571  uTag = CBOR_TAG_INVALID64;
3572  }
3573  QCBOREncode_Private_AddExpMantissa(pMe,
3574  uTag,
3575  Mantissa,
3576  bIsNegative,
3577  0,
3578  nBase2Exponent);
3579 }
3580 
3581 static inline void
3582 QCBOREncode_AddTBigFloatBigNumToMapSZ(QCBOREncodeContext *pMe,
3583  const char *szLabel,
3584  const uint8_t uTagRequirement,
3585  const UsefulBufC Mantissa,
3586  const bool bIsNegative,
3587  const int64_t nBase2Exponent)
3588 {
3589  QCBOREncode_AddSZString(pMe, szLabel);
3590  QCBOREncode_AddTBigFloatBigNum(pMe,
3591  uTagRequirement,
3592  Mantissa,
3593  bIsNegative,
3594  nBase2Exponent);
3595 }
3596 
3597 static inline void
3598 QCBOREncode_AddTBigFloatBigNumToMapN(QCBOREncodeContext *pMe,
3599  const int64_t nLabel,
3600  const uint8_t uTagRequirement,
3601  const UsefulBufC Mantissa,
3602  const bool bIsNegative,
3603  const int64_t nBase2Exponent)
3604 {
3605  QCBOREncode_AddInt64(pMe, nLabel);
3606  QCBOREncode_AddTBigFloatBigNum(pMe,
3607  uTagRequirement,
3608  Mantissa,
3609  bIsNegative,
3610  nBase2Exponent);
3611 }
3612 
3613 
3614 static inline void
3615 QCBOREncode_AddBigFloatBigNum(QCBOREncodeContext *pMe,
3616  const UsefulBufC Mantissa,
3617  const bool bIsNegative,
3618  const int64_t nBase2Exponent)
3619 {
3620  QCBOREncode_AddTBigFloatBigNum(pMe,
3621  QCBOR_ENCODE_AS_TAG,
3622  Mantissa, bIsNegative,
3623  nBase2Exponent);
3624 }
3625 
3626 static inline void
3627 QCBOREncode_AddBigFloatBigNumToMap(QCBOREncodeContext *pMe,
3628  const char *szLabel,
3629  const UsefulBufC Mantissa,
3630  const bool bIsNegative,
3631  const int64_t nBase2Exponent)
3632 {
3633  QCBOREncode_AddTBigFloatBigNumToMapSZ(pMe,
3634  szLabel,
3635  QCBOR_ENCODE_AS_TAG,
3636  Mantissa,
3637  bIsNegative,
3638  nBase2Exponent);
3639 }
3640 
3641 static inline void
3642 QCBOREncode_AddBigFloatBigNumToMapN(QCBOREncodeContext *pMe,
3643  const int64_t nLabel,
3644  const UsefulBufC Mantissa,
3645  const bool bIsNegative,
3646  const int64_t nBase2Exponent)
3647 {
3648  QCBOREncode_AddTBigFloatBigNumToMapN(pMe,
3649  nLabel,
3650  QCBOR_ENCODE_AS_TAG,
3651  Mantissa,
3652  bIsNegative,
3653  nBase2Exponent);
3654 }
3655 #endif /* ! QCBOR_DISABLE_EXP_AND_MANTISSA */
3656 
3657 
3658 static inline void
3659 QCBOREncode_AddTURI(QCBOREncodeContext *pMe,
3660  const uint8_t uTagRequirement,
3661  const UsefulBufC URI)
3662 {
3663  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3664  QCBOREncode_AddTag(pMe, CBOR_TAG_URI);
3665  }
3666  QCBOREncode_AddText(pMe, URI);
3667 }
3668 
3669 static inline void
3670 QCBOREncode_AddTURIToMapSZ(QCBOREncodeContext *pMe,
3671  const char *szLabel,
3672  const uint8_t uTagRequirement,
3673  const UsefulBufC URI)
3674 {
3675  QCBOREncode_AddSZString(pMe, szLabel);
3676  QCBOREncode_AddTURI(pMe, uTagRequirement, URI);
3677 }
3678 
3679 static inline void
3680 QCBOREncode_AddTURIToMapN(QCBOREncodeContext *pMe,
3681  const int64_t nLabel,
3682  const uint8_t uTagRequirement,
3683  const UsefulBufC URI)
3684 {
3685  QCBOREncode_AddInt64(pMe, nLabel);
3686  QCBOREncode_AddTURI(pMe, uTagRequirement, URI);
3687 }
3688 
3689 static inline void
3690 QCBOREncode_AddURI(QCBOREncodeContext *pMe, const UsefulBufC URI)
3691 {
3692  QCBOREncode_AddTURI(pMe, QCBOR_ENCODE_AS_TAG, URI);
3693 }
3694 
3695 static inline void
3696 QCBOREncode_AddURIToMap(QCBOREncodeContext *pMe,
3697  const char *szLabel,
3698  const UsefulBufC URI)
3699 {
3700  QCBOREncode_AddTURIToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, URI);
3701 }
3702 
3703 static inline void
3704 QCBOREncode_AddURIToMapN(QCBOREncodeContext *pMe,
3705  const int64_t nLabel,
3706  const UsefulBufC URI)
3707 {
3708  QCBOREncode_AddTURIToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, URI);
3709 }
3710 
3711 
3712 
3713 static inline void
3714 QCBOREncode_AddTB64Text(QCBOREncodeContext *pMe,
3715  const uint8_t uTagRequirement,
3716  const UsefulBufC B64Text)
3717 {
3718  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3719  QCBOREncode_AddTag(pMe, CBOR_TAG_B64);
3720  }
3721  QCBOREncode_AddText(pMe, B64Text);
3722 }
3723 
3724 static inline void
3725 QCBOREncode_AddTB64TextToMapSZ(QCBOREncodeContext *pMe,
3726  const char *szLabel,
3727  const uint8_t uTagRequirement,
3728  const UsefulBufC B64Text)
3729 {
3730  QCBOREncode_AddSZString(pMe, szLabel);
3731  QCBOREncode_AddTB64Text(pMe, uTagRequirement, B64Text);
3732 }
3733 
3734 static inline void
3735 QCBOREncode_AddTB64TextToMapN(QCBOREncodeContext *pMe,
3736  const int64_t nLabel,
3737  const uint8_t uTagRequirement,
3738  const UsefulBufC B64Text)
3739 {
3740  QCBOREncode_AddInt64(pMe, nLabel);
3741  QCBOREncode_AddTB64Text(pMe, uTagRequirement, B64Text);
3742 }
3743 
3744 static inline void
3745 QCBOREncode_AddB64Text(QCBOREncodeContext *pMe, const UsefulBufC B64Text)
3746 {
3747  QCBOREncode_AddTB64Text(pMe, QCBOR_ENCODE_AS_TAG, B64Text);
3748 }
3749 
3750 static inline void
3751 QCBOREncode_AddB64TextToMap(QCBOREncodeContext *pMe,
3752  const char *szLabel,
3753  const UsefulBufC B64Text)
3754 {
3755  QCBOREncode_AddTB64TextToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, B64Text);
3756 }
3757 
3758 static inline void
3759 QCBOREncode_AddB64TextToMapN(QCBOREncodeContext *pMe,
3760  const int64_t nLabel,
3761  const UsefulBufC B64Text)
3762 {
3763  QCBOREncode_AddTB64TextToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, B64Text);
3764 }
3765 
3766 
3767 
3768 static inline void
3769 QCBOREncode_AddTB64URLText(QCBOREncodeContext *pMe,
3770  const uint8_t uTagRequirement,
3771  const UsefulBufC B64Text)
3772 {
3773  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3774  QCBOREncode_AddTag(pMe, CBOR_TAG_B64URL);
3775  }
3776  QCBOREncode_AddText(pMe, B64Text);
3777 }
3778 
3779 static inline void
3780 QCBOREncode_AddTB64URLTextToMapSZ(QCBOREncodeContext *pMe,
3781  const char *szLabel,
3782  const uint8_t uTagRequirement,
3783  const UsefulBufC B64Text)
3784 {
3785  QCBOREncode_AddSZString(pMe, szLabel);
3786  QCBOREncode_AddTB64URLText(pMe, uTagRequirement, B64Text);
3787 }
3788 
3789 static inline void
3790 QCBOREncode_AddTB64URLTextToMapN(QCBOREncodeContext *pMe,
3791  const int64_t nLabel,
3792  const uint8_t uTagRequirement,
3793  const UsefulBufC B64Text)
3794 {
3795  QCBOREncode_AddInt64(pMe, nLabel);
3796  QCBOREncode_AddTB64URLText(pMe, uTagRequirement, B64Text);
3797 }
3798 
3799 static inline void
3800 QCBOREncode_AddB64URLText(QCBOREncodeContext *pMe, const UsefulBufC B64Text)
3801 {
3802  QCBOREncode_AddTB64URLText(pMe, QCBOR_ENCODE_AS_TAG, B64Text);
3803 }
3804 
3805 static inline void
3806 QCBOREncode_AddB64URLTextToMap(QCBOREncodeContext *pMe,
3807  const char *szLabel,
3808  const UsefulBufC B64Text)
3809 {
3810  QCBOREncode_AddTB64URLTextToMapSZ(pMe,
3811  szLabel,
3812  QCBOR_ENCODE_AS_TAG,
3813  B64Text);
3814 }
3815 
3816 static inline void
3817 QCBOREncode_AddB64URLTextToMapN(QCBOREncodeContext *pMe,
3818  const int64_t nLabel,
3819  const UsefulBufC B64Text)
3820 {
3821  QCBOREncode_AddTB64URLTextToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, B64Text);
3822 }
3823 
3824 
3825 
3826 static inline void
3827 QCBOREncode_AddTRegex(QCBOREncodeContext *pMe,
3828  const uint8_t uTagRequirement,
3829  const UsefulBufC Bytes)
3830 {
3831  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3832  QCBOREncode_AddTag(pMe, CBOR_TAG_REGEX);
3833  }
3834  QCBOREncode_AddText(pMe, Bytes);
3835 }
3836 
3837 static inline void
3838 QCBOREncode_AddTRegexToMapSZ(QCBOREncodeContext *pMe,
3839  const char *szLabel,
3840  const uint8_t uTagRequirement,
3841  const UsefulBufC Bytes)
3842 {
3843  QCBOREncode_AddSZString(pMe, szLabel);
3844  QCBOREncode_AddTRegex(pMe, uTagRequirement, Bytes);
3845 }
3846 
3847 static inline void
3848 QCBOREncode_AddTRegexToMapN(QCBOREncodeContext *pMe,
3849  const int64_t nLabel,
3850  const uint8_t uTagRequirement,
3851  const UsefulBufC Bytes)
3852 {
3853  QCBOREncode_AddInt64(pMe, nLabel);
3854  QCBOREncode_AddTRegex(pMe, uTagRequirement, Bytes);
3855 }
3856 
3857 static inline void
3858 QCBOREncode_AddRegex(QCBOREncodeContext *pMe, const UsefulBufC Bytes)
3859 {
3860  QCBOREncode_AddTRegex(pMe, QCBOR_ENCODE_AS_TAG, Bytes);
3861 }
3862 
3863 static inline void
3864 QCBOREncode_AddRegexToMap(QCBOREncodeContext *pMe,
3865  const char *szLabel,
3866  const UsefulBufC Bytes)
3867 {
3868  QCBOREncode_AddTRegexToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, Bytes);
3869 }
3870 
3871 static inline void
3872 QCBOREncode_AddRegexToMapN(QCBOREncodeContext *pMe,
3873  const int64_t nLabel,
3874  const UsefulBufC Bytes)
3875 {
3876  QCBOREncode_AddTRegexToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, Bytes);
3877 
3878 }
3879 
3880 
3881 static inline void
3882 QCBOREncode_AddTMIMEData(QCBOREncodeContext *pMe,
3883  const uint8_t uTagRequirement,
3884  const UsefulBufC MIMEData)
3885 {
3886  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3887  QCBOREncode_AddTag(pMe, CBOR_TAG_BINARY_MIME);
3888  }
3889  QCBOREncode_AddBytes(pMe, MIMEData);
3890 }
3891 
3892 static inline void
3893 QCBOREncode_AddTMIMEDataToMapSZ(QCBOREncodeContext *pMe,
3894  const char *szLabel,
3895  const uint8_t uTagRequirement,
3896  const UsefulBufC MIMEData)
3897 {
3898  QCBOREncode_AddSZString(pMe, szLabel);
3899  QCBOREncode_AddTMIMEData(pMe, uTagRequirement, MIMEData);
3900 }
3901 
3902 static inline void
3903 QCBOREncode_AddTMIMEDataToMapN(QCBOREncodeContext *pMe,
3904  const int64_t nLabel,
3905  const uint8_t uTagRequirement,
3906  const UsefulBufC MIMEData)
3907 {
3908  QCBOREncode_AddInt64(pMe, nLabel);
3909  QCBOREncode_AddTMIMEData(pMe, uTagRequirement, MIMEData);
3910 }
3911 
3912 static inline void
3913 QCBOREncode_AddMIMEData(QCBOREncodeContext *pMe, UsefulBufC MIMEData)
3914 {
3915  QCBOREncode_AddTMIMEData(pMe, QCBOR_ENCODE_AS_TAG, MIMEData);
3916 }
3917 
3918 static inline void
3919 QCBOREncode_AddMIMEDataToMap(QCBOREncodeContext *pMe,
3920  const char *szLabel,
3921  const UsefulBufC MIMEData)
3922 {
3923  QCBOREncode_AddTMIMEDataToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, MIMEData);
3924 }
3925 
3926 static inline void
3927 QCBOREncode_AddMIMEDataToMapN(QCBOREncodeContext *pMe,
3928  const int64_t nLabel,
3929  const UsefulBufC MIMEData)
3930 {
3931  QCBOREncode_AddTMIMEDataToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, MIMEData);
3932 }
3933 
3934 
3935 static inline void
3936 QCBOREncode_AddTDateString(QCBOREncodeContext *pMe,
3937  const uint8_t uTagRequirement,
3938  const char *szDate)
3939 {
3940  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3941  QCBOREncode_AddTag(pMe, CBOR_TAG_DATE_STRING);
3942  }
3943  QCBOREncode_AddSZString(pMe, szDate);
3944 }
3945 
3946 static inline void
3947 QCBOREncode_AddTDateStringToMapSZ(QCBOREncodeContext *pMe,
3948  const char *szLabel,
3949  const uint8_t uTagRequirement,
3950  const char *szDate)
3951 {
3952  QCBOREncode_AddSZString(pMe, szLabel);
3953  QCBOREncode_AddTDateString(pMe, uTagRequirement, szDate);
3954 }
3955 
3956 static inline void
3957 QCBOREncode_AddTDateStringToMapN(QCBOREncodeContext *pMe,
3958  const int64_t nLabel,
3959  const uint8_t uTagRequirement,
3960  const char *szDate)
3961 {
3962  QCBOREncode_AddInt64(pMe, nLabel);
3963  QCBOREncode_AddTDateString(pMe, uTagRequirement, szDate);
3964 }
3965 
3966 static inline void
3967 QCBOREncode_AddDateString(QCBOREncodeContext *pMe, const char *szDate)
3968 {
3969  QCBOREncode_AddTDateString(pMe, QCBOR_ENCODE_AS_TAG, szDate);
3970 }
3971 
3972 static inline void
3973 QCBOREncode_AddDateStringToMap(QCBOREncodeContext *pMe,
3974  const char *szLabel,
3975  const char *szDate)
3976 {
3977  QCBOREncode_AddTDateStringToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, szDate);
3978 }
3979 
3980 static inline void
3981 QCBOREncode_AddDateStringToMapN(QCBOREncodeContext *pMe,
3982  const int64_t nLabel,
3983  const char *szDate)
3984 {
3985  QCBOREncode_AddTDateStringToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, szDate);
3986 }
3987 
3988 
3989 static inline void
3990 QCBOREncode_AddTDaysString(QCBOREncodeContext *pMe,
3991  const uint8_t uTagRequirement,
3992  const char *szDate)
3993 {
3994  if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
3995  QCBOREncode_AddTag(pMe, CBOR_TAG_DAYS_STRING);
3996  }
3997  QCBOREncode_AddSZString(pMe, szDate);
3998 }
3999 
4000 static inline void
4001 QCBOREncode_AddTDaysStringToMapSZ(QCBOREncodeContext *pMe,
4002  const char *szLabel,
4003  const uint8_t uTagRequirement,
4004  const char *szDate)
4005 {
4006  QCBOREncode_AddSZString(pMe, szLabel);
4007  QCBOREncode_AddTDaysString(pMe, uTagRequirement, szDate);
4008 }
4009 
4010 static inline void
4011 QCBOREncode_AddTDaysStringToMapN(QCBOREncodeContext *pMe,
4012  const int64_t nLabel,
4013  const uint8_t uTagRequirement,
4014  const char *szDate)
4015 {
4016  QCBOREncode_AddInt64(pMe, nLabel);
4017  QCBOREncode_AddTDaysString(pMe, uTagRequirement, szDate);
4018 }
4019 
4020 
4021 static inline void
4022 QCBOREncode_AddSimple(QCBOREncodeContext *pMe, const uint8_t uNum)
4023 {
4024  /* This check often is optimized out because uNum is known at compile time. */
4025 #ifndef QCBOR_DISABLE_ENCODE_USAGE_GUARDS
4026  if(uNum >= CBOR_SIMPLEV_RESERVED_START && uNum <= CBOR_SIMPLEV_RESERVED_END) {
4027  pMe->uError = QCBOR_ERR_ENCODE_UNSUPPORTED;
4028  return;
4029  }
4030 #endif /* ! QCBOR_DISABLE_ENCODE_USAGE_GUARDS */
4031 
4032  QCBOREncode_Private_AddType7(pMe, 0, uNum);
4033 }
4034 
4035 static inline void
4036 QCBOREncode_AddSimpleToMapSZ(QCBOREncodeContext *pMe,
4037  const char *szLabel,
4038  const uint8_t uSimple)
4039 {
4040  QCBOREncode_AddSZString(pMe, szLabel);
4041  QCBOREncode_AddSimple(pMe, uSimple);
4042 }
4043 
4044 static inline void
4045 QCBOREncode_AddSimpleToMap(QCBOREncodeContext *pMe,
4046  const char *szLabel,
4047  const uint8_t uSimple)
4048 {
4049  QCBOREncode_AddSimpleToMapSZ(pMe, szLabel, uSimple);
4050 }
4051 
4052 static inline void
4053 QCBOREncode_AddSimpleToMapN(QCBOREncodeContext *pMe,
4054  const int64_t nLabel,
4055  const uint8_t uSimple)
4056 {
4057  QCBOREncode_AddInt64(pMe, nLabel);
4058  QCBOREncode_AddSimple(pMe, uSimple);
4059 }
4060 
4061 
4062 static inline void
4063 QCBOREncode_AddBool(QCBOREncodeContext *pMe, const bool b)
4064 {
4065  uint8_t uSimple = CBOR_SIMPLEV_FALSE;
4066  if(b) {
4067  uSimple = CBOR_SIMPLEV_TRUE;
4068  }
4069  QCBOREncode_AddSimple(pMe, uSimple);
4070 }
4071 
4072 static inline void
4073 QCBOREncode_AddBoolToMapSZ(QCBOREncodeContext *pMe, const char *szLabel, const bool b)
4074 {
4075  QCBOREncode_AddSZString(pMe, szLabel);
4076  QCBOREncode_AddBool(pMe, b);
4077 }
4078 
4079 static inline void
4080 QCBOREncode_AddBoolToMap(QCBOREncodeContext *pMe, const char *szLabel, bool b)
4081 {
4082  QCBOREncode_AddBoolToMapSZ(pMe, szLabel, b);
4083 }
4084 
4085 static inline void
4086 QCBOREncode_AddBoolToMapN(QCBOREncodeContext *pMe, const int64_t nLabel, const bool b)
4087 {
4088  QCBOREncode_AddInt64(pMe, nLabel);
4089  QCBOREncode_AddBool(pMe, b);
4090 }
4091 
4092 
4093 static inline void
4094 QCBOREncode_AddNULL(QCBOREncodeContext *pMe)
4095 {
4096  QCBOREncode_AddSimple(pMe, CBOR_SIMPLEV_NULL);
4097 }
4098 
4099 static inline void
4100 QCBOREncode_AddNULLToMapSZ(QCBOREncodeContext *pMe, const char *szLabel)
4101 {
4102  QCBOREncode_AddSZString(pMe, szLabel);
4103  QCBOREncode_AddNULL(pMe);
4104 }
4105 
4106 static inline void
4107 QCBOREncode_AddNULLToMap(QCBOREncodeContext *pMe, const char *szLabel)
4108 {
4109  QCBOREncode_AddNULLToMapSZ(pMe, szLabel);
4110 }
4111 
4112 static inline void
4113 QCBOREncode_AddNULLToMapN(QCBOREncodeContext *pMe, const int64_t nLabel)
4114 {
4115  QCBOREncode_AddInt64(pMe, nLabel);
4116  QCBOREncode_AddNULL(pMe);
4117 }
4118 
4119 
4120 static inline void
4121 QCBOREncode_AddUndef(QCBOREncodeContext *pMe)
4122 {
4123  QCBOREncode_AddSimple(pMe, CBOR_SIMPLEV_UNDEF);
4124 }
4125 
4126 static inline void
4127 QCBOREncode_AddUndefToMapSZ(QCBOREncodeContext *pMe, const char *szLabel)
4128 {
4129  QCBOREncode_AddSZString(pMe, szLabel);
4130  QCBOREncode_AddUndef(pMe);
4131 }
4132 
4133 static inline void
4134 QCBOREncode_AddUndefToMap(QCBOREncodeContext *pCtx, const char *szLabel)
4135 {
4136  QCBOREncode_AddUndefToMapSZ(pCtx, szLabel);
4137 }
4138 
4139 static inline void
4140 QCBOREncode_AddUndefToMapN(QCBOREncodeContext *pMe, const int64_t nLabel)
4141 {
4142  QCBOREncode_AddInt64(pMe, nLabel);
4143  QCBOREncode_AddUndef(pMe);
4144 }
4145 
4146 
4147 static inline void
4148 QCBOREncode_OpenArray(QCBOREncodeContext *pMe)
4149 {
4150  QCBOREncode_Private_OpenMapOrArray(pMe, CBOR_MAJOR_TYPE_ARRAY);
4151 }
4152 
4153 static inline void
4154 QCBOREncode_OpenArrayInMapSZ(QCBOREncodeContext *pMe, const char *szLabel)
4155 {
4156  QCBOREncode_AddSZString(pMe, szLabel);
4157  QCBOREncode_OpenArray(pMe);
4158 }
4159 
4160 static inline void
4161 QCBOREncode_OpenArrayInMap(QCBOREncodeContext *pMe, const char *szLabel)
4162 {
4163  QCBOREncode_OpenArrayInMapSZ(pMe, szLabel);
4164 }
4165 
4166 
4167 static inline void
4168 QCBOREncode_OpenArrayInMapN(QCBOREncodeContext *pMe, const int64_t nLabel)
4169 {
4170  QCBOREncode_AddInt64(pMe, nLabel);
4171  QCBOREncode_OpenArray(pMe);
4172 }
4173 
4174 static inline void
4175 QCBOREncode_CloseArray(QCBOREncodeContext *pMe)
4176 {
4177  QCBOREncode_Private_CloseMapOrArray(pMe, CBOR_MAJOR_TYPE_ARRAY);
4178 }
4179 
4180 
4181 static inline void
4182 QCBOREncode_OpenMap(QCBOREncodeContext *pMe)
4183 {
4184  QCBOREncode_Private_OpenMapOrArray(pMe, CBOR_MAJOR_TYPE_MAP);
4185 }
4186 
4187 static inline void
4188 QCBOREncode_OpenMapInMapSZ(QCBOREncodeContext *pMe, const char *szLabel)
4189 {
4190  QCBOREncode_AddSZString(pMe, szLabel);
4191  QCBOREncode_OpenMap(pMe);
4192 }
4193 
4194 static inline void
4195 QCBOREncode_OpenMapInMap(QCBOREncodeContext *pMe, const char *szLabel)
4196 {
4197  QCBOREncode_OpenMapInMapSZ(pMe, szLabel);
4198 }
4199 
4200 static inline void
4201 QCBOREncode_OpenMapInMapN(QCBOREncodeContext *pMe, const int64_t nLabel)
4202 {
4203  QCBOREncode_AddInt64(pMe, nLabel);
4204  QCBOREncode_OpenMap(pMe);
4205 }
4206 
4207 static inline void
4208 QCBOREncode_CloseMap(QCBOREncodeContext *pMe)
4209 {
4210  QCBOREncode_Private_CloseMapOrArray(pMe, CBOR_MAJOR_TYPE_MAP);
4211 }
4212 
4213 static inline void
4214 QCBOREncode_OpenArrayIndefiniteLength(QCBOREncodeContext *pMe)
4215 {
4216  QCBOREncode_Private_OpenMapOrArrayIndefiniteLength(pMe, CBOR_MAJOR_NONE_TYPE_ARRAY_INDEFINITE_LEN);
4217 }
4218 
4219 static inline void
4220 QCBOREncode_OpenArrayIndefiniteLengthInMapSZ(QCBOREncodeContext *pMe,
4221  const char *szLabel)
4222 {
4223  QCBOREncode_AddSZString(pMe, szLabel);
4224  QCBOREncode_OpenArrayIndefiniteLength(pMe);
4225 }
4226 
4227 static inline void
4228 QCBOREncode_OpenArrayIndefiniteLengthInMap(QCBOREncodeContext *pMe,
4229  const char *szLabel)
4230 {
4231  QCBOREncode_OpenArrayIndefiniteLengthInMapSZ(pMe, szLabel);
4232 }
4233 
4234 static inline void
4235 QCBOREncode_OpenArrayIndefiniteLengthInMapN(QCBOREncodeContext *pMe,
4236  const int64_t nLabel)
4237 {
4238  QCBOREncode_AddInt64(pMe, nLabel);
4239  QCBOREncode_OpenArrayIndefiniteLength(pMe);
4240 }
4241 
4242 static inline void
4243 QCBOREncode_CloseArrayIndefiniteLength(QCBOREncodeContext *pMe)
4244 {
4245  QCBOREncode_Private_CloseMapOrArrayIndefiniteLength(pMe, CBOR_MAJOR_NONE_TYPE_ARRAY_INDEFINITE_LEN);
4246 }
4247 
4248 
4249 static inline void
4250 QCBOREncode_OpenMapIndefiniteLength(QCBOREncodeContext *pMe)
4251 {
4252  QCBOREncode_Private_OpenMapOrArrayIndefiniteLength(pMe, CBOR_MAJOR_NONE_TYPE_MAP_INDEFINITE_LEN);
4253 }
4254 
4255 static inline void
4256 QCBOREncode_OpenMapIndefiniteLengthInMapSZ(QCBOREncodeContext *pMe,
4257  const char *szLabel)
4258 {
4259  QCBOREncode_AddSZString(pMe, szLabel);
4260  QCBOREncode_OpenMapIndefiniteLength(pMe);
4261 }
4262 
4263 static inline void
4264 QCBOREncode_OpenMapIndefiniteLengthInMap(QCBOREncodeContext *pMe,
4265  const char *szLabel)
4266 {
4267  QCBOREncode_OpenMapIndefiniteLengthInMapSZ(pMe, szLabel);
4268 }
4269 
4270 static inline void
4271 QCBOREncode_OpenMapIndefiniteLengthInMapN(QCBOREncodeContext *pMe,
4272  const int64_t nLabel)
4273 {
4274  QCBOREncode_AddInt64(pMe, nLabel);
4275  QCBOREncode_OpenMapIndefiniteLength(pMe);
4276 }
4277 
4278 static inline void
4279 QCBOREncode_CloseMapIndefiniteLength(QCBOREncodeContext *pMe)
4280 {
4281  QCBOREncode_Private_CloseMapOrArrayIndefiniteLength(pMe, CBOR_MAJOR_NONE_TYPE_MAP_INDEFINITE_LEN);
4282 }
4283 
4284 
4285 static inline void
4286 QCBOREncode_BstrWrap(QCBOREncodeContext *pMe)
4287 {
4288  QCBOREncode_Private_OpenMapOrArray(pMe, CBOR_MAJOR_TYPE_BYTE_STRING);
4289 }
4290 
4291 static inline void
4292 QCBOREncode_BstrWrapInMapSZ(QCBOREncodeContext *pMe, const char *szLabel)
4293 {
4294  QCBOREncode_AddSZString(pMe, szLabel);
4295  QCBOREncode_BstrWrap(pMe);
4296 }
4297 
4298 static inline void
4299 QCBOREncode_BstrWrapInMap(QCBOREncodeContext *pMe, const char *szLabel)
4300 {
4301  QCBOREncode_BstrWrapInMapSZ(pMe, szLabel);
4302 }
4303 
4304 static inline void
4305 QCBOREncode_BstrWrapInMapN(QCBOREncodeContext *pMe, const int64_t nLabel)
4306 {
4307  QCBOREncode_AddInt64(pMe, nLabel);
4308  QCBOREncode_BstrWrap(pMe);
4309 }
4310 
4311 static inline void
4312 QCBOREncode_CloseBstrWrap(QCBOREncodeContext *pMe, UsefulBufC *pWrappedCBOR)
4313 {
4314  QCBOREncode_CloseBstrWrap2(pMe, true, pWrappedCBOR);
4315 }
4316 
4317 
4318 
4319 static inline void
4320 QCBOREncode_AddEncodedToMapSZ(QCBOREncodeContext *pMe,
4321  const char *szLabel,
4322  const UsefulBufC Encoded)
4323 {
4324  QCBOREncode_AddSZString(pMe, szLabel);
4325  QCBOREncode_AddEncoded(pMe, Encoded);
4326 }
4327 
4328 static inline void
4329 QCBOREncode_AddEncodedToMap(QCBOREncodeContext *pMe, const char *szLabel, UsefulBufC Encoded)
4330 {
4331  QCBOREncode_AddEncodedToMapSZ(pMe, szLabel, Encoded);
4332 }
4333 
4334 static inline void
4335 QCBOREncode_AddEncodedToMapN(QCBOREncodeContext *pMe,
4336  const int64_t nLabel,
4337  const UsefulBufC Encoded)
4338 {
4339  QCBOREncode_AddInt64(pMe, nLabel);
4340  QCBOREncode_AddEncoded(pMe, Encoded);
4341 }
4342 
4343 
4344 static inline int
4345 QCBOREncode_IsBufferNULL(QCBOREncodeContext *pMe)
4346 {
4347  return UsefulOutBuf_IsBufferNULL(&(pMe->OutBuf));
4348 }
4349 
4350 
4351 static inline UsefulBuf
4352 QCBOREncode_RetrieveOutputStorage(QCBOREncodeContext *pMe)
4353 {
4354  return UsefulOutBuf_RetrieveOutputStorage(&(pMe->OutBuf));
4355 }
4356 
4357 
4358 static inline QCBORError
4359 QCBOREncode_GetErrorState(QCBOREncodeContext *pMe)
4360 {
4361  if(UsefulOutBuf_GetError(&(pMe->OutBuf))) {
4362  /* Items didn't fit in the buffer. This check catches this
4363  * condition for all the appends and inserts so checks aren't
4364  * needed when the appends and inserts are performed. And of
4365  * course UsefulBuf will never overrun the input buffer given to
4366  * it. No complex analysis of the error handling in this file is
4367  * needed to know that is true. Just read the UsefulBuf code.
4368  */
4369  pMe->uError = QCBOR_ERR_BUFFER_TOO_SMALL;
4370  /* QCBOR_ERR_BUFFER_TOO_SMALL masks other errors, but that is
4371  * OK. Once the caller fixes this, they'll be unmasked.
4372  */
4373  }
4374 
4375  return (QCBORError)pMe->uError;
4376 }
4377 
4378 
4379 static inline size_t
4380 QCBOREncode_Tell(QCBOREncodeContext *pMe)
4381 {
4382  return UsefulOutBuf_GetEndPosition(&(pMe->OutBuf));
4383 }
4384 
4385 /* ======================================================================== *
4386  * END OF PRIVATE INLINE IMPLEMENTATION *
4387  * ======================================================================== */
4388 
4389 #ifdef __cplusplus
4390 }
4391 #endif
4392 
4393 #endif /* qcbor_encode_h */
UsefulOutBuf_GetEndPosition
static size_t UsefulOutBuf_GetEndPosition(UsefulOutBuf *pUOutBuf)
Returns position of end of data in the UsefulOutBuf.
Definition: UsefulBuf.h:1978
UsefulBuf_FromSZ
static UsefulBufC UsefulBuf_FromSZ(const char *szString)
Convert a NULL-terminated string to a UsefulBufC.
Definition: UsefulBuf.h:1835
UsefulBufUtil_CopyFloatToUint32
static uint32_t UsefulBufUtil_CopyFloatToUint32(float f)
Copy a float to a uint32_t.
Definition: UsefulBuf.h:1939
UsefulOutBuf_RetrieveOutputStorage
static UsefulBuf UsefulOutBuf_RetrieveOutputStorage(UsefulOutBuf *pUOutBuf)
Retrieve the storage buffer passed in to UsefulOutBuf_Init().
Definition: UsefulBuf.h:2274
UsefulBufUtil_CopyDoubleToUint64
static uint64_t UsefulBufUtil_CopyDoubleToUint64(double d)
Copy a double to a uint64_t.
Definition: UsefulBuf.h:1946
UsefulOutBuf_IsBufferNULL
static int UsefulOutBuf_IsBufferNULL(UsefulOutBuf *pUOutBuf)
Returns 1 if buffer given to UsefulOutBuf_Init() was NULL.
Definition: UsefulBuf.h:2253
UsefulOutBuf_GetError
static int UsefulOutBuf_GetError(UsefulOutBuf *pUOutBuf)
Returns the current error status.
Definition: UsefulBuf.h:2235
NULLUsefulBufC
#define NULLUsefulBufC
Definition: UsefulBuf.h:314
qcbor_common.h
CBOR_TAG_INVALID64
#define CBOR_TAG_INVALID64
Definition: qcbor_common.h:244
CBOR_TAG_DAYS_EPOCH
#define CBOR_TAG_DAYS_EPOCH
Definition: qcbor_common.h:224
CBOR_TAG_POS_BIGNUM
#define CBOR_TAG_POS_BIGNUM
Definition: qcbor_common.h:138
CBOR_TAG_URI
#define CBOR_TAG_URI
Definition: qcbor_common.h:187
CBOR_TAG_B64URL
#define CBOR_TAG_B64URL
Definition: qcbor_common.h:189
CBOR_TAG_DATE_STRING
#define CBOR_TAG_DATE_STRING
Definition: qcbor_common.h:134
CBOR_TAG_BIGFLOAT
#define CBOR_TAG_BIGFLOAT
Definition: qcbor_common.h:148
CBOR_TAG_DECIMAL_FRACTION
#define CBOR_TAG_DECIMAL_FRACTION
Definition: qcbor_common.h:144
CBOR_TAG_DATE_EPOCH
#define CBOR_TAG_DATE_EPOCH
Definition: qcbor_common.h:136
CBOR_TAG_B64
#define CBOR_TAG_B64
Definition: qcbor_common.h:191
CBOR_TAG_BIN_UUID
#define CBOR_TAG_BIN_UUID
Definition: qcbor_common.h:197
QCBORError
QCBORError
Definition: qcbor_common.h:265
QCBOR_ERR_ENCODE_UNSUPPORTED
@ QCBOR_ERR_ENCODE_UNSUPPORTED
Definition: qcbor_common.h:275
QCBOR_ERR_BUFFER_TOO_SMALL
@ QCBOR_ERR_BUFFER_TOO_SMALL
Definition: qcbor_common.h:271
CBOR_TAG_REGEX
#define CBOR_TAG_REGEX
Definition: qcbor_common.h:193
CBOR_TAG_BINARY_MIME
#define CBOR_TAG_BINARY_MIME
Definition: qcbor_common.h:230
CBOR_TAG_NEG_BIGNUM
#define CBOR_TAG_NEG_BIGNUM
Definition: qcbor_common.h:140
CBOR_TAG_DAYS_STRING
#define CBOR_TAG_DAYS_STRING
Definition: qcbor_common.h:234
QCBOREncode_FinishGetSize
QCBORError QCBOREncode_FinishGetSize(QCBOREncodeContext *pCtx, size_t *uEncodedLen)
Get the encoded CBOR and error status.
QCBOREncode_AddDoubleNoPreferred
static void QCBOREncode_AddDoubleNoPreferred(QCBOREncodeContext *pCtx, double dNum)
Add a double-precision floating-point number without preferred encoding.
Definition: qcbor_encode.h:2809
QCBOREncode_AddTBigFloatBigNum
static void QCBOREncode_AddTBigFloatBigNum(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase2Exponent)
Add a big floating-point number with a big number mantissa to the encoded output.
Definition: qcbor_encode.h:3561
QCBOREncode_OpenArray
static void QCBOREncode_OpenArray(QCBOREncodeContext *pCtx)
Indicates that the next items added are in an array.
Definition: qcbor_encode.h:4148
QCBOREncode_AddTNegativeBignum
static void QCBOREncode_AddTNegativeBignum(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC BigNumber)
Add a negative big number to the encoded output.
Definition: qcbor_encode.h:3230
QCBOREncode_EncodeHead
UsefulBufC QCBOREncode_EncodeHead(UsefulBuf Buffer, uint8_t uMajorType, uint8_t uMinLen, uint64_t uNumber)
Encode the head of a CBOR data item.
QCBOREncode_Private_AddType7
static void QCBOREncode_Private_AddType7(QCBOREncodeContext *pMe, const uint8_t uMinLen, const uint64_t uArgument)
Semi-private method to add simple items and floating-point.
Definition: qcbor_encode.h:2624
QCBOREncode_OpenMapIndefiniteLength
static void QCBOREncode_OpenMapIndefiniteLength(QCBOREncodeContext *pCtx)
Indicates that the next items added are in an indefinite length map.
Definition: qcbor_encode.h:4250
QCBOREncode_AddTDecimalFractionBigNum
static void QCBOREncode_AddTDecimalFractionBigNum(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC Mantissa, bool bIsNegative, int64_t nBase10Exponent)
Add a decimal fraction with a big number mantissa to the encoded output.
Definition: qcbor_encode.h:3380
QCBOREncode_AddTRegex
static void QCBOREncode_AddTRegex(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC Regex)
Add Perl Compatible Regular Expression.
Definition: qcbor_encode.h:3827
QCBOREncode_OpenArrayIndefiniteLength
static void QCBOREncode_OpenArrayIndefiniteLength(QCBOREncodeContext *pCtx)
Indicates that the next items added are in an indefinite length array.
Definition: qcbor_encode.h:4214
QCBOREncode_AddTDateEpoch
static void QCBOREncode_AddTDateEpoch(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, int64_t nDate)
Add an epoch-based date.
Definition: qcbor_encode.h:2948
QCBOR_ENCODE_AS_TAG
#define QCBOR_ENCODE_AS_TAG
Definition: qcbor_encode.h:408
QCBOREncode_AddEncoded
void QCBOREncode_AddEncoded(QCBOREncodeContext *pCtx, UsefulBufC Encoded)
Add some already-encoded CBOR bytes.
QCBOREncode_AddBool
static void QCBOREncode_AddBool(QCBOREncodeContext *pCtx, bool b)
Add a standard Boolean.
Definition: qcbor_encode.h:4063
QCBOREncode_AddTBinaryUUID
static void QCBOREncode_AddTBinaryUUID(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC Bytes)
Add a binary UUID to the encoded output.
Definition: qcbor_encode.h:3113
QCBOREncode_AddTDaysEpoch
static void QCBOREncode_AddTDaysEpoch(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, int64_t nDays)
Add an epoch-based day-count date.
Definition: qcbor_encode.h:3005
QCBOREncode_CancelBstrWrap
void QCBOREncode_CancelBstrWrap(QCBOREncodeContext *pCtx)
Cancel byte string wrapping.
QCBOREncode_GetErrorState
static QCBORError QCBOREncode_GetErrorState(QCBOREncodeContext *pCtx)
Get the encoding error state.
Definition: qcbor_encode.h:4359
QCBOREncode_CloseBytes
void QCBOREncode_CloseBytes(QCBOREncodeContext *pCtx, size_t uAmount)
Close out a byte string written directly to encoded output.
QCBOREncode_AddTPositiveBignum
static void QCBOREncode_AddTPositiveBignum(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC BigNumber)
Add a positive big number to the encoded output.
Definition: qcbor_encode.h:3170
QCBOREncode_AddTB64URLText
static void QCBOREncode_AddTB64URLText(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC B64Text)
Add base64url encoded data to encoded output.
Definition: qcbor_encode.h:3769
QCBOREncode_AddTDecimalFraction
static void QCBOREncode_AddTDecimalFraction(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, int64_t nMantissa, int64_t nBase10Exponent)
Add a decimal fraction to the encoded output.
Definition: qcbor_encode.h:3293
QCBOREncode_AddSimple
static void QCBOREncode_AddSimple(QCBOREncodeContext *pCtx, const uint8_t uNum)
Add a simple value.
Definition: qcbor_encode.h:4022
QCBOREncode_CloseMap
static void QCBOREncode_CloseMap(QCBOREncodeContext *pCtx)
Close an open map.
Definition: qcbor_encode.h:4208
QCBOREncode_SubString
UsefulBufC QCBOREncode_SubString(QCBOREncodeContext *pCtx, const size_t uStart)
Get a substring of encoded CBOR for cryptographic hash.
QCBOREncode_Tell
static size_t QCBOREncode_Tell(QCBOREncodeContext *pCtx)
Returns current end of encoded data.
Definition: qcbor_encode.h:4380
QCBOREncode_CloseMapIndefiniteLength
static void QCBOREncode_CloseMapIndefiniteLength(QCBOREncodeContext *pCtx)
Close an open indefinite length map.
Definition: qcbor_encode.h:4279
QCBOREncode_AddTBigFloat
static void QCBOREncode_AddTBigFloat(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, int64_t nMantissa, int64_t nBase2Exponent)
Add a big floating-point number to the encoded output.
Definition: qcbor_encode.h:3480
QCBOREncode_BstrWrap
static void QCBOREncode_BstrWrap(QCBOREncodeContext *pCtx)
Indicate start of encoded CBOR to be wrapped in a bstr.
Definition: qcbor_encode.h:4286
QCBOREncode_AddFloatNoPreferred
static void QCBOREncode_AddFloatNoPreferred(QCBOREncodeContext *pCtx, float fNum)
Add a single-precision floating-point number without preferred encoding.
Definition: qcbor_encode.h:2817
QCBOREncode_CloseArray
static void QCBOREncode_CloseArray(QCBOREncodeContext *pCtx)
Close an open array.
Definition: qcbor_encode.h:4175
QCBOREncode_AddUndef
static void QCBOREncode_AddUndef(QCBOREncodeContext *pCtx)
Add an "undef" to the encoded output.
Definition: qcbor_encode.h:4121
QCBOREncode_AddText
static void QCBOREncode_AddText(QCBOREncodeContext *pCtx, UsefulBufC Text)
Add a UTF-8 text string to the encoded output.
Definition: qcbor_encode.h:2736
QCBOREncode_AddInt64
void QCBOREncode_AddInt64(QCBOREncodeContext *pCtx, int64_t nNum)
Add a signed 64-bit integer to the encoded output.
QCBOREncode_AddTDaysString
static void QCBOREncode_AddTDaysString(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, const char *szDate)
Add a date-only string.
Definition: qcbor_encode.h:3990
QCBOREncode_AddBytes
static void QCBOREncode_AddBytes(QCBOREncodeContext *pCtx, UsefulBufC Bytes)
Add a byte string to the encoded output.
Definition: qcbor_encode.h:3037
QCBOREncode_AddTag
static void QCBOREncode_AddTag(QCBOREncodeContext *pCtx, uint64_t uTag)
Add a tag number.
Definition: qcbor_encode.h:2798
QCBOREncode_AddBytesLenOnly
static void QCBOREncode_AddBytesLenOnly(QCBOREncodeContext *pCtx, UsefulBufC Bytes)
Semi-private method to add only the type and length of a byte string.
Definition: qcbor_encode.h:3087
QCBOREncode_Init
void QCBOREncode_Init(QCBOREncodeContext *pCtx, UsefulBuf Storage)
QCBOREncode_RetrieveOutputStorage
static UsefulBuf QCBOREncode_RetrieveOutputStorage(QCBOREncodeContext *pCtx)
Retrieve the storage buffer passed in to QCBOREncode_Init().
Definition: qcbor_encode.h:4352
QCBOREncode_CloseArrayIndefiniteLength
static void QCBOREncode_CloseArrayIndefiniteLength(QCBOREncodeContext *pCtx)
Close an open indefinite length array.
Definition: qcbor_encode.h:4243
QCBOREncode_Finish
QCBORError QCBOREncode_Finish(QCBOREncodeContext *pCtx, UsefulBufC *pEncodedCBOR)
Get the encoded result.
QCBOREncode_AddTB64Text
static void QCBOREncode_AddTB64Text(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC B64Text)
Add Base64-encoded text to encoded output.
Definition: qcbor_encode.h:3714
QCBOREncode_AddFloat
static void QCBOREncode_AddFloat(QCBOREncodeContext *pCtx, float fNum)
Add a single-precision floating-point number to the encoded output.
Definition: qcbor_encode.h:2861
QCBOREncode_AddSZString
static void QCBOREncode_AddSZString(QCBOREncodeContext *pCtx, const char *szString)
Add a UTF-8 text string to the encoded output.
Definition: qcbor_encode.h:2767
QCBOREncode_AddDouble
static void QCBOREncode_AddDouble(QCBOREncodeContext *pCtx, double dNum)
Add a double-precision floating-point number to the encoded output.
Definition: qcbor_encode.h:2826
QCBOREncode_OpenBytes
void QCBOREncode_OpenBytes(QCBOREncodeContext *pCtx, UsefulBuf *pPlace)
Set up to write a byte string value directly to encoded output.
QCBOREncode_IsBufferNULL
static int QCBOREncode_IsBufferNULL(QCBOREncodeContext *pCtx)
Indicate whether the output storage buffer is NULL.
Definition: qcbor_encode.h:4345
QCBOREncode_AddTDateString
static void QCBOREncode_AddTDateString(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, const char *szDate)
Add an RFC 3339 date string.
Definition: qcbor_encode.h:3936
QCBOREncode_AddUInt64
static void QCBOREncode_AddUInt64(QCBOREncodeContext *pCtx, uint64_t uNum)
Add an unsigned 64-bit integer to the encoded output.
Definition: qcbor_encode.h:2704
QCBOREncode_OpenMap
static void QCBOREncode_OpenMap(QCBOREncodeContext *pCtx)
Indicates that the next items added are in a map.
Definition: qcbor_encode.h:4182
QCBOREncode_CloseBstrWrap2
void QCBOREncode_CloseBstrWrap2(QCBOREncodeContext *pCtx, bool bIncludeCBORHead, UsefulBufC *pWrappedCBOR)
Close a wrapping bstr.
QCBOREncode_AddNULL
static void QCBOREncode_AddNULL(QCBOREncodeContext *pCtx)
Add a NULL to the encoded output.
Definition: qcbor_encode.h:4094
QCBOREncode_AddTMIMEData
static void QCBOREncode_AddTMIMEData(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC MIMEData)
MIME encoded data to the encoded output.
Definition: qcbor_encode.h:3882
QCBOREncode_AddTURI
static void QCBOREncode_AddTURI(QCBOREncodeContext *pCtx, uint8_t uTagRequirement, UsefulBufC URI)
Add a text URI to the encoded output.
Definition: qcbor_encode.h:3659
_QCBOREncodeContext
Definition: qcbor_private.h:221
q_useful_buf_c
Definition: UsefulBuf.h:273
q_useful_buf
Definition: UsefulBuf.h:284
Generated by doxygen 1.9.1