Always use the error helper function

Author: liuzicheng1987

include/rfl/cbor/Reader.hpp

@@ -106,15 +106,15 @@ class Reader {
   rfl::Result<InputArrayType> to_array(
       const InputVarType& _var) const noexcept {
     if (!_var.val_->is_array()) {
-      return Unexpected(Error("Could not cast to an array."));
+      return error("Could not cast to an array.");
     }
     return InputArrayType{_var.val_};
   }
 
   rfl::Result<InputObjectType> to_object(
       const InputVarType& _var) const noexcept {
     if (!_var.val_->is_object()) {
-      return Unexpected(Error("Could not cast to an object."));
+      return error("Could not cast to an object.");
     }
     return InputObjectType{_var.val_};
   }

include/rfl/parsing/FieldVariantParser.hpp

@@ -43,7 +43,7 @@ struct FieldVariantParser {
               &_r, &field_variant);
       auto err = _r.read_object(reader, _obj);
       if (err) {
-        return rfl::Unexpected(*err);
+        return error(*err);
       }
       if (!field_variant) {
         return error(

include/rfl/parsing/MapParser.hpp

@@ -68,12 +68,12 @@ struct MapParser {
     if constexpr (schemaful::IsSchemafulReader<R>) {
       const auto err = _r.read_map(map_reader, _obj_or_map);
       if (err) {
-        return Unexpected(*err);
+        return error(*err);
       }
     } else {
       const auto err = _r.read_object(map_reader, _obj_or_map);
       if (err) {
-        return Unexpected(*err);
+        return error(*err);
       }
     }
     if (errors.size() != 0) {

include/rfl/parsing/NamedTupleParser.hpp

@@ -92,7 +92,7 @@ struct NamedTupleParser {
         Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
     if (err) [[unlikely]] {
       call_destructors_where_necessary(set, &view);
-      return rfl::Unexpected(*err);
+      return error(*err);
     }
     auto res = Result<NamedTuple<FieldTypes...>>(std::move(*ptr));
     call_destructors_where_necessary(set, &view);

include/rfl/parsing/Parser_array.hpp

@@ -40,12 +40,12 @@ struct Parser<R, W, std::array<T, _size>, ProcessorsType> {
       auto err = _r.read_array(array_reader, _arr);
       if (err) {
         call_destructors_on_array_where_necessary(array_reader.num_set(), ptr);
-        return rfl::Unexpected(*err);
+        return error(*err);
       }
       err = array_reader.check_size();
       if (err) {
         call_destructors_on_array_where_necessary(array_reader.num_set(), ptr);
-        return rfl::Unexpected(*err);
+        return error(*err);
       }
       auto result = Result<std::array<T, _size>>(std::move(*ptr));
       call_destructors_on_array_where_necessary(array_reader.num_set(), ptr);

include/rfl/parsing/Parser_default.hpp

@@ -298,7 +298,7 @@ struct Parser {
         Parser<R, W, ViewType, ProcessorsType>::read_view_with_default(_r, _var,
                                                                        &view);
     if (err) [[unlikely]] {
-      return rfl::Unexpected(*err);
+      return error(*err);
     }
     return t;
   }

include/rfl/parsing/TupleParser.hpp

@@ -55,13 +55,13 @@ struct TupleParser {
         if (err) {
           call_destructors_on_tuple_where_necessary(tuple_reader.num_set(),
                                                     ptr);
-          return Unexpected(*err);
+          return error(*err);
         }
         err = tuple_reader.handle_missing_fields();
         if (err) {
           call_destructors_on_tuple_where_necessary(tuple_reader.num_set(),
                                                     ptr);
-          return Unexpected(*err);
+          return error(*err);
         }
         auto res = Result<TupleType>(std::move(*ptr));
         call_destructors_on_tuple_where_necessary(tuple_reader.num_set(), ptr);

include/rfl/parsing/VectorParser.hpp

@@ -57,7 +57,7 @@ struct VectorParser {
             VectorReader<R, W, VecType, ProcessorsType>(&_r, &vec);
         const auto err = _r.read_array(vector_reader, _arr);
         if (err) {
-          return rfl::Unexpected(*err);
+          return error(*err);
         }
         return vec;
       };