io_cbor.h

Go to the documentation of this file.

// Copyright 2024-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/io_readable.h>
#include <satcat5/io_writeable.h>
#include <satcat5/utils.h>
 
// Enable this feature? (See types.h)
#if SATCAT5_CBOR_ENABLE
#include <qcbor/qcbor_encode.h>
#include <qcbor/qcbor_spiffy_decode.h>
 
#ifndef SATCAT5_QCBOR_BUFFER
#define SATCAT5_QCBOR_BUFFER 1500
#endif
 
namespace satcat5 {
    namespace cbor {
        class CborWriter {
        public:
            bool close();
 
            inline bool close_and_finalize()
                { return close() && m_dst && m_dst->write_finalize(); }
 
            UsefulBufC get_encoded();
 
            satcat5::io::Readable* get_buffer();
 
            inline void close_list()
                { QCBOREncode_CloseArray(cbor); }
 
            inline void close_map()
                { QCBOREncode_CloseMap(cbor); }
 
            // Member variables
            QCBOREncodeContext* const cbor;         
 
        protected:
            CborWriter(
                satcat5::io::Writeable* dst,
                QCBOREncodeContext* encode,
                u8* buff, unsigned size,
                bool automap=false);
 
            explicit constexpr CborWriter(QCBOREncodeContext* encode)
                : cbor(encode)
                , m_dst(nullptr)
                , m_encoded(nullptr)
                , m_encoded_len(0)
                , m_auto_close(QCBOR_TYPE_NONE)
                , m_read(encode->OutBuf.UB.ptr, 0)
                {} // Nothing else to initialize.
 
            // Prohibit unsafe copy constructor and assignment operator.
            CborWriter(const CborWriter& other) = delete;
            CborWriter& operator=(const CborWriter& other) = delete;
 
            template <typename T>
            void add_unsigned_array(unsigned len, const T* value) const;
 
            template <typename T>
            void add_signed_array(unsigned len, const T* value) const;
 
            // Member variables
            satcat5::io::Writeable* const m_dst;    
            const u8* m_encoded;                    
            unsigned m_encoded_len;                 
            u8 m_auto_close;                        
            satcat5::io::ArrayRead m_read;          
        };
 
        class ListWriter : public CborWriter {
        public:
            explicit constexpr ListWriter(QCBOREncodeContext* encode)
                : CborWriter(encode) {}
 
            inline void add_bool(bool value) const
                { QCBOREncode_AddBool(cbor, value); }
            inline void add_item(s8 value) const
                { QCBOREncode_AddInt64(cbor, value); }
            inline void add_item(s16 value) const
                { QCBOREncode_AddInt64(cbor, value); }
            inline void add_item(s32 value) const
                { QCBOREncode_AddInt64(cbor, value); }
            inline void add_item(s64 value) const
                { QCBOREncode_AddInt64(cbor, value); }
            inline void add_item(u8 value) const
                { QCBOREncode_AddUInt64(cbor, value); }
            inline void add_item(u16 value) const
                { QCBOREncode_AddUInt64(cbor, value); }
            inline void add_item(u32 value) const
                { QCBOREncode_AddUInt64(cbor, value); }
            inline void add_item(u64 value) const
                { QCBOREncode_AddUInt64(cbor, value); }
            inline void add_item(float value) const
                { QCBOREncode_AddFloat(cbor, value); }
            inline void add_item(double value) const
                { QCBOREncode_AddDouble(cbor, value); }
 
            void add_array(u32 len, const bool* value) const;
            inline void add_array(u32 len, const s8* value) const
                { add_signed_array<s8>(len, value); }
            inline void add_array(u32 len, const s16* value) const
                { add_signed_array<s16>(len, value); }
            inline void add_array(u32 len, const s32* value) const
                { add_signed_array<s32>(len, value); }
            inline void add_array(u32 len, const s64* value) const
                { add_signed_array<s64>(len, value); }
            inline void add_array(u32 len, const u8* value) const
                { add_unsigned_array<u8>(len, value); }
            inline void add_array(u32 len, const u16* value) const
                { add_unsigned_array<u16>(len, value); }
            inline void add_array(u32 len, const u32* value) const
                { add_unsigned_array<u32>(len, value); }
            inline void add_array(u32 len, const u64* value) const
                { add_unsigned_array<u64>(len, value); }
            void add_array(u32 len, const float* value) const;
            void add_array(u32 len, const double* value) const;
 
            inline void add_bytes(u32 len, const u8* value) const
                { QCBOREncode_AddBytes(cbor, {value, len}); }
            inline void add_bytes(const u8* value, u32 len) const
                { QCBOREncode_AddBytes(cbor, {value, len}); }
 
            QCBOREncodeContext* open_list();
 
            QCBOREncodeContext* open_map();
 
            inline void add_string(const char* value) const
                { QCBOREncode_AddSZString(cbor, value); }
 
            inline void add_null() const
                { QCBOREncode_AddNULL(cbor); }
 
        protected:
            ListWriter(
                    satcat5::io::Writeable* dst,
                    QCBOREncodeContext* encode,
                    u8* buff, unsigned size)
                : CborWriter(dst, encode, buff, size, false)
                {
                    // Open the top-level list and trigger array auto-close.
                    QCBOREncode_OpenArray(cbor);
                    m_auto_close = QCBOR_TYPE_ARRAY;
                }
        };
 
        template <typename KEYTYPE = const char*>
        class MapWriter : virtual public CborWriter {
        public:
            explicit constexpr MapWriter(QCBOREncodeContext* encode)
                : CborWriter(encode) {}
 
            inline void add_bool(KEYTYPE key, bool value) const
                { add_key(key); QCBOREncode_AddBool(cbor, value); }
            inline void add_item(KEYTYPE key, s8 value) const
                { add_key(key); QCBOREncode_AddInt64(cbor, value); }
            inline void add_item(KEYTYPE key, s16 value) const
                { add_key(key); QCBOREncode_AddInt64(cbor, value); }
            inline void add_item(KEYTYPE key, s32 value) const
                { add_key(key); QCBOREncode_AddInt64(cbor, value); }
            inline void add_item(KEYTYPE key, s64 value) const
                { add_key(key); QCBOREncode_AddInt64(cbor, value); }
            inline void add_item(KEYTYPE key, u8 value) const
                { add_key(key); QCBOREncode_AddUInt64(cbor, value); }
            inline void add_item(KEYTYPE key, u16 value) const
                { add_key(key); QCBOREncode_AddUInt64(cbor, value); }
            inline void add_item(KEYTYPE key, u32 value) const
                { add_key(key); QCBOREncode_AddUInt64(cbor, value); }
            inline void add_item(KEYTYPE key, u64 value) const
                { add_key(key); QCBOREncode_AddUInt64(cbor, value); }
            inline void add_item(KEYTYPE key, float value) const
                { add_key(key); QCBOREncode_AddFloat(cbor, value); }
            inline void add_item(KEYTYPE key, double value) const
                { add_key(key); QCBOREncode_AddDouble(cbor, value); }
 
            void add_array(KEYTYPE key, u32 len, const bool* value) const;
            inline void add_array(KEYTYPE key, u32 len, const s8* value) const
                { add_key(key); add_signed_array<s8>(len, value); }
            inline void add_array(KEYTYPE key, u32 len, const s16* value) const
                { add_key(key); add_signed_array<s16>(len, value); }
            inline void add_array(KEYTYPE key, u32 len, const s32* value) const
                { add_key(key); add_signed_array<s32>(len, value); }
            inline void add_array(KEYTYPE key, u32 len, const s64* value) const
                { add_key(key); add_signed_array<s64>(len, value); }
            inline void add_array(KEYTYPE key, u32 len, const u8* value) const
                { add_key(key); add_unsigned_array<u8>(len, value); }
            inline void add_array(KEYTYPE key, u32 len, const u16* value) const
                { add_key(key); add_unsigned_array<u16>(len, value); }
            inline void add_array(KEYTYPE key, u32 len, const u32* value) const
                { add_key(key); add_unsigned_array<u32>(len, value); }
            inline void add_array(KEYTYPE key, u32 len, const u64* value) const
                { add_key(key); add_unsigned_array<u64>(len, value); }
            void add_array(KEYTYPE key, u32 len, const float* value) const;
            void add_array(KEYTYPE key, u32 len, const double* value) const;
 
            inline void add_bytes(KEYTYPE key, u32 len, const u8* value) const
                { add_key(key); QCBOREncode_AddBytes(cbor, {value, len}); }
            inline void add_bytes(KEYTYPE key, const u8* value, u32 len) const
                { add_key(key); QCBOREncode_AddBytes(cbor, {value, len}); }
 
            QCBOREncodeContext* open_list(KEYTYPE key);
 
            QCBOREncodeContext* open_map(KEYTYPE key);
 
            inline void add_string(KEYTYPE key, const char* value) const
                { add_key(key); QCBOREncode_AddSZString(cbor, value); }
 
            inline void add_null(KEYTYPE key) const
                { add_key(key); QCBOREncode_AddNULL(cbor); }
 
        protected:
            MapWriter() : CborWriter(0, 0, 0, 0, 0) {}
 
            void add_key(KEYTYPE key) const;
        };
 
        template <unsigned SIZE = SATCAT5_QCBOR_BUFFER>
        class ListWriterStatic : public ListWriter {
        public:
            explicit ListWriterStatic(satcat5::io::Writeable* dst = nullptr)
                : ListWriter(dst, &m_cbor, m_raw, SIZE) {}
 
        private:
            QCBOREncodeContext m_cbor;
            u8 m_raw[SIZE];
        };
 
        template <
            typename KEYTYPE = const char*,
            unsigned SIZE = SATCAT5_QCBOR_BUFFER>
        class MapWriterStatic : public MapWriter<KEYTYPE> {
        public:
            explicit MapWriterStatic(satcat5::io::Writeable* dst = nullptr)
                : CborWriter(dst, &m_cbor, m_raw, SIZE, true) {}
 
        private:
            QCBOREncodeContext m_cbor;
            u8 m_raw[SIZE];
        };
 
        class CborReader {
        public:
            inline bool ok() const
                { return (get_error() == QCBOR_SUCCESS); }
 
            inline QCBORError get_error() const
                { return QCBORDecode_GetError(cbor); }
 
            inline void close_list() const
                { QCBORDecode_ExitArray(cbor); }
 
            inline void close_map() const
                { QCBORDecode_ExitMap(cbor); }
 
            bool copy_item(QCBOREncodeContext* dst);
 
            unsigned copy_all(QCBOREncodeContext* dst);
 
            // Error return codes for array reading, values in io_cbor.cc.
            static const int ERR_NOT_FOUND;     
            static const int ERR_OVERFLOW;      
            static const int ERR_BAD_TYPE;      
            static const int ERR_QCBOR_INT;     
 
            // TODO: Below fails to link?
            // Get a string representing the QCBOR decoding error, if any.
            // inline const char* get_error_str() const
            //     { return qcbor_err_to_str(QCBORDecode_GetError(cbor)); }
 
            // Member variables
            QCBORDecodeContext* const cbor;         
 
        protected:
            CborReader(
                satcat5::io::Readable* src,
                QCBORDecodeContext* decode,
                u8* buff, unsigned size);
 
            explicit constexpr CborReader(QCBORDecodeContext* decode)
                : cbor(decode), m_item{} {}
 
            // Prohibit unsafe copy constructor and assignment operator.
            CborReader(const CborReader& other) = delete;
            CborReader& operator=(const CborReader& other) = delete;
 
            int get_array_internal(
                satcat5::io::Writeable& dst, u8 qcbor_type, u8 type_size) const;
 
            unsigned peek_integer_len(const u8* rdptr) const;
 
            // Member variables
            QCBORItem m_item;                       
        };
 
        class ListReader : public CborReader {
        public:
            explicit constexpr ListReader(QCBORDecodeContext* decode)
                : CborReader(decode) {}
 
            satcat5::util::optional<QCBORItem> get_item() const;
            satcat5::util::optional<bool> get_bool() const;
            satcat5::util::optional<s64> get_int() const;
            satcat5::util::optional<u64> get_uint() const;
            satcat5::util::optional<double> get_double() const;
 
            satcat5::util::optional<satcat5::io::ArrayRead> get_string() const;
 
            satcat5::util::optional<satcat5::io::ArrayRead> get_bytes() const;
 
            QCBORDecodeContext* open_list() const;
 
            QCBORDecodeContext* open_map() const;
 
            int get_bool_array(satcat5::io::Writeable& dst) const;
            int get_bool_array(u8* arr, unsigned arr_len) const {
                satcat5::io::ArrayWrite dst(arr, arr_len * sizeof(u8));
                return get_bool_array(dst);
            }
 
            int get_s64_array(satcat5::io::Writeable& dst) const;
            int get_s64_array(s64* arr, unsigned arr_len) const {
                satcat5::io::ArrayWrite dst(arr, arr_len * sizeof(s64));
                return get_s64_array(dst);
            }
 
            int get_double_array(satcat5::io::Writeable& dst) const;
            int get_double_array(double* arr, unsigned arr_len) const {
                satcat5::io::ArrayWrite dst(arr, arr_len * sizeof(double));
                return get_double_array(dst);
            }
 
        protected:
            ListReader(
                satcat5::io::Readable* src,
                QCBORDecodeContext* decode,
                u8* buff, unsigned size);
        };
 
        template <typename KEYTYPE = const char*>
        class MapReader : public CborReader {
        public:
            explicit constexpr MapReader(QCBORDecodeContext* decode)
                : CborReader(decode) {}
 
            satcat5::util::optional<bool> get_bool(KEYTYPE key) const;
            satcat5::util::optional<s64> get_int(KEYTYPE key) const;
            satcat5::util::optional<u64> get_uint(KEYTYPE key) const;
            satcat5::util::optional<double> get_double(KEYTYPE key) const;
 
            bool is_null(KEYTYPE key) const;
 
            satcat5::util::optional<satcat5::io::ArrayRead> get_string(KEYTYPE key) const;
 
            satcat5::util::optional<satcat5::io::ArrayRead> get_bytes(KEYTYPE key) const;
 
            QCBORDecodeContext* open_list(KEYTYPE key) const;
 
            QCBORDecodeContext* open_map(KEYTYPE key) const;
 
            int get_bool_array(KEYTYPE key, satcat5::io::Writeable& dst) const;
            int get_bool_array(KEYTYPE key, u8* arr, unsigned arr_len) const {
                satcat5::io::ArrayWrite dst(arr, arr_len * sizeof(u8));
                return get_bool_array(key, dst);
            }
 
            int get_s64_array(KEYTYPE key, satcat5::io::Writeable& dst) const;
            int get_s64_array(KEYTYPE key, s64* arr, unsigned arr_len) const {
                satcat5::io::ArrayWrite dst(arr, arr_len * sizeof(s64));
                return get_s64_array(key, dst);
            }
 
            int get_double_array(KEYTYPE key, satcat5::io::Writeable& dst) const;
            int get_double_array(KEYTYPE key, double* arr, unsigned arr_len) const {
                satcat5::io::ArrayWrite dst(arr, arr_len * sizeof(double));
                return get_double_array(key, dst);
            }
 
        protected:
            MapReader(
                satcat5::io::Readable* src,
                QCBORDecodeContext* decode,
                u8* buff, unsigned size);
        };
 
        template <unsigned SIZE = SATCAT5_QCBOR_BUFFER>
        class ListReaderStatic : public ListReader {
        public:
            explicit ListReaderStatic(satcat5::io::Readable* src)
                : ListReader(src, &m_cbor, m_raw, SIZE) {}
 
        private:
            QCBORDecodeContext m_cbor;
            u8 m_raw[SIZE];
        };
 
        template <
            typename KEYTYPE = const char*,
            unsigned SIZE = SATCAT5_QCBOR_BUFFER>
        class MapReaderStatic : public MapReader<KEYTYPE> {
        public:
            explicit MapReaderStatic(satcat5::io::Readable* src)
                : MapReader<KEYTYPE>(src, &m_cbor, m_raw, SIZE) {}
 
        private:
            QCBORDecodeContext m_cbor;
            u8 m_raw[SIZE];
        };
 
        struct Logger {
            const QCBORItem& m_item;
 
            constexpr explicit Logger(const QCBORItem& item)
                : m_item(item) {}
            Logger(const Logger& t) = default;
            Logger& operator=(const Logger& t) = default;
            void log_to(satcat5::log::LogBuffer& wr) const;
        };
    }
 
    namespace io {
        typedef satcat5::cbor::ListReader   CborListReader;
        typedef satcat5::cbor::ListWriter   CborListWriter;
        typedef satcat5::cbor::Logger       CborLogger;
        template <unsigned SIZE = SATCAT5_QCBOR_BUFFER>
            using CborListReaderStatic = satcat5::cbor::ListReaderStatic<SIZE>;
        template <unsigned SIZE = SATCAT5_QCBOR_BUFFER>
            using CborListWriterStatic = satcat5::cbor::ListWriterStatic<SIZE>;
        template <typename KEYTYPE = const char*>
            using CborMapReader = satcat5::cbor::MapReader<KEYTYPE>;
        template <typename KEYTYPE = const char*>
            using CborMapWriter = satcat5::cbor::MapReader<KEYTYPE>;
        template <
            typename KEYTYPE = const char*,
            unsigned SIZE = SATCAT5_QCBOR_BUFFER>
            using CborMapReaderStatic = satcat5::cbor::MapReaderStatic<KEYTYPE, SIZE>;
        template <
            typename KEYTYPE = const char*,
            unsigned SIZE = SATCAT5_QCBOR_BUFFER>
            using CborMapWriterStatic = satcat5::cbor::MapWriterStatic<KEYTYPE, SIZE>;
    }
}
 
#endif // SATCAT5_CBOR_ENABLE