refactor: Update unpacking functions to use std::byte for improved type safety

Author: rwindegger

examples/second_example.cpp

@@ -9,37 +9,6 @@
 #include <map>
 #include <msgpack23/msgpack23.h>
 
-class converting_insert_iterator final {
-public:
-    using difference_type = std::ptrdiff_t;
-
-    constexpr explicit converting_insert_iterator(std::back_insert_iterator<std::vector<unsigned char>> &&iterator) : store_{std::move(iterator)} {}
-
-    constexpr converting_insert_iterator &operator=(const std::byte &value) {
-        store_ = std::to_underlying(value);
-        return *this;
-    }
-
-    constexpr converting_insert_iterator &operator=(std::byte &&value) {
-        store_ = std::to_underlying(value);
-        return *this;
-    }
-
-    [[nodiscard]] constexpr converting_insert_iterator &operator*() {
-        return *this;
-    }
-
-    constexpr converting_insert_iterator &operator++() {
-        return *this;
-    }
-
-    constexpr converting_insert_iterator operator++(int) {
-        return *this;
-    }
-private:
-    std::back_insert_iterator<std::vector<unsigned char>> store_;
-};
-
 struct MyData {
     std::int64_t my_integer;
     std::string my_string;
@@ -59,12 +28,9 @@ int main() {
     MyData const original {42, "Hello"};
 
     std::vector<unsigned char> data{};
-    msgpack23::pack(converting_insert_iterator{ std::back_inserter(data) }, original);
+    msgpack23::pack(std::back_inserter(data), original);
 
-    const auto [my_integer, my_string] = msgpack23::unpack<MyData>(std::span{
-        reinterpret_cast<std::byte *>(data.data()),
-        data.size()
-    });
+    const auto [my_integer, my_string] = msgpack23::unpack<unsigned char, MyData>(data);
 
     std::cout << my_integer << ' ' << my_string << '\n';
 }

include/msgpack23/msgpack23.h

@@ -503,9 +503,9 @@ namespace msgpack23 {
         std::span<B const> data_;
         std::size_t position_{0};
 
-        [[nodiscard]] B current() const {
+        [[nodiscard]] std::byte current() const {
             if (position_ < data_.size()) {
-                return data_[position_];
+                return std::byte{ data_[position_] };
             }
             throw std::out_of_range("Unpacker doesn't have enough data.");
         }
@@ -564,7 +564,7 @@ namespace msgpack23 {
             if (read_conditional<FormatConstants::map32, std::uint32_t>(map_size)
                 or read_conditional<FormatConstants::map16, std::uint16_t>(map_size)) {
             } else {
-                map_size = std::to_integer<std::size_t>(current() & static_cast<B>(0b00001111));
+                map_size = std::to_integer<std::size_t>(current() & static_cast<std::byte>(0b00001111));
                 increment();
             }
             return map_size;
@@ -575,7 +575,7 @@ namespace msgpack23 {
             if (read_conditional<FormatConstants::array32, std::uint32_t>(array_size)
                 or read_conditional<FormatConstants::array16, std::uint16_t>(array_size)) {
             } else {
-                array_size = std::to_integer<std::size_t>(current() & static_cast<B>(0b00001111));
+                array_size = std::to_integer<std::size_t>(current() & static_cast<std::byte>(0b00001111));
                 increment();
             }
             return array_size;
@@ -977,7 +977,7 @@ namespace msgpack23 {
                 or read_conditional<FormatConstants::str16, std::uint16_t>(str_size)
                 or read_conditional<FormatConstants::str8, std::uint8_t>(str_size)) {
             } else {
-                str_size = std::to_integer<std::size_t>(current() & static_cast<B>(0b00011111));
+                str_size = std::to_integer<std::size_t>(current() & static_cast<std::byte>(0b00011111));
                 increment();
             }
             if (position_ + str_size > data_.size()) {
@@ -1015,10 +1015,10 @@ namespace msgpack23 {
     template<container Container>
 	Unpacker(Container const&)->Unpacker<typename Container::value_type>;
 
-    template<typename T, typename B>
-    concept unpackable_object = requires(T t, Unpacker<B> u)
+    template<typename T, typename U>
+    concept unpackable_object = requires(T t, U u)
     {
-        { t.unpack(u) };
+        t.unpack(u);
     };
 
     template<byte_type B, std::output_iterator<B> Iter, packable_object<Packer<B, Iter> > PackableObject>

tests/exception_tests.cpp

@@ -58,7 +58,7 @@ namespace {
         constexpr double expected{3.1415};
         packer(expected);
         std::nullptr_t actual;
-        msgpack23::Unpacker unpacker{};
+        msgpack23::Unpacker<std::byte> unpacker{};
         EXPECT_THROW(unpacker(actual), std::logic_error);
     }
 
@@ -69,7 +69,7 @@ namespace {
         constexpr double expected{3.1415};
         packer(expected);
         bool actual;
-        msgpack23::Unpacker unpacker{};
+        msgpack23::Unpacker<std::byte> unpacker{};
         EXPECT_THROW(unpacker(actual), std::logic_error);
     }
 

tests/int16_tests.cpp

@@ -31,7 +31,7 @@ namespace {
         std::vector<std::byte> data{};
         auto const inserter = std::back_insert_iterator(data);
         msgpack23::pack(inserter, testIntStruct);
-        auto [actual] = msgpack23::unpack<Int16Struct>(data);
+        auto [actual] = msgpack23::unpack<std::byte, Int16Struct>(data);
         EXPECT_EQ(actual, GetParam());
     }
 

tests/int32_tests.cpp

@@ -31,7 +31,7 @@ namespace {
         std::vector<std::byte> data{};
         auto const inserter = std::back_insert_iterator(data);
         msgpack23::pack(inserter, testIntStruct);
-        auto [actual] = msgpack23::unpack<Int32Struct>(data);
+        auto [actual] = msgpack23::unpack<std::byte, Int32Struct>(data);
         EXPECT_EQ(actual, GetParam());
     }
 

tests/int64_tests.cpp

@@ -31,7 +31,7 @@ namespace {
         std::vector<std::byte> data{};
         auto const inserter = std::back_insert_iterator(data);
         msgpack23::pack(inserter, testIntStruct);
-        auto [actual] = msgpack23::unpack<Int64Struct>(data);
+        auto [actual] = msgpack23::unpack<std::byte, Int64Struct>(data);
         EXPECT_EQ(actual, GetParam());
     }
 

tests/int8_tests.cpp

@@ -31,7 +31,7 @@ namespace {
         std::vector<std::byte> data{};
         auto const inserter = std::back_insert_iterator(data);
         msgpack23::pack(inserter, testIntStruct);
-        auto [actual] = msgpack23::unpack<Int8Struct>(data);
+        auto [actual] = msgpack23::unpack<std::byte, Int8Struct>(data);
         EXPECT_EQ(actual, GetParam());
     }
 

tests/object_packing_tests.cpp

@@ -81,7 +81,7 @@ namespace {
         std::vector<std::byte> data{};
         auto inserter = std::back_insert_iterator(data);
         msgpack23::pack(inserter, test);
-        auto obj = msgpack23::unpack<TestStruct>(data);
+        auto const obj = msgpack23::unpack<std::byte, TestStruct>(data);
 
         EXPECT_EQ(obj.int64, test.int64);
         EXPECT_EQ(obj.uint32, test.uint32);
@@ -117,6 +117,6 @@ namespace {
         std::vector<std::byte> data{};
         auto const inserter = std::back_insert_iterator(data);
         msgpack23::pack(inserter, my_data);
-        auto obj = msgpack23::unpack<MyData>(data);
+        auto obj = msgpack23::unpack<std::byte, MyData>(data);
     }
 }

tests/uint16_tests.cpp

@@ -30,7 +30,7 @@ namespace {
         std::vector<std::byte> data{};
         auto const inserter = std::back_insert_iterator(data);
         msgpack23::pack(inserter, testIntStruct);
-        auto [uint16] = msgpack23::unpack<UInt16Struct>(data);
+        auto [uint16] = msgpack23::unpack<std::byte, UInt16Struct>(data);
         EXPECT_EQ(uint16, GetParam());
     }
 

tests/uint32_tests.cpp

@@ -30,7 +30,7 @@ namespace {
         std::vector<std::byte> data{};
         auto const inserter = std::back_insert_iterator(data);
         msgpack23::pack(inserter, testIntStruct);
-        auto [int32] = msgpack23::unpack<UInt32Struct>(data);
+        auto [int32] = msgpack23::unpack<std::byte, UInt32Struct>(data);
         EXPECT_EQ(int32, GetParam());
     }