43 result.reserve( group.size() + group.size() / 2 );
45 for(
const char c : group )
47 if(
'=' == c ||
'!' == c ||
':' == c ||
48 '$' == c ||
'/' == c ||
'(' == c ||
')' == c )
66 result.reserve( group.size() + group.size() / 2 );
68 for(
const char c : group )
70 if(
'.' == c ||
'+' == c ||
'*' == c ||
71 '?' == c ||
'=' == c ||
'^' == c ||
72 ':' == c ||
'$' == c ||
'{' == c ||
73 '}' == c ||
'(' == c ||
')' == c ||
74 '[' == c ||
']' == c ||
'|' == c ||
75 '\\' == c ||
'/' == c )
213 const std::vector< std::string > &
262template <
typename Route_Param_Appender >
264 std::function< void ( Route_Param_Appender &,
string_view_t ) >;
271template <
typename Route_Param_Appender >
279template <
typename Route_Param_Appender >
285 Route_Param_Appender & parameters,
287 parameters.add_named_param( key, value );
292template <
typename Route_Param_Appender >
293inline param_appender_t< Route_Param_Appender >
297 []( Route_Param_Appender & parameters,
string_view_t value ){
298 parameters.add_indexed_param( value );
310template <
typename Container >
318 assert(
m_buffer.capacity() >= reserve_size );
326 const auto n = name.size();
332 throw exception_t{
"unable to insert data into names buffer" };
336 const auto prev_size =
m_buffer.size();
338 std::copy( name.data(), name.data() + n, std::back_inserter(
m_buffer ) );
357 R
"((\\.)|(?:\:(\w+)(?:\(((?:\\.|[^\\()])+)\))?|\(((?:\\.|[^\\()])+)\))([+*?])?)";
370template <
typename Route_Param_Appender >
392template <
typename Route_Param_Appender >
395template <
typename Route_Param_Appender >
396using token_list_t = std::vector< token_unique_ptr_t< Route_Param_Appender > >;
403template <
typename Route_Param_Appender >
426 return std::string::npos != delimiters.find(
m_last_char );
435template <
typename Route_Param_Appender >
440 return std::make_unique< token_t >(
std::move( path ) );
448template <
typename Route_Param_Appender,
typename Name >
457 const std::string & prefix,
458 std::string delimiter,
462 std::string pattern )
507 param_appender_sequence.push_back(
508 make_param_setter< Route_Param_Appender >(
529template <
typename Route_Param_Appender,
typename Name >
534 std::string delimiter,
538 std::string pattern )
540 return std::make_unique< parameter_token_t< Route_Param_Appender, Name > >(
564 auto pos = strv.find(
'(' );
565 if( std::string::npos != pos )
569 "non-escaped bracket '(' at pos {}: may be unmatched group start",
573 pos = strv.find(
')' );
574 if( std::string::npos != pos )
578 "non-escaped bracket ')' at pos {}: may be unmatched group finish",
582 return std::string{ strv.data(), strv.size() };
590template <
typename Route_Param_Appender,
typename MATCH >
599 std::string prefix{
"" };
600 if( !path_escaped && !path.empty() )
602 const auto k = path.size() - 1;
604 if( std::string::npos != options.
delimiters().find( path[k] ) )
606 prefix = path.substr( k, 1 );
607 path = path.substr( 0, k );
614 result.push_back( create_token< Route_Param_Appender >(
std::move( path ) ) );
615 path_escaped =
false;
618 const auto next = match.suffix().str().substr( 0, 1 );
623 const bool partial = !prefix.empty() && !next.empty() && prefix != next;
625 const bool optional = modifier ==
"?" || modifier ==
"*";
626 const bool repeat = modifier ==
"+" || modifier ==
"*";
629 auto create_pattern = [ delimiter ](
auto pattern ){
630 if( !pattern.empty() )
645 create_token< Route_Param_Appender >(
658 create_token< Route_Param_Appender >(
674template <
typename Route_Param_Appender >
675token_list_t< Route_Param_Appender >
682 bool path_escaped =
false;
684 std::cregex_iterator token_it{
686 route_sv.data() + route_sv.size(),
689 std::cregex_iterator token_end{};
691 if( token_it == token_end )
697 while( token_it != token_end )
699 const auto & match = *token_it;
701 assert( 6 == match.size() );
704 match.prefix().first,
705 static_cast<std::size_t
>( match.prefix().length() ) };
708 static_cast<std::size_t
>(match.position()) - prefix.size() );
711 if( !escaped.empty() )
713 assert( 2 == escaped.size() );
714 path += escaped[ 1 ];
722 auto next_it = token_it;
723 std::advance( next_it, 1 );
725 if( next_it == token_end )
727 const std::string suffix{ match.suffix() };
731 static_cast<std::size_t
>(match.position() + match.length()) );
738 result.push_back( create_token< Route_Param_Appender >(
std::move( path ) ) );
748template <
typename Route_Param_Appender,
typename Regex_Engine >
758 using regex_t =
typename Regex_Engine::compiled_regex_t;
778template <
typename Route_Param_Appender,
typename Regex_Engine >
797 std::size_t captured_groups_count = 1 ;
799 for(
const auto & t : tokens )
801 const auto appended_token_type =
802 t->append_self_to( route, param_appender_sequence, names_buffer_appender );
805 ++captured_groups_count;
808 if( Regex_Engine::max_capture_groups() < captured_groups_count )
813 "too many parameter to capture from route: {}, while {} is the maximum",
814 captured_groups_count,
815 Regex_Engine::max_capture_groups() ) };
825 route +=
"(?:" + delimiter +
")?";
836 route +=
"(?:" + delimiter +
"(?=" +
ends_with +
"))?";
838 if( !tokens.empty() &&
839 !tokens.back()->is_end_delimited( options.
delimiters() ) )
840 route +=
"(?=" + delimiter +
"|" +
ends_with +
")";
843 result.
m_regex = Regex_Engine::compile_regex(
"^" + route, options.
sensitive() );
845 catch(
const std::exception & ex )
848 fmt::format(
"unable to process route \"{}\": {}", path, ex.what() ) };
861template <
typename Route_Param_Appender,
typename Regex_Engine >
867 return impl::tokens2regexp< Route_Param_Appender, Regex_Engine >(
869 impl::parse< Route_Param_Appender >( path, options ),
Exception class for all exceptions thrown by RESTinio.
Token for paramater (named/indexed).
parameter_token_t(const parameter_token_t &)=delete
const std::string m_escaped_prefix
const std::string m_pattern
parameter_token_t(Name name, const std::string &prefix, std::string delimiter, bool optional, bool repeat, bool partial, std::string pattern)
parameter_token_t(parameter_token_t &&)=delete
const std::string m_delimiter
virtual token_type_t append_self_to(std::string &route, param_appender_sequence_t< Route_Param_Appender > ¶m_appender_sequence, names_buffer_appender_t &names_buffer_appender) const override
const std::string m_escaped_path
Already escaped piece of the route.
virtual token_type_t append_self_to(std::string &route, param_appender_sequence_t< Route_Param_Appender > &, names_buffer_appender_t &) const override
virtual bool is_end_delimited(const std::string &delimiters) const noexcept override
plain_string_token_t(const std::string &path)
Appender for names to a given buffered string.
string_view_t append_name(const std::string &name)
Appends a given name to buffer, and returns a string view object within the context of a buffer.
std::size_t append_name(std::size_t i) const
A stub for indexed paramaters.
string_view_buffer_storage_appender_t(std::size_t reserve_size, Container &buffer)
Base class for token variants.
virtual bool is_end_delimited(const std::string &) const noexcept
virtual token_type_t append_self_to(std::string &route, param_appender_sequence_t< Route_Param_Appender > ¶m_appender_sequence, names_buffer_appender_t &names_buffer_appender) const =0
token_t(token_t &&)=delete
token_t(const token_t &)=delete
virtual ~token_t()=default
Options for matching routes.
options_t & ends_with(std::vector< std::string > p) &
const std::vector< std::string > & ends_with() const
options_t && delimiter(std::string p) &&
bool m_strict
When false the trailing slash is optional.
const std::string & delimiter() const
options_t && delimiters(std::string p) &&
std::string make_ends_with() const
options_t & strict(bool p) &
options_t & sensitive(bool s) &
options_t && ending(bool p) &&
std::string m_delimiters
Path delimiters.
bool m_sensitive
When true the route will be case sensitive.
std::vector< std::string > m_ends_with
Path delimiter.
bool m_ending
When false the path will match at the beginning.
options_t & delimiters(std::string p) &
const std::string & delimiters() const
options_t & delimiter(std::string p) &
std::string make_delimiter(std::string d) const
options_t & ending(bool p) &
options_t && ends_with(std::vector< std::string > p) &&
options_t && sensitive(bool s) &&
options_t && strict(bool p) &&
std::string m_delimiter
Path delimiter.
A special wrapper around fmtlib include files.
RESTINIO_NODISCARD auto repeat(std::size_t min_occurences, std::size_t max_occurences, Clauses &&... clauses)
A factory function to create repetitor of subclauses.
std::vector< token_unique_ptr_t< Route_Param_Appender > > token_list_t
constexpr std::size_t group_escaped_idx
Indexes for different groups in matched result (used when extracting tokens from initial route).
auto escape_string(const std::string &group)
Excape regex control chars.
auto tokens2regexp(string_view_t path, const token_list_t< Route_Param_Appender > &tokens, const options_t &options)
Makes route regex matcher out of path tokens.
constexpr std::size_t group_capture_idx
std::unique_ptr< token_t< Route_Param_Appender > > token_unique_ptr_t
token_unique_ptr_t< Route_Param_Appender > create_token(std::string path)
auto escape_group(const std::string &group)
Escapes not allowed symbols in a sub-match group assigned to a parameter.
constexpr std::size_t group_modifier_idx
constexpr std::size_t group_name_idx
std::string check_no_unescaped_brackets(string_view_t strv, std::size_t base_pos)
Checks that string doesn't contain non-excaped brackets.
constexpr auto path_regex_str
The main path matching expression.
constexpr std::size_t group_group_idx
void handle_param_token(const options_t &options, const MATCH &match, std::string &path, bool &path_escaped, token_list_t< Route_Param_Appender > &result)
Handling of a parameterized token.
token_list_t< Route_Param_Appender > parse(string_view_t route_sv, const options_t &options)
Parse a string for the raw tokens.
auto path2regex(string_view_t path, const options_t &options)
The main path matching regexp.
std::vector< param_appender_t< Route_Param_Appender > > param_appender_sequence_t
A sequence of appenders for submatches.
param_appender_t< Route_Param_Appender > make_param_setter(string_view_t key)
Create default appender for named parameter.
std::function< void(Route_Param_Appender &, string_view_t) > param_appender_t
Appends sub-match as a request parameter to specified container.
RESTINIO_NODISCARD bool ends_with(const string_view_t &where, const string_view_t &what) noexcept
nonstd::string_view string_view_t
Resulting regex and param extraction for a specific route.
std::shared_ptr< std::string > m_named_params_buffer
Char buffer for holding named paramaters.
param_appender_sequence_t< Route_Param_Appender > m_param_appender_sequence
Appenders for captured values (names/indexed groups).
typename Regex_Engine::compiled_regex_t regex_t
route_regex_matcher_data_t(route_regex_matcher_data_t &&)=default
route_regex_matcher_data_t()=default
route_regex_matcher_data_t & operator=(const route_regex_matcher_data_t &)=delete
route_regex_matcher_data_t(const route_regex_matcher_data_t &)=delete