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