Rule

A Rule defines an algorithm used to match an input buffer of ASCII characters against a set of syntactical specifications. Each rule represents either a terminal symbol or a composition in the represented grammar. The library comes with a set of rules for productions typically found in RFC documents. Rules are not invoked directly; instead, rule variables are used with overloads of parse which provide a convenient, uniform front end.

Related Identifiers

is_rule, parse.

Requirements

In this table:

T is a type meeting the requirements of Rule
t is a const value of type T
it is an lvalue with type char const*
end is a value of type char const*

Expression Type Semantics, Pre/Post-conditions

Expression	Type	Semantics, Pre/Post-conditions
`T(t)`	-	Copy construction of `T` throws nothing. `std::is_nothrow_copy_constructible<T>::value == true`
`T::value_type`	-	Values of this type are returned by the rule when the parse operation is successful
`t.parse(it,end)`	`result<T::value_type>`	Attempt to parse the buffer of characters defined by the range `// [it,end)`. Upon success, the return result holds an instance of the rule’s value type, and the reference parameter `it` is modified to point to the first unconsumed character. Otherwise, upon failure the result holds an error. In this case the implementation defines if and how the reference parameter `it` is modified.

T(t)

Copy construction of T throws nothing.

std::is_nothrow_copy_constructible<T>::value == true

T::value_type

Values of this type are returned by the rule when the parse operation is successful

t.parse(it,end)

result<T::value_type>

Attempt to parse the buffer of characters defined by the range // [it,end). Upon success, the return result holds an instance of the rule’s value type, and the reference parameter it is modified to point to the first unconsumed character. Otherwise, upon failure the result holds an error. In this case the implementation defines if and how the reference parameter it is modified.

Exemplar

For best results, it is suggested that all constructors for rules be marked constexpr.

struct Rule
{
    struct value_type;

    constexpr Rule( Rule const& ) noexcept = default;

    auto parse( char const*& it, char const* end ) const -> result< value_type >;
};

// Declare a variable of type Rule for notational convenience
constexpr Rule rule{};

Model

grammar::dec_octet_rule
grammar::delim_rule
grammar::not_empty_rule
grammar::optional_rule
grammar::range_rule
grammar::token_rule
grammar::tuple_rule
grammar::unsigned_rule
grammar::variant_rule