From 3e18243f794f9319db597f98406a707a33283a25 Mon Sep 17 00:00:00 2001
From: sha512sum <linuxnyasha@tutanota.com>
Date: Wed, 9 Oct 2024 15:56:45 +0000
Subject: [PATCH] Use Parse instead TryParse in Serialization for last type in
 std::variant

---
 library/include/larra/serialization.hpp | 37 +++++++++++++++++--------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/library/include/larra/serialization.hpp b/library/include/larra/serialization.hpp
index 60b2f58..31b127a 100644
--- a/library/include/larra/serialization.hpp
+++ b/library/include/larra/serialization.hpp
@@ -138,19 +138,32 @@ struct Serialization<std::variant<Ts...>> : SerializationBase<> {
   static constexpr auto StartCheck(xmlpp::Element* element) {
     return true;
   }
-  [[nodiscard]] static constexpr auto TryParse(xmlpp::Element* element) -> std::optional<std::variant<Ts...>> {
-    return utempl::FirstOf(utempl::Tuple{[&] -> std::optional<Ts> {
-                             if(Serialization<Ts>::StartCheck(element)) {
-                               return Serialization<Ts>::TryParse(element);
-                             } else {
-                               SPDLOG_DEBUG("StartCheck failed for type {}", nameof::nameof_type<Ts>());
-                               return std::nullopt;
-                             }
-                           }...},
-                           std::optional<std::variant<Ts...>>{});
+
+ private:
+  template <typename T>
+  static constexpr auto FunctionForType(xmlpp::Element* element) {
+    return [=] -> std::optional<T> {
+      if(Serialization<T>::StartCheck(element)) {
+        return Serialization<T>::TryParse(element);
+      } else {
+        SPDLOG_DEBUG("StartCheck failed for type {}", nameof::nameof_type<T>());
+        return std::nullopt;
+      }
+    };
   }
-  [[nodiscard]] static constexpr auto Parse(xmlpp::Element* element) -> std::variant<Ts...> {
-    return Serialization::TryParse(element).value();
+
+ public:
+  [[nodiscard]] static constexpr auto TryParse(xmlpp::Element* element) -> std::optional<std::variant<Ts...>> {
+    return utempl::FirstOf(utempl::Tuple{FunctionForType<Ts>(element)...}, std::optional<std::variant<Ts...>>{});
+  }
+  [[nodiscard]] static constexpr auto Parse(xmlpp::Element* element) {
+    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 Serialization<decltype(utempl::Get<sizeof...(Ts) - 1>(utempl::kTypeList<Ts...>))>::Parse(element);
+                  });
+    }(utempl::TakeFrom<sizeof...(Ts) - 1>(utempl::kTypeList<Ts...>));
   }
   static constexpr auto Serialize(xmlpp::Element* element, const std::variant<Ts...>& object) -> void {
     std::visit(