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