Improve shared parser inlining and generated code layout

include/rfl/parsing/NamedTupleParser.hpp

@@ -389,12 +389,12 @@ struct NamedTupleParser {
     const auto reader = ViewReaderType(&_r, _view, &found, &set, &errors);
     if constexpr (_no_field_names) {
       const auto err = _r.read_array(reader, _obj_or_arr);
-      if (err) {
+      if (err) [[unlikely]] {
         return std::make_pair(set, err);
       }
     } else {
       const auto err = _r.read_object(reader, _obj_or_arr);
-      if (err) {
+      if (err) [[unlikely]] {
         return std::make_pair(set, err);
       }
     }
@@ -405,7 +405,7 @@ struct NamedTupleParser {
     if constexpr (internal::fail_fast_v<ProcessorsType>) {
       return std::make_pair(set, std::move(errors).error());
     } else {
-      if (errors.size() != 0) {
+      if (errors.size() != 0) [[unlikely]] {
         return std::make_pair(set, to_single_error_message(errors));
       }
       return std::make_pair(set, std::optional<Error>());
@@ -419,12 +419,12 @@ struct NamedTupleParser {
     const auto reader = ViewReaderWithDefaultType(&_r, _view, &errors);
     if constexpr (_no_field_names) {
       const auto err = _r.read_array(reader, _obj_or_arr);
-      if (err) {
+      if (err) [[unlikely]] {
         return err;
       }
     } else {
       const auto err = _r.read_object(reader, _obj_or_arr);
-      if (err) {
+      if (err) [[unlikely]] {
         return err;
       }
     }
@@ -438,7 +438,7 @@ struct NamedTupleParser {
     if constexpr (internal::fail_fast_v<ProcessorsType>) {
       return std::move(errors).error();
     } else {
-      if (errors.size() != 0) {
+      if (errors.size() != 0) [[unlikely]] {
         return to_single_error_message(errors);
       }
       return std::nullopt;

include/rfl/parsing/ParserBasicType.hpp

@@ -8,6 +8,7 @@
 #include "../always_false.hpp"
 #include "../enums.hpp"
 #include "../from_named_tuple.hpp"
+#include "../internal/always_inline.hpp"
 #include "../internal/has_default_val_v.hpp"
 #include "../internal/has_reflection_method_v.hpp"
 #include "../internal/has_reflection_type_v.hpp"
@@ -47,7 +48,8 @@ struct ParserBasicType {
    * @param _var The input variable to read from.
    * @return A Result containing the parsed value or an error.
    */
-  static Result<T> read(const R& _r, const InputVarType& _var) noexcept {
+  static RFL_ALWAYS_INLINE Result<T> read(const R& _r,
+                                          const InputVarType& _var) noexcept {
     return _r.template to_basic_type<std::remove_cvref_t<T>>(_var);
   }
 

include/rfl/parsing/VectorReader.hpp

@@ -22,6 +22,18 @@ class VectorReader {
   using InputVarType = typename R::InputVarType;
   using T = typename VecType::value_type;
 
+  static constexpr auto parsed_type() {
+    if constexpr (is_map_like_v<VecType>) {
+      using K = std::remove_cvref_t<typename T::first_type>;
+      using V = std::remove_cvref_t<typename T::second_type>;
+      return std::type_identity<std::pair<K, V>>{};
+    } else {
+      return std::type_identity<std::remove_cvref_t<T>>{};
+    }
+  }
+
+  using ParsedType = typename decltype(parsed_type())::type;
+
  public:
   /**
    * @brief Constructor.
@@ -53,43 +65,21 @@ class VectorReader {
    * @return An optional error.
    */
   RFL_ALWAYS_INLINE std::optional<Error> read(const InputVarType& _var) const {
-    const auto parse = [this](const InputVarType& _var) {
-      if constexpr (is_map_like_v<VecType>) {
-        return get_pair(_var);
-      } else {
-        return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(*r_,
-                                                                          _var);
-      }
-    };
-
-    const auto insert = [this](auto&& _var) -> std::optional<Error> {
-      if constexpr (is_map_like_v<VecType> || is_set_like_v<VecType>) {
-        vec_->insert(std::move(_var));
-      } else if constexpr (is_inplace_vector_v<VecType>) {
-        if (!vec_->try_emplace_back(std::move(_var))) {
-          return Error("Too many elements, capacity is " +
-                       std::to_string(vec_->capacity()) + ".");
-        }
-      } else {
-        vec_->emplace_back(std::move(_var));
+    auto res = Parser<R, W, ParsedType, ProcessorsType>::read(*r_, _var);
+    if (!res) {
+      return std::move(res).error();
+    }
+    if constexpr (is_map_like_v<VecType> || is_set_like_v<VecType>) {
+      vec_->insert(std::move(*res));
+    } else if constexpr (is_inplace_vector_v<VecType>) {
+      if (!vec_->try_emplace_back(std::move(*res))) {
+        return Error("Too many elements, capacity is " +
+                     std::to_string(vec_->capacity()) + ".");
       }
-      return std::nullopt;
-    };
-    auto res = parse(_var).transform(insert);
-    if (res) {
-      return *res;
     } else {
-      return res.error();
+      vec_->emplace_back(std::move(*res));
     }
-    // return parse(_var).transform(insert).error();
-  }
-
- private:
-  auto get_pair(const auto& _var) const {
-    using K = std::remove_cvref_t<typename T::first_type>;
-    using V = std::remove_cvref_t<typename T::second_type>;
-    return Parser<R, W, std::remove_cvref_t<std::pair<K, V>>,
-                  ProcessorsType>::read(*r_, _var);
+    return std::nullopt;
   }
 
  private:

include/rfl/parsing/ViewReader.hpp

@@ -105,7 +105,7 @@ class ViewReader {
       std::get<i>(*_found) = true;
       *_already_assigned = true;
       auto res = Parser<R, W, T, ProcessorsType>::read(_r, _var);
-      if (!res) {
+      if (!res) [[unlikely]] {
         constexpr auto name = FieldType::name();
         std::stringstream stream;
         stream << "Failed to parse field '" << name
@@ -141,7 +141,7 @@ class ViewReader {
       std::get<_pos>(*_found) = true;
     }
     auto res = Parser<R, W, T, ProcessorsType>::read(_r, _var);
-    if (!res) {
+    if (!res) [[unlikely]] {
       std::stringstream stream;
       stream << "Failed to parse field '" << _current_name
              << "': " << res.error().what();