cbor 编译及使用

libcbor: GitHub - PJK/libcbor: CBOR protocol implementation for C

cmake编译：

CMAKE_DEBUG_POSTFIX ：d

#include "cbor.h"
#include <stdio.h>
QVariant  traverse_cbor(const cbor_item_t *item)
{
    QVariant va;
    switch (cbor_typeof(item)) {
    case CBOR_TYPE_UINT:
        printf("CBOR type: UINT, value: %lu\n", cbor_get_uint8(item));
        va.setValue(cbor_get_uint8(item));
        break;
    case CBOR_TYPE_NEGINT:
        printf("CBOR type: NEGINT, value: %ld\n", cbor_get_int(item));
        va.setValue(cbor_get_int(item));
        break;
    case CBOR_TYPE_BYTESTRING: {
        size_t str_len = cbor_bytestring_length(item);
        char *bytes = (char*)cbor_bytestring_handle(item);
        printf("CBOR type: BYTESTRING, value: %s\n", bytes);
        QByteArray ba(bytes, str_len);
        va.setValue(ba);
        break;
    }
    case CBOR_TYPE_STRING: {
        size_t str_len = cbor_string_length(item);
        printf("CBOR type: STRING, value: %.*s\n", str_len, cbor_string_handle(item));
        QString str = QString::fromUtf8((const char *)cbor_string_handle(item), str_len);
        va.setValue(str);
        break;
    }
    case CBOR_TYPE_FLOAT_CTRL: {
        qInfo()<<"CBOR_TYPE_FLOAT_CTRL="<<cbor_get_bool(item);
        va.setValue(cbor_get_bool(item));
        break;
    }
    case CBOR_TYPE_ARRAY: {
        size_t size = cbor_array_size(item);
        QVariantList ar_lt;
        for (size_t i = 0; i < size; i++) {
            const cbor_item_t *array_item = cbor_array_get(item, i);
            QVariant ar_va = traverse_cbor(array_item);
            ar_lt.push_back(ar_va);
        }
        break;
    }
    case CBOR_TYPE_MAP: {
        qInfo()<<"CBOR_TYPE_MAP=.....";
        size_t size = cbor_map_size(item);
        QVariantMap qt_map;
        for (size_t i = 0; i < size; i++) {
            cbor_pair *cb_map = cbor_map_handle(item);
            cbor_item_t *key = cb_map[i].key;
            cbor_item_t *value = cb_map[i].value;
            QVariant va_key = traverse_cbor(key);
            QVariant va_val = traverse_cbor(value);
            qt_map.insert(va_key.toString(), va_val);
        }
        va.setValue(qt_map);
        break;
    }
        // ... Handle other types similarly
    default:
        printf("Unhandled CBOR type: %d\n", cbor_typeof(item));
        break;
    }
    return va;
}

bool parseCborData(QByteArray ba)
{
    qInfo()<<"parseCborData().."<<ba.length();
    unsigned char * buffer = (unsigned char *)ba.data();
    size_t length = ba.length();
    struct cbor_load_result result;
    cbor_item_t * item = cbor_load(buffer, length, &result);
    QVariant va_val = this->traverse_cbor(item);

    /* Deallocate the result */
    cbor_decref(&item);

    switch (va_val.type()) {
    case QVariant::List:
    {
        QList<QVariant> vlt = va_val.toList();
        qInfo()<<vlt;
    }    break;
    case QVariant::Map:
    {
        QMap<QString, QVariant> map = va_val.toMap();
        qInfo()<<map;   
    }    break;
    default:
        break;
    }

    return true;
}


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

   std::string eye_str="os";
    cbor_item_t * root = cbor_new_definite_map(3);
    cbor_pair cbp;
    cbp.key   = cbor_move(cbor_build_string("command"));
    cbp.value = cbor_move(cbor_build_string("submit"));
    cbor_map_add(root, cbp);

    cbp.key   = cbor_move(cbor_build_string("error_code"));
    cbp.value = cbor_move(cbor_build_uint32(errorCode));
    cbor_map_add(root, cbp);

    const char *ceye = eye_str.c_str();
    cbp.key   = cbor_move(cbor_build_string("curr_eye"));
    cbp.value = cbor_move(cbor_build_string(ceye));
    cbor_map_add(root, cbp);
    unsigned char * pbuffer;
    size_t buffer_size;
    cbor_serialize_alloc(root, &pbuffer, &buffer_size);


//    cbor_describe(root, stdout);
//    fflush(stdout);


    QByteArray w_ba(buffer_size,0);
    std::memcpy(w_ba.data(), pbuffer, buffer_size);

    free(pbuffer);

    parseCborData(w_ba);

}

QT5.15 以上版本支持cbor

#include <QCborMap>
#include <QCborArray>
#include <QCborValue>
#include <QDebug>
#include <QCoreApplication>

void paraseCbor(QByteArray &ba)
{
    QCborParserError c_er;
    QCborValue cbor_v = QCborValue::fromCbor(ba, &c_er);

    qInfo()<<"paraseCbor().."<<c_er.errorString()<< cbor_v.type();

    switch (cbor_v.type()){
    case QCborValue::Integer:      break;
    case QCborValue::SimpleType:   break;
    case QCborValue::Double:       break;
    case QCborValue::ByteArray:    break;
    case QCborValue::String:       break;
    case QCborValue::Array:
    {
        QCborArray cbor_array = cbor_v.toArray();
    } break;
    case QCborValue::Map:
    {
        QCborMap cbor_map = cbor_v.toMap();

    } break;
    default: break;
    }
}


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QCborMap map;
    map.insert(QCborValue("command"), QCborValue("start"));
    map.insert(QCborValue("targetEye"), QCborValue("both"));

    QByteArray ba = map.toCborValue().toCbor();

    this->paraseCbor(ba);
 

    return a.exec();
}