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

	Coverage	Total	Misses	UNC	LBC	UIC	UBC	GBC	GIC	GNC	CBC	EUB	ECB	DUB	DCB
Lines	100.00%	147	0						1	4	142		4		12
Lines	100.00%	147			147	5

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