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