Better forwarding to improve read performance a little

include/rfl/Result.hpp

@@ -21,10 +21,13 @@ namespace rfl {
 class Error {
  public:
   Error(const std::string& _what) : what_(_what) {}
+  Error(std::string&& _what) : what_(std::move(_what)) {}
 
   Error(const Error& e) = default;
+  Error(Error&& e) = default;
 
   Error& operator=(const Error&) = default;
+  Error& operator=(Error&&) = default;
 
   /// Returns the error message, equivalent to .what() in std::exception.
   const std::string& what() const { return what_; }
@@ -431,6 +434,10 @@ inline Unexpected<Error> error(const std::string& _what) {
   return Unexpected<Error>(Error(_what));
 }
 
+inline Unexpected<Error> error(std::string&& _what) {
+  return Unexpected<Error>(Error(std::move(_what)));
+}
+
 /// Shorthand for unexpected error.
 inline Unexpected<Error> error(const Error& _err) {
   return Unexpected<Error>(_err);

include/rfl/parsing/MapReader.hpp

@@ -55,11 +55,13 @@ class MapReader {
     }
   }
 
-  Result<std::pair<KeyType, ValueType>> make_key(auto& _pair) const noexcept {
+  Result<std::pair<KeyType, ValueType>> make_key(auto&& _pair) const noexcept {
+    static_assert(std::is_rvalue_reference_v<decltype(_pair)>, "Expected an rvalue");
     const auto to_pair =
-        [&](auto _key) -> Result<std::pair<KeyType, ValueType>> {
+        [&](auto&& _key) -> Result<std::pair<KeyType, ValueType>> {
       try {
-        return std::make_pair(KeyType(std::move(_key)),
+        using K = decltype(_key);
+        return std::make_pair(KeyType(std::forward<K>(_key)),
                               std::move(_pair.second));
       } catch (std::exception& e) {
         return error(e.what());
@@ -77,7 +79,7 @@ class MapReader {
                     std::is_floating_point_v<ReflT>) {
         return key_to_numeric<ReflT>(_pair).and_then(to_pair);
       } else {
-        return to_pair(_pair.first);
+        return to_pair(std::move(_pair.first));
       }
 
     } else {
@@ -89,7 +91,7 @@ class MapReader {
       const std::string_view& _name, const InputVarType& _var) const noexcept {
     const auto to_pair = [&](ValueType&& _val) {
       auto pair = std::make_pair(std::string(_name), std::move(_val));
-      return make_key(pair);
+      return make_key(std::move(pair));
     };
     return Parser<R, W, std::remove_cvref_t<ValueType>, ProcessorsType>::read(
                *r_, _var)

include/rfl/parsing/NamedTupleParser.hpp

@@ -305,14 +305,16 @@ struct NamedTupleParser {
     set.fill(false);
     std::vector<Error> errors;
     const auto reader = ViewReaderType(&_r, _view, &found, &set, &errors);
-    std::optional<Error> err;
     if constexpr (_no_field_names) {
-      err = _r.read_array(reader, _obj_or_arr);
+      const auto err = _r.read_array(reader, _obj_or_arr);
+      if (err) {
+        return std::make_pair(set, err);
+      }
     } else {
-      err = _r.read_object(reader, _obj_or_arr);
-    }
-    if (err) {
-      return std::make_pair(set, err);
+      const auto err = _r.read_object(reader, _obj_or_arr);
+      if (err) {
+        return std::make_pair(set, err);
+      }
     }
     handle_missing_fields(found, *_view, &set, &errors,
                           std::make_integer_sequence<int, size_>());
@@ -327,14 +329,16 @@ struct NamedTupleParser {
       NamedTupleType* _view) noexcept {
     std::vector<Error> errors;
     const auto reader = ViewReaderWithDefaultType(&_r, _view, &errors);
-    std::optional<Error> err;
     if constexpr (_no_field_names) {
-      err = _r.read_array(reader, _obj_or_arr);
+      const auto err = _r.read_array(reader, _obj_or_arr);
+      if (err) {
+        return err;
+      }
     } else {
-      err = _r.read_object(reader, _obj_or_arr);
-    }
-    if (err) {
-      return err;
+      const auto err = _r.read_object(reader, _obj_or_arr);
+      if (err) {
+        return err;
+      }
     }
     if (errors.size() != 0) {
       return to_single_error_message(errors);

include/rfl/parsing/Parser_default.hpp

@@ -46,9 +46,10 @@ struct Parser {
   /// Expresses the variables as type T.
   static Result<T> read(const R& _r, const InputVarType& _var) noexcept {
     if constexpr (internal::has_read_reflector<T>) {
-      const auto wrap_in_t = [](auto _named_tuple) -> Result<T> {
+      const auto wrap_in_t = [](auto&& _named_tuple) -> Result<T> {
         try {
-          return Reflector<T>::to(_named_tuple);
+          using NT = decltype(_named_tuple);
+          return Reflector<T>::to(std::forward<NT>(_named_tuple));
         } catch (std::exception& e) {
           return error(e.what());
         }
@@ -67,9 +68,10 @@ struct Parser {
     } else {
       if constexpr (internal::has_reflection_type_v<T>) {
         using ReflectionType = std::remove_cvref_t<typename T::ReflectionType>;
-        const auto wrap_in_t = [](auto _named_tuple) -> Result<T> {
+        const auto wrap_in_t = [](auto&& _named_tuple) -> Result<T> {
           try {
-            return T{std::move(_named_tuple)};
+            using NT = decltype(_named_tuple);
+            return T{std::forward<NT>(_named_tuple)};
           } catch (std::exception& e) {
             return error(e.what());
           }

include/rfl/parsing/Parser_rfl_variant.hpp

@@ -68,6 +68,7 @@ class Parser<R, W, rfl::Variant<AlternativeTypes...>, ProcessorsType> {
     } else {
       std::optional<rfl::Variant<AlternativeTypes...>> result;
       std::vector<Error> errors;
+      errors.reserve(sizeof...(AlternativeTypes));
       read_variant(
           _r, _var, &result, &errors,
           std::make_integer_sequence<int, sizeof...(AlternativeTypes)>());
@@ -187,7 +188,7 @@ class Parser<R, W, rfl::Variant<AlternativeTypes...>, ProcessorsType> {
       if (res) {
         *_result = std::move(*res);
       } else {
-        _errors->emplace_back(res.error());
+        _errors->emplace_back(std::move(res.error()));
       }
     }
   }

include/rfl/parsing/Parser_variant.hpp

@@ -85,6 +85,7 @@ class Parser<R, W, std::variant<AlternativeTypes...>, ProcessorsType> {
     } else {
       std::optional<std::variant<AlternativeTypes...>> result;
       std::vector<Error> errors;
+      errors.reserve(sizeof...(AlternativeTypes));
       read_variant(
           _r, _var, &result, &errors,
           std::make_integer_sequence<int, sizeof...(AlternativeTypes)>());
@@ -215,7 +216,7 @@ class Parser<R, W, std::variant<AlternativeTypes...>, ProcessorsType> {
       if (res) {
         *_result = std::move(*res);
       } else {
-        _errors->emplace_back(res.error());
+        _errors->emplace_back(std::move(res.error()));
       }
     }
   }