restinio::easy_parser Namespace Reference

## Namespaces

namespace | impl

## Classes

class | digits_to_consume_t
| Limits for number of digits to be extracted during parsing of decimal numbers. More...
struct | nothing_t
| A special type to be used in the case where there is no need to store produced value. More...
class | parse_error_t
| Information about parsing error. More...
struct | result_value_wrapper
| A template with specializations for different kind of result values and for type `nothing`. More...
struct | result_value_wrapper< nothing_t >
struct | result_value_wrapper< std::array< T, S > >
struct | result_value_wrapper< std::basic_string< Char, Args... > >
struct | result_value_wrapper< std::map< K, V, Args... > >
struct | result_value_wrapper< std::vector< T, Args... > >
struct | result_wrapper_for
| A metafunction for detection of actual result_value_wrapper type for T. More...
struct | result_wrapper_for< impl::std_array_wrapper< T, S > >
| A specialization of result_wrapper_for metafunction for the case of std::array wrapper. More...

## Typedefs

template<typename T >
using | result_wrapper_for_t = typename result_wrapper_for< T >::type

## Enumerations

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 }
| Reason of parsing error. More...

## Functions

RESTINIO_NODISCARD constexpr digits_to_consume_t | expected_digits (digits_to_consume_t::underlying_int_t total) noexcept
| Create a limit for number of digits to be extracted. More...
RESTINIO_NODISCARD constexpr digits_to_consume_t | expected_digits (digits_to_consume_t::underlying_int_t min, digits_to_consume_t::underlying_int_t max) noexcept
| Create a limit for number of digits to be extracted. More...
template<typename Target_Type , typename... Clauses>
RESTINIO_NODISCARD auto | produce (Clauses &&... clauses)
| A factory function to create a producer that creates an instance of the target type by using specified clauses. More...
template<typename... Clauses>
RESTINIO_NODISCARD auto | alternatives (Clauses &&... clauses)
| A factory function to create an alternatives clause. More...
template<typename... Clauses>
RESTINIO_NODISCARD auto | maybe (Clauses &&... clauses)
| A factory function to create an optional clause. More...
template<typename... Clauses>
RESTINIO_NODISCARD auto | not_clause (Clauses &&... clauses)
| A factory function to create a not_clause. More...
template<typename... Clauses>
RESTINIO_NODISCARD auto | and_clause (Clauses &&... clauses)
| A factory function to create an and_clause. More...
template<typename... Clauses>
RESTINIO_NODISCARD auto | sequence (Clauses &&... clauses)
| A factory function to create a sequence of subclauses. More...
template<typename... Clauses>
RESTINIO_NODISCARD auto | force_only_this_alternative (Clauses &&... clauses)
| An alternative that should be parsed correctly or the parsing of the whole alternatives clause should fail. More...
template<typename... Clauses>
RESTINIO_NODISCARD auto | repeat (std::size_t min_occurences, std::size_t max_occurences, Clauses &&... clauses)
| A factory function to create repetitor of subclauses. More...
RESTINIO_NODISCARD auto | skip () noexcept
| A factory function to create a skip_consumer. More...
RESTINIO_NODISCARD auto | any_symbol_p () noexcept
| A factory function to create an any_symbol_producer. More...
RESTINIO_NODISCARD auto | symbol_p (char expected) noexcept
| A factory function to create a symbol_producer. More...
RESTINIO_NODISCARD auto | any_symbol_if_not_p (char sentinel) noexcept
| A factory function to create a any_symbol_if_not_producer. More...
RESTINIO_NODISCARD auto | caseless_symbol_p (char expected) noexcept
| A factory function to create a caseless_symbol_producer. More...
RESTINIO_NODISCARD auto | symbol_from_range_p (char left, char right) noexcept
| A factory function to create a symbol_from_range_producer. More...
RESTINIO_NODISCARD auto | symbol (char expected) noexcept
| A factory function to create a clause that expects the speficied symbol, extracts it and then skips it. More...
RESTINIO_NODISCARD auto | caseless_symbol (char expected) noexcept
| A factory function to create a clause that expects the speficied symbol, extracts it and then skips it. More...
RESTINIO_NODISCARD auto | symbol_from_range (char left, char right) noexcept
| A factory function to create a clause that expects a symbol from specified range, extracts it and then skips it. More...
RESTINIO_NODISCARD auto | space_p () noexcept
| A factory function to create a space_producer. More...
RESTINIO_NODISCARD auto | space () noexcept
| A factory function to create a clause that expects a space, extracts it and then skips it. More...
RESTINIO_NODISCARD auto | digit_p () noexcept
| A factory function to create a digit_producer. More...
RESTINIO_NODISCARD auto | digit () noexcept
| A factory function to create a clause that expects a decimal digit, extracts it and then skips it. More...
RESTINIO_NODISCARD auto | hexdigit_p () noexcept
| A factory function to create a hexdigit_producer. More...
RESTINIO_NODISCARD auto | hexdigit () noexcept
| A factory function to create a clause that expects a hexadecimal digit, extracts it and then skips it. More...
template<typename T >
RESTINIO_NODISCARD auto | non_negative_decimal_number_p () noexcept
| A factory function to create a non_negative_decimal_number_producer. More...
template<typename T >
RESTINIO_NODISCARD auto | non_negative_decimal_number_p (digits_to_consume_t digits_limit) noexcept
| A factory function to create a non_negative_decimal_number_producer. More...
template<typename T >
RESTINIO_NODISCARD auto | positive_decimal_number_producer () noexcept
| A factory function to create a producer for non-negative decimal numbers. More...
template<typename T >
RESTINIO_NODISCARD auto | hexadecimal_number_p () noexcept
| A factory function to create a hexadecimal_number_producer. More...
template<typename T >
RESTINIO_NODISCARD auto | hexadecimal_number_p (digits_to_consume_t digits_limit) noexcept
| A factory function to create a hexadecimal_number_producer. More...
template<typename T >
RESTINIO_NODISCARD auto | decimal_number_p () noexcept
| A factory function to create a decimal_number_producer. More...
template<typename T >
RESTINIO_NODISCARD auto | decimal_number_p (digits_to_consume_t digits_limit) noexcept
| A factory function to create a decimal_number_producer. More...
RESTINIO_NODISCARD auto | as_result () noexcept
| A factory function to create a as_result_consumer. More...
template<typename F >
RESTINIO_NODISCARD auto | custom_consumer (F consumer)
| A factory function to create a custom_consumer. More...
RESTINIO_NODISCARD auto | to_container ()
| A factory function to create a to_container_consumer. More...
RESTINIO_NODISCARD auto | to_lower () noexcept
| A factory function to create a to_lower_transformer. More...
template<typename T >
RESTINIO_NODISCARD auto | just (T value) noexcept(noexcept(impl::just_value_transformer_t< T >{value}))
| A special transformer that replaces the produced value by a value specified by a user. More...
template<typename T >
RESTINIO_NODISCARD auto | just_result (T value) noexcept(noexcept(impl::just_result_consumer_t< T >{value}))
| A special consumer that replaces the produced value by a value specified by a user and sets that user-specified value as the result. More...
template<typename Converter >
RESTINIO_NODISCARD auto | convert (Converter &&converter)
| A factory function to create convert_transformer. More...
RESTINIO_NODISCARD auto | exact_p (string_view_t fragment)
| A factory function that creates an instance of exact_fragment_producer. More...
template<std::size_t Size>
RESTINIO_NODISCARD auto | exact_p (const char(&fragment)[Size])
| A factory function that creates an instance of exact_fragment_producer. More...
RESTINIO_NODISCARD auto | exact (string_view_t fragment)
| A factory function that creates an instance of exact_fragment clause. More...
template<std::size_t Size>
RESTINIO_NODISCARD auto | exact (const char(&fragment)[Size])
| A factory function that creates an instance of exact_fragment clause. More...
RESTINIO_NODISCARD auto | caseless_exact_p (string_view_t fragment)
| A factory function that creates an instance of caseless_exact_fragment_producer. More...
template<std::size_t Size>
RESTINIO_NODISCARD auto | caseless_exact_p (const char(&fragment)[Size])
| A factory function that creates an instance of caseless_exact_fragment_producer. More...
RESTINIO_NODISCARD auto | caseless_exact (string_view_t fragment)
| A factory function that creates an instance of caseless_exact_fragment clause. More...
template<std::size_t Size>
RESTINIO_NODISCARD auto | caseless_exact (const char(&fragment)[Size])
| A factory function that creates an instance of caseless_exact_fragment clause. More...
template<typename Producer >
RESTINIO_NODISCARD expected_t< typename Producer::result_type, parse_error_t > | try_parse (string_view_t from, Producer producer)
| Perform the parsing of the specified content by using specified value producer. More...
RESTINIO_NODISCARD std::string | make_error_description (const parse_error_t &error, string_view_t from)
| Make textual description of error returned by try_parse function. More...

## Variables

constexpr std::size_t | N = std::numeric_limits<std::size_t>::max()
| A special marker that means infinite repetitions. More...

## Typedef Documentation

## result_wrapper_for_t

template<typename T >

using restinio::easy_parser::result_wrapper_for_t = typedef typename result_wrapper_for<T>::type

Definition at line 250 of file easy_parser.hpp.

## Enumeration Type Documentation

## error_reason_t

enum class restinio::easy_parser::error_reason_t

strong

Reason of parsing error.

Since
  v.0.6.1

Enumerator
unexpected_character | Unexpected character is found in the input.
unexpected_eof | Unexpected end of input is encontered when some character expected.
no_appropriate_alternative | None of alternatives was found in the input.
pattern_not_found | Required pattern is not found in the input.
unconsumed_input | There are some unconsumed non-whitespace characters in the input after the completion of parsing.

illegal_value_found

Illegal value was found in the input.

Since
  v.0.6.2

force_only_this_alternative_failed

A failure of parsing an alternative marked as "force only this alternative".

This error code is intended for internal use for the implementation of alternatives() and force_only_this_alternative() stuff.

This error tells the parser that other alternatives should not be checked and the parsing of the whole alternatives clause should failed too.

Since
  v.0.6.7

Definition at line 51 of file easy_parser.hpp.

## Function Documentation

## alternatives()

template<typename... Clauses>

RESTINIO_NODISCARD auto restinio::easy_parser::alternatives | ( | Clauses &&... | clauses | ) |

A factory function to create an alternatives clause.

Usage example:

produce<std::string>(
alternatives(
sequence(symbol('v'), symbol('='), token_p() >> as_result()),
sequence(symbol('T'), symbol('/'), token_p() >> as_result())
)
);
restinio::easy_parser::symbol
RESTINIO_NODISCARD auto symbol(char expected) noexcept
A factory function to create a clause that expects the speficied symbol, extracts it and then skips i...
Definition: easy_parser.hpp:4032
restinio::easy_parser::sequence
RESTINIO_NODISCARD auto sequence(Clauses &&... clauses)
A factory function to create a sequence of subclauses.
Definition: easy_parser.hpp:3758
restinio::easy_parser::as_result
RESTINIO_NODISCARD auto as_result() noexcept
A factory function to create a as_result_consumer.
Definition: easy_parser.hpp:4470
restinio::easy_parser::alternatives
RESTINIO_NODISCARD auto alternatives(Clauses &&... clauses)
A factory function to create an alternatives clause.
Definition: easy_parser.hpp:3595
restinio::http_field_parsers::token_p
RESTINIO_NODISCARD auto token_p() noexcept
A factory function to create a token_producer.
Definition: basics.hpp:985

Please note the usage of sequence() inside the call to alternatives().

Template Parameters

  Clauses | the list of clauses to be used as alternatives.

Since
  v.0.6.1

Definition at line 3595 of file easy_parser.hpp.

## and_clause()

template<typename... Clauses>

RESTINIO_NODISCARD auto restinio::easy_parser::and_clause | ( | Clauses &&... | clauses | ) |

A factory function to create an and_clause.

Usage example:

produce<std::pair<std::string, std::string>>(
token_p() >> &std::pair<std::string, std::string>::first,
symbol(' '),
token_p() >> &std::pair<std::string, std::string>::second
and_clause(symbol(','), maybe(symbol(' ')), token_p() >> skip())
);
restinio::easy_parser::maybe
RESTINIO_NODISCARD auto maybe(Clauses &&... clauses)
A factory function to create an optional clause.
Definition: easy_parser.hpp:3634
restinio::easy_parser::and_clause
RESTINIO_NODISCARD auto and_clause(Clauses &&... clauses)
A factory function to create an and_clause.
Definition: easy_parser.hpp:3718
restinio::easy_parser::skip
RESTINIO_NODISCARD auto skip() noexcept
A factory function to create a skip_consumer.
Definition: easy_parser.hpp:3922

this expression corresponds the following rule:

    T := token SP token &(',' [' '] token)

Template Parameters

  Clauses | the list of clauses to be used as sequence to be checked.

Since
  v.0.6.1

Definition at line 3718 of file easy_parser.hpp.

## any_symbol_if_not_p()

RESTINIO_NODISCARD auto restinio::easy_parser::any_symbol_if_not_p | ( | char | sentinel | ) |

inline noexcept

A factory function to create a any_symbol_if_not_producer.

Returns
  a producer that expects any character except sentinel in the input stream and returns it if that character is found.

Since
  v.0.6.6

Definition at line 3973 of file easy_parser.hpp.

## any_symbol_p()

RESTINIO_NODISCARD auto restinio::easy_parser::any_symbol_p | ( |  | ) |

inline noexcept

A factory function to create an any_symbol_producer.

Returns
  a producer that expects any symbol in the input stream and returns it.

Since
  v.0.6.6

Definition at line 3937 of file easy_parser.hpp.

## as_result()

RESTINIO_NODISCARD auto restinio::easy_parser::as_result | ( |  | ) |

inline noexcept

A factory function to create a as_result_consumer.

Usage example:

produce<std::string>(
symbol('v'),
symbol('='),
token_p() >> as_result(),
symbol('.')
);

Since
  v.0.6.1

Definition at line 4470 of file easy_parser.hpp.

## caseless_exact() [1/2]

template<std::size_t Size>

RESTINIO_NODISCARD auto restinio::easy_parser::caseless_exact | ( | const char(&) | fragment[Size] | ) |

A factory function that creates an instance of caseless_exact_fragment clause.

Usage example:

produce<std::string>(caseless_exact("version="), token() >> as_result());
restinio::easy_parser::caseless_exact
RESTINIO_NODISCARD auto caseless_exact(string_view_t fragment)
A factory function that creates an instance of caseless_exact_fragment clause.
Definition: easy_parser.hpp:4962

Attention
  This version is dedicated to be used with string literals. Because of that the last byte from a literal will be ignored (it's assumed that this byte contains zero). But this behavior would lead to unexpected results in such cases:
  const char prefix[]{ 'v', 'e', 'r', 's', 'i', 'o', 'n', '=' };
  produce<std::string>(caseless_exact(prefix), token() >> as_result());
  because the last byte with value '=' will be ignored by exact_producer. To avoid such behavior string_view_t should be used explicitely:
  produce<std::string>(caseless_exact(string_view_t{prefix}), token() >> as_result());
  restinio::string_view_t
  nonstd::string_view string_view_t
  Definition: string_view.hpp:19

Since
  v.0.6.9

Definition at line 5000 of file easy_parser.hpp.

## caseless_exact() [2/2]

RESTINIO_NODISCARD auto restinio::easy_parser::caseless_exact | ( | string_view_t | fragment | ) |

inline

A factory function that creates an instance of caseless_exact_fragment clause.

Usage example:

produce<std::string>(caseless_exact("version="), token() >> as_result());

Since
  v.0.6.9

Definition at line 4962 of file easy_parser.hpp.

## caseless_exact_p() [1/2]

template<std::size_t Size>

RESTINIO_NODISCARD auto restinio::easy_parser::caseless_exact_p | ( | const char(&) | fragment[Size] | ) |

A factory function that creates an instance of caseless_exact_fragment_producer.

Usage example:

produce<std::string>(
alternatives(
caseless_exact_p("pro") >> just_result("Professional"),
caseless_exact_p("con") >> just_result("Consumer")
)
);
restinio::easy_parser::just_result
RESTINIO_NODISCARD auto just_result(T value) noexcept(noexcept(impl::just_result_consumer_t< T >{value}))
A special consumer that replaces the produced value by a value specified by a user and sets that user...
Definition: easy_parser.hpp:4664
restinio::easy_parser::caseless_exact_p
RESTINIO_NODISCARD auto caseless_exact_p(string_view_t fragment)
A factory function that creates an instance of caseless_exact_fragment_producer.
Definition: easy_parser.hpp:4897

Attention
  This version is dedicated to be used with string literals. Because of that the last byte from a literal will be ignored (it's assumed that this byte contains zero). But this behavior would lead to unexpected results in such cases:
  const char prefix[]{ 'h', 'e', 'l', 'l', 'o' };
  produce<std::string>(caseless_exact_p(prefix) >> just_result("Hi!"));
  because the last byte with value 'o' will be ignored by exact_producer. To avoid such behavior string_view_t should be used explicitely:
  produce<std::string>(caseless_exact_p(string_view_t{prefix})
  >> just_result("Hi!"));

Since
  v.0.6.9

Definition at line 4941 of file easy_parser.hpp.

## caseless_exact_p() [2/2]

RESTINIO_NODISCARD auto restinio::easy_parser::caseless_exact_p | ( | string_view_t | fragment | ) |

inline

A factory function that creates an instance of caseless_exact_fragment_producer.

Usage example:

produce<std::string>(
alternatives(
caseless_exact_p("pro") >> just_result("Professional"),
caseless_exact_p("con") >> just_result("Consumer")
)
);

Since
  v.0.6.9

Definition at line 4897 of file easy_parser.hpp.

## caseless_symbol()

RESTINIO_NODISCARD auto restinio::easy_parser::caseless_symbol | ( | char | expected | ) |

inline noexcept

A factory function to create a clause that expects the speficied symbol, extracts it and then skips it.

This clause performs caseless comparison of characters.

The call to ‘caseless_symbol('a’)` function is an equivalent of:

caseless_symbol_p('a') >> skip()
restinio::easy_parser::caseless_symbol_p
RESTINIO_NODISCARD auto caseless_symbol_p(char expected) noexcept
A factory function to create a caseless_symbol_producer.
Definition: easy_parser.hpp:3993

Since
  v.0.6.6

Definition at line 4055 of file easy_parser.hpp.

## caseless_symbol_p()

RESTINIO_NODISCARD auto restinio::easy_parser::caseless_symbol_p | ( | char | expected | ) |

inline noexcept

A factory function to create a caseless_symbol_producer.

This producer performs caseless comparison of characters.

Returns
  a producer that expects expected in the input stream and returns it if that character is found.

Since
  v.0.6.6

Definition at line 3993 of file easy_parser.hpp.

## convert()

template<typename Converter >

RESTINIO_NODISCARD auto restinio::easy_parser::convert | ( | Converter && | converter | ) |

A factory function to create convert_transformer.

Usage example:

// Parser for:
// size := DIGIT+ [multiplier]
// multiplier := ('b'|'B') | ('k'|'K') | ('m'|'M')
struct tmp_size { std::uint32_t c_{1u}; std::uint32_t m_{1u}; };
auto size_producer = produce<std::uint64_t>(
produce<tmp_size>(
non_negative_decimal_number_p<std::uint32_t>() >> &tmp_size::c_,
maybe(
produce<std::uint32_t>(
alternatives(
caseless_symbol_p('b') >> just_result(1u),
caseless_symbol_p('k') >> just_result(1024u),
caseless_symbol_p('m') >> just_result(1024u*1024u)
)
) >> &tmp_size::m_
)
)
>> convert( [](const tmp_size & ts) { return std::uint64_t{ts.c_} * ts.m_; } )
>> as_result()
);
restinio::easy_parser::convert
RESTINIO_NODISCARD auto convert(Converter &&converter)
A factory function to create convert_transformer.
Definition: easy_parser.hpp:4737

Note
  Since v.0.6.11 a conversion function can have two formats. The first one is:
  result_type fn(input_type source_val);
  for example:
  convert([](const std::string & from) -> int {...})
  in that case a conversion error can only be reported via an exception. The second one is:
  expected_t<result_type, error_reason_t> fn(input_type source_val);
  restinio::expected_t
  nonstd::expected< T, E > expected_t
  Definition: expected.hpp:22
  for example:
  convert([](const std::string & from) -> expected_t<int, error_reason_t> {...})
  in that case a converion error can be reported also via returning value. For example, let's assume that in the code snippet shown above the result value should be greater than 0. It can be checked in the conversion function that way:
  convert([](const tmp_size & ts) -> expected_t<std::uint64_t, error_reason_t> {
  const auto r = std::uint64_t{ts.c_} * ts.m_;
  if( r )
  return r;
  else
  return make_unexpected(error_reason_t::illegal_value_found);
  }
  restinio::easy_parser::error_reason_t::illegal_value_found
  @ illegal_value_found
  Illegal value was found in the input.

Since
  v.0.6.6

Definition at line 4737 of file easy_parser.hpp.

## custom_consumer()

template<typename F >

RESTINIO_NODISCARD auto restinio::easy_parser::custom_consumer | ( | F | consumer | ) |

A factory function to create a custom_consumer.

Usage example:

class composed_value {
std::string name_;
std::string value_;
public:
composed_value() = default;
void set_name(std::string name) { name_ = std::move(name); }
void set_value(std::string value) { value_ = std::move(value); }
...
};
produce<composed_value>(
token_p() >> custom_consumer(
[](composed_value & to, std::string && what) {
to.set_name(std::move(what));
} ),
symbol('='),
token_p() >> custom_consumer(
[](composed_value & to, std::string && what) {
to.set_value(std::move(what));
} ),
symbol('.')
);
nonstd::optional_lite::std11::move
T & move(T &t)
Definition: optional.hpp:465
restinio::easy_parser::custom_consumer
RESTINIO_NODISCARD auto custom_consumer(F consumer)
A factory function to create a custom_consumer.
Definition: easy_parser.hpp:4516

Note
  A custom consumer should be a function/lambda/function objects with the following prototype:
  void(Target_Type & destination, Value && value);

Since
  v.0.6.1

Definition at line 4516 of file easy_parser.hpp.

## decimal_number_p() [1/2]

template<typename T >

RESTINIO_NODISCARD auto restinio::easy_parser::decimal_number_p | ( |  | ) |

inline noexcept

A factory function to create a decimal_number_producer.

Parses numbers in the form:

    number := [sign] DIGIT+
    sign   := '-' | '+'

Note
  This parser consumes all digits until the first non-digit symbol will be found in the input. It means that in the case of `-1111someword` the leading minus sign and thefirst four digits (e.g. `-1111`) will be extracted from the input and the remaining part (e.g. `someword`) won't be consumed by this parser.

Attention
  Can be used only for singed number types (e.g. short, int, long, std::int32_t and so on).

Returns
  a producer that expects a decimal number in the input stream and returns it if a number is found.

Since
  v.0.6.6

Definition at line 4387 of file easy_parser.hpp.

## decimal_number_p() [2/2]

template<typename T >

RESTINIO_NODISCARD auto restinio::easy_parser::decimal_number_p | ( | digits_to_consume_t | digits_limit | ) |

inline noexcept

A factory function to create a decimal_number_producer.

Parses numbers in the form:

    number := [sign] DIGIT+
    sign   := '-' | '+'

Note
  This parser consumes a number of digits with respect to digits_limit. The leading sign (if present) is not added to a number of extracted digits.

Usage example:

using namespace restinio::easy_parser;
struct compound_number {
short prefix_;
int suffix_;
};
auto parse = produce<compound_number>(
decimal_number_p<short>(expected_digits(4))
>> &compound_number::prefix_,
decimal_number_p<int>(expected_digits(7, 12))
>> &compound_number::suffix_
);
restinio::easy_parser
Definition: easy_parser.hpp:39
restinio::easy_parser::expected_digits
RESTINIO_NODISCARD constexpr digits_to_consume_t expected_digits(digits_to_consume_t::underlying_int_t total) noexcept
Create a limit for number of digits to be extracted.
Definition: easy_parser.hpp:549
restinio::path2regex::impl::parse
token_list_t< Route_Param_Appender > parse(string_view_t route_sv, const options_t &options)
Parse a string for the raw tokens.
Definition: path2regex.hpp:676

Attention
  Can be used only for singed number types (e.g. short, int, long, std::int32_t and so on).

Returns
  a producer that expects a decimal number in the input stream and returns it if a number is found.

Since
  v.0.6.6

Definition at line 4440 of file easy_parser.hpp.

## digit()

RESTINIO_NODISCARD auto restinio::easy_parser::digit | ( |  | ) |

inline noexcept

A factory function to create a clause that expects a decimal digit, extracts it and then skips it.

The call to `digit()` function is an equivalent of:

digit_p() >> skip()
restinio::easy_parser::digit_p
RESTINIO_NODISCARD auto digit_p() noexcept
A factory function to create a digit_producer.
Definition: easy_parser.hpp:4133

Since
  v.0.6.6

Definition at line 4154 of file easy_parser.hpp.

## digit_p()

RESTINIO_NODISCARD auto restinio::easy_parser::digit_p | ( |  | ) |

inline noexcept

A factory function to create a digit_producer.

Returns
  a producer that expects a decimal digit in the input stream and returns it if a decimal digit is found.

Since
  v.0.6.1

Definition at line 4133 of file easy_parser.hpp.

## exact() [1/2]

template<std::size_t Size>

RESTINIO_NODISCARD auto restinio::easy_parser::exact | ( | const char(&) | fragment[Size] | ) |

A factory function that creates an instance of exact_fragment clause.

Usage example:

produce<std::string>(exact("version="), token() >> as_result());
restinio::easy_parser::exact
RESTINIO_NODISCARD auto exact(string_view_t fragment)
A factory function that creates an instance of exact_fragment clause.
Definition: easy_parser.hpp:4833

Attention
  This version is dedicated to be used with string literals. Because of that the last byte from a literal will be ignored (it's assumed that this byte contains zero). But this behavior would lead to unexpected results in such cases:
  const char prefix[]{ 'v', 'e', 'r', 's', 'i', 'o', 'n', '=' };
  produce<std::string>(exact(prefix), token() >> as_result());
  because the last byte with value '=' will be ignored by exact_producer. To avoid such behavior string_view_t should be used explicitely:
  produce<std::string>(exact(string_view_t{prefix}), token() >> as_result());

Since
  v.0.6.6

Definition at line 4871 of file easy_parser.hpp.

## exact() [2/2]

RESTINIO_NODISCARD auto restinio::easy_parser::exact | ( | string_view_t | fragment | ) |

inline

A factory function that creates an instance of exact_fragment clause.

Usage example:

produce<std::string>(exact("version="), token() >> as_result());

Since
  v.0.6.6

Definition at line 4833 of file easy_parser.hpp.

## exact_p() [1/2]

template<std::size_t Size>

RESTINIO_NODISCARD auto restinio::easy_parser::exact_p | ( | const char(&) | fragment[Size] | ) |

A factory function that creates an instance of exact_fragment_producer.

Usage example:

produce<std::string>(
alternatives(
exact_p("pro") >> just_result("Professional"),
exact_p("con") >> just_result("Consumer")
)
);
restinio::easy_parser::exact_p
RESTINIO_NODISCARD auto exact_p(string_view_t fragment)
A factory function that creates an instance of exact_fragment_producer.
Definition: easy_parser.hpp:4768

Attention
  This version is dedicated to be used with string literals. Because of that the last byte from a literal will be ignored (it's assumed that this byte contains zero). But this behavior would lead to unexpected results in such cases:
  const char prefix[]{ 'h', 'e', 'l', 'l', 'o' };
  produce<std::string>(exact_p(prefix) >> just_result("Hi!"));
  because the last byte with value 'o' will be ignored by exact_producer. To avoid such behavior string_view_t should be used explicitely:
  produce<std::string>(exact_p(string_view_t{prefix})
  >> just_result("Hi!"));

Since
  v.0.6.6

Definition at line 4812 of file easy_parser.hpp.

## exact_p() [2/2]

RESTINIO_NODISCARD auto restinio::easy_parser::exact_p | ( | string_view_t | fragment | ) |

inline

A factory function that creates an instance of exact_fragment_producer.

Usage example:

produce<std::string>(
alternatives(
exact_p("pro") >> just_result("Professional"),
exact_p("con") >> just_result("Consumer")
)
);

Since
  v.0.6.6

Definition at line 4768 of file easy_parser.hpp.

## expected_digits() [1/2]

RESTINIO_NODISCARD constexpr digits_to_consume_t restinio::easy_parser::expected_digits | ( | digits_to_consume_t::underlying_int_t | min,
|  | digits_to_consume_t::underlying_int_t | max
| ) |  |

inline constexpr noexcept

Create a limit for number of digits to be extracted.

Makes a limit where min and max are specified separately.

Usage example:

using namespace restinio::easy_parser;
auto ten_digits_int32_p = decimal_number_p<std::int32_t>(expected_digits(1, 10));

Since
  v.0.6.6

Definition at line 570 of file easy_parser.hpp.

## expected_digits() [2/2]

RESTINIO_NODISCARD constexpr digits_to_consume_t restinio::easy_parser::expected_digits | ( | digits_to_consume_t::underlying_int_t | total | ) |

inline constexpr noexcept

Create a limit for number of digits to be extracted.

Makes a limit where min==max and both are equal to total.

Usage example:

using namespace restinio::easy_parser;
auto x_uint32_p = hexadecimal_number_p<std::uint32_t>(expected_digits(8));

Since
  v.0.6.6

Definition at line 549 of file easy_parser.hpp.

## force_only_this_alternative()

template<typename... Clauses>

RESTINIO_NODISCARD auto restinio::easy_parser::force_only_this_alternative | ( | Clauses &&... | clauses | ) |

An alternative that should be parsed correctly or the parsing of the whole alternatives clause should fail.

This special clause is intended to be used to avoid mistakes in grammars like that:

    v = "key" '=' token
      | token '=' 1*VCHAR

If that grammar will be used for parsing a sentence like "key=123" then the second alternative will be selected. It's because the parsing of rule `"key" '=' token` fails at `123` and the second alternative will be tried. And "key" will be recognized as a token.

Before v.0.6.7 this mistake can be avoided by using rules like those:

    v = "key" '=' token
      | !"key" token '=' 1*VCHAR

Since v.0.6.7 this mistake can be avoided by using force_only_this_alternative() function:

alternatives(
sequence(
exact("key"),
force_only_this_alternative(
symbol('='),
token() >> skip()
)
),
sequence(
token() >> skip(),
symbol('='),
repeat(1, N, vchar_symbol_p() >> skip())
)
);
restinio::easy_parser::force_only_this_alternative
RESTINIO_NODISCARD auto force_only_this_alternative(Clauses &&... clauses)
An alternative that should be parsed correctly or the parsing of the whole alternatives clause should...
Definition: easy_parser.hpp:3821
restinio::easy_parser::repeat
RESTINIO_NODISCARD auto repeat(std::size_t min_occurences, std::size_t max_occurences, Clauses &&... clauses)
A factory function to create repetitor of subclauses.
Definition: easy_parser.hpp:3876
restinio::easy_parser::N
constexpr std::size_t N
A special marker that means infinite repetitions.
Definition: easy_parser.hpp:455
restinio::http_field_parsers::vchar_symbol_p
RESTINIO_NODISCARD auto vchar_symbol_p()
A factory for producer of VCHAR symbols.
Definition: basics.hpp:832

Since
  v.0.6.7

Definition at line 3821 of file easy_parser.hpp.

## hexadecimal_number_p() [1/2]

template<typename T >

RESTINIO_NODISCARD auto restinio::easy_parser::hexadecimal_number_p | ( |  | ) |

inline noexcept

A factory function to create a hexadecimal_number_producer.

Note
  This parser consumes all digits until the first non-digit symbol will be found in the input. It means that in the case of `1111someword` the first four digits (e.g. `1111`) will be extracted from the input and the remaining part (e.g. `someword`) won't be consumed by this parser.

Attention
  T should be an unsigned type.

Returns
  a producer that expects a positive hexadecimal number in the input stream and returns it if a number is found.

Since
  v.0.6.6

Definition at line 4307 of file easy_parser.hpp.

## hexadecimal_number_p() [2/2]

template<typename T >

RESTINIO_NODISCARD auto restinio::easy_parser::hexadecimal_number_p | ( | digits_to_consume_t | digits_limit | ) |

inline noexcept

A factory function to create a hexadecimal_number_producer.

Note
  This parser consumes a number of digits with respect to digits_limit.

Usage example:

using namespace restinio::easy_parser;
struct compound_number {
short prefix_;
int suffix_;
};
auto parse = produce<compound_number>(
hexadecimal_number_p<short>(expected_digits(4))
>> &compound_number::prefix_,
hexadecimal_number_p<int>(expected_digits(7, 12))
>> &compound_number::suffix_
);

Attention
  T should be an unsigned type.

Returns
  a producer that expects a positive hexadecimal number in the input stream and returns it if a number is found.

Since
  v.0.6.6

Definition at line 4349 of file easy_parser.hpp.

## hexdigit()

RESTINIO_NODISCARD auto restinio::easy_parser::hexdigit | ( |  | ) |

inline noexcept

A factory function to create a clause that expects a hexadecimal digit, extracts it and then skips it.

The call to `hexdigit()` function is an equivalent of:

hexdigit_p() >> skip()
restinio::easy_parser::hexdigit_p
RESTINIO_NODISCARD auto hexdigit_p() noexcept
A factory function to create a hexdigit_producer.
Definition: easy_parser.hpp:4172

Since
  v.0.6.6

Definition at line 4193 of file easy_parser.hpp.

## hexdigit_p()

RESTINIO_NODISCARD auto restinio::easy_parser::hexdigit_p | ( |  | ) |

inline noexcept

A factory function to create a hexdigit_producer.

Returns
  a producer that expects a hexadecimal digit in the input stream and returns it if a hexadecimal digit is found.

Since
  v.0.6.6

Definition at line 4172 of file easy_parser.hpp.

## just()

template<typename T >

RESTINIO_NODISCARD auto restinio::easy_parser::just | ( | T | value | ) |

noexcept

A special transformer that replaces the produced value by a value specified by a user.

Usage example:

produce<unsigned int>(
alternatives(
symbol('b') >> just(1u) >> as_result(),
symbol('k') >> just(1024u) >> as_result(),
symbol('m') >> just(1024u*1024u) >> as_result()
)
);
restinio::easy_parser::just
RESTINIO_NODISCARD auto just(T value) noexcept(noexcept(impl::just_value_transformer_t< T >{value}))
A special transformer that replaces the produced value by a value specified by a user.
Definition: easy_parser.hpp:4635

Since
  v.0.6.6

Definition at line 4635 of file easy_parser.hpp.

## just_result()

template<typename T >

RESTINIO_NODISCARD auto restinio::easy_parser::just_result | ( | T | value | ) |

noexcept

A special consumer that replaces the produced value by a value specified by a user and sets that user-specified value as the result.

Usage example:

produce<unsigned int>(
alternatives(
symbol('b') >> just_result(1u),
symbol('k') >> just_result(1024u),
symbol('m') >> just_result(1024u*1024u)
)
);

Since
  v.0.6.6

Definition at line 4664 of file easy_parser.hpp.

## make_error_description()

RESTINIO_NODISCARD std::string restinio::easy_parser::make_error_description | ( | const parse_error_t & | error,
|  | string_view_t | from
| ) |  |

inline

Make textual description of error returned by try_parse function.

Note
  The format of textual description is not specified and can be changed in some future versions without notice.

Usage example:

const char * content = "first,Second;Third;Four";
const auto tokens = try_parse(
content,
produce<std::vector<std::string>>(
token_p() >> to_lower() >> to_container(),
repeat( 0, N,
alternatives(symbol(','), symbol(';')),
token_p() >> to_lower() >> to_container()
)
)
);
if(tokens)
{
for(const auto & v: *tokens)
std::cout << v << std::endl;
}
else
std::cerr << make_error_description(tokens.error(), content) << std::endl;
restinio::easy_parser::produce
RESTINIO_NODISCARD auto produce(Clauses &&... clauses)
A factory function to create a producer that creates an instance of the target type by using specifie...
Definition: easy_parser.hpp:3554
restinio::easy_parser::try_parse
RESTINIO_NODISCARD expected_t< typename Producer::result_type, parse_error_t > try_parse(string_view_t from, Producer producer)
Perform the parsing of the specified content by using specified value producer.
Definition: easy_parser.hpp:5042
restinio::easy_parser::make_error_description
RESTINIO_NODISCARD std::string make_error_description(const parse_error_t &error, string_view_t from)
Make textual description of error returned by try_parse function.
Definition: easy_parser.hpp:5103
restinio::easy_parser::to_container
RESTINIO_NODISCARD auto to_container()
A factory function to create a to_container_consumer.
Definition: easy_parser.hpp:4583
restinio::easy_parser::to_lower
RESTINIO_NODISCARD auto to_lower() noexcept
A factory function to create a to_lower_transformer.
Definition: easy_parser.hpp:4610

Since
  v.0.6.1

Definition at line 5103 of file easy_parser.hpp.

## maybe()

template<typename... Clauses>

RESTINIO_NODISCARD auto restinio::easy_parser::maybe | ( | Clauses &&... | clauses | ) |

A factory function to create an optional clause.

Usage example:

produce<std::pair<std::string, std::string>>(
token_p() >> &std::pair<std::string, std::string>::first,
maybe(
symbol('='),
token_p() >> &std::pair<std::string, std::string>::second
)
);

Template Parameters

  Clauses | the list of clauses to be used as optional sequence.

Since
  v.0.6.1

Definition at line 3634 of file easy_parser.hpp.

## non_negative_decimal_number_p() [1/2]

template<typename T >

RESTINIO_NODISCARD auto restinio::easy_parser::non_negative_decimal_number_p | ( |  | ) |

inline noexcept

A factory function to create a non_negative_decimal_number_producer.

Note
  This parser consumes all digits until the first non-digit symbol will be found in the input. It means that in the case of `1111someword` the first four digits (e.g. `1111`) will be extracted from the input and the remaining part (e.g. `someword`) won't be consumed by this parser.

Returns
  a producer that expects a positive decimal number in the input stream and returns it if a number is found.

Since
  v.0.6.2

Definition at line 4218 of file easy_parser.hpp.

## non_negative_decimal_number_p() [2/2]

template<typename T >

RESTINIO_NODISCARD auto restinio::easy_parser::non_negative_decimal_number_p | ( | digits_to_consume_t | digits_limit | ) |

inline noexcept

A factory function to create a non_negative_decimal_number_producer.

Note
  This parser consumes a number of digits with respect to digits_limit.

Usage example:

using namespace restinio::easy_parser;
struct compound_number {
short prefix_;
int suffix_;
};
auto parse = produce<compound_number>(
non_negative_decimal_number_p<short>(expected_digits(2, 5))
>> &compound_number::prefix_,
non_negative_decimal_number_p<int>(expected_digits(7, 12))
>> &compound_number::suffix_
);

Returns
  a producer that expects a positive decimal number in the input stream and returns it if a number is found.

Since
  v.0.6.2

Definition at line 4257 of file easy_parser.hpp.

## not_clause()

template<typename... Clauses>

RESTINIO_NODISCARD auto restinio::easy_parser::not_clause | ( | Clauses &&... | clauses | ) |

A factory function to create a not_clause.

Usage example:

produce<std::pair<std::string, std::string>>(
token_p() >> &std::pair<std::string, std::string>::first,
symbol(' '),
token_p() >> &std::pair<std::string, std::string>::second
not_clause(symbol('.'))
);
restinio::easy_parser::not_clause
RESTINIO_NODISCARD auto not_clause(Clauses &&... clauses)
A factory function to create a not_clause.
Definition: easy_parser.hpp:3676

this expression corresponds the following rule:

    T := token SP token !'.'

Template Parameters

  Clauses | the list of clauses to be used as sequence to be checked.

Since
  v.0.6.1

Definition at line 3676 of file easy_parser.hpp.

## positive_decimal_number_producer()

template<typename T >

RESTINIO_NODISCARD auto restinio::easy_parser::positive_decimal_number_producer | ( |  | ) |

inline noexcept

A factory function to create a producer for non-negative decimal numbers.

Deprecated:
  Use non_negative_decimal_number_p.

Since
  v.0.6.2

Definition at line 4279 of file easy_parser.hpp.

## produce()

template<typename Target_Type , typename... Clauses>

RESTINIO_NODISCARD auto restinio::easy_parser::produce | ( | Clauses &&... | clauses | ) |

A factory function to create a producer that creates an instance of the target type by using specified clauses.

Usage example:

produce<std::string>(symbol('v'), symbol('='), token_p() >> as_result());

Template Parameters

  Target_Type | the type of value to be produced.
  Clauses | the list of clauses to be used for a new value.

Since
  v.0.6.1

Definition at line 3554 of file easy_parser.hpp.

## repeat()

template<typename... Clauses>

RESTINIO_NODISCARD auto restinio::easy_parser::repeat | ( | std::size_t | min_occurences,
|  | std::size_t | max_occurences,
|  | Clauses &&... | clauses
| ) |  |

A factory function to create repetitor of subclauses.

Usage example:

using str_pair = std::pair<std::string, std::string>;
produce<std::vector<str_pair>>(
produce<str_pair>(
token_p() >> &str_pair::first,
symbol('='),
token_p() >> &str_pair::second
) >> to_container(),
repeat(0, N,
symbol(','),
produce<str_pair>(
token_p() >> &str_pair::first,
symbol('='),
token_p() >> &str_pair::second
) >> to_container()
)
);

this expression corresponds to the following rule:

     T := token '=' token *(',' token '=' token)

Template Parameters

  Clauses | the list of clauses to be used as the sequence to be repeated.

Since
  v.0.6.1

Parameters

  min_occurences | Minimal occurences of the sequences in the repetition.
  max_occurences | Maximal occurences of the sequences in the repetition.

Note
  The repetition will be stopped when that numer of repetitions will be reached.

Parameters

  clauses | The sequence of clauses to be repeated.

Definition at line 3876 of file easy_parser.hpp.

## sequence()

template<typename... Clauses>

RESTINIO_NODISCARD auto restinio::easy_parser::sequence | ( | Clauses &&... | clauses | ) |

A factory function to create a sequence of subclauses.

Usage example:

produce<std::string>(
alternatives(
sequence(symbol('v'), symbol('='), token_p() >> as_result()),
sequence(symbol('T'), symbol('/'), token_p() >> as_result())
)
);

Please note the usage of sequence() inside the call to alternatives().

Template Parameters

  Clauses | the list of clauses to be used as the sequence.

Since
  v.0.6.1

Definition at line 3758 of file easy_parser.hpp.

## skip()

RESTINIO_NODISCARD auto restinio::easy_parser::skip | ( |  | ) |

inline noexcept

A factory function to create a skip_consumer.

Usage example:

produce<std::string>(
token_p() >> as_result(),
not_clause(symbol('='), token_p() >> skip())
);

Since
  v.0.6.1

Definition at line 3922 of file easy_parser.hpp.

## space()

RESTINIO_NODISCARD auto restinio::easy_parser::space | ( |  | ) |

inline noexcept

A factory function to create a clause that expects a space, extracts it and then skips it.

The call to `space()` function is an equivalent of:

space_p() >> skip()
restinio::easy_parser::space_p
RESTINIO_NODISCARD auto space_p() noexcept
A factory function to create a space_producer.
Definition: easy_parser.hpp:4094

Since
  v.0.6.4

Definition at line 4115 of file easy_parser.hpp.

## space_p()

RESTINIO_NODISCARD auto restinio::easy_parser::space_p | ( |  | ) |

inline noexcept

A factory function to create a space_producer.

Returns
  a producer that expects space character in the input stream and returns it if that character is found.

Since
  v.0.6.4

Definition at line 4094 of file easy_parser.hpp.

## symbol()

RESTINIO_NODISCARD auto restinio::easy_parser::symbol | ( | char | expected | ) |

inline noexcept

A factory function to create a clause that expects the speficied symbol, extracts it and then skips it.

The call to ‘symbol('a’)` function is an equivalent of:

symbol_p('a') >> skip()
restinio::easy_parser::symbol_p
RESTINIO_NODISCARD auto symbol_p(char expected) noexcept
A factory function to create a symbol_producer.
Definition: easy_parser.hpp:3955

Since
  v.0.6.1

Definition at line 4032 of file easy_parser.hpp.

## symbol_from_range()

RESTINIO_NODISCARD auto restinio::easy_parser::symbol_from_range | ( | char | left,
|  | char | right
| ) |  |

inline noexcept

A factory function to create a clause that expects a symbol from specified range, extracts it and then skips it.

The call to ‘symbol_from_range('a’, 'z')` function is an equivalent of:

symbol_from_range_p('a', 'z') >> skip()
restinio::easy_parser::symbol_from_range_p
RESTINIO_NODISCARD auto symbol_from_range_p(char left, char right) noexcept
A factory function to create a symbol_from_range_producer.
Definition: easy_parser.hpp:4011

Since
  v.0.6.9

Definition at line 4076 of file easy_parser.hpp.

## symbol_from_range_p()

RESTINIO_NODISCARD auto restinio::easy_parser::symbol_from_range_p | ( | char | left,
|  | char | right
| ) |  |

inline noexcept

A factory function to create a symbol_from_range_producer.

Returns
  a producer that expects a symbol from `[left, right]` range in the input stream and returns it if that character is found.

Since
  v.0.6.9

Definition at line 4011 of file easy_parser.hpp.

## symbol_p()

RESTINIO_NODISCARD auto restinio::easy_parser::symbol_p | ( | char | expected | ) |

inline noexcept

A factory function to create a symbol_producer.

Returns
  a producer that expects expected in the input stream and returns it if that character is found.

Since
  v.0.6.1

Definition at line 3955 of file easy_parser.hpp.

## to_container()

RESTINIO_NODISCARD auto restinio::easy_parser::to_container | ( |  | ) |

inline

A factory function to create a to_container_consumer.

Usage example:

using str_pair = std::pair<std::string, std::string>;
produce<std::vector<str_pair>>(
produce<str_pair>(
token_p() >> &str_pair::first,
symbol('='),
token_p() >> &str_pair::second
) >> to_container(),
repeat(0, N,
symbol(','),
produce<str_pair>(
token_p() >> &str_pair::first,
symbol('='),
token_p() >> &str_pair::second
) >> to_container()
)
);

Since
  v.0.6.1

Definition at line 4583 of file easy_parser.hpp.

## to_lower()

RESTINIO_NODISCARD auto restinio::easy_parser::to_lower | ( |  | ) |

inline noexcept

A factory function to create a to_lower_transformer.

Usage example:

produce<std::string>(
symbol('T'), symbol(':'),
token_p() >> to_lower() >> as_result()
);
...
// Since v.0.6.6 to_lower can also be used for a single character.
produce<char>(
exact("I="), any_symbol_p() >> to_lower() >> as_result() );
restinio::easy_parser::any_symbol_p
RESTINIO_NODISCARD auto any_symbol_p() noexcept
A factory function to create an any_symbol_producer.
Definition: easy_parser.hpp:3937

Since
  v.0.6.1

Definition at line 4610 of file easy_parser.hpp.

## try_parse()

template<typename Producer >

RESTINIO_NODISCARD expected_t< typename Producer::result_type, parse_error_t > restinio::easy_parser::try_parse | ( | string_view_t | from,
|  | Producer | producer
| ) |  |

Perform the parsing of the specified content by using specified value producer.

Note
  The whole content of from should be consumed. There can be whitespace remaining in @from after the return from Producer::try_parser. But if there will be some non-whitespace symbol the failure will be reported. (As a side note: since v.0.6.7 all trailing spaces are removed from @from before the parsing starts.)

Usage example

const auto tokens = try_parse(
"first,Second;Third;Four",
produce<std::vector<std::string>>(
token_p() >> to_lower() >> to_container(),
repeat( 0, N,
alternatives(symbol(','), symbol(';')),
token_p() >> to_lower() >> to_container()
)
)
);
if(tokens)
for(const auto & v: *tokens)
std::cout << v << std::endl;

Since
  v.0.6.1

Definition at line 5042 of file easy_parser.hpp.

## Variable Documentation

## N

constexpr std::size_t restinio::easy_parser::N = std::numeric_limits<std::size_t>::max()

constexpr

A special marker that means infinite repetitions.

Since
  v.0.6.1

Definition at line 455 of file easy_parser.hpp.