Add message serialization and deserialization

.forgejo/workflows/pr_check.yaml

@@ -13,9 +13,9 @@ jobs:
           pacman -S --noconfirm cmake make gcc ninja meson
           pacman -S --noconfirm gtk4 gtkmm-4.0 boost spdlog fmt libxml++-5.0 gtest
 
-      - name: Setup environment - Install LLVM-19.1.3
+      - name: Setup environment - Install LLVM-19.1.5
         run: |
-          export LLVM_VER=19.1.3
+          export LLVM_VER=19.1.5
 
           echo "::group::Download LLVM-${LLVM_VER}"
           wget https://github.com/llvm/llvm-project/releases/download/llvmorg-${LLVM_VER}/LLVM-${LLVM_VER}-Linux-X64.tar.xz -O /LLVM-${LLVM_VER}-Linux-X64.tar.xz
@@ -108,7 +108,7 @@ jobs:
         id: clang_format_check
         continue-on-error: true
         run: |
-          export LLVM_VER=19.1.3
+          export LLVM_VER=19.1.5
           export PATH="/home/LLVM-${LLVM_VER}/bin:${PATH}"
           cd ${{ github.workspace }}
           export REPO_FILES=$(cat repo_files_to_check.txt)
@@ -148,7 +148,7 @@ jobs:
         id: clang_build
         continue-on-error: true
         run: |
-          export LLVM_VER=19.1.3
+          export LLVM_VER=19.1.5
           export PATH="/home/LLVM-${LLVM_VER}/bin:${PATH}"
           mkdir -p ${{ github.workspace }}/build_clang
 
@@ -172,7 +172,7 @@ jobs:
         id: clang_tidy
         continue-on-error: true
         run: |
-          export LLVM_VER=19.1.3
+          export LLVM_VER=19.1.5
           export PATH="/home/LLVM-${LLVM_VER}/bin:${PATH}"
           cd ${{ github.workspace }}
 
@@ -197,7 +197,7 @@ jobs:
       
       #- name: Clang unit tests with -fsanitize=address
       #  run: |
-      #    export LLVM_VER=19.1.3
+      #    export LLVM_VER=19.1.5
       #    export PATH="/home/LLVM-${LLVM_VER}/bin:${PATH}"
       #    cd ${{ github.workspace }}/build_clang
       #    ASAN_SYMBOLIZER_PATH=llvm-symbolizer ASAN_OPTIONS=detect_stack_use_after_return=1:check_initialization_order=1:detect_leaks=1:atexit=1:abort_on_error=1 ./larra_xmpp_tests

library/include/larra/message.hpp

@@ -0,0 +1,156 @@
+#pragma once
+#include <larra/serialization/auto.hpp>
+#include <larra/xml_language.hpp>
+#include <string>
+
+namespace larra::xmpp {
+
+namespace message {
+struct Body {
+  std::string content;
+  std::optional<XmlLanguage> language;
+  static constexpr auto kDefaultName = "body";
+  constexpr auto operator==(const Body& other) const -> bool = default;
+  friend constexpr auto operator<<(xmlpp::Element* node, const Body& message) -> void {
+    node->add_child_text(message.content);
+  }
+  static constexpr auto Parse(xmlpp::Element* node) -> Body {
+    auto ptr = node->get_first_child_text();
+    if(!ptr) {
+      throw std::runtime_error("Message::Body: [ Text node not found ]");
+    }
+    auto lang = node->get_attribute("lang", "xml");
+    return {
+        .content = ptr->get_content(),                                                          //
+        .language = lang ? std::optional{XmlLanguage::Parse(lang->get_value())} : std::nullopt  //
+    };
+  }
+};
+
+namespace type {
+
+struct Chat {
+  static constexpr auto TryParse(std::string_view value) -> std::optional<Chat> {
+    return value == "chat" ? std::optional{Chat{}} : std::nullopt;
+  }
+  friend constexpr auto ToString(const Chat&) -> std::string {
+    return "chat";
+  }
+  constexpr auto operator==(const Chat&) const -> bool {
+    return true;
+  };
+};
+
+static constexpr auto kChat = Chat{};
+
+struct Error {
+  static constexpr auto TryParse(std::string_view value) -> std::optional<Error> {
+    return value == "error" ? std::optional{Error{}} : std::nullopt;
+  }
+  friend constexpr auto ToString(const Error&) -> std::string {
+    return "error";
+  }
+  constexpr auto operator==(const Error&) const -> bool {
+    return true;
+  };
+};
+
+static constexpr auto kError = Error{};
+
+struct GroupChat {
+  static constexpr auto TryParse(std::string_view value) -> std::optional<GroupChat> {
+    return value == "groupchat" ? std::optional{GroupChat{}} : std::nullopt;
+  }
+  friend constexpr auto ToString(const GroupChat&) -> std::string {
+    return "groupchat";
+  }
+  constexpr auto operator==(const GroupChat&) const -> bool {
+    return true;
+  };
+};
+
+static constexpr auto kGroupChat = GroupChat{};
+
+struct Headline {
+  static constexpr auto TryParse(std::string_view value) -> std::optional<Headline> {
+    return value == "headline" ? std::optional{Headline{}} : std::nullopt;
+  }
+  friend constexpr auto ToString(const Headline&) -> std::string {
+    return "headline";
+  }
+  constexpr auto operator==(const Headline&) const -> bool {
+    return true;
+  };
+};
+
+static constexpr auto kHeadline = Headline{};
+
+struct Normal {
+  static constexpr auto Parse(std::string_view value) -> Normal {
+    return value == "normal" ? Normal{}
+                             : throw std::runtime_error(
+                                   std::format(R"(message::type::Normal Parsing error: [ expected "normal" but "{}" found ])", value));
+  }
+  friend constexpr auto ToString(const Normal&) -> std::string {
+    return "normal";
+  }
+  constexpr auto operator==(const Normal&) const -> bool {
+    return true;
+  };
+};
+
+static constexpr auto kNormal = Normal{};
+
+}  // namespace type
+
+using TypeVariant = std::variant<type::Chat, type::GroupChat, type::Headline, type::Error, type::Normal>;
+
+struct Type : TypeVariant {
+  using TypeVariant::variant;
+  constexpr Type(TypeVariant variant) : TypeVariant(std::move(variant)) {
+  }
+
+  static constexpr auto GetDefault() -> Type {
+    return type::kNormal;
+  }
+
+  friend constexpr auto ToString(const Type& value) -> std::string {
+    return std::visit(
+        [](const auto& value) {
+          return ToString(value);
+        },
+        value);
+  }
+};
+
+}  // namespace message
+
+template <typename From, typename To>
+struct Message {
+  static constexpr auto kDefaultName = "message";
+  static auto Parse(xmlpp::Element* element) -> Message {
+    return serialization::Parse<Message>(element);
+  }
+  friend auto operator<<(xmlpp::Element* element, const Message& message) -> void {
+    serialization::Serialize(element, message);
+  }
+  constexpr auto operator==(const Message& other) const -> bool = default;
+  From from;
+  To to;
+  message::Type type;
+  std::optional<std::string> id;
+  XmlLanguage language;
+  std::vector<message::Body> body;
+};
+
+template <typename From, typename To>
+struct serialization::SerializationConfigT<Message<From, To>> {
+  static constexpr auto kValue = serialization::SerializationConfig<Message<From, To>>{}  //
+                                     .template With<"type">(serialization::AttributeConfig{})
+                                     .template With<"body">(serialization::Config<std::vector<message::Body>>{});
+};
+
+template <typename Info>
+struct serialization::AttributeSerializer<message::Type, Info> : serialization::AttributeSerializer<message::TypeVariant, Info> {};
+
+}  // namespace larra::xmpp

library/include/larra/serialization/auto.hpp

@@ -4,7 +4,6 @@
 #include <boost/pfr.hpp>
 #include <larra/serialization.hpp>
 #include <larra/serialization/error.hpp>
-#include <ranges>
 #include <utempl/constexpr_string.hpp>
 #include <utempl/tuple.hpp>
 #include <utempl/utils.hpp>
@@ -16,10 +15,20 @@ template <typename T>
 struct Tag {};
 
 template <typename T>
-inline constexpr auto kSerializationConfig = std::monostate{};
+struct SerializationConfigT {
+  static constexpr auto kValue = std::monostate{};
+};
 
 template <typename T>
-inline constexpr auto kDeserializationConfig = kSerializationConfig<T>;
+inline constexpr auto kSerializationConfig = SerializationConfigT<T>::kValue;
+
+template <typename T>
+struct DeserializationConfigT {
+  static constexpr auto kValue = kSerializationConfig<T>;
+};
+
+template <typename T>
+inline constexpr auto kDeserializationConfig = DeserializationConfigT<T>::kValue;
 
 template <typename T>
 constexpr auto Parse(xmlpp::Element* element, Tag<T> = {}) -> T
@@ -55,10 +64,24 @@ struct MetaInfo {
   }
 };
 
+template <typename T>
+struct DefaultValue {};
+
+template <typename T>
+  requires requires {
+    { T::GetDefault() } -> std::convertible_to<T>;
+  }
+struct DefaultValue<T> {
+  static constexpr auto Default() {
+    return T::GetDefault();
+  }
+};
+
 template <typename MainT, std::size_t Element>
 struct FieldInfo {
   using Main = MainT;
   using Info = MetaInfo<Main>;
+  using Type = Info::template TupleElement<Element>;
   static inline const std::string kName = [] {
     if constexpr(requires { Info::template TupleElement<Element>::kDefaultName; }) {
       return Info::template TupleElement<Element>::kDefaultName;
@@ -66,6 +89,13 @@ struct FieldInfo {
       return static_cast<std::string>(Info::template kFieldName<Element>);
     }
   }();
+  static inline const std::string kNamespace = [] {
+    if constexpr(requires { Info::template TupleElement<Element>::kDefaultNamespace; }) {
+      return Info::template TupleElement<Element>::kDefaultNamespace;
+    } else {
+      return std::string{};
+    }
+  }();
 };
 
 template <typename T>
@@ -216,9 +246,16 @@ struct ElementSerializer<std::vector<T>, Config, Info> {
 template <typename T, typename Info>
 struct AttributeSerializer {
   static constexpr auto Parse(xmlpp::Element* element) -> T {
-    auto node = element->get_attribute(Info::kName);
+    auto node = element->get_attribute(Info::kName, Info::kNamespace);
     if(!node) {
-      throw AttributeParsingError(std::format("Attribute [{}: {}] parsing error", Info::kName, nameof::nameof_full_type<T>()));
+      if constexpr(requires { DefaultValue<T>::Default(); }) {
+        return DefaultValue<T>::Default();
+      }
+      throw AttributeParsingError(std::format("Attribute [{}{}{}: {}] parsing error",
+                                              Info::kNamespace,
+                                              Info::kNamespace == std::string{} ? "" : ":",
+                                              Info::kName,
+                                              nameof::nameof_full_type<T>()));
     }
     if constexpr(requires(std::string_view view) { T::Parse(view); }) {
       return T::Parse(node->get_value());
@@ -226,13 +263,26 @@ struct AttributeSerializer {
       return node->get_value();
     }
   }
+  static constexpr auto TryParse(xmlpp::Element* element) -> std::optional<T>
+    requires requires { T::TryParse(std::string_view{}); }
+  {
+    auto node = element->get_attribute(Info::kName, Info::kNamespace);
+    if(!node) {
+      throw AttributeParsingError(std::format("Attribute [{}{}{}: {}] parsing error",
+                                              Info::kNamespace,
+                                              Info::kNamespace == std::string{} ? "" : ":",
+                                              Info::kName,
+                                              nameof::nameof_full_type<T>()));
+    }
+    return T::TryParse(node->get_value());
+  }
   static constexpr auto Serialize(xmlpp::Element* element, const T& obj) {
     if constexpr(requires {
                    { ToString(obj) } -> std::convertible_to<const std::string&>;
                  }) {
-      element->set_attribute(Info::kName, ToString(obj));
+      element->set_attribute(Info::kName, ToString(obj), Info::kNamespace);
     } else {
-      element->set_attribute(Info::kName, obj);
+      element->set_attribute(Info::kName, obj, Info::kNamespace);
     }
   }
 };
@@ -240,8 +290,13 @@ struct AttributeSerializer {
 template <typename T, typename Info>
 struct AttributeSerializer<std::optional<T>, Info> {
   static constexpr auto Parse(xmlpp::Element* element) -> std::optional<T> {
-    auto node = element->get_attribute(Info::kName);
+    auto node = element->get_attribute(Info::kName, Info::kNamespace);
-    return node ? std::optional{AttributeSerializer<T, Info>::Parse(element)} : std::nullopt;
+    return node ? std::optional{AttributeSerializer<T, Info>::Parse(element)} : [] -> std::optional<T> {
+      if constexpr(requires { DefaultValue<T>::Default(); }) {
+        return DefaultValue<T>::Default();
+      }
+      return std::nullopt;
+    }();
   }
   static constexpr auto Serialize(xmlpp::Element* element, const std::optional<T>& obj) {
     if(obj) {
@@ -250,6 +305,52 @@ struct AttributeSerializer<std::optional<T>, Info> {
   }
 };
 
+template <typename... Ts, typename Info>
+struct AttributeSerializer<std::variant<Ts...>, Info> {
+  template <typename T>
+  static constexpr auto FunctionForType(xmlpp::Element* element) {
+    return [=] -> std::optional<T> {
+      if constexpr(requires { AttributeSerializer<T, Info>::TryParse(element); }) {
+        return AttributeSerializer<T, Info>::TryParse(element);
+      } else {
+        try {
+          return AttributeSerializer<T, Info>::Parse(element);
+        } catch(...) {
+          return std::nullopt;
+        }
+      }
+    };
+  }
+  static constexpr auto Parse(xmlpp::Element* element) -> std::variant<Ts...> {
+    using T = Info::Type;
+    auto node = element->get_attribute(Info::kName, Info::kNamespace);
+    if(!node) {
+      if constexpr(requires { DefaultValue<T>::Default(); }) {
+        return DefaultValue<T>::Default();
+      }
+      throw AttributeParsingError(std::format("Attribute [{}{}{}: {}] parsing error",
+                                              Info::kNamespace,
+                                              Info::kNamespace == std::string{} ? "" : ":",
+                                              Info::kName,
+                                              nameof::nameof_full_type<T>()));
+    }
+    return [&]<typename... TTs>(utempl::TypeList<TTs...>) {
+      // operator* is safe because in or_else Parse returns Ts...[sizeof...(Ts) - 1] (not optional)
+      return *utempl::FirstOf(utempl::Tuple{FunctionForType<TTs>(element)...}, std::optional<std::variant<Ts...>>{})
+                  .or_else([&] -> std::optional<std::variant<Ts...>> {
+                    return AttributeSerializer<decltype(utempl::Get<sizeof...(Ts) - 1>(utempl::kTypeList<Ts...>)), Info>::Parse(element);
+                  });
+    }(utempl::TakeFrom<sizeof...(Ts) - 1>(utempl::kTypeList<Ts...>));
+  }
+  static constexpr auto Serialize(xmlpp::Element* element, const std::variant<Ts...>& obj) {
+    std::visit(
+        [&]<typename T>(const T& value) {
+          AttributeSerializer<T, Info>::Serialize(element, value);
+        },
+        obj);
+  }
+};
+
 namespace impl {
 
 template <typename T>

library/include/larra/xml_language.hpp

@@ -0,0 +1,19 @@
+#pragma once
+#include <string>
+namespace larra::xmpp {
+
+struct XmlLanguage : std::string {
+  static constexpr auto kDefaultName = "lang";
+  static constexpr auto kDefaultNamespace = "xml";
+  using std::string::basic_string;
+  constexpr XmlLanguage(std::string str) : std::string(std::move(str)) {
+  }
+  static constexpr auto Parse(std::string_view view) -> XmlLanguage {
+    return static_cast<std::string>(view);
+  }
+  friend constexpr auto ToString(XmlLanguage value) -> std::string {
+    return std::move(static_cast<std::string&>(value));
+  }
+};
+
+}  // namespace larra::xmpp

tests/message.cpp

@@ -0,0 +1,51 @@
+#include <gtest/gtest.h>
+
+#include <larra/jid.hpp>
+#include <larra/message.hpp>
+
+namespace larra::xmpp {
+
+namespace {
+
+auto CreateTestData() {
+  auto doc = std::make_unique<xmlpp::Document>();
+  auto node = doc->create_root_node("message");
+  node->set_attribute("from", "user1@server.i2p");
+  node->set_attribute("to", "user2@server.i2p");
+  node->set_attribute("type", "chat");
+  node->set_attribute("id", "1");
+  node->set_attribute("lang", "en", "xml");
+
+  auto bodyNode = node->add_child_element("body");
+  bodyNode->add_child_text("hello");
+  return doc;
+}
+
+const Message<BareJid, BareJid> kMessage{
+    .from = {.username = "user1", .server = "server.i2p"},
+    .to = {.username = "user2", .server = "server.i2p"},
+    .type = message::type::kChat,
+    .id = "1",
+    .language = "en",
+    .body = {message::Body{.content = "hello"}}  //
+};
+
+}  // namespace
+
+TEST(Parse, Message) {
+  auto doc = CreateTestData();
+  auto node = doc->get_root_node();
+  auto message = Serialization<Message<BareJid, BareJid>>::Parse(node);
+
+  EXPECT_EQ(message, kMessage);
+}
+
+TEST(Serialize, Message) {
+  auto expected = CreateTestData()->write_to_string();
+  xmlpp::Document doc;
+  auto node = doc.create_root_node("message");
+  Serialization<Message<BareJid, BareJid>>::Serialize(node, kMessage);
+  EXPECT_EQ(doc.write_to_string(), expected);
+}
+
+}  // namespace larra::xmpp

tests/roster.cpp

@@ -28,7 +28,7 @@ TEST(Roster, Print) {
 
   EXPECT_NO_THROW({
     auto rosterStr = ToString(roster.payload);
-    EXPECT_EQ(kRosterPrintExpectedData.length(), rosterStr.capacity());
+    EXPECT_EQ(kRosterPrintExpectedData.length(), rosterStr.length());
     EXPECT_EQ(kRosterPrintExpectedData, rosterStr);
   });
 }

tests/xml_lang.cpp

@@ -0,0 +1,42 @@
+#include <gtest/gtest.h>
+
+#include <larra/serialization/auto.hpp>
+#include <larra/xml_language.hpp>
+
+namespace larra::xmpp {
+
+namespace tests::message {
+
+struct SomeStruct {
+  static constexpr auto kDefaultName = "some";
+  XmlLanguage language;
+  friend auto operator<<(xmlpp::Element*, const SomeStruct&) -> void;
+  static auto Parse(xmlpp::Element* node) -> SomeStruct;
+};
+
+}  // namespace tests::message
+template <>
+constexpr auto serialization::kSerializationConfig<tests::message::SomeStruct> =
+    serialization::SerializationConfig<tests::message::SomeStruct>{};
+
+namespace tests::message {
+
+auto SomeStruct::Parse(xmlpp::Element* element) -> SomeStruct {
+  return serialization::Parse<SomeStruct>(element);
+}
+
+auto operator<<(xmlpp::Element* element, const SomeStruct& some) -> void {
+  serialization::Serialize(element, some);
+};
+
+}  // namespace tests::message
+
+TEST(Parse, XmlLanguage) {
+  xmlpp::Document doc;
+  auto node = doc.create_root_node("some");
+  node->set_attribute("lang", "en", "xml");
+  auto value = Serialization<tests::message::SomeStruct>::Parse(node);
+  EXPECT_EQ(value.language, "en");
+}
+
+}  // namespace larra::xmpp