Serialize/Deserialize vector<char> as bytestring

include/rfl/Bytestring.hpp

@@ -7,6 +7,7 @@
 namespace rfl {
 
 using Bytestring = std::vector<std::byte>;
+using Vectorstring = std::vector<char>;
 
 }  // namespace rfl
 

include/rfl/bson/Reader.hpp

@@ -125,6 +125,20 @@ struct Reader {
           internal::ptr_cast<const std::byte*>(value.v_binary.data);
       return rfl::Bytestring(data, data + value.v_binary.data_len);
 
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>,
+                                      rfl::Vectorstring>()) {
+      if (btype != BSON_TYPE_BINARY) {
+        return error("Could not cast to vectorstring.");
+      }
+      if (value.v_binary.subtype != BSON_SUBTYPE_BINARY) {
+        return error(
+            "The BSON subtype must be a binary in order to read into a "
+            "vectorstring.");
+      }
+      const auto data =
+          internal::ptr_cast<const char*>(value.v_binary.data);
+      return rfl::Vectorstring(data, data + value.v_binary.data_len);
+
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
       if (btype != BSON_TYPE_BOOL) {
         return error("Could not cast to boolean.");

include/rfl/bson/Writer.hpp

@@ -101,7 +101,9 @@ class Writer {
       bson_array_builder_append_utf8(_parent->val_, _var.c_str(),
                                      static_cast<int>(_var.size()));
     } else if constexpr (std::is_same<std::remove_cvref_t<T>,
-                                      rfl::Bytestring>()) {
+                                      rfl::Bytestring>() ||
+                         std::is_same<std::remove_cvref_t<T>,
+                                      rfl::Vectorstring>()) {
       bson_array_builder_append_binary(
           _parent->val_, BSON_SUBTYPE_BINARY,
           internal::ptr_cast<const uint8_t*>(_var.data()),

include/rfl/cbor/Reader.hpp

@@ -81,6 +81,15 @@
       const auto data = internal::ptr_cast<const std::byte*>(vec.data());
       return rfl::Bytestring(data, data + vec.size());
 
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>,
+                                      rfl::Vectorstring()) {
+      if (!_var.val_->is_byte_string()) {
+        return error("Could not cast to vectorstring.");
+      }
+      const auto vec = _var.val_->as<std::vector<uint8_t>>();
+      const auto data = internal::ptr_cast<const char*>(vec.data());
+      return rfl::Vectorstring(data, data + vec.size());
+
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
       if (!_var.val_->is_bool()) {
         return error("Could not cast to boolean.");

include/rfl/cbor/Writer.hpp

@@ -97,7 +97,9 @@ class Writer {
     if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
       encoder_->string_value(_var);
     } else if constexpr (std::is_same<std::remove_cvref_t<T>,
-                                      rfl::Bytestring>()) {
+                                      rfl::Bytestring>() ||
+                         std::is_same<std::remove_cvref_t<T>,
+                                      rfl::Vectorstring>()) {
       encoder_->byte_string_value(_var);
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
       encoder_->bool_value(_var);

include/rfl/msgpack/Reader.hpp

@@ -74,6 +74,15 @@ struct Reader {
       const auto data = internal::ptr_cast<const std::byte*>(bin.ptr);
       return rfl::Bytestring(data, data + bin.size);
 
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>,
+                                      rfl::Vectorstring>()) {
+      if (type != MSGPACK_OBJECT_BIN) {
+        return error("Could not cast to a vectorstring.");
+      }
+      const auto bin = _var.via.bin;
+      const auto data = internal::ptr_cast<const char*>(bin.ptr);
+      return rfl::Vectorstring(data, data + bin.size);
+
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
       if (type != MSGPACK_OBJECT_BOOLEAN) {
         return error("Could not cast to boolean.");

include/rfl/msgpack/Writer.hpp

@@ -97,7 +97,7 @@ class Writer {
     if constexpr (std::is_same<Type, std::string>()) {
       msgpack_pack_str(pk_, _var.size());
       msgpack_pack_str_body(pk_, _var.c_str(), _var.size());
-    } else if constexpr (std::is_same<Type, rfl::Bytestring>()) {
+    } else if constexpr (std::is_same<Type, rfl::Bytestring>() || std::is_same<Type, rfl::Vectorstring>()) {
       msgpack_pack_bin(pk_, _var.size());
       msgpack_pack_bin_body(pk_, _var.data(), _var.size());
     } else if constexpr (std::is_same<Type, bool>()) {

include/rfl/ubjson/Reader.hpp

@@ -81,6 +81,15 @@ class Reader {
       const auto data = internal::ptr_cast<const std::byte*>(vec.data());
       return rfl::Bytestring(data, data + vec.size());
 
+    } else if constexpr (std::is_same<std::remove_cvref_t<T>,
+                                      rfl::Vectorstring>()) {
+      if (!_var.val_->is<std::vector<uint8_t>>()) {
+        return error("Could not cast to vectorstring.");
+      }
+      const auto vec = _var.val_->as<std::vector<uint8_t>>();
+      const auto data = internal::ptr_cast<const char*>(vec.data());
+      return rfl::Vectorstring(data, data + vec.size());
+
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
       if (!_var.val_->is_bool()) {
         return error("Could not cast to boolean.");

include/rfl/ubjson/Writer.hpp

@@ -97,7 +97,9 @@ class Writer {
     if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
       encoder_->string_value(_var);
     } else if constexpr (std::is_same<std::remove_cvref_t<T>,
-                                      rfl::Bytestring>()) {
+                                      rfl::Bytestring>() ||
+                         std::is_same<std::remove_cvref_t<T>,
+                                      rfl::Vectorstring>()) {
       encoder_->byte_string_value(_var);
     } else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
       encoder_->bool_value(_var);

tests/bson/test_vectorstring.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+#include <rfl.hpp>
+#include <string>
+#include <vector>
+
+#include "write_and_read.hpp"
+
+namespace test_vectorstring {
+
+struct TestStruct {
+  rfl::Vectorstring vectorstring;
+  std::vector<rfl::Vectorstring> vectorstrings;
+};
+
+TEST(bson, test_vectorstring) {
+  const auto vstr = rfl::Vectorstring(
+      {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'});
+  const auto test = TestStruct{
+      .vectorstring = vstr,
+      .vectorstrings = std::vector<rfl::Vectorstring>({vstr, vstr, vstr})};
+  write_and_read(test);
+}
+}  // namespace test_vectorstring

tests/cbor/test_vectorstring.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <rfl.hpp>
+#include <string>
+#include <vector>
+
+#include "write_and_read.hpp"
+
+namespace test_vectorstring {
+
+struct TestStruct {
+  rfl::Vectorstring vectorstring;
+};
+
+TEST(cbor, test_vectorstring) {
+  const auto test = TestStruct{
+      .vectorstring = rfl::Vectorstring({'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'})};
+
+  write_and_read(test);
+}
+}  // namespace test_vectorstring

tests/msgpack/test_vectorstring.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <rfl.hpp>
+#include <string>
+#include <vector>
+
+#include "write_and_read.hpp"
+
+namespace test_vectorstring {
+
+struct TestStruct {
+  rfl::Vectorstring vectorstring;
+};
+
+TEST(msgpack, test_vectorstring) {
+  const auto test =
+      TestStruct{.vectorstring = rfl::Vectorstring({'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'})};
+
+  write_and_read(test);
+}
+}  // namespace test_vectorstring

tests/ubjson/test_vectorstring.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <rfl.hpp>
+#include <string>
+#include <vector>
+
+#include "write_and_read.hpp"
+
+namespace test_vectorstring {
+
+struct TestStruct {
+  rfl::Vectorstring vectorstring;
+};
+
+TEST(ubjson, test_vectorstring) {
+  const auto test =
+      TestStruct{.vectorstring = rfl::Vectorstring({'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'})};
+
+  write_and_read(test);
+}
+}  // namespace test_vectorstring