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