- Added support for custom structs using Boost.Describe

pfeatherstone · pfeatherstone · commit 236b8549889c · 2024-10-13T19:30:10.000+01:00
- Added "sinks"
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -5,19 +5,29 @@ project(Msgpack)
 include(FetchContent)
 include(ExternalProject)
 
-# set(MSGPACK_NO_BOOST ON)
+set(BOOST_INCLUDE_LIBRARIES describe)
+set(BOOST_ENABLE_CMAKE ON)
+FetchContent_Declare(
+  Boost
+  URL "https://github.com/boostorg/boost/releases/download/boost-1.86.0/boost-1.86.0-cmake.tar.xz"
+  URL_HASH MD5=d02759931cedc02aded80402906c5eb6
+  DOWNLOAD_EXTRACT_TIMESTAMP true
+)
+
 set(MSGPACK_USE_BOOST OFF CACHE INTERNAL "Disabling boost in msgpack library")
 FetchContent_Declare(
   msgpack
   GIT_REPOSITORY https://github.com/msgpack/msgpack-c.git
   GIT_TAG        cpp_master
 )
+
 FetchContent_Declare(
     doctest
   GIT_REPOSITORY https://github.com/doctest/doctest.git
   GIT_TAG        v2.4.11
 )
-FetchContent_MakeAvailable(msgpack doctest)
+
+FetchContent_MakeAvailable(Boost msgpack doctest)
 
 # Unit test
 add_executable(Test test.cpp)
diff --git a/msgpack.h b/msgpack.h
@@ -6,6 +6,8 @@
 #include <type_traits>
 #include <string_view>
 #include <vector>
+#include <map>
+#include <unordered_map>
 #include <endian.h>
 
 namespace msgpackcpp
@@ -35,35 +37,67 @@ namespace msgpackcpp
     }
 
     template<class Stream>
-    inline void serialize(Stream&& out, int8_t v)
+    inline void serialize(Stream&& out, uint16_t v)
     {
-        if (v < -(1<<5))
+        if (v <= std::numeric_limits<uint8_t>::max())
         {
-            // signed 8
-            constexpr uint8_t format = 0xd0;
+            serialize(std::forward<Stream>(out), (uint8_t)v);
+        }
+        else
+        {
+            constexpr uint8_t format = 0xcd;
+            v = htobe16(v);
             out((const char*)&format, 1);
-            out((const char*)&v, 1);
+            out((const char*)&v, 2);
+        }
+    }
+
+    template<class Stream>
+    inline void serialize(Stream&& out, uint32_t v)
+    {
+        if (v <= std::numeric_limits<uint16_t>::max())
+        {
+            serialize(std::forward<Stream>(out), (uint16_t)v);
         }
         else
         {
-            // negative fixing (5-bit negative integer)
-            out((const char*)&v, 1);
+            constexpr uint8_t format = 0xce;
+            out((const char*)&format, 1);
+            v = htobe32(v);
+            out((const char*)&v, 4);
         }
     }
 
     template<class Stream>
-    inline void serialize(Stream&& out, uint16_t v)
+    inline void serialize(Stream&& out, uint64_t v)
     {
-        if (v <= std::numeric_limits<uint8_t>::max())
+        if (v <= std::numeric_limits<uint32_t>::max())
         {
-            serialize(std::forward<Stream>(out), (uint8_t)v);
+            serialize(std::forward<Stream>(out), (uint32_t)v);
         }
         else
         {
-            constexpr uint8_t format = 0xcd;;
+            constexpr uint8_t format = 0xcf;
             out((const char*)&format, 1);
-            v = htobe16(v);
-            out((const char*)&v, 2);
+            v = htobe64(v);
+            out((const char*)&v, 8);
+        }
+    }
+
+    template<class Stream>
+    inline void serialize(Stream&& out, int8_t v)
+    {
+        if (v < -(1<<5))
+        {
+            // signed 8
+            constexpr uint8_t format = 0xd0;
+            out((const char*)&format, 1);
+            out((const char*)&v, 1);
+        }
+        else
+        {
+            // negative fixing (5-bit negative integer)
+            out((const char*)&v, 1);
         }
     }
 
@@ -94,22 +128,6 @@ namespace msgpackcpp
         }
     }
 
-    template<class Stream>
-    inline void serialize(Stream&& out, uint32_t v)
-    {
-        if (v <= std::numeric_limits<uint16_t>::max())
-        {
-            serialize(std::forward<Stream>(out), (uint16_t)v);
-        }
-        else
-        {
-            constexpr uint8_t format = 0xce;
-            out((const char*)&format, 1);
-            v = htobe32(v);
-            out((const char*)&v, 4);
-        }
-    }
-
     template<class Stream>
     inline void serialize(Stream&& out, int32_t v)
     {
@@ -137,22 +155,6 @@ namespace msgpackcpp
         }
     }
 
-    template<class Stream>
-    inline void serialize(Stream&& out, uint64_t v)
-    {
-        if (v <= std::numeric_limits<uint32_t>::max())
-        {
-            serialize(std::forward<Stream>(out), (uint32_t)v);
-        }
-        else
-        {
-            constexpr uint8_t format = 0xcf;
-            out((const char*)&format, 1);
-            v = htobe64(v);
-            out((const char*)&v, 8);
-        }
-    }
-
     template<class Stream>
     inline void serialize(Stream&& out, int64_t v)
     {
@@ -304,4 +306,65 @@ namespace msgpackcpp
         for (const auto& x : v)
             serialize(std::forward<Stream>(out), x);
     }
+
+    template<class Stream>
+    inline void serialize_map_size(Stream&& out, uint32_t size)
+    {
+        if (size < 16)
+        {
+            const uint8_t format = 0x80 | static_cast<uint8_t>(size);
+            out((const char*)&format, 1);
+        }
+        else if (size < 65536)
+        {
+            const uint8_t  format = 0xde;
+            const uint16_t size16 = htobe16(static_cast<uint16_t>(size));
+            out((const char*)&format, 1);
+            out((const char*)&size16, 2);
+        }
+        else 
+        {
+            const uint8_t  format = 0xdf;
+            const uint32_t size32 = htobe32(static_cast<uint32_t>(size));
+            out((const char*)&format, 1);
+            out((const char*)&size32, 4);
+        }
+    }
+
+    template <
+        class Stream, 
+        class K, 
+        class V, 
+        class Compare = std::less<K>,
+        class Alloc = std::allocator<std::pair<const K, V>>
+    >
+    inline void serialize(Stream&& out, const std::map<K,V,Compare,Alloc>& map)
+    {
+        serialize_map_size(std::forward<Stream>(out), map.size());
+        
+        for (const auto& [k,v] : map)
+        {
+            serialize(std::forward<Stream>(out), k);
+            serialize(std::forward<Stream>(out), v);
+        }
+    }
+
+    template <
+        class Stream, 
+        class K,
+        class V,
+        class Hash      = std::hash<K>,
+        class KeyEqual  = std::equal_to<K>,
+        class Alloc     = std::allocator<std::pair<const K, V>>
+    >
+    inline void serialize(Stream&& out, const std::unordered_map<K,V,Hash,KeyEqual,Alloc>& map)
+    {
+        serialize_map_size(std::forward<Stream>(out), map.size());
+        
+        for (const auto& [k,v] : map)
+        {
+            serialize(std::forward<Stream>(out), k);
+            serialize(std::forward<Stream>(out), v);
+        }
+    }
 }
diff --git a/msgpack_describe.h b/msgpack_describe.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <boost/describe/members.hpp>
+#include "msgpack.h"
+
+namespace msgpackcpp
+{
+    template <
+        class Stream, 
+        class T,
+        class D = boost::describe::describe_members<T, boost::describe::mod_any_access>
+    >
+    inline void serialize(Stream&& out, const T& obj, bool as_map = false)
+    { 
+        if (as_map)
+        {
+            serialize_map_size(std::forward<Stream>(out), boost::mp11::mp_size<D>::value);
+
+            boost::mp11::mp_for_each<D>([&](auto D) {
+                serialize(std::forward<Stream>(out), D.name);
+                serialize(std::forward<Stream>(out), obj.*D.pointer)
+            });
+        }
+        else
+        {
+            serialize_array_size(std::forward<Stream>(out), boost::mp11::mp_size<D>::value);
+
+            boost::mp11::mp_for_each<D>([&](auto D) {
+                serialize(std::forward<Stream>(out), obj.*D.pointer)
+            });
+        }
+    }
+}
diff --git a/msgpack_sinks.h b/msgpack_sinks.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <vector>
+#include <ostream>
+
+namespace msgpackcpp
+{
+    template<class Byte, class Alloc, std::enable_if_t<sizeof(Byte) == 1, bool> = true>
+    auto sink(std::vector<Byte, Alloc>& buf)
+    {
+        return [&](const char* bytes, size_t nbytes) {
+            buf.insert(end(buf), bytes, bytes + nbytes);
+        };
+    } 
+
+    inline auto sink(std::ostream& out)
+    {
+        return [&](const char* bytes, size_t nbytes) {
+            out.write(bytes, nbytes);
+        };
+    }
+}
diff --git a/test.cpp b/test.cpp
@@ -7,6 +7,7 @@
 #include <msgpack.hpp>
 #include <doctest.h>
 #include "msgpack.h"
+#include "msgpack_sinks.h"
 
 template<class Byte, class Allocator>
 struct vector_sink
@@ -88,17 +89,17 @@ TEST_SUITE("[MSGPACK]")
 
             {
                 // using custom library
-                vector_sink sink{buf2};
-                msgpackcpp::serialize(sink, a);
-                msgpackcpp::serialize(sink, b);
-                msgpackcpp::serialize(sink, c);
-                msgpackcpp::serialize(sink, d);
-                msgpackcpp::serialize(sink, e);
-                msgpackcpp::serialize(sink, f);
-                msgpackcpp::serialize(sink, g);
-                msgpackcpp::serialize(sink, h);
-                msgpackcpp::serialize(sink, i);
-                msgpackcpp::serialize(sink, j);
+                using namespace msgpackcpp;
+                serialize(sink(buf2), a);
+                serialize(sink(buf2), b);
+                serialize(sink(buf2), c);
+                serialize(sink(buf2), d);
+                serialize(sink(buf2), e);
+                serialize(sink(buf2), f);
+                serialize(sink(buf2), g);
+                serialize(sink(buf2), h);
+                serialize(sink(buf2), i);
+                serialize(sink(buf2), j);
             }
 
             REQUIRE(num_errors(buf1, buf2) == 0);
@@ -176,21 +177,21 @@ TEST_SUITE("[MSGPACK]")
 
         {
             // using custom library
-            vector_sink sink{buf2};
-            msgpackcpp::serialize(sink, k);
-            msgpackcpp::serialize(sink, l);
-            msgpackcpp::serialize(sink, m);
-            msgpackcpp::serialize(sink, n);
-            msgpackcpp::serialize(sink, o);
-            msgpackcpp::serialize(sink, p);
-            msgpackcpp::serialize(sink, q);
-            msgpackcpp::serialize(sink, r);
-            msgpackcpp::serialize(sink, s);
-            msgpackcpp::serialize(sink, t);
-            msgpackcpp::serialize(sink, u);
-            msgpackcpp::serialize(sink, v);
-            msgpackcpp::serialize(sink, w);
-            msgpackcpp::serialize(sink, x);
+            using namespace msgpackcpp;
+            serialize(sink(buf2), k);
+            serialize(sink(buf2), l);
+            serialize(sink(buf2), m);
+            serialize(sink(buf2), n);
+            serialize(sink(buf2), o);
+            serialize(sink(buf2), p);
+            serialize(sink(buf2), q);
+            serialize(sink(buf2), r);
+            serialize(sink(buf2), s);
+            serialize(sink(buf2), t);
+            serialize(sink(buf2), u);
+            serialize(sink(buf2), v);
+            serialize(sink(buf2), w);
+            serialize(sink(buf2), x);
         }
 
         REQUIRE(num_errors(buf1, buf2) == 0);
