45 for(
const char c :
group )
47 if(
'=' == c ||
'!' == c ||
':' == c ||
48 '$' == c ||
'/' == c ||
'(' == c ||
')' == c )
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 )
123 return std::move( this->
strict(
p ) );
142 return std::move( this->
ending(
p ) );
161 return std::move( this->
delimiter( std::move(
p ) ) );
173 std::string
result{ std::move(
d ) };
191 return std::move( this->
delimiters( std::move(
p ) ) );
210 return std::move( this->
ends_with( std::move(
p ) ) );
213 const std::vector< std::string > &
262template <
typename Route_Param_Appender >
271template <
typename Route_Param_Appender >
279template <
typename Route_Param_Appender >
287 parameters.add_named_param(
key, value );
292template <
typename Route_Param_Appender >
298 parameters.add_indexed_param( value );
310template <
typename Container >
326 const auto n = name.size();
332 throw exception_t{
"unable to insert data into names buffer" };
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,
529template <
typename Route_Param_Appender,
typename Name >
534 std::string delimiter,
540 return std::make_unique< parameter_token_t< Route_Param_Appender, Name > >(
543 std::move( delimiter ),
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 >
602 const auto k = path.size() - 1;
604 if( std::string::npos !=
options.delimiters().find( path[
k] ) )
607 path = path.substr( 0,
k );
618 const auto next = match.suffix().str().substr( 0, 1 );
648 std::move( delimiter ),
661 std::move( delimiter ),
674template <
typename Route_Param_Appender >
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() );
727 const std::string
suffix{ match.suffix() };
731 static_cast<std::size_t
>(match.position() + match.length()) );
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 >
799 for(
const auto & t :
tokens )
813 "too many parameter to capture from route: {}, while {} is the maximum",
815 Regex_Engine::max_capture_groups() ) };
819 const auto & ends_with =
options.make_ends_with();
825 route +=
"(?:" + delimiter +
")?";
828 if( ends_with ==
"$" )
831 route +=
"(?=" + ends_with +
")";
836 route +=
"(?:" + delimiter +
"(?=" + ends_with +
"))?";
840 route +=
"(?=" + delimiter +
"|" + ends_with +
")";
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.
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.
run_on_this_thread_settings_t< Traits > on_this_thread()
A special marker for the case when http_server must be run on the context of the current thread.
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