Diff coverage for include/boost/json/detail/value

1		`//`	1		`//`
2		`// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)`	2		`// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)`
3		`// Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)`	3		`// Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)`
4		`// Copyright (c) 2021 Dmitry Arkhipov (grisumbras@gmail.com)`	4		`// Copyright (c) 2021 Dmitry Arkhipov (grisumbras@gmail.com)`
5		`//`	5		`//`
6		`// Distributed under the Boost Software License, Version 1.0. (See accompanying`	6		`// Distributed under the Boost Software License, Version 1.0. (See accompanying`
7		`// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)`	7		`// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)`
8		`//`	8		`//`
9		`// Official repository: https://github.com/boostorg/json`	9		`// Official repository: https://github.com/boostorg/json`
10		`//`	10		`//`
11			11
12		`#ifndef BOOST_JSON_DETAIL_VALUE_TO_HPP`	12		`#ifndef BOOST_JSON_DETAIL_VALUE_TO_HPP`
13		`#define BOOST_JSON_DETAIL_VALUE_TO_HPP`	13		`#define BOOST_JSON_DETAIL_VALUE_TO_HPP`
14	-	`#include <boost/core/detail/static_assert.hpp>`
15			14
16		`#include <boost/json/value.hpp>`	15		`#include <boost/json/value.hpp>`
17		`#include <boost/json/conversion.hpp>`	16		`#include <boost/json/conversion.hpp>`
18		`#include <boost/json/result_for.hpp>`	17		`#include <boost/json/result_for.hpp>`
19		`#include <boost/describe/enum_from_string.hpp>`	18		`#include <boost/describe/enum_from_string.hpp>`
20			19
21		`#ifndef BOOST_NO_CXX17_HDR_OPTIONAL`	20		`#ifndef BOOST_NO_CXX17_HDR_OPTIONAL`
22		`# include <optional>`	21		`# include <optional>`
23		`#endif`	22		`#endif`
24			23
25		`namespace boost {`	24		`namespace boost {`
26		`namespace json {`	25		`namespace json {`
27			26
28		`namespace detail {`	27		`namespace detail {`
29			28
			29	+	`template< class Ctx, class T >`
			30	+	`using value_to_attrs = conversion_attrs<`
			31	+	`Ctx, remove_cvref<T>, value_to_conversion>;`
			32	+
30		`template<class T>`	33		`template<class T>`
31		`using has_reserve_member_helper = decltype(std::declval<T&>().reserve(0));`	34		`using has_reserve_member_helper = decltype(std::declval<T&>().reserve(0));`
32		`template<class T>`	35		`template<class T>`
33		`using has_reserve_member = mp11::mp_valid<has_reserve_member_helper, T>;`	36		`using has_reserve_member = mp11::mp_valid<has_reserve_member_helper, T>;`
34		`template<class T>`	37		`template<class T>`
35		`using reserve_implementation = mp11::mp_cond<`	38		`using reserve_implementation = mp11::mp_cond<`
36		`is_tuple_like<T>, mp11::mp_int<2>,`	39		`is_tuple_like<T>, mp11::mp_int<2>,`
37		`has_reserve_member<T>, mp11::mp_int<1>,`	40		`has_reserve_member<T>, mp11::mp_int<1>,`
38		`mp11::mp_true, mp11::mp_int<0>>;`	41		`mp11::mp_true, mp11::mp_int<0>>;`
39			42
40		`template<class T>`	43		`template<class T>`
41		`error`	44		`error`
42		`try_reserve(`	45		`try_reserve(`
43		`T&,`	46		`T&,`
44		`std::size_t size,`	47		`std::size_t size,`
45		`mp11::mp_int<2>)`	48		`mp11::mp_int<2>)`
46		`{`	49		`{`
47		`constexpr std::size_t N = std::tuple_size<remove_cvref<T>>::value;`	50		`constexpr std::size_t N = std::tuple_size<remove_cvref<T>>::value;`
48		`if ( N != size )`	51		`if ( N != size )`
49		`return error::size_mismatch;`	52		`return error::size_mismatch;`
50		`return error();`	53		`return error();`
51		`}`	54		`}`
52			55
53		`template<typename T>`	56		`template<typename T>`
54		`error`	57		`error`
55		`try_reserve(`	58		`try_reserve(`
56		`T& cont,`	59		`T& cont,`
57		`std::size_t size,`	60		`std::size_t size,`
58		`mp11::mp_int<1>)`	61		`mp11::mp_int<1>)`
59		`{`	62		`{`
60		`cont.reserve(size);`	63		`cont.reserve(size);`
61		`return error();`	64		`return error();`
62		`}`	65		`}`
63			66
64		`template<typename T>`	67		`template<typename T>`
65		`error`	68		`error`
66		`try_reserve(`	69		`try_reserve(`
67		`T&,`	70		`T&,`
68		`std::size_t,`	71		`std::size_t,`
69		`mp11::mp_int<0>)`	72		`mp11::mp_int<0>)`
70		`{`	73		`{`
71		`return error();`	74		`return error();`
72		`}`	75		`}`
73			76
74			77
75		`// identity conversion`	78		`// identity conversion`
76		`template< class Ctx >`	79		`template< class Ctx >`
77		`system::result<value>`	80		`system::result<value>`
78		`value_to_impl(`	81		`value_to_impl(`
79		`value_conversion_tag,`	82		`value_conversion_tag,`
80		`try_value_to_tag<value>,`	83		`try_value_to_tag<value>,`
81		`value const& jv,`	84		`value const& jv,`
82		`Ctx const& )`	85		`Ctx const& )`
83		`{`	86		`{`
84		`return jv;`	87		`return jv;`
85		`}`	88		`}`
86			89
87		`template< class Ctx >`	90		`template< class Ctx >`
88		`value`	91		`value`
89		`value_to_impl(`	92		`value_to_impl(`
90		`value_conversion_tag, value_to_tag<value>, value const& jv, Ctx const& )`	93		`value_conversion_tag, value_to_tag<value>, value const& jv, Ctx const& )`
91		`{`	94		`{`
92		`return jv;`	95		`return jv;`
93		`}`	96		`}`
94			97
95		`// object`	98		`// object`
96		`template< class Ctx >`	99		`template< class Ctx >`
97		`system::result<object>`	100		`system::result<object>`
98		`value_to_impl(`	101		`value_to_impl(`
99		`object_conversion_tag,`	102		`object_conversion_tag,`
100		`try_value_to_tag<object>,`	103		`try_value_to_tag<object>,`
101		`value const& jv,`	104		`value const& jv,`
102		`Ctx const& )`	105		`Ctx const& )`
103		`{`	106		`{`
104		`object const* obj = jv.if_object();`	107		`object const* obj = jv.if_object();`
105		`if( obj )`	108		`if( obj )`
106		`return *obj;`	109		`return *obj;`
107		`system::error_code ec;`	110		`system::error_code ec;`
108		`BOOST_JSON_FAIL(ec, error::not_object);`	111		`BOOST_JSON_FAIL(ec, error::not_object);`
109		`return ec;`	112		`return ec;`
110		`}`	113		`}`
111			114
112		`// array`	115		`// array`
113		`template< class Ctx >`	116		`template< class Ctx >`
114		`system::result<array>`	117		`system::result<array>`
115		`value_to_impl(`	118		`value_to_impl(`
116		`array_conversion_tag,`	119		`array_conversion_tag,`
117		`try_value_to_tag<array>,`	120		`try_value_to_tag<array>,`
118		`value const& jv,`	121		`value const& jv,`
119		`Ctx const& )`	122		`Ctx const& )`
120		`{`	123		`{`
121		`array const* arr = jv.if_array();`	124		`array const* arr = jv.if_array();`
122		`if( arr )`	125		`if( arr )`
123		`return *arr;`	126		`return *arr;`
124		`system::error_code ec;`	127		`system::error_code ec;`
125		`BOOST_JSON_FAIL(ec, error::not_array);`	128		`BOOST_JSON_FAIL(ec, error::not_array);`
126		`return ec;`	129		`return ec;`
127		`}`	130		`}`
128			131
129		`// string`	132		`// string`
130		`template< class Ctx >`	133		`template< class Ctx >`
131		`system::result<string>`	134		`system::result<string>`
132		`value_to_impl(`	135		`value_to_impl(`
133		`string_conversion_tag,`	136		`string_conversion_tag,`
134		`try_value_to_tag<string>,`	137		`try_value_to_tag<string>,`
135		`value const& jv,`	138		`value const& jv,`
136		`Ctx const& )`	139		`Ctx const& )`
137		`{`	140		`{`
138		`string const* str = jv.if_string();`	141		`string const* str = jv.if_string();`
139		`if( str )`	142		`if( str )`
140		`return *str;`	143		`return *str;`
141		`system::error_code ec;`	144		`system::error_code ec;`
142		`BOOST_JSON_FAIL(ec, error::not_string);`	145		`BOOST_JSON_FAIL(ec, error::not_string);`
143		`return ec;`	146		`return ec;`
144		`}`	147		`}`
145			148
146		`// bool`	149		`// bool`
147		`template< class Ctx >`	150		`template< class Ctx >`
148		`system::result<bool>`	151		`system::result<bool>`
149		`value_to_impl(`	152		`value_to_impl(`
150		`bool_conversion_tag, try_value_to_tag<bool>, value const& jv, Ctx const& )`	153		`bool_conversion_tag, try_value_to_tag<bool>, value const& jv, Ctx const& )`
151		`{`	154		`{`
152		`auto b = jv.if_bool();`	155		`auto b = jv.if_bool();`
153		`if( b )`	156		`if( b )`
154		`return *b;`	157		`return *b;`
155		`system::error_code ec;`	158		`system::error_code ec;`
156		`BOOST_JSON_FAIL(ec, error::not_bool);`	159		`BOOST_JSON_FAIL(ec, error::not_bool);`
157		`return {boost::system::in_place_error, ec};`	160		`return {boost::system::in_place_error, ec};`
158		`}`	161		`}`
159			162
160		`// integral and floating point`	163		`// integral and floating point`
161		`template< class T, class Ctx >`	164		`template< class T, class Ctx >`
162		`system::result<T>`	165		`system::result<T>`
163		`value_to_impl(`	166		`value_to_impl(`
164		`number_conversion_tag, try_value_to_tag<T>, value const& jv, Ctx const& )`	167		`number_conversion_tag, try_value_to_tag<T>, value const& jv, Ctx const& )`
165		`{`	168		`{`
166		`system::error_code ec;`	169		`system::error_code ec;`
167		`auto const n = jv.to_number<T>(ec);`	170		`auto const n = jv.to_number<T>(ec);`
168		`if( ec.failed() )`	171		`if( ec.failed() )`
169		`return {boost::system::in_place_error, ec};`	172		`return {boost::system::in_place_error, ec};`
170		`return {boost::system::in_place_value, n};`	173		`return {boost::system::in_place_value, n};`
171		`}`	174		`}`
172			175
173		`// null-like conversion`	176		`// null-like conversion`
174		`template< class T, class Ctx >`	177		`template< class T, class Ctx >`
175		`system::result<T>`	178		`system::result<T>`
176		`value_to_impl(`	179		`value_to_impl(`
177		`null_like_conversion_tag,`	180		`null_like_conversion_tag,`
178		`try_value_to_tag<T>,`	181		`try_value_to_tag<T>,`
179		`value const& jv,`	182		`value const& jv,`
180		`Ctx const& )`	183		`Ctx const& )`
181		`{`	184		`{`
182		`if( jv.is_null() )`	185		`if( jv.is_null() )`
183		`return {boost::system::in_place_value, T{}};`	186		`return {boost::system::in_place_value, T{}};`
184		`system::error_code ec;`	187		`system::error_code ec;`
185		`BOOST_JSON_FAIL(ec, error::not_null);`	188		`BOOST_JSON_FAIL(ec, error::not_null);`
186		`return {boost::system::in_place_error, ec};`	189		`return {boost::system::in_place_error, ec};`
187		`}`	190		`}`
188			191
189		`// string-like types`	192		`// string-like types`
190		`template< class T, class Ctx >`	193		`template< class T, class Ctx >`
191		`system::result<T>`	194		`system::result<T>`
192		`value_to_impl(`	195		`value_to_impl(`
193		`string_like_conversion_tag,`	196		`string_like_conversion_tag,`
194		`try_value_to_tag<T>,`	197		`try_value_to_tag<T>,`
195		`value const& jv,`	198		`value const& jv,`
196		`Ctx const& )`	199		`Ctx const& )`
197		`{`	200		`{`
198		`auto str = jv.if_string();`	201		`auto str = jv.if_string();`
199		`if( str )`	202		`if( str )`
200		`return {boost::system::in_place_value, T(str->subview())};`	203		`return {boost::system::in_place_value, T(str->subview())};`
201		`system::error_code ec;`	204		`system::error_code ec;`
202		`BOOST_JSON_FAIL(ec, error::not_string);`	205		`BOOST_JSON_FAIL(ec, error::not_string);`
203		`return {boost::system::in_place_error, ec};`	206		`return {boost::system::in_place_error, ec};`
204		`}`	207		`}`
205			208
206		`// map-like containers`	209		`// map-like containers`
207		`template< class T, class Ctx >`	210		`template< class T, class Ctx >`
208		`system::result<T>`	211		`system::result<T>`
209		`value_to_impl(`	212		`value_to_impl(`
210		`map_like_conversion_tag,`	213		`map_like_conversion_tag,`
211		`try_value_to_tag<T>,`	214		`try_value_to_tag<T>,`
212		`value const& jv,`	215		`value const& jv,`
213		`Ctx const& ctx )`	216		`Ctx const& ctx )`
214		`{`	217		`{`
215		`object const* obj = jv.if_object();`	218		`object const* obj = jv.if_object();`
216		`if( !obj )`	219		`if( !obj )`
217		`{`	220		`{`
218		`system::error_code ec;`	221		`system::error_code ec;`
219		`BOOST_JSON_FAIL(ec, error::not_object);`	222		`BOOST_JSON_FAIL(ec, error::not_object);`
220		`return {boost::system::in_place_error, ec};`	223		`return {boost::system::in_place_error, ec};`
221		`}`	224		`}`
222			225
223		`T res;`	226		`T res;`
224		`error const e = detail::try_reserve(`	227		`error const e = detail::try_reserve(`
225		`res, obj->size(), reserve_implementation<T>());`	228		`res, obj->size(), reserve_implementation<T>());`
226		`if( e != error() )`	229		`if( e != error() )`
227		`{`	230		`{`
228		`system::error_code ec;`	231		`system::error_code ec;`
229		`BOOST_JSON_FAIL( ec, e );`	232		`BOOST_JSON_FAIL( ec, e );`
230		`return {boost::system::in_place_error, ec};`	233		`return {boost::system::in_place_error, ec};`
231		`}`	234		`}`
232			235
233		`auto ins = detail::inserter(res, inserter_implementation<T>());`	236		`auto ins = detail::inserter(res, inserter_implementation<T>());`
234		`for( key_value_pair const& kv: *obj )`	237		`for( key_value_pair const& kv: *obj )`
235		`{`	238		`{`
			239	+	`using A = value_to_attrs< Ctx, key_type<T> >;`
			240	+	`using K = typename A::representation;`
236		`auto elem_res = try_value_to<mapped_type<T>>( kv.value(), ctx );`	241		`auto elem_res = try_value_to<mapped_type<T>>( kv.value(), ctx );`
237		`if( elem_res.has_error() )`	242		`if( elem_res.has_error() )`
238		`return {boost::system::in_place_error, elem_res.error()};`	243		`return {boost::system::in_place_error, elem_res.error()};`
239		`*ins++ = value_type<T>{`	244		`*ins++ = value_type<T>{`
240	-	`key_type<T>(kv.key()),`	245	+	`K(kv.key()),`
241		`std::move(*elem_res)};`	246		`std::move(*elem_res)};`
242		`}`	247		`}`
243		`return res;`	248		`return res;`
244		`}`	249		`}`
245			250
246		`// all other containers`	251		`// all other containers`
247		`template< class T, class Ctx >`	252		`template< class T, class Ctx >`
248		`system::result<T>`	253		`system::result<T>`
249		`value_to_impl(`	254		`value_to_impl(`
250		`sequence_conversion_tag,`	255		`sequence_conversion_tag,`
251		`try_value_to_tag<T>,`	256		`try_value_to_tag<T>,`
252		`value const& jv,`	257		`value const& jv,`
253		`Ctx const& ctx )`	258		`Ctx const& ctx )`
254		`{`	259		`{`
255		`array const* arr = jv.if_array();`	260		`array const* arr = jv.if_array();`
256		`if( !arr )`	261		`if( !arr )`
257		`{`	262		`{`
258		`system::error_code ec;`	263		`system::error_code ec;`
259		`BOOST_JSON_FAIL(ec, error::not_array);`	264		`BOOST_JSON_FAIL(ec, error::not_array);`
260		`return {boost::system::in_place_error, ec};`	265		`return {boost::system::in_place_error, ec};`
261		`}`	266		`}`
262			267
263		`T result;`	268		`T result;`
264		`error const e = detail::try_reserve(`	269		`error const e = detail::try_reserve(`
265		`result, arr->size(), reserve_implementation<T>());`	270		`result, arr->size(), reserve_implementation<T>());`
266		`if( e != error() )`	271		`if( e != error() )`
267		`{`	272		`{`
268		`system::error_code ec;`	273		`system::error_code ec;`
269		`BOOST_JSON_FAIL( ec, e );`	274		`BOOST_JSON_FAIL( ec, e );`
270		`return {boost::system::in_place_error, ec};`	275		`return {boost::system::in_place_error, ec};`
271		`}`	276		`}`
272			277
273		`auto ins = detail::inserter(result, inserter_implementation<T>());`	278		`auto ins = detail::inserter(result, inserter_implementation<T>());`
274		`for( value const& val: *arr )`	279		`for( value const& val: *arr )`
275		`{`	280		`{`
276		`auto elem_res = try_value_to<value_type<T>>( val, ctx );`	281		`auto elem_res = try_value_to<value_type<T>>( val, ctx );`
277		`if( elem_res.has_error() )`	282		`if( elem_res.has_error() )`
278		`return {boost::system::in_place_error, elem_res.error()};`	283		`return {boost::system::in_place_error, elem_res.error()};`
279		`ins++ = std::move(elem_res);`	284		`ins++ = std::move(elem_res);`
280		`}`	285		`}`
281		`return result;`	286		`return result;`
282		`}`	287		`}`
283			288
284		`// tuple-like types`	289		`// tuple-like types`
285		`template< class T, class Ctx >`	290		`template< class T, class Ctx >`
286		`system::result<T>`	291		`system::result<T>`
287		`try_make_tuple_elem(value const& jv, Ctx const& ctx, system::error_code& ec)`	292		`try_make_tuple_elem(value const& jv, Ctx const& ctx, system::error_code& ec)`
288		`{`	293		`{`
289		`if( ec.failed() )`	294		`if( ec.failed() )`
290		`return {boost::system::in_place_error, ec};`	295		`return {boost::system::in_place_error, ec};`
291			296
292		`auto result = try_value_to<T>( jv, ctx );`	297		`auto result = try_value_to<T>( jv, ctx );`
293		`ec = result.error();`	298		`ec = result.error();`
294		`return result;`	299		`return result;`
295		`}`	300		`}`
296			301
297		`template <class T, class Ctx, std::size_t... Is>`	302		`template <class T, class Ctx, std::size_t... Is>`
298		`system::result<T>`	303		`system::result<T>`
299		`try_make_tuple_like(`	304		`try_make_tuple_like(`
300		`array const& arr, Ctx const& ctx, boost::mp11::index_sequence<Is...>)`	305		`array const& arr, Ctx const& ctx, boost::mp11::index_sequence<Is...>)`
301		`{`	306		`{`
302		`system::error_code ec;`	307		`system::error_code ec;`
303		`auto items = std::make_tuple(`	308		`auto items = std::make_tuple(`
304		`try_make_tuple_elem<`	309		`try_make_tuple_elem<`
305		`typename std::decay<tuple_element_t<Is, T>>::type >(`	310		`typename std::decay<tuple_element_t<Is, T>>::type >(`
306		`arr[Is], ctx, ec)`	311		`arr[Is], ctx, ec)`
307		`...);`	312		`...);`
308		`#if defined(BOOST_GCC)`	313		`#if defined(BOOST_GCC)`
309		`# pragma GCC diagnostic push`	314		`# pragma GCC diagnostic push`
310		`# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"`	315		`# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"`
311		`#endif`	316		`#endif`
312		`if( ec.failed() )`	317		`if( ec.failed() )`
313		`return {boost::system::in_place_error, ec};`	318		`return {boost::system::in_place_error, ec};`
314		`#if defined(BOOST_GCC)`	319		`#if defined(BOOST_GCC)`
315		`# pragma GCC diagnostic pop`	320		`# pragma GCC diagnostic pop`
316		`#endif`	321		`#endif`
317			322
318		`return {`	323		`return {`
319		`boost::system::in_place_value, T(std::move(*std::get<Is>(items))...)};`	324		`boost::system::in_place_value, T(std::move(*std::get<Is>(items))...)};`
320		`}`	325		`}`
321			326
322		`template< class T, class Ctx >`	327		`template< class T, class Ctx >`
323		`system::result<T>`	328		`system::result<T>`
324		`value_to_impl(`	329		`value_to_impl(`
325		`tuple_conversion_tag,`	330		`tuple_conversion_tag,`
326		`try_value_to_tag<T>,`	331		`try_value_to_tag<T>,`
327		`value const& jv,`	332		`value const& jv,`
328		`Ctx const& ctx )`	333		`Ctx const& ctx )`
329		`{`	334		`{`
330		`system::error_code ec;`	335		`system::error_code ec;`
331			336
332		`array const* arr = jv.if_array();`	337		`array const* arr = jv.if_array();`
333		`if( !arr )`	338		`if( !arr )`
334		`{`	339		`{`
335		`BOOST_JSON_FAIL(ec, error::not_array);`	340		`BOOST_JSON_FAIL(ec, error::not_array);`
336		`return {boost::system::in_place_error, ec};`	341		`return {boost::system::in_place_error, ec};`
337		`}`	342		`}`
338			343
339		`constexpr std::size_t N = std::tuple_size<remove_cvref<T>>::value;`	344		`constexpr std::size_t N = std::tuple_size<remove_cvref<T>>::value;`
340		`if( N != arr->size() )`	345		`if( N != arr->size() )`
341		`{`	346		`{`
342		`BOOST_JSON_FAIL(ec, error::size_mismatch);`	347		`BOOST_JSON_FAIL(ec, error::size_mismatch);`
343		`return {boost::system::in_place_error, ec};`	348		`return {boost::system::in_place_error, ec};`
344		`}`	349		`}`
345			350
346		`return try_make_tuple_like<T>(`	351		`return try_make_tuple_like<T>(`
347		`*arr, ctx, boost::mp11::make_index_sequence<N>());`	352		`*arr, ctx, boost::mp11::make_index_sequence<N>());`
348		`}`	353		`}`
349			354
350		`template< class Ctx, class T >`	355		`template< class Ctx, class T >`
351		`struct to_described_member`	356		`struct to_described_member`
352	-	`static_assert(`
353	-	`uniquely_named_members<T>::value,`
354	-	`"The type has several described members with the same name.");`
355	-
356		`{`	357		`{`
357		`using Ds = described_members<T>;`	358		`using Ds = described_members<T>;`
358			359
359		`system::result<T>& res;`	360		`system::result<T>& res;`
360		`object const& obj;`	361		`object const& obj;`
361		`Ctx const& ctx;`	362		`Ctx const& ctx;`
362			363
363		`template< class I >`	364		`template< class I >`
364		`void`	365		`void`
365		`operator()(I)`	366		`operator()(I)`
366		`{`	367		`{`
367		`if( !res )`	368		`if( !res )`
368		`return;`	369		`return;`
369			370
370		`using D = mp11::mp_at<Ds, I>;`	371		`using D = mp11::mp_at<Ds, I>;`
371		`using M = described_member_t<T, D>;`	372		`using M = described_member_t<T, D>;`
372			373
373		`auto const found = obj.find(D::name);`	374		`auto const found = obj.find(D::name);`
374		`if( found == obj.end() )`	375		`if( found == obj.end() )`
375		`{`	376		`{`
376		`BOOST_IF_CONSTEXPR( !is_optional_like<M>::value )`	377		`BOOST_IF_CONSTEXPR( !is_optional_like<M>::value )`
377		`{`	378		`{`
378		`system::error_code ec;`	379		`system::error_code ec;`
379		`BOOST_JSON_FAIL(ec, error::size_mismatch);`	380		`BOOST_JSON_FAIL(ec, error::size_mismatch);`
380		`res = {boost::system::in_place_error, ec};`	381		`res = {boost::system::in_place_error, ec};`
381		`}`	382		`}`
382		`return;`	383		`return;`
383		`}`	384		`}`
384			385
385		`#if defined(__GNUC__) && BOOST_GCC_VERSION >= 80000 && BOOST_GCC_VERSION < 11000`	386		`#if defined(__GNUC__) && BOOST_GCC_VERSION >= 80000 && BOOST_GCC_VERSION < 11000`
386		`# pragma GCC diagnostic push`	387		`# pragma GCC diagnostic push`
387		`# pragma GCC diagnostic ignored "-Wunused"`	388		`# pragma GCC diagnostic ignored "-Wunused"`
388		`# pragma GCC diagnostic ignored "-Wunused-variable"`	389		`# pragma GCC diagnostic ignored "-Wunused-variable"`
389		`#endif`	390		`#endif`
390		`auto member_res = try_value_to<M>( found->value(), ctx );`	391		`auto member_res = try_value_to<M>( found->value(), ctx );`
391		`#if defined(__GNUC__) && BOOST_GCC_VERSION >= 80000 && BOOST_GCC_VERSION < 11000`	392		`#if defined(__GNUC__) && BOOST_GCC_VERSION >= 80000 && BOOST_GCC_VERSION < 11000`
392		`# pragma GCC diagnostic pop`	393		`# pragma GCC diagnostic pop`
393		`#endif`	394		`#endif`
394		`if( member_res )`	395		`if( member_res )`
395		`(res). D::pointer = std::move(*member_res);`	396		`(res). D::pointer = std::move(*member_res);`
396		`else`	397		`else`
397		`res = {boost::system::in_place_error, member_res.error()};`	398		`res = {boost::system::in_place_error, member_res.error()};`
398		`}`	399		`}`
399		`};`	400		`};`
400			401
401		`// described classes`	402		`// described classes`
402		`template< class T, class Ctx >`	403		`template< class T, class Ctx >`
403		`system::result<T>`	404		`system::result<T>`
404		`value_to_impl(`	405		`value_to_impl(`
405		`described_class_conversion_tag,`	406		`described_class_conversion_tag,`
406		`try_value_to_tag<T>,`	407		`try_value_to_tag<T>,`
407		`value const& jv,`	408		`value const& jv,`
408		`Ctx const& ctx )`	409		`Ctx const& ctx )`
409		`{`	410		`{`
410	-	`BOOST_CORE_STATIC_ASSERT( std::is_default_constructible<T>::value );`	411	+	`BOOST_STATIC_ASSERT( std::is_default_constructible<T>::value );`
411		`system::result<T> res;`	412		`system::result<T> res;`
412			413
413		`auto* obj = jv.if_object();`	414		`auto* obj = jv.if_object();`
414		`if( !obj )`	415		`if( !obj )`
415		`{`	416		`{`
416		`system::error_code ec;`	417		`system::error_code ec;`
417		`BOOST_JSON_FAIL(ec, error::not_object);`	418		`BOOST_JSON_FAIL(ec, error::not_object);`
418		`res = {boost::system::in_place_error, ec};`	419		`res = {boost::system::in_place_error, ec};`
419		`return res;`	420		`return res;`
420		`}`	421		`}`
421			422
422		`to_described_member<Ctx, T> member_converter{res, *obj, ctx};`	423		`to_described_member<Ctx, T> member_converter{res, *obj, ctx};`
423			424
424		`using Ds = typename decltype(member_converter)::Ds;`	425		`using Ds = typename decltype(member_converter)::Ds;`
425		`constexpr std::size_t N = mp11::mp_size<Ds>::value;`	426		`constexpr std::size_t N = mp11::mp_size<Ds>::value;`
426		`mp11::mp_for_each< mp11::mp_iota_c<N> >(member_converter);`	427		`mp11::mp_for_each< mp11::mp_iota_c<N> >(member_converter);`
427			428
428		`if( !res )`	429		`if( !res )`
429		`return res;`	430		`return res;`
430			431
431		`return res;`	432		`return res;`
432		`}`	433		`}`
433			434
434		`// described enums`	435		`// described enums`
435		`template< class T, class Ctx >`	436		`template< class T, class Ctx >`
436		`system::result<T>`	437		`system::result<T>`
437		`value_to_impl(`	438		`value_to_impl(`
438		`described_enum_conversion_tag,`	439		`described_enum_conversion_tag,`
439		`try_value_to_tag<T>,`	440		`try_value_to_tag<T>,`
440		`value const& jv,`	441		`value const& jv,`
441		`Ctx const& )`	442		`Ctx const& )`
442		`{`	443		`{`
443		`T val = {};`	444		`T val = {};`
444		`(void)jv;`	445		`(void)jv;`
445		`#ifdef BOOST_DESCRIBE_CXX14`	446		`#ifdef BOOST_DESCRIBE_CXX14`
446		`system::error_code ec;`	447		`system::error_code ec;`
447			448
448		`auto str = jv.if_string();`	449		`auto str = jv.if_string();`
449		`if( !str )`	450		`if( !str )`
450		`{`	451		`{`
451		`BOOST_JSON_FAIL(ec, error::not_string);`	452		`BOOST_JSON_FAIL(ec, error::not_string);`
452		`return {system::in_place_error, ec};`	453		`return {system::in_place_error, ec};`
453		`}`	454		`}`
454			455
455		`if( !describe::enum_from_string(str->data(), val) )`	456		`if( !describe::enum_from_string(str->data(), val) )`
456		`{`	457		`{`
457		`BOOST_JSON_FAIL(ec, error::unknown_name);`	458		`BOOST_JSON_FAIL(ec, error::unknown_name);`
458		`return {system::in_place_error, ec};`	459		`return {system::in_place_error, ec};`
459		`}`	460		`}`
460		`#endif`	461		`#endif`
461			462
462		`return {system::in_place_value, val};`	463		`return {system::in_place_value, val};`
463		`}`	464		`}`
464			465
465		`// optionals`	466		`// optionals`
466		`template< class T, class Ctx >`	467		`template< class T, class Ctx >`
467		`system::result<T>`	468		`system::result<T>`
468		`value_to_impl(`	469		`value_to_impl(`
469		`optional_conversion_tag,`	470		`optional_conversion_tag,`
470		`try_value_to_tag<T>,`	471		`try_value_to_tag<T>,`
471		`value const& jv,`	472		`value const& jv,`
472		`Ctx const& ctx)`	473		`Ctx const& ctx)`
473		`{`	474		`{`
474		`using Inner = value_result_type<T>;`	475		`using Inner = value_result_type<T>;`
475		`if( jv.is_null() )`	476		`if( jv.is_null() )`
476		`return {};`	477		`return {};`
477		`else`	478		`else`
478		`return try_value_to<Inner>(jv, ctx);`	479		`return try_value_to<Inner>(jv, ctx);`
479		`}`	480		`}`
480			481
481		`// variants`	482		`// variants`
482		`template< class T, class V, class I >`	483		`template< class T, class V, class I >`
483		`using variant_construction_category = mp11::mp_cond<`	484		`using variant_construction_category = mp11::mp_cond<`
484		`std::is_constructible< T, variant2::in_place_index_t<I::value>, V >,`	485		`std::is_constructible< T, variant2::in_place_index_t<I::value>, V >,`
485		`mp11::mp_int<2>,`	486		`mp11::mp_int<2>,`
486		`#ifndef BOOST_NO_CXX17_HDR_VARIANT`	487		`#ifndef BOOST_NO_CXX17_HDR_VARIANT`
487		`std::is_constructible< T, std::in_place_index_t<I::value>, V >,`	488		`std::is_constructible< T, std::in_place_index_t<I::value>, V >,`
488		`mp11::mp_int<1>,`	489		`mp11::mp_int<1>,`
489		`#endif // BOOST_NO_CXX17_HDR_VARIANT`	490		`#endif // BOOST_NO_CXX17_HDR_VARIANT`
490		`mp11::mp_true,`	491		`mp11::mp_true,`
491		`mp11::mp_int<0> >;`	492		`mp11::mp_int<0> >;`
492			493
493		`template< class T, class I, class V >`	494		`template< class T, class I, class V >`
494		`T`	495		`T`
495		`initialize_variant( V&& v, mp11::mp_int<0> )`	496		`initialize_variant( V&& v, mp11::mp_int<0> )`
496		`{`	497		`{`
497		`T t;`	498		`T t;`
498		`t.template emplace<I::value>( std::move(v) );`	499		`t.template emplace<I::value>( std::move(v) );`
499		`return t;`	500		`return t;`
500		`}`	501		`}`
501			502
502		`template< class T, class I, class V >`	503		`template< class T, class I, class V >`
503		`T`	504		`T`
504		`initialize_variant( V&& v, mp11::mp_int<2> )`	505		`initialize_variant( V&& v, mp11::mp_int<2> )`
505		`{`	506		`{`
506		`return T( variant2::in_place_index_t<I::value>(), std::move(v) );`	507		`return T( variant2::in_place_index_t<I::value>(), std::move(v) );`
507		`}`	508		`}`
508			509
509		`#ifndef BOOST_NO_CXX17_HDR_VARIANT`	510		`#ifndef BOOST_NO_CXX17_HDR_VARIANT`
510		`template< class T, class I, class V >`	511		`template< class T, class I, class V >`
511		`T`	512		`T`
512		`initialize_variant( V&& v, mp11::mp_int<1> )`	513		`initialize_variant( V&& v, mp11::mp_int<1> )`
513		`{`	514		`{`
514		`return T( std::in_place_index_t<I::value>(), std::move(v) );`	515		`return T( std::in_place_index_t<I::value>(), std::move(v) );`
515		`}`	516		`}`
516		`#endif // BOOST_NO_CXX17_HDR_VARIANT`	517		`#endif // BOOST_NO_CXX17_HDR_VARIANT`
517			518
518			519
519		`template< class T, class Ctx >`	520		`template< class T, class Ctx >`
520		`struct alternative_converter`	521		`struct alternative_converter`
521		`{`	522		`{`
522		`system::result<T>& res;`	523		`system::result<T>& res;`
523		`value const& jv;`	524		`value const& jv;`
524		`Ctx const& ctx;`	525		`Ctx const& ctx;`
525			526
526		`template< class I >`	527		`template< class I >`
527		`void operator()( I ) const`	528		`void operator()( I ) const`
528		`{`	529		`{`
529		`if( res )`	530		`if( res )`
530		`return;`	531		`return;`
531			532
532		`using V = mp11::mp_at<T, I>;`	533		`using V = mp11::mp_at<T, I>;`
533		`auto attempt = try_value_to<V>(jv, ctx);`	534		`auto attempt = try_value_to<V>(jv, ctx);`
534		`if( attempt )`	535		`if( attempt )`
535		`{`	536		`{`
536		`using cat = variant_construction_category<T, V, I>;`	537		`using cat = variant_construction_category<T, V, I>;`
537		`res = initialize_variant<T, I>( std::move(*attempt), cat() );`	538		`res = initialize_variant<T, I>( std::move(*attempt), cat() );`
538		`}`	539		`}`
539		`}`	540		`}`
540		`};`	541		`};`
541			542
542		`template< class T, class Ctx >`	543		`template< class T, class Ctx >`
543		`system::result<T>`	544		`system::result<T>`
544		`value_to_impl(`	545		`value_to_impl(`
545		`variant_conversion_tag,`	546		`variant_conversion_tag,`
546		`try_value_to_tag<T>,`	547		`try_value_to_tag<T>,`
547		`value const& jv,`	548		`value const& jv,`
548		`Ctx const& ctx)`	549		`Ctx const& ctx)`
549		`{`	550		`{`
550		`system::error_code ec;`	551		`system::error_code ec;`
551		`BOOST_JSON_FAIL(ec, error::exhausted_variants);`	552		`BOOST_JSON_FAIL(ec, error::exhausted_variants);`
552			553
553		`using Is = mp11::mp_iota< mp11::mp_size<T> >;`	554		`using Is = mp11::mp_iota< mp11::mp_size<T> >;`
554			555
555		`system::result<T> res = {system::in_place_error, ec};`	556		`system::result<T> res = {system::in_place_error, ec};`
556		`mp11::mp_for_each<Is>( alternative_converter<T, Ctx>{res, jv, ctx} );`	557		`mp11::mp_for_each<Is>( alternative_converter<T, Ctx>{res, jv, ctx} );`
557		`return res;`	558		`return res;`
558		`}`	559		`}`
559			560
560		`template< class T, class Ctx >`	561		`template< class T, class Ctx >`
561		`system::result<T>`	562		`system::result<T>`
562		`value_to_impl(`	563		`value_to_impl(`
563		`path_conversion_tag, try_value_to_tag<T>, value const& jv, Ctx const& )`	564		`path_conversion_tag, try_value_to_tag<T>, value const& jv, Ctx const& )`
564		`{`	565		`{`
565		`auto str = jv.if_string();`	566		`auto str = jv.if_string();`
566		`if( !str )`	567		`if( !str )`
567		`{`	568		`{`
568		`system::error_code ec;`	569		`system::error_code ec;`
569		`BOOST_JSON_FAIL(ec, error::not_string);`	570		`BOOST_JSON_FAIL(ec, error::not_string);`
570		`return {boost::system::in_place_error, ec};`	571		`return {boost::system::in_place_error, ec};`
571		`}`	572		`}`
572			573
573		`string_view sv = str->subview();`	574		`string_view sv = str->subview();`
574		`return {boost::system::in_place_value, T( sv.begin(), sv.end() )};`	575		`return {boost::system::in_place_value, T( sv.begin(), sv.end() )};`
575		`}`	576		`}`
576			577
577		`//----------------------------------------------------------`	578		`//----------------------------------------------------------`
578		`// User-provided conversions; throwing -> throwing`	579		`// User-provided conversions; throwing -> throwing`
579		`template< class T, class Ctx >`	580		`template< class T, class Ctx >`
580		`mp11::mp_if< mp11::mp_valid<has_user_conversion_to_impl, T>, T >`	581		`mp11::mp_if< mp11::mp_valid<has_user_conversion_to_impl, T>, T >`
581		`value_to_impl(`	582		`value_to_impl(`
582		`user_conversion_tag, value_to_tag<T> tag, value const& jv, Ctx const&)`	583		`user_conversion_tag, value_to_tag<T> tag, value const& jv, Ctx const&)`
583		`{`	584		`{`
584		`return tag_invoke(tag, jv);`	585		`return tag_invoke(tag, jv);`
585		`}`	586		`}`
586			587
587		`template<`	588		`template<`
588		`class T,`	589		`class T,`
589		`class Ctx,`	590		`class Ctx,`
590		`class Sup = supported_context<Ctx, T, value_to_conversion>`	591		`class Sup = supported_context<Ctx, T, value_to_conversion>`
591		`>`	592		`>`
592		`mp11::mp_if<`	593		`mp11::mp_if<`
593		`mp11::mp_valid< has_context_conversion_to_impl, typename Sup::type, T>, T >`	594		`mp11::mp_valid< has_context_conversion_to_impl, typename Sup::type, T>, T >`
594		`value_to_impl(`	595		`value_to_impl(`
595		`context_conversion_tag,`	596		`context_conversion_tag,`
596		`value_to_tag<T> tag,`	597		`value_to_tag<T> tag,`
597		`value const& jv,`	598		`value const& jv,`
598		`Ctx const& ctx )`	599		`Ctx const& ctx )`
599		`{`	600		`{`
600		`return tag_invoke( tag, jv, Sup::get(ctx) );`	601		`return tag_invoke( tag, jv, Sup::get(ctx) );`
601		`}`	602		`}`
602			603
603		`template<`	604		`template<`
604		`class T,`	605		`class T,`
605		`class Ctx,`	606		`class Ctx,`
606		`class Sup = supported_context<Ctx, T, value_to_conversion>`	607		`class Sup = supported_context<Ctx, T, value_to_conversion>`
607		`>`	608		`>`
608		`mp11::mp_if<`	609		`mp11::mp_if<`
609		`mp11::mp_valid<`	610		`mp11::mp_valid<`
610		`has_full_context_conversion_to_impl, typename Sup::type, T>,`	611		`has_full_context_conversion_to_impl, typename Sup::type, T>,`
611		`T>`	612		`T>`
612		`value_to_impl(`	613		`value_to_impl(`
613		`full_context_conversion_tag,`	614		`full_context_conversion_tag,`
614		`value_to_tag<T> tag,`	615		`value_to_tag<T> tag,`
615		`value const& jv,`	616		`value const& jv,`
616		`Ctx const& ctx )`	617		`Ctx const& ctx )`
617		`{`	618		`{`
618		`return tag_invoke( tag, jv, Sup::get(ctx), ctx );`	619		`return tag_invoke( tag, jv, Sup::get(ctx), ctx );`
619		`}`	620		`}`
620			621
621		`//----------------------------------------------------------`	622		`//----------------------------------------------------------`
622		`// User-provided conversions; throwing -> nonthrowing`	623		`// User-provided conversions; throwing -> nonthrowing`
623		`template< class T, class Ctx >`	624		`template< class T, class Ctx >`
624		`mp11::mp_if_c< !mp11::mp_valid<has_user_conversion_to_impl, T>::value, T>`	625		`mp11::mp_if_c< !mp11::mp_valid<has_user_conversion_to_impl, T>::value, T>`
625		`value_to_impl(`	626		`value_to_impl(`
626		`user_conversion_tag, value_to_tag<T>, value const& jv, Ctx const& )`	627		`user_conversion_tag, value_to_tag<T>, value const& jv, Ctx const& )`
627		`{`	628		`{`
628		`auto res = tag_invoke(try_value_to_tag<T>(), jv);`	629		`auto res = tag_invoke(try_value_to_tag<T>(), jv);`
629		`if( res.has_error() )`	630		`if( res.has_error() )`
630		`throw_system_error( res.error() );`	631		`throw_system_error( res.error() );`
631		`return std::move(*res);`	632		`return std::move(*res);`
632		`}`	633		`}`
633			634
634		`template<`	635		`template<`
635		`class T,`	636		`class T,`
636		`class Ctx,`	637		`class Ctx,`
637		`class Sup = supported_context<Ctx, T, value_to_conversion>`	638		`class Sup = supported_context<Ctx, T, value_to_conversion>`
638		`>`	639		`>`
639		`mp11::mp_if_c<`	640		`mp11::mp_if_c<`
640		`!mp11::mp_valid<`	641		`!mp11::mp_valid<`
641		`has_context_conversion_to_impl, typename Sup::type, T>::value,`	642		`has_context_conversion_to_impl, typename Sup::type, T>::value,`
642		`T>`	643		`T>`
643		`value_to_impl(`	644		`value_to_impl(`
644		`context_conversion_tag, value_to_tag<T>, value const& jv, Ctx const& ctx )`	645		`context_conversion_tag, value_to_tag<T>, value const& jv, Ctx const& ctx )`
645		`{`	646		`{`
646		`auto res = tag_invoke( try_value_to_tag<T>(), jv, Sup::get(ctx) );`	647		`auto res = tag_invoke( try_value_to_tag<T>(), jv, Sup::get(ctx) );`
647		`if( res.has_error() )`	648		`if( res.has_error() )`
648		`throw_system_error( res.error() );`	649		`throw_system_error( res.error() );`
649		`return std::move(*res);`	650		`return std::move(*res);`
650		`}`	651		`}`
651			652
652		`template<`	653		`template<`
653		`class T,`	654		`class T,`
654		`class Ctx,`	655		`class Ctx,`
655		`class Sup = supported_context<Ctx, T, value_to_conversion>`	656		`class Sup = supported_context<Ctx, T, value_to_conversion>`
656		`>`	657		`>`
657		`mp11::mp_if_c<`	658		`mp11::mp_if_c<`
658		`!mp11::mp_valid<`	659		`!mp11::mp_valid<`
659		`has_full_context_conversion_to_impl, typename Sup::type, T>::value,`	660		`has_full_context_conversion_to_impl, typename Sup::type, T>::value,`
660		`T>`	661		`T>`
661		`value_to_impl(`	662		`value_to_impl(`
662		`full_context_conversion_tag,`	663		`full_context_conversion_tag,`
663		`value_to_tag<T>,`	664		`value_to_tag<T>,`
664		`value const& jv,`	665		`value const& jv,`
665		`Ctx const& ctx )`	666		`Ctx const& ctx )`
666		`{`	667		`{`
667		`auto res = tag_invoke(try_value_to_tag<T>(), jv, Sup::get(ctx), ctx);`	668		`auto res = tag_invoke(try_value_to_tag<T>(), jv, Sup::get(ctx), ctx);`
668		`if( res.has_error() )`	669		`if( res.has_error() )`
669		`throw_system_error( res.error() );`	670		`throw_system_error( res.error() );`
670		`return std::move(*res);`	671		`return std::move(*res);`
671		`}`	672		`}`
672			673
673		`//----------------------------------------------------------`	674		`//----------------------------------------------------------`
674		`// User-provided conversions; nonthrowing -> nonthrowing`	675		`// User-provided conversions; nonthrowing -> nonthrowing`
675		`template< class T, class Ctx >`	676		`template< class T, class Ctx >`
676		`mp11::mp_if<`	677		`mp11::mp_if<`
677		`mp11::mp_valid<`	678		`mp11::mp_valid<`
678		`has_nonthrowing_user_conversion_to_impl, T>, system::result<T> >`	679		`has_nonthrowing_user_conversion_to_impl, T>, system::result<T> >`
679		`value_to_impl(`	680		`value_to_impl(`
680		`user_conversion_tag, try_value_to_tag<T>, value const& jv, Ctx const& )`	681		`user_conversion_tag, try_value_to_tag<T>, value const& jv, Ctx const& )`
681		`{`	682		`{`
682		`return tag_invoke(try_value_to_tag<T>(), jv);`	683		`return tag_invoke(try_value_to_tag<T>(), jv);`
683		`}`	684		`}`
684			685
685		`template<`	686		`template<`
686		`class T,`	687		`class T,`
687		`class Ctx,`	688		`class Ctx,`
688		`class Sup = supported_context<Ctx, T, value_to_conversion>`	689		`class Sup = supported_context<Ctx, T, value_to_conversion>`
689		`>`	690		`>`
690		`mp11::mp_if<`	691		`mp11::mp_if<`
691		`mp11::mp_valid<`	692		`mp11::mp_valid<`
692		`has_nonthrowing_context_conversion_to_impl, typename Sup::type, T>,`	693		`has_nonthrowing_context_conversion_to_impl, typename Sup::type, T>,`
693		`system::result<T> >`	694		`system::result<T> >`
694		`value_to_impl(`	695		`value_to_impl(`
695		`context_conversion_tag,`	696		`context_conversion_tag,`
696		`try_value_to_tag<T> tag,`	697		`try_value_to_tag<T> tag,`
697		`value const& jv,`	698		`value const& jv,`
698		`Ctx const& ctx )`	699		`Ctx const& ctx )`
699		`{`	700		`{`
700		`return tag_invoke( tag, jv, Sup::get(ctx) );`	701		`return tag_invoke( tag, jv, Sup::get(ctx) );`
701		`}`	702		`}`
702			703
703		`template<`	704		`template<`
704		`class T,`	705		`class T,`
705		`class Ctx,`	706		`class Ctx,`
706		`class Sup = supported_context<Ctx, T, value_to_conversion>`	707		`class Sup = supported_context<Ctx, T, value_to_conversion>`
707		`>`	708		`>`
708		`mp11::mp_if<`	709		`mp11::mp_if<`
709		`mp11::mp_valid<`	710		`mp11::mp_valid<`
710		`has_nonthrowing_full_context_conversion_to_impl,`	711		`has_nonthrowing_full_context_conversion_to_impl,`
711		`typename Sup::type,`	712		`typename Sup::type,`
712		`T>,`	713		`T>,`
713		`system::result<T> >`	714		`system::result<T> >`
714		`value_to_impl(`	715		`value_to_impl(`
715		`full_context_conversion_tag,`	716		`full_context_conversion_tag,`
716		`try_value_to_tag<T> tag,`	717		`try_value_to_tag<T> tag,`
717		`value const& jv,`	718		`value const& jv,`
718		`Ctx const& ctx )`	719		`Ctx const& ctx )`
719		`{`	720		`{`
720		`return tag_invoke( tag, jv, Sup::get(ctx), ctx );`	721		`return tag_invoke( tag, jv, Sup::get(ctx), ctx );`
721		`}`	722		`}`
722			723
723		`//----------------------------------------------------------`	724		`//----------------------------------------------------------`
724		`// User-provided conversions; nonthrowing -> throwing`	725		`// User-provided conversions; nonthrowing -> throwing`
725			726
726		`template< class T, class... Args >`	727		`template< class T, class... Args >`
727		`system::result<T>`	728		`system::result<T>`
728		`wrap_conversion_exceptions( value_to_tag<T>, Args&& ... args )`	729		`wrap_conversion_exceptions( value_to_tag<T>, Args&& ... args )`
729		`{`	730		`{`
730		`#ifndef BOOST_NO_EXCEPTIONS`	731		`#ifndef BOOST_NO_EXCEPTIONS`
731		`try`	732		`try`
732		`{`	733		`{`
733		`#endif`	734		`#endif`
734		`return {`	735		`return {`
735		`boost::system::in_place_value,`	736		`boost::system::in_place_value,`
736		`tag_invoke( value_to_tag<T>(), static_cast<Args&&>(args)... )};`	737		`tag_invoke( value_to_tag<T>(), static_cast<Args&&>(args)... )};`
737		`#ifndef BOOST_NO_EXCEPTIONS`	738		`#ifndef BOOST_NO_EXCEPTIONS`
738		`}`	739		`}`
739		`catch( std::bad_alloc const&)`	740		`catch( std::bad_alloc const&)`
740		`{`	741		`{`
741		`throw;`	742		`throw;`
742		`}`	743		`}`
743		`catch( system::system_error const& e)`	744		`catch( system::system_error const& e)`
744		`{`	745		`{`
745		`return {boost::system::in_place_error, e.code()};`	746		`return {boost::system::in_place_error, e.code()};`
746		`}`	747		`}`
747		`catch( ... )`	748		`catch( ... )`
748		`{`	749		`{`
749		`system::error_code ec;`	750		`system::error_code ec;`
750		`BOOST_JSON_FAIL(ec, error::exception);`	751		`BOOST_JSON_FAIL(ec, error::exception);`
751		`return {boost::system::in_place_error, ec};`	752		`return {boost::system::in_place_error, ec};`
752		`}`	753		`}`
753		`#endif`	754		`#endif`
754		`}`	755		`}`
755			756
756		`template< class T, class Ctx >`	757		`template< class T, class Ctx >`
757		`mp11::mp_if_c<`	758		`mp11::mp_if_c<`
758		`!mp11::mp_valid<has_nonthrowing_user_conversion_to_impl, T>::value,`	759		`!mp11::mp_valid<has_nonthrowing_user_conversion_to_impl, T>::value,`
759		`system::result<T> >`	760		`system::result<T> >`
760		`value_to_impl(`	761		`value_to_impl(`
761		`user_conversion_tag, try_value_to_tag<T>, value const& jv, Ctx const& )`	762		`user_conversion_tag, try_value_to_tag<T>, value const& jv, Ctx const& )`
762		`{`	763		`{`
763		`return wrap_conversion_exceptions(value_to_tag<T>(), jv);`	764		`return wrap_conversion_exceptions(value_to_tag<T>(), jv);`
764		`}`	765		`}`
765			766
766		`template<`	767		`template<`
767		`class T,`	768		`class T,`
768		`class Ctx,`	769		`class Ctx,`
769		`class Sup = supported_context<Ctx, T, value_to_conversion>`	770		`class Sup = supported_context<Ctx, T, value_to_conversion>`
770		`>`	771		`>`
771		`mp11::mp_if_c<`	772		`mp11::mp_if_c<`
772		`!mp11::mp_valid<`	773		`!mp11::mp_valid<`
773		`has_nonthrowing_context_conversion_to_impl,`	774		`has_nonthrowing_context_conversion_to_impl,`
774		`typename Sup::type,`	775		`typename Sup::type,`
775		`T>::value,`	776		`T>::value,`
776		`system::result<T> >`	777		`system::result<T> >`
777		`value_to_impl(`	778		`value_to_impl(`
778		`context_conversion_tag,`	779		`context_conversion_tag,`
779		`try_value_to_tag<T>,`	780		`try_value_to_tag<T>,`
780		`value const& jv,`	781		`value const& jv,`
781		`Ctx const& ctx )`	782		`Ctx const& ctx )`
782		`{`	783		`{`
783		`return wrap_conversion_exceptions( value_to_tag<T>(), jv, Sup::get(ctx) );`	784		`return wrap_conversion_exceptions( value_to_tag<T>(), jv, Sup::get(ctx) );`
784		`}`	785		`}`
785			786
786		`template<`	787		`template<`
787		`class T,`	788		`class T,`
788		`class Ctx,`	789		`class Ctx,`
789		`class Sup = supported_context<Ctx, T, value_to_conversion>`	790		`class Sup = supported_context<Ctx, T, value_to_conversion>`
790		`>`	791		`>`
791		`mp11::mp_if_c<`	792		`mp11::mp_if_c<`
792		`!mp11::mp_valid<`	793		`!mp11::mp_valid<`
793		`has_nonthrowing_full_context_conversion_to_impl,`	794		`has_nonthrowing_full_context_conversion_to_impl,`
794		`typename Sup::type,`	795		`typename Sup::type,`
795		`T>::value,`	796		`T>::value,`
796		`system::result<T> >`	797		`system::result<T> >`
797		`value_to_impl(`	798		`value_to_impl(`
798		`full_context_conversion_tag,`	799		`full_context_conversion_tag,`
799		`try_value_to_tag<T>,`	800		`try_value_to_tag<T>,`
800		`value const& jv,`	801		`value const& jv,`
801		`Ctx const& ctx )`	802		`Ctx const& ctx )`
802		`{`	803		`{`
803		`return wrap_conversion_exceptions(`	804		`return wrap_conversion_exceptions(`
804		`value_to_tag<T>(), jv, Sup::get(ctx), ctx);`	805		`value_to_tag<T>(), jv, Sup::get(ctx), ctx);`
805		`}`	806		`}`
806			807
807		`// no suitable conversion implementation`	808		`// no suitable conversion implementation`
808		`template< class T, class Ctx >`	809		`template< class T, class Ctx >`
809		`T`	810		`T`
810		`value_to_impl( no_conversion_tag, value_to_tag<T>, value const&, Ctx const& )`	811		`value_to_impl( no_conversion_tag, value_to_tag<T>, value const&, Ctx const& )`
811		`{`	812		`{`
812		`static_assert(`	813		`static_assert(`
813		`!std::is_same<T, T>::value,`	814		`!std::is_same<T, T>::value,`
814		`"No suitable tag_invoke overload found for the type");`	815		`"No suitable tag_invoke overload found for the type");`
815		`}`	816		`}`
816			817
817		`// generic wrapper over non-throwing implementations`	818		`// generic wrapper over non-throwing implementations`
818		`template< class Impl, class T, class Ctx >`	819		`template< class Impl, class T, class Ctx >`
819		`T`	820		`T`
820		`value_to_impl( Impl impl, value_to_tag<T>, value const& jv, Ctx const& ctx )`	821		`value_to_impl( Impl impl, value_to_tag<T>, value const& jv, Ctx const& ctx )`
821		`{`	822		`{`
822		`return value_to_impl(impl, try_value_to_tag<T>(), jv, ctx).value();`	823		`return value_to_impl(impl, try_value_to_tag<T>(), jv, ctx).value();`
823	-
824	-	`template< class Ctx, class T >`
825	-	`using value_to_category = conversion_category<`
826	-	`Ctx, T, value_to_conversion >;`
827		`}`	824		`}`
828			825
829		`} // detail`	826		`} // detail`
830			827
831		`#ifndef BOOST_NO_CXX17_HDR_OPTIONAL`	828		`#ifndef BOOST_NO_CXX17_HDR_OPTIONAL`
832		`inline`	829		`inline`
833		`system::result<std::nullopt_t>`	830		`system::result<std::nullopt_t>`
834		`tag_invoke(`	831		`tag_invoke(`
835		`try_value_to_tag<std::nullopt_t>,`	832		`try_value_to_tag<std::nullopt_t>,`
836		`value const& jv)`	833		`value const& jv)`
837		`{`	834		`{`
838		`if( jv.is_null() )`	835		`if( jv.is_null() )`
839		`return std::nullopt;`	836		`return std::nullopt;`
840		`system::error_code ec;`	837		`system::error_code ec;`
841		`BOOST_JSON_FAIL(ec, error::not_null);`	838		`BOOST_JSON_FAIL(ec, error::not_null);`
842		`return ec;`	839		`return ec;`
843		`}`	840		`}`
844		`#endif`	841		`#endif`
845			842
846		`} // namespace json`	843		`} // namespace json`
847		`} // namespace boost`	844		`} // namespace boost`
848			845
849		`#endif`	846		`#endif`

	Coverage	Total	Misses	UNC	GBC	CBC	EUB
Child	Rate	Total	Misses	New Misses	Hits		New Hits
Lines	100.00%	157	0			157
Lines	100.00%	157			157