include/boost/json /impl /conversion.hpp
100.00% Lines (18/18) 100.00% Functions (9/9)
[ ] prev/next file n p prev/next uncovered line
TLA Baseline Branch
Line Hits Code Line Hits Code
1   // 1   //
2   // Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com) 2   // Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)
3   // Copyright (c) 2022 Dmitry Arkhipov (grisumbras@yandex.ru) 3   // Copyright (c) 2022 Dmitry Arkhipov (grisumbras@yandex.ru)
4   // 4   //
5   // Distributed under the Boost Software License, Version 1.0. (See accompanying 5   // Distributed under the Boost Software License, Version 1.0. (See accompanying
6   // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6   // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7   // 7   //
8   // Official repository: https://github.com/boostorg/json 8   // Official repository: https://github.com/boostorg/json
9   // 9   //
10   10  
11   #ifndef BOOST_JSON_IMPL_CONVERSION_HPP 11   #ifndef BOOST_JSON_IMPL_CONVERSION_HPP
12   #define BOOST_JSON_IMPL_CONVERSION_HPP 12   #define BOOST_JSON_IMPL_CONVERSION_HPP
13   13  
14   #include <boost/json/fwd.hpp> 14   #include <boost/json/fwd.hpp>
15   #include <boost/json/string_view.hpp> 15   #include <boost/json/string_view.hpp>
16   #include <boost/describe/enumerators.hpp> 16   #include <boost/describe/enumerators.hpp>
17   #include <boost/describe/members.hpp> 17   #include <boost/describe/members.hpp>
18   #include <boost/describe/bases.hpp> 18   #include <boost/describe/bases.hpp>
19   #include <boost/mp11/algorithm.hpp> 19   #include <boost/mp11/algorithm.hpp>
20   #include <boost/mp11/utility.hpp> 20   #include <boost/mp11/utility.hpp>
21   #include <boost/system/result.hpp> 21   #include <boost/system/result.hpp>
22   22  
23   #include <iterator> 23   #include <iterator>
24   #include <tuple> 24   #include <tuple>
25   #include <utility> 25   #include <utility>
26   #ifndef BOOST_NO_CXX17_HDR_VARIANT 26   #ifndef BOOST_NO_CXX17_HDR_VARIANT
27   # include <variant> 27   # include <variant>
28   #endif // BOOST_NO_CXX17_HDR_VARIANT 28   #endif // BOOST_NO_CXX17_HDR_VARIANT
29   29  
30   namespace boost { 30   namespace boost {
31   namespace json { 31   namespace json {
32   32  
33   class value_ref; 33   class value_ref;
34   34  
35   namespace detail { 35   namespace detail {
36   36  
37   #ifdef __cpp_lib_nonmember_container_access 37   #ifdef __cpp_lib_nonmember_container_access
38   using std::size; 38   using std::size;
39   #endif 39   #endif
40   40  
41   template<std::size_t I, class T> 41   template<std::size_t I, class T>
42   using tuple_element_t = typename std::tuple_element<I, T>::type; 42   using tuple_element_t = typename std::tuple_element<I, T>::type;
43   43  
44   template<class T> 44   template<class T>
45   using iterator_type = decltype(std::begin(std::declval<T&>())); 45   using iterator_type = decltype(std::begin(std::declval<T&>()));
46   template<class T> 46   template<class T>
47   using iterator_traits = std::iterator_traits< iterator_type<T> >; 47   using iterator_traits = std::iterator_traits< iterator_type<T> >;
48   48  
49   template<class T> 49   template<class T>
50   using value_type = typename iterator_traits<T>::value_type; 50   using value_type = typename iterator_traits<T>::value_type;
51   template<class T> 51   template<class T>
52   using mapped_type = tuple_element_t< 1, value_type<T> >; 52   using mapped_type = tuple_element_t< 1, value_type<T> >;
53   53  
54   // had to make the metafunction always succeeding in order to make it work 54   // had to make the metafunction always succeeding in order to make it work
55   // with msvc 14.0 55   // with msvc 14.0
56   template<class T> 56   template<class T>
57   using key_type_helper = tuple_element_t< 0, value_type<T> >; 57   using key_type_helper = tuple_element_t< 0, value_type<T> >;
58   template<class T> 58   template<class T>
59   using key_type = mp11::mp_eval_or< 59   using key_type = mp11::mp_eval_or<
60   void, 60   void,
61   key_type_helper, 61   key_type_helper,
62   T>; 62   T>;
63   63  
64   template<class T> 64   template<class T>
65   using are_begin_and_end_same = std::is_same< 65   using are_begin_and_end_same = std::is_same<
66   iterator_type<T>, 66   iterator_type<T>,
67   decltype(std::end(std::declval<T&>()))>; 67   decltype(std::end(std::declval<T&>()))>;
68   68  
69   // msvc 14.0 gets confused when std::is_same is used directly 69   // msvc 14.0 gets confused when std::is_same is used directly
70   template<class A, class B> 70   template<class A, class B>
71   using is_same_msvc_140 = std::is_same<A, B>; 71   using is_same_msvc_140 = std::is_same<A, B>;
72   template<class T> 72   template<class T>
73   using is_its_own_value = is_same_msvc_140<value_type<T>, T>; 73   using is_its_own_value = is_same_msvc_140<value_type<T>, T>;
74   74  
75   template<class T> 75   template<class T>
76   using not_its_own_value = mp11::mp_not< is_its_own_value<T> >; 76   using not_its_own_value = mp11::mp_not< is_its_own_value<T> >;
77   77  
78   template<class T> 78   template<class T>
79   using begin_iterator_category = typename std::iterator_traits< 79   using begin_iterator_category = typename std::iterator_traits<
80   iterator_type<T>>::iterator_category; 80   iterator_type<T>>::iterator_category;
81   81  
82   template<class T> 82   template<class T>
83   using has_positive_tuple_size = mp11::mp_bool< 83   using has_positive_tuple_size = mp11::mp_bool<
84   (std::tuple_size<T>::value > 0) >; 84   (std::tuple_size<T>::value > 0) >;
85   85  
86   template<class T> 86   template<class T>
87   using has_unique_keys = has_positive_tuple_size<decltype( 87   using has_unique_keys = has_positive_tuple_size<decltype(
88   std::declval<T&>().emplace( 88   std::declval<T&>().emplace(
89   std::declval<value_type<T>>()))>; 89   std::declval<value_type<T>>()))>;
90   90  
91   template<class T> 91   template<class T>
92   using has_string_type = std::is_same< 92   using has_string_type = std::is_same<
93   typename T::string_type, std::basic_string<typename T::value_type> >; 93   typename T::string_type, std::basic_string<typename T::value_type> >;
94   94  
95   template<class T> 95   template<class T>
96   struct is_value_type_pair_helper : std::false_type 96   struct is_value_type_pair_helper : std::false_type
97   { }; 97   { };
98   template<class T1, class T2> 98   template<class T1, class T2>
99   struct is_value_type_pair_helper<std::pair<T1, T2>> : std::true_type 99   struct is_value_type_pair_helper<std::pair<T1, T2>> : std::true_type
100   { }; 100   { };
101   template<class T> 101   template<class T>
102   using is_value_type_pair = is_value_type_pair_helper<value_type<T>>; 102   using is_value_type_pair = is_value_type_pair_helper<value_type<T>>;
103   103  
104   template<class T> 104   template<class T>
105   using has_size_member_helper 105   using has_size_member_helper
106   = std::is_convertible<decltype(std::declval<T&>().size()), std::size_t>; 106   = std::is_convertible<decltype(std::declval<T&>().size()), std::size_t>;
107   template<class T> 107   template<class T>
108   using has_size_member = mp11::mp_valid_and_true<has_size_member_helper, T>; 108   using has_size_member = mp11::mp_valid_and_true<has_size_member_helper, T>;
109   template<class T> 109   template<class T>
110   using has_free_size_helper 110   using has_free_size_helper
111   = std::is_convertible< 111   = std::is_convertible<
112   decltype(size(std::declval<T const&>())), 112   decltype(size(std::declval<T const&>())),
113   std::size_t>; 113   std::size_t>;
114   template<class T> 114   template<class T>
115   using has_free_size = mp11::mp_valid_and_true<has_free_size_helper, T>; 115   using has_free_size = mp11::mp_valid_and_true<has_free_size_helper, T>;
116   template<class T> 116   template<class T>
117   using size_implementation = mp11::mp_cond< 117   using size_implementation = mp11::mp_cond<
118   has_size_member<T>, mp11::mp_int<3>, 118   has_size_member<T>, mp11::mp_int<3>,
119   has_free_size<T>, mp11::mp_int<2>, 119   has_free_size<T>, mp11::mp_int<2>,
120   std::is_array<T>, mp11::mp_int<1>, 120   std::is_array<T>, mp11::mp_int<1>,
121   mp11::mp_true, mp11::mp_int<0>>; 121   mp11::mp_true, mp11::mp_int<0>>;
122   122  
123   template<class T> 123   template<class T>
124   std::size_t 124   std::size_t
HITCBC 125   141 try_size(T&& cont, mp11::mp_int<3>) 125   141 try_size(T&& cont, mp11::mp_int<3>)
126   { 126   {
HITCBC 127   141 return cont.size(); 127   141 return cont.size();
128   } 128   }
129   129  
130   template<class T> 130   template<class T>
131   std::size_t 131   std::size_t
HITCBC 132   1 try_size(T& cont, mp11::mp_int<2>) 132   1 try_size(T& cont, mp11::mp_int<2>)
133   { 133   {
HITCBC 134   1 return size(cont); 134   1 return size(cont);
135   } 135   }
136   136  
137   template<class T, std::size_t N> 137   template<class T, std::size_t N>
138   std::size_t 138   std::size_t
HITCBC 139   1 try_size(T(&)[N], mp11::mp_int<1>) 139   1 try_size(T(&)[N], mp11::mp_int<1>)
140   { 140   {
HITCBC 141   1 return N; 141   1 return N;
142   } 142   }
143   143  
144   template<class T> 144   template<class T>
145   std::size_t 145   std::size_t
HITCBC 146   7 try_size(T&, mp11::mp_int<0>) 146   7 try_size(T&, mp11::mp_int<0>)
147   { 147   {
HITCBC 148   7 return 0; 148   7 return 0;
149   } 149   }
150   150  
151   template<class T> 151   template<class T>
152   using has_push_back_helper 152   using has_push_back_helper
153   = decltype(std::declval<T&>().push_back(std::declval<value_type<T>>())); 153   = decltype(std::declval<T&>().push_back(std::declval<value_type<T>>()));
154   template<class T> 154   template<class T>
155   using has_push_back = mp11::mp_valid<has_push_back_helper, T>; 155   using has_push_back = mp11::mp_valid<has_push_back_helper, T>;
156   template<class T> 156   template<class T>
157   using inserter_implementation = mp11::mp_cond< 157   using inserter_implementation = mp11::mp_cond<
158   is_tuple_like<T>, mp11::mp_int<2>, 158   is_tuple_like<T>, mp11::mp_int<2>,
159   has_push_back<T>, mp11::mp_int<1>, 159   has_push_back<T>, mp11::mp_int<1>,
160   mp11::mp_true, mp11::mp_int<0>>; 160   mp11::mp_true, mp11::mp_int<0>>;
161   161  
162   template<class T> 162   template<class T>
163   iterator_type<T> 163   iterator_type<T>
HITCBC 164   56 inserter( 164   56 inserter(
165   T& target, 165   T& target,
166   mp11::mp_int<2>) 166   mp11::mp_int<2>)
167   { 167   {
HITCBC 168   56 return target.begin(); 168   56 return target.begin();
169   } 169   }
170   170  
171   template<class T> 171   template<class T>
172   std::back_insert_iterator<T> 172   std::back_insert_iterator<T>
HITCBC 173   569 inserter( 173   569 inserter(
174   T& target, 174   T& target,
175   mp11::mp_int<1>) 175   mp11::mp_int<1>)
176   { 176   {
HITCBC 177   569 return std::back_inserter(target); 177   569 return std::back_inserter(target);
178   } 178   }
179   179  
180   template<class T> 180   template<class T>
181   std::insert_iterator<T> 181   std::insert_iterator<T>
HITCBC 182   62 inserter( 182   62 inserter(
183   T& target, 183   T& target,
184   mp11::mp_int<0>) 184   mp11::mp_int<0>)
185   { 185   {
HITCBC 186   62 return std::inserter( target, target.end() ); 186   62 return std::inserter( target, target.end() );
187   } 187   }
188   188  
189   using value_from_conversion = mp11::mp_true; 189   using value_from_conversion = mp11::mp_true;
190   using value_to_conversion = mp11::mp_false; 190   using value_to_conversion = mp11::mp_false;
191   191  
192   struct user_conversion_tag { }; 192   struct user_conversion_tag { };
193   struct context_conversion_tag : user_conversion_tag { }; 193   struct context_conversion_tag : user_conversion_tag { };
194   struct full_context_conversion_tag : context_conversion_tag { }; 194   struct full_context_conversion_tag : context_conversion_tag { };
195   struct native_conversion_tag { }; 195   struct native_conversion_tag { };
196   struct value_conversion_tag : native_conversion_tag { }; 196   struct value_conversion_tag : native_conversion_tag { };
197   struct object_conversion_tag : native_conversion_tag { }; 197   struct object_conversion_tag : native_conversion_tag { };
198   struct array_conversion_tag : native_conversion_tag { }; 198   struct array_conversion_tag : native_conversion_tag { };
199   struct string_conversion_tag : native_conversion_tag { }; 199   struct string_conversion_tag : native_conversion_tag { };
200   struct bool_conversion_tag : native_conversion_tag { }; 200   struct bool_conversion_tag : native_conversion_tag { };
201   struct value_ref_tag : native_conversion_tag { }; 201   struct value_ref_tag : native_conversion_tag { };
202   struct number_conversion_tag : native_conversion_tag { }; 202   struct number_conversion_tag : native_conversion_tag { };
203   struct integral_conversion_tag : number_conversion_tag { }; 203   struct integral_conversion_tag : number_conversion_tag { };
204   struct floating_point_conversion_tag : number_conversion_tag { }; 204   struct floating_point_conversion_tag : number_conversion_tag { };
205   struct null_like_conversion_tag { }; 205   struct null_like_conversion_tag { };
206   struct string_like_conversion_tag { }; 206   struct string_like_conversion_tag { };
207   struct map_like_conversion_tag { }; 207   struct map_like_conversion_tag { };
208   struct path_conversion_tag { }; 208   struct path_conversion_tag { };
209   struct sequence_conversion_tag { }; 209   struct sequence_conversion_tag { };
210   struct tuple_conversion_tag { }; 210   struct tuple_conversion_tag { };
211   struct described_class_conversion_tag { }; 211   struct described_class_conversion_tag { };
212   struct described_enum_conversion_tag { }; 212   struct described_enum_conversion_tag { };
213   struct variant_conversion_tag { }; 213   struct variant_conversion_tag { };
214   struct optional_conversion_tag { }; 214   struct optional_conversion_tag { };
215   struct no_conversion_tag { }; 215   struct no_conversion_tag { };
216   216  
217   template<class... Args> 217   template<class... Args>
218   using supports_tag_invoke = decltype(tag_invoke( std::declval<Args>()... )); 218   using supports_tag_invoke = decltype(tag_invoke( std::declval<Args>()... ));
219   219  
220   template<class T> 220   template<class T>
221   using has_user_conversion_from_impl = supports_tag_invoke< 221   using has_user_conversion_from_impl = supports_tag_invoke<
222   value_from_tag, value&, T&& >; 222   value_from_tag, value&, T&& >;
223   template<class T> 223   template<class T>
224   using has_user_conversion_to_impl = supports_tag_invoke< 224   using has_user_conversion_to_impl = supports_tag_invoke<
225   value_to_tag<T>, value const& >; 225   value_to_tag<T>, value const& >;
226   template<class T> 226   template<class T>
227   using has_nonthrowing_user_conversion_to_impl = supports_tag_invoke< 227   using has_nonthrowing_user_conversion_to_impl = supports_tag_invoke<
228   try_value_to_tag<T>, value const& >; 228   try_value_to_tag<T>, value const& >;
229   template< class T, class Dir > 229   template< class T, class Dir >
230   using has_user_conversion1 = mp11::mp_if< 230   using has_user_conversion1 = mp11::mp_if<
231   std::is_same<Dir, value_from_conversion>, 231   std::is_same<Dir, value_from_conversion>,
232   mp11::mp_valid<has_user_conversion_from_impl, T>, 232   mp11::mp_valid<has_user_conversion_from_impl, T>,
233   mp11::mp_or< 233   mp11::mp_or<
234   mp11::mp_valid<has_user_conversion_to_impl, T>, 234   mp11::mp_valid<has_user_conversion_to_impl, T>,
235   mp11::mp_valid<has_nonthrowing_user_conversion_to_impl, T>>>; 235   mp11::mp_valid<has_nonthrowing_user_conversion_to_impl, T>>>;
236   236  
237   template< class Ctx, class T > 237   template< class Ctx, class T >
238   using has_context_conversion_from_impl = supports_tag_invoke< 238   using has_context_conversion_from_impl = supports_tag_invoke<
239   value_from_tag, value&, T&&, Ctx const& >; 239   value_from_tag, value&, T&&, Ctx const& >;
240   template< class Ctx, class T > 240   template< class Ctx, class T >
241   using has_context_conversion_to_impl = supports_tag_invoke< 241   using has_context_conversion_to_impl = supports_tag_invoke<
242   value_to_tag<T>, value const&, Ctx const& >; 242   value_to_tag<T>, value const&, Ctx const& >;
243   template< class Ctx, class T > 243   template< class Ctx, class T >
244   using has_nonthrowing_context_conversion_to_impl = supports_tag_invoke< 244   using has_nonthrowing_context_conversion_to_impl = supports_tag_invoke<
245   try_value_to_tag<T>, value const&, Ctx const& >; 245   try_value_to_tag<T>, value const&, Ctx const& >;
246   template< class Ctx, class T, class Dir > 246   template< class Ctx, class T, class Dir >
247   using has_user_conversion2 = mp11::mp_if< 247   using has_user_conversion2 = mp11::mp_if<
248   std::is_same<Dir, value_from_conversion>, 248   std::is_same<Dir, value_from_conversion>,
249   mp11::mp_valid<has_context_conversion_from_impl, Ctx, T>, 249   mp11::mp_valid<has_context_conversion_from_impl, Ctx, T>,
250   mp11::mp_or< 250   mp11::mp_or<
251   mp11::mp_valid<has_context_conversion_to_impl, Ctx, T>, 251   mp11::mp_valid<has_context_conversion_to_impl, Ctx, T>,
252   mp11::mp_valid<has_nonthrowing_context_conversion_to_impl, Ctx, T>>>; 252   mp11::mp_valid<has_nonthrowing_context_conversion_to_impl, Ctx, T>>>;
253   253  
254   template< class Ctx, class T > 254   template< class Ctx, class T >
255   using has_full_context_conversion_from_impl = supports_tag_invoke< 255   using has_full_context_conversion_from_impl = supports_tag_invoke<
256   value_from_tag, value&, T&&, Ctx const&, Ctx const& >; 256   value_from_tag, value&, T&&, Ctx const&, Ctx const& >;
257   template< class Ctx, class T > 257   template< class Ctx, class T >
258   using has_full_context_conversion_to_impl = supports_tag_invoke< 258   using has_full_context_conversion_to_impl = supports_tag_invoke<
259   value_to_tag<T>, value const&, Ctx const&, Ctx const& >; 259   value_to_tag<T>, value const&, Ctx const&, Ctx const& >;
260   template< class Ctx, class T > 260   template< class Ctx, class T >
261   using has_nonthrowing_full_context_conversion_to_impl = supports_tag_invoke< 261   using has_nonthrowing_full_context_conversion_to_impl = supports_tag_invoke<
262   try_value_to_tag<T>, value const&, Ctx const&, Ctx const& >; 262   try_value_to_tag<T>, value const&, Ctx const&, Ctx const& >;
263   template< class Ctx, class T, class Dir > 263   template< class Ctx, class T, class Dir >
264   using has_user_conversion3 = mp11::mp_if< 264   using has_user_conversion3 = mp11::mp_if<
265   std::is_same<Dir, value_from_conversion>, 265   std::is_same<Dir, value_from_conversion>,
266   mp11::mp_valid<has_full_context_conversion_from_impl, Ctx, T>, 266   mp11::mp_valid<has_full_context_conversion_from_impl, Ctx, T>,
267   mp11::mp_or< 267   mp11::mp_or<
268   mp11::mp_valid<has_full_context_conversion_to_impl, Ctx, T>, 268   mp11::mp_valid<has_full_context_conversion_to_impl, Ctx, T>,
269   mp11::mp_valid< 269   mp11::mp_valid<
270   has_nonthrowing_full_context_conversion_to_impl, Ctx, T>>>; 270   has_nonthrowing_full_context_conversion_to_impl, Ctx, T>>>;
271   271  
272   template< class T > 272   template< class T >
273   using described_non_public_members = describe::describe_members< 273   using described_non_public_members = describe::describe_members<
274   T, 274   T,
275   describe::mod_private 275   describe::mod_private
276   | describe::mod_protected 276   | describe::mod_protected
277   | boost::describe::mod_inherited>; 277   | boost::describe::mod_inherited>;
278   278  
279   #if defined(BOOST_MSVC) && BOOST_MSVC < 1920 279   #if defined(BOOST_MSVC) && BOOST_MSVC < 1920
280   280  
281   template< class T > 281   template< class T >
282   struct described_member_t_impl; 282   struct described_member_t_impl;
283   283  
284   template< class T, class C > 284   template< class T, class C >
285   struct described_member_t_impl<T C::*> 285   struct described_member_t_impl<T C::*>
286   { 286   {
287   using type = T; 287   using type = T;
288   }; 288   };
289   289  
290   template< class T, class D > 290   template< class T, class D >
291   using described_member_t = remove_cvref< 291   using described_member_t = remove_cvref<
292   typename described_member_t_impl< 292   typename described_member_t_impl<
293   remove_cvref<decltype(D::pointer)> >::type>; 293   remove_cvref<decltype(D::pointer)> >::type>;
294   294  
295   #else 295   #else
296   296  
297   template< class T, class D > 297   template< class T, class D >
298   using described_member_t = remove_cvref<decltype( 298   using described_member_t = remove_cvref<decltype(
299   std::declval<T&>().* D::pointer )>; 299   std::declval<T&>().* D::pointer )>;
300   300  
301   #endif 301   #endif
302   302  
303   template< class T > 303   template< class T >
304   using described_members = describe::describe_members< 304   using described_members = describe::describe_members<
305   T, describe::mod_any_access | describe::mod_inherited>; 305   T, describe::mod_any_access | describe::mod_inherited>;
306   306  
307   #ifdef BOOST_DESCRIBE_CXX14 307   #ifdef BOOST_DESCRIBE_CXX14
308   308  
309   constexpr 309   constexpr
310   bool 310   bool
311   compare_strings(char const* l, char const* r) 311   compare_strings(char const* l, char const* r)
312   { 312   {
313   #if defined(_MSC_VER) && (_MSC_VER <= 1900) && !defined(__clang__) 313   #if defined(_MSC_VER) && (_MSC_VER <= 1900) && !defined(__clang__)
314   return *l == *r && ( (*l == 0) | compare_strings(l + 1, r + 1) ); 314   return *l == *r && ( (*l == 0) | compare_strings(l + 1, r + 1) );
315   #else 315   #else
316   do 316   do
317   { 317   {
318   if( *l != *r ) 318   if( *l != *r )
319   return false; 319   return false;
320   if( *l == 0 ) 320   if( *l == 0 )
321   return true; 321   return true;
322   ++l; 322   ++l;
323   ++r; 323   ++r;
324   } while(true); 324   } while(true);
325   #endif 325   #endif
326   } 326   }
327   327  
328   template< class L, class R > 328   template< class L, class R >
329   struct equal_member_names 329   struct equal_member_names
330   : mp11::mp_bool< compare_strings(L::name, R::name) > 330   : mp11::mp_bool< compare_strings(L::name, R::name) >
331   {}; 331   {};
332   332  
333   template< class T > 333   template< class T >
334   using uniquely_named_members = mp11::mp_same< 334   using uniquely_named_members = mp11::mp_same<
335   mp11::mp_unique_if< described_members<T>, equal_member_names >, 335   mp11::mp_unique_if< described_members<T>, equal_member_names >,
336   described_members<T> >; 336   described_members<T> >;
337   337  
338   #else 338   #else
339   339  
340   // we only check this in C++14, but the template should exist nevertheless 340   // we only check this in C++14, but the template should exist nevertheless
341   template< class T > 341   template< class T >
342   using uniquely_named_members = std::true_type; 342   using uniquely_named_members = std::true_type;
343   343  
344   #endif // BOOST_DESCRIBE_CXX14 344   #endif // BOOST_DESCRIBE_CXX14
345   345  
346   // user conversion (via tag_invoke) 346   // user conversion (via tag_invoke)
347   template< class Ctx, class T, class Dir > 347   template< class Ctx, class T, class Dir >
348   using user_conversion_category = mp11::mp_cond< 348   using user_conversion_category = mp11::mp_cond<
349   has_user_conversion3<Ctx, T, Dir>, full_context_conversion_tag, 349   has_user_conversion3<Ctx, T, Dir>, full_context_conversion_tag,
350   has_user_conversion2<Ctx, T, Dir>, context_conversion_tag, 350   has_user_conversion2<Ctx, T, Dir>, context_conversion_tag,
351   has_user_conversion1<T, Dir>, user_conversion_tag>; 351   has_user_conversion1<T, Dir>, user_conversion_tag>;
352   352  
353   // native conversions (constructors and member functions of value) 353   // native conversions (constructors and member functions of value)
354   template< class T > 354   template< class T >
355   using native_conversion_category = mp11::mp_cond< 355   using native_conversion_category = mp11::mp_cond<
356   std::is_same<T, value>, value_conversion_tag, 356   std::is_same<T, value>, value_conversion_tag,
357   std::is_same<T, array>, array_conversion_tag, 357   std::is_same<T, array>, array_conversion_tag,
358   std::is_same<T, object>, object_conversion_tag, 358   std::is_same<T, object>, object_conversion_tag,
359   std::is_same<T, string>, string_conversion_tag>; 359   std::is_same<T, string>, string_conversion_tag>;
360   360  
361   // generic conversions 361   // generic conversions
362   template< class T > 362   template< class T >
363   using generic_conversion_category = mp11::mp_cond< 363   using generic_conversion_category = mp11::mp_cond<
364   // std::is_same<T,std::initializer_list<value_ref>>, init_list_tag, 364   // std::is_same<T,std::initializer_list<value_ref>>, init_list_tag,
365   std::is_same<T, value_ref>, value_ref_tag, 365   std::is_same<T, value_ref>, value_ref_tag,
366   366  
367   std::is_same<T, bool>, bool_conversion_tag, 367   std::is_same<T, bool>, bool_conversion_tag,
368   std::is_integral<T>, integral_conversion_tag, 368   std::is_integral<T>, integral_conversion_tag,
369   std::is_floating_point<T>, floating_point_conversion_tag, 369   std::is_floating_point<T>, floating_point_conversion_tag,
370   is_null_like<T>, null_like_conversion_tag, 370   is_null_like<T>, null_like_conversion_tag,
371   is_string_like<T>, string_like_conversion_tag, 371   is_string_like<T>, string_like_conversion_tag,
372   is_variant_like<T>, variant_conversion_tag, 372   is_variant_like<T>, variant_conversion_tag,
373   is_optional_like<T>, optional_conversion_tag, 373   is_optional_like<T>, optional_conversion_tag,
374   is_map_like<T>, map_like_conversion_tag, 374   is_map_like<T>, map_like_conversion_tag,
375   is_sequence_like<T>, sequence_conversion_tag, 375   is_sequence_like<T>, sequence_conversion_tag,
376   is_tuple_like<T>, tuple_conversion_tag, 376   is_tuple_like<T>, tuple_conversion_tag,
377   is_described_class<T>, described_class_conversion_tag, 377   is_described_class<T>, described_class_conversion_tag,
378   is_described_enum<T>, described_enum_conversion_tag, 378   is_described_enum<T>, described_enum_conversion_tag,
379   is_path_like<T>, path_conversion_tag, 379   is_path_like<T>, path_conversion_tag,
380   // failed to find a suitable implementation 380   // failed to find a suitable implementation
381   mp11::mp_true, no_conversion_tag>; 381   mp11::mp_true, no_conversion_tag>;
382   382  
383   template< class T > 383   template< class T >
384   using nested_type = typename T::type; 384   using nested_type = typename T::type;
385   template< class T1, class T2 > 385   template< class T1, class T2 >
386   using conversion_category_impl_helper = mp11::mp_eval_if_not< 386   using conversion_category_impl_helper = mp11::mp_eval_if_not<
387   std::is_same<detail::no_conversion_tag, T1>, 387   std::is_same<detail::no_conversion_tag, T1>,
388   T1, 388   T1,
389   mp11::mp_eval_or_q, T1, mp11::mp_quote<nested_type>, T2>; 389   mp11::mp_eval_or_q, T1, mp11::mp_quote<nested_type>, T2>;
390   template< class Ctx, class T, class Dir > 390   template< class Ctx, class T, class Dir >
391   struct conversion_category_impl 391   struct conversion_category_impl
392   { 392   {
393   using type = mp11::mp_fold< 393   using type = mp11::mp_fold<
394   mp11::mp_list< 394   mp11::mp_list<
395   mp11::mp_defer<user_conversion_category, Ctx, T, Dir>, 395   mp11::mp_defer<user_conversion_category, Ctx, T, Dir>,
396   mp11::mp_defer<native_conversion_category, T>, 396   mp11::mp_defer<native_conversion_category, T>,
397   mp11::mp_defer<generic_conversion_category, T>>, 397   mp11::mp_defer<generic_conversion_category, T>>,
398   no_conversion_tag, 398   no_conversion_tag,
399   conversion_category_impl_helper>; 399   conversion_category_impl_helper>;
400   }; 400   };
401   template< class Ctx, class T, class Dir > 401   template< class Ctx, class T, class Dir >
402   using conversion_category = 402   using conversion_category =
403   typename conversion_category_impl< Ctx, T, Dir >::type; 403   typename conversion_category_impl< Ctx, T, Dir >::type;
404   404  
405   template< class T > 405   template< class T >
406   using any_conversion_tag = mp11::mp_not< 406   using any_conversion_tag = mp11::mp_not<
407   std::is_same< T, no_conversion_tag > >; 407   std::is_same< T, no_conversion_tag > >;
408   408  
409   template< class T, class Dir, class... Ctxs > 409   template< class T, class Dir, class... Ctxs >
410   struct conversion_category_impl< std::tuple<Ctxs...>, T, Dir > 410   struct conversion_category_impl< std::tuple<Ctxs...>, T, Dir >
411   { 411   {
412   using ctxs = mp11::mp_list< remove_cvref<Ctxs>... >; 412   using ctxs = mp11::mp_list< remove_cvref<Ctxs>... >;
413   using cats = mp11::mp_list< 413   using cats = mp11::mp_list<
414   conversion_category<remove_cvref<Ctxs>, T, Dir>... >; 414   conversion_category<remove_cvref<Ctxs>, T, Dir>... >;
415   415  
416   template< class I > 416   template< class I >
417   using exists = mp11::mp_less< I, mp11::mp_size<cats> >; 417   using exists = mp11::mp_less< I, mp11::mp_size<cats> >;
418   418  
419   using context2 = mp11::mp_find< cats, full_context_conversion_tag >; 419   using context2 = mp11::mp_find< cats, full_context_conversion_tag >;
420   using context1 = mp11::mp_find< cats, context_conversion_tag >; 420   using context1 = mp11::mp_find< cats, context_conversion_tag >;
421   using context0 = mp11::mp_find< cats, user_conversion_tag >; 421   using context0 = mp11::mp_find< cats, user_conversion_tag >;
422   using index = mp11::mp_cond< 422   using index = mp11::mp_cond<
423   exists<context2>, context2, 423   exists<context2>, context2,
424   exists<context1>, context1, 424   exists<context1>, context1,
425   exists<context0>, context0, 425   exists<context0>, context0,
426   mp11::mp_true, mp11::mp_find_if< cats, any_conversion_tag > >; 426   mp11::mp_true, mp11::mp_find_if< cats, any_conversion_tag > >;
427   using type = mp11::mp_eval_or< 427   using type = mp11::mp_eval_or<
428   no_conversion_tag, 428   no_conversion_tag,
429   mp11::mp_at, cats, index >; 429   mp11::mp_at, cats, index >;
430   }; 430   };
431   431  
432   struct no_context 432   struct no_context
433   {}; 433   {};
434   434  
435   template <class T, class Dir> 435   template <class T, class Dir>
436   using can_convert = mp11::mp_not< 436   using can_convert = mp11::mp_not<
437   std::is_same< 437   std::is_same<
438   detail::conversion_category<no_context, T, Dir>, 438   detail::conversion_category<no_context, T, Dir>,
439   detail::no_conversion_tag>>; 439   detail::no_conversion_tag>>;
440   440  
441   template<class Impl1, class Impl2> 441   template<class Impl1, class Impl2>
442   using conversion_round_trips_helper = mp11::mp_or< 442   using conversion_round_trips_helper = mp11::mp_or<
443   std::is_same<Impl1, Impl2>, 443   std::is_same<Impl1, Impl2>,
444   std::is_base_of<user_conversion_tag, Impl1>, 444   std::is_base_of<user_conversion_tag, Impl1>,
445   std::is_base_of<user_conversion_tag, Impl2>>; 445   std::is_base_of<user_conversion_tag, Impl2>>;
446   template< class Ctx, class T, class Dir > 446   template< class Ctx, class T, class Dir >
447   using conversion_round_trips = conversion_round_trips_helper< 447   using conversion_round_trips = conversion_round_trips_helper<
448   conversion_category<Ctx, T, Dir>, 448   conversion_category<Ctx, T, Dir>,
449   conversion_category<Ctx, T, mp11::mp_not<Dir>>>; 449   conversion_category<Ctx, T, mp11::mp_not<Dir>>>;
450   450  
451   template< class T1, class T2 > 451   template< class T1, class T2 >
452   struct copy_cref_helper 452   struct copy_cref_helper
453   { 453   {
454   using type = remove_cvref<T2>; 454   using type = remove_cvref<T2>;
455   }; 455   };
456   template< class T1, class T2 > 456   template< class T1, class T2 >
457   using copy_cref = typename copy_cref_helper< T1, T2 >::type; 457   using copy_cref = typename copy_cref_helper< T1, T2 >::type;
458   458  
459   template< class T1, class T2 > 459   template< class T1, class T2 >
460   struct copy_cref_helper<T1 const, T2> 460   struct copy_cref_helper<T1 const, T2>
461   { 461   {
462   using type = remove_cvref<T2> const; 462   using type = remove_cvref<T2> const;
463   }; 463   };
464   template< class T1, class T2 > 464   template< class T1, class T2 >
465   struct copy_cref_helper<T1&, T2> 465   struct copy_cref_helper<T1&, T2>
466   { 466   {
467   using type = copy_cref<T1, T2>&; 467   using type = copy_cref<T1, T2>&;
468   }; 468   };
469   template< class T1, class T2 > 469   template< class T1, class T2 >
470   struct copy_cref_helper<T1&&, T2> 470   struct copy_cref_helper<T1&&, T2>
471   { 471   {
472   using type = copy_cref<T1, T2>&&; 472   using type = copy_cref<T1, T2>&&;
473   }; 473   };
474   474  
475   template< class Rng, class Traits > 475   template< class Rng, class Traits >
476   using forwarded_value_helper = mp11::mp_if< 476   using forwarded_value_helper = mp11::mp_if<
477   std::is_convertible< 477   std::is_convertible<
478   typename Traits::reference, 478   typename Traits::reference,
479   copy_cref<Rng, typename Traits::value_type> >, 479   copy_cref<Rng, typename Traits::value_type> >,
480   copy_cref<Rng, typename Traits::value_type>, 480   copy_cref<Rng, typename Traits::value_type>,
481   typename Traits::value_type >; 481   typename Traits::value_type >;
482   482  
483   template< class Rng > 483   template< class Rng >
484   using forwarded_value = forwarded_value_helper< 484   using forwarded_value = forwarded_value_helper<
485   Rng, iterator_traits< Rng > >; 485   Rng, iterator_traits< Rng > >;
486   486  
487   template< class Ctx, class T, class Dir > 487   template< class Ctx, class T, class Dir >
488   struct supported_context 488   struct supported_context
489   { 489   {
490   using type = Ctx; 490   using type = Ctx;
491   491  
492   static 492   static
493   type const& 493   type const&
HITCBC 494   32 get( Ctx const& ctx ) noexcept 494   32 get( Ctx const& ctx ) noexcept
495   { 495   {
HITCBC 496   32 return ctx; 496   32 return ctx;
497   } 497   }
498   }; 498   };
499   499  
500   template< class T, class Dir, class... Ctxs > 500   template< class T, class Dir, class... Ctxs >
501   struct supported_context< std::tuple<Ctxs...>, T, Dir > 501   struct supported_context< std::tuple<Ctxs...>, T, Dir >
502   { 502   {
503   using Ctx = std::tuple<Ctxs...>; 503   using Ctx = std::tuple<Ctxs...>;
504   using impl = conversion_category_impl<Ctx, T, Dir>; 504   using impl = conversion_category_impl<Ctx, T, Dir>;
505   using index = typename impl::index; 505   using index = typename impl::index;
506   using next_supported = supported_context< 506   using next_supported = supported_context<
507   mp11::mp_at< typename impl::ctxs, index >, T, Dir >; 507   mp11::mp_at< typename impl::ctxs, index >, T, Dir >;
508   using type = typename next_supported::type; 508   using type = typename next_supported::type;
509   509  
510   static 510   static
511   type const& 511   type const&
HITCBC 512   19 get( Ctx const& ctx ) noexcept 512   19 get( Ctx const& ctx ) noexcept
513   { 513   {
HITCBC 514   19 return next_supported::get( std::get<index::value>( ctx ) ); 514   19 return next_supported::get( std::get<index::value>( ctx ) );
515   } 515   }
516   }; 516   };
517   517  
518   template< class T > 518   template< class T >
519   using value_result_type = typename std::decay< 519   using value_result_type = typename std::decay<
520   decltype( std::declval<T&>().value() )>::type; 520   decltype( std::declval<T&>().value() )>::type;
521   521  
522   template< class T > 522   template< class T >
523   using can_reset = decltype( std::declval<T&>().reset() ); 523   using can_reset = decltype( std::declval<T&>().reset() );
524   524  
525   template< class T > 525   template< class T >
526   using has_valueless_by_exception = 526   using has_valueless_by_exception =
527   decltype( std::declval<T const&>().valueless_by_exception() ); 527   decltype( std::declval<T const&>().valueless_by_exception() );
528   528  
529   } // namespace detail 529   } // namespace detail
530   530  
531   template <class T> 531   template <class T>
532   struct result_for<T, value> 532   struct result_for<T, value>
533   { 533   {
534   using type = system::result< detail::remove_cvref<T> >; 534   using type = system::result< detail::remove_cvref<T> >;
535   }; 535   };
536   536  
537   template<class T> 537   template<class T>
538   struct is_string_like 538   struct is_string_like
539   : std::is_convertible<T, string_view> 539   : std::is_convertible<T, string_view>
540   { }; 540   { };
541   541  
542   template<class T> 542   template<class T>
543   struct is_path_like 543   struct is_path_like
544   : mp11::mp_all< 544   : mp11::mp_all<
545   mp11::mp_valid_and_true<detail::is_its_own_value, T>, 545   mp11::mp_valid_and_true<detail::is_its_own_value, T>,
546   mp11::mp_valid_and_true<detail::has_string_type, T>> 546   mp11::mp_valid_and_true<detail::has_string_type, T>>
547   { }; 547   { };
548   template<class T> 548   template<class T>
549   struct is_sequence_like 549   struct is_sequence_like
550   : mp11::mp_all< 550   : mp11::mp_all<
551   mp11::mp_valid_and_true<detail::are_begin_and_end_same, T>, 551   mp11::mp_valid_and_true<detail::are_begin_and_end_same, T>,
552   mp11::mp_valid_and_true<detail::not_its_own_value, T>, 552   mp11::mp_valid_and_true<detail::not_its_own_value, T>,
553   mp11::mp_valid<detail::begin_iterator_category, T>> 553   mp11::mp_valid<detail::begin_iterator_category, T>>
554   { }; 554   { };
555   555  
556   template<class T> 556   template<class T>
557   struct is_map_like 557   struct is_map_like
558   : mp11::mp_all< 558   : mp11::mp_all<
559   is_sequence_like<T>, 559   is_sequence_like<T>,
560   mp11::mp_valid_and_true<detail::is_value_type_pair, T>, 560   mp11::mp_valid_and_true<detail::is_value_type_pair, T>,
561   is_string_like<detail::key_type<T>>, 561   is_string_like<detail::key_type<T>>,
562   mp11::mp_valid_and_true<detail::has_unique_keys, T>> 562   mp11::mp_valid_and_true<detail::has_unique_keys, T>>
563   { }; 563   { };
564   564  
565   template<class T> 565   template<class T>
566   struct is_tuple_like 566   struct is_tuple_like
567   : mp11::mp_valid_and_true<detail::has_positive_tuple_size, T> 567   : mp11::mp_valid_and_true<detail::has_positive_tuple_size, T>
568   { }; 568   { };
569   569  
570   template<> 570   template<>
571   struct is_null_like<std::nullptr_t> 571   struct is_null_like<std::nullptr_t>
572   : std::true_type 572   : std::true_type
573   { }; 573   { };
574   574  
575   #ifndef BOOST_NO_CXX17_HDR_VARIANT 575   #ifndef BOOST_NO_CXX17_HDR_VARIANT
576   template<> 576   template<>
577   struct is_null_like<std::monostate> 577   struct is_null_like<std::monostate>
578   : std::true_type 578   : std::true_type
579   { }; 579   { };
580   #endif // BOOST_NO_CXX17_HDR_VARIANT 580   #endif // BOOST_NO_CXX17_HDR_VARIANT
581   581  
582   template<class T> 582   template<class T>
583   struct is_described_class 583   struct is_described_class
584   : mp11::mp_and< 584   : mp11::mp_and<
585   describe::has_describe_members<T>, 585   describe::has_describe_members<T>,
586   mp11::mp_not< std::is_union<T> >, 586   mp11::mp_not< std::is_union<T> >,
587   mp11::mp_empty< 587   mp11::mp_empty<
588   mp11::mp_eval_or< 588   mp11::mp_eval_or<
589   mp11::mp_list<>, detail::described_non_public_members, T>>> 589   mp11::mp_list<>, detail::described_non_public_members, T>>>
590   { }; 590   { };
591   591  
592   template<class T> 592   template<class T>
593   struct is_described_enum 593   struct is_described_enum
594   : describe::has_describe_enumerators<T> 594   : describe::has_describe_enumerators<T>
595   { }; 595   { };
596   596  
597   template<class T> 597   template<class T>
598   struct is_variant_like : mp11::mp_valid<detail::has_valueless_by_exception, T> 598   struct is_variant_like : mp11::mp_valid<detail::has_valueless_by_exception, T>
599   { }; 599   { };
600   600  
601   template<class T> 601   template<class T>
602   struct is_optional_like 602   struct is_optional_like
603   : mp11::mp_and< 603   : mp11::mp_and<
604   mp11::mp_not<std::is_void< 604   mp11::mp_not<std::is_void<
605   mp11::mp_eval_or<void, detail::value_result_type, T>>>, 605   mp11::mp_eval_or<void, detail::value_result_type, T>>>,
606   mp11::mp_valid<detail::can_reset, T>> 606   mp11::mp_valid<detail::can_reset, T>>
607   { }; 607   { };
608   608  
609   } // namespace json 609   } // namespace json
610   } // namespace boost 610   } // namespace boost
611   611  
612   #endif // BOOST_JSON_IMPL_CONVERSION_HPP 612   #endif // BOOST_JSON_IMPL_CONVERSION_HPP