EIC code displayed by LXR master/​include/​boost/​json/​detail/​parse_into.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:38:59

 //
 // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 // Official repository: https://github.com/boostorg/json
 //
 
 #ifndef BOOST_JSON_DETAIL_PARSE_INTO_HPP
 #define BOOST_JSON_DETAIL_PARSE_INTO_HPP
 
 #include <boost/json/detail/config.hpp>
 
 #include <boost/json/error.hpp>
 #include <boost/json/conversion.hpp>
 #include <boost/describe/enum_from_string.hpp>
 
 #include <vector>
 
 /*
  * This file contains the majority of parse_into functionality, specifically
  * the implementation of dedicated handlers for different generic categories of
  * types.
  *
  * At the core of parse_into is the specialisation basic_parser<
  * detail::into_handler<T> >. detail::into_handler<T> is a handler for
  * basic_parser. It directly handles events on_comment_part and on_comment (by
  * ignoring them), on_document_begin (by enabling the nested dedicated
  * handler), and on_document_end (by disabling the nested handler).
  *
  * Every other event is handled by the nested handler, which has the type
  * get_handler< T, into_handler<T> >. The second parameter is the parent
  * handler (in this case, it's the top handler, into_handler<T>). The type is
  * actually an alias to class template converting_handler, which has a separate
  * specialisation for every conversion category from the list of generic
  * conversion categories (e.g. sequence_conversion_tag, tuple_conversion_tag,
  * etc.) Instantiations of the template store a pointer to the parent handler
  * and a pointer to the value T.
  *
  * The nested handler handles specific parser events by setting error_code to
  * an appropriate value, if it receives an event it isn't supposed to handle
  * (e.g. a number handler getting an on_string event), and also updates the
  * value when appropriate. Note that they never need to handle on_comment_part,
  * on_comment, on_document_begin, and on_document_end events, as those are
  * always handled by the top handler into_handler<T>.
  *
  * When the nested handler receives an event that completes the current value,
  * it is supposed to call its parent's signal_value member function. This is
  * necessary for correct handling of composite types (e.g. sequences).
  *
  * Finally, nested handlers should always call parent's signal_end member
  * function if they don't handle on_array_end themselves. This is necessary
  * to correctly handle nested composites (e.g. sequences inside sequences).
  * signal_end can return false and set error state when the containing parser
  * requires more elements.
  *
  * converting_handler instantiations for composite categories of types have
  * their own nested handlers, to which they themselves delegate events. For
  * complex types you will get a tree of handlers with into_handler<T> as the
  * root and handlers for scalars as leaves.
  *
  * To reiterate, only into_handler has to handle on_comment_part, on_comment,
  * on_document_begin, and on_document_end; only handlers for composites and
  * into_handler has to provide signal_value and signal_end; all handlers
  * except for into_handler have to call their parent's signal_end from
  * their on_array_begin, if they don't handle it themselves; once a handler
  * receives an event that finishes its current value, it should call its
  * parent's signal_value.
  */
 
 namespace boost {
 namespace json {
 namespace detail {
 
 template< class Impl, class T, class Parent >
 class converting_handler;
 
 // get_handler
 template< class V, class P >
 using get_handler = converting_handler< generic_conversion_category<V>, V, P >;
 
 template<error E> class handler_error_base
 {
 public:
 
     handler_error_base() = default;
 
     handler_error_base( handler_error_base const& ) = delete;
     handler_error_base& operator=( handler_error_base const& ) = delete;
 
 public:
 
     bool on_object_begin( error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_array_begin( error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_array_end( error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_string_part( error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_string( error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_number_part( error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_int64( error_code& ec, std::int64_t ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_uint64( error_code& ec, std::uint64_t ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_double( error_code& ec, double ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_bool( error_code& ec, bool ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_null( error_code& ec ) { BOOST_JSON_FAIL( ec, E ); return false; }
 
     // LCOV_EXCL_START
     // parses that can't handle this would fail at on_object_begin
     bool on_object_end( error_code& ) { BOOST_ASSERT( false ); return false; }
     bool on_key_part( error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }
     bool on_key( error_code& ec, string_view ) { BOOST_JSON_FAIL( ec, E ); return false; }
     // LCOV_EXCL_START
 };
 
 template< class P, error E >
 class scalar_handler
     : public handler_error_base<E>
 {
 protected:
     P* parent_;
 
 public:
     scalar_handler(scalar_handler const&) = delete;
     scalar_handler& operator=(scalar_handler const&) = delete;
 
     scalar_handler(P* p): parent_( p )
     {}
 
     bool on_array_end( error_code& ec )
     {
         return parent_->signal_end(ec);
     }
 };
 
 template< class D, class V, class P, error E >
 class composite_handler
 {
 protected:
     using inner_handler_type = get_handler<V, D>;
 
     P* parent_;
 #if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)
 # pragma GCC diagnostic push
 # pragma GCC diagnostic ignored "-Wmissing-field-initializers"
 #endif
     V next_value_ = {};
     inner_handler_type inner_;
     bool inner_active_ = false;
 
 public:
     composite_handler( composite_handler const& ) = delete;
     composite_handler& operator=( composite_handler const& ) = delete;
 
     composite_handler( P* p )
         : parent_(p), inner_( &next_value_, static_cast<D*>(this) )
     {}
 #if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)
 # pragma GCC diagnostic pop
 #endif
 
     bool signal_end(error_code&)
     {
         inner_active_ = false;
         parent_->signal_value();
         return true;
     }
 
 #define BOOST_JSON_INVOKE_INNER(f) \
     if( !inner_active_ ) { \
         BOOST_JSON_FAIL(ec, E); \
         return false; \
     } \
     else \
         return inner_.f
 
     bool on_object_begin( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );
     }
 
     bool on_object_end( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_object_end(ec) );
     }
 
     bool on_array_begin( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );
     }
 
     bool on_array_end( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_array_end(ec) );
     }
 
     bool on_key_part( error_code& ec, string_view sv )
     {
         BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );
     }
 
     bool on_key( error_code& ec, string_view sv )
     {
         BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );
     }
 
     bool on_string_part( error_code& ec, string_view sv )
     {
         BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );
     }
 
     bool on_string( error_code& ec, string_view sv )
     {
         BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );
     }
 
     bool on_number_part( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_number_part(ec) );
     }
 
     bool on_int64( error_code& ec, std::int64_t v )
     {
         BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );
     }
 
     bool on_uint64( error_code& ec, std::uint64_t v )
     {
         BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );
     }
 
     bool on_double( error_code& ec, double v )
     {
         BOOST_JSON_INVOKE_INNER( on_double(ec, v) );
     }
 
     bool on_bool( error_code& ec, bool v )
     {
         BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );
     }
 
     bool on_null( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_null(ec) );
     }
 
 #undef BOOST_JSON_INVOKE_INNER
 };
 
 // integral handler
 template<class V,
 typename std::enable_if<std::is_signed<V>::value, int>::type = 0>
 bool integral_in_range( std::int64_t v )
 {
     return v >= (std::numeric_limits<V>::min)() && v <= (std::numeric_limits<V>::max)();
 }
 
 template<class V,
 typename std::enable_if<!std::is_signed<V>::value, int>::type = 0>
 bool integral_in_range( std::int64_t v )
 {
     return v >= 0 && static_cast<std::uint64_t>( v ) <= (std::numeric_limits<V>::max)();
 }
 
 template<class V>
 bool integral_in_range( std::uint64_t v )
 {
     return v <= static_cast<typename std::make_unsigned<V>::type>( (std::numeric_limits<V>::max)() );
 }
 
 template< class V, class P >
 class converting_handler<integral_conversion_tag, V, P>
     : public scalar_handler<P, error::not_integer>
 {
 private:
     V* value_;
 
 public:
     converting_handler( V* v, P* p )
         : converting_handler::scalar_handler(p)
         , value_(v)
     {}
 
     bool on_number_part( error_code& )
     {
         return true;
     }
 
     bool on_int64( error_code& ec, std::int64_t v )
     {
         if( !integral_in_range<V>( v ) )
         {
             BOOST_JSON_FAIL( ec, error::not_exact );
             return false;
         }
 
         *value_ = static_cast<V>( v );
 
         this->parent_->signal_value();
         return true;
     }
 
     bool on_uint64( error_code& ec, std::uint64_t v )
     {
         if( !integral_in_range<V>( v ) )
         {
             BOOST_JSON_FAIL( ec, error::not_exact );
             return false;
         }
 
         *value_ = static_cast<V>( v );
 
         this->parent_->signal_value();
         return true;
     }
 };
 
 // floating point handler
 template< class V, class P>
 class converting_handler<floating_point_conversion_tag, V, P>
     : public scalar_handler<P, error::not_double>
 {
 private:
     V* value_;
 
 public:
     converting_handler( V* v, P* p )
         : converting_handler::scalar_handler(p)
         , value_(v)
     {}
 
     bool on_number_part( error_code& )
     {
         return true;
     }
 
     bool on_int64( error_code&, std::int64_t v )
     {
         *value_ = static_cast<V>( v );
 
         this->parent_->signal_value();
         return true;
     }
 
     bool on_uint64( error_code&, std::uint64_t v )
     {
         *value_ = static_cast<V>( v );
 
         this->parent_->signal_value();
         return true;
     }
 
     bool on_double( error_code&, double v )
     {
         *value_ = static_cast<V>( v );
 
         this->parent_->signal_value();
         return true;
     }
 };
 
 // string handler
 template< class V, class P >
 class converting_handler<string_like_conversion_tag, V, P>
     : public scalar_handler<P, error::not_string>
 {
 private:
     V* value_;
     bool cleared_ = false;
 
 public:
     converting_handler( V* v, P* p )
         : converting_handler::scalar_handler(p)
         , value_(v)
     {}
 
     bool on_string_part( error_code&, string_view sv )
     {
         if( !cleared_ )
         {
             cleared_ = true;
             value_->clear();
         }
 
         value_->append( sv.begin(), sv.end() );
         return true;
     }
 
     bool on_string( error_code&, string_view sv )
     {
         if( !cleared_ )
             value_->clear();
         else
             cleared_ = false;
 
         value_->append( sv.begin(), sv.end() );
 
         this->parent_->signal_value();
         return true;
     }
 };
 
 // bool handler
 template< class V, class P >
 class converting_handler<bool_conversion_tag, V, P>
     : public scalar_handler<P, error::not_bool>
 {
 private:
     V* value_;
 
 public:
     converting_handler( V* v, P* p )
         : converting_handler::scalar_handler(p)
         , value_(v)
     {}
 
     bool on_bool( error_code&, bool v )
     {
         *value_ = v;
 
         this->parent_->signal_value();
         return true;
     }
 };
 
 // null handler
 template< class V, class P >
 class converting_handler<null_like_conversion_tag, V, P>
     : public scalar_handler<P, error::not_null>
 {
 private:
     V* value_;
 
 public:
     converting_handler( V* v, P* p )
         : converting_handler::scalar_handler(p)
         , value_(v)
     {}
 
     bool on_null( error_code& )
     {
         *value_ = {};
 
         this->parent_->signal_value();
         return true;
     }
 };
 
 // described enum handler
 template< class V, class P >
 class converting_handler<described_enum_conversion_tag, V, P>
     : public scalar_handler<P, error::not_string>
 {
 #ifndef BOOST_DESCRIBE_CXX14
 
     static_assert(
         sizeof(V) == 0, "Enum support for parse_into requires C++14" );
 
 #else
 
 private:
     V* value_;
     std::string name_;
 
 public:
     converting_handler( V* v, P* p )
         : converting_handler::scalar_handler(p)
         , value_(v)
     {}
 
     bool on_string_part( error_code&, string_view sv )
     {
         name_.append( sv.begin(), sv.end() );
         return true;
     }
 
     bool on_string( error_code& ec, string_view sv )
     {
         string_view name = sv;
         if( !name_.empty() )
         {
             name_.append( sv.begin(), sv.end() );
             name = name_;
         }
 
         if( !describe::enum_from_string(name, *value_) )
         {
             BOOST_JSON_FAIL(ec, error::unknown_name);
             return false;
         }
 
         this->parent_->signal_value();
         return true;
     }
 
 #endif // BOOST_DESCRIBE_CXX14
 };
 
 template< class V, class P >
 class converting_handler<no_conversion_tag, V, P>
 {
     static_assert( sizeof(V) == 0, "This type is not supported" );
 };
 
 // sequence handler
 template< class It >
 bool check_inserter( It l, It r )
 {
     return l == r;
 }
 
 template< class It1, class It2 >
 std::true_type check_inserter( It1, It2 )
 {
     return {};
 }
 
 template<class T>
 void
 clear_container(
     T&,
     mp11::mp_int<2>)
 {
 }
 
 template<class T>
 void
 clear_container(
     T& target,
     mp11::mp_int<1>)
 {
     target.clear();
 }
 
 template<class T>
 void
 clear_container(
     T& target,
     mp11::mp_int<0>)
 {
     target.clear();
 }
 
 template< class V, class P >
 class converting_handler<sequence_conversion_tag, V, P>
     : public composite_handler<
         converting_handler<sequence_conversion_tag, V, P>,
         detail::value_type<V>,
         P,
         error::not_array>
 {
 private:
     V* value_;
 
     using Inserter = decltype(
         detail::inserter(*value_, inserter_implementation<V>()) );
     Inserter inserter;
 
 public:
     converting_handler( V* v, P* p )
         : converting_handler::composite_handler(p)
         , value_(v)
         , inserter( detail::inserter(*value_, inserter_implementation<V>()) )
     {}
 
     void signal_value()
     {
         *inserter++ = std::move(this->next_value_);
 #if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)
 # pragma GCC diagnostic push
 # pragma GCC diagnostic ignored "-Wmissing-field-initializers"
 #endif
         this->next_value_ = {};
 #if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)
 # pragma GCC diagnostic pop
 #endif
     }
 
     bool signal_end(error_code& ec)
     {
         if( !check_inserter( inserter, value_->end() ) )
         {
             BOOST_JSON_FAIL( ec, error::size_mismatch );
             return false;
         }
 
         inserter = detail::inserter(*value_, inserter_implementation<V>());
 
         return converting_handler::composite_handler::signal_end(ec);
     }
 
     bool on_array_begin( error_code& ec )
     {
         if( this->inner_active_ )
             return this->inner_.on_array_begin( ec );
 
         this->inner_active_ = true;
         clear_container( *value_, inserter_implementation<V>() );
         return true;
     }
 
     bool on_array_end( error_code& ec )
     {
         if( this->inner_active_ )
             return this->inner_.on_array_end( ec );
 
         return this->parent_->signal_end(ec);
     }
 };
 
 // map handler
 template< class V, class P >
 class converting_handler<map_like_conversion_tag, V, P>
     : public composite_handler<
         converting_handler<map_like_conversion_tag, V, P>,
         detail::mapped_type<V>,
         P,
         error::not_object>
 {
 private:
     V* value_;
     std::string key_;
 
 public:
     converting_handler( V* v, P* p )
         : converting_handler::composite_handler(p), value_(v)
     {}
 
     void signal_value()
     {
         value_->emplace( std::move(key_), std::move(this->next_value_) );
 
         key_ = {};
         this->next_value_ = {};
 
         this->inner_active_ = false;
     }
 
     bool on_object_begin( error_code& ec )
     {
         if( this->inner_active_ )
             return this->inner_.on_object_begin(ec);
 
         clear_container( *value_, inserter_implementation<V>() );
         return true;
     }
 
     bool on_object_end( error_code& ec )
     {
         if( this->inner_active_ )
             return this->inner_.on_object_end(ec);
 
         this->parent_->signal_value();
         return true;
     }
 
     bool on_array_end( error_code& ec )
     {
         if( this->inner_active_ )
             return this->inner_.on_array_end(ec);
 
         return this->parent_->signal_end(ec);
     }
 
     bool on_key_part( error_code& ec, string_view sv )
     {
         if( this->inner_active_ )
             return this->inner_.on_key_part(ec, sv);
 
         key_.append( sv.data(), sv.size() );
         return true;
     }
 
     bool on_key( error_code& ec, string_view sv )
     {
         if( this->inner_active_ )
             return this->inner_.on_key(ec, sv);
 
         key_.append( sv.data(), sv.size() );
 
         this->inner_active_ = true;
         return true;
     }
 };
 
 // tuple handler
 template<std::size_t I, class T>
 struct handler_tuple_element
 {
     template< class... Args >
     handler_tuple_element( Args&& ... args )
         : t_( static_cast<Args&&>(args)... )
     {}
 
     T t_;
 };
 
 template<std::size_t I, class T>
 T&
 get( handler_tuple_element<I, T>& e )
 {
     return e.t_;
 }
 
 template<
     class P,
     class LV,
     class S = mp11::make_index_sequence<mp11::mp_size<LV>::value> >
 struct handler_tuple;
 
 template< class P, template<class...> class L, class... V, std::size_t... I >
 struct handler_tuple< P, L<V...>, mp11::index_sequence<I...> >
     : handler_tuple_element< I, get_handler<V, P> >
     ...
 {
     handler_tuple( handler_tuple const& ) = delete;
     handler_tuple& operator=( handler_tuple const& ) = delete;
 
     template< class Access, class T >
     handler_tuple( Access access, T* pv, P* pp )
         : handler_tuple_element< I, get_handler<V, P> >(
             access( pv, mp11::mp_int<I>() ),
             pp )
         ...
     { }
 };
 
 #if defined(BOOST_MSVC) && BOOST_MSVC < 1910
 
 template< class T >
 struct tuple_element_list_impl
 {
     template< class I >
     using tuple_element_helper = tuple_element_t<I::value, T>;
 
     using type = mp11::mp_transform<
         tuple_element_helper,
         mp11::mp_iota< std::tuple_size<T> > >;
 };
 template< class T >
 using tuple_element_list = typename tuple_element_list_impl<T>::type;
 
 #else
 
 template< class I, class T >
 using tuple_element_helper = tuple_element_t<I::value, T>;
 template< class T >
 using tuple_element_list = mp11::mp_transform_q<
     mp11::mp_bind_back< tuple_element_helper, T>,
     mp11::mp_iota< std::tuple_size<T> > >;
 
 #endif
 
 template< class Op, class... Args>
 struct handler_op_invoker
 {
 public:
     std::tuple<Args&...> args;
 
     template< class Handler >
     bool
     operator()( Handler& handler ) const
     {
         return (*this)( handler, mp11::index_sequence_for<Args...>() );
     }
 
 private:
     template< class Handler, std::size_t... I >
     bool
     operator()( Handler& handler, mp11::index_sequence<I...> ) const
     {
         return Op()( handler, std::get<I>(args)... );
     }
 };
 
 template< class Handlers, class F >
 struct tuple_handler_op_invoker
 {
     Handlers& handlers;
     F fn;
 
     template< class I >
     bool
     operator()( I ) const
     {
         return fn( get<I::value>(handlers) );
     }
 };
 
 struct tuple_accessor
 {
     template< class T, class I >
     auto operator()( T* t, I ) const -> tuple_element_t<I::value, T>*
     {
         using std::get;
         return &get<I::value>(*t);
     }
 };
 
 template< class T, class P >
 class converting_handler<tuple_conversion_tag, T, P>
 {
 
 private:
     T* value_;
     P* parent_;
 
     handler_tuple< converting_handler, tuple_element_list<T> > handlers_;
     int inner_active_ = -1;
 
 public:
     converting_handler( converting_handler const& ) = delete;
     converting_handler& operator=( converting_handler const& ) = delete;
 
     converting_handler( T* v, P* p )
         : value_(v) , parent_(p) , handlers_(tuple_accessor(), v, this)
     {}
 
     void signal_value()
     {
         ++inner_active_;
     }
 
     bool signal_end(error_code& ec)
     {
         constexpr int N = std::tuple_size<T>::value;
         if( inner_active_ < N )
         {
             BOOST_JSON_FAIL( ec, error::size_mismatch );
             return true;
         }
 
         inner_active_ = -1;
         parent_->signal_value();
         return true;
     }
 
 #define BOOST_JSON_HANDLE_EVENT(fn) \
     struct do_ ## fn \
     { \
         template< class H, class... Args > \
         bool operator()( H& h, Args& ... args ) const \
         { \
             return h. fn (args...); \
         } \
     }; \
        \
     template< class... Args > \
     bool fn( error_code& ec, Args&& ... args ) \
     { \
         if( inner_active_ < 0 ) \
         { \
             BOOST_JSON_FAIL( ec, error::not_array ); \
             return false; \
         } \
         constexpr int N = std::tuple_size<T>::value; \
         if( inner_active_ >= N ) \
         { \
             BOOST_JSON_FAIL( ec, error::size_mismatch ); \
             return false; \
         } \
         using F = handler_op_invoker< do_ ## fn, error_code, Args...>; \
         using H = decltype(handlers_); \
         return mp11::mp_with_index<N>( \
             inner_active_, \
             tuple_handler_op_invoker<H, F>{ \
                 handlers_, \
                 F{ std::forward_as_tuple(ec, args...) } } ); \
     }
 
     BOOST_JSON_HANDLE_EVENT( on_object_begin );
     BOOST_JSON_HANDLE_EVENT( on_object_end );
 
     struct do_on_array_begin
     {
         handler_tuple< converting_handler, tuple_element_list<T> >& handlers;
         error_code& ec;
 
         template< class I >
         bool operator()( I ) const
         {
             return get<I::value>(handlers).on_array_begin(ec);
         };
     };
     bool on_array_begin( error_code& ec )
     {
         if( inner_active_ < 0 )
         {
             inner_active_ = 0;
             return true;
         }
 
         constexpr int N = std::tuple_size<T>::value;
 
         if( inner_active_ >= N )
         {
             inner_active_ = 0;
             return true;
         }
 
         return mp11::mp_with_index<N>(
             inner_active_, do_on_array_begin{handlers_, ec} );
     }
 
     struct do_on_array_end
     {
         handler_tuple< converting_handler, tuple_element_list<T> >& handlers;
         error_code& ec;
 
         template< class I >
         bool operator()( I ) const
         {
             return get<I::value>(handlers).on_array_end(ec);
         };
     };
     bool on_array_end( error_code& ec )
     {
         if( inner_active_ < 0 )
             return parent_->signal_end(ec);
 
         constexpr int N = std::tuple_size<T>::value;
 
         if( inner_active_ >= N )
             return signal_end(ec);
 
         return mp11::mp_with_index<N>(
             inner_active_, do_on_array_end{handlers_, ec} );
     }
 
     BOOST_JSON_HANDLE_EVENT( on_key_part );
     BOOST_JSON_HANDLE_EVENT( on_key );
     BOOST_JSON_HANDLE_EVENT( on_string_part );
     BOOST_JSON_HANDLE_EVENT( on_string );
     BOOST_JSON_HANDLE_EVENT( on_number_part );
     BOOST_JSON_HANDLE_EVENT( on_int64 );
     BOOST_JSON_HANDLE_EVENT( on_uint64 );
     BOOST_JSON_HANDLE_EVENT( on_double );
     BOOST_JSON_HANDLE_EVENT( on_bool );
     BOOST_JSON_HANDLE_EVENT( on_null );
 
 #undef BOOST_JSON_HANDLE_EVENT
 };
 
 // described struct handler
 #if defined(BOOST_MSVC) && BOOST_MSVC < 1910
 
 template< class T >
 struct struct_element_list_impl
 {
     template< class D >
     using helper = described_member_t<T, D>;
 
     using type = mp11::mp_transform<
         helper,
         describe::describe_members<T, describe::mod_public> >;
 };
 template< class T >
 using struct_element_list = typename struct_element_list_impl<T>::type;
 
 #else
 
 template< class T >
 using struct_element_list = mp11::mp_transform_q<
     mp11::mp_bind_front< described_member_t, T >,
     describe::describe_members<T, describe::mod_public> >;
 
 #endif
 
 struct struct_accessor
 {
     template< class T, class I >
     auto operator()( T* t, I ) const
         -> described_member_t<T,
              mp11::mp_at<
                  describe::describe_members<T, describe::mod_public>, I> >*
     {
         using Ds = describe::describe_members<T, describe::mod_public>;
         using D = mp11::mp_at<Ds, I>;
         return &(t->*D::pointer);
     }
 };
 
 template< class F >
 struct struct_key_searcher
 {
     F fn;
 
     template< class D >
     void
     operator()( D ) const
     {
         fn( D::name ) ;
     }
 };
 
 template<class V, class P>
 class converting_handler<described_class_conversion_tag, V, P>
 {
 #if !defined(BOOST_DESCRIBE_CXX14)
 
     static_assert(
         sizeof(V) == 0, "Struct support for parse_into requires C++14" );
 
 #else
 
 private:
     V* value_;
     P* parent_;
 
     std::string key_;
 
     using Dm = describe::describe_members<V, describe::mod_public>;
 
     handler_tuple< converting_handler, struct_element_list<V> > handlers_;
     int inner_active_ = -1;
     std::size_t activated_ = 0;
 
 public:
     converting_handler( converting_handler const& ) = delete;
     converting_handler& operator=( converting_handler const& ) = delete;
 
     converting_handler( V* v, P* p )
         : value_(v), parent_(p), handlers_(struct_accessor(), v, this)
     {}
 
     struct is_optional_checker
     {
         template< class I >
         bool operator()( I ) const noexcept
         {
             using L = struct_element_list<V>;
             using T = mp11::mp_at<L, I>;
             return !is_optional_like<T>::value;
         }
     };
     void signal_value()
     {
         BOOST_ASSERT( inner_active_ >= 0 );
         bool required_member = mp11::mp_with_index< mp11::mp_size<Dm> >(
             inner_active_,
             is_optional_checker{});
         if( required_member )
             ++activated_;
 
         key_ = {};
         inner_active_ = -1;
     }
 
     bool signal_end(error_code&)
     {
         key_ = {};
         inner_active_ = -1;
         parent_->signal_value();
         return true;
     }
 
 #define BOOST_JSON_INVOKE_INNER(fn) \
     if( inner_active_ < 0 ) \
     { \
         BOOST_JSON_FAIL( ec, error::not_object ); \
         return false; \
     } \
     auto f = [&](auto& handler) { return handler.fn ; }; \
     using F = decltype(f); \
     using H = decltype(handlers_); \
     return mp11::mp_with_index< mp11::mp_size<Dm> >( \
             inner_active_, \
             tuple_handler_op_invoker<H, F>{handlers_, f} );
 
     bool on_object_begin( error_code& ec )
     {
         if( inner_active_ < 0 )
             return true;
 
         BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );
     }
 
     bool on_object_end( error_code& ec )
     {
         if( inner_active_ < 0 )
         {
             using L = struct_element_list<V>;
             using C = mp11::mp_count_if<L, is_optional_like>;
             constexpr int N = mp11::mp_size<L>::value - C::value;
             if( activated_ < N )
             {
                 BOOST_JSON_FAIL( ec, error::size_mismatch );
                 return false;
             }
 
             parent_->signal_value();
             return true;
         }
 
         BOOST_JSON_INVOKE_INNER( on_object_end(ec) );
     }
 
     bool on_array_begin( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );
     }
 
     bool on_array_end( error_code& ec )
     {
         if( inner_active_ < 0 )
             return parent_->signal_end(ec);
 
         BOOST_JSON_INVOKE_INNER( on_array_end(ec) );
     }
 
     bool on_key_part( error_code& ec, string_view sv )
     {
         if( inner_active_ < 0 )
         {
             key_.append( sv.data(), sv.size() );
             return true;
         }
 
         BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );
     }
 
     bool on_key( error_code& ec, string_view sv )
     {
         if( inner_active_ >= 0 )
         {
             BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );
         }
 
         string_view key = sv;
         if( !key_.empty() )
         {
             key_.append( sv.data(), sv.size() );
             key = key_;
         }
 
         int i = 0;
 
         auto f = [&](char const* name)
         {
             if( key == name )
                 inner_active_ = i;
             ++i;
         };
 
         mp11::mp_for_each<Dm>(
             struct_key_searcher<decltype(f)>{f} );
 
         if( inner_active_ < 0 )
         {
             BOOST_JSON_FAIL(ec, error::unknown_name);
             return false;
         }
 
         return true;
     }
 
     bool on_string_part( error_code& ec, string_view sv )
     {
         BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );
     }
 
     bool on_string( error_code& ec, string_view sv )
     {
         BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );
     }
 
     bool on_number_part( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_number_part(ec) );
     }
 
     bool on_int64( error_code& ec, std::int64_t v )
     {
         BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );
     }
 
     bool on_uint64( error_code& ec, std::uint64_t v )
     {
         BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );
     }
 
     bool on_double( error_code& ec, double v )
     {
         BOOST_JSON_INVOKE_INNER( on_double(ec, v) );
     }
 
     bool on_bool( error_code& ec, bool v )
     {
         BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );
     }
 
     bool on_null( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_null(ec) );
     }
 
 #undef BOOST_JSON_INVOKE_INNER
 
 #endif
 };
 
 // variant handler
 struct object_begin_handler_event
 { };
 
 struct object_end_handler_event
 { };
 
 struct array_begin_handler_event
 { };
 
 struct array_end_handler_event
 { };
 
 struct key_handler_event
 {
     std::string value;
 };
 
 struct string_handler_event
 {
     std::string value;
 };
 
 struct int64_handler_event
 {
     std::int64_t value;
 };
 
 struct uint64_handler_event
 {
     std::uint64_t value;
 };
 
 struct double_handler_event
 {
     double value;
 };
 
 struct bool_handler_event
 {
     bool value;
 };
 
 struct null_handler_event
 { };
 
 using parse_event = variant2::variant<
     object_begin_handler_event,
     object_end_handler_event,
     array_begin_handler_event,
     array_end_handler_event,
     key_handler_event,
     string_handler_event,
     int64_handler_event,
     uint64_handler_event,
     double_handler_event,
     bool_handler_event,
     null_handler_event>;
 
 template< class H >
 struct event_visitor
 {
     H& handler;
     error_code& ec;
 
     bool
     operator()(object_begin_handler_event&) const
     {
         return handler.on_object_begin(ec);
     }
 
     bool
     operator()(object_end_handler_event&) const
     {
         return handler.on_object_end(ec);
     }
 
     bool
     operator()(array_begin_handler_event&) const
     {
         return handler.on_array_begin(ec);
     }
 
     bool
     operator()(array_end_handler_event&) const
     {
         return handler.on_array_end(ec);
     }
 
     bool
     operator()(key_handler_event& ev) const
     {
         return handler.on_key(ec, ev.value);
     }
 
     bool
     operator()(string_handler_event& ev) const
     {
         return handler.on_string(ec, ev.value);
     }
 
     bool
     operator()(int64_handler_event& ev) const
     {
         return handler.on_int64(ec, ev.value);
     }
 
     bool
     operator()(uint64_handler_event& ev) const
     {
         return handler.on_uint64(ec, ev.value);
     }
 
     bool
     operator()(double_handler_event& ev) const
     {
         return handler.on_double(ec, ev.value);
     }
 
     bool
     operator()(bool_handler_event& ev) const
     {
         return handler.on_bool(ec, ev.value);
     }
 
     bool
     operator()(null_handler_event&) const
     {
         return handler.on_null(ec);
     }
 };
 
 // L<T...> -> variant< monostate, get_handler<T, P>... >
 template< class P, class L >
 using inner_handler_variant = mp11::mp_push_front<
     mp11::mp_transform_q<
         mp11::mp_bind_back<get_handler, P>,
         mp11::mp_apply<variant2::variant, L>>,
     variant2::monostate>;
 
 template< class T, class P >
 class converting_handler<variant_conversion_tag, T, P>
 {
 private:
     using variant_size = mp11::mp_size<T>;
 
     T* value_;
     P* parent_;
 
     std::string string_;
     std::vector< parse_event > events_;
     inner_handler_variant<converting_handler, T> inner_;
     int inner_active_ = -1;
 
 public:
     converting_handler( converting_handler const& ) = delete;
     converting_handler& operator=( converting_handler const& ) = delete;
 
     converting_handler( T* v, P* p )
         : value_( v )
         , parent_( p )
     {}
 
     void signal_value()
     {
         inner_.template emplace<0>();
         inner_active_ = -1;
         events_.clear();
         parent_->signal_value();
     }
 
     bool signal_end(error_code& ec)
     {
         return parent_->signal_end(ec);
     }
 
     struct alternative_selector
     {
         converting_handler* self;
 
         template< class I >
         void
         operator()( I ) const
         {
             using V = mp11::mp_at<T, I>;
             auto& v = self->value_->template emplace<I::value>( V{} );
             self->inner_.template emplace<I::value + 1>(&v, self);
         }
     };
     void
     next_alternative()
     {
         if( ++inner_active_ >= static_cast<int>(variant_size::value) )
             return;
 
         mp11::mp_with_index< variant_size::value >(
             inner_active_, alternative_selector{this} );
     }
 
     struct event_processor
     {
         converting_handler* self;
         error_code& ec;
         parse_event& event;
 
         template< class I >
         bool operator()( I ) const
         {
             auto& handler = variant2::get<I::value + 1>(self->inner_);
             using Handler = remove_cvref<decltype(handler)>;
             return variant2::visit(
                 event_visitor<Handler>{handler, ec}, event );
         }
     };
     bool process_events(error_code& ec)
     {
         constexpr std::size_t N = variant_size::value;
 
         // should be pointers not iterators, otherwise MSVC crashes
         auto const last = events_.data() + events_.size();
         auto first = last - 1;
         bool ok = false;
 
         if( inner_active_ < 0 )
             next_alternative();
         do
         {
             if( static_cast<std::size_t>(inner_active_) >= N )
             {
                 BOOST_JSON_FAIL( ec, error::exhausted_variants );
                 return false;
             }
 
             for ( ; first != last; ++first )
             {
                 ok = mp11::mp_with_index< N >(
                     inner_active_, event_processor{this, ec, *first} );
                 if( !ok )
                 {
                     first = events_.data();
                     next_alternative();
                     ec.clear();
                     break;
                 }
             }
         }
         while( !ok );
 
         return true;
     }
 
 #define BOOST_JSON_INVOKE_INNER(ev, ec) \
     events_.emplace_back( ev ); \
     return process_events(ec);
 
     bool on_object_begin( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( object_begin_handler_event{}, ec );
     }
 
     bool on_object_end( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( object_end_handler_event{}, ec );
     }
 
     bool on_array_begin( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( array_begin_handler_event{}, ec );
     }
 
     bool on_array_end( error_code& ec )
     {
         if( !inner_active_ )
             return signal_end(ec);
 
         BOOST_JSON_INVOKE_INNER( array_end_handler_event{}, ec );
     }
 
     bool on_key_part( error_code&, string_view sv )
     {
         string_.append(sv);
         return true;
     }
 
     bool on_key( error_code& ec, string_view sv )
     {
         string_.append(sv);
         BOOST_JSON_INVOKE_INNER( key_handler_event{ std::move(string_) }, ec );
     }
 
     bool on_string_part( error_code&, string_view sv )
     {
         string_.append(sv);
         return true;
     }
 
     bool on_string( error_code& ec, string_view sv )
     {
         string_.append(sv);
         BOOST_JSON_INVOKE_INNER(
             string_handler_event{ std::move(string_) }, ec );
     }
 
     bool on_number_part( error_code& )
     {
         return true;
     }
 
     bool on_int64( error_code& ec, std::int64_t v )
     {
         BOOST_JSON_INVOKE_INNER( int64_handler_event{v}, ec );
     }
 
     bool on_uint64( error_code& ec, std::uint64_t v )
     {
         BOOST_JSON_INVOKE_INNER( uint64_handler_event{v}, ec );
     }
 
     bool on_double( error_code& ec, double v )
     {
         BOOST_JSON_INVOKE_INNER( double_handler_event{v}, ec );
     }
 
     bool on_bool( error_code& ec, bool v )
     {
         BOOST_JSON_INVOKE_INNER( bool_handler_event{v}, ec );
     }
 
     bool on_null( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( null_handler_event{}, ec );
     }
 
 #undef BOOST_JSON_INVOKE_INNER
 };
 
 // optional handler
 template<class V, class P>
 class converting_handler<optional_conversion_tag, V, P>
 {
 private:
     using inner_type = value_result_type<V>;
     using inner_handler_type = get_handler<inner_type, converting_handler>;
 
     V* value_;
     P* parent_;
 
     inner_type inner_value_ = {};
     inner_handler_type inner_;
     bool inner_active_ = false;
 
 public:
     converting_handler( converting_handler const& ) = delete;
     converting_handler& operator=( converting_handler const& ) = delete;
 
     converting_handler( V* v, P* p )
         : value_(v), parent_(p), inner_(&inner_value_, this)
     {}
 
     void signal_value()
     {
         *value_ = std::move(inner_value_);
 
         inner_active_ = false;
         parent_->signal_value();
     }
 
     bool signal_end(error_code& ec)
     {
         return parent_->signal_end(ec);
     }
 
 #define BOOST_JSON_INVOKE_INNER(fn) \
     if( !inner_active_ ) \
         inner_active_ = true; \
     return inner_.fn;
 
     bool on_object_begin( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );
     }
 
     bool on_object_end( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_object_end(ec) );
     }
 
     bool on_array_begin( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );
     }
 
     bool on_array_end( error_code& ec )
     {
         if( !inner_active_ )
             return signal_end(ec);
 
         BOOST_JSON_INVOKE_INNER( on_array_end(ec) );
     }
 
     bool on_key_part( error_code& ec, string_view sv )
     {
         BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );
     }
 
     bool on_key( error_code& ec, string_view sv )
     {
         BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );
     }
 
     bool on_string_part( error_code& ec, string_view sv )
     {
         BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );
     }
 
     bool on_string( error_code& ec, string_view sv )
     {
         BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );
     }
 
     bool on_number_part( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_number_part(ec) );
     }
 
     bool on_int64( error_code& ec, std::int64_t v )
     {
         BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );
     }
 
     bool on_uint64( error_code& ec, std::uint64_t v )
     {
         BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );
     }
 
     bool on_double( error_code& ec, double v )
     {
         BOOST_JSON_INVOKE_INNER( on_double(ec, v) );
     }
 
     bool on_bool( error_code& ec, bool v )
     {
         BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );
     }
 
     bool on_null( error_code& ec )
     {
         if( !inner_active_ )
         {
             *value_ = {};
 
             this->parent_->signal_value();
             return true;
         }
         else
         {
             return inner_.on_null(ec);
         }
     }
 
 #undef BOOST_JSON_INVOKE_INNER
 };
 
 // into_handler
 template< class V >
 class into_handler
 {
 private:
 
     using inner_handler_type = get_handler<V, into_handler>;
 
     inner_handler_type inner_;
     bool inner_active_ = true;
 
 public:
 
     into_handler( into_handler const& ) = delete;
     into_handler& operator=( into_handler const& ) = delete;
 
 public:
 
     static constexpr std::size_t max_object_size = object::max_size();
     static constexpr std::size_t max_array_size = array::max_size();
     static constexpr std::size_t max_key_size = string::max_size();
     static constexpr std::size_t max_string_size = string::max_size();
 
 public:
 
     explicit into_handler( V* v ): inner_( v, this )
     {
     }
 
     void signal_value()
     {
     }
 
     bool signal_end(error_code&)
     {
         return true;
     }
 
     bool on_document_begin( error_code& )
     {
         return true;
     }
 
     bool on_document_end( error_code& )
     {
         inner_active_ = false;
         return true;
     }
 
 #define BOOST_JSON_INVOKE_INNER(f) \
     if( !inner_active_ ) \
     { \
         BOOST_JSON_FAIL( ec, error::extra_data ); \
         return false; \
     } \
     else \
         return inner_.f
 
     bool on_object_begin( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_object_begin(ec) );
     }
 
     bool on_object_end( std::size_t, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_object_end(ec) );
     }
 
     bool on_array_begin( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_array_begin(ec) );
     }
 
     bool on_array_end( std::size_t, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_array_end(ec) );
     }
 
     bool on_key_part( string_view sv, std::size_t, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_key_part(ec, sv) );
     }
 
     bool on_key( string_view sv, std::size_t, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_key(ec, sv) );
     }
 
     bool on_string_part( string_view sv, std::size_t, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_string_part(ec, sv) );
     }
 
     bool on_string( string_view sv, std::size_t, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_string(ec, sv) );
     }
 
     bool on_number_part( string_view, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_number_part(ec) );
     }
 
     bool on_int64( std::int64_t v, string_view, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_int64(ec, v) );
     }
 
     bool on_uint64( std::uint64_t v, string_view, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_uint64(ec, v) );
     }
 
     bool on_double( double v, string_view, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_double(ec, v) );
     }
 
     bool on_bool( bool v, error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_bool(ec, v) );
     }
 
     bool on_null( error_code& ec )
     {
         BOOST_JSON_INVOKE_INNER( on_null(ec) );
     }
 
     bool on_comment_part(string_view, error_code&)
     {
         return true;
     }
 
     bool on_comment(string_view, error_code&)
     {
         return true;
     }
 
 #undef BOOST_JSON_INVOKE_INNER
 };
 
 } // namespace detail
 } // namespace boost
 } // namespace json
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team