From f73d03af885940facfbc8d40bf139e373b36bcab Mon Sep 17 00:00:00 2001 From: Dmitry Arkhipov Date: Mon, 21 Aug 2023 11:10:01 +0300 Subject: [PATCH] temp --- include/boost/json/detail/parse_into.hpp | 37 ++++++++++++++++++++---- test/parse_into.cpp | 17 +++++++++++ 2 files changed, 48 insertions(+), 6 deletions(-) diff --git a/include/boost/json/detail/parse_into.hpp b/include/boost/json/detail/parse_into.hpp index 4c432b627..3f3f76ec8 100644 --- a/include/boost/json/detail/parse_into.hpp +++ b/include/boost/json/detail/parse_into.hpp @@ -18,6 +18,7 @@ #include #include +#include /* * This file contains the majority of parse_into functionality, specifically @@ -1244,7 +1245,7 @@ class converting_handler converting_handler( T* v, P* p ) : value_( v ) , parent_( p ) - {} + { } void signal_value() { @@ -1267,46 +1268,57 @@ class converting_handler void operator()( I ) const { + std::cerr << "alternative_selector " << I::value << " 1\n"; using V = mp11::mp_at; auto& v = self->value_->template emplace( V{} ); + std::cerr << "alternative_selector " << I::value << " 2\n"; self->inner_.template emplace(&v, self); + std::cerr << "alternative_selector " << I::value << " 3\n"; } }; void next_alternative() { + std::cerr << "next_alternative 1\n"; if( ++inner_active_ >= static_cast(variant_size::value) ) return; + std::cerr << "next_alternative 2\n"; mp11::mp_with_index< variant_size::value >( inner_active_, alternative_selector{this} ); + std::cerr << "next_alternative 3\n"; } struct event_processor { converting_handler* self; - error_code& ec; - parse_event& event; + error_code* ec; + parse_event* event; template< class I > bool operator()( I ) const { + std::cerr << "event_processor " << I::value << " 1\n"; auto& handler = variant2::get(self->inner_); + std::cerr << "event_processor " << I::value << " 2\n"; using Handler = remove_cvref; return variant2::visit( - event_visitor{handler, ec}, event ); + event_visitor{handler, *ec}, *event ); } }; bool process_events(error_code& ec) { + std::cerr << "process_events 1\n"; constexpr std::size_t N = variant_size::value; auto const last = events_.end(); auto first = last - 1; bool ok = false; + std::cerr << "process_events 2 " << (&*first) << "\n"; if( inner_active_ < 0 ) next_alternative(); + std::cerr << "process_events 3 " << (&*first) << "\n"; do { if( static_cast(inner_active_) >= N ) @@ -1314,22 +1326,35 @@ class converting_handler BOOST_JSON_FAIL( ec, error::exhausted_variants ); return false; } + std::cerr << "process_events 4 " << (&*first) << "\n"; - for ( ; first != last; ++first ) + // for ( ; first != last; ++first ) + while ( first != last ) { + parse_event& event = *first; + std::cerr << "process_events 5 " << (&*first) << "\n"; ok = mp11::mp_with_index< N >( - inner_active_, event_processor{this, ec, *first} ); + inner_active_, event_processor{this, &ec, &event} ); + std::cerr << "process_events 6 " << (&*first) << "\n"; if( !ok ) { first = events_.begin(); + std::cerr << "process_events 7 " << (&*first) << "\n"; next_alternative(); + std::cerr << "process_events 8 " << (&*first) << "\n"; ec.clear(); + std::cerr << "process_events 9 " << (&*first) << "\n"; break; } + std::cerr << "process_events 10 " << (&*first) << "\n"; + ++first; + std::cerr << "process_events 11 " << (&*first) << "\n"; } + std::cerr << "process_events 12\n"; } while( !ok ); + std::cerr << "process_events 13\n"; return true; } diff --git a/test/parse_into.cpp b/test/parse_into.cpp index 703874e64..bb3ff6ca1 100644 --- a/test/parse_into.cpp +++ b/test/parse_into.cpp @@ -17,6 +17,7 @@ #include #include +#include #include "test.hpp" #include "test_suite.hpp" @@ -59,29 +60,35 @@ class parse_into_test template void testParseInto( T const& t ) { + std::cerr << "testParseInto 1" << '\n'; T t1( t ); std::string json = serialize( value_from( t1 ) ); + std::cerr << "testParseInto 2" << '\n'; T t2{}; error_code jec; parse_into(t2, json, jec); BOOST_TEST( !jec.failed() ) && BOOST_TEST( t1 == t2 ); + std::cerr << "testParseInto 3" << '\n'; T t3{}; std::error_code ec; parse_into(t3, json, ec); BOOST_TEST( !ec ) && BOOST_TEST( t1 == t3 ); + std::cerr << "testParseInto 4" << '\n'; T t4{}; parse_into(t4, json); BOOST_TEST( t1 == t4 ); + std::cerr << "testParseInto 5" << '\n'; std::istringstream is(json); T t5{}; jec = {}; parse_into(t5, is, jec); BOOST_TEST( !jec.failed() ) && BOOST_TEST( t1 == t5 ); + std::cerr << "testParseInto 6" << '\n'; is.clear(); is.seekg(0); T t6{}; @@ -89,11 +96,14 @@ class parse_into_test parse_into(t6, is, ec); BOOST_TEST( !ec ) && BOOST_TEST( t1 == t6 ); + std::cerr << "testParseInto 7" << '\n'; is.clear(); is.seekg(0); T t7{}; parse_into(t7, is); BOOST_TEST( t1 == t7 ); + + std::cerr << "testParseInto 8" << '\n'; } void testNull() @@ -218,7 +228,9 @@ class parse_into_test template< template class Variant, class Monostate > void testVariant() { + std::cerr << "variant 1 " << '\n'; testParseInto< Variant >( 1 ); + std::cerr << "variant 2 " << '\n'; testParseInto< Variant >( 1 ); testParseInto< Variant >( "qwerty" ); testParseInto< Variant >( {} ); @@ -233,6 +245,7 @@ class parse_into_test testParseInto< std::vector< Variant > >( {1, 2, 3, "four", 5, "six", "seven", 8}); + std::cerr << "variant 3 " << '\n'; using V = Variant< std::vector< int >, std::tuple< int, std::string, std::map >, @@ -242,6 +255,8 @@ class parse_into_test 5, "five", std::map{ {"one", 1}, {"pi", 3.14} })); + + std::cerr << "variant 4 " << '\n'; } void testOptional() @@ -278,8 +293,10 @@ class parse_into_test testStruct(); testEnum(); testOptional(); + std::cerr << "before variant2" << '\n'; testVariant(); #ifndef BOOST_NO_CXX17_HDR_VARIANT + std::cerr << "before std::variant" << '\n'; testVariant(); #endif }