Diff coverage report for

//

//

// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)

// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)

// Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)

// Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// 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)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/boostorg/json

// Official repository: https://github.com/boostorg/json

//

//

#ifndef BOOST_JSON_BASIC_PARSER_HPP

#ifndef BOOST_JSON_BASIC_PARSER_HPP

#define BOOST_JSON_BASIC_PARSER_HPP

#define BOOST_JSON_BASIC_PARSER_HPP

#include <boost/json/detail/config.hpp>

#include <boost/json/detail/config.hpp>

#include <boost/json/detail/except.hpp>

#include <boost/json/detail/except.hpp>

#include <boost/json/error.hpp>

#include <boost/json/error.hpp>

#include <boost/json/kind.hpp>

#include <boost/json/kind.hpp>

#include <boost/json/parse_options.hpp>

#include <boost/json/parse_options.hpp>

#include <boost/json/detail/stack.hpp>

#include <boost/json/detail/stack.hpp>

#include <boost/json/detail/stream.hpp>

#include <boost/json/detail/stream.hpp>

#include <boost/json/detail/utf8.hpp>

#include <boost/json/detail/utf8.hpp>

#include <boost/json/detail/sbo_buffer.hpp>

#include <boost/json/detail/sbo_buffer.hpp>

namespace boost {

namespace boost {

namespace json {

namespace json {

/** An incremental SAX parser for serialized JSON.

/** An incremental SAX parser for serialized JSON.

    This implements a SAX-style parser, invoking a caller-supplied handler with

    This implements a SAX-style parser, invoking a

    each parsing event. To use, first declare a variable of type

    caller-supplied handler with each parsing event.

    `basic_parser<T>` where `T` meets the handler requirements specified below.

    To use, first declare a variable of type

    Then call @ref write_some one or more times with the input, setting

    `basic_parser<T>` where `T` meets the handler

    `more = false` on the final buffer. The parsing events are realized through

    requirements specified below. Then call

    member function calls on the handler, which exists as a data member of the

    @ref write_some one or more times with the input,

    parser.

    setting `more = false` on the final buffer.

    The parsing events are realized through member

    The parser may dynamically allocate intermediate storage as needed to

    function calls on the handler, which exists

    accommodate the nesting level of the input JSON. On subsequent invocations,

    as a data member of the parser.

    the parser can cheaply re-use this memory, improving performance. This

\n

    storage is freed when the parser is destroyed

    The parser may dynamically allocate intermediate

    storage as needed to accommodate the nesting level

    of the input JSON. On subsequent invocations, the

    parser can cheaply re-use this memory, improving

    performance. This storage is freed when the

    parser is destroyed

    @par Usage

    @par Usage

    To get the declaration and function definitions for this class it is

    necessary to include this file instead:

    To get the declaration and function definitions

    for this class it is necessary to include this

    file instead:

    @code

    @code

    #include <boost/json/basic_parser_impl.hpp>

    #include <boost/json/basic_parser_impl.hpp>

    @endcode

    @endcode

    Users who wish to parse JSON into the DOM container @ref value will not use

    Users who wish to parse JSON into the DOM container

    this class directly; instead they will create an instance of @ref parser or

    @ref value will not use this class directly; instead

    @ref stream_parser and use that instead. Alternatively, they may call the

    they will create an instance of @ref parser or

    function @ref parse. This class is designed for users who wish to perform

    @ref stream_parser and use that instead. Alternatively,

    custom actions instead of building a @ref value. For example, to produce a

    they may call the function @ref parse. This class is

    DOM from an external library.

    designed for users who wish to perform custom actions

    instead of building a @ref value. For example, to

    produce a DOM from an external library.

\n

    @note

    @note

    By default, only conforming JSON using UTF-8 encoding is accepted. However,

    select non-compliant syntax can be allowed by construction using a

    By default, only conforming JSON using UTF-8

    encoding is accepted. However, select non-compliant

    syntax can be allowed by construction using a

    @ref parse_options set to desired values.

    @ref parse_options set to desired values.

    The handler provided must be implemented as an object of class type which

    defines each of the required event member functions below. The event

    functions return a `bool` where `true` indicates success, and `false`

    indicates failure. If the member function returns `false`, it must set the

    error code to a suitable value. This error code will be returned by the

    write function to the caller.

    @par Handler

    @par Handler

    Handlers are required to declare the maximum limits on various elements. If

    The handler provided must be implemented as an

    these limits are exceeded during parsing, then parsing fails with an error.

    object of class type which defines each of the

    required event member functions below. The event

    The following declaration meets the parser's handler requirements:

    functions return a `bool` where `true` indicates

    success, and `false` indicates failure. If the

    member function returns `false`, it must set

    the error code to a suitable value. This error

    code will be returned by the write function to

    the caller.

\n

    Handlers are required to declare the maximum

    limits on various elements. If these limits

    are exceeded during parsing, then parsing

    fails with an error.

\n

    The following declaration meets the parser's

    handler requirements:

    @code

    @code

    struct handler

    struct handler

    {

    {

        /// The maximum number of elements allowed in an array

        /// The maximum number of elements allowed in an array

        static constexpr std::size_t max_array_size = -1;

        static constexpr std::size_t max_array_size = -1;

        /// The maximum number of elements allowed in an object

        /// The maximum number of elements allowed in an object

        static constexpr std::size_t max_object_size = -1;

        static constexpr std::size_t max_object_size = -1;

        /// The maximum number of characters allowed in a string

        /// The maximum number of characters allowed in a string

        static constexpr std::size_t max_string_size = -1;

        static constexpr std::size_t max_string_size = -1;

        /// The maximum number of characters allowed in a key

        /// The maximum number of characters allowed in a key

        static constexpr std::size_t max_key_size = -1;

        static constexpr std::size_t max_key_size = -1;

        /// Called once when the JSON parsing begins.

        /// Called once when the JSON parsing begins.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_document_begin( error_code& ec );

        bool on_document_begin( error_code& ec );

        /// Called when the JSON parsing is done.

        /// Called when the JSON parsing is done.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_document_end( error_code& ec );

        bool on_document_end( error_code& ec );

        /// Called when the beginning of an array is encountered.

        /// Called when the beginning of an array is encountered.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_array_begin( error_code& ec );

        bool on_array_begin( error_code& ec );

        /// Called when the end of the current array is encountered.

        /// Called when the end of the current array is encountered.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param n The number of elements in the array.

        /// @param n The number of elements in the array.

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_array_end( std::size_t n, error_code& ec );

        bool on_array_end( std::size_t n, error_code& ec );

        /// Called when the beginning of an object is encountered.

        /// Called when the beginning of an object is encountered.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_object_begin( error_code& ec );

        bool on_object_begin( error_code& ec );

        /// Called when the end of the current object is encountered.

        /// Called when the end of the current object is encountered.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param n The number of elements in the object.

        /// @param n The number of elements in the object.

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_object_end( std::size_t n, error_code& ec );

        bool on_object_end( std::size_t n, error_code& ec );

        /// Called with characters corresponding to part of the current string.

        /// Called with characters corresponding to part of the current string.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param s The partial characters

        /// @param s The partial characters

        /// @param n The total size of the string thus far

        /// @param n The total size of the string thus far

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_string_part( string_view s, std::size_t n, error_code& ec );

        bool on_string_part( string_view s, std::size_t n, error_code& ec );

        /// Called with the last characters corresponding to the current string.

        /// Called with the last characters corresponding to the current string.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param s The remaining characters

        /// @param s The remaining characters

        /// @param n The total size of the string

        /// @param n The total size of the string

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_string( string_view s, std::size_t n, error_code& ec );

        bool on_string( string_view s, std::size_t n, error_code& ec );

        /// Called with characters corresponding to part of the current key.

        /// Called with characters corresponding to part of the current key.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param s The partial characters

        /// @param s The partial characters

        /// @param n The total size of the key thus far

        /// @param n The total size of the key thus far

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_key_part( string_view s, std::size_t n, error_code& ec );

        bool on_key_part( string_view s, std::size_t n, error_code& ec );

        /// Called with the last characters corresponding to the current key.

        /// Called with the last characters corresponding to the current key.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param s The remaining characters

        /// @param s The remaining characters

        /// @param n The total size of the key

        /// @param n The total size of the key

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_key( string_view s, std::size_t n, error_code& ec );

        bool on_key( string_view s, std::size_t n, error_code& ec );

        /// Called with the characters corresponding to part of the current number.

        /// Called with the characters corresponding to part of the current number.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param s The partial characters

        /// @param s The partial characters

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_number_part( string_view s, error_code& ec );

        bool on_number_part( string_view s, error_code& ec );

        /// Called when a signed integer is parsed.

        /// Called when a signed integer is parsed.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param i The value

        /// @param i The value

        /// @param s The remaining characters

        /// @param s The remaining characters

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_int64( int64_t i, string_view s, error_code& ec );

        bool on_int64( int64_t i, string_view s, error_code& ec );

        /// Called when an unsigend integer is parsed.

        /// Called when an unsigend integer is parsed.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param u The value

        /// @param u The value

        /// @param s The remaining characters

        /// @param s The remaining characters

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_uint64( uint64_t u, string_view s, error_code& ec );

        bool on_uint64( uint64_t u, string_view s, error_code& ec );

        /// Called when a double is parsed.

        /// Called when a double is parsed.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param d The value

        /// @param d The value

        /// @param s The remaining characters

        /// @param s The remaining characters

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_double( double d, string_view s, error_code& ec );

        bool on_double( double d, string_view s, error_code& ec );

        /// Called when a boolean is parsed.

        /// Called when a boolean is parsed.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param b The value

        /// @param b The value

        /// @param s The remaining characters

        /// @param s The remaining characters

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_bool( bool b, error_code& ec );

        bool on_bool( bool b, error_code& ec );

        /// Called when a null is parsed.

        /// Called when a null is parsed.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_null( error_code& ec );

        bool on_null( error_code& ec );

        /// Called with characters corresponding to part of the current comment.

        /// Called with characters corresponding to part of the current comment.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param s The partial characters.

        /// @param s The partial characters.

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_comment_part( string_view s, error_code& ec );

        bool on_comment_part( string_view s, error_code& ec );

        /// Called with the last characters corresponding to the current comment.

        /// Called with the last characters corresponding to the current comment.

        ///

        ///

        /// @return `true` on success.

        /// @return `true` on success.

        /// @param s The remaining characters

        /// @param s The remaining characters

        /// @param ec Set to the error, if any occurred.

        /// @param ec Set to the error, if any occurred.

        ///

        ///

        bool on_comment( string_view s, error_code& ec );

        bool on_comment( string_view s, error_code& ec );

    };

    };

    @endcode

    @endcode

    @see

    @see

        @ref parse,

        @ref parse,

        @ref stream_parser,

        @ref stream_parser,

        \<\<examples_validate, validating parser example\>\>.

        [Validating parser example](../../doc/html/json/examples.html#json.examples.validate).

    @headerfile <boost/json/basic_parser.hpp>

*/

*/

template<class Handler>

template<class Handler>

class basic_parser

class basic_parser

{

{

    enum class state : char

    enum class state : char

    {

    {

        doc1,  doc3,

        doc1,  doc3,

        com1,  com2,  com3, com4,

        com1,  com2,  com3, com4,

        lit1,

        lit1,

        str1,  str2,  str3,  str4,

        str1,  str2,  str3,  str4,

        str5,  str6,  str7,  str8,

        str5,  str6,  str7,  str8,

        sur1,  sur2,  sur3,

        sur1,  sur2,  sur3,

        sur4,  sur5,  sur6,

        sur4,  sur5,  sur6,

        obj1,  obj2,  obj3,  obj4,

        obj1,  obj2,  obj3,  obj4,

        obj5,  obj6,  obj7,  obj8,

        obj5,  obj6,  obj7,  obj8,

        obj9,  obj10, obj11,

        obj9,  obj10, obj11,

        arr1,  arr2,  arr3,

        arr1,  arr2,  arr3,

        arr4,  arr5,  arr6,

        arr4,  arr5,  arr6,

        num1,  num2,  num3,  num4,

        num1,  num2,  num3,  num4,

        num5,  num6,  num7,  num8,

        num5,  num6,  num7,  num8,

        exp1,  exp2,  exp3,

        exp1,  exp2,  exp3,

        val1,  val2, val3

        val1,  val2, val3

    };

    };

    struct number

    struct number

    {

    {

        uint64_t mant;

        uint64_t mant;

        int bias;

        int bias;

        int exp;

        int exp;

        bool frac;

        bool frac;

        bool neg;

        bool neg;

    };

    };

    template< bool StackEmpty_, char First_ >

    template< bool StackEmpty_, char First_ >

    struct parse_number_helper;

    struct parse_number_helper;

    // optimization: must come first

    // optimization: must come first

    Handler h_;

    Handler h_;

    number num_;

    number num_;

    system::error_code ec_;

    system::error_code ec_;

    detail::stack st_;

    detail::stack st_;

    detail::utf8_sequence seq_;

    detail::utf8_sequence seq_;

    unsigned u1_;

    unsigned u1_;

    unsigned u2_;

    unsigned u2_;

    bool more_; // false for final buffer

    bool more_; // false for final buffer

    bool done_ = false; // true on complete parse

    bool done_ = false; // true on complete parse

    bool clean_ = true; // write_some exited cleanly

    bool clean_ = true; // write_some exited cleanly

    const char* end_;

    const char* end_;

    detail::sbo_buffer<16 + 16 + 1 + 1> num_buf_;

    detail::sbo_buffer<16 + 16 + 1 + 1> num_buf_;

    parse_options opt_;

    parse_options opt_;

    // how many levels deeper the parser can go

    // how many levels deeper the parser can go

    std::size_t depth_ = opt_.max_depth;

    std::size_t depth_ = opt_.max_depth;

    unsigned char cur_lit_ = 0;

    unsigned char cur_lit_ = 0;

    unsigned char lit_offset_ = 0;

    unsigned char lit_offset_ = 0;

    inline void reserve();

    inline void reserve();

    inline const char* sentinel();

    inline const char* sentinel();

    inline bool incomplete(

    inline bool incomplete(

        const detail::const_stream_wrapper& cs);

        const detail::const_stream_wrapper& cs);

#ifdef __INTEL_COMPILER

#ifdef __INTEL_COMPILER

#pragma warning push

#pragma warning push

#pragma warning disable 2196

#pragma warning disable 2196

#endif

#endif

    BOOST_NOINLINE

    BOOST_NOINLINE

    inline

    inline

    const char*

    const char*

    suspend_or_fail(state st);

    suspend_or_fail(state st);

    BOOST_NOINLINE

    BOOST_NOINLINE

    inline

    inline

    const char*

    const char*

    suspend_or_fail(

    suspend_or_fail(

        state st,

        state st,

        std::size_t n);

        std::size_t n);

    BOOST_NOINLINE

    BOOST_NOINLINE

    inline

    inline

    const char*

    const char*

    fail(const char* p) noexcept;

    fail(const char* p) noexcept;

    BOOST_NOINLINE

    BOOST_NOINLINE

    inline

    inline

    const char*

    const char*

    fail(

    fail(

        const char* p,

        const char* p,

        error ev,

        error ev,

        source_location const* loc) noexcept;

        source_location const* loc) noexcept;

    BOOST_NOINLINE

    BOOST_NOINLINE

    inline

    inline

    const char*

    const char*

    maybe_suspend(

    maybe_suspend(

        const char* p,

        const char* p,

        state st);

        state st);

    BOOST_NOINLINE

    BOOST_NOINLINE

    inline

    inline

    const char*

    const char*

    maybe_suspend(

    maybe_suspend(

        const char* p,

        const char* p,

        state st,

        state st,

        std::size_t n);

        std::size_t n);

    BOOST_NOINLINE

    BOOST_NOINLINE

    inline

    inline

    const char*

    const char*

    maybe_suspend(

    maybe_suspend(

        const char* p,

        const char* p,

        state st,

        state st,

        const number& num);

        const number& num);

    BOOST_NOINLINE

    BOOST_NOINLINE

    inline

    inline

    const char*

    const char*

    suspend(

    suspend(

        const char* p,

        const char* p,

        state st);

        state st);

    BOOST_NOINLINE

    BOOST_NOINLINE

    inline

    inline

    const char*

    const char*

    suspend(

    suspend(

        const char* p,

        const char* p,

        state st,

        state st,

        const number& num);

        const number& num);

#ifdef __INTEL_COMPILER

#ifdef __INTEL_COMPILER

#pragma warning pop

#pragma warning pop

#endif

#endif

    template<bool StackEmpty_/*, bool Terminal_*/>

    template<bool StackEmpty_/*, bool Terminal_*/>

    const char* parse_comment(const char* p,

    const char* parse_comment(const char* p,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        /*std::integral_constant<bool, Terminal_>*/ bool terminal);

        /*std::integral_constant<bool, Terminal_>*/ bool terminal);

    template<bool StackEmpty_>

    template<bool StackEmpty_>

    const char* parse_document(const char* p,

    const char* parse_document(const char* p,

        std::integral_constant<bool, StackEmpty_> stack_empty);

        std::integral_constant<bool, StackEmpty_> stack_empty);

    template<bool StackEmpty_, bool AllowComments_/*,

    template<bool StackEmpty_, bool AllowComments_/*,

        bool AllowTrailing_, bool AllowBadUTF8_*/>

        bool AllowTrailing_, bool AllowBadUTF8_*/>

    const char* parse_value(const char* p,

    const char* parse_value(const char* p,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, AllowComments_> allow_comments,

        std::integral_constant<bool, AllowComments_> allow_comments,

        /*std::integral_constant<bool, AllowTrailing_>*/ bool allow_trailing,

        /*std::integral_constant<bool, AllowTrailing_>*/ bool allow_trailing,

        /*std::integral_constant<bool, AllowBadUTF8_>*/ bool allow_bad_utf8,

        /*std::integral_constant<bool, AllowBadUTF8_>*/ bool allow_bad_utf8,

        bool allow_bad_utf16);

        bool allow_bad_utf16);

    template<bool AllowComments_/*,

    template<bool AllowComments_/*,

        bool AllowTrailing_, bool AllowBadUTF8_*/>

        bool AllowTrailing_, bool AllowBadUTF8_*/>

    const char* resume_value(const char* p,

    const char* resume_value(const char* p,

        std::integral_constant<bool, AllowComments_> allow_comments,

        std::integral_constant<bool, AllowComments_> allow_comments,

        /*std::integral_constant<bool, AllowTrailing_>*/ bool allow_trailing,

        /*std::integral_constant<bool, AllowTrailing_>*/ bool allow_trailing,

        /*std::integral_constant<bool, AllowBadUTF8_>*/ bool allow_bad_utf8,

        /*std::integral_constant<bool, AllowBadUTF8_>*/ bool allow_bad_utf8,

        bool allow_bad_utf16);

        bool allow_bad_utf16);

    template<bool StackEmpty_, bool AllowComments_/*,

    template<bool StackEmpty_, bool AllowComments_/*,

        bool AllowTrailing_, bool AllowBadUTF8_*/>

        bool AllowTrailing_, bool AllowBadUTF8_*/>

    const char* parse_object(const char* p,

    const char* parse_object(const char* p,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, AllowComments_> allow_comments,

        std::integral_constant<bool, AllowComments_> allow_comments,

        /*std::integral_constant<bool, AllowTrailing_>*/ bool allow_trailing,

        /*std::integral_constant<bool, AllowTrailing_>*/ bool allow_trailing,

        /*std::integral_constant<bool, AllowBadUTF8_>*/ bool allow_bad_utf8,

        /*std::integral_constant<bool, AllowBadUTF8_>*/ bool allow_bad_utf8,

        bool allow_bad_utf16);

        bool allow_bad_utf16);

    template<bool StackEmpty_, bool AllowComments_/*,

    template<bool StackEmpty_, bool AllowComments_/*,

        bool AllowTrailing_, bool AllowBadUTF8_*/>

        bool AllowTrailing_, bool AllowBadUTF8_*/>

    const char* parse_array(const char* p,

    const char* parse_array(const char* p,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, AllowComments_> allow_comments,

        std::integral_constant<bool, AllowComments_> allow_comments,

        /*std::integral_constant<bool, AllowTrailing_>*/ bool allow_trailing,

        /*std::integral_constant<bool, AllowTrailing_>*/ bool allow_trailing,

        /*std::integral_constant<bool, AllowBadUTF8_>*/ bool allow_bad_utf8,

        /*std::integral_constant<bool, AllowBadUTF8_>*/ bool allow_bad_utf8,

        bool allow_bad_utf16);

        bool allow_bad_utf16);

    template<class Literal>

    template<class Literal>

    const char* parse_literal(const char* p, Literal literal);

    const char* parse_literal(const char* p, Literal literal);

    template<bool StackEmpty_, bool IsKey_>

    template<bool StackEmpty_, bool IsKey_>

    const char* parse_string(const char* p,

    const char* parse_string(const char* p,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, IsKey_> is_key,

        std::integral_constant<bool, IsKey_> is_key,

        bool allow_bad_utf8,

        bool allow_bad_utf8,

        bool allow_bad_utf16);

        bool allow_bad_utf16);

    template<bool StackEmpty_>

    template<bool StackEmpty_>

    const char* parse_escaped(

    const char* parse_escaped(

        const char* p,

        const char* p,

        std::size_t& total,

        std::size_t& total,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        bool is_key,

        bool is_key,

        bool allow_bad_utf16);

        bool allow_bad_utf16);

    template<bool StackEmpty_, char First_, number_precision Numbers_>

    template<bool StackEmpty_, char First_, number_precision Numbers_>

    const char* parse_number(const char* p,

    const char* parse_number(const char* p,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<bool, StackEmpty_> stack_empty,

        std::integral_constant<char, First_> first,

        std::integral_constant<char, First_> first,

        std::integral_constant<number_precision, Numbers_> numbers);

        std::integral_constant<number_precision, Numbers_> numbers);

    // intentionally private

    // intentionally private

    std::size_t

    std::size_t

    {

    {

    }

    }

public:

public:

    /// Copy constructor (deleted)

    basic_parser(

        basic_parser const&) = delete;

    /// Copy assignment (deleted)

    basic_parser& operator=(

        basic_parser const&) = delete;

    /** Destructor.

    /** Destructor.

        All dynamically allocated internal memory is freed.

        All dynamically allocated internal memory is freed.

        @par Effects

        @par Effects

        @code

        @code

        handler().~Handler()

        this->handler().~Handler()

        @endcode

        @endcode

        @par Complexity

        @par Complexity

        Same as `~Handler()`.

        Same as `~Handler()`.

        @par Exception Safety

        @par Exception Safety

        Same as `~Handler()`.

        Same as `~Handler()`.

    */

    */

    /** Constructors.

    /** Constructor.

        Overload **(1)** constructs the parser with the specified options, with

        any additional arguments forwarded to the handler's constructor.

        `basic_parser` is not copyable or movable, so the copy constructor is

        This function constructs the parser with

        deleted.

        the specified options, with any additional

        arguments forwarded to the handler's constructor.

        @par Complexity

        @par Complexity

        Same as `Handler( std::forward< Args >( args )... )`.

        Same as `Handler( std::forward< Args >( args )... )`.

        @par Exception Safety

        @par Exception Safety

        Same as `Handler( std::forward< Args >( args )... )`.

        Same as `Handler( std::forward< Args >( args )... )`.

        @param opt Configuration settings for the parser. If this structure is

        @param opt Configuration settings for the parser.

               default constructed, the parser will accept only standard JSON.

        If this structure is default constructed, the

        @param args Optional additional arguments forwarded to the handler's

        parser will accept only standard JSON.

               constructor.

        @{

        @param args Optional additional arguments

        forwarded to the handler's constructor.

    */

    */

    template<class... Args>

    template<class... Args>

    explicit

    explicit

    basic_parser(

    basic_parser(

        parse_options const& opt,

        parse_options const& opt,

        Args&&... args);

        Args&&... args);

    /// Overload

    basic_parser(

        basic_parser const&) = delete;

    /// @}

    /** Assignment.

        This type cannot be copied or moved. The copy assignment is deleted.