Began using if constexpr instead of SFINAE

Author: liuzicheng1987

include/rfl/parsing/Parser.hpp

@@ -28,7 +28,6 @@
 #include "Parser_rfl_array.hpp"
 #include "Parser_rfl_tuple.hpp"
 #include "Parser_rfl_variant.hpp"
-#include "Parser_shared_ptr.hpp"
 #include "Parser_short.hpp"
 #include "Parser_skip.hpp"
 #include "Parser_span.hpp"

include/rfl/parsing/Parser_shared_ptr.hpp include/rfl/parsing/ParserSharedPtr.hppinclude/rfl/parsing/Parser_shared_ptr.hpp renamed to include/rfl/parsing/ParserSharedPtr.hpp

@@ -22,9 +22,17 @@
 
 namespace rfl::parsing {
 
+template <class T>
+struct is_shared_ptr : std::false_type {};
+
+template <class T>
+struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
+
+template <class T>
+constexpr bool is_shared_ptr_v = is_shared_ptr<std::remove_cvref_t<T>>::value;
+
 template <class R, class W, class T, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::shared_ptr<T>>
-struct Parser<R, W, std::shared_ptr<T>, ProcessorsType> {
+struct ParserSharedPtr {
   using InputVarType = typename R::InputVarType;
 
   using ParentType = Parent<W>;

include/rfl/parsing/Parser_box.hpp

@@ -16,9 +16,20 @@
 
 namespace rfl::parsing {
 
+template <class T>
+struct is_box : std::false_type {};
+
+template <class T, Copyability C>
+struct is_box<Box<T, C>> : std::true_type {
+  using element_type = T;
+  static constexpr Copyability copyability = C;
+};
+
+template <class T>
+constexpr bool is_box_v = is_box<std::remove_cvref_t<T>>::value;
+
 template <class R, class W, class T, Copyability C, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, Box<T, C>>
-struct Parser<R, W, Box<T, C>, ProcessorsType> {
+struct ParserBox {
   using InputVarType = typename R::InputVarType;
 
   /**

include/rfl/parsing/Parser_default.hpp

@@ -25,6 +25,12 @@
 #include "../to_view.hpp"
 #include "AreReaderAndWriter.hpp"
 #include "Parent.hpp"
+#include "ParserSharedPtr.hpp"
+#include "Parser_box.hpp"
+#include "Parser_optional.hpp"
+#include "Parser_ref.hpp"
+#include "Parser_reference_wrapper.hpp"
+#include "Parser_unique_ptr.hpp"
 #include "Parser_base.hpp"
 #include "call_destructors_where_necessary.hpp"
 #include "is_tagged_union_wrapper.hpp"
@@ -52,7 +58,33 @@ struct Parser {
    * @return A Result containing the parsed value or an error.
    */
   static Result<T> read(const R& _r, const InputVarType& _var) noexcept {
-    if constexpr (internal::has_read_reflector<T>) {
+    if constexpr (is_shared_ptr_v<T>) {
+      return ParserSharedPtr<R, W, typename T::element_type,
+                             ProcessorsType>::read(_r, _var);
+
+    } else if constexpr (is_unique_ptr_v<T>) {
+      return ParserUniquePtr<R, W, typename T::element_type,
+                            ProcessorsType>::read(_r, _var);
+
+    } else if constexpr (is_optional_v<T>) {
+      return ParserOptional<R, W, typename std::remove_cvref_t<T>::value_type,
+                            ProcessorsType>::read(_r, _var);
+
+    } else if constexpr (is_box_v<T>) {
+      using IsBox = is_box<std::remove_cvref_t<T>>;
+      return ParserBox<R, W, typename IsBox::element_type, IsBox::copyability,
+                       ProcessorsType>::read(_r, _var);
+
+    } else if constexpr (is_ref_v<T>) {
+      using IsRef = is_ref<std::remove_cvref_t<T>>;
+      return ParserRef<R, W, typename IsRef::element_type,
+                       ProcessorsType>::read(_r, _var);
+
+    } else if constexpr (is_reference_wrapper_v<T>) {
+      return ParserReferenceWrapper<R, W, typename std::remove_cvref_t<T>::type,
+                                    ProcessorsType>::read(_r, _var);
+
+    } else if constexpr (internal::has_read_reflector<T>) {
       const auto wrap_in_t = [](auto&& _named_tuple) -> Result<T> {
         try {
           using NT = decltype(_named_tuple);
@@ -106,7 +138,33 @@ struct Parser {
    */
   template <class P>
   static void write(const W& _w, const T& _var, const P& _parent) {
-    if constexpr (internal::has_write_reflector<T>) {
+    if constexpr (is_shared_ptr_v<T>) {
+      ParserSharedPtr<R, W, typename T::element_type, ProcessorsType>::write(
+          _w, _var, _parent);
+
+    } else if constexpr (is_unique_ptr_v<T>) {
+      ParserUniquePtr<R, W, typename T::element_type, ProcessorsType>::write(
+          _w, _var, _parent);
+
+    } else if constexpr (is_optional_v<T>) {
+      ParserOptional<R, W, typename std::remove_cvref_t<T>::value_type,
+                     ProcessorsType>::write(_w, _var, _parent);
+
+    } else if constexpr (is_box_v<T>) {
+      using IsBox = is_box<std::remove_cvref_t<T>>;
+      ParserBox<R, W, typename IsBox::element_type, IsBox::copyability,
+                ProcessorsType>::write(_w, _var, _parent);
+
+    } else if constexpr (is_ref_v<T>) {
+      using IsRef = is_ref<std::remove_cvref_t<T>>;
+      ParserRef<R, W, typename IsRef::element_type, ProcessorsType>::write(
+          _w, _var, _parent);
+
+    } else if constexpr (is_reference_wrapper_v<T>) {
+      ParserReferenceWrapper<R, W, typename std::remove_cvref_t<T>::type,
+                             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);
 
@@ -144,7 +202,33 @@ struct Parser {
     using U = std::remove_cvref_t<T>;
     using Type = schema::Type;
 
-    if constexpr (rfl::internal::is_description_v<U>) {
+    if constexpr (is_shared_ptr_v<U>) {
+      return ParserSharedPtr<R, W, typename U::element_type,
+                             ProcessorsType>::to_schema(_definitions);
+
+    } else if constexpr (is_unique_ptr_v<U>) {
+      return ParserUniquePtr<R, W, typename U::element_type,
+                             ProcessorsType>::to_schema(_definitions);
+
+    } else if constexpr (is_optional_v<U>) {
+      return ParserOptional<R, W, typename U::value_type,
+                            ProcessorsType>::to_schema(_definitions);
+
+    } else if constexpr (is_box_v<U>) {
+      using IsBox = is_box<U>;
+      return ParserBox<R, W, typename IsBox::element_type, IsBox::copyability,
+                       ProcessorsType>::to_schema(_definitions);
+
+    } else if constexpr (is_ref_v<U>) {
+      using IsRef = is_ref<U>;
+      return ParserRef<R, W, typename IsRef::element_type,
+                       ProcessorsType>::to_schema(_definitions);
+
+    } else if constexpr (is_reference_wrapper_v<U>) {
+      return ParserReferenceWrapper<R, W, typename U::type,
+                                    ProcessorsType>::to_schema(_definitions);
+
+    } else if constexpr (rfl::internal::is_description_v<U>) {
       return make_description<U>(_definitions);
 
     } else if constexpr (rfl::internal::is_deprecated_v<U>) {

include/rfl/parsing/Parser_optional.hpp

@@ -15,12 +15,19 @@
 #include "schemaful/IsSchemafulWriter.hpp"
 #include "schemaful/OptionalReader.hpp"
 
-namespace rfl {
-namespace parsing {
+namespace rfl::parsing {
+
+template <class T>
+struct is_optional : std::false_type {};
+
+template <class T>
+struct is_optional<std::optional<T>> : std::true_type {};
+
+template <class T>
+constexpr bool is_optional_v = is_optional<std::remove_cvref_t<T>>::value;
 
 template <class R, class W, class T, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::optional<T>>
-struct Parser<R, W, std::optional<T>, ProcessorsType> {
+struct ParserOptional {
   using InputVarType = typename R::InputVarType;
 
   using ParentType = Parent<W>;
@@ -98,7 +105,6 @@ struct Parser<R, W, std::optional<T>, ProcessorsType> {
   }
 };
 
-}  // namespace parsing
-}  // namespace rfl
+}  // namespace rfl::parsing
 
 #endif

include/rfl/parsing/Parser_ref.hpp

@@ -17,9 +17,19 @@
 
 namespace rfl::parsing {
 
+template <class T>
+struct is_ref : std::false_type {};
+
+template <class T>
+struct is_ref<Ref<T>> : std::true_type {
+  using element_type = T;
+};
+
+template <class T>
+constexpr bool is_ref_v = is_ref<std::remove_cvref_t<T>>::value;
+
 template <class R, class W, class T, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, Ref<T>>
-struct Parser<R, W, Ref<T>, ProcessorsType> {
+struct ParserRef {
   using InputVarType = typename R::InputVarType;
 
   /**

include/rfl/parsing/Parser_reference_wrapper.hpp

@@ -10,12 +10,20 @@
 #include "Parser_base.hpp"
 #include "schema/Type.hpp"
 
-namespace rfl {
-namespace parsing {
+namespace rfl::parsing {
+
+template <class T>
+struct is_reference_wrapper : std::false_type {};
+
+template <class T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+
+template <class T>
+constexpr bool is_reference_wrapper_v =
+    is_reference_wrapper<std::remove_cvref_t<T>>::value;
 
 template <class R, class W, class T, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::reference_wrapper<T>>
-struct Parser<R, W, std::reference_wrapper<T>, ProcessorsType> {
+struct ParserReferenceWrapper {
   using InputVarType = typename R::InputVarType;
 
   /**
@@ -62,7 +70,6 @@ struct Parser<R, W, std::reference_wrapper<T>, ProcessorsType> {
   }
 };
 
-}  // namespace parsing
-}  // namespace rfl
+}  // namespace rfl::parsing
 
 #endif

include/rfl/parsing/Parser_unique_ptr.hpp

@@ -20,11 +20,19 @@
 #include "schemaful/IsSchemafulWriter.hpp"
 #include "schemaful/UniquePtrReader.hpp"
 
-namespace rfl ::parsing {
+namespace rfl::parsing {
+
+template <class T>
+struct is_unique_ptr : std::false_type {};
+
+template <class T>
+struct is_unique_ptr<std::unique_ptr<T>> : std::true_type {};
+
+template <class T>
+constexpr bool is_unique_ptr_v = is_unique_ptr<std::remove_cvref_t<T>>::value;
 
 template <class R, class W, class T, class ProcessorsType>
-  requires AreReaderAndWriter<R, W, std::unique_ptr<T>>
-struct Parser<R, W, std::unique_ptr<T>, ProcessorsType> {
+struct ParserUniquePtr {
   using InputVarType = typename R::InputVarType;
 
   using ParentType = Parent<W>;