basics.hpp

Go to the documentation of this file.

/*
 * RESTinio
 */

 
#pragma once
 
#include <restinio/impl/string_caseless_compare.hpp>
 
#include <restinio/helpers/easy_parser.hpp>
 
#include <restinio/expected.hpp>
 
#include <algorithm>
 
namespace restinio
{
 
namespace http_field_parsers
{
 
using namespace restinio::easy_parser;
 
namespace meta = restinio::utils::metaprogramming;
 
namespace qvalue_details
{

using underlying_uint_t = std::uint_least16_t;

constexpr underlying_uint_t maximum = 1000u;
constexpr underlying_uint_t zero = 0u;
 
// A part of workaround for problem with static constexpr members
// detected after release of v.0.6.1.
enum class extremum_min_t { v };
enum class extremum_max_t { v };

class trusted
{
    const underlying_uint_t m_value;
 
public :
    explicit constexpr
    trusted( underlying_uint_t value ) noexcept : m_value{ value } {}
 
    constexpr auto get() const noexcept { return m_value; }
};

class untrusted
{
    underlying_uint_t m_value;
 
public :
    explicit
    untrusted( underlying_uint_t value ) : m_value{ value }
    {
        if( m_value > maximum )
            throw exception_t( "invalid value for "
                    "http_field_parser::rfc::qvalue_t" );
    }
 
    auto get() const noexcept { return m_value; }
};
 
} /* namespace qvalue_details */
 
//
// qvalue_t
//
class qvalue_t
{
public :
    using underlying_uint_t = qvalue_details::underlying_uint_t;
    using trusted = qvalue_details::trusted;
    using untrusted = qvalue_details::untrusted;

    static constexpr qvalue_details::extremum_max_t maximum =
            qvalue_details::extremum_max_t::v;
    static constexpr qvalue_details::extremum_min_t zero =
            qvalue_details::extremum_min_t::v;
 
private :
    // Note: with the terminal 0-symbol.
    using underlying_char_array_t = std::array<char, 6>;
 
    underlying_uint_t m_value{};
 
    underlying_char_array_t
    make_char_array() const noexcept
    {
        underlying_char_array_t result;
        if( qvalue_details::maximum == m_value )
        {
            static constexpr char fixed_value[]{ "1.000" };
            std::copy( std::begin(fixed_value), std::end(fixed_value),
                    std::begin(result) );
        }
        else
        {
            result[0] = '0';
            result[1] = '.';
 
            result[2] = '0' + static_cast<char>(m_value / 100u);
            const auto d2 = m_value % 100u;
            result[3] = '0' + static_cast<char>(d2 / 10u);
            const auto d3 = d2 % 10u;
            result[4] = '0' + static_cast<char>(d3);
            result[5] = 0;
        }
 
        return result;
    }
 
public :
 
    constexpr qvalue_t() = default;
 
    qvalue_t( untrusted val ) noexcept
        :   m_value{ val.get() }
    {}
 
    constexpr qvalue_t( trusted val ) noexcept
        :   m_value{ val.get() }
    {}
 
    constexpr qvalue_t( qvalue_details::extremum_min_t ) noexcept
        :   m_value{ qvalue_details::zero }
    {}
 
    constexpr qvalue_t( qvalue_details::extremum_max_t ) noexcept
        :   m_value{ qvalue_details::maximum }
    {}
 
    constexpr auto as_uint() const noexcept { return m_value; }
 
    auto as_string() const
    {
        return std::string{ &make_char_array().front() };
    }
 
    friend std::ostream &
    operator<<( std::ostream & to, const qvalue_t & what )
    {
        return (to << &what.make_char_array().front());
    }
};
 
[[nodiscard]]
inline bool
operator==( const qvalue_t & a, const qvalue_t & b ) noexcept
{
    return a.as_uint() == b.as_uint();
}
 
[[nodiscard]]
inline bool
operator!=( const qvalue_t & a, const qvalue_t & b ) noexcept
{
    return a.as_uint() != b.as_uint();
}
 
[[nodiscard]]
inline bool
operator<( const qvalue_t & a, const qvalue_t & b ) noexcept
{
    return a.as_uint() < b.as_uint();
}
 
[[nodiscard]]
inline bool
operator<=( const qvalue_t & a, const qvalue_t & b ) noexcept
{
    return a.as_uint() <= b.as_uint();
}
 
namespace impl
{
 
using namespace restinio::easy_parser::impl;
 
//
// is_alpha
//
[[nodiscard]]
inline constexpr bool
is_alpha( const char ch ) noexcept
{
    return (ch >= '\x41' && ch <= '\x5A') ||
            (ch >= '\x61' && ch <= '\x7A');
}
 
//
// is_alpha_predicate_t
//
struct is_alpha_predicate_t
{
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return is_alpha(actual);
    }
};
 
//
// is_alphanum_predicate_t
//
struct is_alphanum_predicate_t
{
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return is_alpha(actual) || is_digit(actual);
    }
};
 
//
// is_vchar
//
[[nodiscard]]
inline constexpr bool
is_vchar( const char ch ) noexcept
{
    return (ch >= '\x21' && ch <= '\x7E');
}
 
//
// is_vchar_predicate_t
//
struct is_vchar_predicate_t
{
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return is_vchar(actual);
    }
};
 
//
// is_obs_text
//
[[nodiscard]]
inline constexpr bool
is_obs_text( const char ch ) noexcept
{
    constexpr unsigned short left = 0x80u;
    constexpr unsigned short right = 0xFFu;
 
    const unsigned short t = static_cast<unsigned short>(
            static_cast<unsigned char>(ch));
 
    return (t >= left && t <= right);
}
 
//
// is_qdtext
//
[[nodiscard]]
inline constexpr bool
is_qdtext( const char ch ) noexcept
{
    return ch == SP ||
            ch == HTAB ||
            ch == '!' ||
            (ch >= '\x23' && ch <= '\x5B') ||
            (ch >= '\x5D' && ch <= '\x7E') ||
            is_obs_text( ch );
}
 
//
// is_ctext
//
[[nodiscard]]
inline constexpr bool
is_ctext( const char ch ) noexcept
{
    return ch == SP ||
            ch == HTAB ||
            (ch >= '\x21' && ch <= '\x27') ||
            (ch >= '\x2A' && ch <= '\x5B') ||
            (ch >= '\x5D' && ch <= '\x7E') ||
            is_obs_text( ch );
}
 
//
// is_ctext_predicate_t
//
struct is_ctext_predicate_t
{
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return is_ctext(actual);
    }
};
 
//
// is_token_char_predicate_t
//
struct is_token_char_predicate_t
{
    [[nodiscard]]
    static constexpr bool
    is_token_char( const char ch ) noexcept
    {
        return is_alpha(ch) || is_digit(ch) ||
                ch == '!' ||
                ch == '#' ||
                ch == '$' ||
                ch == '%' ||
                ch == '&' ||
                ch == '\'' ||
                ch == '*' ||
                ch == '+' ||
                ch == '-' ||
                ch == '.' ||
                ch == '^' ||
                ch == '_' ||
                ch == '`' ||
                ch == '|' ||
                ch == '~';
    }
 
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return is_token_char(actual);
    }
};
 
//
// ows_producer_t
//
class ows_producer_t : public producer_tag< std::optional<char> >
{
public :
    [[nodiscard]]
    expected_t< result_type, parse_error_t >
    try_parse(
        source_t & from ) const noexcept
    {
        std::size_t extracted_spaces{};
        character_t ch;
        for( ch = from.getch();
            !ch.m_eof && is_space(ch.m_ch);
            ch = from.getch() )
        {
            ++extracted_spaces;
        }
 
        if( !ch.m_eof )
            // The first non-space char should be returned back.
            from.putback();
 
        if( extracted_spaces > 0u )
            return result_type{ ' ' };
 
        return result_type{ std::nullopt };
    }
};
 
//
// token_producer_t
//
class token_producer_t : public producer_tag< std::string >
{
    [[nodiscard]]
    static std::optional< parse_error_t >
    try_parse_value( source_t & from, std::string & accumulator )
    {
        error_reason_t reason = error_reason_t::pattern_not_found;
 
        do
        {
            const auto ch = from.getch();
            if( ch.m_eof )
            {
                reason = error_reason_t::unexpected_eof;
                break;
            }
 
            if( !is_token_char(ch.m_ch) )
            {
                from.putback();
                reason = error_reason_t::unexpected_character;
                break;
            }
 
            accumulator += ch.m_ch;
        }
        while( true );
 
        if( accumulator.empty() )
        {
            return parse_error_t{ from.current_position(), reason };
        }
 
        return std::nullopt;
    }
 
    [[nodiscard]]
    static constexpr bool
    is_token_char( const char ch ) noexcept
    {
        return is_token_char_predicate_t::is_token_char( ch );
    }
 
public :
    [[nodiscard]]
    expected_t< result_type, parse_error_t >
    try_parse( source_t & from ) const
    {
        std::string value;
        const auto try_result = try_parse_value( from, value );
        if( !try_result )
            return { std::move(value) };
        else
            return make_unexpected( *try_result );
    }
};
 
//
// quoted_string_producer_t
//
class quoted_string_producer_t : public producer_tag< std::string >
{
    [[nodiscard]]
    static std::optional< parse_error_t >
    try_parse_value( source_t & from, std::string & accumulator )
    {
        error_reason_t reason = error_reason_t::pattern_not_found;
 
        bool second_quote_extracted{ false };
        do
        {
            const auto ch = from.getch();
            if( ch.m_eof )
            {
                reason = error_reason_t::unexpected_eof;
                break;
            }
 
            if( '"' == ch.m_ch )
                second_quote_extracted = true;
            else if( '\\' == ch.m_ch )
            {
                const auto next = from.getch();
                if( next.m_eof )
                {
                    reason = error_reason_t::unexpected_eof;
                    break;
                }
                else if( SP == next.m_ch || HTAB == next.m_ch ||
                        is_vchar( next.m_ch ) ||
                        is_obs_text( next.m_ch ) )
                {
                    accumulator += next.m_ch;
                }
                else
                {
                    reason = error_reason_t::unexpected_character;
                    from.putback();
                    break;
                }
            }
            else if( is_qdtext( ch.m_ch ) )
                accumulator += ch.m_ch;
            else
            {
                reason = error_reason_t::unexpected_character;
                from.putback();
                break;
            }
        }
        while( !second_quote_extracted );
 
        if( !second_quote_extracted )
            return parse_error_t{ from.current_position(), reason };
        else
            return std::nullopt;
    }
 
public :
    [[nodiscard]]
    expected_t< result_type, parse_error_t >
    try_parse( source_t & from ) const
    {
        source_t::content_consumer_t consumer{ from };
 
        const auto ch = from.getch();
        if( !ch.m_eof )
        {
            if( '"' == ch.m_ch )
            {
                std::string value;
                const auto try_result = try_parse_value( from, value );
                if( !try_result )
                {
                    consumer.commit();
                    return { std::move(value) };
                }
                else
                    return make_unexpected( *try_result );
            }
            else
            {
                return make_unexpected( parse_error_t{
                        consumer.started_at(),
                        error_reason_t::unexpected_character
                } );
            }
        }
        else
            return make_unexpected( parse_error_t{
                    consumer.started_at(),
                    error_reason_t::unexpected_eof
            } );
    }
};
 
//
// quoted_pair_producer_t
//
class quoted_pair_producer_t : public producer_tag< char >
{
public :
    [[nodiscard]]
    expected_t< result_type, parse_error_t >
    try_parse( source_t & from ) const
    {
        source_t::content_consumer_t consumer{ from };
 
        error_reason_t reason = error_reason_t::unexpected_eof;
 
        const auto ch = from.getch();
        if( !ch.m_eof )
        {
            if( '\\' == ch.m_ch )
            {
                const auto next = from.getch();
                if( !next.m_eof )
                {
                    if( SP == next.m_ch || HTAB == next.m_ch ||
                            is_vchar( next.m_ch ) ||
                            is_obs_text( next.m_ch ) )
                    {
                        consumer.commit();
                        return next.m_ch;
                    }
 
                    reason = error_reason_t::unexpected_character;
                }
            }
            else
                reason = error_reason_t::unexpected_character;
        }
 
        return make_unexpected( parse_error_t{
                from.current_position(),
                reason
        } );
    }
};
 
//
// comment_producer_t
//
class comment_producer_t : public producer_tag< std::string >
{
public :
    [[nodiscard]]
    expected_t< result_type, parse_error_t >
    try_parse( source_t & from ) const; // NOTE: implementation below.
};
 
} /* namespace impl */
 
//
// alpha_symbol_producer
//
[[nodiscard]]
inline auto
alpha_symbol_p()
{
    return restinio::easy_parser::impl::symbol_producer_template_t<
            impl::is_alpha_predicate_t >{};
}
 
//
// alphanum_symbol_producer
//
[[nodiscard]]
inline auto
alphanum_symbol_p()
{
    return restinio::easy_parser::impl::symbol_producer_template_t<
            impl::is_alphanum_predicate_t >{};
}
 
//
// vchar_symbol_producer
//
[[nodiscard]]
inline auto
vchar_symbol_p()
{
    return restinio::easy_parser::impl::symbol_producer_template_t<
            impl::is_vchar_predicate_t >{};
}
 
//
// ctext_symbol_producer
//
[[nodiscard]]
inline auto
ctext_symbol_p()
{
    return restinio::easy_parser::impl::symbol_producer_template_t<
            impl::is_ctext_predicate_t >{};
}
 
//
// comment_producer
//
[[nodiscard]]
inline auto
comment_p()
{
    return impl::comment_producer_t{};
}
 
//
// ows_producer
//
[[nodiscard]]
inline auto
ows_p() noexcept { return impl::ows_producer_t{}; }
 
//
// ows
//
[[nodiscard]]
inline auto
ows() noexcept { return ows_p() >> skip(); }
 
//
// token_symbol_producer
//
[[nodiscard]]
inline auto
token_symbol_p() noexcept
{
    return restinio::easy_parser::impl::symbol_producer_template_t<
            impl::is_token_char_predicate_t >{};
}
 
//
// token_producer
//
[[nodiscard]]
inline auto
token_p() noexcept { return impl::token_producer_t{}; }
 
//
// quoted_string_producer
//
[[nodiscard]]
inline auto
quoted_string_p() noexcept
{
    return impl::quoted_string_producer_t{};
}
 
//
// quoted_pair_producer
//
[[nodiscard]]
inline auto
quoted_pair_p() noexcept
{
    return impl::quoted_pair_producer_t{};
}
 
//
// expected_token_p
//
[[nodiscard]]
inline auto
expected_token_p( string_view_t token )
{
    return produce< bool >(
            exact_p( token ) >> as_result(),
            not_clause( token_symbol_p() >> skip() ) );
}
 
//
// expected_caseless_token_p
//
[[nodiscard]]
inline auto
expected_caseless_token_p( string_view_t token )
{
    return produce< bool >(
            caseless_exact_p( token ) >> as_result(),
            not_clause( token_symbol_p() >> skip() ) );
}
 
namespace impl
{
 
//
// comment_producer_t implementation
//
[[nodiscard]]
inline expected_t< comment_producer_t::result_type, parse_error_t >
comment_producer_t::try_parse( source_t & from ) const
{
    return produce< std::string >(
            sequence(
                symbol('('),
                repeat(0, N,
                    alternatives(
                        ctext_symbol_p() >> to_container(),
                        quoted_pair_p() >> to_container(),
                        comment_p() >> custom_consumer(
                            []( std::string & dest, std::string && what ) {
                                dest += what;
                            } )
                    ) ),
                symbol(')') )
        ).try_parse( from );
}
 
//
// qvalue_producer_t
//
class qvalue_producer_t
    :   public producer_tag< qvalue_t >
{
    // This type has to be used as type parameter for produce().
    struct zero_initialized_unit_t
    {
        qvalue_t::underlying_uint_t m_value{0u};
    };

    class digit_consumer_t : public consumer_tag
    {
        const qvalue_t::underlying_uint_t m_multiplier;
    
    public :
        constexpr digit_consumer_t( qvalue_t::underlying_uint_t m )
            :   m_multiplier{ m }
        {}
    
        void
        consume( zero_initialized_unit_t & dest, char && digit )
        {
            dest.m_value += m_multiplier *
                    static_cast< qvalue_t::underlying_uint_t >(digit - '0');
        }
    };
 
public :
    [[nodiscard]]
    expected_t< result_type, parse_error_t >
    try_parse( source_t & from ) const noexcept
    {
        const auto parse_result = produce< zero_initialized_unit_t >(
                alternatives(
                    sequence(
                        symbol('0'),
                        maybe(
                            symbol('.'),
                            maybe( digit_p() >> digit_consumer_t{100},
                                maybe( digit_p() >> digit_consumer_t{10},
                                    maybe( digit_p() >> digit_consumer_t{1} )
                                )
                            )
                        )
                    ),
                    sequence(
                        symbol_p('1') >> digit_consumer_t{1000},
                        maybe(
                            symbol('.'),
                            maybe( symbol('0'),
                                maybe( symbol('0'),
                                    maybe( symbol('0') )
                                )
                            )
                        )
                    )
                )
            ).try_parse( from );
 
        if( parse_result )
            return qvalue_t{ qvalue_t::trusted{ parse_result->m_value } };
        else
            return make_unexpected( parse_result.error() );
    }
};
 
} /* namespace impl */
 
//
// qvalue_producer
//
[[nodiscard]]
inline auto
qvalue_p() noexcept
{
    return impl::qvalue_producer_t{};
}
 
//
// weight_producer
//
[[nodiscard]]
inline auto
weight_p() noexcept
{
    return produce< qvalue_t >(
            ows(),
            symbol(';'),
            ows(),
            caseless_symbol('q'),
            symbol('='),
            qvalue_p() >> as_result()
        );
}
 
namespace impl
{
 
//
// non_empty_comma_separated_list_producer_t
//
template<
    typename Container,
    typename Element_Producer >
class non_empty_comma_separated_list_producer_t
    : public producer_tag< Container >
{
    static_assert( impl::is_producer_v<Element_Producer>,
            "Element_Producer should be a value producer type" );
 
    Element_Producer m_element;
 
public :
    using typename producer_tag< Container >::result_type;
 
    non_empty_comma_separated_list_producer_t(
        Element_Producer && element )
        :   m_element{ std::move(element) }
    {}
 
    [[nodiscard]]
    expected_t< result_type, parse_error_t >
    try_parse( source_t & from )
    {
        Container tmp_value;
 
        const auto appender = to_container();
 
        const auto process_result = sequence(
                repeat( 0, N, symbol(','), ows() ),
                m_element >> appender,  
                repeat( 0, N,
                    ows(), symbol(','),
                    maybe( ows(), m_element >> appender )
                )
            ).try_process( from, tmp_value );
 
        if( !process_result )
            return { std::move(tmp_value) };
        else
            return make_unexpected( *process_result );
    }
};
 
//
// maybe_empty_comma_separated_list_producer_t
//
template<
    typename Container,
    typename Element_Producer >
class maybe_empty_comma_separated_list_producer_t
    :   public producer_tag< Container >
{
    static_assert( impl::is_producer_v<Element_Producer>,
            "Element_Producer should be a value producer type" );
 
    Element_Producer m_element;
 
public :
    using typename producer_tag< Container >::result_type;
 
    maybe_empty_comma_separated_list_producer_t(
        Element_Producer && element )
        :   m_element{ std::move(element) }
    {}
 
    [[nodiscard]]
    expected_t< result_type, parse_error_t >
    try_parse( source_t & from )
    {
        Container tmp_value;
 
        const auto appender = to_container();
 
        const auto process_result = maybe(
                alternatives( symbol(','), m_element >> appender ),
                repeat( 0, N,
                    ows(), symbol(','),
                    maybe( ows(), m_element >> appender )
                )
            ).try_process( from, tmp_value );
 
        if( !process_result )
            return { std::move(tmp_value) };
        else
            return make_unexpected( *process_result );
    }
};
 
} /* namespace impl */
 
//
// non_empty_comma_separated_list_producer
//
template<
    typename Container,
    typename Element_Producer >
[[nodiscard]]
auto
non_empty_comma_separated_list_p( Element_Producer element )
{
    static_assert( impl::is_producer_v<Element_Producer>,
            "Element_Producer should be a value producer type" );
 
    return impl::non_empty_comma_separated_list_producer_t<
            Container,
            Element_Producer >{ std::move(element) };
}
 
//
// maybe_empty_comma_separated_list_producer
//
template<
    typename Container,
    typename Element_Producer >
[[nodiscard]]
auto
maybe_empty_comma_separated_list_p( Element_Producer element )
{
    static_assert( impl::is_producer_v<Element_Producer>,
            "Element_Producer should be a value producer type" );
 
    return impl::maybe_empty_comma_separated_list_producer_t<
            Container,
            Element_Producer >{ std::move(element) };
}
 
//
// parameter_with_mandatory_value_t
//
using parameter_with_mandatory_value_t = std::pair< std::string, std::string >;
 
//
// parameter_with_mandatory_value_container_t
//
using parameter_with_mandatory_value_container_t =
        std::vector< parameter_with_mandatory_value_t >;
 
//
// not_found_t
//
struct not_found_t {};
 
//
// find_first
//
[[nodiscard]]
inline expected_t< string_view_t, not_found_t >
find_first(
    const parameter_with_mandatory_value_container_t & where,
    string_view_t what )
{
    const auto it = std::find_if( where.begin(), where.end(),
            [&what]( const auto & pair ) {
                return restinio::impl::is_equal_caseless( pair.first, what );
            } );
    if( it != where.end() )
        return string_view_t{ it->second };
    else
        return make_unexpected( not_found_t{} );
}
 
namespace impl
{
 
namespace params_with_value_producer_details
{
 
//
// make_parser
//
[[nodiscard]]
inline auto
make_parser()
{
    return produce< parameter_with_mandatory_value_container_t >(
            repeat( 0, N,
                produce< parameter_with_mandatory_value_t >(
                    ows(),
                    symbol(';'),
                    ows(),
                    token_p() >> to_lower()
                            >> &parameter_with_mandatory_value_t::first,
                    symbol('='),
                    alternatives(
                        token_p()
                                >> &parameter_with_mandatory_value_t::second,
                        quoted_string_p()
                                >> &parameter_with_mandatory_value_t::second
                    )
                ) >> to_container()
            )
        );
}
 
} /* namespace params_with_value_producer_details */
 
//
// params_with_value_producer_t
//
class params_with_value_producer_t
    :   public producer_tag< parameter_with_mandatory_value_container_t >
{
    using actual_producer_t = std::decay_t<
            decltype(params_with_value_producer_details::make_parser()) >;
 
    actual_producer_t m_producer{
            params_with_value_producer_details::make_parser() };
 
public :
    params_with_value_producer_t() = default;
 
    [[nodiscard]]
    auto
    try_parse( source_t & from )
    {
        return m_producer.try_parse( from );
    }
};
 
} /* namespace impl */
 
//
// params_with_value_producer
//
[[nodiscard]]
inline impl::params_with_value_producer_t
params_with_value_p() { return {}; }
 
//
// parameter_with_optional_value_t
//
using parameter_with_optional_value_t =
        std::pair< std::string, std::optional<std::string> >;
 
//
// parameter_with_optional_value_container_t
//
using parameter_with_optional_value_container_t =
        std::vector< parameter_with_optional_value_t >;
 
//
// find_first
//
[[nodiscard]]
inline expected_t< std::optional<string_view_t>, not_found_t >
find_first(
    const parameter_with_optional_value_container_t & where,
    string_view_t what )
{
    const auto it = std::find_if( where.begin(), where.end(),
            [&what]( const auto & pair ) {
                return restinio::impl::is_equal_caseless( pair.first, what );
            } );
    if( it != where.end() )
    {
        const auto opt = it->second;
        if( opt )
            return string_view_t{ *opt };
        else
            return std::optional< string_view_t >{ std::nullopt };
    }
    else
        return make_unexpected( not_found_t{} );
}
 
namespace impl
{
 
namespace params_with_opt_value_producer_details
{
 
//
// make_parser
//
[[nodiscard]]
inline auto
make_parser()
{
    return produce< parameter_with_optional_value_container_t >(
            repeat( 0, N,
                produce< parameter_with_optional_value_t >(
                    ows(),
                    symbol(';'),
                    ows(),
                    token_p() >> to_lower()
                            >> &parameter_with_optional_value_t::first,
                    maybe(
                        symbol('='),
                        alternatives(
                            token_p()
                                    >> &parameter_with_optional_value_t::second,
                            quoted_string_p()
                                    >> &parameter_with_optional_value_t::second
                        )
                    )
                ) >> to_container()
            )
        );
}
 
} /* namespace params_with_opt_value_producer_details */
 
//
// params_with_opt_value_producer_t
//
class params_with_opt_value_producer_t
    :   public producer_tag< parameter_with_optional_value_container_t >
{
    using actual_producer_t = std::decay_t<
            decltype(params_with_opt_value_producer_details::make_parser()) >;
 
    actual_producer_t m_producer{
            params_with_opt_value_producer_details::make_parser() };
 
public :
    params_with_opt_value_producer_t() = default;
 
    [[nodiscard]]
    auto
    try_parse( source_t & from )
    {
        return m_producer.try_parse( from );
    }
};
 
} /* namespace impl */
 
//
// params_with_opt_value_producer
//
[[nodiscard]]
inline impl::params_with_opt_value_producer_t
params_with_opt_value_p() { return {}; }
 
} /* namespace http_field_parser */
 
} /* namespace restinio */