reflect supports other option types

Author: danielaparker

include/jsoncons/reflect/json_conv_traits.hpp

@@ -1243,34 +1243,34 @@ has_can_convert = ext_traits::is_detected<traits_can_convert_t, Json, T>;
     };
 
     template <typename Json,typename T>
-    struct json_conv_traits<Json, jsoncons::optional<T>,
-                            typename std::enable_if<!is_json_conv_traits_declared<jsoncons::optional<T>>::value>::type>
+    struct json_conv_traits<Json, T,
+        typename std::enable_if<jsoncons::ext_traits::is_optional<T>::value && !is_json_conv_traits_declared<T>::value>::type>
     {
     public:
-        using result_type = conversion_result<jsoncons::optional<T>>;
+        using result_type = conversion_result<T>;
 
         static bool is(const Json& j) noexcept
         {
-            return j.is_null() || j.template is<T>();
+            return j.is_null() || j.template is<typename T::value_type>();
         }
 
         template <typename Alloc, typename TempAlloc>
         static result_type try_as(const allocator_set<Alloc,TempAlloc>& aset, const Json& j)
         { 
             if (j.is_null())
             {
-                return result_type(jsoncons::optional<T>());
+                return result_type(T());
             }
-            auto r = j.template try_as<T>(aset);
+            auto r = j.template try_as<typename T::value_type>(aset);
             if (!r)
             {
                 return result_type(jsoncons::unexpect, r.error());
             }
-            return result_type(jsoncons::optional<T>(std::move(r.value())));
+            return result_type(T(std::move(r.value())));
         }
 
         template <typename Alloc, typename TempAlloc>
-        static Json to_json(const allocator_set<Alloc,TempAlloc>& aset, const jsoncons::optional<T>& val)
+        static Json to_json(const allocator_set<Alloc,TempAlloc>& aset, const T& val)
         {
             return val.has_value() ? jsoncons::make_obj_using_allocator<Json>(aset.get_allocator(), *val) : Json::null();
         }

include/jsoncons/utility/more_type_traits.hpp

@@ -463,6 +463,10 @@ namespace ext_traits {
     using
     optional_has_value_t = decltype(std::declval<Optional>().has_value());
 
+    template <typename T>
+    using
+    value_type_t = typename T::value_type;
+
     template <typename Optional>
     using
     optional_value_t = decltype(std::declval<Optional>().value());
@@ -587,6 +591,10 @@ namespace ext_traits {
     using
     has_has_value = is_detected_exact<bool, optional_has_value_t, T>;
 
+    template <typename T>
+    using
+    has_value_type = is_detected<value_type_t, T>;
+
     template <typename T>
     using
     has_value = is_detected<optional_value_t, T>;
@@ -602,7 +610,7 @@ namespace ext_traits {
     template <typename T>
     struct is_optional
     {
-        static constexpr bool value = has_has_value<T>::value && has_value<T>::value && has_operator_bool<T>::value && has_operator_star<T>::value;
+        static constexpr bool value = has_value_type<T>::value && has_has_value<T>::value && has_value<T>::value && has_operator_bool<T>::value && has_operator_star<T>::value;
     };
 
     // is_front_insertable