:relfileprefix: ../../
[#boost-urls-grammar]

= xref:boost.adoc[pass:[boost]]::xref:boost/urls.adoc[pass:[urls]]::grammar

==  Types
[cols=2,separator=¦]
|===
¦Name ¦Description
¦xref:boost/urls/grammar/aligned_storage.adoc[`aligned_storage`]  ¦

¦xref:boost/urls/grammar/all_chars_t.adoc[`all_chars_t`]  ¦

¦xref:boost/urls/grammar/alnum_chars_t.adoc[`alnum_chars_t`]  ¦

¦xref:boost/urls/grammar/alpha_chars_t.adoc[`alpha_chars_t`]  ¦

¦xref:boost/urls/grammar/ch_delim_rule.adoc[`ch_delim_rule`]  ¦

¦xref:boost/urls/grammar/ci_equal.adoc[`ci_equal`]  ¦

¦xref:boost/urls/grammar/ci_hash.adoc[`ci_hash`]  ¦

¦xref:boost/urls/grammar/ci_less.adoc[`ci_less`]  ¦

¦xref:boost/urls/grammar/cs_delim_rule.adoc[`cs_delim_rule`]  ¦

¦xref:boost/urls/grammar/dec_octet_rule_t.adoc[`dec_octet_rule_t`]  ¦

¦xref:boost/urls/grammar/digit_chars_t.adoc[`digit_chars_t`]  ¦

¦xref:boost/urls/grammar/hexdig_chars_t.adoc[`hexdig_chars_t`]  ¦

¦xref:boost/urls/grammar/is_charset-0c.adoc[`is_charset<T, void_t<decltype(std::declval<bool&>() =
                std::declval<T const&>().operator()(
                    std::declval<char>()))>>`]  ¦

¦xref:boost/urls/grammar/is_charset-06.adoc[`is_charset`]  ¦

¦xref:boost/urls/grammar/is_rule-0a.adoc[`is_rule`]  ¦

¦xref:boost/urls/grammar/is_rule-0f.adoc[`is_rule<T, void_t<decltype(std::declval<system::result<typename T::value_type>&>() =
                std::declval<T const&>().parse(
                    std::declval<char const*&>(),
                    std::declval<char const*>()))>>`]  ¦

¦xref:boost/urls/grammar/literal_rule.adoc[`literal_rule`]  ¦

¦xref:boost/urls/grammar/lut_chars.adoc[`lut_chars`]  ¦

A set of characters

¦xref:boost/urls/grammar/not_empty_rule_t.adoc[`not_empty_rule_t`]  ¦

¦xref:boost/urls/grammar/optional_rule_t.adoc[`optional_rule_t`]  ¦

¦xref:boost/urls/grammar/range.adoc[`range`]  ¦

A forward range of parsed elements

¦xref:boost/urls/grammar/range_rule_t-09.adoc[`range_rule_t`]  ¦

¦xref:boost/urls/grammar/range_rule_t-01.adoc[`range_rule_t<R>`]  ¦

¦xref:boost/urls/grammar/recycled.adoc[`recycled`]  ¦

A thread-safe collection of instances of T

¦xref:boost/urls/grammar/recycled_ptr.adoc[`recycled_ptr`]  ¦

A pointer to shared instance of T

¦xref:boost/urls/grammar/string_view_base.adoc[`string_view_base`]  ¦

Common functionality for string views

¦xref:boost/urls/grammar/token_rule_t.adoc[`token_rule_t`]  ¦

¦xref:boost/urls/grammar/tuple_rule_t.adoc[`tuple_rule_t`]  ¦

¦xref:boost/urls/grammar/unsigned_rule.adoc[`unsigned_rule`]  ¦

¦xref:boost/urls/grammar/variant_rule_t.adoc[`variant_rule_t`]  ¦

¦xref:boost/urls/grammar/vchars_t.adoc[`vchars_t`]  ¦

|===
==  Enums
[cols=2,separator=¦]
|===
¦Name ¦Description
¦xref:boost/urls/grammar/condition.adoc[`condition`]  ¦

Error conditions for errors received from rules

¦xref:boost/urls/grammar/error.adoc[`error`]  ¦

Error codes returned when using rules

|===
== Functions
[cols=2,separator=¦]
|===
¦Name ¦Description
¦xref:boost/urls/grammar/ci_compare.adoc[`ci_compare`]  ¦

Return the case-insensitive comparison of s0 and s1

¦xref:boost/urls/grammar/ci_digest.adoc[`ci_digest`]  ¦

Return the case-insensitive digest of a string

¦xref:boost/urls/grammar/ci_is_equal.adoc[`ci_is_equal`]  ¦
¦xref:boost/urls/grammar/ci_is_less.adoc[`ci_is_less`]  ¦

Return true if s0 is less than s1 using case-insensitive comparison

¦xref:boost/urls/grammar/delim_rule.adoc[`delim_rule`]  ¦
¦xref:boost/urls/grammar/find_if.adoc[`find_if`]  ¦

Find the first character in the string that is in the set.

¦xref:boost/urls/grammar/find_if_not.adoc[`find_if_not`]  ¦

Find the first character in the string that is not in CharSet

¦xref:boost/urls/grammar/hash_value.adoc[`hash_value`]  ¦

Return the hash of this value

¦xref:boost/urls/grammar/hexdig_value.adoc[`hexdig_value`]  ¦

Return the decimal value of a hex character

¦xref:boost/urls/grammar/make_error_code.adoc[`make_error_code`]  ¦

¦xref:boost/urls/grammar/make_error_condition.adoc[`make_error_condition`]  ¦

¦xref:boost/urls/grammar/not_empty_rule.adoc[`not_empty_rule`]  ¦
¦xref:boost/urls/grammar/operator_not_eq.adoc[`operator!=`]  ¦

¦xref:boost/urls/grammar/operator_plus.adoc[`operator+`]  ¦

Return the union of two character sets.

¦xref:boost/urls/grammar/operator_minus.adoc[`operator-`]  ¦

Return a new character set by subtracting

¦xref:boost/urls/grammar/operator_lt.adoc[`operator<`]  ¦

¦xref:boost/urls/grammar/operator_lshift.adoc[`operator<<`]  ¦

Format a string to an output stream

¦xref:boost/urls/grammar/operator_le.adoc[`operator<=`]  ¦

¦xref:boost/urls/grammar/operator_eq.adoc[`operator==`]  ¦

¦xref:boost/urls/grammar/operator_gt.adoc[`operator>`]  ¦

¦xref:boost/urls/grammar/operator_ge.adoc[`operator>=`]  ¦

¦xref:boost/urls/grammar/optional_rule.adoc[`optional_rule`]  ¦
¦xref:boost/urls/grammar/parse.adoc[`parse`]  ¦

Parse a character buffer using a rule

¦xref:boost/urls/grammar/range_rule.adoc[`range_rule`]  ¦
¦xref:boost/urls/grammar/ref.adoc[`ref`]  ¦
¦xref:boost/urls/grammar/squelch.adoc[`squelch`]  ¦

¦xref:boost/urls/grammar/to_lower.adoc[`to_lower`]  ¦

Return c converted to lowercase

¦xref:boost/urls/grammar/to_upper.adoc[`to_upper`]  ¦

Return c converted to uppercase

¦xref:boost/urls/grammar/token_rule.adoc[`token_rule`]  ¦

¦xref:boost/urls/grammar/tuple_rule.adoc[`tuple_rule`]  ¦
¦xref:boost/urls/grammar/variant_rule.adoc[`variant_rule`]  ¦
|===
== Variables
[cols=2,separator=¦]
|===
¦Name ¦Description
¦xref:boost/urls/grammar/all_chars.adoc[`all_chars`]  ¦

A character set containing all characters.

¦xref:boost/urls/grammar/alnum_chars.adoc[`alnum_chars`]  ¦

¦xref:boost/urls/grammar/alpha_chars.adoc[`alpha_chars`]  ¦

A character set containing the alphabetical characters.

¦xref:boost/urls/grammar/dec_octet_rule.adoc[`dec_octet_rule`]  ¦

¦xref:boost/urls/grammar/digit_chars.adoc[`digit_chars`]  ¦

¦xref:boost/urls/grammar/hexdig_chars.adoc[`hexdig_chars`]  ¦

¦xref:boost/urls/grammar/vchars.adoc[`vchars`]  ¦

|===

