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

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	`//`	4		`//`
5	`// Distributed under the Boost Software License, Version 1.0. (See accompanying`	5		`// Distributed under the Boost Software License, Version 1.0. (See accompanying`
6	`// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)`	6		`// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)`
7	`//`	7		`//`
8	`// Official repository: https://github.com/boostorg/json`	8		`// Official repository: https://github.com/boostorg/json`
9	`//`	9		`//`
10		10
11	`#ifndef BOOST_JSON_DETAIL_PARSE_INTO_HPP`	11		`#ifndef BOOST_JSON_DETAIL_PARSE_INTO_HPP`
12	`#define BOOST_JSON_DETAIL_PARSE_INTO_HPP`	12		`#define BOOST_JSON_DETAIL_PARSE_INTO_HPP`
13		13
14	`#include <boost/json/detail/config.hpp>`	14		`#include <boost/json/detail/config.hpp>`
15		15
16	`#include <boost/json/error.hpp>`	16		`#include <boost/json/error.hpp>`
17	`#include <boost/json/conversion.hpp>`	17		`#include <boost/json/conversion.hpp>`
		18	+	`#include <boost/json/value.hpp>`
18	`#include <boost/describe/enum_from_string.hpp>`	19		`#include <boost/describe/enum_from_string.hpp>`
19		20
20	`#include <vector>`	21		`#include <vector>`
21		22
22	`/*`	23		`/*`
23	`* This file contains the majority of parse_into functionality, specifically`	24		`* This file contains the majority of parse_into functionality, specifically`
24	`* the implementation of dedicated handlers for different generic categories of`	25		`* the implementation of dedicated handlers for different generic categories of`
25	`* types.`	26		`* types.`
26	`*`	27		`*`
27	`* At the core of parse_into is the specialisation basic_parser<`	28		`* At the core of parse_into is the specialisation basic_parser<`
28	`* detail::into_handler<T> >. detail::into_handler<T> is a handler for`	29		`* detail::into_handler<T> >. detail::into_handler<T> is a handler for`
29	`* basic_parser. It directly handles events on_comment_part and on_comment (by`	30		`* basic_parser. It directly handles events on_comment_part and on_comment (by`
30	`* ignoring them), on_document_begin (by enabling the nested dedicated`	31		`* ignoring them), on_document_begin (by enabling the nested dedicated`
31	`* handler), and on_document_end (by disabling the nested handler).`	32		`* handler), and on_document_end (by disabling the nested handler).`
32	`*`	33		`*`
33	`* Every other event is handled by the nested handler, which has the type`	34		`* Every other event is handled by the nested handler, which has the type`
34	`* get_handler< T, into_handler<T> >. The second parameter is the parent`	35		`* get_handler< T, into_handler<T> >. The second parameter is the parent`
35	`* handler (in this case, it's the top handler, into_handler<T>). The type is`	36		`* handler (in this case, it's the top handler, into_handler<T>). The type is`
36	`* actually an alias to class template converting_handler, which has a separate`	37		`* actually an alias to class template converting_handler, which has a separate`
37	`* specialisation for every conversion category from the list of generic`	38		`* specialisation for every conversion category from the list of generic`
38	`* conversion categories (e.g. sequence_conversion_tag, tuple_conversion_tag,`	39		`* conversion categories (e.g. sequence_conversion_tag, tuple_conversion_tag,`
39	`* etc.) Instantiations of the template store a pointer to the parent handler`	40		`* etc.) Instantiations of the template store a pointer to the parent handler`
40	`* and a pointer to the value T.`	41		`* and a pointer to the value T.`
41	`*`	42		`*`
42	`* The nested handler handles specific parser events by setting error_code to`	43		`* The nested handler handles specific parser events by setting error_code to`
43	`* an appropriate value, if it receives an event it isn't supposed to handle`	44		`* an appropriate value, if it receives an event it isn't supposed to handle`
44	`* (e.g. a number handler getting an on_string event), and also updates the`	45		`* (e.g. a number handler getting an on_string event), and also updates the`
45	`* value when appropriate. Note that they never need to handle on_comment_part,`	46		`* value when appropriate. Note that they never need to handle on_comment_part,`
46	`* on_comment, on_document_begin, and on_document_end events, as those are`	47		`* on_comment, on_document_begin, and on_document_end events, as those are`
47	`* always handled by the top handler into_handler<T>.`	48		`* always handled by the top handler into_handler<T>.`
48	`*`	49		`*`
49	`* When the nested handler receives an event that completes the current value,`	50		`* When the nested handler receives an event that completes the current value,`
50	`* it is supposed to call its parent's signal_value member function. This is`	51		`* it is supposed to call its parent's signal_value member function. This is`
51	`* necessary for correct handling of composite types (e.g. sequences).`	52		`* necessary for correct handling of composite types (e.g. sequences).`
52	`*`	53		`*`
53	`* Finally, nested handlers should always call parent's signal_end member`	54		`* Finally, nested handlers should always call parent's signal_end member`
54	`* function if they don't handle on_array_end themselves. This is necessary`	55		`* function if they don't handle on_array_end themselves. This is necessary`
55	`* to correctly handle nested composites (e.g. sequences inside sequences).`	56		`* to correctly handle nested composites (e.g. sequences inside sequences).`
56	`* signal_end can return false and set error state when the containing parser`	57		`* signal_end can return false and set error state when the containing parser`
57	`* requires more elements.`	58		`* requires more elements.`
58	`*`	59		`*`
59	`* converting_handler instantiations for composite categories of types have`	60		`* converting_handler instantiations for composite categories of types have`
60	`* their own nested handlers, to which they themselves delegate events. For`	61		`* their own nested handlers, to which they themselves delegate events. For`
61	`* complex types you will get a tree of handlers with into_handler<T> as the`	62		`* complex types you will get a tree of handlers with into_handler<T> as the`
62	`* root and handlers for scalars as leaves.`	63		`* root and handlers for scalars as leaves.`
63	`*`	64		`*`
64	`* To reiterate, only into_handler has to handle on_comment_part, on_comment,`	65		`* To reiterate, only into_handler has to handle on_comment_part, on_comment,`
65	`* on_document_begin, and on_document_end; only handlers for composites and`	66		`* on_document_begin, and on_document_end; only handlers for composites and`
66	`* into_handler has to provide signal_value and signal_end; all handlers`	67		`* into_handler has to provide signal_value and signal_end; all handlers`
67	`* except for into_handler have to call their parent's signal_end from`	68		`* except for into_handler have to call their parent's signal_end from`
68	`* their on_array_begin, if they don't handle it themselves; once a handler`	69		`* their on_array_begin, if they don't handle it themselves; once a handler`
69	`* receives an event that finishes its current value, it should call its`	70		`* receives an event that finishes its current value, it should call its`
70	`* parent's signal_value.`	71		`* parent's signal_value.`
71	`*/`	72		`*/`
72		73
73	`namespace boost {`	74		`namespace boost {`
74	`namespace json {`	75		`namespace json {`
75	`namespace detail {`	76		`namespace detail {`
76		77
77	`template< class Impl, class T, class Parent >`	78		`template< class Impl, class T, class Parent >`
78	`class converting_handler;`	79		`class converting_handler;`
79		80
80	`// get_handler`	81		`// get_handler`
81	`template< class V, class P >`	82		`template< class V, class P >`
82	`using get_handler = converting_handler< generic_conversion_category<V>, V, P >;`	83		`using get_handler = converting_handler< generic_conversion_category<V>, V, P >;`
83		84
84	`template<error E> class handler_error_base`	85		`template<error E> class handler_error_base`
85	`{`	86		`{`
86	`public:`	87		`public:`
87		88
88	`handler_error_base() = default;`	89		`handler_error_base() = default;`
89		90
90	`handler_error_base( handler_error_base const& ) = delete;`	91		`handler_error_base( handler_error_base const& ) = delete;`
91	`handler_error_base& operator=( handler_error_base const& ) = delete;`	92		`handler_error_base& operator=( handler_error_base const& ) = delete;`
92		93
93	`public:`	94		`public:`
94		95
95	`bool on_object_begin( system::error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }`	96		`bool on_object_begin( system::error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }`
96	`bool on_array_begin( system::error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }`	97		`bool on_array_begin( system::error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }`
97	`bool on_array_end( system::error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }`	98		`bool on_array_end( system::error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }`
98	`bool on_string_part( system::error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }`	99		`bool on_string_part( system::error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }`
99	`bool on_string( system::error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }`	100		`bool on_string( system::error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }`
100	`bool on_number_part( system::error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }`	101		`bool on_number_part( system::error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }`
101	`bool on_int64( system::error_code& ec, std::int64_t ) { BOOST_JSON_FAIL( ec, E ); return false; }`	102		`bool on_int64( system::error_code& ec, std::int64_t ) { BOOST_JSON_FAIL( ec, E ); return false; }`
102	`bool on_uint64( system::error_code& ec, std::uint64_t ) { BOOST_JSON_FAIL( ec, E ); return false; }`	103		`bool on_uint64( system::error_code& ec, std::uint64_t ) { BOOST_JSON_FAIL( ec, E ); return false; }`
103	`bool on_double( system::error_code& ec, double ) { BOOST_JSON_FAIL( ec, E ); return false; }`	104		`bool on_double( system::error_code& ec, double ) { BOOST_JSON_FAIL( ec, E ); return false; }`
104	`bool on_bool( system::error_code& ec, bool ) { BOOST_JSON_FAIL( ec, E ); return false; }`	105		`bool on_bool( system::error_code& ec, bool ) { BOOST_JSON_FAIL( ec, E ); return false; }`
105	`bool on_null( system::error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }`	106		`bool on_null( system::error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }`
106		107
107	`// LCOV_EXCL_START`	108		`// LCOV_EXCL_START`
108	`// parses that can't handle this would fail at on_object_begin`	109		`// parses that can't handle this would fail at on_object_begin`
109	`bool on_object_end( system::error_code& ) { BOOST_ASSERT( false ); return false; }`	110		`bool on_object_end( system::error_code& ) { BOOST_ASSERT( false ); return false; }`
110	`bool on_key_part( system::error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }`	111		`bool on_key_part( system::error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }`
111	`bool on_key( system::error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }`	112		`bool on_key( system::error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }`
112	`// LCOV_EXCL_STOP`	113		`// LCOV_EXCL_STOP`
113	`};`	114		`};`
114		115
115	`template< class P, error E >`	116		`template< class P, error E >`
116	`class scalar_handler`	117		`class scalar_handler`
117	`: public handler_error_base<E>`	118		`: public handler_error_base<E>`
118	`{`	119		`{`
119	`protected:`	120		`protected:`
120	`P* parent_;`	121		`P* parent_;`
121		122
122	`public:`	123		`public:`
123	`scalar_handler(scalar_handler const&) = delete;`	124		`scalar_handler(scalar_handler const&) = delete;`
124	`scalar_handler& operator=(scalar_handler const&) = delete;`	125		`scalar_handler& operator=(scalar_handler const&) = delete;`
125		126
126	`scalar_handler(P* p): parent_( p )`	127		`scalar_handler(P* p): parent_( p )`
127	`{}`	128		`{}`
128		129
129	`bool on_array_end( system::error_code& ec )`	130		`bool on_array_end( system::error_code& ec )`
130	`{`	131		`{`
131	`return parent_->signal_end(ec);`	132		`return parent_->signal_end(ec);`
132	`}`	133		`}`
133	`};`	134		`};`
134		135
135	`template< class D, class V, class P, error E >`	136		`template< class D, class V, class P, error E >`
136	`class composite_handler`	137		`class composite_handler`
137	`{`	138		`{`
138	`protected:`	139		`protected:`
139	`using inner_handler_type = get_handler<V, D>;`	140		`using inner_handler_type = get_handler<V, D>;`
140		141
141	`P* parent_;`	142		`P* parent_;`
142	`#if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)`	143		`#if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)`
143	`# pragma GCC diagnostic push`	144		`# pragma GCC diagnostic push`
144	`# pragma GCC diagnostic ignored "-Wmissing-field-initializers"`	145		`# pragma GCC diagnostic ignored "-Wmissing-field-initializers"`
145	`#endif`	146		`#endif`
146	`V next_value_ = {};`	147		`V next_value_ = {};`
147	`inner_handler_type inner_;`	148		`inner_handler_type inner_;`
148	`bool inner_active_ = false;`	149		`bool inner_active_ = false;`
149		150
150	`public:`	151		`public:`
151	`composite_handler( composite_handler const& ) = delete;`	152		`composite_handler( composite_handler const& ) = delete;`
152	`composite_handler& operator=( composite_handler const& ) = delete;`	153		`composite_handler& operator=( composite_handler const& ) = delete;`
153		154
154	`composite_handler( P* p )`	155		`composite_handler( P* p )`
155	`: parent_(p), inner_( &next_value_, static_cast<D*>(this) )`	156		`: parent_(p), inner_( &next_value_, static_cast<D*>(this) )`
156	`{}`	157		`{}`
157	`#if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)`	158		`#if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)`
158	`# pragma GCC diagnostic pop`	159		`# pragma GCC diagnostic pop`
159	`#endif`	160		`#endif`
160		161
161	`bool signal_end(system::error_code& ec)`	162		`bool signal_end(system::error_code& ec)`
162	`{`	163		`{`
163	`inner_active_ = false;`	164		`inner_active_ = false;`
164	`return parent_->signal_value(ec);`	165		`return parent_->signal_value(ec);`
165	`}`	166		`}`
166		167
167	`#define BOOST_JSON_INVOKE_INNER(f) \`	168		`#define BOOST_JSON_INVOKE_INNER(f) \`
168	`if( !inner_active_ ) { \`	169		`if( !inner_active_ ) { \`
169	`BOOST_JSON_FAIL(ec, E); \`	170		`BOOST_JSON_FAIL(ec, E); \`
170	`return false; \`	171		`return false; \`
171	`} \`	172		`} \`
172	`else \`	173		`else \`
173	`return inner_.f`	174		`return inner_.f`
174		175
175	`bool on_object_begin( system::error_code& ec )`	176		`bool on_object_begin( system::error_code& ec )`
176	`{`	177		`{`
177	`BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );`	178		`BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );`
178	`}`	179		`}`
179		180
180	`bool on_object_end( system::error_code& ec )`	181		`bool on_object_end( system::error_code& ec )`
181	`{`	182		`{`
182	`BOOST_JSON_INVOKE_INNER( on_object_end(ec) );`	183		`BOOST_JSON_INVOKE_INNER( on_object_end(ec) );`
183	`}`	184		`}`
184		185
185	`bool on_array_begin( system::error_code& ec )`	186		`bool on_array_begin( system::error_code& ec )`
186	`{`	187		`{`
187	`BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );`	188		`BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );`
188	`}`	189		`}`
189		190
190	`bool on_array_end( system::error_code& ec )`	191		`bool on_array_end( system::error_code& ec )`
191	`{`	192		`{`
192	`BOOST_JSON_INVOKE_INNER( on_array_end(ec) );`	193		`BOOST_JSON_INVOKE_INNER( on_array_end(ec) );`
193	`}`	194		`}`
194		195
195	`bool on_key_part( system::error_code& ec, string_view sv )`	196		`bool on_key_part( system::error_code& ec, string_view sv )`
196	`{`	197		`{`
197	`BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );`	198		`BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );`
198	`}`	199		`}`
199		200
200	`bool on_key( system::error_code& ec, string_view sv )`	201		`bool on_key( system::error_code& ec, string_view sv )`
201	`{`	202		`{`
202	`BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );`	203		`BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );`
203	`}`	204		`}`
204		205
205	`bool on_string_part( system::error_code& ec, string_view sv )`	206		`bool on_string_part( system::error_code& ec, string_view sv )`
206	`{`	207		`{`
207	`BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );`	208		`BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );`
208	`}`	209		`}`
209		210
210	`bool on_string( system::error_code& ec, string_view sv )`	211		`bool on_string( system::error_code& ec, string_view sv )`
211	`{`	212		`{`
212	`BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );`	213		`BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );`
213	`}`	214		`}`
214		215
215	`bool on_number_part( system::error_code& ec )`	216		`bool on_number_part( system::error_code& ec )`
216	`{`	217		`{`
217	`BOOST_JSON_INVOKE_INNER( on_number_part(ec) );`	218		`BOOST_JSON_INVOKE_INNER( on_number_part(ec) );`
218	`}`	219		`}`
219		220
220	`bool on_int64( system::error_code& ec, std::int64_t v )`	221		`bool on_int64( system::error_code& ec, std::int64_t v )`
221	`{`	222		`{`
222	`BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );`	223		`BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );`
223	`}`	224		`}`
224		225
225	`bool on_uint64( system::error_code& ec, std::uint64_t v )`	226		`bool on_uint64( system::error_code& ec, std::uint64_t v )`
226	`{`	227		`{`
227	`BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );`	228		`BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );`
228	`}`	229		`}`
229		230
230	`bool on_double( system::error_code& ec, double v )`	231		`bool on_double( system::error_code& ec, double v )`
231	`{`	232		`{`
232	`BOOST_JSON_INVOKE_INNER( on_double(ec, v) );`	233		`BOOST_JSON_INVOKE_INNER( on_double(ec, v) );`
233	`}`	234		`}`
234		235
235	`bool on_bool( system::error_code& ec, bool v )`	236		`bool on_bool( system::error_code& ec, bool v )`
236	`{`	237		`{`
237	`BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );`	238		`BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );`
238	`}`	239		`}`
239		240
240	`bool on_null( system::error_code& ec )`	241		`bool on_null( system::error_code& ec )`
241	`{`	242		`{`
242	`BOOST_JSON_INVOKE_INNER( on_null(ec) );`	243		`BOOST_JSON_INVOKE_INNER( on_null(ec) );`
243	`}`	244		`}`
244		245
245	`#undef BOOST_JSON_INVOKE_INNER`	246		`#undef BOOST_JSON_INVOKE_INNER`
246	`};`	247		`};`
247		248
248	`// integral handler`	249		`// integral handler`
249	`template<class V,`	250		`template<class V,`
250	`typename std::enable_if<std::is_signed<V>::value, int>::type = 0>`	251		`typename std::enable_if<std::is_signed<V>::value, int>::type = 0>`
251	`bool integral_in_range( std::int64_t v )`	252		`bool integral_in_range( std::int64_t v )`
252	`{`	253		`{`
253	`return v >= (std::numeric_limits<V>::min)() && v <= (std::numeric_limits<V>::max)();`	254		`return v >= (std::numeric_limits<V>::min)() && v <= (std::numeric_limits<V>::max)();`
254	`}`	255		`}`
255		256
256	`template<class V,`	257		`template<class V,`
257	`typename std::enable_if<!std::is_signed<V>::value, int>::type = 0>`	258		`typename std::enable_if<!std::is_signed<V>::value, int>::type = 0>`
258	`bool integral_in_range( std::int64_t v )`	259		`bool integral_in_range( std::int64_t v )`
259	`{`	260		`{`
260	`return v >= 0 && static_cast<std::uint64_t>( v ) <= (std::numeric_limits<V>::max)();`	261		`return v >= 0 && static_cast<std::uint64_t>( v ) <= (std::numeric_limits<V>::max)();`
261	`}`	262		`}`
262		263
263	`template<class V>`	264		`template<class V>`
264	`bool integral_in_range( std::uint64_t v )`	265		`bool integral_in_range( std::uint64_t v )`
265	`{`	266		`{`
266	`return v <= static_cast<typename std::make_unsigned<V>::type>( (std::numeric_limits<V>::max)() );`	267		`return v <= static_cast<typename std::make_unsigned<V>::type>( (std::numeric_limits<V>::max)() );`
267	`}`	268		`}`
268		269
269	`template< class V, class P >`	270		`template< class V, class P >`
270	`class converting_handler<integral_conversion_tag, V, P>`	271		`class converting_handler<integral_conversion_tag, V, P>`
271	`: public scalar_handler<P, error::not_integer>`	272		`: public scalar_handler<P, error::not_integer>`
272	`{`	273		`{`
273	`private:`	274		`private:`
274	`V* value_;`	275		`V* value_;`
275		276
276	`public:`	277		`public:`
277	`converting_handler( V* v, P* p )`	278		`converting_handler( V* v, P* p )`
278	`: converting_handler::scalar_handler(p)`	279		`: converting_handler::scalar_handler(p)`
279	`, value_(v)`	280		`, value_(v)`
280	`{}`	281		`{}`
281		282
282	`bool on_number_part( system::error_code& )`	283		`bool on_number_part( system::error_code& )`
283	`{`	284		`{`
284	`return true;`	285		`return true;`
285	`}`	286		`}`
286		287
287	`bool on_int64(system::error_code& ec, std::int64_t v)`	288		`bool on_int64(system::error_code& ec, std::int64_t v)`
288	`{`	289		`{`
289	`if( !integral_in_range<V>( v ) )`	290		`if( !integral_in_range<V>( v ) )`
290	`{`	291		`{`
291	`BOOST_JSON_FAIL( ec, error::not_exact );`	292		`BOOST_JSON_FAIL( ec, error::not_exact );`
292	`return false;`	293		`return false;`
293	`}`	294		`}`
294		295
295	`*value_ = static_cast<V>( v );`	296		`*value_ = static_cast<V>( v );`
296	`return this->parent_->signal_value(ec);`	297		`return this->parent_->signal_value(ec);`
297	`}`	298		`}`
298		299
299	`bool on_uint64(system::error_code& ec, std::uint64_t v)`	300		`bool on_uint64(system::error_code& ec, std::uint64_t v)`
300	`{`	301		`{`
301	`if( !integral_in_range<V>(v) )`	302		`if( !integral_in_range<V>(v) )`
302	`{`	303		`{`
303	`BOOST_JSON_FAIL( ec, error::not_exact );`	304		`BOOST_JSON_FAIL( ec, error::not_exact );`
304	`return false;`	305		`return false;`
305	`}`	306		`}`
306		307
307	`*value_ = static_cast<V>(v);`	308		`*value_ = static_cast<V>(v);`
308	`return this->parent_->signal_value(ec);`	309		`return this->parent_->signal_value(ec);`
309	`}`	310		`}`
310	`};`	311		`};`
311		312
312	`// floating point handler`	313		`// floating point handler`
313	`template< class V, class P>`	314		`template< class V, class P>`
314	`class converting_handler<floating_point_conversion_tag, V, P>`	315		`class converting_handler<floating_point_conversion_tag, V, P>`
315	`: public scalar_handler<P, error::not_double>`	316		`: public scalar_handler<P, error::not_double>`
316	`{`	317		`{`
317	`private:`	318		`private:`
318	`V* value_;`	319		`V* value_;`
319		320
320	`public:`	321		`public:`
321	`converting_handler( V* v, P* p )`	322		`converting_handler( V* v, P* p )`
322	`: converting_handler::scalar_handler(p)`	323		`: converting_handler::scalar_handler(p)`
323	`, value_(v)`	324		`, value_(v)`
324	`{}`	325		`{}`
325		326
326	`bool on_number_part( system::error_code& )`	327		`bool on_number_part( system::error_code& )`
327	`{`	328		`{`
328	`return true;`	329		`return true;`
329	`}`	330		`}`
330		331
331	`bool on_int64(system::error_code& ec, std::int64_t v)`	332		`bool on_int64(system::error_code& ec, std::int64_t v)`
332	`{`	333		`{`
333	`*value_ = static_cast<V>(v);`	334		`*value_ = static_cast<V>(v);`
334	`return this->parent_->signal_value(ec);`	335		`return this->parent_->signal_value(ec);`
335	`}`	336		`}`
336		337
337	`bool on_uint64(system::error_code& ec, std::uint64_t v)`	338		`bool on_uint64(system::error_code& ec, std::uint64_t v)`
338	`{`	339		`{`
339	`*value_ = static_cast<V>(v);`	340		`*value_ = static_cast<V>(v);`
340	`return this->parent_->signal_value(ec);`	341		`return this->parent_->signal_value(ec);`
341	`}`	342		`}`
342		343
343	`bool on_double(system::error_code& ec, double v)`	344		`bool on_double(system::error_code& ec, double v)`
344	`{`	345		`{`
345	`*value_ = static_cast<V>(v);`	346		`*value_ = static_cast<V>(v);`
346	`return this->parent_->signal_value(ec);`	347		`return this->parent_->signal_value(ec);`
347	`}`	348		`}`
348	`};`	349		`};`
349		350
350	`// string handler`	351		`// string handler`
351	`template< class V, class P >`	352		`template< class V, class P >`
352	`class converting_handler<string_like_conversion_tag, V, P>`	353		`class converting_handler<string_like_conversion_tag, V, P>`
353	`: public scalar_handler<P, error::not_string>`	354		`: public scalar_handler<P, error::not_string>`
354	`{`	355		`{`
355	`private:`	356		`private:`
356	`V* value_;`	357		`V* value_;`
357	`bool cleared_ = false;`	358		`bool cleared_ = false;`
358		359
359	`public:`	360		`public:`
360	`converting_handler( V* v, P* p )`	361		`converting_handler( V* v, P* p )`
361	`: converting_handler::scalar_handler(p)`	362		`: converting_handler::scalar_handler(p)`
362	`, value_(v)`	363		`, value_(v)`
363	`{}`	364		`{}`
364		365
365	`bool on_string_part( system::error_code&, string_view sv )`	366		`bool on_string_part( system::error_code&, string_view sv )`
366	`{`	367		`{`
367	`if( !cleared_ )`	368		`if( !cleared_ )`
368	`{`	369		`{`
369	`cleared_ = true;`	370		`cleared_ = true;`
370	`value_->clear();`	371		`value_->clear();`
371	`}`	372		`}`
372		373
373	`value_->append( sv.begin(), sv.end() );`	374		`value_->append( sv.begin(), sv.end() );`
374	`return true;`	375		`return true;`
375	`}`	376		`}`
376		377
377	`bool on_string(system::error_code& ec, string_view sv)`	378		`bool on_string(system::error_code& ec, string_view sv)`
378	`{`	379		`{`
379	`if( !cleared_ )`	380		`if( !cleared_ )`
380	`value_->clear();`	381		`value_->clear();`
381	`else`	382		`else`
382	`cleared_ = false;`	383		`cleared_ = false;`
383		384
384	`value_->append( sv.begin(), sv.end() );`	385		`value_->append( sv.begin(), sv.end() );`
385	`return this->parent_->signal_value(ec);`	386		`return this->parent_->signal_value(ec);`
386	`}`	387		`}`
387	`};`	388		`};`
388		389
389	`// bool handler`	390		`// bool handler`
390	`template< class V, class P >`	391		`template< class V, class P >`
391	`class converting_handler<bool_conversion_tag, V, P>`	392		`class converting_handler<bool_conversion_tag, V, P>`
392	`: public scalar_handler<P, error::not_bool>`	393		`: public scalar_handler<P, error::not_bool>`
393	`{`	394		`{`
394	`private:`	395		`private:`
395	`V* value_;`	396		`V* value_;`
396		397
397	`public:`	398		`public:`
398	`converting_handler( V* v, P* p )`	399		`converting_handler( V* v, P* p )`
399	`: converting_handler::scalar_handler(p)`	400		`: converting_handler::scalar_handler(p)`
400	`, value_(v)`	401		`, value_(v)`
401	`{}`	402		`{}`
402		403
403	`bool on_bool(system::error_code& ec, bool v)`	404		`bool on_bool(system::error_code& ec, bool v)`
404	`{`	405		`{`
405	`*value_ = v;`	406		`*value_ = v;`
406	`return this->parent_->signal_value(ec);`	407		`return this->parent_->signal_value(ec);`
407	`}`	408		`}`
408	`};`	409		`};`
409		410
410	`// null handler`	411		`// null handler`
411	`template< class V, class P >`	412		`template< class V, class P >`
412	`class converting_handler<null_like_conversion_tag, V, P>`	413		`class converting_handler<null_like_conversion_tag, V, P>`
413	`: public scalar_handler<P, error::not_null>`	414		`: public scalar_handler<P, error::not_null>`
414	`{`	415		`{`
415	`private:`	416		`private:`
416	`V* value_;`	417		`V* value_;`
417		418
418	`public:`	419		`public:`
419	`converting_handler( V* v, P* p )`	420		`converting_handler( V* v, P* p )`
420	`: converting_handler::scalar_handler(p)`	421		`: converting_handler::scalar_handler(p)`
421	`, value_(v)`	422		`, value_(v)`
422	`{}`	423		`{}`
423		424
424	`bool on_null(system::error_code& ec)`	425		`bool on_null(system::error_code& ec)`
425	`{`	426		`{`
426	`*value_ = {};`	427		`*value_ = {};`
427	`return this->parent_->signal_value(ec);`	428		`return this->parent_->signal_value(ec);`
428	`}`	429		`}`
429	`};`	430		`};`
430		431
431	`// described enum handler`	432		`// described enum handler`
432	`template< class V, class P >`	433		`template< class V, class P >`
433	`class converting_handler<described_enum_conversion_tag, V, P>`	434		`class converting_handler<described_enum_conversion_tag, V, P>`
434	`: public scalar_handler<P, error::not_string>`	435		`: public scalar_handler<P, error::not_string>`
435	`{`	436		`{`
436	`#ifndef BOOST_DESCRIBE_CXX14`	437		`#ifndef BOOST_DESCRIBE_CXX14`
437		438
438	`static_assert(`	439		`static_assert(`
439	`sizeof(V) == 0, "Enum support for parse_into requires C++14" );`	440		`sizeof(V) == 0, "Enum support for parse_into requires C++14" );`
440		441
441	`#else`	442		`#else`
442		443
443	`private:`	444		`private:`
444	`V* value_;`	445		`V* value_;`
445	`std::string name_;`	446		`std::string name_;`
446		447
447	`public:`	448		`public:`
448	`converting_handler( V* v, P* p )`	449		`converting_handler( V* v, P* p )`
449	`: converting_handler::scalar_handler(p)`	450		`: converting_handler::scalar_handler(p)`
450	`, value_(v)`	451		`, value_(v)`
451	`{}`	452		`{}`
452		453
453	`bool on_string_part( system::error_code&, string_view sv )`	454		`bool on_string_part( system::error_code&, string_view sv )`
454	`{`	455		`{`
455	`name_.append( sv.begin(), sv.end() );`	456		`name_.append( sv.begin(), sv.end() );`
456	`return true;`	457		`return true;`
457	`}`	458		`}`
458		459
459	`bool on_string(system::error_code& ec, string_view sv)`	460		`bool on_string(system::error_code& ec, string_view sv)`
460	`{`	461		`{`
461	`string_view name = sv;`	462		`string_view name = sv;`
462	`if( !name_.empty() )`	463		`if( !name_.empty() )`
463	`{`	464		`{`
464	`name_.append( sv.begin(), sv.end() );`	465		`name_.append( sv.begin(), sv.end() );`
465	`name = name_;`	466		`name = name_;`
466	`}`	467		`}`
467		468
468	`if( !describe::enum_from_string(name, *value_) )`	469		`if( !describe::enum_from_string(name, *value_) )`
469	`{`	470		`{`
470	`BOOST_JSON_FAIL(ec, error::unknown_name);`	471		`BOOST_JSON_FAIL(ec, error::unknown_name);`
471	`return false;`	472		`return false;`
472	`}`	473		`}`
473		474
474	`return this->parent_->signal_value(ec);`	475		`return this->parent_->signal_value(ec);`
475	`}`	476		`}`
476		477
477	`#endif // BOOST_DESCRIBE_CXX14`	478		`#endif // BOOST_DESCRIBE_CXX14`
478	`};`	479		`};`
479		480
480	`template< class V, class P >`	481		`template< class V, class P >`
481	`class converting_handler<no_conversion_tag, V, P>`	482		`class converting_handler<no_conversion_tag, V, P>`
482	`{`	483		`{`
483	`static_assert( sizeof(V) == 0, "This type is not supported" );`	484		`static_assert( sizeof(V) == 0, "This type is not supported" );`
484	`};`	485		`};`
485		486
486	`// sequence handler`	487		`// sequence handler`
487	`template< class It >`	488		`template< class It >`
488	`bool cannot_insert(It i, It e)`	489		`bool cannot_insert(It i, It e)`
489	`{`	490		`{`
490	`return i == e;`	491		`return i == e;`
491	`}`	492		`}`
492		493
493	`template< class It1, class It2 >`	494		`template< class It1, class It2 >`
494	`std::false_type cannot_insert(It1, It2)`	495		`std::false_type cannot_insert(It1, It2)`
495	`{`	496		`{`
496	`return {};`	497		`return {};`
497	`}`	498		`}`
498		499
499	`template< class It >`	500		`template< class It >`
500	`bool needs_more_elements(It i, It e)`	501		`bool needs_more_elements(It i, It e)`
501	`{`	502		`{`
502	`return i != e;`	503		`return i != e;`
503	`}`	504		`}`
504		505
505	`template< class It1, class It2 >`	506		`template< class It1, class It2 >`
506	`std::false_type needs_more_elements(It1, It2)`	507		`std::false_type needs_more_elements(It1, It2)`
507	`{`	508		`{`
508	`return {};`	509		`return {};`
509	`}`	510		`}`
510		511
511	`template<class T>`	512		`template<class T>`
512	`void`	513		`void`
513	`clear_container(`	514		`clear_container(`
514	`T&,`	515		`T&,`
515	`mp11::mp_int<2>)`	516		`mp11::mp_int<2>)`
516	`{`	517		`{`
517	`}`	518		`}`
518		519
519	`template<class T>`	520		`template<class T>`
520	`void`	521		`void`
521	`clear_container(`	522		`clear_container(`
522	`T& target,`	523		`T& target,`
523	`mp11::mp_int<1>)`	524		`mp11::mp_int<1>)`
524	`{`	525		`{`
525	`target.clear();`	526		`target.clear();`
526	`}`	527		`}`
527		528
528	`template<class T>`	529		`template<class T>`
529	`void`	530		`void`
530	`clear_container(`	531		`clear_container(`
531	`T& target,`	532		`T& target,`
532	`mp11::mp_int<0>)`	533		`mp11::mp_int<0>)`
533	`{`	534		`{`
534	`target.clear();`	535		`target.clear();`
535	`}`	536		`}`
536		537
537	`template< class V, class P >`	538		`template< class V, class P >`
538	`class converting_handler<sequence_conversion_tag, V, P>`	539		`class converting_handler<sequence_conversion_tag, V, P>`
539	`: public composite_handler<`	540		`: public composite_handler<`
540	`converting_handler<sequence_conversion_tag, V, P>,`	541		`converting_handler<sequence_conversion_tag, V, P>,`
541	`detail::value_type<V>,`	542		`detail::value_type<V>,`
542	`P,`	543		`P,`
543	`error::not_array>`	544		`error::not_array>`
544	`{`	545		`{`
545	`private:`	546		`private:`
546	`V* value_;`	547		`V* value_;`
547		548
548	`using Inserter = decltype(`	549		`using Inserter = decltype(`
549	`detail::inserter(*value_, inserter_implementation<V>()) );`	550		`detail::inserter(*value_, inserter_implementation<V>()) );`
550	`Inserter inserter;`	551		`Inserter inserter;`
551		552
552	`public:`	553		`public:`
553	`converting_handler( V* v, P* p )`	554		`converting_handler( V* v, P* p )`
554	`: converting_handler::composite_handler(p)`	555		`: converting_handler::composite_handler(p)`
555	`, value_(v)`	556		`, value_(v)`
556	`, inserter( detail::inserter(*value_, inserter_implementation<V>()) )`	557		`, inserter( detail::inserter(*value_, inserter_implementation<V>()) )`
557	`{}`	558		`{}`
558		559
559	`bool signal_value(system::error_code& ec)`	560		`bool signal_value(system::error_code& ec)`
560	`{`	561		`{`
561	`if(cannot_insert( inserter, value_->end() ))`	562		`if(cannot_insert( inserter, value_->end() ))`
562	`{`	563		`{`
563	`BOOST_JSON_FAIL( ec, error::size_mismatch );`	564		`BOOST_JSON_FAIL( ec, error::size_mismatch );`
564	`return false;`	565		`return false;`
565	`}`	566		`}`
566		567
567	`*inserter++ = std::move(this->next_value_);`	568		`*inserter++ = std::move(this->next_value_);`
568	`#if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)`	569		`#if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)`
569	`# pragma GCC diagnostic push`	570		`# pragma GCC diagnostic push`
570	`# pragma GCC diagnostic ignored "-Wmissing-field-initializers"`	571		`# pragma GCC diagnostic ignored "-Wmissing-field-initializers"`
571	`#endif`	572		`#endif`
572	`this->next_value_ = {};`	573		`this->next_value_ = {};`
573	`#if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)`	574		`#if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)`
574	`# pragma GCC diagnostic pop`	575		`# pragma GCC diagnostic pop`
575	`#endif`	576		`#endif`
576	`return true;`	577		`return true;`
577	`}`	578		`}`
578		579
579	`bool signal_end(system::error_code& ec)`	580		`bool signal_end(system::error_code& ec)`
580	`{`	581		`{`
581	`if(needs_more_elements( inserter, value_->end() ))`	582		`if(needs_more_elements( inserter, value_->end() ))`
582	`{`	583		`{`
583	`BOOST_JSON_FAIL( ec, error::size_mismatch );`	584		`BOOST_JSON_FAIL( ec, error::size_mismatch );`
584	`return false;`	585		`return false;`
585	`}`	586		`}`
586		587
587	`inserter = detail::inserter(*value_, inserter_implementation<V>());`	588		`inserter = detail::inserter(*value_, inserter_implementation<V>());`
588		589
589	`return converting_handler::composite_handler::signal_end(ec);`	590		`return converting_handler::composite_handler::signal_end(ec);`
590	`}`	591		`}`
591		592
592	`bool on_array_begin( system::error_code& ec )`	593		`bool on_array_begin( system::error_code& ec )`
593	`{`	594		`{`
594	`if( this->inner_active_ )`	595		`if( this->inner_active_ )`
595	`return this->inner_.on_array_begin( ec );`	596		`return this->inner_.on_array_begin( ec );`
596		597
597	`this->inner_active_ = true;`	598		`this->inner_active_ = true;`
598	`clear_container( *value_, inserter_implementation<V>() );`	599		`clear_container( *value_, inserter_implementation<V>() );`
599	`return true;`	600		`return true;`
600	`}`	601		`}`
601		602
602	`bool on_array_end( system::error_code& ec )`	603		`bool on_array_end( system::error_code& ec )`
603	`{`	604		`{`
604	`if( this->inner_active_ )`	605		`if( this->inner_active_ )`
605	`return this->inner_.on_array_end( ec );`	606		`return this->inner_.on_array_end( ec );`
606		607
607	`return this->parent_->signal_end(ec);`	608		`return this->parent_->signal_end(ec);`
608	`}`	609		`}`
609	`};`	610		`};`
610		611
611	`// map handler`	612		`// map handler`
612	`template< class V, class P >`	613		`template< class V, class P >`
613	`class converting_handler<map_like_conversion_tag, V, P>`	614		`class converting_handler<map_like_conversion_tag, V, P>`
614	`: public composite_handler<`	615		`: public composite_handler<`
615	`converting_handler<map_like_conversion_tag, V, P>,`	616		`converting_handler<map_like_conversion_tag, V, P>,`
616	`detail::mapped_type<V>,`	617		`detail::mapped_type<V>,`
617	`P,`	618		`P,`
618	`error::not_object>`	619		`error::not_object>`
619	`{`	620		`{`
620	`private:`	621		`private:`
621	`V* value_;`	622		`V* value_;`
622	`std::string key_;`	623		`std::string key_;`
623		624
624	`public:`	625		`public:`
625	`converting_handler( V* v, P* p )`	626		`converting_handler( V* v, P* p )`
626	`: converting_handler::composite_handler(p), value_(v)`	627		`: converting_handler::composite_handler(p), value_(v)`
627	`{}`	628		`{}`
628		629
629	`bool signal_value(system::error_code&)`	630		`bool signal_value(system::error_code&)`
630	`{`	631		`{`
631	`value_->emplace( std::move(key_), std::move(this->next_value_) );`	632		`value_->emplace( std::move(key_), std::move(this->next_value_) );`
632		633
633	`key_ = {};`	634		`key_ = {};`
634	`this->next_value_ = {};`	635		`this->next_value_ = {};`
635		636
636	`this->inner_active_ = false;`	637		`this->inner_active_ = false;`
637		638
638	`return true;`	639		`return true;`
639	`}`	640		`}`
640		641
641	`bool on_object_begin( system::error_code& ec )`	642		`bool on_object_begin( system::error_code& ec )`
642	`{`	643		`{`
643	`if( this->inner_active_ )`	644		`if( this->inner_active_ )`
644	`return this->inner_.on_object_begin(ec);`	645		`return this->inner_.on_object_begin(ec);`
645		646
646	`clear_container( *value_, inserter_implementation<V>() );`	647		`clear_container( *value_, inserter_implementation<V>() );`
647	`return true;`	648		`return true;`
648	`}`	649		`}`
649		650
650	`bool on_object_end(system::error_code& ec)`	651		`bool on_object_end(system::error_code& ec)`
651	`{`	652		`{`
652	`if( this->inner_active_ )`	653		`if( this->inner_active_ )`
653	`return this->inner_.on_object_end(ec);`	654		`return this->inner_.on_object_end(ec);`
654		655
655	`return this->parent_->signal_value(ec);`	656		`return this->parent_->signal_value(ec);`
656	`}`	657		`}`
657		658
658	`bool on_array_end( system::error_code& ec )`	659		`bool on_array_end( system::error_code& ec )`
659	`{`	660		`{`
660	`if( this->inner_active_ )`	661		`if( this->inner_active_ )`
661	`return this->inner_.on_array_end(ec);`	662		`return this->inner_.on_array_end(ec);`
662		663
663	`return this->parent_->signal_end(ec);`	664		`return this->parent_->signal_end(ec);`
664	`}`	665		`}`
665		666
666	`bool on_key_part( system::error_code& ec, string_view sv )`	667		`bool on_key_part( system::error_code& ec, string_view sv )`
667	`{`	668		`{`
668	`if( this->inner_active_ )`	669		`if( this->inner_active_ )`
669	`return this->inner_.on_key_part(ec, sv);`	670		`return this->inner_.on_key_part(ec, sv);`
670		671
671	`key_.append( sv.data(), sv.size() );`	672		`key_.append( sv.data(), sv.size() );`
672	`return true;`	673		`return true;`
673	`}`	674		`}`
674		675
675	`bool on_key( system::error_code& ec, string_view sv )`	676		`bool on_key( system::error_code& ec, string_view sv )`
676	`{`	677		`{`
677	`if( this->inner_active_ )`	678		`if( this->inner_active_ )`
678	`return this->inner_.on_key(ec, sv);`	679		`return this->inner_.on_key(ec, sv);`
679		680
680	`key_.append( sv.data(), sv.size() );`	681		`key_.append( sv.data(), sv.size() );`
681		682
682	`this->inner_active_ = true;`	683		`this->inner_active_ = true;`
683	`return true;`	684		`return true;`
684	`}`	685		`}`
685	`};`	686		`};`
686		687
687	`// tuple handler`	688		`// tuple handler`
688	`template<std::size_t I, class T>`	689		`template<std::size_t I, class T>`
689	`struct handler_tuple_element`	690		`struct handler_tuple_element`
690	`{`	691		`{`
691	`template< class... Args >`	692		`template< class... Args >`
692	`handler_tuple_element( Args&& ... args )`	693		`handler_tuple_element( Args&& ... args )`
693	`: t_( static_cast<Args&&>(args)... )`	694		`: t_( static_cast<Args&&>(args)... )`
694	`{}`	695		`{}`
695		696
696	`T t_;`	697		`T t_;`
697	`};`	698		`};`
698		699
699	`template<std::size_t I, class T>`	700		`template<std::size_t I, class T>`
700	`T&`	701		`T&`
701	`get( handler_tuple_element<I, T>& e )`	702		`get( handler_tuple_element<I, T>& e )`
702	`{`	703		`{`
703	`return e.t_;`	704		`return e.t_;`
704	`}`	705		`}`
705		706
706	`template<`	707		`template<`
707	`class P,`	708		`class P,`
708	`class LV,`	709		`class LV,`
709	`class S = mp11::make_index_sequence<mp11::mp_size<LV>::value> >`	710		`class S = mp11::make_index_sequence<mp11::mp_size<LV>::value> >`
710	`struct handler_tuple;`	711		`struct handler_tuple;`
711		712
712	`template< class P, template<class...> class L, class... V, std::size_t... I >`	713		`template< class P, template<class...> class L, class... V, std::size_t... I >`
713	`struct handler_tuple< P, L<V...>, mp11::index_sequence<I...> >`	714		`struct handler_tuple< P, L<V...>, mp11::index_sequence<I...> >`
714	`: handler_tuple_element<I, V>`	715		`: handler_tuple_element<I, V>`
715	`...`	716		`...`
716	`{`	717		`{`
717	`handler_tuple( handler_tuple const& ) = delete;`	718		`handler_tuple( handler_tuple const& ) = delete;`
718	`handler_tuple& operator=( handler_tuple const& ) = delete;`	719		`handler_tuple& operator=( handler_tuple const& ) = delete;`
719		720
720	`template< class Access, class T >`	721		`template< class Access, class T >`
721	`handler_tuple( Access access, T* pv, P* pp )`	722		`handler_tuple( Access access, T* pv, P* pp )`
722	`: handler_tuple_element<I, V>(`	723		`: handler_tuple_element<I, V>(`
723	`access( pv, mp11::mp_size_t<I>() ),`	724		`access( pv, mp11::mp_size_t<I>() ),`
724	`pp )`	725		`pp )`
725	`...`	726		`...`
726	`{}`	727		`{}`
727	`};`	728		`};`
728		729
729	`#if defined(BOOST_MSVC) && BOOST_MSVC < 1910`	730		`#if defined(BOOST_MSVC) && BOOST_MSVC < 1910`
730		731
731	`template< class T >`	732		`template< class T >`
732	`struct tuple_element_list_impl`	733		`struct tuple_element_list_impl`
733	`{`	734		`{`
734	`template< class I >`	735		`template< class I >`
735	`using tuple_element_helper = tuple_element_t<I::value, T>;`	736		`using tuple_element_helper = tuple_element_t<I::value, T>;`
736		737
737	`using type = mp11::mp_transform<`	738		`using type = mp11::mp_transform<`
738	`tuple_element_helper,`	739		`tuple_element_helper,`
739	`mp11::mp_iota< std::tuple_size<T> > >;`	740		`mp11::mp_iota< std::tuple_size<T> > >;`
740	`};`	741		`};`
741	`template< class T >`	742		`template< class T >`
742	`using tuple_element_list = typename tuple_element_list_impl<T>::type;`	743		`using tuple_element_list = typename tuple_element_list_impl<T>::type;`
743		744
744	`#else`	745		`#else`
745		746
746	`template< class I, class T >`	747		`template< class I, class T >`
747	`using tuple_element_helper = tuple_element_t<I::value, T>;`	748		`using tuple_element_helper = tuple_element_t<I::value, T>;`
748	`template< class T >`	749		`template< class T >`
749	`using tuple_element_list = mp11::mp_transform_q<`	750		`using tuple_element_list = mp11::mp_transform_q<`
750	`mp11::mp_bind_back< tuple_element_helper, T>,`	751		`mp11::mp_bind_back< tuple_element_helper, T>,`
751	`mp11::mp_iota< std::tuple_size<T> > >;`	752		`mp11::mp_iota< std::tuple_size<T> > >;`
752		753
753	`#endif`	754		`#endif`
754		755
755	`template< class Op, class... Args>`	756		`template< class Op, class... Args>`
756	`struct handler_op_invoker`	757		`struct handler_op_invoker`
757	`{`	758		`{`
758	`public:`	759		`public:`
759	`std::tuple<Args&...> args;`	760		`std::tuple<Args&...> args;`
760		761
761	`template< class Handler >`	762		`template< class Handler >`
762	`bool`	763		`bool`
763	`operator()( Handler& handler ) const`	764		`operator()( Handler& handler ) const`
764	`{`	765		`{`
765	`return (*this)( handler, mp11::index_sequence_for<Args...>() );`	766		`return (*this)( handler, mp11::index_sequence_for<Args...>() );`
766	`}`	767		`}`
767		768
768	`private:`	769		`private:`
769	`template< class Handler, std::size_t... I >`	770		`template< class Handler, std::size_t... I >`
770	`bool`	771		`bool`
771	`operator()( Handler& handler, mp11::index_sequence<I...> ) const`	772		`operator()( Handler& handler, mp11::index_sequence<I...> ) const`
772	`{`	773		`{`
773	`return Op()( handler, std::get<I>(args)... );`	774		`return Op()( handler, std::get<I>(args)... );`
774	`}`	775		`}`
775	`};`	776		`};`
776		777
777	`template< class Handlers, class F >`	778		`template< class Handlers, class F >`
778	`struct tuple_handler_op_invoker`	779		`struct tuple_handler_op_invoker`
779	`{`	780		`{`
780	`Handlers& handlers;`	781		`Handlers& handlers;`
781	`F fn;`	782		`F fn;`
782		783
783	`template< class I >`	784		`template< class I >`
784	`bool`	785		`bool`
785	`operator()( I ) const`	786		`operator()( I ) const`
786	`{`	787		`{`
787	`return fn( get<I::value>(handlers) );`	788		`return fn( get<I::value>(handlers) );`
788	`}`	789		`}`
789	`};`	790		`};`
790		791
791	`struct tuple_accessor`	792		`struct tuple_accessor`
792	`{`	793		`{`
793	`template< class T, class I >`	794		`template< class T, class I >`
794	`auto operator()( T* t, I ) const -> tuple_element_t<I::value, T>*`	795		`auto operator()( T* t, I ) const -> tuple_element_t<I::value, T>*`
795	`{`	796		`{`
796	`using std::get;`	797		`using std::get;`
797	`return &get<I::value>(*t);`	798		`return &get<I::value>(*t);`
798	`}`	799		`}`
799	`};`	800		`};`
800		801
801	`template< class T, class P >`	802		`template< class T, class P >`
802	`class converting_handler<tuple_conversion_tag, T, P>`	803		`class converting_handler<tuple_conversion_tag, T, P>`
803	`{`	804		`{`
804		805
805	`private:`	806		`private:`
806	`using ElementTypes = tuple_element_list<T>;`	807		`using ElementTypes = tuple_element_list<T>;`
807		808
808	`template<class V>`	809		`template<class V>`
809	`using ElementHandler = get_handler<V, converting_handler>;`	810		`using ElementHandler = get_handler<V, converting_handler>;`
810	`using InnerHandlers = mp11::mp_transform<ElementHandler, ElementTypes>;`	811		`using InnerHandlers = mp11::mp_transform<ElementHandler, ElementTypes>;`
811	`using HandlerTuple = handler_tuple<converting_handler, InnerHandlers>;`	812		`using HandlerTuple = handler_tuple<converting_handler, InnerHandlers>;`
812		813
813	`T* value_;`	814		`T* value_;`
814	`P* parent_;`	815		`P* parent_;`
815		816
816	`HandlerTuple handlers_;`	817		`HandlerTuple handlers_;`
817	`int inner_active_ = -1;`	818		`int inner_active_ = -1;`
818		819
819	`public:`	820		`public:`
820	`converting_handler( converting_handler const& ) = delete;`	821		`converting_handler( converting_handler const& ) = delete;`
821	`converting_handler& operator=( converting_handler const& ) = delete;`	822		`converting_handler& operator=( converting_handler const& ) = delete;`
822		823
823	`converting_handler( T* v, P* p )`	824		`converting_handler( T* v, P* p )`
824	`: value_(v) , parent_(p) , handlers_(tuple_accessor(), v, this)`	825		`: value_(v) , parent_(p) , handlers_(tuple_accessor(), v, this)`
825	`{}`	826		`{}`
826		827
827	`bool signal_value(system::error_code&)`	828		`bool signal_value(system::error_code&)`
828	`{`	829		`{`
829	`++inner_active_;`	830		`++inner_active_;`
830	`return true;`	831		`return true;`
831	`}`	832		`}`
832		833
833	`bool signal_end(system::error_code& ec)`	834		`bool signal_end(system::error_code& ec)`
834	`{`	835		`{`
835	`constexpr int N = std::tuple_size<T>::value;`	836		`constexpr int N = std::tuple_size<T>::value;`
836	`if( inner_active_ < N )`	837		`if( inner_active_ < N )`
837	`{`	838		`{`
838	`BOOST_JSON_FAIL( ec, error::size_mismatch );`	839		`BOOST_JSON_FAIL( ec, error::size_mismatch );`
839	`return false;`	840		`return false;`
840	`}`	841		`}`
841		842
842	`inner_active_ = -1;`	843		`inner_active_ = -1;`
843	`return parent_->signal_value(ec);`	844		`return parent_->signal_value(ec);`
844	`}`	845		`}`
845		846
846	`#define BOOST_JSON_HANDLE_EVENT(fn) \`	847		`#define BOOST_JSON_HANDLE_EVENT(fn) \`
847	`struct do_ ## fn \`	848		`struct do_ ## fn \`
848	`{ \`	849		`{ \`
849	`template< class H, class... Args > \`	850		`template< class H, class... Args > \`
850	`bool operator()( H& h, Args& ... args ) const \`	851		`bool operator()( H& h, Args& ... args ) const \`
851	`{ \`	852		`{ \`
852	`return h. fn (args...); \`	853		`return h. fn (args...); \`
853	`} \`	854		`} \`
854	`}; \`	855		`}; \`
855	`\`	856		`\`
856	`template< class... Args > \`	857		`template< class... Args > \`
857	`bool fn( system::error_code& ec, Args&& ... args ) \`	858		`bool fn( system::error_code& ec, Args&& ... args ) \`
858	`{ \`	859		`{ \`
859	`if( inner_active_ < 0 ) \`	860		`if( inner_active_ < 0 ) \`
860	`{ \`	861		`{ \`
861	`BOOST_JSON_FAIL( ec, error::not_array ); \`	862		`BOOST_JSON_FAIL( ec, error::not_array ); \`
862	`return false; \`	863		`return false; \`
863	`} \`	864		`} \`
864	`constexpr int N = std::tuple_size<T>::value; \`	865		`constexpr int N = std::tuple_size<T>::value; \`
865	`if( inner_active_ >= N ) \`	866		`if( inner_active_ >= N ) \`
866	`{ \`	867		`{ \`
867	`BOOST_JSON_FAIL( ec, error::size_mismatch ); \`	868		`BOOST_JSON_FAIL( ec, error::size_mismatch ); \`
868	`return false; \`	869		`return false; \`
869	`} \`	870		`} \`
870	`using F = handler_op_invoker< do_ ## fn, system::error_code, Args...>; \`	871		`using F = handler_op_invoker< do_ ## fn, system::error_code, Args...>; \`
871	`using H = decltype(handlers_); \`	872		`using H = decltype(handlers_); \`
872	`return mp11::mp_with_index<N>( \`	873		`return mp11::mp_with_index<N>( \`
873	`inner_active_, \`	874		`inner_active_, \`
874	`tuple_handler_op_invoker<H, F>{ \`	875		`tuple_handler_op_invoker<H, F>{ \`
875	`handlers_, \`	876		`handlers_, \`
876	`F{ std::forward_as_tuple(ec, args...) } } ); \`	877		`F{ std::forward_as_tuple(ec, args...) } } ); \`
877	`}`	878		`}`
878		879
879	`BOOST_JSON_HANDLE_EVENT( on_object_begin )`	880		`BOOST_JSON_HANDLE_EVENT( on_object_begin )`
880	`BOOST_JSON_HANDLE_EVENT( on_object_end )`	881		`BOOST_JSON_HANDLE_EVENT( on_object_end )`
881		882
882	`struct do_on_array_begin`	883		`struct do_on_array_begin`
883	`{`	884		`{`
884	`HandlerTuple& handlers;`	885		`HandlerTuple& handlers;`
885	`system::error_code& ec;`	886		`system::error_code& ec;`
886		887
887	`template< class I >`	888		`template< class I >`
888	`bool operator()( I ) const`	889		`bool operator()( I ) const`
889	`{`	890		`{`
890	`return get<I::value>(handlers).on_array_begin(ec);`	891		`return get<I::value>(handlers).on_array_begin(ec);`
891	`}`	892		`}`
892	`};`	893		`};`
893	`bool on_array_begin( system::error_code& ec )`	894		`bool on_array_begin( system::error_code& ec )`
894	`{`	895		`{`
895	`if( inner_active_ < 0 )`	896		`if( inner_active_ < 0 )`
896	`{`	897		`{`
897	`inner_active_ = 0;`	898		`inner_active_ = 0;`
898	`return true;`	899		`return true;`
899	`}`	900		`}`
900		901
901	`constexpr int N = std::tuple_size<T>::value;`	902		`constexpr int N = std::tuple_size<T>::value;`
902		903
903	`if( inner_active_ >= N )`	904		`if( inner_active_ >= N )`
904	`{`	905		`{`
905	`BOOST_JSON_FAIL( ec, error::size_mismatch );`	906		`BOOST_JSON_FAIL( ec, error::size_mismatch );`
906	`return false;`	907		`return false;`
907	`}`	908		`}`
908		909
909	`return mp11::mp_with_index<N>(`	910		`return mp11::mp_with_index<N>(`
910	`inner_active_, do_on_array_begin{handlers_, ec} );`	911		`inner_active_, do_on_array_begin{handlers_, ec} );`
911	`}`	912		`}`
912		913
913	`struct do_on_array_end`	914		`struct do_on_array_end`
914	`{`	915		`{`
915	`HandlerTuple& handlers;`	916		`HandlerTuple& handlers;`
916	`system::error_code& ec;`	917		`system::error_code& ec;`
917		918
918	`template< class I >`	919		`template< class I >`
919	`bool operator()( I ) const`	920		`bool operator()( I ) const`
920	`{`	921		`{`
921	`return get<I::value>(handlers).on_array_end(ec);`	922		`return get<I::value>(handlers).on_array_end(ec);`
922	`}`	923		`}`
923	`};`	924		`};`
924	`bool on_array_end( system::error_code& ec )`	925		`bool on_array_end( system::error_code& ec )`
925	`{`	926		`{`
926	`if( inner_active_ < 0 )`	927		`if( inner_active_ < 0 )`
927	`return parent_->signal_end(ec);`	928		`return parent_->signal_end(ec);`
928		929
929	`constexpr int N = std::tuple_size<T>::value;`	930		`constexpr int N = std::tuple_size<T>::value;`
930		931
931	`if( inner_active_ >= N )`	932		`if( inner_active_ >= N )`
932	`return signal_end(ec);`	933		`return signal_end(ec);`
933		934
934	`return mp11::mp_with_index<N>(`	935		`return mp11::mp_with_index<N>(`
935	`inner_active_, do_on_array_end{handlers_, ec} );`	936		`inner_active_, do_on_array_end{handlers_, ec} );`
936	`}`	937		`}`
937		938
938	`BOOST_JSON_HANDLE_EVENT( on_key_part )`	939		`BOOST_JSON_HANDLE_EVENT( on_key_part )`
939	`BOOST_JSON_HANDLE_EVENT( on_key )`	940		`BOOST_JSON_HANDLE_EVENT( on_key )`
940	`BOOST_JSON_HANDLE_EVENT( on_string_part )`	941		`BOOST_JSON_HANDLE_EVENT( on_string_part )`
941	`BOOST_JSON_HANDLE_EVENT( on_string )`	942		`BOOST_JSON_HANDLE_EVENT( on_string )`
942	`BOOST_JSON_HANDLE_EVENT( on_number_part )`	943		`BOOST_JSON_HANDLE_EVENT( on_number_part )`
943	`BOOST_JSON_HANDLE_EVENT( on_int64 )`	944		`BOOST_JSON_HANDLE_EVENT( on_int64 )`
944	`BOOST_JSON_HANDLE_EVENT( on_uint64 )`	945		`BOOST_JSON_HANDLE_EVENT( on_uint64 )`
945	`BOOST_JSON_HANDLE_EVENT( on_double )`	946		`BOOST_JSON_HANDLE_EVENT( on_double )`
946	`BOOST_JSON_HANDLE_EVENT( on_bool )`	947		`BOOST_JSON_HANDLE_EVENT( on_bool )`
947	`BOOST_JSON_HANDLE_EVENT( on_null )`	948		`BOOST_JSON_HANDLE_EVENT( on_null )`
948		949
949	`#undef BOOST_JSON_HANDLE_EVENT`	950		`#undef BOOST_JSON_HANDLE_EVENT`
950	`};`	951		`};`
951		952
952	`// described struct handler`	953		`// described struct handler`
953	`#if defined(BOOST_MSVC) && BOOST_MSVC < 1910`	954		`#if defined(BOOST_MSVC) && BOOST_MSVC < 1910`
954		955
955	`template< class T >`	956		`template< class T >`
956	`struct struct_element_list_impl`	957		`struct struct_element_list_impl`
957	`{`	958		`{`
958	`template< class D >`	959		`template< class D >`
959	`using helper = described_member_t<T, D>;`	960		`using helper = described_member_t<T, D>;`
960		961
961	`using type = mp11::mp_transform< helper, described_members<T> >;`	962		`using type = mp11::mp_transform< helper, described_members<T> >;`
962	`};`	963		`};`
963	`template< class T >`	964		`template< class T >`
964	`using struct_element_list = typename struct_element_list_impl<T>::type;`	965		`using struct_element_list = typename struct_element_list_impl<T>::type;`
965		966
966	`#else`	967		`#else`
967		968
968	`template< class T >`	969		`template< class T >`
969	`using struct_element_list = mp11::mp_transform_q<`	970		`using struct_element_list = mp11::mp_transform_q<`
970	`mp11::mp_bind_front< described_member_t, T >, described_members<T> >;`	971		`mp11::mp_bind_front< described_member_t, T >, described_members<T> >;`
971		972
972	`#endif`	973		`#endif`
973		974
974	`struct struct_accessor`	975		`struct struct_accessor`
975	`{`	976		`{`
976	`template< class T >`	977		`template< class T >`
977	`auto operator()( T*, mp11::mp_size< described_members<T> > ) const`	978		`auto operator()( T*, mp11::mp_size< described_members<T> > ) const`
978	`-> void*`	979		`-> void*`
979	`{`	980		`{`
980	`return nullptr;`	981		`return nullptr;`
981	`}`	982		`}`
982		983
983	`template< class T, class I >`	984		`template< class T, class I >`
984	`auto operator()( T* t, I ) const`	985		`auto operator()( T* t, I ) const`
985	`-> described_member_t<T, mp11::mp_at< described_members<T>, I> >*`	986		`-> described_member_t<T, mp11::mp_at< described_members<T>, I> >*`
986	`{`	987		`{`
987	`using Ds = described_members<T>;`	988		`using Ds = described_members<T>;`
988	`using D = mp11::mp_at<Ds, I>;`	989		`using D = mp11::mp_at<Ds, I>;`
989	`return &(t->*D::pointer);`	990		`return &(t->*D::pointer);`
990	`}`	991		`}`
991	`};`	992		`};`
992		993
993	`struct struct_key_searcher`	994		`struct struct_key_searcher`
994	`{`	995		`{`
995	`string_view key;`	996		`string_view key;`
996	`int& found;`	997		`int& found;`
997	`int index = 0;`	998		`int index = 0;`
998		999
999	`struct_key_searcher(string_view key, int& found) noexcept`	1000		`struct_key_searcher(string_view key, int& found) noexcept`
1000	`: key(key), found(found)`	1001		`: key(key), found(found)`
1001	`{}`	1002		`{}`
1002		1003
1003	`template< class D >`	1004		`template< class D >`
1004	`void`	1005		`void`
1005	`operator()( D )`	1006		`operator()( D )`
1006	`{`	1007		`{`
1007	`if( key == D::name )`	1008		`if( key == D::name )`
1008	`found = index;`	1009		`found = index;`
1009	`++index;`	1010		`++index;`
1010	`}`	1011		`}`
1011	`};`	1012		`};`
1012		1013
1013	`template<class P>`	1014		`template<class P>`
1014	`struct ignoring_handler`	1015		`struct ignoring_handler`
1015	`{`	1016		`{`
1016	`P* parent_;`	1017		`P* parent_;`
1017	`std::size_t array_depth_ = 0;`	1018		`std::size_t array_depth_ = 0;`
1018	`std::size_t object_depth_ = 0;`	1019		`std::size_t object_depth_ = 0;`
1019		1020
1020	`ignoring_handler(ignoring_handler const&) = delete;`	1021		`ignoring_handler(ignoring_handler const&) = delete;`
1021	`ignoring_handler& operator=(ignoring_handler const&) = delete;`	1022		`ignoring_handler& operator=(ignoring_handler const&) = delete;`
1022		1023
1023	`ignoring_handler(void, P p) noexcept`	1024		`ignoring_handler(void, P p) noexcept`
1024	`: parent_(p)`	1025		`: parent_(p)`
1025	`{}`	1026		`{}`
1026		1027
1027	`bool on_object_begin(system::error_code&)`	1028		`bool on_object_begin(system::error_code&)`
1028	`{`	1029		`{`
1029	`++object_depth_;`	1030		`++object_depth_;`
1030	`return true;`	1031		`return true;`
1031	`}`	1032		`}`
1032		1033
1033	`bool on_object_end(system::error_code& ec)`	1034		`bool on_object_end(system::error_code& ec)`
1034	`{`	1035		`{`
1035	`BOOST_ASSERT( object_depth_ > 0 );`	1036		`BOOST_ASSERT( object_depth_ > 0 );`
1036	`--object_depth_;`	1037		`--object_depth_;`
1037		1038
1038	`if( (array_depth_ + object_depth_) == 0 )`	1039		`if( (array_depth_ + object_depth_) == 0 )`
1039	`return parent_->signal_value(ec);`	1040		`return parent_->signal_value(ec);`
1040	`return true;`	1041		`return true;`
1041	`}`	1042		`}`
1042		1043
1043	`bool on_array_begin(system::error_code&)`	1044		`bool on_array_begin(system::error_code&)`
1044	`{`	1045		`{`
1045	`++array_depth_;`	1046		`++array_depth_;`
1046	`return true;`	1047		`return true;`
1047	`}`	1048		`}`
1048		1049
1049	`bool on_array_end(system::error_code& ec)`	1050		`bool on_array_end(system::error_code& ec)`
1050	`{`	1051		`{`
1051	`BOOST_ASSERT( array_depth_ > 0 );`	1052		`BOOST_ASSERT( array_depth_ > 0 );`
1052	`--array_depth_;`	1053		`--array_depth_;`
1053		1054
1054	`if( (array_depth_ + object_depth_) == 0 )`	1055		`if( (array_depth_ + object_depth_) == 0 )`
1055	`return parent_->signal_value(ec);`	1056		`return parent_->signal_value(ec);`
1056	`return true;`	1057		`return true;`
1057	`}`	1058		`}`
1058		1059
1059	`bool on_key_part(system::error_code&, string_view)`	1060		`bool on_key_part(system::error_code&, string_view)`
1060	`{`	1061		`{`
1061	`return true;`	1062		`return true;`
1062	`}`	1063		`}`
1063		1064
1064	`bool on_key(system::error_code&, string_view)`	1065		`bool on_key(system::error_code&, string_view)`
1065	`{`	1066		`{`
1066	`return true;`	1067		`return true;`
1067	`}`	1068		`}`
1068		1069
1069	`bool on_string_part(system::error_code&, string_view)`	1070		`bool on_string_part(system::error_code&, string_view)`
1070	`{`	1071		`{`
1071	`return true;`	1072		`return true;`
1072	`}`	1073		`}`
1073		1074
1074	`bool on_string(system::error_code& ec, string_view)`	1075		`bool on_string(system::error_code& ec, string_view)`
1075	`{`	1076		`{`
1076	`if( (array_depth_ + object_depth_) == 0 )`	1077		`if( (array_depth_ + object_depth_) == 0 )`
1077	`return parent_->signal_value(ec);`	1078		`return parent_->signal_value(ec);`
1078	`return true;`	1079		`return true;`
1079	`}`	1080		`}`
1080		1081
1081	`bool on_number_part(system::error_code&)`	1082		`bool on_number_part(system::error_code&)`
1082	`{`	1083		`{`
1083	`return true;`	1084		`return true;`
1084	`}`	1085		`}`
1085		1086
1086	`bool on_int64(system::error_code& ec, std::int64_t)`	1087		`bool on_int64(system::error_code& ec, std::int64_t)`
1087	`{`	1088		`{`
1088	`if( (array_depth_ + object_depth_) == 0 )`	1089		`if( (array_depth_ + object_depth_) == 0 )`
1089	`return parent_->signal_value(ec);`	1090		`return parent_->signal_value(ec);`
1090	`return true;`	1091		`return true;`
1091	`}`	1092		`}`
1092		1093
1093	`bool on_uint64(system::error_code& ec, std::uint64_t)`	1094		`bool on_uint64(system::error_code& ec, std::uint64_t)`
1094	`{`	1095		`{`
1095	`if( (array_depth_ + object_depth_) == 0 )`	1096		`if( (array_depth_ + object_depth_) == 0 )`
1096	`return parent_->signal_value(ec);`	1097		`return parent_->signal_value(ec);`
1097	`return true;`	1098		`return true;`
1098	`}`	1099		`}`
1099		1100
1100	`bool on_double(system::error_code& ec, double)`	1101		`bool on_double(system::error_code& ec, double)`
1101	`{`	1102		`{`
1102	`if( (array_depth_ + object_depth_) == 0 )`	1103		`if( (array_depth_ + object_depth_) == 0 )`
1103	`return parent_->signal_value(ec);`	1104		`return parent_->signal_value(ec);`
1104	`return true;`	1105		`return true;`
1105	`}`	1106		`}`
1106		1107
1107	`bool on_bool(system::error_code& ec, bool)`	1108		`bool on_bool(system::error_code& ec, bool)`
1108	`{`	1109		`{`
1109	`if( (array_depth_ + object_depth_) == 0 )`	1110		`if( (array_depth_ + object_depth_) == 0 )`
1110	`return parent_->signal_value(ec);`	1111		`return parent_->signal_value(ec);`
1111	`return true;`	1112		`return true;`
1112	`}`	1113		`}`
1113		1114
1114	`bool on_null(system::error_code& ec)`	1115		`bool on_null(system::error_code& ec)`
1115	`{`	1116		`{`
1116	`if( (array_depth_ + object_depth_) == 0 )`	1117		`if( (array_depth_ + object_depth_) == 0 )`
1117	`return parent_->signal_value(ec);`	1118		`return parent_->signal_value(ec);`
1118	`return true;`	1119		`return true;`
1119	`}`	1120		`}`
1120	`};`	1121		`};`
1121		1122
1122	`template<class V, class P>`	1123		`template<class V, class P>`
1123	`class converting_handler<described_class_conversion_tag, V, P>`	1124		`class converting_handler<described_class_conversion_tag, V, P>`
1124	`{`	1125		`{`
1125	`#if !defined(BOOST_DESCRIBE_CXX14)`	1126		`#if !defined(BOOST_DESCRIBE_CXX14)`
1126		1127
1127	`static_assert(`	1128		`static_assert(`
1128	`sizeof(V) == 0, "Struct support for parse_into requires C++14" );`	1129		`sizeof(V) == 0, "Struct support for parse_into requires C++14" );`
1129		1130
1130	`#else`	1131		`#else`
1131		1132
1132	`private:`	1133		`private:`
1133	`static_assert(`	1134		`static_assert(`
1134	`uniquely_named_members<V>::value,`	1135		`uniquely_named_members<V>::value,`
1135	`"The type has several described members with the same name.");`	1136		`"The type has several described members with the same name.");`
1136		1137
1137	`using Dm = described_members<V>;`	1138		`using Dm = described_members<V>;`
1138	`using Dt = struct_element_list<V>;`	1139		`using Dt = struct_element_list<V>;`
1139		1140
1140	`template<class T>`	1141		`template<class T>`
1141	`using MemberHandler = get_handler<T, converting_handler>;`	1142		`using MemberHandler = get_handler<T, converting_handler>;`
1142	`using InnerHandlers = mp11::mp_push_back<`	1143		`using InnerHandlers = mp11::mp_push_back<`
1143	`mp11::mp_transform<MemberHandler, Dt>,`	1144		`mp11::mp_transform<MemberHandler, Dt>,`
1144	`ignoring_handler<converting_handler> >;`	1145		`ignoring_handler<converting_handler> >;`
1145	`using InnerCount = mp11::mp_size<InnerHandlers>;`	1146		`using InnerCount = mp11::mp_size<InnerHandlers>;`
1146		1147
1147	`V* value_;`	1148		`V* value_;`
1148	`P* parent_;`	1149		`P* parent_;`
1149		1150
1150	`std::string key_;`	1151		`std::string key_;`
1151		1152
1152	`handler_tuple<converting_handler, InnerHandlers> handlers_;`	1153		`handler_tuple<converting_handler, InnerHandlers> handlers_;`
1153	`int inner_active_ = -1;`	1154		`int inner_active_ = -1;`
1154	`std::size_t activated_ = 0;`	1155		`std::size_t activated_ = 0;`
1155		1156
1156	`public:`	1157		`public:`
1157	`converting_handler( converting_handler const& ) = delete;`	1158		`converting_handler( converting_handler const& ) = delete;`
1158	`converting_handler& operator=( converting_handler const& ) = delete;`	1159		`converting_handler& operator=( converting_handler const& ) = delete;`
1159		1160
1160	`converting_handler( V* v, P* p )`	1161		`converting_handler( V* v, P* p )`
1161	`: value_(v), parent_(p), handlers_(struct_accessor(), v, this)`	1162		`: value_(v), parent_(p), handlers_(struct_accessor(), v, this)`
1162	`{}`	1163		`{}`
1163		1164
1164	`struct is_required_checker`	1165		`struct is_required_checker`
1165	`{`	1166		`{`
1166	`bool operator()( mp11::mp_size<Dt> ) const noexcept`	1167		`bool operator()( mp11::mp_size<Dt> ) const noexcept`
1167	`{`	1168		`{`
1168	`return false;`	1169		`return false;`
1169	`}`	1170		`}`
1170		1171
1171	`template< class I >`	1172		`template< class I >`
1172	`auto operator()( I ) const noexcept`	1173		`auto operator()( I ) const noexcept`
1173	`{`	1174		`{`
1174	`using T = mp11::mp_at<Dt, I>;`	1175		`using T = mp11::mp_at<Dt, I>;`
1175	`return !is_optional_like<T>::value;`	1176		`return !is_optional_like<T>::value;`
1176	`}`	1177		`}`
1177	`};`	1178		`};`
1178		1179
1179	`bool signal_value(system::error_code&)`	1180		`bool signal_value(system::error_code&)`
1180	`{`	1181		`{`
1181	`BOOST_ASSERT( inner_active_ >= 0 );`	1182		`BOOST_ASSERT( inner_active_ >= 0 );`
1182	`bool required_member = mp11::mp_with_index<InnerCount>(`	1183		`bool required_member = mp11::mp_with_index<InnerCount>(`
1183	`inner_active_,`	1184		`inner_active_,`
1184	`is_required_checker{});`	1185		`is_required_checker{});`
1185	`if( required_member )`	1186		`if( required_member )`
1186	`++activated_;`	1187		`++activated_;`
1187		1188
1188	`key_ = {};`	1189		`key_ = {};`
1189	`inner_active_ = -1;`	1190		`inner_active_ = -1;`
1190	`return true;`	1191		`return true;`
1191	`}`	1192		`}`
1192		1193
1193	`bool signal_end(system::error_code& ec)`	1194		`bool signal_end(system::error_code& ec)`
1194	`{`	1195		`{`
1195	`key_ = {};`	1196		`key_ = {};`
1196	`inner_active_ = -1;`	1197		`inner_active_ = -1;`
1197	`return parent_->signal_value(ec);`	1198		`return parent_->signal_value(ec);`
1198	`}`	1199		`}`
1199		1200
1200	`#define BOOST_JSON_INVOKE_INNER(fn) \`	1201		`#define BOOST_JSON_INVOKE_INNER(fn) \`
1201	`if( inner_active_ < 0 ) \`	1202		`if( inner_active_ < 0 ) \`
1202	`{ \`	1203		`{ \`
1203	`BOOST_JSON_FAIL( ec, error::not_object ); \`	1204		`BOOST_JSON_FAIL( ec, error::not_object ); \`
1204	`return false; \`	1205		`return false; \`
1205	`} \`	1206		`} \`
1206	`auto f = [&](auto& handler) { return handler.fn ; }; \`	1207		`auto f = [&](auto& handler) { return handler.fn ; }; \`
1207	`using F = decltype(f); \`	1208		`using F = decltype(f); \`
1208	`using H = decltype(handlers_); \`	1209		`using H = decltype(handlers_); \`
1209	`return mp11::mp_with_index<InnerCount>( \`	1210		`return mp11::mp_with_index<InnerCount>( \`
1210	`inner_active_, \`	1211		`inner_active_, \`
1211	`tuple_handler_op_invoker<H, F>{handlers_, f} );`	1212		`tuple_handler_op_invoker<H, F>{handlers_, f} );`
1212		1213
1213	`bool on_object_begin( system::error_code& ec )`	1214		`bool on_object_begin( system::error_code& ec )`
1214	`{`	1215		`{`
1215	`if( inner_active_ < 0 )`	1216		`if( inner_active_ < 0 )`
1216	`return true;`	1217		`return true;`
1217		1218
1218	`BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );`	1219		`BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );`
1219	`}`	1220		`}`
1220		1221
1221	`bool on_object_end( system::error_code& ec )`	1222		`bool on_object_end( system::error_code& ec )`
1222	`{`	1223		`{`
1223	`if( inner_active_ < 0 )`	1224		`if( inner_active_ < 0 )`
1224	`{`	1225		`{`
1225	`using C = mp11::mp_count_if<Dt, is_optional_like>;`	1226		`using C = mp11::mp_count_if<Dt, is_optional_like>;`
1226	`constexpr int N = mp11::mp_size<Dt>::value - C::value;`	1227		`constexpr int N = mp11::mp_size<Dt>::value - C::value;`
1227	`if( activated_ < N )`	1228		`if( activated_ < N )`
1228	`{`	1229		`{`
1229	`BOOST_JSON_FAIL( ec, error::size_mismatch );`	1230		`BOOST_JSON_FAIL( ec, error::size_mismatch );`
1230	`return false;`	1231		`return false;`
1231	`}`	1232		`}`
1232		1233
1233	`return parent_->signal_value(ec);`	1234		`return parent_->signal_value(ec);`
1234	`}`	1235		`}`
1235		1236
1236	`BOOST_JSON_INVOKE_INNER( on_object_end(ec) );`	1237		`BOOST_JSON_INVOKE_INNER( on_object_end(ec) );`
1237	`}`	1238		`}`
1238		1239
1239	`bool on_array_begin( system::error_code& ec )`	1240		`bool on_array_begin( system::error_code& ec )`
1240	`{`	1241		`{`
1241	`BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );`	1242		`BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );`
1242	`}`	1243		`}`
1243		1244
1244	`bool on_array_end( system::error_code& ec )`	1245		`bool on_array_end( system::error_code& ec )`
1245	`{`	1246		`{`
1246	`if( inner_active_ < 0 )`	1247		`if( inner_active_ < 0 )`
1247	`return parent_->signal_end(ec);`	1248		`return parent_->signal_end(ec);`
1248		1249
1249	`BOOST_JSON_INVOKE_INNER( on_array_end(ec) );`	1250		`BOOST_JSON_INVOKE_INNER( on_array_end(ec) );`
1250	`}`	1251		`}`
1251		1252
1252	`bool on_key_part( system::error_code& ec, string_view sv )`	1253		`bool on_key_part( system::error_code& ec, string_view sv )`
1253	`{`	1254		`{`
1254	`if( inner_active_ < 0 )`	1255		`if( inner_active_ < 0 )`
1255	`{`	1256		`{`
1256	`key_.append( sv.data(), sv.size() );`	1257		`key_.append( sv.data(), sv.size() );`
1257	`return true;`	1258		`return true;`
1258	`}`	1259		`}`
1259		1260
1260	`BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );`	1261		`BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );`
1261	`}`	1262		`}`
1262		1263
1263	`bool on_key( system::error_code& ec, string_view sv )`	1264		`bool on_key( system::error_code& ec, string_view sv )`
1264	`{`	1265		`{`
1265	`if( inner_active_ >= 0 )`	1266		`if( inner_active_ >= 0 )`
1266	`{`	1267		`{`
1267	`BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );`	1268		`BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );`
1268	`}`	1269		`}`
1269		1270
1270	`string_view key = sv;`	1271		`string_view key = sv;`
1271	`if( !key_.empty() )`	1272		`if( !key_.empty() )`
1272	`{`	1273		`{`
1273	`key_.append( sv.data(), sv.size() );`	1274		`key_.append( sv.data(), sv.size() );`
1274	`key = key_;`	1275		`key = key_;`
1275	`}`	1276		`}`
1276		1277
1277	`inner_active_ = InnerCount::value - 1;`	1278		`inner_active_ = InnerCount::value - 1;`
1278	`mp11::mp_for_each<Dm>( struct_key_searcher(key, inner_active_) );`	1279		`mp11::mp_for_each<Dm>( struct_key_searcher(key, inner_active_) );`
1279	`return true;`	1280		`return true;`
1280	`}`	1281		`}`
1281		1282
1282	`bool on_string_part( system::error_code& ec, string_view sv )`	1283		`bool on_string_part( system::error_code& ec, string_view sv )`
1283	`{`	1284		`{`
1284	`BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );`	1285		`BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );`
1285	`}`	1286		`}`
1286		1287
1287	`bool on_string( system::error_code& ec, string_view sv )`	1288		`bool on_string( system::error_code& ec, string_view sv )`
1288	`{`	1289		`{`
1289	`BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );`	1290		`BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );`
1290	`}`	1291		`}`
1291		1292
1292	`bool on_number_part( system::error_code& ec )`	1293		`bool on_number_part( system::error_code& ec )`
1293	`{`	1294		`{`
1294	`BOOST_JSON_INVOKE_INNER( on_number_part(ec) );`	1295		`BOOST_JSON_INVOKE_INNER( on_number_part(ec) );`
1295	`}`	1296		`}`
1296		1297
1297	`bool on_int64( system::error_code& ec, std::int64_t v )`	1298		`bool on_int64( system::error_code& ec, std::int64_t v )`
1298	`{`	1299		`{`
1299	`BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );`	1300		`BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );`
1300	`}`	1301		`}`
1301		1302
1302	`bool on_uint64( system::error_code& ec, std::uint64_t v )`	1303		`bool on_uint64( system::error_code& ec, std::uint64_t v )`
1303	`{`	1304		`{`
1304	`BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );`	1305		`BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );`
1305	`}`	1306		`}`
1306		1307
1307	`bool on_double( system::error_code& ec, double v )`	1308		`bool on_double( system::error_code& ec, double v )`
1308	`{`	1309		`{`
1309	`BOOST_JSON_INVOKE_INNER( on_double(ec, v) );`	1310		`BOOST_JSON_INVOKE_INNER( on_double(ec, v) );`
1310	`}`	1311		`}`
1311		1312
1312	`bool on_bool( system::error_code& ec, bool v )`	1313		`bool on_bool( system::error_code& ec, bool v )`
1313	`{`	1314		`{`
1314	`BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );`	1315		`BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );`
1315	`}`	1316		`}`
1316		1317
1317	`bool on_null( system::error_code& ec )`	1318		`bool on_null( system::error_code& ec )`
1318	`{`	1319		`{`
1319	`BOOST_JSON_INVOKE_INNER( on_null(ec) );`	1320		`BOOST_JSON_INVOKE_INNER( on_null(ec) );`
1320	`}`	1321		`}`
1321		1322
1322	`#undef BOOST_JSON_INVOKE_INNER`	1323		`#undef BOOST_JSON_INVOKE_INNER`
1323		1324
1324	`#endif`	1325		`#endif`
1325	`};`	1326		`};`
1326		1327
1327	`// variant handler`	1328		`// variant handler`
1328	`struct object_begin_handler_event`	1329		`struct object_begin_handler_event`
1329	`{ };`	1330		`{ };`
1330		1331
1331	`struct object_end_handler_event`	1332		`struct object_end_handler_event`
1332	`{ };`	1333		`{ };`
1333		1334
1334	`struct array_begin_handler_event`	1335		`struct array_begin_handler_event`
1335	`{ };`	1336		`{ };`
1336		1337
1337	`struct array_end_handler_event`	1338		`struct array_end_handler_event`
1338	`{ };`	1339		`{ };`
1339		1340
1340	`struct key_handler_event`	1341		`struct key_handler_event`
1341	`{`	1342		`{`
1342	`std::string value;`	1343		`std::string value;`
1343	`};`	1344		`};`
1344		1345
1345	`struct string_handler_event`	1346		`struct string_handler_event`
1346	`{`	1347		`{`
1347	`std::string value;`	1348		`std::string value;`
1348	`};`	1349		`};`
1349		1350
1350	`struct int64_handler_event`	1351		`struct int64_handler_event`
1351	`{`	1352		`{`
1352	`std::int64_t value;`	1353		`std::int64_t value;`
1353	`};`	1354		`};`
1354		1355
1355	`struct uint64_handler_event`	1356		`struct uint64_handler_event`
1356	`{`	1357		`{`
1357	`std::uint64_t value;`	1358		`std::uint64_t value;`
1358	`};`	1359		`};`
1359		1360
1360	`struct double_handler_event`	1361		`struct double_handler_event`
1361	`{`	1362		`{`
1362	`double value;`	1363		`double value;`
1363	`};`	1364		`};`
1364		1365
1365	`struct bool_handler_event`	1366		`struct bool_handler_event`
1366	`{`	1367		`{`
1367	`bool value;`	1368		`bool value;`
1368	`};`	1369		`};`
1369		1370
1370	`struct null_handler_event`	1371		`struct null_handler_event`
1371	`{ };`	1372		`{ };`
1372		1373
1373	`using parse_event = variant2::variant<`	1374		`using parse_event = variant2::variant<`
1374	`object_begin_handler_event,`	1375		`object_begin_handler_event,`
1375	`object_end_handler_event,`	1376		`object_end_handler_event,`
1376	`array_begin_handler_event,`	1377		`array_begin_handler_event,`
1377	`array_end_handler_event,`	1378		`array_end_handler_event,`
1378	`key_handler_event,`	1379		`key_handler_event,`
1379	`string_handler_event,`	1380		`string_handler_event,`
1380	`int64_handler_event,`	1381		`int64_handler_event,`
1381	`uint64_handler_event,`	1382		`uint64_handler_event,`
1382	`double_handler_event,`	1383		`double_handler_event,`
1383	`bool_handler_event,`	1384		`bool_handler_event,`
1384	`null_handler_event>;`	1385		`null_handler_event>;`
1385		1386
1386	`template< class H >`	1387		`template< class H >`
1387	`struct event_visitor`	1388		`struct event_visitor`
1388	`{`	1389		`{`
1389	`H& handler;`	1390		`H& handler;`
1390	`system::error_code& ec;`	1391		`system::error_code& ec;`
1391		1392
1392	`bool`	1393		`bool`
1393	`operator()(object_begin_handler_event&) const`	1394		`operator()(object_begin_handler_event&) const`
1394	`{`	1395		`{`
1395	`return handler.on_object_begin(ec);`	1396		`return handler.on_object_begin(ec);`
1396	`}`	1397		`}`
1397		1398
1398	`bool`	1399		`bool`
1399	`operator()(object_end_handler_event&) const`	1400		`operator()(object_end_handler_event&) const`
1400	`{`	1401		`{`
1401	`return handler.on_object_end(ec);`	1402		`return handler.on_object_end(ec);`
1402	`}`	1403		`}`
1403		1404
1404	`bool`	1405		`bool`
1405	`operator()(array_begin_handler_event&) const`	1406		`operator()(array_begin_handler_event&) const`
1406	`{`	1407		`{`
1407	`return handler.on_array_begin(ec);`	1408		`return handler.on_array_begin(ec);`
1408	`}`	1409		`}`
1409		1410
1410	`bool`	1411		`bool`
1411	`operator()(array_end_handler_event&) const`	1412		`operator()(array_end_handler_event&) const`
1412	`{`	1413		`{`
1413	`return handler.on_array_end(ec);`	1414		`return handler.on_array_end(ec);`
1414	`}`	1415		`}`
1415		1416
1416	`bool`	1417		`bool`
1417	`operator()(key_handler_event& ev) const`	1418		`operator()(key_handler_event& ev) const`
1418	`{`	1419		`{`
1419	`return handler.on_key(ec, ev.value);`	1420		`return handler.on_key(ec, ev.value);`
1420	`}`	1421		`}`
1421		1422
1422	`bool`	1423		`bool`
1423	`operator()(string_handler_event& ev) const`	1424		`operator()(string_handler_event& ev) const`
1424	`{`	1425		`{`
1425	`return handler.on_string(ec, ev.value);`	1426		`return handler.on_string(ec, ev.value);`
1426	`}`	1427		`}`
1427		1428
1428	`bool`	1429		`bool`
1429	`operator()(int64_handler_event& ev) const`	1430		`operator()(int64_handler_event& ev) const`
1430	`{`	1431		`{`
1431	`return handler.on_int64(ec, ev.value);`	1432		`return handler.on_int64(ec, ev.value);`
1432	`}`	1433		`}`
1433		1434
1434	`bool`	1435		`bool`
1435	`operator()(uint64_handler_event& ev) const`	1436		`operator()(uint64_handler_event& ev) const`
1436	`{`	1437		`{`
1437	`return handler.on_uint64(ec, ev.value);`	1438		`return handler.on_uint64(ec, ev.value);`
1438	`}`	1439		`}`
1439		1440
1440	`bool`	1441		`bool`
1441	`operator()(double_handler_event& ev) const`	1442		`operator()(double_handler_event& ev) const`
1442	`{`	1443		`{`
1443	`return handler.on_double(ec, ev.value);`	1444		`return handler.on_double(ec, ev.value);`
1444	`}`	1445		`}`
1445		1446
1446	`bool`	1447		`bool`
1447	`operator()(bool_handler_event& ev) const`	1448		`operator()(bool_handler_event& ev) const`
1448	`{`	1449		`{`
1449	`return handler.on_bool(ec, ev.value);`	1450		`return handler.on_bool(ec, ev.value);`
1450	`}`	1451		`}`
1451		1452
1452	`bool`	1453		`bool`
1453	`operator()(null_handler_event&) const`	1454		`operator()(null_handler_event&) const`
1454	`{`	1455		`{`
1455	`return handler.on_null(ec);`	1456		`return handler.on_null(ec);`
1456	`}`	1457		`}`
1457	`};`	1458		`};`
1458		1459
1459	`// L<T...> -> variant< monostate, get_handler<T, P>... >`	1460		`// L<T...> -> variant< monostate, get_handler<T, P>... >`
1460	`template< class P, class L >`	1461		`template< class P, class L >`
1461	`using inner_handler_variant = mp11::mp_push_front<`	1462		`using inner_handler_variant = mp11::mp_push_front<`
1462	`mp11::mp_transform_q<`	1463		`mp11::mp_transform_q<`
1463	`mp11::mp_bind_back<get_handler, P>,`	1464		`mp11::mp_bind_back<get_handler, P>,`
1464	`mp11::mp_apply<variant2::variant, L>>,`	1465		`mp11::mp_apply<variant2::variant, L>>,`
1465	`variant2::monostate>;`	1466		`variant2::monostate>;`
1466		1467
1467	`template< class T, class P >`	1468		`template< class T, class P >`
1468	`class converting_handler<variant_conversion_tag, T, P>`	1469		`class converting_handler<variant_conversion_tag, T, P>`
1469	`{`	1470		`{`
1470	`private:`	1471		`private:`
1471	`using variant_size = mp11::mp_size<T>;`	1472		`using variant_size = mp11::mp_size<T>;`
1472		1473
1473	`T* value_;`	1474		`T* value_;`
1474	`P* parent_;`	1475		`P* parent_;`
1475		1476
1476	`std::string string_;`	1477		`std::string string_;`
1477	`std::vector< parse_event > events_;`	1478		`std::vector< parse_event > events_;`
1478	`inner_handler_variant<converting_handler, T> inner_;`	1479		`inner_handler_variant<converting_handler, T> inner_;`
1479	`int inner_active_ = -1;`	1480		`int inner_active_ = -1;`
1480		1481
1481	`public:`	1482		`public:`
1482	`converting_handler( converting_handler const& ) = delete;`	1483		`converting_handler( converting_handler const& ) = delete;`
1483	`converting_handler& operator=( converting_handler const& ) = delete;`	1484		`converting_handler& operator=( converting_handler const& ) = delete;`
1484		1485
1485	`converting_handler( T* v, P* p )`	1486		`converting_handler( T* v, P* p )`
1486	`: value_( v )`	1487		`: value_( v )`
1487	`, parent_( p )`	1488		`, parent_( p )`
1488	`{}`	1489		`{}`
1489		1490
1490	`bool signal_value(system::error_code& ec)`	1491		`bool signal_value(system::error_code& ec)`
1491	`{`	1492		`{`
1492	`inner_.template emplace<0>();`	1493		`inner_.template emplace<0>();`
1493	`inner_active_ = -1;`	1494		`inner_active_ = -1;`
1494	`events_.clear();`	1495		`events_.clear();`
1495	`return parent_->signal_value(ec);`	1496		`return parent_->signal_value(ec);`
1496	`}`	1497		`}`
1497		1498
1498	`bool signal_end(system::error_code& ec)`	1499		`bool signal_end(system::error_code& ec)`
1499	`{`	1500		`{`
1500	`return parent_->signal_end(ec);`	1501		`return parent_->signal_end(ec);`
1501	`}`	1502		`}`
1502		1503
1503	`struct alternative_selector`	1504		`struct alternative_selector`
1504	`{`	1505		`{`
1505	`converting_handler* self;`	1506		`converting_handler* self;`
1506		1507
1507	`template< class I >`	1508		`template< class I >`
1508	`void`	1509		`void`
1509	`operator()( I ) const`	1510		`operator()( I ) const`
1510	`{`	1511		`{`
1511	`using V = mp11::mp_at<T, I>;`	1512		`using V = mp11::mp_at<T, I>;`
1512	`auto& v = self->value_->template emplace<I::value>( V{} );`	1513		`auto& v = self->value_->template emplace<I::value>( V{} );`
1513	`self->inner_.template emplace<I::value + 1>(&v, self);`	1514		`self->inner_.template emplace<I::value + 1>(&v, self);`
1514	`}`	1515		`}`
1515	`};`	1516		`};`
1516	`void`	1517		`void`
1517	`next_alternative()`	1518		`next_alternative()`
1518	`{`	1519		`{`
1519	`if( ++inner_active_ >= static_cast<int>(variant_size::value) )`	1520		`if( ++inner_active_ >= static_cast<int>(variant_size::value) )`
1520	`return;`	1521		`return;`
1521		1522
1522	`mp11::mp_with_index< variant_size::value >(`	1523		`mp11::mp_with_index< variant_size::value >(`
1523	`inner_active_, alternative_selector{this} );`	1524		`inner_active_, alternative_selector{this} );`
1524	`}`	1525		`}`
1525		1526
1526	`struct event_processor`	1527		`struct event_processor`
1527	`{`	1528		`{`
1528	`converting_handler* self;`	1529		`converting_handler* self;`
1529	`system::error_code& ec;`	1530		`system::error_code& ec;`
1530	`parse_event& event;`	1531		`parse_event& event;`
1531		1532
1532	`template< class I >`	1533		`template< class I >`
1533	`bool operator()( I ) const`	1534		`bool operator()( I ) const`
1534	`{`	1535		`{`
1535	`auto& handler = variant2::get<I::value + 1>(self->inner_);`	1536		`auto& handler = variant2::get<I::value + 1>(self->inner_);`
1536	`using Handler = remove_cvref<decltype(handler)>;`	1537		`using Handler = remove_cvref<decltype(handler)>;`
1537	`return variant2::visit(`	1538		`return variant2::visit(`
1538	`event_visitor<Handler>{handler, ec}, event );`	1539		`event_visitor<Handler>{handler, ec}, event );`
1539	`}`	1540		`}`
1540	`};`	1541		`};`
1541	`bool process_events(system::error_code& ec)`	1542		`bool process_events(system::error_code& ec)`
1542	`{`	1543		`{`
1543	`constexpr std::size_t N = variant_size::value;`	1544		`constexpr std::size_t N = variant_size::value;`
1544		1545
1545	`// should be pointers not iterators, otherwise MSVC crashes`	1546		`// should be pointers not iterators, otherwise MSVC crashes`
1546	`auto const last = events_.data() + events_.size();`	1547		`auto const last = events_.data() + events_.size();`
1547	`auto first = last - 1;`	1548		`auto first = last - 1;`
1548	`bool ok = false;`	1549		`bool ok = false;`
1549		1550
1550	`if( inner_active_ < 0 )`	1551		`if( inner_active_ < 0 )`
1551	`next_alternative();`	1552		`next_alternative();`
1552	`do`	1553		`do`
1553	`{`	1554		`{`
1554	`if( static_cast<std::size_t>(inner_active_) >= N )`	1555		`if( static_cast<std::size_t>(inner_active_) >= N )`
1555	`{`	1556		`{`
1556	`BOOST_JSON_FAIL( ec, error::exhausted_variants );`	1557		`BOOST_JSON_FAIL( ec, error::exhausted_variants );`
1557	`return false;`	1558		`return false;`
1558	`}`	1559		`}`
1559		1560
1560	`for ( ; first != last; ++first )`	1561		`for ( ; first != last; ++first )`
1561	`{`	1562		`{`
1562	`ok = mp11::mp_with_index< N >(`	1563		`ok = mp11::mp_with_index< N >(`
1563	`inner_active_, event_processor{this, ec, *first} );`	1564		`inner_active_, event_processor{this, ec, *first} );`
1564	`if( !ok )`	1565		`if( !ok )`
1565	`{`	1566		`{`
1566	`first = events_.data();`	1567		`first = events_.data();`
1567	`next_alternative();`	1568		`next_alternative();`
1568	`ec.clear();`	1569		`ec.clear();`
1569	`break;`	1570		`break;`
1570	`}`	1571		`}`
1571	`}`	1572		`}`
1572	`}`	1573		`}`
1573	`while( !ok );`	1574		`while( !ok );`
1574		1575
1575	`return true;`	1576		`return true;`
1576	`}`	1577		`}`
1577		1578
1578	`#define BOOST_JSON_INVOKE_INNER(ev, ec) \`	1579		`#define BOOST_JSON_INVOKE_INNER(ev, ec) \`
1579	`events_.emplace_back( ev ); \`	1580		`events_.emplace_back( ev ); \`
1580	`return process_events(ec);`	1581		`return process_events(ec);`
1581		1582
1582	`bool on_object_begin( system::error_code& ec )`	1583		`bool on_object_begin( system::error_code& ec )`
1583	`{`	1584		`{`
1584	`BOOST_JSON_INVOKE_INNER( object_begin_handler_event{}, ec );`	1585		`BOOST_JSON_INVOKE_INNER( object_begin_handler_event{}, ec );`
1585	`}`	1586		`}`
1586		1587
1587	`bool on_object_end( system::error_code& ec )`	1588		`bool on_object_end( system::error_code& ec )`
1588	`{`	1589		`{`
1589	`BOOST_JSON_INVOKE_INNER( object_end_handler_event{}, ec );`	1590		`BOOST_JSON_INVOKE_INNER( object_end_handler_event{}, ec );`
1590	`}`	1591		`}`
1591		1592
1592	`bool on_array_begin( system::error_code& ec )`	1593		`bool on_array_begin( system::error_code& ec )`
1593	`{`	1594		`{`
1594	`BOOST_JSON_INVOKE_INNER( array_begin_handler_event{}, ec );`	1595		`BOOST_JSON_INVOKE_INNER( array_begin_handler_event{}, ec );`
1595	`}`	1596		`}`
1596		1597
1597	`bool on_array_end( system::error_code& ec )`	1598		`bool on_array_end( system::error_code& ec )`
1598	`{`	1599		`{`
1599	`if( !inner_active_ )`	1600		`if( !inner_active_ )`
1600	`return signal_end(ec);`	1601		`return signal_end(ec);`
1601		1602
1602	`BOOST_JSON_INVOKE_INNER( array_end_handler_event{}, ec );`	1603		`BOOST_JSON_INVOKE_INNER( array_end_handler_event{}, ec );`
1603	`}`	1604		`}`
1604		1605
1605	`bool on_key_part( system::error_code&, string_view sv )`	1606		`bool on_key_part( system::error_code&, string_view sv )`
1606	`{`	1607		`{`
1607	`string_.append(sv);`	1608		`string_.append(sv);`
1608	`return true;`	1609		`return true;`
1609	`}`	1610		`}`
1610		1611
1611	`bool on_key( system::error_code& ec, string_view sv )`	1612		`bool on_key( system::error_code& ec, string_view sv )`
1612	`{`	1613		`{`
1613	`string_.append(sv);`	1614		`string_.append(sv);`
1614	`BOOST_JSON_INVOKE_INNER( key_handler_event{ std::move(string_) }, ec );`	1615		`BOOST_JSON_INVOKE_INNER( key_handler_event{ std::move(string_) }, ec );`
1615	`}`	1616		`}`
1616		1617
1617	`bool on_string_part( system::error_code&, string_view sv )`	1618		`bool on_string_part( system::error_code&, string_view sv )`
1618	`{`	1619		`{`
1619	`string_.append(sv);`	1620		`string_.append(sv);`
1620	`return true;`	1621		`return true;`
1621	`}`	1622		`}`
1622		1623
1623	`bool on_string( system::error_code& ec, string_view sv )`	1624		`bool on_string( system::error_code& ec, string_view sv )`
1624	`{`	1625		`{`
1625	`string_.append(sv);`	1626		`string_.append(sv);`
1626	`BOOST_JSON_INVOKE_INNER(`	1627		`BOOST_JSON_INVOKE_INNER(`
1627	`string_handler_event{ std::move(string_) }, ec );`	1628		`string_handler_event{ std::move(string_) }, ec );`
1628	`}`	1629		`}`
1629		1630
1630	`bool on_number_part( system::error_code& )`	1631		`bool on_number_part( system::error_code& )`
1631	`{`	1632		`{`
1632	`return true;`	1633		`return true;`
1633	`}`	1634		`}`
1634		1635
1635	`bool on_int64( system::error_code& ec, std::int64_t v )`	1636		`bool on_int64( system::error_code& ec, std::int64_t v )`
1636	`{`	1637		`{`
1637	`BOOST_JSON_INVOKE_INNER( int64_handler_event{v}, ec );`	1638		`BOOST_JSON_INVOKE_INNER( int64_handler_event{v}, ec );`
1638	`}`	1639		`}`
1639		1640
1640	`bool on_uint64( system::error_code& ec, std::uint64_t v )`	1641		`bool on_uint64( system::error_code& ec, std::uint64_t v )`
1641	`{`	1642		`{`
1642	`BOOST_JSON_INVOKE_INNER( uint64_handler_event{v}, ec );`	1643		`BOOST_JSON_INVOKE_INNER( uint64_handler_event{v}, ec );`
1643	`}`	1644		`}`
1644		1645
1645	`bool on_double( system::error_code& ec, double v )`	1646		`bool on_double( system::error_code& ec, double v )`
1646	`{`	1647		`{`
1647	`BOOST_JSON_INVOKE_INNER( double_handler_event{v}, ec );`	1648		`BOOST_JSON_INVOKE_INNER( double_handler_event{v}, ec );`
1648	`}`	1649		`}`
1649		1650
1650	`bool on_bool( system::error_code& ec, bool v )`	1651		`bool on_bool( system::error_code& ec, bool v )`
1651	`{`	1652		`{`
1652	`BOOST_JSON_INVOKE_INNER( bool_handler_event{v}, ec );`	1653		`BOOST_JSON_INVOKE_INNER( bool_handler_event{v}, ec );`
1653	`}`	1654		`}`
1654		1655
1655	`bool on_null( system::error_code& ec )`	1656		`bool on_null( system::error_code& ec )`
1656	`{`	1657		`{`
1657	`BOOST_JSON_INVOKE_INNER( null_handler_event{}, ec );`	1658		`BOOST_JSON_INVOKE_INNER( null_handler_event{}, ec );`
1658	`}`	1659		`}`
1659		1660
1660	`#undef BOOST_JSON_INVOKE_INNER`	1661		`#undef BOOST_JSON_INVOKE_INNER`
1661	`};`	1662		`};`
1662		1663
1663	`// optional handler`	1664		`// optional handler`
1664	`template<class V, class P>`	1665		`template<class V, class P>`
1665	`class converting_handler<optional_conversion_tag, V, P>`	1666		`class converting_handler<optional_conversion_tag, V, P>`
1666	`{`	1667		`{`
1667	`private:`	1668		`private:`
1668	`using inner_type = value_result_type<V>;`	1669		`using inner_type = value_result_type<V>;`
1669	`using inner_handler_type = get_handler<inner_type, converting_handler>;`	1670		`using inner_handler_type = get_handler<inner_type, converting_handler>;`
1670		1671
1671	`V* value_;`	1672		`V* value_;`
1672	`P* parent_;`	1673		`P* parent_;`
1673		1674
1674	`inner_type inner_value_ = {};`	1675		`inner_type inner_value_ = {};`
1675	`inner_handler_type inner_;`	1676		`inner_handler_type inner_;`
1676	`bool inner_active_ = false;`	1677		`bool inner_active_ = false;`
1677		1678
1678	`public:`	1679		`public:`
1679	`converting_handler( converting_handler const& ) = delete;`	1680		`converting_handler( converting_handler const& ) = delete;`
1680	`converting_handler& operator=( converting_handler const& ) = delete;`	1681		`converting_handler& operator=( converting_handler const& ) = delete;`
1681		1682
1682	`converting_handler( V* v, P* p )`	1683		`converting_handler( V* v, P* p )`
1683	`: value_(v), parent_(p), inner_(&inner_value_, this)`	1684		`: value_(v), parent_(p), inner_(&inner_value_, this)`
1684	`{}`	1685		`{}`
1685		1686
1686	`bool signal_value(system::error_code& ec)`	1687		`bool signal_value(system::error_code& ec)`
1687	`{`	1688		`{`
1688	`*value_ = std::move(inner_value_);`	1689		`*value_ = std::move(inner_value_);`
1689		1690
1690	`inner_active_ = false;`	1691		`inner_active_ = false;`
1691	`return parent_->signal_value(ec);`	1692		`return parent_->signal_value(ec);`
1692	`}`	1693		`}`
1693		1694
1694	`bool signal_end(system::error_code& ec)`	1695		`bool signal_end(system::error_code& ec)`
1695	`{`	1696		`{`
1696	`return parent_->signal_end(ec);`	1697		`return parent_->signal_end(ec);`
1697	`}`	1698		`}`
1698		1699
1699	`#define BOOST_JSON_INVOKE_INNER(fn) \`	1700		`#define BOOST_JSON_INVOKE_INNER(fn) \`
1700	`if( !inner_active_ ) \`	1701		`if( !inner_active_ ) \`
1701	`inner_active_ = true; \`	1702		`inner_active_ = true; \`
1702	`return inner_.fn;`	1703		`return inner_.fn;`
1703		1704
1704	`bool on_object_begin( system::error_code& ec )`	1705		`bool on_object_begin( system::error_code& ec )`
1705	`{`	1706		`{`
1706	`BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );`	1707		`BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );`
1707	`}`	1708		`}`
1708		1709
1709	`bool on_object_end( system::error_code& ec )`	1710		`bool on_object_end( system::error_code& ec )`
1710	`{`	1711		`{`
1711	`BOOST_JSON_INVOKE_INNER( on_object_end(ec) );`	1712		`BOOST_JSON_INVOKE_INNER( on_object_end(ec) );`
1712	`}`	1713		`}`
1713		1714
1714	`bool on_array_begin( system::error_code& ec )`	1715		`bool on_array_begin( system::error_code& ec )`
1715	`{`	1716		`{`
1716	`BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );`	1717		`BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );`
1717	`}`	1718		`}`
1718		1719
1719	`bool on_array_end( system::error_code& ec )`	1720		`bool on_array_end( system::error_code& ec )`
1720	`{`	1721		`{`
1721	`if( !inner_active_ )`	1722		`if( !inner_active_ )`
1722	`return signal_end(ec);`	1723		`return signal_end(ec);`
1723		1724
1724	`BOOST_JSON_INVOKE_INNER( on_array_end(ec) );`	1725		`BOOST_JSON_INVOKE_INNER( on_array_end(ec) );`
1725	`}`	1726		`}`
1726		1727
1727	`bool on_key_part( system::error_code& ec, string_view sv )`	1728		`bool on_key_part( system::error_code& ec, string_view sv )`
1728	`{`	1729		`{`
1729	`BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );`	1730		`BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );`
1730	`}`	1731		`}`
1731		1732
1732	`bool on_key( system::error_code& ec, string_view sv )`	1733		`bool on_key( system::error_code& ec, string_view sv )`
1733	`{`	1734		`{`
1734	`BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );`	1735		`BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );`
1735	`}`	1736		`}`
1736		1737
1737	`bool on_string_part( system::error_code& ec, string_view sv )`	1738		`bool on_string_part( system::error_code& ec, string_view sv )`
1738	`{`	1739		`{`
1739	`BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );`	1740		`BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );`
1740	`}`	1741		`}`
1741		1742
1742	`bool on_string( system::error_code& ec, string_view sv )`	1743		`bool on_string( system::error_code& ec, string_view sv )`
1743	`{`	1744		`{`
1744	`BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );`	1745		`BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );`
1745	`}`	1746		`}`
1746		1747
1747	`bool on_number_part( system::error_code& ec )`	1748		`bool on_number_part( system::error_code& ec )`
1748	`{`	1749		`{`
1749	`BOOST_JSON_INVOKE_INNER( on_number_part(ec) );`	1750		`BOOST_JSON_INVOKE_INNER( on_number_part(ec) );`
1750	`}`	1751		`}`
1751		1752
1752	`bool on_int64( system::error_code& ec, std::int64_t v )`	1753		`bool on_int64( system::error_code& ec, std::int64_t v )`
1753	`{`	1754		`{`
1754	`BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );`	1755		`BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );`
1755	`}`	1756		`}`
1756		1757
1757	`bool on_uint64( system::error_code& ec, std::uint64_t v )`	1758		`bool on_uint64( system::error_code& ec, std::uint64_t v )`
1758	`{`	1759		`{`
1759	`BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );`	1760		`BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );`
1760	`}`	1761		`}`
1761		1762
1762	`bool on_double( system::error_code& ec, double v )`	1763		`bool on_double( system::error_code& ec, double v )`
1763	`{`	1764		`{`
1764	`BOOST_JSON_INVOKE_INNER( on_double(ec, v) );`	1765		`BOOST_JSON_INVOKE_INNER( on_double(ec, v) );`
1765	`}`	1766		`}`
1766		1767
1767	`bool on_bool( system::error_code& ec, bool v )`	1768		`bool on_bool( system::error_code& ec, bool v )`
1768	`{`	1769		`{`
1769	`BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );`	1770		`BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );`
1770	`}`	1771		`}`
1771		1772
1772	`bool on_null(system::error_code& ec)`	1773		`bool on_null(system::error_code& ec)`
1773	`{`	1774		`{`
1774	`if( !inner_active_ )`	1775		`if( !inner_active_ )`
1775	`{`	1776		`{`
1776	`*value_ = {};`	1777		`*value_ = {};`
1777	`return this->parent_->signal_value(ec);`	1778		`return this->parent_->signal_value(ec);`
1778	`}`	1779		`}`
1779	`else`	1780		`else`
1780	`{`	1781		`{`
1781	`return inner_.on_null(ec);`	1782		`return inner_.on_null(ec);`
1782	`}`	1783		`}`
1783	`}`	1784		`}`
1784		1785
1785	`#undef BOOST_JSON_INVOKE_INNER`	1786		`#undef BOOST_JSON_INVOKE_INNER`
1786	`};`	1787		`};`
1787		1788
1788	`// path handler`	1789		`// path handler`
1789	`template< class V, class P >`	1790		`template< class V, class P >`
1790	`class converting_handler<path_conversion_tag, V, P>`	1791		`class converting_handler<path_conversion_tag, V, P>`
1791	`: public scalar_handler<P, error::not_string>`	1792		`: public scalar_handler<P, error::not_string>`
1792	`{`	1793		`{`
1793	`private:`	1794		`private:`
1794	`V* value_;`	1795		`V* value_;`
1795	`bool cleared_ = false;`	1796		`bool cleared_ = false;`
1796		1797
1797	`public:`	1798		`public:`
1798	`converting_handler( V* v, P* p )`	1799		`converting_handler( V* v, P* p )`
1799	`: converting_handler::scalar_handler(p)`	1800		`: converting_handler::scalar_handler(p)`
1800	`, value_(v)`	1801		`, value_(v)`
1801	`{}`	1802		`{}`
1802		1803
1803	`bool on_string_part( system::error_code&, string_view sv )`	1804		`bool on_string_part( system::error_code&, string_view sv )`
1804	`{`	1805		`{`
1805	`if( !cleared_ )`	1806		`if( !cleared_ )`
1806	`{`	1807		`{`
1807	`cleared_ = true;`	1808		`cleared_ = true;`
1808	`value_->clear();`	1809		`value_->clear();`
1809	`}`	1810		`}`
1810		1811
1811	`value_->concat( sv.begin(), sv.end() );`	1812		`value_->concat( sv.begin(), sv.end() );`
1812	`return true;`	1813		`return true;`
1813	`}`	1814		`}`
1814		1815
1815	`bool on_string(system::error_code& ec, string_view sv)`	1816		`bool on_string(system::error_code& ec, string_view sv)`
1816	`{`	1817		`{`
1817	`if( !cleared_ )`	1818		`if( !cleared_ )`
1818	`value_->clear();`	1819		`value_->clear();`
1819	`else`	1820		`else`
1820	`cleared_ = false;`	1821		`cleared_ = false;`
1821		1822
1822	`value_->concat( sv.begin(), sv.end() );`	1823		`value_->concat( sv.begin(), sv.end() );`
1823		1824
1824	`return this->parent_->signal_value(ec);`	1825		`return this->parent_->signal_value(ec);`
1825	`}`	1826		`}`
1826	`};`	1827		`};`
1827		1828
1828	`// into_handler`	1829		`// into_handler`
1829	`template< class V >`	1830		`template< class V >`
1830	`class into_handler`	1831		`class into_handler`
1831	`{`	1832		`{`
1832	`private:`	1833		`private:`
1833		1834
1834	`using inner_handler_type = get_handler<V, into_handler>;`	1835		`using inner_handler_type = get_handler<V, into_handler>;`
1835		1836
1836	`inner_handler_type inner_;`	1837		`inner_handler_type inner_;`
1837	`bool inner_active_ = true;`	1838		`bool inner_active_ = true;`
1838		1839
1839	`public:`	1840		`public:`
1840		1841
1841	`into_handler( into_handler const& ) = delete;`	1842		`into_handler( into_handler const& ) = delete;`
1842	`into_handler& operator=( into_handler const& ) = delete;`	1843		`into_handler& operator=( into_handler const& ) = delete;`
1843		1844
1844	`public:`	1845		`public:`
1845		1846
1846	`static constexpr std::size_t max_object_size = object::max_size();`	1847		`static constexpr std::size_t max_object_size = object::max_size();`
1847	`static constexpr std::size_t max_array_size = array::max_size();`	1848		`static constexpr std::size_t max_array_size = array::max_size();`
1848	`static constexpr std::size_t max_key_size = string::max_size();`	1849		`static constexpr std::size_t max_key_size = string::max_size();`
1849	`static constexpr std::size_t max_string_size = string::max_size();`	1850		`static constexpr std::size_t max_string_size = string::max_size();`
1850		1851
1851	`public:`	1852		`public:`
1852		1853
1853	`explicit into_handler( V* v ): inner_( v, this )`	1854		`explicit into_handler( V* v ): inner_( v, this )`
1854	`{`	1855		`{`
1855	`}`	1856		`}`
1856		1857
1857	`bool signal_value(system::error_code&)`	1858		`bool signal_value(system::error_code&)`
1858	`{`	1859		`{`
1859	`return true;`	1860		`return true;`
1860	`}`	1861		`}`
1861		1862
1862	`bool signal_end(system::error_code&)`	1863		`bool signal_end(system::error_code&)`
1863	`{`	1864		`{`
1864	`return true;`	1865		`return true;`
1865	`}`	1866		`}`
1866		1867
1867	`bool on_document_begin( system::error_code& )`	1868		`bool on_document_begin( system::error_code& )`
1868	`{`	1869		`{`
1869	`return true;`	1870		`return true;`
1870	`}`	1871		`}`
1871		1872
1872	`bool on_document_end( system::error_code& )`	1873		`bool on_document_end( system::error_code& )`
1873	`{`	1874		`{`
1874	`inner_active_ = false;`	1875		`inner_active_ = false;`
1875	`return true;`	1876		`return true;`
1876	`}`	1877		`}`
1877		1878
1878	`#define BOOST_JSON_INVOKE_INNER(f) \`	1879		`#define BOOST_JSON_INVOKE_INNER(f) \`
1879	`if( !inner_active_ ) \`	1880		`if( !inner_active_ ) \`
1880	`{ \`	1881		`{ \`
1881	`BOOST_JSON_FAIL( ec, error::extra_data ); \`	1882		`BOOST_JSON_FAIL( ec, error::extra_data ); \`
1882	`return false; \`	1883		`return false; \`
1883	`} \`	1884		`} \`
1884	`else \`	1885		`else \`
1885	`return inner_.f`	1886		`return inner_.f`
1886		1887
1887	`bool on_object_begin( system::error_code& ec )`	1888		`bool on_object_begin( system::error_code& ec )`
1888	`{`	1889		`{`
1889	`BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );`	1890		`BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );`
1890	`}`	1891		`}`
1891		1892
1892	`bool on_object_end( std::size_t, system::error_code& ec )`	1893		`bool on_object_end( std::size_t, system::error_code& ec )`
1893	`{`	1894		`{`
1894	`BOOST_JSON_INVOKE_INNER( on_object_end(ec) );`	1895		`BOOST_JSON_INVOKE_INNER( on_object_end(ec) );`
1895	`}`	1896		`}`
1896		1897
1897	`bool on_array_begin( system::error_code& ec )`	1898		`bool on_array_begin( system::error_code& ec )`
1898	`{`	1899		`{`
1899	`BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );`	1900		`BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );`
1900	`}`	1901		`}`
1901		1902
1902	`bool on_array_end( std::size_t, system::error_code& ec )`	1903		`bool on_array_end( std::size_t, system::error_code& ec )`
1903	`{`	1904		`{`
1904	`BOOST_JSON_INVOKE_INNER( on_array_end(ec) );`	1905		`BOOST_JSON_INVOKE_INNER( on_array_end(ec) );`
1905	`}`	1906		`}`
1906		1907
1907	`bool on_key_part( string_view sv, std::size_t, system::error_code& ec )`	1908		`bool on_key_part( string_view sv, std::size_t, system::error_code& ec )`
1908	`{`	1909		`{`
1909	`BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );`	1910		`BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );`
1910	`}`	1911		`}`
1911		1912
1912	`bool on_key( string_view sv, std::size_t, system::error_code& ec )`	1913		`bool on_key( string_view sv, std::size_t, system::error_code& ec )`
1913	`{`	1914		`{`
1914	`BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );`	1915		`BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );`
1915	`}`	1916		`}`
1916		1917
1917	`bool on_string_part( string_view sv, std::size_t, system::error_code& ec )`	1918		`bool on_string_part( string_view sv, std::size_t, system::error_code& ec )`
1918	`{`	1919		`{`
1919	`BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );`	1920		`BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );`
1920	`}`	1921		`}`
1921		1922
1922	`bool on_string( string_view sv, std::size_t, system::error_code& ec )`	1923		`bool on_string( string_view sv, std::size_t, system::error_code& ec )`
1923	`{`	1924		`{`
1924	`BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );`	1925		`BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );`
1925	`}`	1926		`}`
1926		1927
1927	`bool on_number_part( string_view, system::error_code& ec )`	1928		`bool on_number_part( string_view, system::error_code& ec )`
1928	`{`	1929		`{`
1929	`BOOST_JSON_INVOKE_INNER( on_number_part(ec) );`	1930		`BOOST_JSON_INVOKE_INNER( on_number_part(ec) );`
1930	`}`	1931		`}`
1931		1932
1932	`bool on_int64( std::int64_t v, string_view, system::error_code& ec )`	1933		`bool on_int64( std::int64_t v, string_view, system::error_code& ec )`
1933	`{`	1934		`{`
1934	`BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );`	1935		`BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );`
1935	`}`	1936		`}`
1936		1937
1937	`bool on_uint64( std::uint64_t v, string_view, system::error_code& ec )`	1938		`bool on_uint64( std::uint64_t v, string_view, system::error_code& ec )`
1938	`{`	1939		`{`
1939	`BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );`	1940		`BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );`
1940	`}`	1941		`}`
1941		1942
1942	`bool on_double( double v, string_view, system::error_code& ec )`	1943		`bool on_double( double v, string_view, system::error_code& ec )`
1943	`{`	1944		`{`
1944	`BOOST_JSON_INVOKE_INNER( on_double(ec, v) );`	1945		`BOOST_JSON_INVOKE_INNER( on_double(ec, v) );`
1945	`}`	1946		`}`
1946		1947
1947	`bool on_bool( bool v, system::error_code& ec )`	1948		`bool on_bool( bool v, system::error_code& ec )`
1948	`{`	1949		`{`
1949	`BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );`	1950		`BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );`
1950	`}`	1951		`}`
1951		1952
1952	`bool on_null( system::error_code& ec )`	1953		`bool on_null( system::error_code& ec )`
1953	`{`	1954		`{`
1954	`BOOST_JSON_INVOKE_INNER( on_null(ec) );`	1955		`BOOST_JSON_INVOKE_INNER( on_null(ec) );`
1955	`}`	1956		`}`
1956		1957
1957	`bool on_comment_part(string_view, system::error_code&)`	1958		`bool on_comment_part(string_view, system::error_code&)`
1958	`{`	1959		`{`
1959	`return true;`	1960		`return true;`
1960	`}`	1961		`}`
1961		1962
1962	`bool on_comment(string_view, system::error_code&)`	1963		`bool on_comment(string_view, system::error_code&)`
1963	`{`	1964		`{`
1964	`return true;`	1965		`return true;`
1965	`}`	1966		`}`
1966		1967
1967	`#undef BOOST_JSON_INVOKE_INNER`	1968		`#undef BOOST_JSON_INVOKE_INNER`
1968	`};`	1969		`};`
1969		1970
1970	`} // namespace detail`	1971		`} // namespace detail`
1971	`} // namespace boost`	1972		`} // namespace boost`
1972	`} // namespace json`	1973		`} // namespace json`
1973		1974
1974	`#endif`	1975		`#endif`

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