xml: raw nodes

Author: Tsche

include/rsl/serializer/annotations.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+namespace rsl::annotations::inline serializer {
+struct Skip {};
+constexpr inline Skip skip{};
+};  // namespace rsl::annotations::inline serializer

include/rsl/serializer/machinery.hpp

@@ -1,7 +1,9 @@
 #pragma once
 #include <meta>
 #include <ranges>
+#include <rsl/meta_traits>
 #include "util.hpp"
+#include "annotations.hpp"
 
 namespace rsl::serializer {
 
@@ -64,13 +66,16 @@ struct Meta<T> {
   void descend(F&& visitor, U&& value) {
     template for (constexpr auto Idx : std::views::iota(0ZU, members.size())) {
       constexpr auto M = members[Idx];
-      Member<Idx, M, typename[:type_of(M):]>{}.visit(visitor, value.[:M:]);
+      if constexpr (!meta::has_annotation(M, ^^annotations::Skip)){
+        Member<Idx, M, typename[:type_of(M):]>{}.visit(visitor, value.[:M:]);
+      }
     }
   }
 };
 
 template <std::ranges::range T>
-  requires std::constructible_from<std::initializer_list<typename T::value_type>>
+  requires(std::constructible_from<std::initializer_list<typename T::value_type>> &&
+           !std::convertible_to<T, std::string_view>)
 struct Meta<T> {
   using type                            = T;
   using element_type                    = typename T::value_type;
@@ -111,4 +116,16 @@ struct Meta<std::optional<T>> {
   }
 };
 
+template <std::convertible_to<std::string> T>
+struct Meta<T> {
+  using type                            = T;
+  constexpr static std::meta::info info = ^^T;
+
+  template <typename S, typename F, typename U>
+    requires(std::same_as<std::remove_cvref_t<U>, type>)
+  void visit(this S&& self, F&& visitor, U&& value) {
+    std::invoke(std::forward<F>(visitor), std::forward<S>(self), std::forward<U>(value));
+  }
+};
+
 }  // namespace rsl::serializer

include/rsl/serializer/xml/annotations.hpp

@@ -3,6 +3,8 @@
 namespace rsl::xml {
 namespace annotations {
 struct Attribute {};
+struct Raw {};
 }  // namespace annotations
 constexpr inline annotations::Attribute attribute{};
+constexpr inline annotations::Raw raw{};
 }  // namespace rsl::xml

include/rsl/serializer/xml/serializer.hpp

@@ -2,6 +2,8 @@
 #include "document.hpp"
 #include "rsl/serializer/xml/annotations.hpp"
 
+#include <format>
+
 #include <rsl/meta_traits>
 #include <rsl/serializer/machinery.hpp>
 #include <stdexcept>
@@ -27,7 +29,8 @@ class Serializer {
   }
 
   [[nodiscard]] std::string get_header() const {
-    return R"(<?xml version="1.0" encoding="UTF-8"?>)""\n";
+    return R"(<?xml version="1.0" encoding="UTF-8"?>)"
+           "\n";
   }
 
 public:
@@ -72,25 +75,28 @@ class Serializer {
       throw std::runtime_error("Root node must be a structure");
     }
 
-    if constexpr (!meta::has_annotation(meta.info, ^^xml::annotations::Attribute)) {
-      throw std::runtime_error("Non-structural fields can only be attributes.");
-    } else {
+    if constexpr (meta::has_annotation(meta.info, ^^xml::annotations::Attribute)) {
       if constexpr (!has_identifier(meta.info)) {
         throw std::runtime_error("Attributes must have identifiers.");
       } else {
         if constexpr (is_optional<R>) {
           if (value.has_value()) {
             cursor->attributes[std::string(identifier_of(meta.info))] = stringify_value(*value);
           }
-        }else {
+        } else {
           cursor->attributes[std::string(identifier_of(meta.info))] = stringify_value(value);
         }
       }
+    } else if constexpr (meta::has_annotation(meta.info, ^^xml::annotations::Raw)){
+      cursor = cursor->add({std::string(identifier_of(meta.info))});
+      cursor->raw_content = stringify_value(value);
+      cursor = cursor->parent;
+    } else {
+      throw std::runtime_error(std::format("Non-structural fields can only be attributes. {}",
+                                           define_static_string(display_string_of(meta.info))));
     }
   }
 
-  [[nodiscard]] std::string finalize() const {
-    return get_header() + document.stringify();
-  }
+  [[nodiscard]] std::string finalize() const { return get_header() + document.stringify(); }
 };
 }  // namespace rsl::serializer::_xml_impl