regex_utils Namespace Reference

Functions
std::string	surround_with (const std::string &s, const std::string &w)
std::string	capture (const std::string &s)
std::string	non_capture_optional_group (const std::string &s)
std::vector< std::string >	capture (const std::vector< std::string > &s)
std::string	character_class (const std::vector< std::string > &chars)
std::string	negated_character_class (const std::vector< std::string > &chars)
std::string	one_or_more (const std::string &character_class)
std::string	zero_or_more (const std::string &character_class)
std::string	wrap_parentheses (const std::string &s)
const std::string	string_literal (R"("(?:[^"\\]|\\.)*")")
const std::string	char_literal (R"('(?:[^'\\]|\\.)')")
std::string	tuple_of (const std::vector< std::string > &regexes)
std::regex	function_signature_re (R"(^\s*([\w:<>()]+(?:\s*[*&])?)\s+(\w+)\s*\‍((.*)\‍)\s*$)")

Variables
const std::string	start_of_line = R"(^)"
const std::string	end_of_line = R"($)"
const std::string	any_char = R"(.)"
const std::string	any_char_greedy = R"(.*)"
const std::string	any_char_nongreedy = R"(.*?)"
const std::string	right_parenthesis = R"(\‍))"
const std::string	left_parenthesis = R"(\‍()"
const std::string	ws_char = R"(\s)"
const std::string	optional_ws = R"(\s*)"
const std::string	one_or_more_ws = R"(\s+)"
const std::string	digit = R"(\d)"
const std::string	nonzero_digit = R"([1-9])"
const std::string	binary_digit = R"([0-1])"
const std::string	lowercase_letter = R"([a-z])"
const std::string	uppercase_letter = R"([A-Z])"
const std::string	letter = R"([A-Za-z])"
const std::string	word_char = R"(\w)"
const std::string	word = R"(\w+)"
const std::string	identifier = R"([A-Za-z_]\w*)"
const std::string	optional_ws_comma = surround_with(",", optional_ws)
const std::string	int_regex = R"(-?\d+)"
const std::string	unsigned_int_regex = R"(\d+)"
const std::string	float_regex = R"(-?\d+(?:\.\d+)?)"
const std::string	captured_float_regex = capture(float_regex)
const std::string	float_tuple
const std::string	captured_float_tuple
const std::string	float_triplet
const std::string	captured_float_triplet
const std::string	type_char_class = character_class({word_char, ws_char, ":", "<", ">", "(", ")"})
const std::string	type
std::string	function_signature_ree
std::string	constructor_signature_re
const std::string	simple_template_type

Function Documentation

capture() [1/2]

std::string regex_utils::capture ( const std::string & s )

inline

capture() [2/2]

std::vector< std::string > regex_utils::capture ( const std::vector< std::string > & s )

inline

char_literal()

const std::string regex_utils::char_literal ( R"('(?:[^'\\]|\\.)')" )

inline

character_class()

std::string regex_utils::character_class ( const std::vector< std::string > & chars )

inline

function_signature_re()

std::regex regex_utils::function_signature_re ( R"(^\s*([\w:<>()]+(?:\s*[*&])?)\s+(\w+)\s*\‍((.*)\‍)\s*$)" )

inline

negated_character_class()

std::string regex_utils::negated_character_class ( const std::vector< std::string > & chars )

inline

non_capture_optional_group()

std::string regex_utils::non_capture_optional_group ( const std::string & s )

inline

one_or_more()

std::string regex_utils::one_or_more ( const std::string & character_class )

inline

string_literal()

const std::string regex_utils::string_literal ( R"("(?:[^"\\]|\\.)*")" )

inline

surround_with()

std::string regex_utils::surround_with ( const std::string & s, const std::string & w )

inline

tuple_of()

std::string regex_utils::tuple_of ( const std::vector< std::string > & regexes )

inline

wrap_parentheses()

std::string regex_utils::wrap_parentheses ( const std::string & s )

inline

zero_or_more()

std::string regex_utils::zero_or_more ( const std::string & character_class )

inline

Variable Documentation

any_char

const std::string regex_utils::any_char = R"(.)"

inline

any_char_greedy

const std::string regex_utils::any_char_greedy = R"(.*)"

inline

any_char_nongreedy

const std::string regex_utils::any_char_nongreedy = R"(.*?)"

inline

binary_digit

const std::string regex_utils::binary_digit = R"([0-1])"

inline

captured_float_regex

const std::string regex_utils::captured_float_regex = capture(float_regex)

inline

captured_float_triplet

const std::string regex_utils::captured_float_triplet

inline

Initial value:

= surround_with(
    wrap_parentheses(surround_with(
        text_utils::join({capture(float_regex), capture(float_regex), capture(float_regex)}, optional_ws_comma),
        optional_ws)),
    optional_ws)

captured_float_tuple

const std::string regex_utils::captured_float_tuple

inline

Initial value:

=
    surround_with(wrap_parentheses(surround_with(
                      text_utils::join({capture(float_regex), capture(float_regex)}, optional_ws_comma), optional_ws)),
                  optional_ws)

constructor_signature_re

std::string regex_utils::constructor_signature_re

inline

Initial value:

= start_of_line + optional_ws + capture(word) + optional_ws +
                                              wrap_parentheses(capture(any_char_greedy)) + optional_ws + end_of_line

digit

const std::string regex_utils::digit = R"(\d)"

inline

end_of_line

const std::string regex_utils::end_of_line = R"($)"

inline

float_regex

const std::string regex_utils::float_regex = R"(-?\d+(?:\.\d+)?)"

inline

float_triplet

const std::string regex_utils::float_triplet

inline

Initial value:

=
    surround_with(wrap_parentheses(surround_with(
                      text_utils::join({float_regex, float_regex, float_regex}, optional_ws_comma), optional_ws)),
                  optional_ws)

float_tuple

const std::string regex_utils::float_tuple

inline

Initial value:

= surround_with(
    wrap_parentheses(surround_with(text_utils::join({float_regex, float_regex}, optional_ws_comma), optional_ws)),
    optional_ws)

function_signature_ree

std::string regex_utils::function_signature_ree

inline

Initial value:

= start_of_line + optional_ws + type + one_or_more_ws + capture(word) +
                                            optional_ws + wrap_parentheses(capture(any_char_greedy)) + optional_ws +
                                            end_of_line

identifier

const std::string regex_utils::identifier = R"([A-Za-z_]\w*)"

inline

int_regex

const std::string regex_utils::int_regex = R"(-?\d+)"

inline

left_parenthesis

const std::string regex_utils::left_parenthesis = R"(\‍()"

inline

letter

const std::string regex_utils::letter = R"([A-Za-z])"

inline

lowercase_letter

const std::string regex_utils::lowercase_letter = R"([a-z])"

inline

nonzero_digit

const std::string regex_utils::nonzero_digit = R"([1-9])"

inline

one_or_more_ws

const std::string regex_utils::one_or_more_ws = R"(\s+)"

inline

optional_ws

const std::string regex_utils::optional_ws = R"(\s*)"

inline

optional_ws_comma

const std::string regex_utils::optional_ws_comma = surround_with(",", optional_ws)

inline

right_parenthesis

const std::string regex_utils::right_parenthesis = R"(\‍))"

inline

simple_template_type

const std::string regex_utils::simple_template_type

inline

Initial value:

=
    text_utils::join({capture(word), "<", capture(one_or_more(type_char_class)), ">"}, optional_ws)

start_of_line

const std::string regex_utils::start_of_line = R"(^)"

inline

type

const std::string regex_utils::type

inline

Initial value:

=
    capture(one_or_more(type_char_class) + non_capture_optional_group(optional_ws + character_class({"*", "&"})))

type_char_class

const std::string regex_utils::type_char_class = character_class({word_char, ws_char, ":", "<", ">", "(", ")"})

inline

unsigned_int_regex

const std::string regex_utils::unsigned_int_regex = R"(\d+)"

inline

uppercase_letter

const std::string regex_utils::uppercase_letter = R"([A-Z])"

inline

word

const std::string regex_utils::word = R"(\w+)"

inline

word_char

const std::string regex_utils::word_char = R"(\w)"

inline

ws_char

const std::string regex_utils::ws_char = R"(\s)"

inline