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