Implement a higher-level API on top of the basics

LibCBOR/Include/CBOR/Concepts.hpp

@@ -0,0 +1,74 @@
+#ifndef LIBCBOR_CONCEPTS_HPP
+#define LIBCBOR_CONCEPTS_HPP
+
+#include "Core.hpp"
+
+#include <concepts>
+#include <span>
+#include <string_view>
+#include <type_traits>
+
+namespace CBOR
+{
+    template <typename T>
+    concept SimpleType = std::integral<T> ||
+                         std::floating_point<T> ||
+                         std::same_as<std::remove_cvref_t<T>, Special> ||
+                         std::same_as<std::remove_cvref_t<T>, bool>;
+
+    template <typename T>
+    concept StringLike = std::convertible_to<T, std::string_view>;
+
+    template <typename T>
+    concept BinaryLike = std::convertible_to<T, std::span<const std::uint8_t>>;
+
+    template <typename T>
+    concept EncodableContainer = !StringLike<T> && requires(T t) {
+        { t.size() } -> std::same_as<std::size_t>;
+        t.begin();
+        t.end();
+        typename T::value_type;
+    };
+
+    template <typename T>
+    concept MapContainer = EncodableContainer<T> && requires {
+        typename T::key_type;
+        typename T::mapped_type;
+    };
+
+    template <typename T>
+    concept SequenceContainer = EncodableContainer<T> && !MapContainer<T>;
+
+    namespace Implementation
+    {
+        template <typename... Ts>
+        struct First;
+
+        template <typename T>
+        struct First<T>
+        {
+            using Type = T;
+        };
+
+        template <typename T, typename... Ts>
+        struct First<T, Ts...>
+        {
+            using Type = T;
+        };
+    }
+
+    template <typename... Ts>
+    using First = Implementation::First<Ts...>::Type;
+
+    template <typename T>
+    struct MemberTraits;
+
+    template <typename T, typename MemberT>
+    struct MemberTraits<MemberT T:: *>
+    {
+        using ContainingType = T;
+        using MemberType = MemberT;
+    };
+}
+
+#endif // LIBCBOR_CONCEPTS_HPP

LibCBOR/Include/CBOR/Decoder.hpp

@@ -1,10 +1,15 @@
 #ifndef LIBCBOR_DECODER_HPP
 #define LIBCBOR_DECODER_HPP
 
+#include "Concepts.hpp"
 #include "Core.hpp"
 
+#include <concepts>
 #include <limits>
 #include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <utility>
 
 namespace CBOR
 {
@@ -59,6 +64,9 @@ namespace CBOR
         class Map        Map();
         class TaggedItem TaggedItem();
 
+        template <typename T>
+        T Decode();
+
     private:
         friend class Decoder;
         friend class Array;
@@ -183,6 +191,8 @@ namespace CBOR
         Array &operator=(const Array &) = delete;
 
     public:
+        static constexpr std::size_t Indefinite = std::numeric_limits<std::size_t>::max();
+
         Array(Array &&other);
         Array &operator=(Array &&other);
         ~Array() = default;
@@ -190,6 +200,8 @@ namespace CBOR
         bool Done();
         Item Next();
 
+        std::size_t Size();
+
     private:
         friend class Decoder;
 
@@ -210,6 +222,8 @@ namespace CBOR
         Map &operator=(const Map &) = delete;
 
     public:
+        static constexpr std::size_t Indefinite = std::numeric_limits<std::size_t>::max();
+
         Map(Map &&other);
         Map &operator=(Map &&other);
         ~Map() = default;
@@ -217,6 +231,8 @@ namespace CBOR
         bool     Done();
         KeyValue Next();
 
+        std::size_t Size();
+
     private:
         friend class Decoder;
 
@@ -272,6 +288,10 @@ namespace CBOR
         class TaggedItem TaggedItem();
 
         class Item       AsItem();
+
+        template <typename T>
+        T Decode();
+
     private:
         friend class Binary;
         friend class String;
@@ -282,6 +302,136 @@ namespace CBOR
         std::size_t mCurrent;
         ConstBuffer mBuffer;
     };
+
+    template <typename T>
+    T Item::Decode()
+    {
+        return mDecoder->Decode<T>();
+    }
+
+    template <typename T>
+    T Decoder::Decode()
+    {
+        if constexpr (std::same_as<T, bool>) {
+            return Bool();
+        }
+        else if constexpr (std::same_as<T, enum class Special>) {
+            return Special();
+        }
+        else if constexpr (std::signed_integral<T>) {
+            if constexpr (sizeof(T) == 1) {
+                return Int8();
+            }
+            else if constexpr (sizeof(T) == 2) {
+                return Int16();
+            }
+            else if constexpr (sizeof(T) == 4) {
+                return Int32();
+            }
+            else if constexpr (sizeof(T) == 8) {
+                return Int64();
+            }
+        }
+        else if constexpr (std::unsigned_integral<T>) {
+            if constexpr (sizeof(T) == 1) {
+                return Uint8();
+            }
+            else if constexpr (sizeof(T) == 2) {
+                return Uint16();
+            }
+            else if constexpr (sizeof(T) == 4) {
+                return Uint32();
+            }
+            else if constexpr (sizeof(T) == 8) {
+                return Uint64();
+            }
+        }
+        else if constexpr (std::same_as<T, float>) {
+            return Float();
+        }
+        else if constexpr (std::same_as<T, double>) {
+            return Double();
+        }
+        else if constexpr (std::same_as<T, std::string_view>) {
+            return String();
+        }
+        else if constexpr (std::same_as<T, ConstBuffer>) {
+            return Binary();
+        }
+        else if constexpr (requires (T a) { DecodeHook(*this, a); }) {
+            T result;
+            DecodeHook(*this, result);
+            return result;
+        }
+        else {
+            static_assert(false, "This type is not decodable (needs a custom DecodeHook)");
+        }
+    }
+
+    template <typename Key, typename ValuePtr>
+        requires std::is_member_object_pointer_v<ValuePtr>
+    class StructMember
+    {
+    public:
+        using KeyType = Key;
+        using MemberPtrType = ValuePtr;
+        using ContainingType = MemberTraits<ValuePtr>::ContainingType;
+        using MemberType = MemberTraits<ValuePtr>::MemberType;
+
+        StructMember(Key key, ValuePtr ptr)
+            : mEnabled(true), mKey(key), mValuePtr(ptr)
+        {}
+
+        bool Match(const Key &other) const
+        {
+            return mEnabled && other == mKey;
+        }
+
+        void Decode(Item &item, ContainingType &result)
+        {
+            result.*mValuePtr = item.Decode<MemberType>();
+            mEnabled = false;
+        }
+    private:
+        bool     mEnabled;
+        Key      mKey;
+        ValuePtr mValuePtr;
+    };
+
+    template <typename ValuePtr>
+    StructMember(const char *, ValuePtr) -> StructMember<std::string_view, ValuePtr>;
+
+    template <typename Key, typename... ValuePtrs>
+    class StructHelper
+    {
+    public:
+        using ContainingType = MemberTraits<First<ValuePtrs...>>::ContainingType;
+
+        StructHelper(StructMember<Key, ValuePtrs> &&...items)
+            : mStructItems(std::forward<StructMember<Key, ValuePtrs>>(items)...)
+        {}
+
+        void Decode(Decoder &decoder, ContainingType &result)
+        {
+            return Decode(decoder.AsItem(), result);
+        }
+
+        void Decode(Item item, ContainingType &result)
+        {
+            CBOR::Map map = item.Map();
+            while (!map.Done()) {
+                CBOR::KeyValue kv = map.Next();
+                Key key = kv.Key().Decode<Key>();
+                Item value = kv.Value();
+                std::apply([&key, &value, &result](auto &&...args) {
+                    void(((args.Match(key) ? (args.Decode(value, result), true) : false) || ...));
+                }, mStructItems);
+            }
+        }
+
+    private:
+        std::tuple<StructMember<Key, ValuePtrs>...> mStructItems;
+    };
 }
 
 #endif // LIBCBOR_DECODER_HPP

LibCBOR/Include/CBOR/DecoderHooks.hpp

@@ -0,0 +1,80 @@
+#ifndef LIBCBOR_DECODERHOOKS_HPP
+#define LIBCBOR_DECODERHOOKS_HPP
+
+#include "Decoder.hpp"
+
+#include <format>
+#include <map>
+#include <unordered_map>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+namespace CBOR
+{
+    constexpr
+    void DecodeHook(Decoder &decoder, std::string &value)
+    {
+        String string = decoder.IndefiniteString();
+        while (!string.Done()) {
+            value.append(string.Next());
+        }
+    }
+
+    constexpr
+    void DecodeHook(Decoder &decoder, std::vector<std::uint8_t> &value)
+    {
+        Binary binary = decoder.IndefiniteBinary();
+        while(!binary.Done()) {
+            value.append_range(binary.Next());
+        }
+    }
+
+    template <typename T>
+    constexpr
+    void DecodeHook(Decoder &decoder, std::vector<T> &value)
+    {
+        Array array = decoder.Array();
+        while (!array.Done()) {
+            value.push_back(array.Next().Decode<T>());
+        }
+    }
+
+    template <typename Key, typename Value>
+    constexpr
+    void DecodeHook(Decoder &decoder, std::unordered_map<Key, Value> &value)
+    {
+        Map map = decoder.Map();
+        while (!map.Done()) {
+            KeyValue kv = map.Next();
+            value.insert(std::make_pair(kv.Key().Decode<Key>(), kv.Value().Decode<Value>()));
+        }
+    }
+
+    template <typename Key, typename Value>
+    constexpr
+    void DecodeHook(Decoder &decoder, std::map<Key, Value> &value)
+    {
+        Map map = decoder.Map();
+        while (!map.Done()) {
+            KeyValue kv = map.Next();
+            value.insert(std::make_pair(kv.Key().Decode<Key>(), kv.Value().Decode<Value>()));
+        }
+    }
+
+    template <typename... Items>
+    constexpr
+    void DecodeHook(Decoder &decoder, std::tuple<Items...> &value)
+    {
+        Array array = decoder.Array();
+        if (array.Size() != sizeof...(Items)) {
+            throw DecodeError(std::format("Expected {} elements to fill tuple, got {} instead",
+                                          sizeof...(Items), array.Size()));
+        }
+        std::apply([&array] <typename... Args> (Args &...args) {
+            ((array.Done(), args = array.Next().Decode<Args>()), ...);
+        }, value);
+    }
+}
+
+#endif // LIBCBOR_DECODERHOOKS_HPP

LibCBOR/Include/CBOR/Encoder.hpp

@@ -1,6 +1,7 @@
 #ifndef LIBCBOR_ENCODER_HPP
 #define LIBCBOR_ENCODER_HPP
 
+#include "Concepts.hpp"
 #include "Core.hpp"
 
 #include <array>
@@ -39,7 +40,7 @@ namespace CBOR
         void Write(std::uint16_t value);
         void Write(std::uint32_t value);
         void Write(std::uint64_t value);
-        void Write(Buffer value);
+        void Write(ConstBuffer value);
         void Write(std::string_view value);
 
         std::size_t Size() const;
@@ -51,7 +52,7 @@ namespace CBOR
             void Write(std::uint16_t value);
             void Write(std::uint32_t value);
             void Write(std::uint64_t value);
-            void Write(Buffer value);
+            void Write(ConstBuffer value);
             void Write(std::string_view value);
 
             std::size_t Size() const;
@@ -67,7 +68,7 @@ namespace CBOR
             void Write(std::uint16_t value);
             void Write(std::uint32_t value);
             void Write(std::uint64_t value);
-            void Write(Buffer value);
+            void Write(ConstBuffer value);
             void Write(std::string_view value);
 
             std::size_t Size() const;
@@ -108,7 +109,7 @@ namespace CBOR
         void Encode(float value);
         void Encode(double value);
 
-        void Encode(Buffer value);
+        void Encode(ConstBuffer value);
         void Encode(const char *value);
         void Encode(std::string_view value);
 
@@ -125,9 +126,91 @@ namespace CBOR
         void EncodeTag(std::uint64_t value);
 
         std::size_t Size() const;
+
     private:
         EncoderBuffer mBuffer;
     };
+
+    class Encoder
+    {
+    public:
+        Encoder(EncoderBuffer buffer);
+
+        template <typename T>
+        Encoder &Encode(const T &value)
+        {
+            if constexpr (SimpleType<T> || StringLike<T> || BinaryLike<T>) {
+                mEncoder.Encode(value);
+            }
+            else if constexpr (SequenceContainer<T>) {
+                mEncoder.BeginArray(value.size());
+                for (const auto &item: value) {
+                    Encode(item);
+                }
+            }
+            else if constexpr (MapContainer<T>) {
+                mEncoder.BeginMap(value.size());
+                for (const auto &[key, value]: value) {
+                    Encode(key);
+                    Encode(value);
+                }
+            }
+            else if constexpr (requires { EncodeHook(*this, value); }) {
+                EncodeHook(*this, value);
+            }
+            else if constexpr (requires { EncodeHook(mEncoder, value); }) {
+                EncodeHook(mEncoder, value);
+            }
+            else {
+                static_assert(false, "This type is not encodable (needs a custom EncodeHook)");
+            }
+            return *this;
+        }
+
+        template <typename... Ts>
+        Encoder &EncodeArray(Ts &&...values)
+        {
+            mEncoder.BeginArray(sizeof...(values));
+            (Encode(std::forward<Ts>(values)), ...);
+            return *this;
+        }
+
+        template <typename... Ts>
+            requires (sizeof...(Ts) % 2 == 0)
+        Encoder &EncodeMap(Ts &&...values)
+        {
+            mEncoder.BeginMap(sizeof...(values) / 2);
+            (Encode(std::forward<Ts>(values)), ...);
+            return *this;
+        }
+
+        template <typename T>
+        Encoder &EncodeTagged(std::uint64_t tag, const T &value)
+        {
+            mEncoder.EncodeTag(tag);
+            return Encode(value);
+        }
+
+        template <typename... Ts>
+        Encoder &EncodeTaggedArray(std::uint64_t tag, Ts &&...values)
+        {
+            mEncoder.EncodeTag(tag);
+            return EncodeArray(std::forward<Ts>(values)...);
+        }
+
+        template <typename... Ts>
+            requires (sizeof...(Ts) % 2 == 0)
+        Encoder &EncodeTaggedMap(std::uint64_t tag, Ts &&...values)
+        {
+            mEncoder.EncodeTag(tag);
+            return EncodeMap(std::forward<Ts>(values)...);
+        }
+
+        std::size_t Size() const;
+
+    private:
+        BasicEncoder mEncoder;
+    };
 }
 
 #endif // LIBCBOR_ENCODER_HPP

LibCBOR/Source/Decoder.cpp

@@ -55,8 +55,6 @@ namespace CBOR
 
     namespace
     {
-        static constexpr std::size_t Indefinite = std::numeric_limits<std::size_t>::max();
-
         std::size_t SpaceLeft(ConstBuffer buffer, std::size_t offset)
         {
             if (offset >= buffer.size()) {
@@ -851,7 +849,7 @@ namespace CBOR
         }
 
         if (!mCheckedDone) {
-            throw InvalidUsageError("check whether the indefinite string is done first");
+            throw InvalidUsageError("check whether the array is done first");
         }
         mCheckedDone = false;
 
@@ -859,6 +857,27 @@ namespace CBOR
         return Item(*mDecoder);
     }
 
+    std::size_t Array::Size()
+    {
+        if (!mHeaderParsed) {
+            std::uint8_t header = Consume1B(mDecoder->mBuffer, mDecoder->mCurrent);
+            mHeaderParsed = true;
+            if (GetMajorType(header) != MajorType::Array) {
+                throw TypeMismatchError("array", ToString(GetMajorType(header)));
+            }
+
+            bool indefinite = GetArgumentPosition(header) == ArgumentPosition::Indefinite;
+            mSize = indefinite ? Indefinite
+                               : ArgumentValue(header, mDecoder->mBuffer, mDecoder->mCurrent);
+
+            if (!mSize) {
+                mDone = true;
+                mCheckedDone = true;
+            }
+        }
+        return mSize;
+    }
+
     Map::Map(Decoder &decoder)
         : mHeaderParsed(false)
         , mDone(false)
@@ -935,7 +954,7 @@ namespace CBOR
         }
 
         if (!mCheckedDone) {
-            throw InvalidUsageError("check whether the indefinite string is done first");
+            throw InvalidUsageError("check whether the map is done first");
         }
         mCheckedDone = false;
 
@@ -943,6 +962,27 @@ namespace CBOR
         return KeyValue(*mDecoder);
     }
 
+    std::size_t Map::Size()
+    {
+        if (!mHeaderParsed) {
+            std::uint8_t header = Consume1B(mDecoder->mBuffer, mDecoder->mCurrent);
+            mHeaderParsed = true;
+            if (GetMajorType(header) != MajorType::Map) {
+                throw TypeMismatchError("map", ToString(GetMajorType(header)));
+            }
+
+            bool indefinite = GetArgumentPosition(header) == ArgumentPosition::Indefinite;
+            mSize = indefinite ? Indefinite
+                               : ArgumentValue(header, mDecoder->mBuffer, mDecoder->mCurrent);
+
+            if (!mSize) {
+                mDone = true;
+                mCheckedDone = true;
+            }
+        }
+        return mSize;
+    }
+
     Decoder::Decoder(ConstBuffer buffer)
         : mCurrent(0), mBuffer(buffer)
     {}

LibCBOR/Source/Encoder.cpp

@@ -120,7 +120,7 @@ namespace CBOR
         }, mBuffer);
     }
 
-    void EncoderBuffer::Write(Buffer value)
+    void EncoderBuffer::Write(ConstBuffer value)
     {
         std::visit(Overload {
             [value] (FixedBuffer &buffer) { buffer.Write(value); },
@@ -185,7 +185,7 @@ namespace CBOR
         mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 56) & mask);
     }
 
-    void EncoderBuffer::FixedBuffer::Write(Buffer value)
+    void EncoderBuffer::FixedBuffer::Write(ConstBuffer value)
     {
         EnsureSpace(value.size());
         std::memcpy(mBuffer.data() + mCurrent, value.data(), value.size());
@@ -250,7 +250,7 @@ namespace CBOR
         mBuffer->push_back(static_cast<std::uint8_t>((network >> 56) & mask));
     }
 
-    void EncoderBuffer::DynamicBuffer::Write(Buffer value)
+    void EncoderBuffer::DynamicBuffer::Write(ConstBuffer value)
     {
         mBuffer->append_range(value);
     }
@@ -447,7 +447,7 @@ namespace CBOR
         mBuffer.Write(std::bit_cast<std::uint64_t>(value));
     }
 
-    void BasicEncoder::Encode(Buffer value)
+    void BasicEncoder::Encode(ConstBuffer value)
     {
         WriteHeader(mBuffer, MajorType::Binary, value.size());
         mBuffer.Write(value);
@@ -508,4 +508,13 @@ namespace CBOR
     {
         return mBuffer.Size();
     }
+
+    Encoder::Encoder(EncoderBuffer buffer)
+        : mEncoder(std::move(buffer))
+    {}
+
+    std::size_t Encoder::Size() const
+    {
+        return mEncoder.Size();
+    }
 }

Tests/Main.cpp

@@ -1,11 +1,14 @@
-#include "CBOR/Decoder.hpp"
+#include <CBOR/Core.hpp>
-#include "CBOR/Encoder.hpp"
+#include <CBOR/Decoder.hpp>
-#include "CBOR/Printer.hpp"
+#include <CBOR/DecoderHooks.hpp> // IWYU pragma: keep
+#include <CBOR/Encoder.hpp>
+#include <CBOR/Printer.hpp>
+
 #include <array>
+#include <compare> // IWYU pragma: keep
 #include <cstdint>
 #include <iostream>
 #include <print>
-#include <ranges>
 #include <stdexcept>
 #include <vector>
 
@@ -18,166 +21,47 @@ struct SomeStruct
     std::int64_t slots;
     std::uint32_t times;
     std::vector<std::string> tools;
+
+    constexpr auto operator<=>(const SomeStruct &) const = default;
 };
 
-std::size_t Encode(const SomeStruct &value, auto &buffer)
+void EncodeHook(CBOR::Encoder &enc, const SomeStruct &value)
 {
-    CBOR::BasicEncoder enc(buffer);
+    enc.EncodeTaggedMap(
-    enc.EncodeTag(15'000);
+        15'000,
-
+        "name",  value.name,
-    enc.BeginMap(7);
+        "speed", value.speed,
-
+        "fov",   value.fov,
-    enc.Encode("name");
+        "thing", value.thing,
-    enc.Encode(value.name);
+        "slots", value.slots,
-
+        "times", value.times,
-    enc.Encode("speed");
+        "tools", value.tools
-    enc.Encode(value.speed);
+    );
-
-    enc.Encode("fov");
-    enc.Encode(value.fov);
-
-    enc.Encode("thing");
-    enc.Encode(value.thing);
-
-    enc.Encode("slots");
-    enc.Encode(value.slots);
-
-    enc.Encode("times");
-    enc.Encode(value.times);
-
-    enc.Encode("tools");
-    enc.BeginIndefiniteArray();
-    for (std::string_view tool: value.tools) {
-        enc.Encode(tool);
-    }
-    enc.End();
-
-    return enc.Size();
 }
 
-SomeStruct Decode1(std::span<std::uint8_t> buffer)
+void DecodeHook(CBOR::Decoder &dec, SomeStruct &value)
 {
-    SomeStruct result;
+    CBOR::StructHelper helper {
-
+        CBOR::StructMember { "name",  &SomeStruct::name  },
-    CBOR::Decoder dec(buffer);
+        CBOR::StructMember { "speed", &SomeStruct::speed },
+        CBOR::StructMember { "fov",   &SomeStruct::fov   },
+        CBOR::StructMember { "thing", &SomeStruct::thing },
+        CBOR::StructMember { "slots", &SomeStruct::slots },
+        CBOR::StructMember { "times", &SomeStruct::times },
+        CBOR::StructMember { "tools", &SomeStruct::tools },
+    };
     CBOR::TaggedItem tagged = dec.TaggedItem();
     if (tagged.Tag() != 15'000) {
-        throw std::runtime_error("test error: could not extract object tag");
+        throw std::runtime_error("Expected item with tag value 15000");
-    }
-    CBOR::Map object = tagged.Item().Map();
-    while (!object.Done()) {
-        CBOR::KeyValue kv = object.Next();
-        std::string_view key = kv.Key().String();
-        CBOR::Item value = kv.Value();
-        if (key == "name") {
-            result.name = value.String();
-        }
-        else if (key == "speed") {
-            result.speed = value.Double();
-        }
-        else if (key == "fov") {
-            result.fov = value.Float();
-        }
-        else if (key == "thing") {
-            result.thing = value.Int8();
-        }
-        else if (key == "slots") {
-            result.slots = value.Int64();
-        }
-        else if (key == "times") {
-            result.times = value.Uint32();
-        }
-        else if (key == "tools") {
-            CBOR::Array tools = value.Array();
-            while(!tools.Done()) {
-                result.tools.push_back(std::string(tools.Next().String()));
-            }
-        }
-    }
-
-    return result;
-}
-
-SomeStruct Decode2(std::span<std::uint8_t> buffer)
-{
-    SomeStruct result;
-
-    CBOR::Decoder dec(buffer);
-    CBOR::TaggedItem tagged = dec.TaggedItem();
-    if (tagged.Tag() != 15'000) {
-        throw std::runtime_error("test error: could not extract object tag");
-    }
-    CBOR::Map object = tagged.Item().Map();
-    while (!object.Done()) {
-        CBOR::KeyValue kv = object.Next();
-        std::string_view key = kv.Key().String();
-        CBOR::Item value = kv.Value();
-        if (key == "name") {
-            result.name = value.String();
-        }
-        else if (key == "speed") {
-            result.speed = value.Double();
-        }
-        else if (key == "fov") {
-            result.fov = value.Float();
-        }
-        else if (key == "thing") {
-            result.thing = value.Int8();
-        }
-        else if (key == "slots") {
-            result.slots = value.Int64();
-        }
-        else if (key == "times") {
-            result.times = value.Uint32();
-        }
-        else if (key == "tools") {
-            CBOR::Array tools = value.Array();
-            while(!tools.Done()) {
-                result.tools.push_back("");
-                CBOR::String tool = tools.Next().IndefiniteString();
-                while (!tool.Done()) {
-                    result.tools.back().append(tool.Next());
-                }
-            }
-        }
-    }
-
-    return result;
-}
-
-void Compare(const SomeStruct &s1, const SomeStruct &s2)
-{
-    if (s1.name != s2.name) {
-        throw std::runtime_error("test error: names are not the same");
-    }
-    if (s1.speed != s2.speed) {
-        throw std::runtime_error("test error: speed is not the same");
-    }
-    if (s1.fov != s2.fov) {
-        throw std::runtime_error("test error: fovs are not the same");
-    }
-    if (s1.thing != s2.thing) {
-        throw std::runtime_error("test error: things are not the same");
-    }
-    if (s1.slots != s2.slots) {
-        throw std::runtime_error("test error: slots are not the same");
-    }
-    if (s1.times != s2.times) {
-        throw std::runtime_error("test error: times are not the same");
-    }
-    for (const auto &[t1, t2]: std::ranges::views::zip(s1.tools, s2.tools)) {
-        if (t1 != t2) {
-            throw std::runtime_error("test error: some tools are not the same");
-        }
     }
+    helper.Decode(tagged.Item(), value);
 }
 
 int main()
 {
     using namespace std::string_view_literals;
 
-    //std::array<std::uint8_t, 1024> buffer {};
+    std::array<std::uint8_t, 1024> buffer {};
-    std::vector<std::uint8_t> buffer;
 
     SomeStruct expected {
         .name = "Player1",
@@ -196,23 +80,20 @@ int main()
     };
 
     try {
-        std::size_t encodedSize = Encode(expected, buffer);
+        CBOR::Encoder enc(buffer);
-        std::println("Encoded size: {}", encodedSize);
+        enc.Encode(expected);
 
-        std::print("Encoded hex: ");
+        CBOR::ConstBuffer encoded(buffer.data(), enc.Size());
-        for (std::size_t i = 0; i < encodedSize; ++i) {
+
-            std::print("{:02X} ", buffer[i]);
+        CBOR::Decoder dec(encoded);
+        SomeStruct res = dec.Decode<SomeStruct>();
+
+        if (res != expected) {
+            throw std::runtime_error("test error: the encode/decode round trip should be lossless");
         }
-        std::println();
 
-        SomeStruct result1 = Decode1(std::span<std::uint8_t>(buffer.data(), encodedSize));
+        CBOR::Print(std::cout, encoded);
-        SomeStruct result2 = Decode2(std::span<std::uint8_t>(buffer.data(), encodedSize));
 
-        std::println("JSON-esque serialization:");
-        CBOR::Print(std::cout, std::span<std::uint8_t>(buffer.data(), encodedSize));
-
-        Compare(expected, result1);
-        Compare(expected, result2);
         std::println("The test has been completed successfully.");
     }
     catch (const std::exception &e) {