Fixes

Author: linuxnyasha

universal/include/userver/formats/universal/common_containers.hpp

@@ -1,3 +1,4 @@
+#if __cplusplus >= 202002L
 #pragma once
 #include <userver/formats/universal/universal.hpp>
 #include <userver/formats/common/items.hpp>
@@ -11,31 +12,35 @@ template <typename T>
 struct Max : public impl::Param<T> {
   inline constexpr Max(const T& value) :
       impl::Param<T>(value) {}
-  inline constexpr std::string Check(const T& value) const {
-    return value <= this->value ? "" : this->Error(value);
+  inline constexpr std::optional<std::string> Check(const T& value) const {
+    if(value <= this->value) {
+      return std::nullopt;
+    }
+    return this->Error(value);
   }
   template <typename Value>
-  inline constexpr std::enable_if_t<meta::kIsRange<Value>, std::string>
+  inline constexpr std::enable_if_t<meta::kIsRange<Value>, std::optional<std::string>>
   Check(const Value& value) const {
     for(const auto& element : value) {
       if(element > this->value) {
         return this->Error(element);
       }
     }
-    return "";
+    return std::nullopt;
   }
   inline constexpr std::string Error(const T& value) const {
     return std::format("{} > {}", value, this->value);
   }
 };
 
+
 struct MinElements : public impl::Param<std::size_t> {
   inline constexpr MinElements(const std::size_t& value) :
       impl::Param<std::size_t>(value) {}
   template <typename Value>
-  inline constexpr std::string Check(const Value& value) const {
+  inline constexpr std::optional<std::string> Check(const Value& value) const {
     if(value.size() >= this->value) {
-      return "";
+      return std::nullopt;
     }
     return this->Error(value);
   }
@@ -49,18 +54,21 @@ template <typename T>
 struct Min : public impl::Param<T> {
   inline constexpr Min(const T& value) :
       impl::Param<T>(value) {}
-  inline constexpr std::string Check(const T& value) const {
-    return value >= this->value ? "" : this->Error(value);
+  inline constexpr std::optional<std::string> Check(const T& value) const {
+    if(value >= this->value) {
+      return std::nullopt;
+    }
+    return this->Error(value);
   };
   template <typename Value>
-  inline constexpr std::enable_if_t<meta::kIsRange<Value>, std::string>
+  inline constexpr std::enable_if_t<meta::kIsRange<Value>, std::optional<std::string>>
   Check(const Value& value) const {
     for(const auto& element : value) {
       if(element < this->value) {
         return this->Error(element);
       }
     }
-    return "";
+    return std::nullopt;
   }
   inline constexpr auto Error(const T& value) const {
     return std::format("{} < {}", value, this->value);
@@ -77,8 +85,11 @@ static const utils::regex kRegex(Pattern);
 struct Pattern : public impl::EmptyCheck, public impl::Param<const utils::regex*> {
   constexpr inline Pattern(const utils::regex& regex) :
       impl::Param<const utils::regex*>(&regex) {}
-  constexpr inline std::string Check(std::string_view str) const {
-    return utils::regex_match(str, *this->value) ? "" : this->Error(str);
+  constexpr inline std::optional<std::string> Check(std::string_view str) const {
+    if(utils::regex_match(str, *this->value)) {
+      return std::nullopt;
+    }
+    return this->Error(str);
   }
   constexpr inline std::string Error(std::string_view) const {
     return "Error";
@@ -90,8 +101,8 @@ struct Additional : public impl::EmptyCheck, public impl::Param<bool> {
 };
 template <>
 struct FieldConfig<int> {
-  std::optional<Max<int>> Maximum;
-  std::optional<Min<int>> Minimum;
+  std::optional<Max<int>> Maximum = std::nullopt;
+  std::optional<Min<int>> Minimum = std::nullopt;
   template <typename MainClass, auto I, typename Value>
   constexpr int Read(Value&& value) const {
     constexpr auto name = boost::pfr::get_name<I, MainClass>();
@@ -105,48 +116,74 @@ struct FieldConfig<int> {
   constexpr auto Write(const int& value, std::string_view fieldName, const auto&, auto& builder) const {
     builder[static_cast<std::string>(fieldName)] = value;
   };
-  inline constexpr std::string_view Check(const int&) const {
-    return "";
+  inline constexpr std::optional<std::string> Check(const int&) const {
+    return std::nullopt;
   }
 
 };
 template <>
 struct FieldConfig<std::optional<std::string>> {
-  std::optional<Pattern> Pattern;
-  std::optional<Default<std::string>> Default;
+  std::optional<Pattern> Pattern = std::nullopt;
+  std::optional<Default<std::string_view>> Default = std::nullopt;
+  bool Required = false;
+  bool Nullable = false;
   template <typename MainClass, auto I, typename Value>
   constexpr std::optional<std::string> Read(Value&& value) const {
     constexpr auto name = boost::pfr::get_name<I, MainClass>();
-    if(!value.HasMember(name)) {
+    if(value[name].IsMissing() && this->Required) {
       return std::nullopt;
     };
-    return value[name].template As<std::string>();
+    if(!value[name].IsMissing()) {
+      if(this->Nullable) {
+        return value[name].template As<std::optional<std::string>>();
+      };
+      return value[name].template As<std::string>();
+    };
+    if(this->Default) {
+      return static_cast<std::string>(this->Default->value);
+    };
+    return std::nullopt;
   };
   template <typename MainClass, auto I, typename Value>
   constexpr std::optional<std::optional<std::string>> TryRead(Value&& value) const {
     constexpr auto name = boost::pfr::get_name<I, MainClass>();
-    auto response = parse::TryParse(value[name], parse::To<std::string>{});
-    if(response) {
-      return response;
-    }
+    if(value[name].IsMissing() && this->Required) {
+      return std::nullopt;
+    };
+
+    if(this->Nullable) {
+      auto response = parse::TryParse(value[name], parse::To<std::optional<std::string>>{});
+      if(response) {
+        return response;
+      }
+    } else {
+      auto response = parse::TryParse(value[name], parse::To<std::string>{});
+      if(response) {
+        return response;
+      };
+    };
     if(this->Default) {
-      return this->Default->value;
+      return static_cast<std::string>(this->Default->value);
     }
-    return std::nullopt;
+    return {{}};
   }
   constexpr auto Write(const std::optional<std::string>& value, std::string_view fieldName, const auto&, auto& builder) const {
     if(value) {
       builder[static_cast<std::string>(fieldName)] = *value;
+      return;
+    };
+    if(this->Default) {
+      builder[static_cast<std::string>(fieldName)] = this->Default->value;
     };
   };
-  inline constexpr std::string_view Check(const std::string&) const {
-    return "";
+  inline constexpr std::optional<std::string> Check(const auto&) const {
+    return std::nullopt;
   }
 
 };
 template <>
 struct FieldConfig<std::string> {
-  std::optional<Pattern> Pattern;
+  std::optional<Pattern> Pattern = std::nullopt;
   template <typename MainClass, auto I, typename Value>
   constexpr std::string Read(Value&& value) const {
     constexpr auto name = boost::pfr::get_name<I, MainClass>();
@@ -160,21 +197,29 @@ struct FieldConfig<std::string> {
   constexpr auto Write(std::string_view value, std::string_view fieldName, const auto&, auto& builder) const {
     builder[static_cast<std::string>(fieldName)] = value;
   };
-  inline constexpr std::string_view Check(std::string_view) const {
-    return "";
+  inline constexpr std::optional<std::string> Check(std::string_view) const {
+    return std::nullopt;
   }
 
 };
 
 template <>
 struct FieldConfig<std::optional<int>> {
-  std::optional<Max<int>> Maximum;
-  std::optional<Min<int>> Minimum;
-  std::optional<Default<int>> Default;
+  std::optional<Max<int>> Maximum = std::nullopt;
+  std::optional<Min<int>> Minimum = std::nullopt;
+  std::optional<Default<int>> Default = std::nullopt;
+  bool Required = false;
+  bool Nullable = false;
   template <typename MainClass, auto I, typename Value>
   constexpr std::optional<int> Read(Value&& value) const {
     constexpr auto name = boost::pfr::get_name<I, MainClass>();
-    if(value.HasMember(name)) {
+    if(value[name].IsMissing() && this->Required) {
+      return std::nullopt;
+    };
+    if(!value[name].IsMissing()) {
+      if(this->Nullable) {
+        return value[name].template As<std::optional<int>>();
+      };
       return value[name].template As<int>();
     }
     if(this->Default) {
@@ -185,10 +230,20 @@ struct FieldConfig<std::optional<int>> {
   template <typename MainClass, auto I, typename Value>
   constexpr std::optional<std::optional<int>> TryRead(Value&& value) const {
     constexpr auto name = boost::pfr::get_name<I, MainClass>();
-    auto response = parse::TryParse(value[name], parse::To<int>{});
-    if(response) {
-      return response;
-    }
+    if(this->Nullable) {
+      auto response = parse::TryParse(value[name], parse::To<std::optional<int>>{});
+      if(response) {
+        return response;
+      }
+    } else {
+      if(value[name].IsNull()) {
+        return std::nullopt;
+      };
+      auto response = parse::TryParse(value[name], parse::To<int>{});
+      if(response) {
+        return response;
+      };
+    };
     if(this->Default) {
       return this->Default->value;
     }
@@ -204,21 +259,21 @@ struct FieldConfig<std::optional<int>> {
     }
   }
 
-  inline constexpr std::string_view Check(const std::optional<int>&) const {
-    return "";
+  inline constexpr std::optional<std::string> Check(const std::optional<int>&) const {
+    return std::nullopt;
   }
 
 };
 template <typename Value>
 struct FieldConfig<std::unordered_map<std::string, Value>> {
-  std::optional<Additional> Additional;
-  using kType = std::unordered_map<std::string, Value>;
+  std::optional<Additional> Additional = std::nullopt;
+  using Type = std::unordered_map<std::string, Value>;
   template <typename MainClass, auto I, typename Value2>
-  inline constexpr kType Read(Value2&& value) const {
+  inline constexpr Type Read(Value2&& value) const {
     if(!this->Additional) {
       throw std::runtime_error("Invalid Flags");
     }
-    kType response;
+    Type response;
     constexpr auto fields = boost::pfr::names_as_array<MainClass>();
     for(const auto& [name, value2] : userver::formats::common::Items(std::forward<Value2>(value))) {
       auto it = std::find(fields.begin(), fields.end(), name);
@@ -229,11 +284,11 @@ struct FieldConfig<std::unordered_map<std::string, Value>> {
     return response;
   }
   template <typename MainClass, auto I, typename Value2>
-  inline constexpr std::optional<kType> TryRead(Value2&& value) const {
+  inline constexpr std::optional<Type> TryRead(Value2&& value) const {
     if(!this->Additional) {
       throw std::runtime_error("Invalid Flags");
     }
-    kType response;
+    Type response;
     constexpr auto fields = boost::pfr::names_as_array<MainClass>();
     constexpr auto name = boost::pfr::get_name<I, MainClass>();
     for(const auto& [name2, value2] : userver::formats::common::Items(std::forward<Value2>(value))) {
@@ -247,19 +302,19 @@ struct FieldConfig<std::unordered_map<std::string, Value>> {
     }
     return response;
   }
-  inline constexpr std::string_view Check(const kType&) const {
-    return "";
+  inline constexpr std::optional<std::string> Check(const Type&) const {
+    return std::nullopt;
   }
-  constexpr auto Write(const kType& value, std::string_view, const auto&, auto& builder) const {
+  constexpr auto Write(const Type& value, std::string_view, const auto&, auto& builder) const {
     for(const auto& [name, value2] : value) {
       builder[name] = value2;
     };
   };
 };
 template <typename Element>
 struct FieldConfig<std::vector<Element>> {
-  std::optional<MinElements> MinimalElements;
-  FieldConfig<Element> Items;
+  std::optional<MinElements> MinimalElements = std::nullopt;
+  FieldConfig<Element> Items = {};
   template <typename MainClass, auto I, typename Value>
   inline constexpr auto Read(Value&& value) const {
     constexpr auto name = boost::pfr::get_name<I, MainClass>();
@@ -283,14 +338,22 @@ struct FieldConfig<std::vector<Element>> {
     }
     return response;
   }
-  inline constexpr std::string Check(const std::vector<Element>& obj) const {
-    std::string error;
+  inline constexpr std::optional<std::string> Check(const std::vector<Element>& obj) const {
+    std::optional<std::string> error = std::nullopt;
     for(const auto& element : obj) {
-      error += impl::UniversalCheckField(element, this->Items);
+      auto add = impl::UniversalCheckField(element, this->Items);
+      if(add) {
+        if(!error) {
+          error = *add;
+          continue;
+        };
+        *error += *add;
+      }
     }
     return error;
   }
 
 };
 } // namespace formats::universal
 USERVER_NAMESPACE_END
+#endif