cbor.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "types.hpp"
 
#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
#define __STDC_WANT_IEC_60559_TYPES_EXT__
#endif
#include <float.h>
#include <math.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include <algorithm>
#include <array>
#include <bit>
#include <concepts>
#include <optional>
#include <span>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace Cbor
{
 
#if (defined(FLT16_MIN) || defined(FLT16_MIN)) && !defined(NO_FLOAT16)
#define CBOR_HALF_SUPPORT
#endif
 
#if defined(CBOR_HALF_SUPPORT)
typedef _Float16 half;
#endif

    enum class Major : uint8_t
    {
        U64 = 0,
        Neg64 = 1,
        Bytes = 2,
        Utf8 = 3,
        Array = 4,
        Map = 5,
        Tagged = 6,
        Simple = 7,
        Float = 7,
    };
    constexpr Major getMajor(uint8_t initial) { return Major(initial >> 5); }
    constexpr uint8_t setMajor(uint8_t initial, Major major)
    {
        return static_cast<uint8_t>(
            (initial & ~(~0 << 5)) |
            static_cast<uint8_t>(major) << 5);
    }
 
    enum class Minor : uint8_t
    {
        EmbeddedFirst = 0,
        EmbeddedLast = 23,
        OneByteFollows = 24,
        TwoByteFollows = 25,
        FourByteFollows = 26,
        EightByteFollows = 27,
        Indefinite = 31,
    };
    constexpr uint8_t EMBEDDED_MIN = static_cast<uint8_t>(Minor::EmbeddedFirst);
    constexpr uint8_t EMBEDDED_MAX = static_cast<uint8_t>(Minor::EmbeddedLast);
    constexpr Minor getMinor(uint8_t initial) { return Minor(initial & ((1 << 5) - 1)); }
    constexpr uint8_t setMinor(uint8_t initial, Minor minor)
    {
        return static_cast<uint8_t>(
            (initial & (~0 << 5)) |
            static_cast<uint8_t>(minor));
    }
    constexpr uint8_t initialByte(Major major, Minor minor)
    {
        return setMinor(setMajor(0, major), minor);
    }
    consteval Minor minorFromSizeOf(const size_t bytes)
    {
        return
            bytes == 1 ? Minor::OneByteFollows :
            bytes == 2 ? Minor::TwoByteFollows :
            bytes == 4 ? Minor::FourByteFollows :
            Minor::EightByteFollows;
     }

    enum class SimpleValues : uint8_t
    {
        Unassigned0First = 0,
        Unassigned0Last = 19,
        False = 20,
        True = 21,
        Null = 22,
        Undefined = 23,
        ReservedFirst = 24,
        ReservedLast = 31,
        Unassigned1First = 32,
        Unassigned1Last = 255,
    };
 
    struct Undefined{};

    template<typename T, typename Placeholder>
    struct WrapVoid{};;
 
    template<typename Placeholder>
    struct WrapVoid<void, Placeholder>
    {
        using T = Placeholder;
        T value;
        template<typename Fn, typename Tuple>
        WrapVoid(Fn && fn, Tuple && args)
        {
            std::apply(std::forward<Fn>(fn), std::forward<Tuple>(args));
        }
    };
 
    template<typename U, typename Placeholder> requires (!std::same_as<U, void>)
    struct WrapVoid<U, Placeholder>
    {
        using T = U;
        T value;
        template<typename Fn, typename Tuple>
        WrapVoid(Fn && fn, Tuple && args)
            : value(std::apply(std::forward<Fn>(fn), std::forward<Tuple>(args)))
        {
        }
    };
 
    template<typename T, typename Placeholder>
    using WrapVoidT = WrapVoid<T, Placeholder>::T;
 

    bool packEmbedded(Major major, uint8_t value, std::span<uint8_t> & buf);
    template<std::unsigned_integral Int>
    bool pack(Major major, Int value, std::span<uint8_t> & buf);
    template<>
    bool pack<unsigned char>(Major major, unsigned char value, std::span<uint8_t> & buf);
    template<>
    bool pack<unsigned short>(Major major, unsigned short value, std::span<uint8_t> & buf);
    template<>
    bool pack<unsigned int>(Major major, unsigned int value, std::span<uint8_t> & buf);
    template<>
    bool pack<unsigned long>(Major major, unsigned long value, std::span<uint8_t> & buf);
    template<>
    bool pack<unsigned long long>(Major major, unsigned long long value, std::span<uint8_t> & buf);

    struct Item
    {
        Major major;
        Minor minor;
        uint64_t value;
    };

    std::optional<Item> unpack(std::span<uint8_t> & buf);

    template<std::unsigned_integral Int>
    bool encode(Major major, Int value, std::span<uint8_t> & buf);
    template<>
    bool encode<unsigned char>(Major major, unsigned char value, std::span<uint8_t> & buf);
    template<>
    bool encode<unsigned short>(Major major, unsigned short value, std::span<uint8_t> & buf);
    template<>
    bool encode<unsigned int>(Major major, unsigned int value, std::span<uint8_t> & buf);
    template<>
    bool encode<unsigned long>(Major major, unsigned long value, std::span<uint8_t> & buf);
    template<>
    bool encode<unsigned long long>(Major major, unsigned long long value, std::span<uint8_t> & buf);

    template<typename T>
    struct Cbor
    {
    };
 
    template<typename I> requires std::integral<I> && (!std::same_as<I, bool>)
    struct Cbor<I>
    {
        static constexpr size_t bytes = sizeof(I);
        static bool encode(I value, std::span<uint8_t> & buf)
        {
            Major major = value >= 0 ? Major::U64 : Major::Neg64;
            value = value >= 0 ? value : ~value;
            using UI = std::make_unsigned_t<I>;
            return ::Cbor::encode<UI>(major, std::bit_cast<UI>(value), buf);
        }
        static std::optional<I> decode(std::span<uint8_t> & buf)
        {
            auto value = unpack(buf);
            if (!value)
            {
                return {};
            }
            if (value->major == Major::Neg64)
            {
                value->value = ~value->value;
            }
            else if (value->major != Major::U64)
            {
                return {};
            }
            if (value->minor <= minorFromSizeOf(bytes))
            {
                return {value->value};
            }
            return {};
        }
        static size_t maxSize()
        {
            return 1 + bytes;
        }
    };
 
    template<typename F> requires std::floating_point<F>
#if defined(CBOR_HALF_SUPPORT)
        || std::same_as<F, _Float16>
#endif
    struct Cbor<F>
    {
        static constexpr size_t bytes = sizeof(F);
        using BitT = UintT<bytes * 8>;
        static bool encode(F value, std::span<uint8_t> & buf)
        {
#if defined(CBOR_HALF_SUPPORT)
            if (std::isnan(value))
            {
                const auto nan = std::bit_cast<uint16_t>(static_cast<_Float16>(NAN));
                return ::Cbor::pack<uint16_t>(Major::Float, nan, buf);
            }
            const auto v16 = static_cast<_Float16>(value);
            if (value == v16)
            {
                uint16_t b16 = std::bit_cast<uint16_t>(v16);
                return ::Cbor::pack<uint16_t>(Major::Float, b16, buf);
            }
#endif
            if (std::isnan(value))
            {
                const auto nan = std::bit_cast<uint32_t>(static_cast<float>(NAN));
                return ::Cbor::pack<uint32_t>(Major::Float, nan, buf);
            }
            const auto v32 = static_cast<float>(value);
            if (v32 == value)
            {
                const auto b32 = std::bit_cast<uint32_t>(v32);
                return ::Cbor::pack<uint32_t>(Major::Float, b32, buf);
            }
            const auto v64 = static_cast<double>(value);
            const auto b64 = std::bit_cast<uint64_t>(v64);
            return ::Cbor::pack<uint64_t>(Major::Float, b64, buf);
        }
        static std::optional<F> decode(std::span<uint8_t> & buf)
        {
            auto value = unpack(buf);
            if (!value || value->major != Major::Float)
            {
                return {};
            }
            // Allow upcasts to support deterministically encoded CBOR
#if defined(CBOR_HALF_SUPPORT)
            if (value->minor == Minor::TwoByteFollows && 2 <= bytes)
            {
                return {static_cast<F>(std::bit_cast<_Float16>(static_cast<uint16_t>(value->value)))};
            }
#endif
            if (value->minor == Minor::FourByteFollows && 4 <= bytes)
            {
                return {static_cast<F>(std::bit_cast<float>(static_cast<uint32_t>(value->value)))};
            }
            if (value->minor == Minor::EightByteFollows && 8 <= bytes)
            {
                return {static_cast<F>(std::bit_cast<double>(static_cast<uint64_t>(value->value)))};
            }
            return {};
        }
        static size_t maxSize()
        {
            return 1 + bytes;
        }
    };
 
    template<>
    struct Cbor<bool>
    {
        static bool encode(bool value, std::span<uint8_t> & buf)
        {
            return packEmbedded(
                Major::Simple,
                static_cast<uint8_t>(value ? SimpleValues::True : SimpleValues::False),
                buf);
        }
        static std::optional<bool> decode(std::span<uint8_t> & buf)
        {
            auto value = unpack(buf);
            if (value.has_value() && value->major == Major::Simple)
            {
                if (value->minor == static_cast<Minor>(SimpleValues::True))
                {
                    return {true};
                }
                else if (value->minor == static_cast<Minor>(SimpleValues::False))
                {
                    return {false};
                }
            }
            return {};
        }
    };
 
    template<typename T>
    struct Cbor<T *>
    {
        static bool encode(T * obj, std::span<uint8_t> & buf)
        {
            return obj != nullptr
                ? Cbor<T>::encode(*obj, buf)
                : packEmbedded(Major::Simple, static_cast<uint8_t>(SimpleValues::Null), buf);
        }
    };
 
    template<>
    struct Cbor<void>
    {
        static bool encode(Undefined, std::span<uint8_t> & buf)
        {
            return packEmbedded(
                Major::Simple,
                static_cast<uint8_t>(SimpleValues::Undefined), buf);
        }
 
        static std::optional<Undefined> decode(std::span<uint8_t> & buf)
        {
            auto value = unpack(buf);
            if (value.has_value() &&
                value->major == Major::Simple &&
                value->minor == static_cast<Minor>(SimpleValues::Undefined))
            {
                return {Undefined{}};
            }
            return {};
        }
    };
 
    template<>
    struct Cbor<std::string_view>
    {
        static bool encode(std::string_view str, std::span<uint8_t> & buf)
        {
            if (!::Cbor::encode<size_t>(Major::Utf8, str.size(), buf))
            {
                return false;
            }
            for (char c : str)
            {
                if (buf.size() == 0)
                {
                    return false;
                }
                buf[0] = c;
                buf = buf.subspan(1);
            }
            return true;
        }
    };
 
    template<>
    struct Cbor<const char *>
    {
        static bool encode(const char * str, std::span<uint8_t> & buf)
        {
            const size_t size = strlen(str);
            if (!::Cbor::encode<size_t>(Major::Utf8, size, buf))
            {
                return false;
            }
            for (size_t i = 0; i < size; ++i)
            {
                if (buf.size() == 0)
                {
                    return false;
                }
                buf[0] = str[i];
                buf = buf.subspan(1);
            }
            return true;
        }
    };
 
    template<size_t size>
    struct Cbor<const char (&)[size]>
    {
        static bool encode(const char (&str)[size], std::span<uint8_t> & buf)
        {
            if (!::Cbor::encode<size_t>(Major::Utf8, size, buf))
            {
                return false;
            }
            for (size_t i = 0; i < size; ++i)
            {
                if (buf.size() == 0)
                {
                    return false;
                }
                buf[0] = str[i];
                buf = buf.subspan(1);
            }
            return true;
        }
    };
 
    template<typename... Item>
    struct Cbor<std::tuple<Item...>>
    {
        using Tuple = std::tuple<Item...>;
        static bool encode(Tuple tup, std::span<uint8_t> & buf)
        {
            if (buf.size() < 1)
            {
                return false;
            }
            return
                ::Cbor::encode<size_t>(
                    Major::Array,
                    std::tuple_size_v<Tuple>,
                    buf) &&
                [&]<size_t... Index>(std::index_sequence<Index...>)
                {
                    return (
                        Cbor<std::tuple_element_t<Index, Tuple>>::encode(std::get<Index>(tup), buf) &&
                        ...
                    );
                }(std::index_sequence_for<Item...>{});
        }
        template<typename... T>
        static std::optional<std::tuple<T...>> transpose(std::tuple<std::optional<T>...> ts)
        {
            return [&]<size_t... Index>(std::index_sequence<Index...>)
            {
                if ((std::get<Index>(ts) && ...))
                {
                    return std::optional<std::tuple<T...>>{std::in_place, *std::get<Index>(ts)...};
                }
                return std::optional<std::tuple<T...>>{};
            }(std::index_sequence_for<T...>{});
        }
        static std::optional<Tuple> decode(std::span<uint8_t> & buf)
        {
            auto value = unpack(buf);
            if (value.has_value() && value->major == Major::Array)
            {
                std::tuple<std::optional<Item>...> ts{Cbor<Item>::decode(buf)...};
                if (value->minor != Minor::Indefinite)
                {
                    return transpose(ts);
                }
                else
                {
                    auto sentinel = unpack(buf);
                    if (sentinel.has_value() &&
                        sentinel->major == Major::Simple &&
                        sentinel->minor == Minor::Indefinite)
                    {
                        return transpose(ts);
                    }
                }
            }
            return {};
        }
    };
 
    template<size_t Size>
    struct Cbor<std::span<uint8_t, Size>>
    {
        static bool encode(std::span<uint8_t, Size> span, std::span<uint8_t> & buf)
        {
            if (buf.size() < 1)
            {
                return false;
            }
            if (!::Cbor::encode<size_t>(Major::Bytes, span.size(), buf))
            {
                return false;
            }
            if (buf.size() < span.size())
            {
                return false;
            }
            std::copy(span.cbegin(), span.cend(), buf.begin());
            buf = buf.subspan(span.size());
            return true;
        }
        static std::optional<std::span<uint8_t, Size>> decode(std::span<uint8_t> & buf)
        {
            auto value = unpack(buf);
            if (value.has_value() && value->major == Major::Bytes)
            {
                if (value->minor == Minor::Indefinite)
                {
                    return {};
                }
                else
                {
                    return {buf};
                }
            }
            return {};
        }
    };
 
    template<typename T, size_t Size>
    struct Cbor<std::array<T, Size>>
    {
        static bool encode(std::array<T, Size> array, std::span<uint8_t> & buf)
        {
            if (buf.size() < 1)
            {
                return false;
            }
            if (!::Cbor::encode<size_t>(Major::Array, array.size(), buf))
            {
                return false;
            }
            for (const auto & item : array)
            {
                if (!Cbor<T>::encode(item, buf))
                {
                    return false;
                }
            }
            return true;
        }
        static std::optional<std::array<T, Size>> decode(std::span<uint8_t> & buf)
        {
            auto value = unpack(buf);
            if (value.has_value() && value->major == Major::Array)
            {
                std::array<T, Size> array =
                    [&]<size_t... Index>(std::index_sequence<Index...>)
                    {
                        return std::array<T, Size>{
                            *((void)Index, Cbor<T>::decode(buf))...
                        };
                    }(std::make_index_sequence<Size>{});
                if (value->minor != Minor::Indefinite)
                {
                    return array;
                }
                else
                {
                    auto sentinel = unpack(buf);
                    if (sentinel.has_value() &&
                        sentinel->major == Major::Simple &&
                        sentinel->minor == Minor::Indefinite)
                    {
                        return array;
                    }
                }
            }
            return {};
        }
    };
 
    template<Major major>
    class Sequence
    {
    public:
        Sequence(std::span<uint8_t> & buf_, size_t extent_ = std::dynamic_extent)
            : buf(buf_),  extent(extent_)
        {
            if (extent == std::dynamic_extent)
            {
                packEmbedded(major, static_cast<uint8_t>(Minor::Indefinite), buf);
            }
            else
            {
                ::Cbor::encode<size_t>(major, extent, buf);
            }
        }
        template<Major parentMajor>
        Sequence(Sequence<parentMajor> & parentSeq, size_t extent_ = std::dynamic_extent)
            : buf(parentSeq.buf),  extent(extent_)
        {
            ++parentSeq.packed;
            if (extent == std::dynamic_extent)
            {
                packEmbedded(major, static_cast<uint8_t>(Minor::Indefinite), buf);
            }
            else
            {
                ::Cbor::encode<size_t>(major, extent, buf);
            }
        }
        bool as_expected()
        {
            return extent == std::dynamic_extent || extent == packed;
        }
        ~Sequence()
        {
            if (extent == std::dynamic_extent)
            {
                packEmbedded(Major::Simple, static_cast<uint8_t>(Minor::Indefinite), buf);
            }
        }
 
        template<typename T>
        bool encode(T value)
        {
            ++packed;
            return Cbor<T>::encode(value, buf);
        }
    private:
        std::span<uint8_t> & buf;
        const size_t extent;
        size_t packed = 0;
    };
};