Refactored more classes

Author: liuzicheng1987

include/rfl/parsing/Parser_array.hpp

@@ -15,11 +15,22 @@
 #include "call_destructors_on_array_where_necessary.hpp"
 #include "schema/Type.hpp"
 
-namespace rfl {
-namespace parsing {
+namespace rfl::parsing {
+
+template <class T>
+struct is_array : std::false_type {};
+
+template <class T, size_t _size>
+struct is_array<std::array<T, _size>> : std::true_type {
+  using element_type = T;
+  static constexpr size_t size = _size;
+};
+
+template <class T>
+constexpr bool is_array_v = is_array<std::remove_cvref_t<T>>::value;
+
 template <class R, class W, class T, size_t _size, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::array<T, _size>>
-struct Parser<R, W, std::array<T, _size>, ProcessorsType> {
+struct ParserArray {
  public:
   using InputArrayType = typename R::InputArrayType;
   using InputVarType = typename R::InputVarType;
@@ -93,7 +104,6 @@ struct Parser<R, W, std::array<T, _size>, ProcessorsType> {
   }
 };
 
-}  // namespace parsing
-}  // namespace rfl
+}  // namespace rfl::parsing
 
 #endif

include/rfl/parsing/Parser_default.hpp

@@ -26,12 +26,15 @@
 #include "AreReaderAndWriter.hpp"
 #include "Parent.hpp"
 #include "ParserSharedPtr.hpp"
+#include "Parser_array.hpp"
+#include "Parser_base.hpp"
 #include "Parser_box.hpp"
 #include "Parser_optional.hpp"
 #include "Parser_ref.hpp"
 #include "Parser_reference_wrapper.hpp"
+#include "Parser_rfl_tuple.hpp"
+#include "Parser_tuple.hpp"
 #include "Parser_unique_ptr.hpp"
-#include "Parser_base.hpp"
 #include "call_destructors_where_necessary.hpp"
 #include "is_tagged_union_wrapper.hpp"
 #include "make_type_name.hpp"
@@ -64,7 +67,7 @@ struct Parser {
 
     } else if constexpr (is_unique_ptr_v<T>) {
       return ParserUniquePtr<R, W, typename T::element_type,
-                            ProcessorsType>::read(_r, _var);
+                             ProcessorsType>::read(_r, _var);
 
     } else if constexpr (is_optional_v<T>) {
       return ParserOptional<R, W, typename std::remove_cvref_t<T>::value_type,
@@ -84,6 +87,17 @@ struct Parser {
       return ParserReferenceWrapper<R, W, typename std::remove_cvref_t<T>::type,
                                     ProcessorsType>::read(_r, _var);
 
+    } else if constexpr (is_array_v<T>) {
+      using IsArray = is_array<T>;
+      return ParserArray<R, W, typename IsArray::element_type, IsArray::size,
+                         ProcessorsType>::read(_r, _var);
+
+    } else if constexpr (is_tuple_v<T>) {
+      return ParserTuple<R, W, T, ProcessorsType>::read(_r, _var);
+
+    } else if constexpr (is_rfl_tuple_v<T>) {
+      return ParserRflTuple<R, W, T, ProcessorsType>::read(_r, _var);
+
     } else if constexpr (internal::has_read_reflector<T>) {
       const auto wrap_in_t = [](auto&& _named_tuple) -> Result<T> {
         try {
@@ -164,6 +178,17 @@ struct Parser {
       ParserReferenceWrapper<R, W, typename std::remove_cvref_t<T>::type,
                              ProcessorsType>::write(_w, _var, _parent);
 
+    } else if constexpr (is_array_v<T>) {
+      using IsArray = is_array<T>;
+      ParserArray<R, W, typename IsArray::element_type, IsArray::size,
+                  ProcessorsType>::write(_w, _var, _parent);
+
+    } else if constexpr (is_tuple_v<T>) {
+      ParserTuple<R, W, T, ProcessorsType>::write(_w, _var, _parent);
+
+    } else if constexpr (is_rfl_tuple_v<T>) {
+      ParserRflTuple<R, W, T, ProcessorsType>::write(_w, _var, _parent);
+
     } else if constexpr (internal::has_write_reflector<T>) {
       Parser<R, W, typename Reflector<T>::ReflType, ProcessorsType>::write(
           _w, Reflector<T>::from(_var), _parent);
@@ -228,6 +253,17 @@ struct Parser {
       return ParserReferenceWrapper<R, W, typename U::type,
                                     ProcessorsType>::to_schema(_definitions);
 
+    } else if constexpr (is_array_v<U>) {
+      using IsArray = is_array<U>;
+      return ParserArray<R, W, typename IsArray::element_type, IsArray::size,
+                         ProcessorsType>::to_schema(_definitions);
+
+    } else if constexpr (is_tuple_v<U>) {
+      return ParserTuple<R, W, U, ProcessorsType>::to_schema(_definitions);
+
+    } else if constexpr (is_rfl_tuple_v<U>) {
+      return ParserRflTuple<R, W, U, ProcessorsType>::to_schema(_definitions);
+
     } else if constexpr (rfl::internal::is_description_v<U>) {
       return make_description<U>(_definitions);
 

include/rfl/parsing/Parser_rfl_tuple.hpp

@@ -6,21 +6,27 @@
 #include "Parser_base.hpp"
 #include "TupleParser.hpp"
 
-namespace rfl {
-namespace parsing {
+namespace rfl::parsing {
+
+template <class T>
+struct is_rfl_tuple : std::false_type {};
+
+template <class... Ts>
+struct is_rfl_tuple<rfl::Tuple<Ts...>> : std::true_type {};
+
+template <class T>
+constexpr bool is_rfl_tuple_v = is_rfl_tuple<std::remove_cvref_t<T>>::value;
 
 /**
  * @brief Parser specialization for rfl::Tuple.
  */
-template <class R, class W, class... Ts, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, rfl::Tuple<Ts...>>
-struct Parser<R, W, rfl::Tuple<Ts...>, ProcessorsType>
+template <class R, class W, class T, class ProcessorsType>
+struct ParserRflTuple
     : public TupleParser<
           R, W, /*_ignore_empty_containers=*/false,
           /*_all_required=*/internal::no_optionals_v<ProcessorsType>,
-          ProcessorsType, rfl::Tuple<Ts...>> {};
+          ProcessorsType, T> {};
 
-}  // namespace parsing
-}  // namespace rfl
+}  // namespace rfl::parsing
 
 #endif

include/rfl/parsing/Parser_tuple.hpp

@@ -7,21 +7,27 @@
 #include "Parser_base.hpp"
 #include "TupleParser.hpp"
 
-namespace rfl {
-namespace parsing {
+namespace rfl::parsing {
+
+template <class T>
+struct is_tuple : std::false_type {};
+
+template <class... Ts>
+struct is_tuple<std::tuple<Ts...>> : std::true_type {};
+
+template <class T>
+constexpr bool is_tuple_v = is_tuple<std::remove_cvref_t<T>>::value;
 
 /**
  * @brief Parser specialization for std::tuple.
  */
-template <class R, class W, class... Ts, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::tuple<Ts...>>
-struct Parser<R, W, std::tuple<Ts...>, ProcessorsType>
+template <class R, class W, class T, class ProcessorsType>
+struct ParserTuple
     : public TupleParser<
           R, W, /*_ignore_empty_containers=*/false,
           /*_all_required=*/internal::no_optionals_v<ProcessorsType>,
-          ProcessorsType, std::tuple<Ts...>> {};
+          ProcessorsType, T> {};
 
-}  // namespace parsing
-}  // namespace rfl
+}  // namespace rfl::parsing
 
 #endif