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 <vector>
22 :
23 : /*
24 : * This file contains the majority of parse_into functionality, specifically
25 : * the implementation of dedicated handlers for different generic categories of
26 : * types.
27 : *
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
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
32 : * handler), and on_document_end (by disabling the nested handler).
33 : *
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
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
38 : * specialisation for every conversion category from the list of generic
39 : * conversion categories (e.g. sequence_category, tuple_category, etc.)
40 : * Instantiations of the template store a pointer to the parent handler and a
41 : * pointer to the value T.
42 : *
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
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,
47 : * on_comment, on_document_begin, and on_document_end events, as those are
48 : * always handled by the top handler into_handler<T>.
49 : *
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
52 : * necessary for correct handling of composite types (e.g. sequences).
53 : *
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
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
58 : * requires more elements.
59 : *
60 : * converting_handler instantiations for composite categories of types have
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
63 : * root and handlers for scalars as leaves.
64 : *
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
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
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
71 : * parent's signal_value.
72 : */
73 :
74 : namespace boost {
75 : namespace json {
76 : namespace detail {
77 :
78 : template< conversion_category C, class T, class Parent >
79 : class converting_handler;
80 :
81 : // get_handler
82 : template< class V, class P >
83 : using get_handler = converting_handler<
84 : get_conversion_category<V, void, direct_checks>::value, 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 229 : bool on_number_part( system::error_code& ec )
218 : {
219 229 : 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<conversion_category::integer, 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<conversion_category::floating_point, 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 99 : bool on_number_part( system::error_code& )
329 : {
330 99 : 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_category::value, 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<conversion_category::boolean, 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_category::value, 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_category::value, 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<unknown_category::value, 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_category::value, V, P>
541 : : public composite_handler<
542 : converting_handler<sequence_category::value, 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_category::value, V, P>
616 : : public composite_handler<
617 : converting_handler<map_category::value, 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 516 : get( handler_tuple_element<I, T>& e )
704 : {
705 516 : 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 466 : operator()( Handler& handler ) const
766 : {
767 466 : return (*this)( handler, mp11::index_sequence_for<Args...>() );
768 : }
769 :
770 : private:
771 : template< class Handler, std::size_t... I >
772 : bool
773 466 : operator()( Handler& handler, mp11::index_sequence<I...> ) const
774 : {
775 466 : 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 466 : operator()( I ) const
788 : {
789 466 : 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_category::value, 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 152 : 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_category::value, 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::size_t activated_ = 0;
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 : ++activated_;
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 : return true;
1219 :
1220 : BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );
1221 : }
1222 :
1223 : bool on_object_end( system::error_code& ec )
1224 : {
1225 : if( inner_active_ < 0 )
1226 : {
1227 : using C = mp11::mp_count_if<Dt, is_optional_like>;
1228 : constexpr int N = mp11::mp_size<Dt>::value - C::value;
1229 : if( activated_ < N )
1230 : {
1231 : BOOST_JSON_FAIL( ec, error::size_mismatch );
1232 : return false;
1233 : }
1234 :
1235 : return parent_->signal_value(ec);
1236 : }
1237 :
1238 : BOOST_JSON_INVOKE_INNER( on_object_end(ec) );
1239 : }
1240 :
1241 : bool on_array_begin( system::error_code& ec )
1242 : {
1243 : BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );
1244 : }
1245 :
1246 : bool on_array_end( system::error_code& ec )
1247 : {
1248 : if( inner_active_ < 0 )
1249 : return parent_->signal_end(ec);
1250 :
1251 : BOOST_JSON_INVOKE_INNER( on_array_end(ec) );
1252 : }
1253 :
1254 : bool on_key_part( system::error_code& ec, string_view sv )
1255 : {
1256 : if( inner_active_ < 0 )
1257 : {
1258 : key_.append( sv.data(), sv.size() );
1259 : return true;
1260 : }
1261 :
1262 : BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );
1263 : }
1264 :
1265 : bool on_key( system::error_code& ec, string_view sv )
1266 : {
1267 : if( inner_active_ >= 0 )
1268 : {
1269 : BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );
1270 : }
1271 :
1272 : string_view key = sv;
1273 : if( !key_.empty() )
1274 : {
1275 : key_.append( sv.data(), sv.size() );
1276 : key = key_;
1277 : }
1278 :
1279 : inner_active_ = InnerCount::value - 1;
1280 : mp11::mp_for_each<Dm>( struct_key_searcher(key, inner_active_) );
1281 : return true;
1282 : }
1283 :
1284 : bool on_string_part( system::error_code& ec, string_view sv )
1285 : {
1286 : BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );
1287 : }
1288 :
1289 : bool on_string( system::error_code& ec, string_view sv )
1290 : {
1291 : BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );
1292 : }
1293 :
1294 : bool on_number_part( system::error_code& ec )
1295 : {
1296 : BOOST_JSON_INVOKE_INNER( on_number_part(ec) );
1297 : }
1298 :
1299 : bool on_int64( system::error_code& ec, std::int64_t v )
1300 : {
1301 : BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );
1302 : }
1303 :
1304 : bool on_uint64( system::error_code& ec, std::uint64_t v )
1305 : {
1306 : BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );
1307 : }
1308 :
1309 : bool on_double( system::error_code& ec, double v )
1310 : {
1311 : BOOST_JSON_INVOKE_INNER( on_double(ec, v) );
1312 : }
1313 :
1314 : bool on_bool( system::error_code& ec, bool v )
1315 : {
1316 : BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );
1317 : }
1318 :
1319 : bool on_null( system::error_code& ec )
1320 : {
1321 : BOOST_JSON_INVOKE_INNER( on_null(ec) );
1322 : }
1323 :
1324 : #undef BOOST_JSON_INVOKE_INNER
1325 :
1326 : #endif
1327 : };
1328 :
1329 : // variant handler
1330 : struct object_begin_handler_event
1331 : { };
1332 :
1333 : struct object_end_handler_event
1334 : { };
1335 :
1336 : struct array_begin_handler_event
1337 : { };
1338 :
1339 : struct array_end_handler_event
1340 : { };
1341 :
1342 : struct key_handler_event
1343 : {
1344 : std::string value;
1345 : };
1346 :
1347 : struct string_handler_event
1348 : {
1349 : std::string value;
1350 : };
1351 :
1352 : struct int64_handler_event
1353 : {
1354 : std::int64_t value;
1355 : };
1356 :
1357 : struct uint64_handler_event
1358 : {
1359 : std::uint64_t value;
1360 : };
1361 :
1362 : struct double_handler_event
1363 : {
1364 : double value;
1365 : };
1366 :
1367 : struct bool_handler_event
1368 : {
1369 : bool value;
1370 : };
1371 :
1372 : struct null_handler_event
1373 : { };
1374 :
1375 : using parse_event = variant2::variant<
1376 : object_begin_handler_event,
1377 : object_end_handler_event,
1378 : array_begin_handler_event,
1379 : array_end_handler_event,
1380 : key_handler_event,
1381 : string_handler_event,
1382 : int64_handler_event,
1383 : uint64_handler_event,
1384 : double_handler_event,
1385 : bool_handler_event,
1386 : null_handler_event>;
1387 :
1388 : template< class H >
1389 : struct event_visitor
1390 : {
1391 : H& handler;
1392 : system::error_code& ec;
1393 :
1394 : bool
1395 14 : operator()(object_begin_handler_event&) const
1396 : {
1397 14 : return handler.on_object_begin(ec);
1398 : }
1399 :
1400 : bool
1401 7 : operator()(object_end_handler_event&) const
1402 : {
1403 7 : return handler.on_object_end(ec);
1404 : }
1405 :
1406 : bool
1407 42 : operator()(array_begin_handler_event&) const
1408 : {
1409 42 : return handler.on_array_begin(ec);
1410 : }
1411 :
1412 : bool
1413 21 : operator()(array_end_handler_event&) const
1414 : {
1415 21 : return handler.on_array_end(ec);
1416 : }
1417 :
1418 : bool
1419 21 : operator()(key_handler_event& ev) const
1420 : {
1421 21 : return handler.on_key(ec, ev.value);
1422 : }
1423 :
1424 : bool
1425 108 : operator()(string_handler_event& ev) const
1426 : {
1427 108 : return handler.on_string(ec, ev.value);
1428 : }
1429 :
1430 : bool
1431 154 : operator()(int64_handler_event& ev) const
1432 : {
1433 154 : return handler.on_int64(ec, ev.value);
1434 : }
1435 :
1436 : bool
1437 14 : operator()(uint64_handler_event& ev) const
1438 : {
1439 14 : return handler.on_uint64(ec, ev.value);
1440 : }
1441 :
1442 : bool
1443 21 : operator()(double_handler_event& ev) const
1444 : {
1445 21 : return handler.on_double(ec, ev.value);
1446 : }
1447 :
1448 : bool
1449 7 : operator()(bool_handler_event& ev) const
1450 : {
1451 7 : return handler.on_bool(ec, ev.value);
1452 : }
1453 :
1454 : bool
1455 7 : operator()(null_handler_event&) const
1456 : {
1457 7 : return handler.on_null(ec);
1458 : }
1459 : };
1460 :
1461 : // L<T...> -> variant< monostate, get_handler<T, P>... >
1462 : template< class P, class L >
1463 : using inner_handler_variant = mp11::mp_push_front<
1464 : mp11::mp_transform_q<
1465 : mp11::mp_bind_back<get_handler, P>,
1466 : mp11::mp_apply<variant2::variant, L>>,
1467 : variant2::monostate>;
1468 :
1469 : template< class T, class P >
1470 : class converting_handler<variant_category::value, T, P>
1471 : {
1472 : private:
1473 : using variant_size = mp11::mp_size<T>;
1474 :
1475 : T* value_;
1476 : P* parent_;
1477 :
1478 : std::string string_;
1479 : std::vector< parse_event > events_;
1480 : inner_handler_variant<converting_handler, T> inner_;
1481 : int inner_active_ = -1;
1482 :
1483 : public:
1484 : converting_handler( converting_handler const& ) = delete;
1485 : converting_handler& operator=( converting_handler const& ) = delete;
1486 :
1487 90 : converting_handler( T* v, P* p )
1488 90 : : value_( v )
1489 90 : , parent_( p )
1490 90 : {}
1491 :
1492 126 : bool signal_value(system::error_code& ec)
1493 : {
1494 126 : inner_.template emplace<0>();
1495 126 : inner_active_ = -1;
1496 126 : events_.clear();
1497 126 : return parent_->signal_value(ec);
1498 : }
1499 :
1500 14 : bool signal_end(system::error_code& ec)
1501 : {
1502 14 : return parent_->signal_end(ec);
1503 : }
1504 :
1505 : struct alternative_selector
1506 : {
1507 : converting_handler* self;
1508 :
1509 : template< class I >
1510 : void
1511 227 : operator()( I ) const
1512 : {
1513 : using V = mp11::mp_at<T, I>;
1514 227 : auto& v = self->value_->template emplace<I::value>( V{} );
1515 227 : self->inner_.template emplace<I::value + 1>(&v, self);
1516 227 : }
1517 : };
1518 : void
1519 233 : next_alternative()
1520 : {
1521 233 : if( ++inner_active_ >= static_cast<int>(variant_size::value) )
1522 6 : return;
1523 :
1524 227 : mp11::mp_with_index< variant_size::value >(
1525 227 : inner_active_, alternative_selector{this} );
1526 : }
1527 :
1528 : struct event_processor
1529 : {
1530 : converting_handler* self;
1531 : system::error_code& ec;
1532 : parse_event& event;
1533 :
1534 : template< class I >
1535 416 : bool operator()( I ) const
1536 : {
1537 416 : auto& handler = variant2::get<I::value + 1>(self->inner_);
1538 : using Handler = remove_cvref<decltype(handler)>;
1539 416 : return variant2::visit(
1540 832 : event_visitor<Handler>{handler, ec}, event );
1541 : }
1542 : };
1543 286 : bool process_events(system::error_code& ec)
1544 : {
1545 286 : constexpr std::size_t N = variant_size::value;
1546 :
1547 : // should be pointers not iterators, otherwise MSVC crashes
1548 286 : auto const last = events_.data() + events_.size();
1549 286 : auto first = last - 1;
1550 286 : bool ok = false;
1551 :
1552 286 : if( inner_active_ < 0 )
1553 146 : next_alternative();
1554 : do
1555 : {
1556 373 : if( static_cast<std::size_t>(inner_active_) >= N )
1557 : {
1558 6 : BOOST_JSON_FAIL( ec, error::exhausted_variants );
1559 6 : return false;
1560 : }
1561 :
1562 696 : for ( ; first != last; ++first )
1563 : {
1564 832 : ok = mp11::mp_with_index< N >(
1565 416 : inner_active_, event_processor{this, ec, *first} );
1566 416 : if( !ok )
1567 : {
1568 87 : first = events_.data();
1569 87 : next_alternative();
1570 87 : ec.clear();
1571 87 : break;
1572 : }
1573 : }
1574 : }
1575 367 : while( !ok );
1576 :
1577 280 : return true;
1578 : }
1579 :
1580 : #define BOOST_JSON_INVOKE_INNER(ev, ec) \
1581 : events_.emplace_back( ev ); \
1582 : return process_events(ec);
1583 :
1584 7 : bool on_object_begin( system::error_code& ec )
1585 : {
1586 7 : BOOST_JSON_INVOKE_INNER( object_begin_handler_event{}, ec );
1587 : }
1588 :
1589 7 : bool on_object_end( system::error_code& ec )
1590 : {
1591 7 : BOOST_JSON_INVOKE_INNER( object_end_handler_event{}, ec );
1592 : }
1593 :
1594 21 : bool on_array_begin( system::error_code& ec )
1595 : {
1596 21 : BOOST_JSON_INVOKE_INNER( array_begin_handler_event{}, ec );
1597 : }
1598 :
1599 28 : bool on_array_end( system::error_code& ec )
1600 : {
1601 28 : if( !inner_active_ )
1602 7 : return signal_end(ec);
1603 :
1604 21 : BOOST_JSON_INVOKE_INNER( array_end_handler_event{}, ec );
1605 : }
1606 :
1607 5 : bool on_key_part( system::error_code&, string_view sv )
1608 : {
1609 5 : string_.append(sv);
1610 5 : return true;
1611 : }
1612 :
1613 14 : bool on_key( system::error_code& ec, string_view sv )
1614 : {
1615 14 : string_.append(sv);
1616 28 : BOOST_JSON_INVOKE_INNER( key_handler_event{ std::move(string_) }, ec );
1617 14 : }
1618 :
1619 31 : bool on_string_part( system::error_code&, string_view sv )
1620 : {
1621 31 : string_.append(sv);
1622 31 : return true;
1623 : }
1624 :
1625 48 : bool on_string( system::error_code& ec, string_view sv )
1626 : {
1627 48 : string_.append(sv);
1628 96 : BOOST_JSON_INVOKE_INNER(
1629 : string_handler_event{ std::move(string_) }, ec );
1630 48 : }
1631 :
1632 60 : bool on_number_part( system::error_code& )
1633 : {
1634 60 : return true;
1635 : }
1636 :
1637 133 : bool on_int64( system::error_code& ec, std::int64_t v )
1638 : {
1639 133 : BOOST_JSON_INVOKE_INNER( int64_handler_event{v}, ec );
1640 : }
1641 :
1642 7 : bool on_uint64( system::error_code& ec, std::uint64_t v )
1643 : {
1644 7 : BOOST_JSON_INVOKE_INNER( uint64_handler_event{v}, ec );
1645 : }
1646 :
1647 14 : bool on_double( system::error_code& ec, double v )
1648 : {
1649 14 : BOOST_JSON_INVOKE_INNER( double_handler_event{v}, ec );
1650 : }
1651 :
1652 7 : bool on_bool( system::error_code& ec, bool v )
1653 : {
1654 7 : BOOST_JSON_INVOKE_INNER( bool_handler_event{v}, ec );
1655 : }
1656 :
1657 7 : bool on_null( system::error_code& ec )
1658 : {
1659 7 : BOOST_JSON_INVOKE_INNER( null_handler_event{}, ec );
1660 : }
1661 :
1662 : #undef BOOST_JSON_INVOKE_INNER
1663 : };
1664 :
1665 : // optional handler
1666 : template<class V, class P>
1667 : class converting_handler<optional_category::value, V, P>
1668 : {
1669 : private:
1670 : using inner_type = value_result_type<V>;
1671 : using inner_handler_type = get_handler<inner_type, converting_handler>;
1672 :
1673 : V* value_;
1674 : P* parent_;
1675 :
1676 : inner_type inner_value_ = {};
1677 : inner_handler_type inner_;
1678 : bool inner_active_ = false;
1679 :
1680 : public:
1681 : converting_handler( converting_handler const& ) = delete;
1682 : converting_handler& operator=( converting_handler const& ) = delete;
1683 :
1684 : converting_handler( V* v, P* p )
1685 : : value_(v), parent_(p), inner_(&inner_value_, this)
1686 : {}
1687 :
1688 : bool signal_value(system::error_code& ec)
1689 : {
1690 : *value_ = std::move(inner_value_);
1691 :
1692 : inner_active_ = false;
1693 : return parent_->signal_value(ec);
1694 : }
1695 :
1696 : bool signal_end(system::error_code& ec)
1697 : {
1698 : return parent_->signal_end(ec);
1699 : }
1700 :
1701 : #define BOOST_JSON_INVOKE_INNER(fn) \
1702 : if( !inner_active_ ) \
1703 : inner_active_ = true; \
1704 : return inner_.fn;
1705 :
1706 : bool on_object_begin( system::error_code& ec )
1707 : {
1708 : BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );
1709 : }
1710 :
1711 : bool on_object_end( system::error_code& ec )
1712 : {
1713 : BOOST_JSON_INVOKE_INNER( on_object_end(ec) );
1714 : }
1715 :
1716 : bool on_array_begin( system::error_code& ec )
1717 : {
1718 : BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );
1719 : }
1720 :
1721 : bool on_array_end( system::error_code& ec )
1722 : {
1723 : if( !inner_active_ )
1724 : return signal_end(ec);
1725 :
1726 : BOOST_JSON_INVOKE_INNER( on_array_end(ec) );
1727 : }
1728 :
1729 : bool on_key_part( system::error_code& ec, string_view sv )
1730 : {
1731 : BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );
1732 : }
1733 :
1734 : bool on_key( system::error_code& ec, string_view sv )
1735 : {
1736 : BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );
1737 : }
1738 :
1739 : bool on_string_part( system::error_code& ec, string_view sv )
1740 : {
1741 : BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );
1742 : }
1743 :
1744 : bool on_string( system::error_code& ec, string_view sv )
1745 : {
1746 : BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );
1747 : }
1748 :
1749 : bool on_number_part( system::error_code& ec )
1750 : {
1751 : BOOST_JSON_INVOKE_INNER( on_number_part(ec) );
1752 : }
1753 :
1754 : bool on_int64( system::error_code& ec, std::int64_t v )
1755 : {
1756 : BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );
1757 : }
1758 :
1759 : bool on_uint64( system::error_code& ec, std::uint64_t v )
1760 : {
1761 : BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );
1762 : }
1763 :
1764 : bool on_double( system::error_code& ec, double v )
1765 : {
1766 : BOOST_JSON_INVOKE_INNER( on_double(ec, v) );
1767 : }
1768 :
1769 : bool on_bool( system::error_code& ec, bool v )
1770 : {
1771 : BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );
1772 : }
1773 :
1774 : bool on_null(system::error_code& ec)
1775 : {
1776 : if( !inner_active_ )
1777 : {
1778 : *value_ = {};
1779 : return this->parent_->signal_value(ec);
1780 : }
1781 : else
1782 : {
1783 : return inner_.on_null(ec);
1784 : }
1785 : }
1786 :
1787 : #undef BOOST_JSON_INVOKE_INNER
1788 : };
1789 :
1790 : // path handler
1791 : template< class V, class P >
1792 : class converting_handler<path_category::value, V, P>
1793 : : public scalar_handler<P, error::not_string>
1794 : {
1795 : private:
1796 : V* value_;
1797 : bool cleared_ = false;
1798 :
1799 : public:
1800 : converting_handler( V* v, P* p )
1801 : : converting_handler::scalar_handler(p)
1802 : , value_(v)
1803 : {}
1804 :
1805 : bool on_string_part( system::error_code&, string_view sv )
1806 : {
1807 : if( !cleared_ )
1808 : {
1809 : cleared_ = true;
1810 : value_->clear();
1811 : }
1812 :
1813 : value_->concat( sv.begin(), sv.end() );
1814 : return true;
1815 : }
1816 :
1817 : bool on_string(system::error_code& ec, string_view sv)
1818 : {
1819 : if( !cleared_ )
1820 : value_->clear();
1821 : else
1822 : cleared_ = false;
1823 :
1824 : value_->concat( sv.begin(), sv.end() );
1825 :
1826 : return this->parent_->signal_value(ec);
1827 : }
1828 : };
1829 :
1830 : // into_handler
1831 : template< class V >
1832 : class into_handler
1833 : {
1834 : private:
1835 :
1836 : using inner_handler_type = get_handler<V, into_handler>;
1837 :
1838 : inner_handler_type inner_;
1839 : bool inner_active_ = true;
1840 :
1841 : public:
1842 :
1843 : into_handler( into_handler const& ) = delete;
1844 : into_handler& operator=( into_handler const& ) = delete;
1845 :
1846 : public:
1847 :
1848 : static constexpr std::size_t max_object_size = object::max_size();
1849 : static constexpr std::size_t max_array_size = array::max_size();
1850 : static constexpr std::size_t max_key_size = string::max_size();
1851 : static constexpr std::size_t max_string_size = string::max_size();
1852 :
1853 : public:
1854 :
1855 522 : explicit into_handler( V* v ): inner_( v, this )
1856 : {
1857 522 : }
1858 :
1859 466 : bool signal_value(system::error_code&)
1860 : {
1861 466 : return true;
1862 : }
1863 :
1864 7 : bool signal_end(system::error_code&)
1865 : {
1866 7 : return true;
1867 : }
1868 :
1869 521 : bool on_document_begin( system::error_code& )
1870 : {
1871 521 : return true;
1872 : }
1873 :
1874 473 : bool on_document_end( system::error_code& )
1875 : {
1876 473 : inner_active_ = false;
1877 473 : return true;
1878 : }
1879 :
1880 : #define BOOST_JSON_INVOKE_INNER(f) \
1881 : if( !inner_active_ ) \
1882 : { \
1883 : BOOST_JSON_FAIL( ec, error::extra_data ); \
1884 : return false; \
1885 : } \
1886 : else \
1887 : return inner_.f
1888 :
1889 144 : bool on_object_begin( system::error_code& ec )
1890 : {
1891 144 : BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );
1892 : }
1893 :
1894 138 : bool on_object_end( std::size_t, system::error_code& ec )
1895 : {
1896 138 : BOOST_JSON_INVOKE_INNER( on_object_end(ec) );
1897 : }
1898 :
1899 418 : bool on_array_begin( system::error_code& ec )
1900 : {
1901 418 : BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );
1902 : }
1903 :
1904 404 : bool on_array_end( std::size_t, system::error_code& ec )
1905 : {
1906 404 : BOOST_JSON_INVOKE_INNER( on_array_end(ec) );
1907 : }
1908 :
1909 48 : bool on_key_part( string_view sv, std::size_t, system::error_code& ec )
1910 : {
1911 48 : BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );
1912 : }
1913 :
1914 139 : bool on_key( string_view sv, std::size_t, system::error_code& ec )
1915 : {
1916 139 : BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );
1917 : }
1918 :
1919 54 : bool on_string_part( string_view sv, std::size_t, system::error_code& ec )
1920 : {
1921 54 : BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );
1922 : }
1923 :
1924 101 : bool on_string( string_view sv, std::size_t, system::error_code& ec )
1925 : {
1926 101 : BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );
1927 : }
1928 :
1929 484 : bool on_number_part( string_view, system::error_code& ec )
1930 : {
1931 484 : BOOST_JSON_INVOKE_INNER( on_number_part(ec) );
1932 : }
1933 :
1934 707 : bool on_int64( std::int64_t v, string_view, system::error_code& ec )
1935 : {
1936 707 : BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );
1937 : }
1938 :
1939 39 : bool on_uint64( std::uint64_t v, string_view, system::error_code& ec )
1940 : {
1941 39 : BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );
1942 : }
1943 :
1944 63 : bool on_double( double v, string_view, system::error_code& ec )
1945 : {
1946 63 : BOOST_JSON_INVOKE_INNER( on_double(ec, v) );
1947 : }
1948 :
1949 44 : bool on_bool( bool v, system::error_code& ec )
1950 : {
1951 44 : BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );
1952 : }
1953 :
1954 39 : bool on_null( system::error_code& ec )
1955 : {
1956 39 : BOOST_JSON_INVOKE_INNER( on_null(ec) );
1957 : }
1958 :
1959 1254 : bool on_comment_part(string_view, system::error_code&)
1960 : {
1961 1254 : return true;
1962 : }
1963 :
1964 66 : bool on_comment(string_view, system::error_code&)
1965 : {
1966 66 : return true;
1967 : }
1968 :
1969 : #undef BOOST_JSON_INVOKE_INNER
1970 : };
1971 :
1972 : } // namespace detail
1973 : } // namespace boost
1974 : } // namespace json
1975 :
1976 : #endif
|
