roar
Loading...
Searching...
No Matches
Classes | Functions | Variables
Roar::Parser Namespace Reference

Classes

struct  Ipv6SegmentContainer
 

Functions

 BOOST_SPIRIT_DEFINE (ipv4)
 
 BOOST_SPIRIT_DEFINE (ipv6)
 
 BOOST_SPIRIT_DEFINE (url)
 

Variables

const auto ipv4 = boost::spirit::x3::rule<Ipv4Tag, Ipv4>{"ipv4"}
 
const auto ipv4Section = x3::rule<Ipv4SectionTag, uint8_t>{"ipv4Section"} = uint_parser<uint8_t, 10, 1, 3>()
 
const auto ipv4_def = ipv4Section >> '.' >> ipv4Section >> '.' >> ipv4Section >> '.' >> ipv4Section
 
const auto ipv6 = x3::rule<Ipv6Tag, Ipv6>{"ipv6"}
 
const auto h16 = x3::rule<H16Tag, uint16_t>{"h16"} = uint_parser<uint16_t, 16, 1, 4>{} - ipv4
 
const auto ls32
 
const auto repeatedSegmentSectionActionBefore
 
const auto repeatedSegmentSectionActionAfter
 
const auto ls32Action
 
const auto h16ActionBefore
 
const auto h16ActionAfter
 
const auto beforeAbbreviationParser
 
const auto afterAbbreviationParser
 
const auto abbreviationParser
 
const auto beforeAbbreviationAction
 
const auto abbreviationAction
 
const auto ipv6Intermediate
 
const auto ipv6_def
 
const auto digestRule
 
const x3::rule< UrlTag, Url > url = "url"
 
const auto unreserved = x3::rule<UnreservedTag, char>{} = alnum | char_("-._~")
 
const auto genDelims = x3::rule<GenDelimsTag, char>{"gen-delims"} = char_(":/?#[]@")
 
const auto subDelims = x3::rule<SubDelimsTag, char>{"sub-delims"} = char_("!$&'()*+,;=")
 
const auto leniency = x3::rule<Leniency, char>("leniency") = char_("\"<> ")
 
const auto reserved = x3::rule<ReservedTag, char>{"reserved"} = genDelims | subDelims
 
const auto percentEncoded
 
const auto pathCharacter
 
const auto path
 
const auto schemeAllowedChar
 
const auto scheme
 
const auto credentialsCharacter
 
const auto userInfo
 
const auto domainCharacter = x3::rule<DomainCharacterTag, char>("domainCharacter") = alnum | char_("-.")
 
const auto domain = x3::rule<DomainTag, std::string>{"domain"} = +domainCharacter
 
const auto host = x3::rule<HostTag, Url::Host>{"host"} = ('[' >> ipv6 >> ']') | (ipv4 >> &char_(":/")) | domain
 
const auto remote
 
const auto authority
 
const auto queryCharacter = x3::rule<QueryCharacterTag, char>{"queryCharacter"} = pathCharacter | char_("/?")
 
const auto queryKey
 
const auto queryValue
 
const auto query
 
const auto fragment
 
const auto url_def
 

Function Documentation

◆ BOOST_SPIRIT_DEFINE() [1/3]

Roar::Parser::BOOST_SPIRIT_DEFINE ( ipv4  )

◆ BOOST_SPIRIT_DEFINE() [2/3]

Roar::Parser::BOOST_SPIRIT_DEFINE ( ipv6  )

◆ BOOST_SPIRIT_DEFINE() [3/3]

Roar::Parser::BOOST_SPIRIT_DEFINE ( url  )

Variable Documentation

◆ abbreviationAction

const auto Roar::Parser::abbreviationAction
Initial value:
= [](auto& ctx) {
concatContainers(_val(ctx).segmentsAfter, _attr(ctx).segmentsAfter);
_val(ctx).endsWithIpv4 = _attr(ctx).endsWithIpv4;
}
Roar::concatContainers
void concatContainers(ContainerType< ElementType > &lhs, ContainerType< ElementType > const &rhs)
Definition concat_containers.hpp:8

◆ abbreviationParser

const auto Roar::Parser::abbreviationParser
Initial value:
= [](int count) {
return "::" >> -afterAbbreviationParser(count);
}
Roar::Parser::afterAbbreviationParser
const auto afterAbbreviationParser
Definition ipv6.hpp:70

◆ afterAbbreviationParser

const auto Roar::Parser::afterAbbreviationParser
Initial value:
= [](int count) {
return (repeat(0, count)[h16 >> ':'][repeatedSegmentSectionActionAfter] >>
(ls32[ls32Action] | h16[h16ActionAfter])) |
h16[h16ActionAfter];
}
Roar::Parser::h16
const auto h16
Definition ipv6.hpp:35
Roar::Parser::repeatedSegmentSectionActionAfter
const auto repeatedSegmentSectionActionAfter
Definition ipv6.hpp:52
Roar::Parser::ls32
const auto ls32
Definition ipv6.hpp:38
Roar::Parser::h16ActionAfter
const auto h16ActionAfter
Definition ipv6.hpp:62
Roar::Parser::ls32Action
const auto ls32Action
Definition ipv6.hpp:55

◆ authority

const auto Roar::Parser::authority
Initial value:
= x3::rule<AuthorityTag, Url::Authority>{"authority"} = -(userInfo >> "@")[([](auto& ctx) {
_val(ctx).userInfo = _attr(ctx);
})] >>
remote[([](auto& ctx) {
_val(ctx).remote = _attr(ctx);
})]
Roar::Parser::userInfo
const auto userInfo
Definition url.cpp:94

◆ beforeAbbreviationAction

const auto Roar::Parser::beforeAbbreviationAction
Initial value:
= [](auto& ctx) {
_val(ctx).segmentsBefore = _attr(ctx).segmentsBefore;
}

◆ beforeAbbreviationParser

const auto Roar::Parser::beforeAbbreviationParser
Initial value:
= [](int count) {
return repeat(count)[h16 >> ':'][repeatedSegmentSectionActionBefore] >> h16[h16ActionBefore];
}
Roar::Parser::h16ActionBefore
const auto h16ActionBefore
Definition ipv6.hpp:59
Roar::Parser::repeatedSegmentSectionActionBefore
const auto repeatedSegmentSectionActionBefore
Definition ipv6.hpp:49

◆ credentialsCharacter

const auto Roar::Parser::credentialsCharacter
Initial value:
= x3::rule<CredentialsCharacterTag, char>{"credentialsCharacter"} =
percentEncoded | unreserved | reserved
Roar::Parser::unreserved
const auto unreserved
Definition url.cpp:41
Roar::Parser::reserved
const auto reserved
Definition url.cpp:53
Roar::Parser::percentEncoded
const auto percentEncoded
Definition url.cpp:56

◆ digestRule

const auto Roar::Parser::digestRule
Initial value:
= x3::rule<DigestTag, Roar::DigestAuth>{"digestAuth"} =
(PARAM_PARSER(username) | PARAM_PARSER(realm) | PARAM_PARSER(uri) | PARAM_PARSER(algorithm) |
PARAM_PARSER(nonce) | PARAM_PARSER(nc) | PARAM_PARSER(cnonce) | PARAM_PARSER(qop) |
PARAM_PARSER(response) | PARAM_PARSER(opaque)) %
',' >>
x3::eps[([](auto&) {})]
PARAM_PARSER
#define PARAM_PARSER(name)
Definition digest_auth.cpp:17

◆ domain

const auto Roar::Parser::domain = x3::rule<DomainTag, std::string>{"domain"} = +domainCharacter

◆ domainCharacter

const auto Roar::Parser::domainCharacter = x3::rule<DomainCharacterTag, char>("domainCharacter") = alnum | char_("-.")

◆ fragment

const auto Roar::Parser::fragment
Initial value:
= x3::rule<FragmentTag, std::string>{"fragment"} =
*(unreserved | reserved | percentEncoded | char_(":@"))

◆ genDelims

const auto Roar::Parser::genDelims = x3::rule<GenDelimsTag, char>{"gen-delims"} = char_(":/?#[]@")

◆ h16

const auto Roar::Parser::h16 = x3::rule<H16Tag, uint16_t>{"h16"} = uint_parser<uint16_t, 16, 1, 4>{} - ipv4

◆ h16ActionAfter

const auto Roar::Parser::h16ActionAfter
Initial value:
= [](auto& ctx) {
_val(ctx).segmentsAfter.push_back(_attr(ctx));
}

◆ h16ActionBefore

const auto Roar::Parser::h16ActionBefore
Initial value:
= [](auto& ctx) {
_val(ctx).segmentsBefore.push_back(_attr(ctx));
}

◆ host

const auto Roar::Parser::host = x3::rule<HostTag, Url::Host>{"host"} = ('[' >> ipv6 >> ']') | (ipv4 >> &char_(":/")) | domain

◆ ipv4

const auto Roar::Parser::ipv4 = boost::spirit::x3::rule<Ipv4Tag, Ipv4>{"ipv4"}

◆ ipv4_def

const auto Roar::Parser::ipv4_def = ipv4Section >> '.' >> ipv4Section >> '.' >> ipv4Section >> '.' >> ipv4Section

◆ ipv4Section

const auto Roar::Parser::ipv4Section = x3::rule<Ipv4SectionTag, uint8_t>{"ipv4Section"} = uint_parser<uint8_t, 10, 1, 3>()

◆ ipv6

const auto Roar::Parser::ipv6 = x3::rule<Ipv6Tag, Ipv6>{"ipv6"}

◆ ipv6_def

const auto Roar::Parser::ipv6_def
Initial value:
= ipv6Intermediate[([](auto& ctx) {
decltype(Ipv6::segments) segments{};
auto const& segmentsBefore = _attr(ctx).segmentsBefore;
auto const& segmentsAfter = _attr(ctx).segmentsAfter;
if (segmentsBefore.size() + segmentsAfter.size() > segments.size())
{
_pass(ctx) = false;
return;
}
for (std::size_t i = 0; i != segmentsBefore.size(); ++i)
segments[i] = segmentsBefore[i];
for (std::size_t i = 0; i != segmentsAfter.size(); ++i)
segments[i + segments.size() - segmentsAfter.size()] = segmentsAfter[i];
_val(ctx) = Ipv6{
.segments = std::move(segments),
.endsWithIpv4 = _attr(ctx).endsWithIpv4,
};
})]
Roar::Parser::ipv6Intermediate
const auto ipv6Intermediate
Definition ipv6.hpp:116
Roar::Ipv6
Definition ipv6.hpp:12
Roar::Ipv6::segments
std::array< uint16_t, 8 > segments
Definition ipv6.hpp:13

◆ ipv6Intermediate

const auto Roar::Parser::ipv6Intermediate
Initial value:
= x3::rule<Ipv6IntermediateTag, Ipv6SegmentContainer>{"ipv6Intermediate"} =
beforeAbbreviation7[beforeAbbreviationAction] | (beforeAbbreviation6[beforeAbbreviationAction] >> lit("::")) |
(beforeAbbreviation5[beforeAbbreviationAction] >> lit("::") >> -h16[h16ActionAfter]) |
(repeat(6)[h16 >> ':'][repeatedSegmentSectionActionBefore] >> ls32[ls32Action]) |
(beforeAbbreviation4[beforeAbbreviationAction] >> abbreviation0[abbreviationAction]) |
(beforeAbbreviation3[beforeAbbreviationAction] >> abbreviation1[abbreviationAction]) |
(beforeAbbreviation2[beforeAbbreviationAction] >> abbreviation2[abbreviationAction]) |
(beforeAbbreviation1[beforeAbbreviationAction] >> abbreviation3[abbreviationAction]) |
(beforeAbbreviation0[beforeAbbreviationAction] >> abbreviation4[abbreviationAction]) |
(abbreviation5[abbreviationAction]) | (abbreviation6[abbreviationAction])
Roar::Parser::abbreviationAction
const auto abbreviationAction
Definition ipv6.hpp:112
Roar::Parser::beforeAbbreviationAction
const auto beforeAbbreviationAction
Definition ipv6.hpp:109

◆ leniency

const auto Roar::Parser::leniency = x3::rule<Leniency, char>("leniency") = char_("\"<> ")

◆ ls32

const auto Roar::Parser::ls32
Initial value:
= x3::rule<Ls32Tag, Ipv6SegmentContainer>{"ls32"} =
ipv4[([](auto& ctx) {
_val(ctx).segmentsAfter = _attr(ctx).toIpv6Segments();
_val(ctx).endsWithIpv4 = true;
})] |
(h16 >> ':' >> h16)[([](auto& ctx) {
_val(ctx).segmentsAfter.push_back(at_c<0>(_attr(ctx)));
_val(ctx).segmentsAfter.push_back(at_c<1>(_attr(ctx)));
_val(ctx).endsWithIpv4 = false;
})]
Roar::Parser::ipv4
const auto ipv4
Definition ipv4.hpp:12

◆ ls32Action

const auto Roar::Parser::ls32Action
Initial value:
= [](auto& ctx) {
concatContainers(_val(ctx).segmentsAfter, _attr(ctx).segmentsAfter);
_val(ctx).endsWithIpv4 = _attr(ctx).endsWithIpv4;
}

◆ path

const auto Roar::Parser::path
Initial value:
= x3::rule<PathTag, std::vector<std::string>>{"path"} =
((*pathCharacter) % '/')[([](auto& ctx) {
if (!_attr(ctx).empty())
_pass(ctx) = !_attr(ctx).front().empty();
_val(ctx) = _attr(ctx);
})]

◆ pathCharacter

const auto Roar::Parser::pathCharacter
Initial value:
= x3::rule<PathCharacterTag, char>{"pathCharacter"} =
(percentEncoded | leniency | unreserved | reserved | char_(":@")) - char_("#?/")
Roar::Parser::leniency
const auto leniency
Definition url.cpp:50

◆ percentEncoded

const auto Roar::Parser::percentEncoded
Initial value:
= x3::rule<PercentEncodedTag, char>{"percentEncoded"} =
'%' >> uint_parser<unsigned char, 16, 2, 2>{}[([](auto& ctx) {
_val(ctx) = static_cast<char>(_attr(ctx));
})]

◆ query

const auto Roar::Parser::query
Initial value:
= x3::rule<QueryTag, std::unordered_map<std::string, std::string>>{"query"} =
((queryKey > "=" > queryValue)[([](auto& ctx) {
_val(ctx).insert(std::make_pair(at_c<0>(_attr(ctx)), at_c<1>(_attr(ctx))));
})] %
char_("&;"))
Roar::Parser::queryValue
const auto queryValue
Definition url.cpp:143
Roar::Parser::queryKey
const auto queryKey
Definition url.cpp:137

◆ queryCharacter

const auto Roar::Parser::queryCharacter = x3::rule<QueryCharacterTag, char>{"queryCharacter"} = pathCharacter | char_("/?")

◆ queryKey

const auto Roar::Parser::queryKey
Initial value:
= x3::rule<QueryKeyTag, std::string>{"queryKey"} =
+(queryCharacter - char_("=&;"))[([](auto& ctx) {
_val(ctx).push_back(_attr(ctx));
})]
Roar::Parser::queryCharacter
const auto queryCharacter
Definition url.cpp:134

◆ queryValue

const auto Roar::Parser::queryValue
Initial value:
= x3::rule<QueryValueTag, std::string>{"queryValue"} =
*(queryCharacter - char_("&;#"))[([](auto& ctx) {
_val(ctx).push_back(_attr(ctx));
})]

◆ remote

const auto Roar::Parser::remote
Initial value:
= x3::rule<RemoteTag, Url::Authority::Remote>{"remote"} = host[([](auto& ctx) {
_val(ctx).host = _attr(ctx);
})] >>
-(char_(':') >> ushort_[([](auto& ctx) {
_val(ctx).port = _attr(ctx);
})])
Roar::Parser::host
const auto host
Definition url.cpp:114

◆ repeatedSegmentSectionActionAfter

const auto Roar::Parser::repeatedSegmentSectionActionAfter
Initial value:
= [](auto& ctx) {
_val(ctx).segmentsAfter = _attr(ctx);
}

◆ repeatedSegmentSectionActionBefore

const auto Roar::Parser::repeatedSegmentSectionActionBefore
Initial value:
= [](auto& ctx) {
_val(ctx).segmentsBefore = _attr(ctx);
}

◆ reserved

const auto Roar::Parser::reserved = x3::rule<ReservedTag, char>{"reserved"} = genDelims | subDelims

◆ scheme

const auto Roar::Parser::scheme
Initial value:
= x3::rule<SchemeTag, std::string>{"scheme"} = alpha[([](auto& ctx) {
_val(ctx).push_back(_attr(ctx));
})] >>
*(schemeAllowedChar - char_(':'))[([](auto& ctx) {
_val(ctx).push_back(_attr(ctx));
})]

◆ schemeAllowedChar

const auto Roar::Parser::schemeAllowedChar
Initial value:
= x3::rule<SchemeAllowedCharacterTag, char>{"schemeAllowedChar"} =
alnum | char_('+') | char_('.') | char_('-')

◆ subDelims

const auto Roar::Parser::subDelims = x3::rule<SubDelimsTag, char>{"sub-delims"} = char_("!$&'()*+,;=")

◆ unreserved

const auto Roar::Parser::unreserved = x3::rule<UnreservedTag, char>{} = alnum | char_("-._~")

◆ url

const x3::rule<UrlTag, Url> Roar::Parser::url = "url"

◆ url_def

const auto Roar::Parser::url_def
Initial value:
= scheme > ':' > -("//" > authority) > -("/" > -path) > -("?" > query) >
-("#" > fragment) > eoi
Roar::Parser::query
const auto query
Definition url.cpp:149
Roar::Parser::authority
const auto authority
Definition url.cpp:125
Roar::Parser::scheme
const auto scheme
Definition url.cpp:81

◆ userInfo

const auto Roar::Parser::userInfo
Initial value:
= x3::rule<UserInfoTag, Url::UserInfo>{"userInfo"} =
((+(credentialsCharacter - ':'))[([](auto& ctx) {
_val(ctx).user = _attr(ctx);
})] >>
':' >> (*(credentialsCharacter - '@'))[([](auto& ctx) {
_val(ctx).password = _attr(ctx);
})]) |
(+(credentialsCharacter - '@'))[([](auto& ctx) {
_val(ctx).user = _attr(ctx);
_val(ctx).password = std::nullopt;
})]
Roar::Parser::credentialsCharacter
const auto credentialsCharacter
Definition url.cpp:90
Generated by doxygen 1.9.7