Added support for bytestrings

Author: liuzicheng1987

include/rfl/cereal/Reader.hpp

@@ -9,7 +9,9 @@
 #include <string>
 #include <type_traits>
 
+#include "../Bytestring.hpp"
 #include "../Result.hpp"
+#include "../Vectorstring.hpp"
 #include "../always_false.hpp"
 #include "../internal/is_literal.hpp"
 #include "../parsing/schemaful/IsSchemafulReader.hpp"
@@ -58,6 +60,17 @@ struct Reader {
         std::string str;
         (*_var.archive_)(str);
         return std::remove_cvref_t<T>::from_string(str);
+
+      } else if constexpr (std::is_same<std::remove_cvref_t<T>,
+                                        rfl::Bytestring>() ||
+                           std::is_same<std::remove_cvref_t<T>,
+                                        rfl::Vectorstring>()) {
+        size_t size;
+        (*_var.archive_)(::cereal::make_size_tag(size));
+        std::remove_cvref_t<T> result(size);
+        (*_var.archive_)(::cereal::binary_data(result.data(), size));
+        return result;
+
       } else {
         T value;
         (*_var.archive_)(value);

include/rfl/cereal/Writer.hpp

@@ -9,6 +9,8 @@
 #include <string_view>
 #include <type_traits>
 
+#include "../Bytestring.hpp"
+#include "../Vectorstring.hpp"
 #include "../always_false.hpp"
 #include "../common.hpp"
 #include "../internal/is_literal.hpp"
@@ -232,6 +234,12 @@ class Writer {
     using Type = std::remove_cvref_t<T>;
     if constexpr (internal::is_literal_v<Type>) {
       add_value(_var.str());
+
+    } else if constexpr (std::is_same<Type, rfl::Bytestring>() ||
+                         std::is_same<Type, rfl::Vectorstring>()) {
+      (*archive_)(::cereal::make_size_tag(_var.size()));
+      (*archive_)(::cereal::binary_data(_var.data(), _var.size()));
+
     } else {
       (*archive_)(_var);
     }

tests/cereal/test_bytestring.cpp

@@ -9,10 +9,10 @@ struct TestStruct {
 };
 
 TEST(cereal, test_bytestring) {
-  /*const auto test =
+  const auto test =
       TestStruct{.bytestring = rfl::Bytestring({std::byte{13}, std::byte{14},
                                                 std::byte{15}, std::byte{16}})};
 
-  write_and_read(test);*/
+  write_and_read(test);
 }
 }  // namespace test_bytestring

tests/cereal/test_literal.cpp

@@ -17,8 +17,8 @@ struct Person {
 };
 
 TEST(cereal, test_literal) {
-  /*const auto bart = Person{.first_name = FirstName::make<"Bart">()};
+  const auto bart = Person{.first_name = FirstName::make<"Bart">()};
 
-  write_and_read(bart);*/
+  write_and_read(bart);
 }
 }  // namespace test_literal

tests/cereal/test_monster_example.cpp

@@ -36,7 +36,7 @@ struct Monster {
 };
 
 TEST(cereal, test_monster_example) {
-  /*const auto sword = Weapon{.name = "Sword", .damage = 3};
+  const auto sword = Weapon{.name = "Sword", .damage = 3};
   const auto axe = Weapon{.name = "Axe", .damage = 5};
 
   const auto weapons = std::vector<Weapon>({sword, axe});
@@ -54,6 +54,6 @@ TEST(cereal, test_monster_example) {
                            .weapons = weapons,
                            .equipped = rfl::make_field<"weapon">(axe)};
 
-  write_and_read(orc);*/
+  write_and_read(orc);
 }
 }  // namespace test_monster_example

tests/cereal/write_and_read.hpp

@@ -4,7 +4,6 @@
 #include <gtest/gtest.h>
 
 #include <rfl/cereal.hpp>
-#include <rfl/json.hpp>
 
 template <class... Ps>
 void write_and_read(const auto& _struct) {
@@ -15,7 +14,5 @@ void write_and_read(const auto& _struct) {
                            << res.error().what();
   const auto serialized2 = rfl::cereal::write<Ps...>(res.value());
   EXPECT_EQ(serialized1, serialized2);
-  EXPECT_EQ(rfl::json::write<Ps...>(_struct),
-            rfl::json::write<Ps...>(res.value()));
 }
 #endif