easy_parser.hpp

Go to the documentation of this file.

/*
 * RESTinio
 */

 
#pragma once
 
#include <restinio/impl/to_lower_lut.hpp>
#include <restinio/impl/overflow_controlled_integer_accumulator.hpp>
 
#include <restinio/utils/tuple_algorithms.hpp>
#include <restinio/utils/metaprogramming.hpp>
 
#include <restinio/string_view.hpp>
#include <restinio/compiler_features.hpp>
 
#include <restinio/exception.hpp>
#include <restinio/expected.hpp>
 
#include <algorithm>
#include <array>
#include <cstring>
#include <iostream>
#include <limits>
#include <map>
#include <optional>
#include <vector>
 
namespace restinio
{
 
namespace easy_parser
{
 
namespace meta = restinio::utils::metaprogramming;
 
//
// error_reason_t
//
enum class error_reason_t
{
    unexpected_character,
    unexpected_eof,
    no_appropriate_alternative,
    pattern_not_found,
    unconsumed_input,

    illegal_value_found,

    force_only_this_alternative_failed
};
 
//
// parse_error_t
//
class parse_error_t
{
    std::size_t m_position;
    error_reason_t m_reason;
 
public:
    parse_error_t(
        std::size_t position,
        error_reason_t reason ) noexcept
        :   m_position{ position }
        ,   m_reason{ reason }
    {}

    [[nodiscard]]
    std::size_t
    position() const noexcept { return m_position; }

    [[nodiscard]]
    error_reason_t
    reason() const noexcept { return m_reason; }
};
 
//
// nothing_t
//
struct nothing_t {};
 
//
// result_value_wrapper
//
template< typename T >
struct result_value_wrapper
{
    using result_type = T;
    using wrapped_type = result_type;
 
    static void
    as_result( wrapped_type & to, result_type && what )
    {
        to = std::move(what);
    }
 
    [[nodiscard]]
    static result_type &&
    unwrap_value( wrapped_type & v )
    {
        return std::move(v);
    }
};
 
//
// result_wrapper_for
//
template< typename T >
struct result_wrapper_for
{
    using type = result_value_wrapper< T >;
};
 
template< typename T >
using result_wrapper_for_t = typename result_wrapper_for<T>::type;
 
template< typename T, typename... Args >
struct result_value_wrapper< std::vector< T, Args... > >
{
    using result_type = std::vector< T, Args... >;
    using value_type = typename result_type::value_type;
    using wrapped_type = result_type;
 
    static void
    as_result( wrapped_type & to, result_type && what )
    {
        to = std::move(what);
    }
 
    static void
    to_container( wrapped_type & to, value_type && what )
    {
        to.push_back( std::move(what) );
    }
 
    [[nodiscard]]
    static result_type &&
    unwrap_value( wrapped_type & v )
    {
        return std::move(v);
    }
};
 
namespace impl
{
 
//
// std_array_wrapper
//
template< typename T, std::size_t S >
struct std_array_wrapper
{
    std::array< T, S > m_array;
    std::size_t m_index{ 0u };
};
 
} /* namespace impl */
 
template< typename T, std::size_t S >
struct result_value_wrapper< std::array< T, S > >
{
    using result_type = std::array< T, S >;
    using value_type = typename result_type::value_type;
    using wrapped_type = impl::std_array_wrapper< T, S >;
 
    static void
    as_result( wrapped_type & to, result_type && what )
    {
        to.m_array = std::move(what);
        to.m_index = 0u;
    }
 
    static void
    to_container( wrapped_type & to, value_type && what )
    {
        if( to.m_index >= S )
            throw exception_t(
                    "index in the result std::array is out of range, "
                    "index=" + std::to_string(to.m_index) +
                    ", size={}" + std::to_string(S) );
 
        to.m_array[ to.m_index ] = std::move(what);
        ++to.m_index;
    }
 
    [[nodiscard]]
    static result_type &&
    unwrap_value( wrapped_type & v )
    {
        return std::move(v.m_array);
    }
};

template< typename T, std::size_t S >
struct result_wrapper_for< impl::std_array_wrapper<T, S> >
{
    using type = result_value_wrapper< std::array< T, S > >;
};
 
template< typename Char, typename... Args >
struct result_value_wrapper< std::basic_string< Char, Args... > >
{
    using result_type = std::basic_string< Char, Args... >;
    using value_type = Char;
    using wrapped_type = result_type;
 
    static void
    as_result( wrapped_type & to, result_type && what )
    {
        to = std::move(what);
    }
 
    static void
    to_container( wrapped_type & to, value_type && what )
    {
        to.push_back( what );
    }

    static void
    to_container( wrapped_type & to, wrapped_type && what )
    {
        to.append( what );
    }
 
    [[nodiscard]]
    static result_type &&
    unwrap_value( wrapped_type & v )
    {
        return std::move(v);
    }
};
 
template< typename K, typename V, typename... Args >
struct result_value_wrapper< std::map< K, V, Args... > >
{
    using result_type = std::map< K, V, Args... >;
    // NOTE: we can't use container_type::value_type here
    // because value_type for std::map is std::pair<const K, V>,
    // not just std::pair<K, V>,
    using value_type = std::pair<K, V>;
    using wrapped_type = result_type;
 
    static void
    as_result( wrapped_type & to, result_type && what )
    {
        to = std::move(what);
    }
 
    static void
    to_container( wrapped_type & to, value_type && what )
    {
        to.emplace( std::move(what) );
    }
 
    [[nodiscard]]
    static result_type &&
    unwrap_value( wrapped_type & v )
    {
        return std::move(v);
    }
};
 
template<>
struct result_value_wrapper< nothing_t >
{
    using result_type = nothing_t;
    using value_type = nothing_t;
    using wrapped_type = result_type;
 
    static void
    as_result( wrapped_type &, result_type && ) noexcept {}
 
    static void
    to_container( wrapped_type &, value_type && ) noexcept {}
 
    [[nodiscard]]
    static result_type &&
    unwrap_value( wrapped_type & v )
    {
        return std::move(v);
    }
};

constexpr std::size_t N = std::numeric_limits<std::size_t>::max();
 
//
// digits_to_consume_t
//
class digits_to_consume_t
{
public:
    using underlying_int_t = std::int_fast8_t;


    underlying_int_t m_min;
    underlying_int_t m_max;
 
public:
    constexpr
    digits_to_consume_t( underlying_int_t total ) noexcept
        :   m_min{ total }
        ,   m_max{ total }
    {}

    constexpr
    digits_to_consume_t(
        underlying_int_t min,
        underlying_int_t max ) noexcept
        :   m_min{ min }
        ,   m_max{ max }
    {}

    [[nodiscard]]
    constexpr auto
    min() const noexcept { return m_min; }

    [[nodiscard]]
    constexpr auto
    max() const noexcept { return m_max; }

    [[nodiscard]]
    constexpr static auto
    unlimited_max() noexcept
    {
        return std::numeric_limits<underlying_int_t>::max();
    }

    [[nodiscard]]
    constexpr static auto
    from_one_to_max() noexcept
    {
        return digits_to_consume_t{ 1, unlimited_max() };
    }
};

[[nodiscard]]
inline constexpr digits_to_consume_t
expected_digits( digits_to_consume_t::underlying_int_t total ) noexcept
{
    return { total };
}

[[nodiscard]]
inline constexpr digits_to_consume_t
expected_digits(
    digits_to_consume_t::underlying_int_t min,
    digits_to_consume_t::underlying_int_t max ) noexcept
{
    return { min, max };
}
 
namespace impl
{
 
//
// character_t
//
struct character_t
{
    bool m_eof;
    char m_ch;
};
 
[[nodiscard]]
inline bool
operator==( const character_t & a, const character_t & b ) noexcept
{
    return (a.m_eof == b.m_eof && a.m_ch == b.m_ch);
}
 
[[nodiscard]]
inline bool
operator!=( const character_t & a, const character_t & b ) noexcept
{
    return (a.m_eof != b.m_eof || a.m_ch != b.m_ch);
}

constexpr char SP = ' ';
constexpr char  HTAB = '\x09';
 
//
// is_space
//
[[nodiscard]]
inline constexpr bool
is_space( const char ch ) noexcept
{
    return ch == SP || ch == HTAB;
}
 
//
// is_space_predicate_t
//
struct is_space_predicate_t
{
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return is_space(actual);
    }
};
 
//
// is_digit
//
[[nodiscard]]
inline constexpr bool
is_digit( const char ch ) noexcept
{
    return (ch >= '0' && ch <= '9');
}
 
//
// is_digit_predicate_t
//
struct is_digit_predicate_t
{
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return is_digit( actual );
    }
};
 
//
// is_hexdigit
//
[[nodiscard]]
inline constexpr bool
is_hexdigit( const char ch ) noexcept
{
    return (ch >= '0' && ch <= '9') ||
            (ch >= 'A' && ch <= 'F') ||
            (ch >= 'a' && ch <= 'f');
}
 
//
// is_hexdigit_predicate_t
//
struct is_hexdigit_predicate_t
{
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return is_hexdigit( actual );
    }
};
 
//
// source_t
//
class source_t
{
    const string_view_t m_data;

    string_view_t::size_type m_index{};
 
public:
    using position_t = string_view_t::size_type;

    explicit source_t( string_view_t data ) noexcept : m_data{ data } {}


    [[nodiscard]]
    character_t
    getch() noexcept
    {
        if( m_index < m_data.size() )
        {
            return {false, m_data[ m_index++ ]};
        }
        else
            return {true, 0};
    }

    void
    putback() noexcept
    {
        if( m_index )
            --m_index;
    }

    [[nodiscard]]
    position_t
    current_position() const noexcept
    {
        return m_index;
    }

    void
    backto( position_t pos ) noexcept
    {
        if( pos <= m_data.size() )
            m_index = pos;
    }

    [[nodiscard]]
    bool
    eof() const noexcept
    {
        return m_index >= m_data.size();
    }


    [[nodiscard]]
    string_view_t
    fragment(
        string_view_t::size_type from,
        string_view_t::size_type length = string_view_t::npos ) const noexcept
    {
        return m_data.substr( from, length );
    }

    class content_consumer_t
    {
        source_t & m_from;
        const position_t m_started_at;
        bool m_consumed{ false };
 
    public :
        content_consumer_t() = delete;
        content_consumer_t( const content_consumer_t & ) = delete;
        content_consumer_t( content_consumer_t && ) = delete;
 
        content_consumer_t( source_t & from ) noexcept
            :   m_from{ from }
            ,   m_started_at{ from.current_position() }
        {}
 
        ~content_consumer_t() noexcept
        {
            if( !m_consumed )
                m_from.backto( m_started_at );
        }
 
        position_t
        started_at() const noexcept
        {
            return m_started_at;
        }


        void
        commit() noexcept
        {
            m_consumed = true;
        }
    };
};
 
//
// entity_type_t
//
enum class entity_type_t
{
    producer,
    transformer,
    consumer,
    clause,

    transformer_proxy
};
 
//
// producer_tag
//
template< typename Result_Type >
struct producer_tag
{
    using result_type = Result_Type;
    static constexpr entity_type_t entity_type = entity_type_t::producer;
};
 
template< typename T, typename = meta::void_t<> >
struct is_producer : public std::false_type {};
 
template< typename T >
struct is_producer< T, meta::void_t< decltype(T::entity_type) > >
{
    static constexpr bool value = entity_type_t::producer == T::entity_type;
};

template< typename T >
constexpr bool is_producer_v = is_producer<T>::value;
 
//
// transformer_tag
//
template< typename Result_Type >
struct transformer_tag
{
    using result_type = Result_Type;
    static constexpr entity_type_t entity_type = entity_type_t::transformer;
};
 
template< typename T, typename = meta::void_t<> >
struct is_transformer : public std::false_type {};
 
template< typename T >
struct is_transformer< T, meta::void_t< decltype(T::entity_type) > >
{
    static constexpr bool value = entity_type_t::transformer == T::entity_type;
};

template< typename T >
constexpr bool is_transformer_v = is_transformer<T>::value;
 
//
// transformer_invoker
//
template< typename Result_Type >
struct transformer_invoker
{
    template< typename Transformer, typename Input_Type >
    [[nodiscard]]
    static Result_Type
    invoke(
        source_t &,
        Transformer & transformer,
        expected_t< Input_Type, parse_error_t > && input )
    {
        return transformer.transform( std::move(*input) );
    }
};

template< typename Result_Type >
struct transformer_invoker< expected_t< Result_Type, error_reason_t > >
{
    template< typename Transformer, typename Input_Type >
    [[nodiscard]]
    static expected_t< Result_Type, parse_error_t >
    invoke(
        // source_t is necessary to get the position in the case of an error.
        source_t & source,
        Transformer & transformer,
        expected_t< Input_Type, parse_error_t > && input )
    {
        auto result = transformer.transform( std::move(*input) );
        if( result )
            return *result;
        else
            return make_unexpected( parse_error_t{
                    source.current_position(),
                    result.error()
                } );
    }
};
 
//
// is_appropriate_transformer_result_type
//
template< typename Result_Type >
struct is_appropriate_transformer_result_type
{
    static constexpr bool value = true;
};
 
template< typename Result_Type >
struct is_appropriate_transformer_result_type<
        expected_t< Result_Type, error_reason_t > >
{
    static constexpr bool value = true;
};
 
template< typename Result_Type >
struct is_appropriate_transformer_result_type<
        expected_t< Result_Type, parse_error_t > >
{
    static constexpr bool value = false;
};
 
//
// transformed_value_producer_traits_checker
//
template< typename Producer, typename Transformer >
struct transformed_value_producer_traits_checker
{
    static_assert( is_producer_v<Producer>,
            "Producer should be a producer type" );
    static_assert( is_transformer_v<Transformer>,
            "Transformer should be a transformer type" );
 
    using producer_result_t = std::decay_t< decltype( 
            std::declval<Producer &>().try_parse( std::declval<source_t &>() )
        ) >;
 
    using transformation_result_t = std::decay_t< decltype(
            std::declval<Transformer &>().transform(
                    std::move(*(std::declval<producer_result_t>())) )
        ) >;
 
    using expected_result_t = typename Transformer::result_type;
 
    static constexpr bool is_valid_transformation_result_type =
            is_appropriate_transformer_result_type< expected_result_t >::value;
};
 
//
// transformed_value_producer_t
//
template< typename Producer, typename Transformer >
class transformed_value_producer_t
    :   public producer_tag< typename Transformer::result_type >
{
    using traits_checker = transformed_value_producer_traits_checker<
            Producer, Transformer >;
 
    static_assert(
            traits_checker::is_valid_transformation_result_type,
            "transformation result should be either T or "
            "expected_t<T, error_reson_t>, not expected_t<T, parse_error_t>" );
 
    Producer m_producer;
    Transformer m_transformer;
 
public :
    using result_type = typename Transformer::result_type;
 
    transformed_value_producer_t(
        Producer && producer,
        Transformer && transformer )
        :   m_producer{ std::move(producer) }
        ,   m_transformer{ std::move(transformer) }
    {}
 
    [[nodiscard]]
    expected_t< result_type, parse_error_t >
    try_parse( source_t & source )
    {
        auto producer_result = m_producer.try_parse( source );
        if( producer_result )
        {
            using transformation_result_t =
                    typename traits_checker::transformation_result_t;
 
            return transformer_invoker< transformation_result_t >::invoke(
                    source,
                    m_transformer,
                    std::move(producer_result) );
        }
        else
            return make_unexpected( producer_result.error() );
    }
};

template< typename P, typename T >
[[nodiscard]]
std::enable_if_t<
    is_producer_v<P> & is_transformer_v<T>,
    transformed_value_producer_t< P, T > >
operator>>(
    P producer,
    T transformer )
{
    using transformator_type = transformed_value_producer_t< P, T >;
 
    return transformator_type{ std::move(producer), std::move(transformer) };
}
 
//
// transformer_proxy_tag
//
struct transformer_proxy_tag
{
    static constexpr entity_type_t entity_type = entity_type_t::transformer_proxy;
};
 
template< typename T, typename = meta::void_t<> >
struct is_transformer_proxy : public std::false_type {};
 
template< typename T >
struct is_transformer_proxy< T, meta::void_t< decltype(T::entity_type) > >
{
    static constexpr bool value = entity_type_t::transformer_proxy == T::entity_type;
};

template< typename T >
constexpr bool is_transformer_proxy_v = is_transformer_proxy<T>::value;

template<
    typename P,
    typename T,
    typename S = std::enable_if_t<
            is_producer_v<P> & is_transformer_proxy_v<T>,
            void > >
[[nodiscard]]
auto
operator>>(
    P producer,
    T transformer_proxy )
{
    auto real_transformer = transformer_proxy.template make_transformer< 
            typename P::result_type >();
 
    using transformator_type = std::decay_t< decltype(real_transformer) >;
 
    using producer_type = transformed_value_producer_t< P, transformator_type >;
 
    return producer_type{ std::move(producer), std::move(real_transformer) };
}
 
//
// consumer_tag
//
struct consumer_tag
{
    static constexpr entity_type_t entity_type = entity_type_t::consumer;
};
 
template< typename T, typename = meta::void_t<> >
struct is_consumer : public std::false_type {};
 
template< typename T >
struct is_consumer< T, meta::void_t< decltype(T::entity_type) > >
{
    static constexpr bool value = entity_type_t::consumer == T::entity_type;
};

template< typename T >
constexpr bool is_consumer_v = is_consumer<T>::value;
 
//
// clause_tag
//
struct clause_tag
{
    static constexpr entity_type_t entity_type = entity_type_t::clause;
};
 
template< typename T, typename = meta::void_t<> >
struct is_clause : public std::false_type {};
 
template< typename T >
struct is_clause< T, meta::void_t<
    decltype(std::decay_t<T>::entity_type) > >
{
    using real_type = std::decay_t<T>;
 
    static constexpr bool value = entity_type_t::clause == real_type::entity_type;
};

template< typename T >
constexpr bool is_clause_v = is_clause<T>::value;
 
//
// tuple_of_entities_t
//
template< typename... Entities >
using tuple_of_entities_t = meta::rename_t<
        meta::transform_t< std::decay, meta::type_list<Entities...> >,
        std::tuple >;
 
//
// consume_value_clause_t
//
template< typename P, typename C >
class consume_value_clause_t : public clause_tag
{
    static_assert( is_producer_v<P>, "P should be a producer type" );
    static_assert( is_consumer_v<C>, "C should be a consumer type" );
 
    P m_producer;
    C m_consumer;
 
public :
    consume_value_clause_t( P && producer, C && consumer )
        :   m_producer{ std::move(producer) }
        ,   m_consumer{ std::move(consumer) }
    {}
 
    template< typename Target_Type >
    [[nodiscard]]
    std::optional< parse_error_t >
    try_process( source_t & from, Target_Type & target )
    {
        auto parse_result = m_producer.try_parse( from );
        if( parse_result )
        {
            m_consumer.consume( target, std::move(*parse_result) );
            return std::nullopt;
        }
        else
            return parse_result.error();
    }
};

template< typename P, typename C >
[[nodiscard]]
std::enable_if_t<
    is_producer_v<P> && is_consumer_v<C>,
    consume_value_clause_t< P, C > >
operator>>( P producer, C consumer )
{
    return { std::move(producer), std::move(consumer) };
}
 
//
// top_level_clause_t
//
template< typename Producer >
class top_level_clause_t
{
    static_assert( is_producer_v<Producer>,
            "Producer should be a producer type" );
 
    Producer m_producer;
 
public :
    top_level_clause_t( Producer && producer )
        :   m_producer{ std::move(producer) }
    {}
 
    [[nodiscard]]
    auto
    try_process( source_t & from )
    {
        return m_producer.try_parse( from );
    }
};
 
//
// ensure_no_remaining_content
//
[[nodiscard]]
inline std::optional< parse_error_t >
ensure_no_remaining_content(
    source_t & from )
{
    while( !from.eof() )
    {
        if( !is_space( from.getch().m_ch ) )
        {
            from.putback(); // Otherwise current_position() will be wrong.
            return parse_error_t{
                    from.current_position(),
                    error_reason_t::unconsumed_input
            };
        }
    }
 
    return std::nullopt;
}
 
//
// remove_trailing_spaces
//
[[nodiscard]]
inline string_view_t
remove_trailing_spaces( string_view_t from ) noexcept
{
    auto s = from.size();
    for(; s && is_space( from[ (s-1u) ] ); --s) {}
 
    return from.substr( 0u, s );
}
 
//
// alternatives_clause_t
//
template<
    typename Subitems_Tuple >
class alternatives_clause_t : public clause_tag
{
    Subitems_Tuple m_subitems;
 
public :
    alternatives_clause_t(
        Subitems_Tuple && subitems )
        :   m_subitems{ std::move(subitems) }
    {}
 
    template< typename Target_Type >
    [[nodiscard]]
    std::optional< parse_error_t >
    try_process( source_t & from, Target_Type & target )
    {
        const auto starting_pos = from.current_position();
 
        std::optional< parse_error_t > actual_parse_error;
        const bool success = restinio::utils::tuple_algorithms::any_of(
                m_subitems,
                [&from, &target, &actual_parse_error]( auto && one_producer ) {
                    source_t::content_consumer_t consumer{ from };
                    Target_Type tmp_value{ target };
 
                    actual_parse_error = one_producer.try_process( from, tmp_value );
                    if( !actual_parse_error )
                    {
                        target = std::move(tmp_value);
                        consumer.commit();
 
                        return true;
                    }
                    else {
                        // Since v.0.6.7 we should check for
                        // force_only_this_alternative_failed error.
                        // In the case of that error enumeration of alternatives
                        // should be stopped.
                        return error_reason_t::force_only_this_alternative_failed ==
                                actual_parse_error->reason();
                    }
                } );
 
        if( !success || actual_parse_error )
            return parse_error_t{
                    starting_pos,
                    error_reason_t::no_appropriate_alternative
            };
        else
            return std::nullopt;
    }
};
 
//
// maybe_clause_t
//
template<
    typename Subitems_Tuple >
class maybe_clause_t : public clause_tag
{
    Subitems_Tuple m_subitems;
 
public :
    maybe_clause_t(
        Subitems_Tuple && subitems )
        :   m_subitems{ std::move(subitems) }
    {}
 
    template< typename Target_Type >
    [[nodiscard]]
    std::optional< parse_error_t >
    try_process( source_t & from, Target_Type & target )
    {
        source_t::content_consumer_t consumer{ from };
        Target_Type tmp_value{ target };
 
        const bool success = restinio::utils::tuple_algorithms::all_of(
                m_subitems,
                [&from, &tmp_value]( auto && one_producer ) {
                    return !one_producer.try_process( from, tmp_value );
                } );
 
        if( success )
        {
            target = std::move(tmp_value);
            consumer.commit();
        }
 
        // maybe_clause always returns success even if nothing consumed.
        return std::nullopt;
    }
};
 
//
// not_clause_t
//
template<
    typename Subitems_Tuple >
class not_clause_t : public clause_tag
{
    Subitems_Tuple m_subitems;
 
public :
    not_clause_t(
        Subitems_Tuple && subitems )
        :   m_subitems{ std::move(subitems) }
    {}
 
    template< typename Target_Type >
    [[nodiscard]]
    std::optional< parse_error_t >
    try_process( source_t & from, Target_Type & )
    {
        // NOTE: will always return the current position back.
        source_t::content_consumer_t consumer{ from };
 
        Target_Type dummy_value;
 
        const auto success = !restinio::utils::tuple_algorithms::all_of(
                m_subitems,
                [&from, &dummy_value]( auto && one_producer ) {
                    return !one_producer.try_process( from, dummy_value );
                } );
 
        // This is contra-intuitive but: we return pattern_not_found in
        // the case when pattern is actually found in the input.
        if( !success )
            return parse_error_t{
                    consumer.started_at(),
                    //FIXME: maybe a more appropriate error_reason can
                    //be used here?
                    error_reason_t::pattern_not_found
            };
        else
            return std::nullopt;
    }
};
 
//
// and_clause_t
//
template<
    typename Subitems_Tuple >
class and_clause_t : public clause_tag
{
    Subitems_Tuple m_subitems;
 
public :
    and_clause_t(
        Subitems_Tuple && subitems )
        :   m_subitems{ std::move(subitems) }
    {}
 
    template< typename Target_Type >
    [[nodiscard]]
    std::optional< parse_error_t >
    try_process( source_t & from, Target_Type & )
    {
        // NOTE: will always return the current position back.
        source_t::content_consumer_t consumer{ from };
 
        Target_Type dummy_value;
 
        const bool success = restinio::utils::tuple_algorithms::all_of(
                m_subitems,
                [&from, &dummy_value]( auto && one_producer ) {
                    return !one_producer.try_process( from, dummy_value );
                } );
 
        if( !success )
            return parse_error_t{
                    consumer.started_at(),
                    error_reason_t::pattern_not_found
            };
        else
            return std::nullopt;
    }
};
 
//
// sequence_clause_t
//
template<
    typename Subitems_Tuple >
class sequence_clause_t : public clause_tag
{
    Subitems_Tuple m_subitems;
 
public :
    sequence_clause_t(
        Subitems_Tuple && subitems )
        :   m_subitems{ std::move(subitems) }
    {}
 
    template< typename Target_Type >
    [[nodiscard]]
    std::optional< parse_error_t >
    try_process( source_t & from, Target_Type & target )
    {
        source_t::content_consumer_t consumer{ from };
        Target_Type tmp_value{ target };
 
        // We should store actual parse error from subitems to return it.
        std::optional< parse_error_t > result;
 
        const bool success = restinio::utils::tuple_algorithms::all_of(
                m_subitems,
                [&from, &tmp_value, &result]( auto && one_producer ) {
                    result = one_producer.try_process( from, tmp_value );
                    return !result;
                } );
 
        if( success )
        {
            target = std::move(tmp_value);
            consumer.commit();
        }
 
        return result;
    }
};
 
//
// forced_alternative_clause_t
//
template<
    typename Subitems_Tuple >
class forced_alternative_clause_t : public sequence_clause_t< Subitems_Tuple >
{
    using base_type_t = sequence_clause_t< Subitems_Tuple >;
 
public :
    using base_type_t::base_type_t;
 
    template< typename Target_Type >
    [[nodiscard]]
    std::optional< parse_error_t >
    try_process( source_t & from, Target_Type & target )
    {
        const auto starting_pos = from.current_position();
 
        if( base_type_t::try_process( from, target ) )
        {
            // The forced clause is not parsed correctly.
            // So the special error code should be returned in that case.
            return parse_error_t{
                    starting_pos,
                    error_reason_t::force_only_this_alternative_failed
            };
        }
        else
            return std::nullopt;
    }
};
 
//
// produce_t
//
template<
    typename Target_Type,
    typename Subitems_Tuple >
class produce_t : public producer_tag< Target_Type >
{
    using value_wrapper_t = result_value_wrapper< Target_Type >;
 
    Subitems_Tuple m_subitems;
 
public :
    produce_t(
        Subitems_Tuple && subitems )
        :   m_subitems{ std::move(subitems) }
    {}
 
    [[nodiscard]]
    expected_t< Target_Type, parse_error_t >
    try_parse( source_t & from )
    {
        typename value_wrapper_t::wrapped_type tmp_value{};
        std::optional< parse_error_t > error;
 
        const bool success = restinio::utils::tuple_algorithms::all_of(
                m_subitems,
                [&from, &tmp_value, &error]( auto && one_clause ) {
                    error = one_clause.try_process( from, tmp_value );
                    return !error;
                } );
 
        if( success )
            return value_wrapper_t::unwrap_value( tmp_value );
        else
            return make_unexpected( *error );
    }
};
 
//
// repeat_clause_t
//
template<
    typename Subitems_Tuple >
class repeat_clause_t : public clause_tag
{
    std::size_t m_min_occurences;
    std::size_t m_max_occurences;
 
    Subitems_Tuple m_subitems;
 
public :
    repeat_clause_t(
        std::size_t min_occurences,
        std::size_t max_occurences,
        Subitems_Tuple && subitems )
        :   m_min_occurences{ min_occurences }
        ,   m_max_occurences{ max_occurences }
        ,   m_subitems{ std::move(subitems) }
    {}
 
    template< typename Target_Type >
    [[nodiscard]]
    std::optional< parse_error_t >
    try_process( source_t & from, Target_Type & dest )
    {
        source_t::content_consumer_t whole_consumer{ from };
 
        std::size_t count{};
        bool failure_detected{ false };
        for(; !failure_detected && count != m_max_occurences; )
        {
            source_t::content_consumer_t item_consumer{ from };
 
            failure_detected = !restinio::utils::tuple_algorithms::all_of(
                    m_subitems,
                    [&from, &dest]( auto && one_clause ) {
                        return !one_clause.try_process( from, dest );
                    } );
 
            if( !failure_detected )
            {
                // Another item successfully parsed and should be stored.
                item_consumer.commit();
                ++count;
            }
        }
 
        if( count >= m_min_occurences )
        {
            whole_consumer.commit();
            return std::nullopt;
        }
 
        return parse_error_t{
                from.current_position(),
                error_reason_t::pattern_not_found
        };
    }
};
 
//
// symbol_producer_template_t
//
template< typename Predicate >
class symbol_producer_template_t
    :   public producer_tag< char >
    ,   protected Predicate
{
public:
    template< typename... Args >
    symbol_producer_template_t( Args &&... args )
        :    Predicate{ std::forward<Args>(args)... }
    {}
 
    [[nodiscard]]
    expected_t< char, parse_error_t >
    try_parse( source_t & from ) const noexcept
    {
        const auto ch = from.getch();
        if( !ch.m_eof )
        {
            // A call to predicate.
            if( (*this)(ch.m_ch) )
                return ch.m_ch;
            else
            {
                from.putback();
                return make_unexpected( parse_error_t{
                        from.current_position(),
                        error_reason_t::unexpected_character
                } );
            }
        }
        else
            return make_unexpected( parse_error_t{
                    from.current_position(),
                    error_reason_t::unexpected_eof
            } );
    }
};
 
//
// any_symbol_predicate_t
//
struct any_symbol_predicate_t
{
    [[nodiscard]]
    constexpr bool
    operator()( const char ) const noexcept
    {
        return true;
    }
};
 
//
// particular_symbol_predicate_t
//
struct particular_symbol_predicate_t
{
    char m_expected;
 
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return m_expected == actual;
    }
};
 
//
// not_particular_symbol_predicate_t
//
struct not_particular_symbol_predicate_t
{
    char m_sentinel;
 
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return m_sentinel != actual;
    }
};
 
//
// caseless_particular_symbol_predicate_t
//
struct caseless_particular_symbol_predicate_t
{
    char m_expected;
 
    caseless_particular_symbol_predicate_t( char v ) noexcept
        :   m_expected{ restinio::impl::to_lower_case( v ) }
    {}
 
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return m_expected == restinio::impl::to_lower_case(actual);
    }
};
 
//
// symbol_from_range_predicate_t
//
struct symbol_from_range_predicate_t
{
    char m_left;
    char m_right;
 
    [[nodiscard]]
    bool
    operator()( const char actual ) const noexcept
    {
        return ( actual >= m_left && actual <= m_right );
    }
};
 
//
// symbol_producer_t
//
class symbol_producer_t
    : public symbol_producer_template_t< particular_symbol_predicate_t >
{
    using base_type_t =
        symbol_producer_template_t< particular_symbol_predicate_t >;
 
public:
    symbol_producer_t( char expected )
        :   base_type_t{ particular_symbol_predicate_t{expected} }
    {}
};
 
//
// any_symbol_if_not_producer_t
//
class any_symbol_if_not_producer_t
    : public symbol_producer_template_t< not_particular_symbol_predicate_t >
{
    using base_type_t =
        symbol_producer_template_t< not_particular_symbol_predicate_t >;
 
public:
    any_symbol_if_not_producer_t( char sentinel )
        :   base_type_t{ not_particular_symbol_predicate_t{sentinel} }
    {}
};
 
//
// caseless_symbol_producer_t
//
class caseless_symbol_producer_t
    : public symbol_producer_template_t< caseless_particular_symbol_predicate_t >
{
    using base_type_t =
        symbol_producer_template_t< caseless_particular_symbol_predicate_t >;
 
public:
    caseless_symbol_producer_t( char expected )
        :   base_type_t{ caseless_particular_symbol_predicate_t{expected} }
    {}
};
 
//
// symbol_from_range_producer_t
//
class symbol_from_range_producer_t
    : public symbol_producer_template_t< symbol_from_range_predicate_t >
{
    using base_type_t =
        symbol_producer_template_t< symbol_from_range_predicate_t >;
 
public:
    symbol_from_range_producer_t( char left, char right )
        :   base_type_t{ symbol_from_range_predicate_t{left, right} }
    {}
};
 
//
// digit_producer_t
//
class digit_producer_t
    : public symbol_producer_template_t< is_digit_predicate_t >
{
public:
    digit_producer_t() {}
};
 
//
// hexdigit_producer_t
//
class hexdigit_producer_t
    : public symbol_producer_template_t< is_hexdigit_predicate_t >
{
public:
    hexdigit_producer_t() {}
};
 
//
// try_parse_digits_with_digits_limit
//
template< typename T, typename Value_Accumulator >
[[nodiscard]]
expected_t< T, parse_error_t >
try_parse_digits_with_digits_limit(
    source_t & from,
    digits_to_consume_t digits_limit,
    Value_Accumulator acc ) noexcept
{
    source_t::content_consumer_t consumer{ from };
 
    digits_to_consume_t::underlying_int_t symbols_processed{};
 
    for( auto ch = from.getch(); !ch.m_eof; ch = from.getch() )
    {
        if( is_digit(ch.m_ch) )
        {
            acc.next_digit( static_cast<T>(ch.m_ch - '0') );
 
            if( acc.overflow_detected() )
                return make_unexpected( parse_error_t{
                        consumer.started_at(),
                        error_reason_t::illegal_value_found
                } );
 
            ++symbols_processed;
            if( symbols_processed == digits_limit.max() )
                break;
        }
        else
        {
            from.putback();
            break;
        }
    }
 
    if( symbols_processed < digits_limit.min() )
        // Not all required digits are extracted.
        return make_unexpected( parse_error_t{
                from.current_position(),
                error_reason_t::pattern_not_found
        } );
    else
    {
        consumer.commit();
        return acc.value();
    }
}
 
//
// try_parse_hexdigits_with_digits_limit
//
template< typename T, typename Value_Accumulator >
[[nodiscard]]
expected_t< T, parse_error_t >
try_parse_hexdigits_with_digits_limit(
    source_t & from,
    digits_to_consume_t digits_limit,
    Value_Accumulator acc ) noexcept
{
    const auto ch_to_digit = []( char ch ) -> std::pair<bool, T> {
        if( ch >= '0' && ch <= '9' )
            return std::make_pair( true, static_cast<T>(ch - '0') );
        else if( ch >= 'A' && ch <= 'F' )
            return std::make_pair( true, static_cast<T>(10 + (ch - 'A')) );
        else if( ch >= 'a' && ch <= 'f' )
            return std::make_pair( true, static_cast<T>(10 + (ch - 'a')) );
        else
            return std::make_pair( false, static_cast<T>(0) );
    };
 
    source_t::content_consumer_t consumer{ from };
 
    digits_to_consume_t::underlying_int_t symbols_processed{};
 
    for( auto ch = from.getch(); !ch.m_eof; ch = from.getch() )
    {
        const auto d = ch_to_digit( ch.m_ch );
        if( d.first )
        {
            acc.next_digit( d.second );
 
            if( acc.overflow_detected() )
                return make_unexpected( parse_error_t{
                        consumer.started_at(),
                        error_reason_t::illegal_value_found
                } );
 
            ++symbols_processed;
            if( symbols_processed == digits_limit.max() )
                break;
        }
        else
        {
            from.putback();
            break;
        }
    }
 
    if( symbols_processed < digits_limit.min() )
        // Not all required digits are extracted.
        return make_unexpected( parse_error_t{
                from.current_position(),
                error_reason_t::pattern_not_found
        } );
    else
    {
        consumer.commit();
        return acc.value();
    }
}
 
//
// non_negative_decimal_number_producer_t
//
template< typename T >
class non_negative_decimal_number_producer_t : public producer_tag< T >
{
public:
    [[nodiscard]]
    expected_t< T, parse_error_t >
    try_parse( source_t & from ) const noexcept
    {
        return try_parse_digits_with_digits_limit< T >(
                from,
                digits_to_consume_t::from_one_to_max(),
                restinio::impl::overflow_controlled_integer_accumulator_t<T, 10>{} );
    }
};
 
//
// non_negative_decimal_number_producer_with_digits_limit_t
//
template< typename T >
class non_negative_decimal_number_producer_with_digits_limit_t
    :   public non_negative_decimal_number_producer_t<T>
{
    digits_to_consume_t m_digits_limit;
 
public:
    non_negative_decimal_number_producer_with_digits_limit_t(
        digits_to_consume_t digits_limit )
        :   m_digits_limit{ digits_limit }
    {}
 
    [[nodiscard]]
    expected_t< T, parse_error_t >
    try_parse( source_t & from ) const noexcept
    {
        return try_parse_digits_with_digits_limit< T >(
                from,
                m_digits_limit,
                restinio::impl::overflow_controlled_integer_accumulator_t<T, 10>{} );
    }
};
 
//
// hexadecimal_number_producer_t
//
template< typename T >
class hexadecimal_number_producer_t : public producer_tag< T >
{
    static_assert( std::is_unsigned<T>::value,
            "T is expected to be unsigned type" );
 
public:
    [[nodiscard]]
    expected_t< T, parse_error_t >
    try_parse( source_t & from ) const noexcept
    {
        return try_parse_hexdigits_with_digits_limit< T >(
                from,
                digits_to_consume_t::from_one_to_max(),
                restinio::impl::overflow_controlled_integer_accumulator_t<T, 16>{} );
    }
};
 
//
// hexadecimal_number_producer_with_digits_limit_t
//
template< typename T >
class hexadecimal_number_producer_with_digits_limit_t
    :   public hexadecimal_number_producer_t< T >
{
    digits_to_consume_t m_digits_limit;
 
public:
    hexadecimal_number_producer_with_digits_limit_t(
        digits_to_consume_t digits_limit )
        :   m_digits_limit{ digits_limit }
    {}
 
    [[nodiscard]]
    expected_t< T, parse_error_t >
    try_parse( source_t & from ) const noexcept
    {
        return try_parse_hexdigits_with_digits_limit< T >(
                from,
                m_digits_limit,
                restinio::impl::overflow_controlled_integer_accumulator_t<T, 16>{} );
    }
};
 
//
// decimal_number_producer_t
//
template< typename T >
class decimal_number_producer_t : public producer_tag<T>
{
    static_assert( std::is_signed<T>::value,
            "decimal_number_producer_t can be used only for signed types" );
 
public:
    using try_parse_result_type = expected_t< T, parse_error_t >;
 
    [[nodiscard]]
    try_parse_result_type
    try_parse( source_t & from ) const noexcept
    {
        return try_parse_impl( from,
                []() noexcept {
                    return digits_to_consume_t::from_one_to_max();
                } );
    }
 
protected:
    template< typename Digits_Limit_Maker >
    [[nodiscard]]
    try_parse_result_type
    try_parse_impl(
        source_t & from,
        Digits_Limit_Maker && digits_limit_maker ) const noexcept
    {
        source_t::content_consumer_t consumer{ from };
 
        auto sign_ch = from.getch();
        if( !sign_ch.m_eof )
        {
            const auto r = try_parse_with_this_first_symbol(
                    from,
                    sign_ch.m_ch,
                    std::forward<Digits_Limit_Maker>(digits_limit_maker) );
 
            if( r )
                consumer.commit();
 
            return r;
        }
        else
            return make_unexpected( parse_error_t{
                    from.current_position(),
                    error_reason_t::pattern_not_found
            } );
    }
 
private:
    template< typename Digits_Limit_Maker >
    [[nodiscard]]
    static try_parse_result_type
    try_parse_with_this_first_symbol(
        source_t & from,
        char first_symbol,
        Digits_Limit_Maker && digits_limit_maker ) noexcept
    {
        using restinio::impl::overflow_controlled_integer_accumulator_t;
        using restinio::impl::check_negative_extremum;
 
        if( '-' == first_symbol )
        {
            const auto r = try_parse_digits_with_digits_limit< T >(
                    from,
                    digits_limit_maker(),
                    overflow_controlled_integer_accumulator_t<
                            T,
                            10,
                            check_negative_extremum >{} );
            if( r )
                return static_cast< T >( -(*r) ); // This static_cast is required
                    // for clang compiler that warns that if type of *r is `short`,
                    // then -(*r) will have type `int`.
            else
                return r;
        }
        else if( '+' == first_symbol )
        {
            return try_parse_digits_with_digits_limit< T >(
                    from,
                    digits_limit_maker(),
                    overflow_controlled_integer_accumulator_t< T, 10 >{} );
        }
        else if( is_digit(first_symbol) )
        {
            from.putback();
            return try_parse_digits_with_digits_limit< T >(
                    from,
                    digits_limit_maker(),
                    overflow_controlled_integer_accumulator_t< T, 10 >{} );
        }
 
        return make_unexpected( parse_error_t{
                from.current_position(),
                error_reason_t::pattern_not_found
        } );
    }
};
 
//
// decimal_number_producer_with_digits_limit_t
//
template< typename T >
class decimal_number_producer_with_digits_limit_t
    :   public decimal_number_producer_t< T >
{
    digits_to_consume_t m_digits_limit;
 
public:
    decimal_number_producer_with_digits_limit_t(
        digits_to_consume_t digits_limit )
        :   m_digits_limit{ digits_limit }
    {}
 
    [[nodiscard]]
    auto
    try_parse( source_t & from ) const noexcept
    {
        return this->try_parse_impl(
                from,
                [this]() noexcept { return m_digits_limit; } );
    }
};
 
//
// any_value_skipper_t
//
struct any_value_skipper_t : public consumer_tag
{
    template< typename Target_Type, typename Value >
    void
    consume( Target_Type &, Value && ) const noexcept {}
};
 
//
// as_result_consumer_t
//
struct as_result_consumer_t : public consumer_tag
{
    template< typename Target_Type, typename Value >
    void
    consume( Target_Type & dest, Value && src ) const
    {
        result_wrapper_for_t<Target_Type>::as_result(
                dest, std::forward<Value>(src) );
    }
};
 
//
// just_result_consumer_t
//
template< typename Result_Type >
class just_result_consumer_t : public consumer_tag
{
    Result_Type m_result;
 
    // NOTE: this helper method is necessary for MSVC++ compiler.
    // It's because MSVC++ can't compile expression:
    //
    // as_result(dest, Result_Type{m_result})
    //
    // in consume() method for trivial types like size_t.
    Result_Type
    make_copy_of_result() const
        noexcept(noexcept(Result_Type{m_result}))
    {
        return m_result;
    }
 
public :
    template< typename Result_Arg >
    just_result_consumer_t( Result_Arg && result )
        noexcept(noexcept(Result_Type{std::forward<Result_Arg>(result)}))
        :   m_result{ std::forward<Result_Arg>(result) }
    {}
 
    template< typename Target_Type, typename Value >
    void
    consume( Target_Type & dest, Value && ) const
    {
        result_wrapper_for_t<Target_Type>::as_result(
                dest,
                // NOTE: use a copy of m_result.
                make_copy_of_result() );
    }
};
 
//
// custom_consumer_t
//
template< typename C >
class custom_consumer_t : public consumer_tag
{
    C m_consumer;
 
public :
    custom_consumer_t( C && consumer ) : m_consumer{std::move(consumer)} {}
 
    template< typename Target_Type, typename Value >
    void
    consume( Target_Type & dest, Value && src ) const
        noexcept(noexcept(m_consumer(dest, std::forward<Value>(src))))
    {
        m_consumer( dest, std::forward<Value>(src) );
    }
};
 
//
// field_setter_consumer_t
//
template< typename F, typename C >
class field_setter_consumer_t : public consumer_tag
{
    using pointer_t = F C::*;
 
    pointer_t m_ptr;
 
public :
    field_setter_consumer_t( pointer_t ptr ) noexcept : m_ptr{ptr} {}
 
    // NOTE: it seems that this method won't be compiled if
    // result_value_wrapper::result_type differs from
    // result_value_wrapper::wrapped_type.
    //
    // This is not a problem for the current version.
    // But this moment would require more attention in the future.
    void
    consume( C & to, F && value ) const
        noexcept(noexcept(to.*m_ptr = std::move(value)))
    {
        to.*m_ptr = std::move(value);
    }
};

template< typename P, typename F, typename C >
[[nodiscard]]
std::enable_if_t<
    is_producer_v<P>,
    consume_value_clause_t< P, field_setter_consumer_t<F,C> > >
operator>>( P producer, F C::*member_ptr )
{
    return {
            std::move(producer),
            field_setter_consumer_t<F,C>{ member_ptr }
    };
}
 
//
// tuple_item_consumer_t
//
template< std::size_t Index >
struct tuple_item_consumer_t : public consumer_tag
{
    // NOTE: it seems that this method won't be compiled if
    // result_value_wrapper::result_type differs from
    // result_value_wrapper::wrapped_type.
    //
    // This is not a problem for the current version.
    // But this moment would require more attention in the future.
    template< typename Target_Type, typename Value >
    void
    consume( Target_Type && to, Value && value )
    {
        std::get<Index>(std::forward<Target_Type>(to)) =
                std::forward<Value>(value);
    }
};
 
//
// to_lower_transformer_t
//
template< typename Input_Type >
struct to_lower_transformer_t;

template<>
struct to_lower_transformer_t< std::string >
    : public transformer_tag< std::string >
{
    using input_type = std::string;
 
    [[nodiscard]]
    result_type
    transform( input_type && input ) const noexcept
    {
        result_type result{ std::move(input) };
        std::transform( result.begin(), result.end(), result.begin(),
            []( unsigned char ch ) -> char {
                return restinio::impl::to_lower_case(ch);
            } );
 
        return result;
    }
};

template<>
struct to_lower_transformer_t< char >
    : public transformer_tag< char >
{
    using input_type = char;
 
    [[nodiscard]]
    result_type
    transform( input_type && input ) const noexcept
    {
        return restinio::impl::to_lower_case(input);
    }
};

template< std::size_t S >
struct to_lower_transformer_t< std::array< char, S > >
    : public transformer_tag< std::array< char, S > >
{
    using input_type = std::array< char, S >;
    using base_type = transformer_tag< input_type >;
 
    [[nodiscard]]
    typename base_type::result_type
    transform( input_type && input ) const noexcept
    {
        typename base_type::result_type result;
        std::transform( input.begin(), input.end(), result.begin(),
            []( unsigned char ch ) -> char {
                return restinio::impl::to_lower_case(ch);
            } );
 
        return result;
    }
};
 
//
// to_lower_transformer_proxy_t
//
struct to_lower_transformer_proxy_t : public transformer_proxy_tag
{
    template< typename Input_Type >
    [[nodiscard]]
    auto
    make_transformer() const noexcept
    {
        return to_lower_transformer_t< Input_Type >{};
    }
};
 
//
// just_value_transformer_t
//
template< typename T >
class just_value_transformer_t : public transformer_tag< T >
{
    T m_value;
 
public :
    just_value_transformer_t( T v ) noexcept(noexcept(T{std::move(v)}))
        : m_value{ std::move(v) }
    {}
 
    template< typename Input >
    [[nodiscard]]
    T
    transform( Input && ) const noexcept(noexcept(T{m_value}))
    {
        return m_value;
    }
};
 
//
// convert_transformer_t
//
template< typename Output_Type, typename Converter >
class convert_transformer_t : public transformer_tag< Output_Type >
{
    Converter m_converter;
 
public :
    template< typename Convert_Arg >
    convert_transformer_t( Convert_Arg && converter )
        noexcept(noexcept(Converter{std::forward<Convert_Arg>(converter)}))
        : m_converter{ std::forward<Convert_Arg>(converter) }
    {}

    template< typename Input >
    [[nodiscard]]
    auto
    transform( Input && input ) const
        noexcept(noexcept(m_converter(std::forward<Input>(input))))
    {
        using actual_result_t = std::decay_t< decltype(
                m_converter(std::forward<Input>(input))
            ) >;
 
        static_assert(
                is_appropriate_transformer_result_type<actual_result_t>::value,
                "the return value of converter should be either Output_Type or "
                "expected_t<Output_Type, error_reason_t>" );
 
        return m_converter(std::forward<Input>(input));
    }
};
 
//
// conversion_result_type_detector
//
template< typename Result_Type >
struct conversion_result_type_detector
{
    using type = Result_Type;
};
 
template< typename Result_Type >
struct conversion_result_type_detector< expected_t< Result_Type, error_reason_t > >
{
    using type = Result_Type;
};

template< typename Result_Type >
using conversion_result_type_detector_t =
        typename conversion_result_type_detector<Result_Type>::type;
 
//
// convert_transformer_proxy_t
//
template< typename Converter >
class convert_transformer_proxy_t : public transformer_proxy_tag
{
    template< typename Input_Type >
    using output = conversion_result_type_detector_t<
                std::decay_t< decltype(
                        std::declval<Converter &>()(std::declval<Input_Type&&>())
                    ) >
            >;
 
    Converter m_converter;
 
public :
    template< typename Convert_Arg >
    convert_transformer_proxy_t( Convert_Arg && converter )
        noexcept(noexcept(Converter{std::forward<Convert_Arg>(converter)}))
        : m_converter{ std::forward<Convert_Arg>(converter) }
    {}
 
    template< typename Input_Type >
    [[nodiscard]]
    auto
    make_transformer() const &
        noexcept(noexcept(Converter{m_converter}))
    {
        using output_t = output<Input_Type>;
 
        return convert_transformer_t< output_t, Converter >{ m_converter };
    }
 
    template< typename Input_Type >
    [[nodiscard]]
    auto
    make_transformer() &&
        noexcept(noexcept(Converter{std::move(m_converter)}))
    {
        using output_t = output<Input_Type>;
 
        return convert_transformer_t< output_t, Converter >{
                std::move(m_converter)
        };
    }
};
 
//
// try_parse_exact_fragment
//
 
// Requires that begin is not equal to end.
template< typename It >
[[nodiscard]]
expected_t< bool, parse_error_t >
try_parse_exact_fragment( source_t & from, It begin, It end )
{
    assert( begin != end );
 
    source_t::content_consumer_t consumer{ from };
 
    for( auto ch = from.getch(); !ch.m_eof; ch = from.getch() )
    {
        if( ch.m_ch != *begin )
            return make_unexpected( parse_error_t{
                    consumer.started_at(),
                    error_reason_t::pattern_not_found
                } );
        if( ++begin == end )
            break;
    }
 
    if( begin != end )
        return make_unexpected( parse_error_t{
                consumer.started_at(),
                error_reason_t::unexpected_eof
            } );
 
    consumer.commit();
 
    return true;
}
 
//
// exact_fixed_size_fragment_producer_t
//
template< std::size_t Size >
class exact_fixed_size_fragment_producer_t
    :   public producer_tag< bool >
{
    static_assert( 1u < Size, "Size is expected to greater that 1" );
 
    // NOTE: there is no space for last zero-byte.
    std::array< char, Size-1u > m_fragment;
 
public:
    exact_fixed_size_fragment_producer_t( const char (&f)[Size] )
    {
        // NOTE: last zero-byte is discarded.
        std::copy( &f[ 0 ], &f[ m_fragment.size() ], m_fragment.data() );
    }
 
    [[nodiscard]]
    expected_t< bool, parse_error_t >
    try_parse( source_t & from )
    {
        return try_parse_exact_fragment( from,
                m_fragment.begin(), m_fragment.end() );
    }
};
 
//
// exact_fragment_producer_t
//
class exact_fragment_producer_t
    :   public producer_tag< bool >
{
    std::string m_fragment;
 
public:
    exact_fragment_producer_t( std::string fragment )
        :   m_fragment{ std::move(fragment) }
    {
        if( m_fragment.empty() )
            throw exception_t( "'fragment' value for exact_fragment_producer_t "
                    "can't be empty!" );
    }
 
    [[nodiscard]]
    expected_t< bool, parse_error_t >
    try_parse( source_t & from )
    {
        return try_parse_exact_fragment( from,
                m_fragment.begin(), m_fragment.end() );
    }
};
 
//
// try_parse_caseless_exact_fragment
//
 
// Requires that begin is not equal to end.
// It assumes that content in [begin, end) is already in lower case.
template< typename It >
[[nodiscard]]
expected_t< bool, parse_error_t >
try_parse_caseless_exact_fragment( source_t & from, It begin, It end )
{
    assert( begin != end );
 
    source_t::content_consumer_t consumer{ from };
 
    for( auto ch = from.getch(); !ch.m_eof; ch = from.getch() )
    {
        if( restinio::impl::to_lower_case(ch.m_ch) != *begin )
            return make_unexpected( parse_error_t{
                    consumer.started_at(),
                    error_reason_t::pattern_not_found
                } );
        if( ++begin == end )
            break;
    }
 
    if( begin != end )
        return make_unexpected( parse_error_t{
                consumer.started_at(),
                error_reason_t::unexpected_eof
            } );
 
    consumer.commit();
 
    return true;
}
 
//
// caseless_exact_fixed_size_fragment_producer_t
//
template< std::size_t Size >
class caseless_exact_fixed_size_fragment_producer_t
    :   public producer_tag< bool >
{
    static_assert( 1u < Size, "Size is expected to greater that 1" );
 
    // NOTE: there is no space for last zero-byte.
    std::array< char, Size-1u > m_fragment;
 
public:
    caseless_exact_fixed_size_fragment_producer_t( const char (&f)[Size] )
    {
        // Content should be converted to lower-case.
        // NOTE: last zero-byte is discarded.
        std::transform(
                &f[ 0 ], &f[ m_fragment.size() ],
                m_fragment.data(),
                []( const char src ) {
                    return restinio::impl::to_lower_case( src );
                } );
    }
 
    [[nodiscard]]
    expected_t< bool, parse_error_t >
    try_parse( source_t & from )
    {
        return try_parse_caseless_exact_fragment( from,
                m_fragment.begin(), m_fragment.end() );
    }
};
 
//
// caseless_exact_fragment_producer_t
//
class caseless_exact_fragment_producer_t
    :   public producer_tag< bool >
{
    std::string m_fragment;
 
public:
    caseless_exact_fragment_producer_t( std::string fragment )
        :   m_fragment{ std::move(fragment) }
    {
        if( m_fragment.empty() )
            throw exception_t( "'fragment' value for exact_fragment_producer_t "
                    "can't be empty!" );
 
        // Content should be converted to lower-case.
        for( auto & ch : m_fragment )
            ch = restinio::impl::to_lower_case( ch );
    }
 
    [[nodiscard]]
    expected_t< bool, parse_error_t >
    try_parse( source_t & from )
    {
        return try_parse_caseless_exact_fragment( from,
                m_fragment.begin(), m_fragment.end() );
    }
};
 
} /* namespace impl */
 
//
// produce
//
template<
    typename Target_Type,
    typename... Clauses >
[[nodiscard]]
auto
produce( Clauses &&... clauses )
{
    static_assert( 0 != sizeof...(clauses),
            "list of clauses can't be empty" );
    static_assert( meta::all_of_v< impl::is_clause, Clauses... >,
            "all arguments for produce() should be clauses" );
 
    using producer_type_t = impl::produce_t<
            Target_Type,
            impl::tuple_of_entities_t<Clauses...> >;
 
    return producer_type_t{
            std::make_tuple(std::forward<Clauses>(clauses)...)
    };
}
 
//
// alternatives
//
template< typename... Clauses >
[[nodiscard]]
auto
alternatives( Clauses &&... clauses )
{
    static_assert( 0 != sizeof...(clauses),
            "list of clauses can't be empty" );
    static_assert( meta::all_of_v< impl::is_clause, Clauses... >,
            "all arguments for alternatives() should be clauses" );
 
    using clause_type_t = impl::alternatives_clause_t<
            impl::tuple_of_entities_t< Clauses... > >;
 
    return clause_type_t{
            std::make_tuple(std::forward<Clauses>(clauses)...)
    };
}
 
//
// maybe
//
template< typename... Clauses >
[[nodiscard]]
auto
maybe( Clauses &&... clauses )
{
    static_assert( 0 != sizeof...(clauses),
            "list of clauses can't be empty" );
    static_assert( meta::all_of_v< impl::is_clause, Clauses... >,
            "all arguments for maybe() should be clauses" );
 
    using clause_type_t = impl::maybe_clause_t<
            impl::tuple_of_entities_t<Clauses...> >;
 
    return clause_type_t{
            std::make_tuple(std::forward<Clauses>(clauses)...)
    };
}
 
//
// not_clause
//
template< typename... Clauses >
[[nodiscard]]
auto
not_clause( Clauses &&... clauses )
{
    static_assert( 0 != sizeof...(clauses),
            "list of clauses can't be empty" );
    static_assert( meta::all_of_v< impl::is_clause, Clauses... >,
            "all arguments for not_clause() should be clauses" );
 
    using clause_type_t = impl::not_clause_t<
            impl::tuple_of_entities_t<Clauses...> >;
 
    return clause_type_t{
            std::make_tuple(std::forward<Clauses>(clauses)...)
    };
}
 
//
// and_clause
//
template< typename... Clauses >
[[nodiscard]]
auto
and_clause( Clauses &&... clauses )
{
    static_assert( 0 != sizeof...(clauses),
            "list of clauses can't be empty" );
    static_assert( meta::all_of_v< impl::is_clause, Clauses... >,
            "all arguments for sequence() should be clauses" );
 
    using clause_type_t = impl::and_clause_t<
            impl::tuple_of_entities_t<Clauses...> >;
 
    return clause_type_t{
            std::make_tuple(std::forward<Clauses>(clauses)...)
    };
}
 
//
// sequence
//
template< typename... Clauses >
[[nodiscard]]
auto
sequence( Clauses &&... clauses )
{
    static_assert( 0 != sizeof...(clauses),
            "list of clauses can't be empty" );
    static_assert( meta::all_of_v< impl::is_clause, Clauses... >,
            "all arguments for sequence() should be clauses" );
 
    using clause_type_t = impl::sequence_clause_t<
            impl::tuple_of_entities_t< Clauses... > >;
 
    return clause_type_t{
            std::make_tuple(std::forward<Clauses>(clauses)...)
    };
}
 
//
// force_only_this_alternative
//
template< typename... Clauses >
[[nodiscard]]
auto
force_only_this_alternative( Clauses &&... clauses )
{
    static_assert( 0 != sizeof...(clauses),
            "list of clauses can't be empty" );
    static_assert( meta::all_of_v< impl::is_clause, Clauses... >,
            "all arguments for force_only_this_alternative() should "
            "be clauses" );
 
    using clause_type_t = impl::forced_alternative_clause_t<
            impl::tuple_of_entities_t< Clauses... > >;
 
    return clause_type_t{
            std::make_tuple(std::forward<Clauses>(clauses)...)
    };
}
 
//
// repeat
//
template<
    typename... Clauses >
[[nodiscard]]
auto
repeat(
    std::size_t min_occurences,

    std::size_t max_occurences,
    Clauses &&... clauses )
{
    static_assert( 0 != sizeof...(clauses),
            "list of clauses can't be empty" );
    static_assert( meta::all_of_v< impl::is_clause, Clauses... >,
            "all arguments for repeat() should be clauses" );
 
    using producer_type_t = impl::repeat_clause_t<
            impl::tuple_of_entities_t<Clauses...> >;
 
    return producer_type_t{
            min_occurences,
            max_occurences,
            std::make_tuple(std::forward<Clauses>(clauses)...)
    };
}
 
//
// skip
//
[[nodiscard]]
inline auto
skip() noexcept { return impl::any_value_skipper_t{}; }
 
//
// any_symbol_p
//
[[nodiscard]]
inline auto
any_symbol_p() noexcept
{
    return impl::symbol_producer_template_t<impl::any_symbol_predicate_t>{};
}
 
//
// symbol_p
//
[[nodiscard]]
inline auto
symbol_p( char expected ) noexcept
{
    return impl::symbol_producer_t{expected};
}
 
//
// any_symbol_if_not_p
//
[[nodiscard]]
inline auto
any_symbol_if_not_p( char sentinel ) noexcept
{
    return impl::any_symbol_if_not_producer_t{sentinel};
}
 
//
// caseless_symbol_p
//
[[nodiscard]]
inline auto
caseless_symbol_p( char expected ) noexcept
{
    return impl::caseless_symbol_producer_t{expected};
}
 
//
// symbol_from_range_p
//
[[nodiscard]]
inline auto
symbol_from_range_p( char left, char right ) noexcept
{
    return impl::symbol_from_range_producer_t{left, right};
}
 
//
// symbol
//
[[nodiscard]]
inline auto
symbol( char expected ) noexcept
{
    return symbol_p(expected) >> skip();
}
 
//
// caseless_symbol
//
[[nodiscard]]
inline auto
caseless_symbol( char expected ) noexcept
{
    return caseless_symbol_p(expected) >> skip();
}
 
//
// symbol_from_range
//
[[nodiscard]]
inline auto
symbol_from_range( char left, char right ) noexcept
{
    return symbol_from_range_p(left, right) >> skip();
}
 
//
// space_p
//
[[nodiscard]]
inline auto
space_p() noexcept
{
    return impl::symbol_producer_template_t< impl::is_space_predicate_t >{};
}
 
//
// space
//
[[nodiscard]]
inline auto
space() noexcept
{
    return space_p() >> skip();
}
 
//
// digit_p
//
[[nodiscard]]
inline auto
digit_p() noexcept
{
    return impl::digit_producer_t{};
}
 
//
// digit
//
[[nodiscard]]
inline auto
digit() noexcept
{
    return digit_p() >> skip();
}
 
//
// hexdigit_p
//
[[nodiscard]]
inline auto
hexdigit_p() noexcept
{
    return impl::hexdigit_producer_t{};
}
 
//
// hexdigit
//
[[nodiscard]]
inline auto
hexdigit() noexcept
{
    return hexdigit_p() >> skip();
}
 
//
// non_negative_decimal_number_p
//
template< typename T >
[[nodiscard]]
inline auto
non_negative_decimal_number_p() noexcept
{
    return impl::non_negative_decimal_number_producer_t<T>{};
}
 
//
// non_negative_decimal_number_p
//
template< typename T >
[[nodiscard]]
inline auto
non_negative_decimal_number_p( digits_to_consume_t digits_limit ) noexcept
{
    return impl::non_negative_decimal_number_producer_with_digits_limit_t<T>{
            digits_limit
    };
}
 
//
// hexadecimal_number_p
//
template< typename T >
[[nodiscard]]
inline auto
hexadecimal_number_p() noexcept
{
    return impl::hexadecimal_number_producer_t<T>{};
}
 
//
// hexadecimal_number_p
//
template< typename T >
[[nodiscard]]
inline auto
hexadecimal_number_p( digits_to_consume_t digits_limit ) noexcept
{
    return impl::hexadecimal_number_producer_with_digits_limit_t<T>{
            digits_limit
    };
}
 
//
// decimal_number_p
//
template< typename T >
[[nodiscard]]
inline auto
decimal_number_p() noexcept
{
    static_assert( std::is_signed<T>::value,
            "decimal_number_p() can be used only for signed numeric types" );
 
    return impl::decimal_number_producer_t<T>{};
}
 
//
// decimal_number_p
//
template< typename T >
[[nodiscard]]
inline auto
decimal_number_p( digits_to_consume_t digits_limit ) noexcept
{
    static_assert( std::is_signed<T>::value,
            "decimal_number_p() can be used only for signed numeric types" );
 
    return impl::decimal_number_producer_with_digits_limit_t<T>{
            digits_limit
    };
}
 
//
// as_result
//
[[nodiscard]]
inline auto
as_result() noexcept { return impl::as_result_consumer_t{}; }
 
//
// custom_consumer
//
template< typename F >
[[nodiscard]]
auto
custom_consumer( F consumer )
{
    using actual_consumer_t = impl::custom_consumer_t< F >;
 
    return actual_consumer_t{ std::move(consumer) };
}
 
namespace impl
{
 
//
// to_container_consumer_t
//
struct to_container_consumer_t : public consumer_tag
{
    template< typename Container, typename Item >
    void
    consume( Container & to, Item && item )
    {
        using container_adaptor_type = result_wrapper_for_t<Container>;
        container_adaptor_type::to_container( to, std::move(item) );
    }
};
 
} /* namespace impl */
 
//
// to_container
//
[[nodiscard]]
inline auto
to_container()
{
    return impl::to_container_consumer_t();
}
 
//
// to_lower
//
[[nodiscard]]
inline auto
to_lower() noexcept { return impl::to_lower_transformer_proxy_t{}; }
 
//
// just
//
template< typename T >
[[nodiscard]]
auto
just( T value ) noexcept(noexcept(impl::just_value_transformer_t<T>{value}))
{
    return impl::just_value_transformer_t<T>{value};
}
 
//
// just_result
//
template< typename T >
[[nodiscard]]
auto
just_result( T value )
    noexcept(noexcept(impl::just_result_consumer_t<T>{value}))
{
    return impl::just_result_consumer_t<T>{value};
}
 
//
// convert
//
template< typename Converter >
[[nodiscard]]
auto
convert( Converter && converter )
{
    using converter_type = std::decay_t<Converter>;
 
    using transformer_proxy_type = impl::convert_transformer_proxy_t<
            converter_type >;
 
    return transformer_proxy_type{ std::forward<Converter>(converter) };
}
 
//
// exact_p
//
[[nodiscard]]
inline auto
exact_p( string_view_t fragment )
{
    return impl::exact_fragment_producer_t{
            std::string{ fragment.data(), fragment.size() }
        };
}

template< std::size_t Size >
[[nodiscard]]
auto
exact_p( const char (&fragment)[Size] )
{
    return impl::exact_fixed_size_fragment_producer_t<Size>{ fragment };
}
 
//
// exact
//
[[nodiscard]]
inline auto
exact( string_view_t fragment )
{
    return impl::exact_fragment_producer_t{
            std::string{ fragment.data(), fragment.size() }
        } >> skip();
}

template< std::size_t Size >
[[nodiscard]]
auto
exact( const char (&fragment)[Size] )
{
    return impl::exact_fixed_size_fragment_producer_t<Size>{ fragment } >> skip();
}
 
//
// caseless_exact_p
//
[[nodiscard]]
inline auto
caseless_exact_p( string_view_t fragment )
{
    return impl::caseless_exact_fragment_producer_t{
            std::string{ fragment.data(), fragment.size() }
        };
}

template< std::size_t Size >
[[nodiscard]]
auto
caseless_exact_p( const char (&fragment)[Size] )
{
    return impl::caseless_exact_fixed_size_fragment_producer_t<Size>{ fragment };
}
 
//
// caseless_exact
//
[[nodiscard]]
inline auto
caseless_exact( string_view_t fragment )
{
    return impl::caseless_exact_fragment_producer_t{
            std::string{ fragment.data(), fragment.size() }
        } >> skip();
}

template< std::size_t Size >
[[nodiscard]]
auto
caseless_exact( const char (&fragment)[Size] )
{
    return impl::caseless_exact_fixed_size_fragment_producer_t<Size>{ fragment } >> skip();
}
 
//
// try_parse
//
template< typename Producer >
[[nodiscard]]
expected_t< typename Producer::result_type, parse_error_t >
try_parse(
    string_view_t from,
    Producer producer )
{
    static_assert( impl::is_producer_v<Producer>,
            "Producer should be a value producer type" );
 
    from = impl::remove_trailing_spaces( from );
    impl::source_t source{ from };
 
    auto result = impl::top_level_clause_t< Producer >{ std::move(producer) }
            .try_process( source );
 
    if( result )
    {
        // We should ensure that all content has been consumed.
        const auto all_content_check =
                impl::ensure_no_remaining_content( source );
        if( all_content_check )
            return make_unexpected( *all_content_check );
    }
 
    return result;
}
 
//
// make_error_description
//
[[nodiscard]]
inline std::string
make_error_description(
    const parse_error_t & error,
    string_view_t from )
{
    const auto append_quote = [&]( std::string & dest ) {
        constexpr std::size_t max_quote_size = 16u;
        if( error.position() > 0u )
        {
            // How many chars we can get from right of error position?
            const auto prefix_size = error.position() > max_quote_size ?
                    max_quote_size : error.position();
 
            dest.append( 1u, '"' );
            dest.append(
                    &from[ error.position() ] - prefix_size,
                    prefix_size );
            dest.append( "\" >>> " );
        }
 
        const char problematic_symbol = error.position() < from.size() ?
                from[ error.position() ] : '?';
        dest.append( 1u, '\'' );
        if( problematic_symbol >= '\x00' && problematic_symbol < ' ' )
        {
            constexpr char hex_digits[] = "0123456789abcdef";
 
            dest.append( "\\x" );
            dest.append( 1u, hex_digits[
                    static_cast<unsigned char>(problematic_symbol) >> 4 ] );
            dest.append( 1u, hex_digits[
                    static_cast<unsigned char>(problematic_symbol) & 0xfu ] );
        }
        else
            dest.append( 1u, problematic_symbol );
 
        dest.append( 1u, '\'' );
 
        if( error.position() + 1u < from.size() )
        {
            // How many chars we can get from the right of error position?
            const auto suffix_size =
                    error.position() + 1u + max_quote_size < from.size() ?
                    max_quote_size : from.size() - error.position() - 1u;
 
            dest.append( " <<< \"" );
            dest.append( &from[ error.position() + 1u ], suffix_size );
            dest.append( 1u, '"' );
        }
    };
 
    std::string result;
 
    const auto basic_reaction = [&](const char * msg) {
        result += msg;
        result += " at ";
        result += std::to_string( error.position() );
        result += ": ";
        append_quote( result );
    };
 
    switch( error.reason() )
    {
        case error_reason_t::unexpected_character:
            basic_reaction( "unexpected character" );
        break;
 
        case error_reason_t::unexpected_eof:
            result += "unexpected EOF at ";
            result += std::to_string( error.position() );
        break;
 
        case error_reason_t::no_appropriate_alternative:
            basic_reaction( "appropriate alternative can't found" );
        break;
 
        case error_reason_t::pattern_not_found:
            basic_reaction( "expected pattern is not found" );
        break;
 
        case error_reason_t::unconsumed_input:
            basic_reaction( "unconsumed input found" );
        break;
 
        case error_reason_t::illegal_value_found:
            basic_reaction( "some illegal value found" );
        break;
 
        case error_reason_t::force_only_this_alternative_failed:
            basic_reaction( "forced selection alternative failed" );
        break;
    }
 
    return result;
}
 
} /* namespace easy_parser */
 
} /* namespace restinio */