qcbor_tag_encode.h

Go to the documentation of this file.

/* ===========================================================================
 * qcbor_tag_encode.h
 * Forked from qcbor_encode.h 12/17/2024
 *
 * Copyright (c) 2016-2018, The Linux Foundation.
 * Copyright (c) 2018-2024, Laurence Lundblade.
 * Copyright (c) 2021, Arm Limited.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *     * Neither the name of The Linux Foundation nor the names of its
 *       contributors, nor the name "Laurence Lundblade" may be used to
 *       endorse or promote products derived from this software without
 *       specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * ========================================================================= */
 
#ifndef qcbor_tag_encode_h
#define qcbor_tag_encode_h
 
 
#include "qcbor/qcbor_common.h"
#include "qcbor/qcbor_private.h"
#include "qcbor/qcbor_main_encode.h"
#include <stdbool.h>
 
 
#ifdef __cplusplus
extern "C" {
#if 0
} // Keep editor indention formatting happy
#endif
#endif
 
 
enum QCBOREncodeTagReq {
     QCBOR_ENCODE_AS_TAG =  0,
 
    QCBOR_ENCODE_AS_BORROWED = 1
};
 
 
 
static void
QCBOREncode_AddTagNumber(QCBOREncodeContext *pCtx, uint64_t uTagNumber);
 
 
 
 
static void
QCBOREncode_AddTDateEpoch(QCBOREncodeContext    *pCtx,
                          enum QCBOREncodeTagReq uTagRequirement,
                          int64_t                nDate);
 
static void
QCBOREncode_AddTDateEpochToMapSZ(QCBOREncodeContext    *pCtx,
                                 const char            *szLabel,
                                 enum QCBOREncodeTagReq uTagRequirement,
                                 int64_t                nDate);
 
static void
QCBOREncode_AddTDateEpochToMapN(QCBOREncodeContext    *pCtx,
                                int64_t                nLabel,
                                enum QCBOREncodeTagReq uTagRequirement,
                                int64_t                nDate);
 
 
static void
QCBOREncode_AddTDaysEpoch(QCBOREncodeContext    *pCtx,
                          enum QCBOREncodeTagReq uTagRequirement,
                          int64_t                nDays);
 
static void
QCBOREncode_AddTDaysEpochToMapSZ(QCBOREncodeContext    *pCtx,
                                 const char            *szLabel,
                                 enum QCBOREncodeTagReq uTagRequirement,
                                 int64_t                nDays);
 
static void
QCBOREncode_AddTDaysEpochToMapN(QCBOREncodeContext    *pCtx,
                                int64_t                nLabel,
                                enum QCBOREncodeTagReq uTagRequirement,
                                int64_t                nDays);
 
 
static void
QCBOREncode_AddTBinaryUUID(QCBOREncodeContext    *pCtx,
                           enum QCBOREncodeTagReq uTagRequirement,
                           UsefulBufC             UUID);
 
static void
QCBOREncode_AddTBinaryUUIDToMapSZ(QCBOREncodeContext    *pCtx,
                                  const char            *szLabel,
                                  enum QCBOREncodeTagReq uTagRequirement,
                                  UsefulBufC             UUID);
 
static void
QCBOREncode_AddTBinaryUUIDToMapN(QCBOREncodeContext    *pCtx,
                                 int64_t                nLabel,
                                 enum QCBOREncodeTagReq uTagRequirement,
                                 UsefulBufC             UUID);
 
 
static void
QCBOREncode_AddTURI(QCBOREncodeContext    *pCtx,
                    enum QCBOREncodeTagReq uTagRequirement,
                    UsefulBufC             URI);
 
static void
QCBOREncode_AddTURIToMapSZ(QCBOREncodeContext    *pCtx,
                           const char            *szLabel,
                           enum QCBOREncodeTagReq uTagRequirement,
                           UsefulBufC             URI);
 
static void
QCBOREncode_AddTURIToMapN(QCBOREncodeContext    *pCtx,
                          int64_t                nLabel,
                          enum QCBOREncodeTagReq uTagRequirement,
                          UsefulBufC             URI);
 
 
static void
QCBOREncode_AddTB64Text(QCBOREncodeContext    *pCtx,
                        enum QCBOREncodeTagReq uTagRequirement,
                        UsefulBufC             B64Text);
 
static void
QCBOREncode_AddTB64TextToMapSZ(QCBOREncodeContext    *pCtx,
                               const char            *szLabel,
                               enum QCBOREncodeTagReq uTagRequirement,
                               UsefulBufC             B64Text);
 
static void
QCBOREncode_AddTB64TextToMapN(QCBOREncodeContext    *pCtx,
                              int64_t                nLabel,
                              enum QCBOREncodeTagReq uTagRequirement,
                              UsefulBufC             B64Text);
 
 
static void
QCBOREncode_AddTB64URLText(QCBOREncodeContext    *pCtx,
                           enum QCBOREncodeTagReq uTagRequirement,
                           UsefulBufC             B64Text);
 
static void
QCBOREncode_AddTB64URLTextToMapSZ(QCBOREncodeContext    *pCtx,
                                  const char            *szLabel,
                                  enum QCBOREncodeTagReq uTagRequirement,
                                  UsefulBufC             B64Text);
 
static void
QCBOREncode_AddTB64URLTextToMapN(QCBOREncodeContext    *pCtx,
                                 int64_t                nLabel,
                                 enum QCBOREncodeTagReq uTagRequirement,
                                 UsefulBufC             B64Text);
 
 
static void
QCBOREncode_AddTRegex(QCBOREncodeContext    *pCtx,
                      enum QCBOREncodeTagReq uTagRequirement,
                      UsefulBufC             Regex);
 
static void
QCBOREncode_AddTRegexToMapSZ(QCBOREncodeContext    *pCtx,
                             const char            *szLabel,
                             enum QCBOREncodeTagReq uTagRequirement,
                             UsefulBufC             Regex);
 
static void
QCBOREncode_AddTRegexToMapN(QCBOREncodeContext    *pCtx,
                            int64_t                nLabel,
                            enum QCBOREncodeTagReq uTagRequirement,
                            UsefulBufC             Regex);
 
 
static void
QCBOREncode_AddTMIMEData(QCBOREncodeContext    *pCtx,
                         enum QCBOREncodeTagReq uTagRequirement,
                         UsefulBufC             MIMEData);
 
static void
QCBOREncode_AddTMIMEDataToMapSZ(QCBOREncodeContext    *pCtx,
                                const char            *szLabel,
                                enum QCBOREncodeTagReq uTagRequirement,
                                UsefulBufC             MIMEData);
 
static void
QCBOREncode_AddTMIMEDataToMapN(QCBOREncodeContext    *pCtx,
                               int64_t                nLabel,
                               enum QCBOREncodeTagReq uTagRequirement,
                               UsefulBufC             MIMEData);
 
 
static void
QCBOREncode_AddTDateString(QCBOREncodeContext    *pCtx,
                           enum QCBOREncodeTagReq uTagRequirement,
                           const char            *szDate);
 
static void
QCBOREncode_AddTDateStringToMapSZ(QCBOREncodeContext    *pCtx,
                                  const char            *szLabel,
                                  enum QCBOREncodeTagReq uTagRequirement,
                                  const char            *szDate);
 
static void
QCBOREncode_AddTDateStringToMapN(QCBOREncodeContext    *pCtx,
                                 int64_t                nLabel,
                                 enum QCBOREncodeTagReq uTagRequirement,
                                 const char            *szDate);
 
 
static void
QCBOREncode_AddTDaysString(QCBOREncodeContext    *pCtx,
                           enum QCBOREncodeTagReq uTagRequirement,
                           const char            *szDate);
 
static void
QCBOREncode_AddTDaysStringToMapSZ(QCBOREncodeContext    *pCtx,
                                  const char            *szLabel,
                                  enum QCBOREncodeTagReq uTagRequirement,
                                  const char            *szDate);
 
static void
QCBOREncode_AddTDaysStringToMapN(QCBOREncodeContext    *pCtx,
                                 int64_t                nLabel,
                                 enum QCBOREncodeTagReq uTagRequirement,
                                 const char            *szDate);
 
 
 
 
/* ========================================================================= *
 *    BEGINNING OF DEPRECATED FUNCTION DECLARATIONS                          *
 *                                                                           *
 *    There is no plan to remove these in future versions.                   *
 *    They just have been replaced by something better.                      *
 * ========================================================================= */
 
static void
QCBOREncode_AddDateEpoch(QCBOREncodeContext *pCtx, int64_t nDate);
 
static void
QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pCtx, const char *szLabel, int64_t nDate);
 
static void
QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, int64_t nDate);
 
static void
QCBOREncode_AddBinaryUUID(QCBOREncodeContext *pCtx, UsefulBufC UUID);
 
static void
QCBOREncode_AddBinaryUUIDToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC UUID);
 
static void
QCBOREncode_AddBinaryUUIDToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC UUID);
 
static void
QCBOREncode_AddTag(QCBOREncodeContext *pCtx, uint64_t uTagNumber);
 
static void
QCBOREncode_AddURI(QCBOREncodeContext *pCtx, UsefulBufC URI);
 
static void
QCBOREncode_AddURIToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC URI);
 
static void
QCBOREncode_AddURIToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC URI);
 
static void
QCBOREncode_AddB64Text(QCBOREncodeContext *pCtx, UsefulBufC B64Text);
 
static void
QCBOREncode_AddB64TextToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC B64Text);
 
static void
QCBOREncode_AddB64TextToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC B64Text);
 
static void
QCBOREncode_AddB64URLText(QCBOREncodeContext *pCtx, UsefulBufC B64Text);
 
static void
QCBOREncode_AddB64URLTextToMap(QCBOREncodeContext *pCtx,
                               const char         *szLabel,
                               UsefulBufC          B64Text);
 
static void
QCBOREncode_AddB64URLTextToMapN(QCBOREncodeContext *pCtx,
                                int64_t             nLabel,
                                UsefulBufC          B64Text);
 
static void
QCBOREncode_AddRegex(QCBOREncodeContext *pCtx, UsefulBufC Regex);
 
static void
QCBOREncode_AddRegexToMap(QCBOREncodeContext *pCtx,
                          const char         *szLabel,
                          UsefulBufC          Regex);
 
static void
QCBOREncode_AddRegexToMapN(QCBOREncodeContext *pCtx,
                           int64_t             nLabel,
                           UsefulBufC          Regex);
 
static void
QCBOREncode_AddMIMEData(QCBOREncodeContext *pCtx, UsefulBufC MIMEData);
 
static void
QCBOREncode_AddMIMEDataToMap(QCBOREncodeContext *pCtx,
                             const char         *szLabel,
                             UsefulBufC          MIMEData);
 
static void
QCBOREncode_AddMIMEDataToMapN(QCBOREncodeContext *pCtx,
                              int64_t             nLabel,
                              UsefulBufC          MIMEData);
 
static void
QCBOREncode_AddDateString(QCBOREncodeContext *pCtx, const char *szDate);
 
static void
QCBOREncode_AddDateStringToMap(QCBOREncodeContext *pCtx,
                               const char         *szLabel,
                               const char         *szDate);
 
static void
QCBOREncode_AddDateStringToMapN(QCBOREncodeContext *pCtx,
                                int64_t             nLabel,
                                const char         *szDate);
 
/* ========================================================================= *
 *    END OF DEPRECATED FUNCTION DECLARATIONS                                *
 * ========================================================================= */
 
 
 
 
/* ========================================================================= *
 *    BEGINNING OF PRIVATE INLINE IMPLEMENTATION
 *    Note that the entire qcbor_tag_encode implementation is line.
 * ========================================================================= */
 
 
static inline void
QCBOREncode_AddTagNumber(QCBOREncodeContext *pMe, const uint64_t uTagNumber)
{
   QCBOREncode_Private_AppendCBORHead(pMe, CBOR_MAJOR_TYPE_TAG, uTagNumber, 0);
}
 
 
static inline void
QCBOREncode_AddTag(QCBOREncodeContext *pMe, const uint64_t uTagNumber)
{
   QCBOREncode_AddTagNumber(pMe, uTagNumber);
}
 
 
static inline void
QCBOREncode_AddTDateEpoch(QCBOREncodeContext          *pMe,
                          const enum QCBOREncodeTagReq uTagRequirement,
                          const int64_t                nDate)
{
   if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
      QCBOREncode_AddTagNumber(pMe, CBOR_TAG_DATE_EPOCH);
   }
   QCBOREncode_AddInt64(pMe, nDate);
}
 
static inline void
QCBOREncode_AddTDateEpochToMapSZ(QCBOREncodeContext          *pMe,
                                 const char                  *szLabel,
                                 const enum QCBOREncodeTagReq uTagRequirement,
                                 const int64_t                nDate)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddTDateEpoch(pMe, uTagRequirement, nDate);
}
 
static inline void
QCBOREncode_AddTDateEpochToMapN(QCBOREncodeContext          *pMe,
                                const int64_t                nLabel,
                                const enum QCBOREncodeTagReq uTagRequirement,
                                const int64_t                nDate)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddTDateEpoch(pMe, uTagRequirement, nDate);
}
 
static inline void
QCBOREncode_AddDateEpoch(QCBOREncodeContext *pMe,
                         const int64_t       nDate)
{
   QCBOREncode_AddTDateEpoch(pMe, QCBOR_ENCODE_AS_TAG, nDate);
}
 
static inline void
QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pMe,
                              const char         *szLabel,
                              const int64_t       nDate)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddDateEpoch(pMe, nDate);
}
 
static inline void
QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pMe,
                               const int64_t       nLabel,
                               const int64_t       nDate)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddDateEpoch(pMe, nDate);
}
 
 
static inline void
QCBOREncode_AddTDaysEpoch(QCBOREncodeContext          *pMe,
                          const enum QCBOREncodeTagReq uTagRequirement,
                          const int64_t                nDays)
{
   if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
      QCBOREncode_AddTagNumber(pMe, CBOR_TAG_DAYS_EPOCH);
   }
   QCBOREncode_AddInt64(pMe, nDays);
}
 
static inline void
QCBOREncode_AddTDaysEpochToMapSZ(QCBOREncodeContext          *pMe,
                                 const char                  *szLabel,
                                 const enum QCBOREncodeTagReq uTagRequirement,
                                 const int64_t                nDays)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddTDaysEpoch(pMe, uTagRequirement, nDays);
}
 
static inline void
QCBOREncode_AddTDaysEpochToMapN(QCBOREncodeContext          *pMe,
                                const int64_t                nLabel,
                                const enum QCBOREncodeTagReq uTagRequirement,
                                const int64_t                nDays)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddTDaysEpoch(pMe, uTagRequirement, nDays);
}
 
 
 
static inline void
QCBOREncode_AddTBinaryUUID(QCBOREncodeContext          *pMe,
                           const enum QCBOREncodeTagReq uTagRequirement,
                           const UsefulBufC             UUID)
{
   if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
      QCBOREncode_AddTagNumber(pMe, CBOR_TAG_BIN_UUID);
   }
   QCBOREncode_AddBytes(pMe, UUID);
}
 
static inline void
QCBOREncode_AddTBinaryUUIDToMapSZ(QCBOREncodeContext          *pMe,
                                  const char                  *szLabel,
                                  const enum QCBOREncodeTagReq uTagRequirement,
                                  const UsefulBufC             UUID)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddTBinaryUUID(pMe, uTagRequirement, UUID);
}
 
static inline void
QCBOREncode_AddTBinaryUUIDToMapN(QCBOREncodeContext         *pMe,
                                 const int64_t                nLabel,
                                 const enum QCBOREncodeTagReq uTagRequirement,
                                 const UsefulBufC             UUID)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddTBinaryUUID(pMe, uTagRequirement, UUID);
}
 
static inline void
QCBOREncode_AddBinaryUUID(QCBOREncodeContext *pMe, const UsefulBufC UUID)
{
   QCBOREncode_AddTBinaryUUID(pMe, QCBOR_ENCODE_AS_TAG, UUID);
}
 
static inline void
QCBOREncode_AddBinaryUUIDToMap(QCBOREncodeContext *pMe,
                               const char         *szLabel,
                               const UsefulBufC    UUID)
{
   QCBOREncode_AddTBinaryUUIDToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, UUID);
}
 
static inline void
QCBOREncode_AddBinaryUUIDToMapN(QCBOREncodeContext *pMe,
                                const int64_t       nLabel,
                                const UsefulBufC    UUID)
{
   QCBOREncode_AddTBinaryUUIDToMapN(pMe,
                                    nLabel,
                                    QCBOR_ENCODE_AS_TAG,
                                    UUID);
}
 
 
static inline void
QCBOREncode_AddTURI(QCBOREncodeContext          *pMe,
                    const enum QCBOREncodeTagReq uTagRequirement,
                    const UsefulBufC             URI)
{
   if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
      QCBOREncode_AddTagNumber(pMe, CBOR_TAG_URI);
   }
   QCBOREncode_AddText(pMe, URI);
}
 
static inline void
QCBOREncode_AddTURIToMapSZ(QCBOREncodeContext          *pMe,
                           const char                  *szLabel,
                           const enum QCBOREncodeTagReq uTagRequirement,
                           const UsefulBufC             URI)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddTURI(pMe, uTagRequirement, URI);
}
 
static inline void
QCBOREncode_AddTURIToMapN(QCBOREncodeContext          *pMe,
                          const int64_t                nLabel,
                          const enum QCBOREncodeTagReq uTagRequirement,
                          const UsefulBufC             URI)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddTURI(pMe, uTagRequirement, URI);
}
 
static inline void
QCBOREncode_AddURI(QCBOREncodeContext *pMe, const UsefulBufC URI)
{
   QCBOREncode_AddTURI(pMe, QCBOR_ENCODE_AS_TAG, URI);
}
 
static inline void
QCBOREncode_AddURIToMap(QCBOREncodeContext *pMe,
                        const char         *szLabel,
                        const UsefulBufC    URI)
{
   QCBOREncode_AddTURIToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, URI);
}
 
static inline void
QCBOREncode_AddURIToMapN(QCBOREncodeContext *pMe,
                         const int64_t       nLabel,
                         const UsefulBufC    URI)
{
   QCBOREncode_AddTURIToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, URI);
}
 
 
 
static inline void
QCBOREncode_AddTB64Text(QCBOREncodeContext          *pMe,
                        const enum QCBOREncodeTagReq uTagRequirement,
                        const UsefulBufC             B64Text)
{
   if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
      QCBOREncode_AddTagNumber(pMe, CBOR_TAG_B64);
   }
   QCBOREncode_AddText(pMe, B64Text);
}
 
static inline void
QCBOREncode_AddTB64TextToMapSZ(QCBOREncodeContext          *pMe,
                               const char                  *szLabel,
                               const enum QCBOREncodeTagReq uTagRequirement,
                               const UsefulBufC             B64Text)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddTB64Text(pMe, uTagRequirement, B64Text);
}
 
static inline void
QCBOREncode_AddTB64TextToMapN(QCBOREncodeContext          *pMe,
                              const int64_t                nLabel,
                              const enum QCBOREncodeTagReq uTagRequirement,
                              const UsefulBufC             B64Text)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddTB64Text(pMe, uTagRequirement, B64Text);
}
 
static inline void
QCBOREncode_AddB64Text(QCBOREncodeContext *pMe, const UsefulBufC B64Text)
{
   QCBOREncode_AddTB64Text(pMe, QCBOR_ENCODE_AS_TAG, B64Text);
}
 
static inline void
QCBOREncode_AddB64TextToMap(QCBOREncodeContext *pMe,
                            const char         *szLabel,
                            const UsefulBufC    B64Text)
{
   QCBOREncode_AddTB64TextToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, B64Text);
}
 
static inline void
QCBOREncode_AddB64TextToMapN(QCBOREncodeContext *pMe,
                             const int64_t       nLabel,
                             const UsefulBufC    B64Text)
{
   QCBOREncode_AddTB64TextToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, B64Text);
}
 
 
 
static inline void
QCBOREncode_AddTB64URLText(QCBOREncodeContext          *pMe,
                           const enum QCBOREncodeTagReq uTagRequirement,
                           const UsefulBufC             B64Text)
{
   if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
      QCBOREncode_AddTagNumber(pMe, CBOR_TAG_B64URL);
   }
   QCBOREncode_AddText(pMe, B64Text);
}
 
static inline void
QCBOREncode_AddTB64URLTextToMapSZ(QCBOREncodeContext          *pMe,
                                  const char                  *szLabel,
                                  const enum QCBOREncodeTagReq uTagRequirement,
                                  const UsefulBufC             B64Text)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddTB64URLText(pMe, uTagRequirement, B64Text);
}
 
static inline void
QCBOREncode_AddTB64URLTextToMapN(QCBOREncodeContext          *pMe,
                                 const int64_t                nLabel,
                                 const enum QCBOREncodeTagReq uTagRequirement,
                                 const UsefulBufC             B64Text)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddTB64URLText(pMe, uTagRequirement, B64Text);
}
 
static inline void
QCBOREncode_AddB64URLText(QCBOREncodeContext *pMe, const UsefulBufC B64Text)
{
   QCBOREncode_AddTB64URLText(pMe, QCBOR_ENCODE_AS_TAG, B64Text);
}
 
static inline void
QCBOREncode_AddB64URLTextToMap(QCBOREncodeContext *pMe,
                               const char         *szLabel,
                               const UsefulBufC    B64Text)
{
   QCBOREncode_AddTB64URLTextToMapSZ(pMe,
                                     szLabel,
                                     QCBOR_ENCODE_AS_TAG,
                                     B64Text);
}
 
static inline void
QCBOREncode_AddB64URLTextToMapN(QCBOREncodeContext *pMe,
                                const int64_t       nLabel,
                                const UsefulBufC    B64Text)
{
   QCBOREncode_AddTB64URLTextToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, B64Text);
}
 
 
static inline void
QCBOREncode_AddTRegex(QCBOREncodeContext          *pMe,
                      const enum QCBOREncodeTagReq uTagRequirement,
                      const UsefulBufC             Regex)
{
   if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
      QCBOREncode_AddTagNumber(pMe, CBOR_TAG_REGEX);
   }
   QCBOREncode_AddText(pMe, Regex);
}
 
static inline void
QCBOREncode_AddTRegexToMapSZ(QCBOREncodeContext          *pMe,
                             const char                  *szLabel,
                             const enum QCBOREncodeTagReq uTagRequirement,
                             const UsefulBufC             Regex)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddTRegex(pMe, uTagRequirement, Regex);
}
 
static inline void
QCBOREncode_AddTRegexToMapN(QCBOREncodeContext          *pMe,
                            const int64_t                nLabel,
                            const enum QCBOREncodeTagReq uTagRequirement,
                            const UsefulBufC             Regex)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddTRegex(pMe, uTagRequirement, Regex);
}
 
static inline void
QCBOREncode_AddRegex(QCBOREncodeContext *pMe, const UsefulBufC Regex)
{
   QCBOREncode_AddTRegex(pMe, QCBOR_ENCODE_AS_TAG, Regex);
}
 
static inline void
QCBOREncode_AddRegexToMap(QCBOREncodeContext *pMe,
                          const char         *szLabel,
                          const UsefulBufC    Regex)
{
   QCBOREncode_AddTRegexToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, Regex);
}
 
static inline void
QCBOREncode_AddRegexToMapN(QCBOREncodeContext *pMe,
                           const int64_t       nLabel,
                           const UsefulBufC    Regex)
{
   QCBOREncode_AddTRegexToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, Regex);
 
}
 
 
static inline void
QCBOREncode_AddTMIMEData(QCBOREncodeContext          *pMe,
                         const enum QCBOREncodeTagReq uTagRequirement,
                         const UsefulBufC             MIMEData)
{
   if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
      QCBOREncode_AddTagNumber(pMe, CBOR_TAG_BINARY_MIME);
   }
   QCBOREncode_AddBytes(pMe, MIMEData);
}
 
static inline void
QCBOREncode_AddTMIMEDataToMapSZ(QCBOREncodeContext          *pMe,
                                const char                  *szLabel,
                                const enum QCBOREncodeTagReq uTagRequirement,
                                const UsefulBufC             MIMEData)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddTMIMEData(pMe, uTagRequirement, MIMEData);
}
 
static inline void
QCBOREncode_AddTMIMEDataToMapN(QCBOREncodeContext          *pMe,
                               const int64_t                nLabel,
                               const enum QCBOREncodeTagReq uTagRequirement,
                               const UsefulBufC             MIMEData)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddTMIMEData(pMe, uTagRequirement, MIMEData);
}
 
static inline void
QCBOREncode_AddMIMEData(QCBOREncodeContext *pMe, UsefulBufC MIMEData)
{
   QCBOREncode_AddTMIMEData(pMe, QCBOR_ENCODE_AS_TAG, MIMEData);
}
 
static inline void
QCBOREncode_AddMIMEDataToMap(QCBOREncodeContext *pMe,
                             const char         *szLabel,
                             const UsefulBufC    MIMEData)
{
   QCBOREncode_AddTMIMEDataToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, MIMEData);
}
 
static inline void
QCBOREncode_AddMIMEDataToMapN(QCBOREncodeContext *pMe,
                              const int64_t       nLabel,
                              const UsefulBufC    MIMEData)
{
   QCBOREncode_AddTMIMEDataToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, MIMEData);
}
 
 
static inline void
QCBOREncode_AddTDateString(QCBOREncodeContext          *pMe,
                           const enum QCBOREncodeTagReq uTagRequirement,
                           const char                  *szDate)
{
   if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
      QCBOREncode_AddTagNumber(pMe, CBOR_TAG_DATE_STRING);
   }
   QCBOREncode_AddSZString(pMe, szDate);
}
 
static inline void
QCBOREncode_AddTDateStringToMapSZ(QCBOREncodeContext          *pMe,
                                  const char                  *szLabel,
                                  const enum QCBOREncodeTagReq uTagRequirement,
                                  const char                  *szDate)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddTDateString(pMe, uTagRequirement, szDate);
}
 
static inline void
QCBOREncode_AddTDateStringToMapN(QCBOREncodeContext          *pMe,
                                 const int64_t                nLabel,
                                 const enum QCBOREncodeTagReq uTagRequirement,
                                 const char                  *szDate)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddTDateString(pMe, uTagRequirement, szDate);
}
 
static inline void
QCBOREncode_AddDateString(QCBOREncodeContext *pMe, const char *szDate)
{
   QCBOREncode_AddTDateString(pMe, QCBOR_ENCODE_AS_TAG, szDate);
}
 
static inline void
QCBOREncode_AddDateStringToMap(QCBOREncodeContext *pMe,
                               const char         *szLabel,
                               const char         *szDate)
{
   QCBOREncode_AddTDateStringToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, szDate);
}
 
static inline void
QCBOREncode_AddDateStringToMapN(QCBOREncodeContext *pMe,
                                const int64_t       nLabel,
                                const char         *szDate)
{
   QCBOREncode_AddTDateStringToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, szDate);
}
 
 
static inline void
QCBOREncode_AddTDaysString(QCBOREncodeContext          *pMe,
                           const enum QCBOREncodeTagReq uTagRequirement,
                           const char                  *szDate)
{
   if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
      QCBOREncode_AddTagNumber(pMe, CBOR_TAG_DAYS_STRING);
   }
   QCBOREncode_AddSZString(pMe, szDate);
}
 
static inline void
QCBOREncode_AddTDaysStringToMapSZ(QCBOREncodeContext          *pMe,
                                  const char                  *szLabel,
                                  const enum QCBOREncodeTagReq uTagRequirement,
                                  const char                  *szDate)
{
   QCBOREncode_AddSZString(pMe, szLabel);
   QCBOREncode_AddTDaysString(pMe, uTagRequirement, szDate);
}
 
static inline void
QCBOREncode_AddTDaysStringToMapN(QCBOREncodeContext          *pMe,
                                 const int64_t                nLabel,
                                 const enum QCBOREncodeTagReq uTagRequirement,
                                 const char                  *szDate)
{
   QCBOREncode_AddInt64(pMe, nLabel);
   QCBOREncode_AddTDaysString(pMe, uTagRequirement, szDate);
}
 
 
/* ======================================================================== *
 *    END OF PRIVATE INLINE IMPLEMENTATION                                  *
 * ======================================================================== */
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* qcbor_tag_encode_h */