String Operations

Adds a few utility functions that deal with strings and string_views. More...

Modules
	ASCII
	Functions that operate on codepoints and strings encoded as ASCII.
	Unicode
	Functions and types that operate on Unicode codepoints and strings.

Concepts
concept	ghassanpl::string_ops::string_or_char
	The type is a stringable or a character.
concept	ghassanpl::string_ops::stringable
	The type is "stringable", that is, a continuous range of characters.
concept	ghassanpl::string_ops::string8
	The type is a string with an 8-bit char type.
concept	ghassanpl::string_ops::stringable8
	The type is convertible to a string view with an 8-bit char type.
concept	ghassanpl::string_ops::string_view8
	The type is a string view with an 8-bit char type.
concept	ghassanpl::string_ops::string16
	The type is a string with a 16-bit char type.
concept	ghassanpl::string_ops::stringable16
	The type is convertible to a string view with a 16-bit char type.
concept	ghassanpl::string_ops::string_view16
	The type is a string view with a 16-bit char type.
concept	ghassanpl::string_ops::string32
	The type is a string with an 32-bit char type.
concept	ghassanpl::string_ops::stringable32
	The type is convertible to a string view with a 32-bit char type.
concept	ghassanpl::string_ops::string_view32
	The type is a string view with a 32-bit char type.
concept	ghassanpl::string_ops::charable
	Can a type be bit-cast to a native/utf char type?
concept	ghassanpl::string_ops::char_type
	Whether the type is a native char type.
concept	ghassanpl::string_ops::utf_type
	Whether the type is a utf char type.
concept	ghassanpl::string_ops::stringable_base_type
	Whether the type is a native or utf char type.

Classes
struct	ghassanpl::string_ops::split_range< SINGLE >
	A very basic "range" (not really a C++ range yet) that can be iterated over as if its a range of elements in source split by split_on. More...

Macros
#define	GHPL_FORMAT_TEMPLATE   typename... GHPL_ARGS
#define	GHPL_FORMAT_ARGS   std::string_view ghpl_fmt, GHPL_ARGS&&... ghpl_args
#define	GHPL_FORMAT_FORWARD   ghpl_fmt, std::forward<GHPL_ARGS>(ghpl_args)...
#define	GHPL_FORMAT_CALL   std::vformat(ghpl_fmt, std::make_format_args(std::forward<GHPL_ARGS>(ghpl_args)...))
#define	GHPL_PRINT_CALL   std::vprint_unicode(ghpl_fmt, std::make_format_args(std::forward<GHPL_ARGS>(ghpl_args)...))

Typedefs
using	ghassanpl::string_ops::wide_char16_t = std::conditional_t< sizeof(wchar_t)==sizeof(char16_t), wchar_t, char16_t >
	The default 16-bit char type for the current platform (wchar_t if it is 16-bit, char16_t otherwise)
using	ghassanpl::string_ops::wide_char32_t = std::conditional_t< sizeof(wchar_t)==sizeof(char32_t), wchar_t, char32_t >
	The default 32-bit char type for the current platform (wchar_t if it is 32-bit, char32_t otherwise)
template<charable T>
using	ghassanpl::string_ops::charable_utf_t = std::conditional_t< same_size_and_alignment< T, char8_t >, char8_t, std::conditional_t< same_size_and_alignment< T, char16_t >, char16_t, std::conditional_t< same_size_and_alignment< T, char32_t >, char32_t, void > > >
	The utf char type corresponding to the charable type.
template<charable T>
using	ghassanpl::string_ops::charable_char_t = std::conditional_t< same_size_and_alignment< T, char >, char, std::conditional_t< same_size_and_alignment< T, wide_char16_t >, wide_char16_t, std::conditional_t< same_size_and_alignment< T, wide_char32_t >, wide_char32_t, void > > >
	The native char type corresponding to the charable type.
template<charable T>
using	ghassanpl::string_ops::best_stringable_type = std::conditional_t< stringable_base_type< T >, T, charable_char_t< T > >

Functions
template<typename COUT , typename CIN > requires charable<COUT> && charable<CIN> && same_size_and_alignment<COUT, CIN>
constexpr std::basic_string_view< COUT >	ghassanpl::string_ops::string_view_cast (std::basic_string_view< CIN > id) noexcept
	Casts a string_view to a string_view with a different char type via a simple reinterpret_cast.
constexpr std::string_view	ghassanpl::string_ops::back (std::string_view child_to_back_up, std::string_view parent, size_t n=1) noexcept
	Creates a string_view with its beginning moved back by n characters, limited to a parent range.
constexpr std::string_view	ghassanpl::string_ops::back (std::string_view child_to_back_up, size_t n=1) noexcept
	Creates a string_view with its beginning moved back by n characters.
constexpr bool	ghassanpl::string_ops::is_inside (std::string_view big_string, std::string_view smaller_string)
	Checks if smaller_string is a true subset of big_string (true subset meaning they view over overlapping memory subregions)
constexpr bool	ghassanpl::string_ops::isascii (char32_t cp) noexcept
	Returns true if cp is an ascii codepoint.
constexpr bool	ghassanpl::string_ops::is_ascii (char32_t cp) noexcept
	Returns true if cp is an ascii codepoint.
bool	ghassanpl::string_ops::contains (std::string_view str, char c)
	A pre-C++23 version of str.contains(c)
std::string_view	ghassanpl::string_ops::substr (std::string_view str, intptr_t start, size_t count=std::string::npos) noexcept
	Gets a substring of str starting at start and containing count characters.
std::string_view	ghassanpl::string_ops::prefix (std::string_view str, size_t count) noexcept
	Returns a substring containing the count leftmost characters of str. Always valid, clamped to the bounds of str (or empty).
std::string_view	ghassanpl::string_ops::without_suffix (std::string_view str, size_t count) noexcept
	Returns a substring created by removing count characters from the end. Always valid, clamped to the bounds of str (or empty).
std::string_view	ghassanpl::string_ops::suffix (std::string_view str, size_t count) noexcept
	Returns a substring containing the count rightmost characters of str. Always valid, clamped to the bounds of str (or empty).
std::string_view	ghassanpl::string_ops::without_prefix (std::string_view str, size_t count) noexcept
	Returns a substring created by removing count characters from the start. Always valid, clamped to the bounds of str (or empty).
void	ghassanpl::string_ops::erase_outside_n (std::string &str, size_t start, size_t count) noexcept
	Erases all characters in str outside of the range [start, start + count]. Always safe.
void	ghassanpl::string_ops::erase_outside_from_to (std::string &str, size_t from, size_t to) noexcept
	Erases all characters in str outside of the range [from, to].
template<std::ranges::random_access_range T> requires stringable_base_type<std::ranges::range_value_t<T>>
constexpr bool	ghassanpl::string_ops::isany (char32_t cp, T &&chars) noexcept
	Checks if cp is any of the characters in chars
constexpr bool	ghassanpl::string_ops::isany (char32_t c, char32_t c2) noexcept
	A isany overload that takes a single character.
template<string_or_char NEEDLE, typename FUNC >
void	ghassanpl::string_ops::find_all (std::string_view subject, NEEDLE &&search, FUNC &&func)
template<typename RESULT_TYPE = std::string_view, string_or_char NEEDLE>
std::vector< RESULT_TYPE >	ghassanpl::string_ops::find_all (std::string_view subject, NEEDLE &&search)
std::string	ghassanpl::string_ops::url_encode (std::string_view text)
	Returns a url-encoded version of the string.
std::string	ghassanpl::string_ops::url_unencode (std::string_view text)
	Returns a url-decoded version of the string.
template<std::integral T>
auto	ghassanpl::string_ops::from_chars (std::string_view str, T &value, const int base=10) noexcept
	A version of std::from_chars that takes a std::string_view as the first argument.
template<std::floating_point T>
auto	ghassanpl::string_ops::from_chars (std::string_view str, T &value, const std::chars_format chars_format=std::chars_format::general) noexcept
	A version of std::from_chars that takes a std::string_view as the first argument.
template<typename RESULT_TYPE = std::string_view, typename T , typename FUNC > requires std::is_arithmetic_v<T>&& std::is_invocable_r_v<T, FUNC, std::string_view>
std::vector< RESULT_TYPE >	ghassanpl::string_ops::word_wrap (std::string_view _source, T max_width, FUNC width_getter)
	Performs a basic word-wrapping split of _source, as if it was constrained to max_width.
template<typename RESULT_TYPE = std::string_view, typename T > requires std::is_arithmetic_v<T>
std::vector< RESULT_TYPE >	ghassanpl::string_ops::word_wrap (std::string_view _source, T max_width, T letter_width)
	Word-wrapping function for constant-width characters.
size_t	ghassanpl::string_ops::levenshtein_distance (std::string_view s1, std::string_view s2)
template<typename CALLBACK > requires std::invocable<CALLBACK, size_t, std::string_view, std::string&>
std::string	ghassanpl::string_ops::callback_format (std::string_view fmt, CALLBACK &&callback)

Make Functions
Functions that create string_view and string types from various values Rationale Even though C++20 has a range constructor, it uses operator- on its arguments, which means that iterators from disparate string_views do not work, even if they point to a contiguous string range (for example, were made from substrings of the same string_view). Hence these functions. They should work with any pair of iterators (no support for sentinels yet, unfortunately), support nulls, and are almost as strong as the string_view range constructor in terms of exception and type safety. As with the respective constructors, undefined behavior when start > end.
template<typename C = char>
constexpr std::basic_string_view< C >	ghassanpl::string_ops::make_sv (std::nullptr_t, std::nullptr_t) noexcept
template<stringable_base_type CT, std::contiguous_iterator IT, std::contiguous_iterator IT2> requires charable<std::iter_value_t<IT>>
constexpr auto	ghassanpl::string_ops::make_sv (IT start, IT2 end) noexcept(noexcept(std::to_address(start)))
template<std::contiguous_iterator IT, std::contiguous_iterator IT2> requires charable<std::iter_value_t<IT>>
constexpr auto	ghassanpl::string_ops::make_sv (IT start, IT2 end) noexcept(noexcept(std::to_address(start)))
template<typename T > requires stringable_base_type<std::remove_cvref_t<T>>
constexpr auto	ghassanpl::string_ops::make_sv (T &&single_char) noexcept
template<charable T>
constexpr auto	ghassanpl::string_ops::make_sv (const T *str) noexcept
template<typename C >
constexpr std::basic_string_view< C >	ghassanpl::string_ops::make_sv (std::basic_string_view< C > id) noexcept
template<typename C >
constexpr std::basic_string_view< C >	ghassanpl::string_ops::make_sv (std::basic_string< C > const &id) noexcept
template<typename C >
constexpr std::basic_string_view< C >	ghassanpl::string_ops::make_sv (std::basic_string< C > &&id) noexcept=delete
template<std::ranges::range RANGE> requires charable<std::ranges::range_value_t<RANGE>>
constexpr auto	ghassanpl::string_ops::make_sv (RANGE &&range) noexcept
template<typename... NONARGS, typename... ARGS>
constexpr auto	ghassanpl::string_ops::make_string (ARGS &&... args)

to_string Functions
Basic identity and utility to_string functions. See also Stringification
std::string	ghassanpl::string_ops::to_string (std::string_view from) noexcept
std::string	ghassanpl::string_ops::to_string (std::u8string_view from) noexcept
template<typename T > requires requires { std::to_string(t); }
std::string	ghassanpl::string_ops::to_string (T const &t)
constexpr std::string const &	ghassanpl::string_ops::to_string (std::same_as< std::string > auto const &s)
template<typename T >
std::string	ghassanpl::string_ops::to_string (std::optional< T > const &o)

Trimming Functions
Functions that trim (remove ascii whitespace from) strings and string_views.
constexpr std::string_view	ghassanpl::string_ops::trimmed_whitespace_right (std::string_view str) noexcept
constexpr std::string_view	ghassanpl::string_ops::trimmed_whitespace_left (std::string_view str) noexcept
constexpr std::string_view	ghassanpl::string_ops::trimmed_whitespace (std::string_view str) noexcept
constexpr std::string_view	ghassanpl::string_ops::trimmed_until (std::string_view str, char chr) noexcept
constexpr std::string_view	ghassanpl::string_ops::trimmed (std::string_view str, char chr) noexcept
constexpr std::string	ghassanpl::string_ops::trimmed_whitespace_right (std::string str) noexcept
constexpr std::string	ghassanpl::string_ops::trimmed_whitespace_left (std::string str) noexcept
constexpr std::string	ghassanpl::string_ops::trimmed_whitespace (std::string str) noexcept
constexpr std::string	ghassanpl::string_ops::trimmed_until (std::string str, char chr) noexcept
constexpr std::string	ghassanpl::string_ops::trimmed (std::string str, char chr) noexcept
template<typename FUNC > requires std::is_invocable_r_v<bool, FUNC, char>
std::string_view	ghassanpl::string_ops::trimmed_while (std::string_view str, FUNC &&func) noexcept
constexpr void	ghassanpl::string_ops::trim_whitespace_right (std::string_view &str) noexcept
constexpr void	ghassanpl::string_ops::trim_whitespace_left (std::string_view &str) noexcept
constexpr void	ghassanpl::string_ops::trim_whitespace (std::string_view &str) noexcept
constexpr void	ghassanpl::string_ops::trim_until (std::string_view &str, char chr) noexcept
constexpr void	ghassanpl::string_ops::trim (std::string_view &str, char chr) noexcept
template<typename FUNC > requires std::is_invocable_r_v<bool, FUNC, char>
constexpr void	ghassanpl::string_ops::trim_while (std::string_view &str, FUNC &&func) noexcept

Consume Functions
Functions that "consume" parts of a string_view (that is, remove a section from the beginning or end if the conditions apply). Most of the functions return the consumed part, or 'true/false' if the part to be consumed is given explicitly. These functions do nothing (or the maximum safe amount) if there is nothing appropriate available to consume.
char	ghassanpl::string_ops::consume (std::string_view &str)
	Consumes and returns the first character in the str, or \0 if no more characters.
bool	ghassanpl::string_ops::consume (std::string_view &str, char val)
	Consumes the character val if it's at the beginning of str
bool	ghassanpl::string_ops::consume (std::string_view &str, std::string_view val)
	Consumes the string val if it's at the beginning of str.
template<typename... ARGS>
char	ghassanpl::string_ops::consume_any (std::string_view &str, ARGS &&... args)
	Consumes any of the characters in 'chars' if it's the first char of str.
template<typename PRED > requires std::is_invocable_r_v<bool, PRED, char>
char	ghassanpl::string_ops::consume (std::string_view &str, PRED &&pred)
	Consumes a character from the beginning of str if it matches pred(str[0]).
char	ghassanpl::string_ops::consume_or (std::string_view &str, char or_else)
	Consumes the first character from str, returning it, or or_else if string is empty.
bool	ghassanpl::string_ops::consume_at_end (std::string_view &str, char val)
	Consumes the last character from str if it matches val.
bool	ghassanpl::string_ops::consume_at_end (std::string_view &str, std::string_view val)
	Consumes the string val from the end str
template<typename FUNC > requires std::is_invocable_r_v<bool, FUNC, char>
std::string_view	ghassanpl::string_ops::consume_while (std::string_view &str, FUNC &&pred)
	Consumes characters from the beginning of str while they match pred(str[0]).
std::string_view	ghassanpl::string_ops::consume_while (std::string_view &str, char c)
	Consumes characters from the beginning of str while they are equal to c.
template<typename... ARGS>
std::string_view	ghassanpl::string_ops::consume_while_any (std::string_view &str, ARGS &&... args)
	Consumes a run of any of the characters in 'chars' at the beginning of str.
template<typename FUNC > requires std::is_invocable_r_v<bool, FUNC, char>
std::string_view	ghassanpl::string_ops::consume_until (std::string_view &str, FUNC &&pred)
	Consumes characters from the beginning of str until one matches pred(str[0]), exclusive.
std::string_view	ghassanpl::string_ops::consume_until (std::string_view &str, char c)
	Consumes characters from the beginning of str until one is equal to c, exclusive.
std::string_view	ghassanpl::string_ops::consume_until (std::string_view &str, std::string_view end)
	Consumes characters from the beginning of str until the string starts with end, exclusive.
template<typename... ARGS>
std::string_view	ghassanpl::string_ops::consume_until_any (std::string_view &str, ARGS &&... args)
	Consumes characters from the beginning of str until one is equal to any in the parameter pack, exclusive.
std::string_view	ghassanpl::string_ops::consume_until_delim (std::string_view &str, char c)
	Consumes characters from the beginning of str until one is equal to c, inclusive.
std::string_view	ghassanpl::string_ops::consume_n (std::string_view &str, size_t n)
	Consumes at most n characters from the beginning of str.
template<typename FUNC > requires std::is_invocable_r_v<bool, FUNC, char>
std::string_view	ghassanpl::string_ops::consume_n (std::string_view &str, size_t n, FUNC &&pred)
	Consumes at most n characters from the beginning of str that match pred(str[0]).
template<typename CALLBACK > requires std::is_invocable_r_v<bool, CALLBACK, std::string_view&>
bool	ghassanpl::string_ops::consume_delimited_list_non_empty (std::string_view &str, std::string_view delimiter, CALLBACK callback)
	Consumes a list of delimiter-delimited strings, calling callback(str) each time; whitespaces before and after items are trimmed.
template<typename CALLBACK > requires std::is_invocable_r_v<bool, CALLBACK, std::string_view>
bool	ghassanpl::string_ops::consume_delimited_list (std::string_view &str, std::string_view delimiter, std::string_view closer, CALLBACK callback)
	Consumes a list of delimiter-delimited strings, ended with closer, calling callback(str) each time; whitespaces before and after items are trimmed.

Split Functions
Functions that split strings into multiple parts, each delimited with some sort of delimiter.
template<typename FUNC > requires std::is_invocable_v<FUNC, std::string_view, bool>
constexpr void	ghassanpl::string_ops::split (std::string_view source, char delim, FUNC &&func) noexcept(noexcept(func(std::string_view{}, true)))
	Performs a basic "split" operation, calling func for each part of source delimited by delim.
template<typename FUNC > requires std::is_invocable_v<FUNC, std::string_view, bool>
constexpr void	ghassanpl::string_ops::split (std::string_view source, std::string_view delim, FUNC &&func) noexcept(noexcept(func(std::string_view{}, true)))
	Performs a basic "split" operation, calling func for each part of source delimited by delim.
template<typename FUNC > requires std::is_invocable_v<FUNC, std::string_view, bool>
constexpr void	ghassanpl::string_ops::split_on_any (std::string_view source, std::string_view delim, FUNC &&func) noexcept(noexcept(func(std::string_view{}, true)))
	Performs a basic "split" operation, calling func for each part of source delimited by any character in delim.
template<typename DELIM_FUNC , typename FUNC > requires std::is_invocable_v<FUNC, std::string_view, bool>&& std::is_invocable_r_v<size_t, DELIM_FUNC, std::string_view>
void	ghassanpl::string_ops::split_on (std::string_view source, DELIM_FUNC &&delim, FUNC &&func) noexcept(noexcept(func(std::string_view{}, true)) &&noexcept(delim(std::string_view{})))
	Performs a basic "split" operation, calling func for each part of source delimited by the delim function.
constexpr std::pair< std::string_view, std::string_view >	ghassanpl::string_ops::split_at (std::string_view src, size_t split_at) noexcept
	Does not include the character at split_at in the returned strings.
constexpr bool	ghassanpl::string_ops::split_at (std::string_view src, size_t split_at, std::string_view &first, std::string_view &second) noexcept
	Does not include the character at split_at in the returned strings.
constexpr std::pair< std::string_view, std::string_view >	ghassanpl::string_ops::single_split (std::string_view src, char delim) noexcept
	Splits src once on the first instance of delim
constexpr std::pair< std::string_view, std::string_view >	ghassanpl::string_ops::single_split_last (std::string_view src, char delim) noexcept
	Splits src once on the last instance of delim
constexpr bool	ghassanpl::string_ops::single_split (std::string_view src, char delim, std::string_view &first, std::string_view &second) noexcept
	Splits src once on the first instance of delim
constexpr bool	ghassanpl::string_ops::single_split_last (std::string_view src, char delim, std::string_view &first, std::string_view &second) noexcept
	Splits src once on the last instance of delim
template<typename FUNC > requires std::is_invocable_v<FUNC, std::string_view, bool>
void	ghassanpl::string_ops::natural_split (std::string_view source, char delim, FUNC &&func) noexcept
	Performs a more natural split of the string, that is: ignoring multiple delimiters in a row, and empty items.
template<typename RESULT_TYPE = std::string_view, string_or_char DELIM>
constexpr std::vector< RESULT_TYPE >	ghassanpl::string_ops::split (std::string_view source, DELIM &&delim) noexcept
	Performs a basic "split" operation, returning a std::vector of the split parts.
template<typename RESULT_TYPE = std::string_view>
constexpr std::vector< RESULT_TYPE >	ghassanpl::string_ops::split_on_any (std::string_view source, std::string_view delim) noexcept
	Performs a basic "split" operation, returning a std::vector of the split parts.
template<typename RESULT_TYPE = std::string_view, typename DELIM_FUNC > requires std::is_invocable_r_v<size_t, DELIM_FUNC, std::string_view>
std::vector< RESULT_TYPE >	ghassanpl::string_ops::split_on (std::string_view source, DELIM_FUNC &&delim) noexcept(noexcept(delim(std::string_view{})))
	Performs a basic "split" operation, returning a std::vector of the split parts.
template<typename RESULT_TYPE = std::string_view, string_or_char DELIM>
std::vector< RESULT_TYPE >	ghassanpl::string_ops::natural_split (std::string_view source, DELIM &&delim) noexcept
	Performs a more natural split of the string, that is: ignoring multiple delimiters in a row, and empty items; returns a std::vector of the split parts.

Join Functions
Functions that join a range of formattable elements into a single string Note Formatting is done using stream operators (operator<<). Todo: Use Stringification instead
template<std::ranges::range T>
auto	ghassanpl::string_ops::join (T &&source)
	Returns a string that is created by joining together string representation of the elements in the source range.
template<std::ranges::range T, string_or_char DELIM>
auto	ghassanpl::string_ops::join (T &&source, DELIM const &delim)
	Returns a string that is created by joining together string representation of the elements in the source range, separated by delim; delim is only added between elements.
template<std::ranges::range... RANGES, string_or_char DELIM>
auto	ghassanpl::string_ops::join_multiple (DELIM const &delim, RANGES &&... sources)
	Returns a string that is created by joining together string representation of the elements in the sources ranges, separated by delim; delim is only added between elements.
template<std::ranges::range T, string_or_char DELIM, string_or_char LAST_DELIM>
auto	ghassanpl::string_ops::join_and (T &&source, DELIM const &delim, LAST_DELIM &&last_delim)
	Returns a string that is created by joining together string representation of the elements in the source range, separated by delim; delim is only added between elements; the last element is delimited by last_delim instead of delim.
template<std::ranges::range T, string_or_char DELIM, string_or_char LAST_DELIM, typename FUNC >
auto	ghassanpl::string_ops::join_and (T &&source, DELIM const &delim, LAST_DELIM &&last_delim, FUNC &&transform_func)
	Same as join(T&& source, DELIM const& delim, LAST_DELIM&& last_delim) except each element is transformed by transform_func before being stringified and added to the result.
template<std::ranges::range T, typename FUNC , string_or_char DELIM>
auto	ghassanpl::string_ops::join (T &&source, DELIM const &delim, FUNC &&transform_func)
	Same as join(T&& source, DELIM const& delim) except each element is transformed by transform_func before being stringified and added to the result.

Replace and Escape Functions
Warning A lot of these functions have stupid and/or subtle bugs, or are not intuitive in their behavior. Use at your own risk. Pull requests welcome. Todo: C++23's format has a string format specifications that automatically escape, use those when they become available
template<string_or_char NEEDLE, string_or_char REPLACE>
void	ghassanpl::string_ops::replace (std::string &subject, NEEDLE &&search, REPLACE &&replace)
template<string_or_char NEEDLE, string_or_char REPLACE>
std::string	ghassanpl::string_ops::replaced (std::string subject, NEEDLE &&search, REPLACE &&replace)
template<string_or_char DELIMITER = char, string_or_char ESCAPE = char>
void	ghassanpl::string_ops::quote (std::string &subject, DELIMITER delimiter='"', ESCAPE escape = '\\')
template<string_or_char DELIMITER = char, string_or_char ESCAPE = char>
std::string	ghassanpl::string_ops::quoted (std::string &&subject, DELIMITER &&delimiter='"', ESCAPE&& escape = '\\')
template<string_or_char DELIMITER = char, string_or_char ESCAPE = char>
std::string	ghassanpl::string_ops::quoted (std::string_view subject, DELIMITER &&delimiter='"', ESCAPE&& escape = '\\')
template<string_or_char DELIMITER = char, string_or_char ESCAPE = char>
std::string	ghassanpl::string_ops::quoted (const char *subject, DELIMITER &&delimiter='"', ESCAPE&& escape = '\\')
template<typename ESCAPE_FUNC > requires std::is_invocable_v<ESCAPE_FUNC, std::string_view>&& std::is_constructible_v<std::string_view, std::invoke_result_t<ESCAPE_FUNC, std::string_view>>
void	ghassanpl::string_ops::escape (std::string &subject, std::string_view chars_to_escape, ESCAPE_FUNC &&escape_func)
template<string_or_char ESCAPE = char>
void	ghassanpl::string_ops::escape (std::string &subject, std::string_view chars_to_escape, ESCAPE &&escape='\\')
template<typename ESCAPE_FUNC , typename ISPRINTABLE_FUNC = decltype(ascii::isprint)>
void	ghassanpl::string_ops::escape_non_printable (std::string &subject, ESCAPE_FUNC &&escape_func, ISPRINTABLE_FUNC &&isprintable_func=ascii::isprint)
void	ghassanpl::string_ops::escape_non_printable (std::string &subject)
template<typename STR , string_or_char ESCAPE = char>
std::string	ghassanpl::string_ops::escaped (STR &&subject, std::string_view to_escape="\"\\", ESCAPE &&escape_str='\\')
	Lint Note: Changing the initializer of to_escape to a R-string breaks doxygen.
template<typename STR >
std::string	ghassanpl::string_ops::escaped_non_printable (STR &&subject)

sto* replacements
Functions equivalent to std::stoi, std::stod, etc that take std::string_view as its first argument
int	ghassanpl::string_ops::stoi (std::string_view str, size_t *idx=nullptr, int base=10)
long	ghassanpl::string_ops::stol (std::string_view str, size_t *idx=nullptr, int base=10)
long long	ghassanpl::string_ops::stoll (std::string_view str, size_t *idx=nullptr, int base=10)
unsigned long	ghassanpl::string_ops::stoul (std::string_view str, size_t *idx=nullptr, int base=10)
unsigned long long	ghassanpl::string_ops::stoull (std::string_view str, size_t *idx=nullptr, int base=10)
float	ghassanpl::string_ops::stof (std::string_view str, size_t *idx=nullptr, std::chars_format format=std::chars_format::general)
double	ghassanpl::string_ops::stod (std::string_view str, size_t *idx=nullptr, std::chars_format format=std::chars_format::general)
long double	ghassanpl::string_ops::stold (std::string_view str, size_t *idx=nullptr, std::chars_format format=std::chars_format::general)

Detailed Description

Adds a few utility functions that deal with strings and string_views.

Macro Definition Documentation

GHPL_FORMAT_ARGS

#define GHPL_FORMAT_ARGS   std::string_view ghpl_fmt, GHPL_ARGS&&... ghpl_args

Definition at line 1787 of file string_ops.h.

GHPL_FORMAT_CALL

#define GHPL_FORMAT_CALL   std::vformat(ghpl_fmt, std::make_format_args(std::forward<GHPL_ARGS>(ghpl_args)...))

Definition at line 1791 of file string_ops.h.

GHPL_FORMAT_FORWARD

#define GHPL_FORMAT_FORWARD   ghpl_fmt, std::forward<GHPL_ARGS>(ghpl_args)...

Definition at line 1789 of file string_ops.h.

GHPL_FORMAT_TEMPLATE

#define GHPL_FORMAT_TEMPLATE   typename... GHPL_ARGS

Definition at line 1785 of file string_ops.h.

GHPL_PRINT_CALL

#define GHPL_PRINT_CALL   std::vprint_unicode(ghpl_fmt, std::make_format_args(std::forward<GHPL_ARGS>(ghpl_args)...))

Definition at line 1793 of file string_ops.h.

Typedef Documentation

best_stringable_type

template<charable T>

using ghassanpl::string_ops::best_stringable_type = typedef std::conditional_t<stringable_base_type<T>, T, charable_char_t<T> >

Definition at line 125 of file string_ops.h.

charable_char_t

template<charable T>

using ghassanpl::string_ops::charable_char_t = typedef std::conditional_t<same_size_and_alignment<T, char>, char, std::conditional_t<same_size_and_alignment<T, wide_char16_t>, wide_char16_t, std::conditional_t<same_size_and_alignment<T, wide_char32_t>, wide_char32_t, void > >>

The native char type corresponding to the charable type.

Definition at line 118 of file string_ops.h.

charable_utf_t

template<charable T>

using ghassanpl::string_ops::charable_utf_t = typedef std::conditional_t<same_size_and_alignment<T, char8_t>, char8_t, std::conditional_t<same_size_and_alignment<T, char16_t>, char16_t, std::conditional_t<same_size_and_alignment<T, char32_t>, char32_t, void > >>

The utf char type corresponding to the charable type.

Definition at line 110 of file string_ops.h.

wide_char16_t

using ghassanpl::string_ops::wide_char16_t = typedef std::conditional_t<sizeof(wchar_t) == sizeof(char16_t), wchar_t, char16_t>

The default 16-bit char type for the current platform (wchar_t if it is 16-bit, char16_t otherwise)

Definition at line 78 of file string_ops.h.

wide_char32_t

using ghassanpl::string_ops::wide_char32_t = typedef std::conditional_t<sizeof(wchar_t) == sizeof(char32_t), wchar_t, char32_t>

The default 32-bit char type for the current platform (wchar_t if it is 32-bit, char32_t otherwise)

Definition at line 81 of file string_ops.h.

Function Documentation

back() [1/2]

constexpr std::string_view ghassanpl::string_ops::back ( std::string_view  child_to_back_up, size_t  n = 1  )

constexprnoexcept

Creates a string_view with its beginning moved back by n characters.

Example

parent = "HelloWorld"; 
child = parent.substr(5); 
n = 1; 
back(child, n) => "oWorld";

Note

This is, of course, unsafe to do if the new beginning is beyond the underlying string's range

Parameters

child_to_back_up	the input string_view
n	how many characters to back up

Definition at line 260 of file string_ops.h.

back() [2/2]

constexpr std::string_view ghassanpl::string_ops::back ( std::string_view  child_to_back_up, std::string_view  parent, size_t  n = 1  )

constexprnoexcept

Creates a string_view with its beginning moved back by n characters, limited to a parent range.

Example

parent = "HelloWorld"; 
child = parent.substr(5); 
n = 1; 
back(child, parent, n) => "oWorld";

Parameters

child_to_back_up	the input string_view
parent	a string_view that child_to_back_up is a subview of
n	how many characters to back up

Definition at line 241 of file string_ops.h.

callback_format()

template<typename CALLBACK >
requires std::invocable<CALLBACK, size_t, std::string_view, std::string&>

std::string ghassanpl::string_ops::callback_format	(	std::string_view	fmt,
		CALLBACK &&	callback
	)

Definition at line 1745 of file string_ops.h.

consume() [1/4]

char ghassanpl::string_ops::consume ( std::string_view &  str )

inline

Consumes and returns the first character in the str, or \0 if no more characters.

Definition at line 652 of file string_ops.h.

consume() [2/4]

bool ghassanpl::string_ops::consume ( std::string_view &  str, char  val  )

inline

Consumes the character val if it's at the beginning of str

Returns

whether it actually consumed

Definition at line 663 of file string_ops.h.

consume() [3/4]

template<typename PRED >
requires std::is_invocable_r_v<bool, PRED, char>

char ghassanpl::string_ops::consume ( std::string_view &  str, PRED &&  pred  )

inline

Consumes a character from the beginning of str if it matches pred(str[0]).

Returns

the matched character, or \0 if no match

Definition at line 703 of file string_ops.h.

consume() [4/4]

bool ghassanpl::string_ops::consume ( std::string_view &  str, std::string_view  val  )

inline

Consumes the string val if it's at the beginning of str.

Returns

whether it actually consumed

Definition at line 675 of file string_ops.h.

consume_any()

template<typename... ARGS>

char ghassanpl::string_ops::consume_any ( std::string_view &  str, ARGS &&...  args  )

inline

Consumes any of the characters in 'chars' if it's the first char of str.

Returns

the consumed character, or \0 if none found

Definition at line 688 of file string_ops.h.

consume_at_end() [1/2]

bool ghassanpl::string_ops::consume_at_end ( std::string_view &  str, char  val  )

inline

Consumes the last character from str if it matches val.

Returns

whether it consumed

See also

consume(std::string_view&, char)

Definition at line 727 of file string_ops.h.

consume_at_end() [2/2]

bool ghassanpl::string_ops::consume_at_end ( std::string_view &  str, std::string_view  val  )

inline

Consumes the string val from the end str

Returns

whether it consumed

See also

consume(std::string_view&, char)

Definition at line 741 of file string_ops.h.

consume_delimited_list()

template<typename CALLBACK >
requires std::is_invocable_r_v<bool, CALLBACK, std::string_view>

bool ghassanpl::string_ops::consume_delimited_list ( std::string_view &  str, std::string_view  delimiter, std::string_view  closer, CALLBACK  callback  )

inline

Consumes a list of delimiter-delimited strings, ended with closer, calling callback(str) each time; whitespaces before and after items are trimmed.

Stops when closer is consumed.

Attention

callback will be called with the ENTIRE string left after consuming the delimiter, so you have to consume the list elements yourself!

Example

consume_delimited_list("alpha, beta, gamma, omega ), blah, bleh", ",", ")" [](auto& sv) { println("'{}'", consume_while(sv, ascii::isalpha)); return true; });
>> will print
'alpha'
'beta'
'gamma'
'omega'

Parameters

callback

must be invocable as callback(string_view&) -> bool; if the callback returns false, consumption is stopped

Returns

true if closer is consumed; false if callback returned false at any point or if end-of-string is encountered before closer is consumed

Definition at line 924 of file string_ops.h.

consume_delimited_list_non_empty()

template<typename CALLBACK >
requires std::is_invocable_r_v<bool, CALLBACK, std::string_view&>

bool ghassanpl::string_ops::consume_delimited_list_non_empty ( std::string_view &  str, std::string_view  delimiter, CALLBACK  callback  )

inline

Consumes a list of delimiter-delimited strings, calling callback(str) each time; whitespaces before and after items are trimmed.

Attention

callback will be called with the ENTIRE string left after consuming the delimiter, so you have to consume the list elements yourself!

Example

consume_delimited_list_non_empty("alpha, beta, gamma, omega", ",", [](auto& sv) { println("'{}'", consume_until(sv, ',')); return true; });
>> will print
'alpha'
'beta'
'gamma'
'omega'

Parameters

callback

must be invocable as callback(string_view&) -> bool; if the callback returns false, consumption is stopped; otherwise, this function must consume its item from the given string view

Returns

true if consumption ended, either by making the string empty, or encountering a non-delimiter after callback; false if callback returned false at any point

Definition at line 895 of file string_ops.h.

consume_n() [1/2]

std::string_view ghassanpl::string_ops::consume_n ( std::string_view &  str, size_t  n  )

inline

Consumes at most n characters from the beginning of str.

Returns

the consumed prefix as a string_view

Definition at line 857 of file string_ops.h.

consume_n() [2/2]

template<typename FUNC >
requires std::is_invocable_r_v<bool, FUNC, char>

std::string_view ghassanpl::string_ops::consume_n ( std::string_view &  str, size_t  n, FUNC &&  pred  )

inline

Consumes at most n characters from the beginning of str that match pred(str[0]).

Returns

the consumed prefix as a string_view

Definition at line 869 of file string_ops.h.

consume_or()

char ghassanpl::string_ops::consume_or ( std::string_view &  str, char  or_else  )

inline

Consumes the first character from str, returning it, or or_else if string is empty.

Definition at line 715 of file string_ops.h.

consume_until() [1/3]

std::string_view ghassanpl::string_ops::consume_until ( std::string_view &  str, char  c  )

inline

Consumes characters from the beginning of str until one is equal to c, exclusive.

Returns

the consumed prefix as a string_view

Definition at line 798 of file string_ops.h.

consume_until() [2/3]

template<typename FUNC >
requires std::is_invocable_r_v<bool, FUNC, char>

std::string_view ghassanpl::string_ops::consume_until ( std::string_view &  str, FUNC &&  pred  )

inline

Consumes characters from the beginning of str until one matches pred(str[0]), exclusive.

Returns

the consumed prefix as a string_view

Definition at line 788 of file string_ops.h.

consume_until() [3/3]

std::string_view ghassanpl::string_ops::consume_until ( std::string_view &  str, std::string_view  end  )

inline

Consumes characters from the beginning of str until the string starts with end, exclusive.

Returns

the consumed prefix as a string_view

Definition at line 808 of file string_ops.h.

consume_until_any()

template<typename... ARGS>

std::string_view ghassanpl::string_ops::consume_until_any ( std::string_view &  str, ARGS &&...  args  )

inline

Consumes characters from the beginning of str until one is equal to any in the parameter pack, exclusive.

Returns

the consumed prefix as a string_view

Definition at line 834 of file string_ops.h.

consume_until_delim()

std::string_view ghassanpl::string_ops::consume_until_delim ( std::string_view &  str, char  c  )

inline

Consumes characters from the beginning of str until one is equal to c, inclusive.

Returns

the consumed prefix as a string_view

Definition at line 844 of file string_ops.h.

consume_while() [1/2]

std::string_view ghassanpl::string_ops::consume_while ( std::string_view &  str, char  c  )

inline

Consumes characters from the beginning of str while they are equal to c.

Returns

the consumed prefix as a string_view

Definition at line 765 of file string_ops.h.

consume_while() [2/2]

template<typename FUNC >
requires std::is_invocable_r_v<bool, FUNC, char>

std::string_view ghassanpl::string_ops::consume_while ( std::string_view &  str, FUNC &&  pred  )

inline

Consumes characters from the beginning of str while they match pred(str[0]).

Returns

the consumed prefix as a string_view

Definition at line 755 of file string_ops.h.

consume_while_any()

template<typename... ARGS>

std::string_view ghassanpl::string_ops::consume_while_any ( std::string_view &  str, ARGS &&...  args  )

inline

Consumes a run of any of the characters in 'chars' at the beginning of str.

Returns

the consumed character, or \0 if none found

Definition at line 776 of file string_ops.h.

contains()

bool ghassanpl::string_ops::contains ( std::string_view  str, char  c  )

inline

A pre-C++23 version of str.contains(c)

Definition at line 547 of file string_ops.h.

erase_outside_from_to()

void ghassanpl::string_ops::erase_outside_from_to ( std::string &  str, size_t  from, size_t  to  )

inlinenoexcept

Erases all characters in str outside of the range [from, to].

Always safe. If from > to, acts as if calling erase_outside_from_to(str, to, from)

Definition at line 598 of file string_ops.h.

erase_outside_n()

void ghassanpl::string_ops::erase_outside_n ( std::string &  str, size_t  start, size_t  count  )

inlinenoexcept

Erases all characters in str outside of the range [start, start + count]. Always safe.

Definition at line 591 of file string_ops.h.

escape() [1/2]

template<string_or_char ESCAPE = char>

void ghassanpl::string_ops::escape ( std::string &  subject, std::string_view  chars_to_escape, ESCAPE &&  escape = '\\'  )

inline

Definition at line 1413 of file string_ops.h.

escape() [2/2]

template<typename ESCAPE_FUNC >
requires std::is_invocable_v<ESCAPE_FUNC, std::string_view>&& std::is_constructible_v<std::string_view, std::invoke_result_t<ESCAPE_FUNC, std::string_view>>

void ghassanpl::string_ops::escape ( std::string &  subject, std::string_view  chars_to_escape, ESCAPE_FUNC &&  escape_func  )

inline

Definition at line 1398 of file string_ops.h.

escape_non_printable() [1/2]

void ghassanpl::string_ops::escape_non_printable ( std::string &  subject )

inline

Definition at line 1447 of file string_ops.h.

escape_non_printable() [2/2]

template<typename ESCAPE_FUNC , typename ISPRINTABLE_FUNC = decltype(ascii::isprint)>

void ghassanpl::string_ops::escape_non_printable ( std::string &  subject, ESCAPE_FUNC &&  escape_func, ISPRINTABLE_FUNC &&  isprintable_func = ascii::isprint  )

inline

Definition at line 1429 of file string_ops.h.

escaped()

template<typename STR , string_or_char ESCAPE = char>

std::string ghassanpl::string_ops::escaped ( STR &&  subject, std::string_view  to_escape = "\"\\", ESCAPE &&  escape_str = '\\'  )

inline

Lint Note: Changing the initializer of to_escape to a R-string breaks doxygen.

Definition at line 1455 of file string_ops.h.

escaped_non_printable()

template<typename STR >

std::string ghassanpl::string_ops::escaped_non_printable ( STR &&  subject )

inline

Definition at line 1463 of file string_ops.h.

find_all() [1/2]

template<typename RESULT_TYPE = std::string_view, string_or_char NEEDLE>

std::vector< RESULT_TYPE > ghassanpl::string_ops::find_all ( std::string_view  subject, NEEDLE &&  search  )

inline

Definition at line 1318 of file string_ops.h.

find_all() [2/2]

template<string_or_char NEEDLE, typename FUNC >

void ghassanpl::string_ops::find_all ( std::string_view  subject, NEEDLE &&  search, FUNC &&  func  )

inline

Definition at line 1302 of file string_ops.h.

from_chars() [1/2]

template<std::integral T>

auto ghassanpl::string_ops::from_chars ( std::string_view  str, T &  value, const int  base = 10  )

inlinenoexcept

A version of std::from_chars that takes a std::string_view as the first argument.

Definition at line 1535 of file string_ops.h.

from_chars() [2/2]

template<std::floating_point T>

auto ghassanpl::string_ops::from_chars ( std::string_view  str, T &  value, const std::chars_format  chars_format = std::chars_format::general  )

inlinenoexcept

A version of std::from_chars that takes a std::string_view as the first argument.

Definition at line 1540 of file string_ops.h.

is_ascii()

constexpr bool ghassanpl::string_ops::is_ascii ( char32_t  cp )

constexprnoexcept

Returns true if cp is an ascii codepoint.

Definition at line 544 of file string_ops.h.

is_inside()

constexpr bool ghassanpl::string_ops::is_inside ( std::string_view  big_string, std::string_view  smaller_string  )

constexpr

Checks if smaller_string is a true subset of big_string (true subset meaning they view over overlapping memory subregions)

Definition at line 266 of file string_ops.h.

isany() [1/2]

constexpr bool ghassanpl::string_ops::isany ( char32_t  c, char32_t  c2  )

constexprnoexcept

A isany overload that takes a single character.

Definition at line 643 of file string_ops.h.

isany() [2/2]

template<std::ranges::random_access_range T>
requires stringable_base_type<std::ranges::range_value_t<T>>

constexpr bool ghassanpl::string_ops::isany ( char32_t  cp, T &&  chars  )

constexprnoexcept

Checks if cp is any of the characters in chars

Definition at line 638 of file string_ops.h.

isascii()

constexpr bool ghassanpl::string_ops::isascii ( char32_t  cp )

constexprnoexcept

Returns true if cp is an ascii codepoint.

Definition at line 540 of file string_ops.h.

join() [1/3]

template<std::ranges::range T>

auto ghassanpl::string_ops::join ( T &&  source )

inline

Returns a string that is created by joining together string representation of the elements in the source range.

Definition at line 1183 of file string_ops.h.

join() [2/3]

template<std::ranges::range T, string_or_char DELIM>

auto ghassanpl::string_ops::join ( T &&  source, DELIM const &  delim  )

inline

Returns a string that is created by joining together string representation of the elements in the source range, separated by delim; delim is only added between elements.

Definition at line 1193 of file string_ops.h.

join() [3/3]

template<std::ranges::range T, typename FUNC , string_or_char DELIM>

auto ghassanpl::string_ops::join ( T &&  source, DELIM const &  delim, FUNC &&  transform_func  )

inline

Same as join(T&& source, DELIM const& delim) except each element is transformed by transform_func before being stringified and added to the result.

Parameters

transform_func

must be invocable as transform_fun(el) for each element in the source range

Definition at line 1286 of file string_ops.h.

join_and() [1/2]

template<std::ranges::range T, string_or_char DELIM, string_or_char LAST_DELIM>

auto ghassanpl::string_ops::join_and ( T &&  source, DELIM const &  delim, LAST_DELIM &&  last_delim  )

inline

Returns a string that is created by joining together string representation of the elements in the source range, separated by delim; delim is only added between elements; the last element is delimited by last_delim instead of delim.

Definition at line 1227 of file string_ops.h.

join_and() [2/2]

template<std::ranges::range T, string_or_char DELIM, string_or_char LAST_DELIM, typename FUNC >

auto ghassanpl::string_ops::join_and ( T &&  source, DELIM const &  delim, LAST_DELIM &&  last_delim, FUNC &&  transform_func  )

inline

Same as join(T&& source, DELIM const& delim, LAST_DELIM&& last_delim) except each element is transformed by transform_func before being stringified and added to the result.

Parameters

transform_func

must be invocable as transform_fun(el) for each element in the source range

Definition at line 1257 of file string_ops.h.

join_multiple()

template<std::ranges::range... RANGES, string_or_char DELIM>

auto ghassanpl::string_ops::join_multiple ( DELIM const &  delim, RANGES &&...  sources  )

inline

Returns a string that is created by joining together string representation of the elements in the sources ranges, separated by delim; delim is only added between elements.

Definition at line 1208 of file string_ops.h.

levenshtein_distance()

size_t ghassanpl::string_ops::levenshtein_distance ( std::string_view  s1, std::string_view  s2  )

inline

Definition at line 1673 of file string_ops.h.

make_string()

template<typename... NONARGS, typename... ARGS>

constexpr auto ghassanpl::string_ops::make_string ( ARGS &&...  args )

constexpr

Definition at line 188 of file string_ops.h.

make_sv() [1/8]

template<charable T>

constexpr auto ghassanpl::string_ops::make_sv ( const T *  str )

constexprnoexcept

Definition at line 168 of file string_ops.h.

make_sv() [2/8]

template<stringable_base_type CT, std::contiguous_iterator IT, std::contiguous_iterator IT2>
requires charable<std::iter_value_t<IT>>

constexpr auto ghassanpl::string_ops::make_sv ( IT  start, IT2  end  )

constexprnoexcept

Definition at line 146 of file string_ops.h.

make_sv() [3/8]

template<std::contiguous_iterator IT, std::contiguous_iterator IT2>
requires charable<std::iter_value_t<IT>>

constexpr auto ghassanpl::string_ops::make_sv ( IT  start, IT2  end  )

constexprnoexcept

Definition at line 155 of file string_ops.h.

make_sv() [4/8]

template<std::ranges::range RANGE>
requires charable<std::ranges::range_value_t<RANGE>>

constexpr auto ghassanpl::string_ops::make_sv ( RANGE &&  range )

constexprnoexcept

Definition at line 182 of file string_ops.h.

make_sv() [5/8]

template<typename C >

constexpr std::basic_string_view< C > ghassanpl::string_ops::make_sv ( std::basic_string< C > const &  id )

constexprnoexcept

Definition at line 176 of file string_ops.h.

make_sv() [6/8]

template<typename C >

constexpr std::basic_string_view< C > ghassanpl::string_ops::make_sv ( std::basic_string_view< C >  id )

constexprnoexcept

Definition at line 174 of file string_ops.h.

make_sv() [7/8]

template<typename C = char>

constexpr std::basic_string_view< C > ghassanpl::string_ops::make_sv ( std::nullptr_t  , std::nullptr_t    )

constexprnoexcept

Definition at line 142 of file string_ops.h.

make_sv() [8/8]

template<typename T >
requires stringable_base_type<std::remove_cvref_t<T>>

constexpr auto ghassanpl::string_ops::make_sv ( T &&  single_char )

constexprnoexcept

Definition at line 162 of file string_ops.h.

natural_split() [1/2]

template<typename FUNC >
requires std::is_invocable_v<FUNC, std::string_view, bool>

void ghassanpl::string_ops::natural_split ( std::string_view  source, char  delim, FUNC &&  func  )

inlinenoexcept

Performs a more natural split of the string, that is: ignoring multiple delimiters in a row, and empty items.

See also

split(std::string_view source, char delim, FUNC&& func)

Example

split("these   are matched words ", ' ', [](auto sv, bool){ println("'{}'", sv); });
>> will print
'these'
'are'
'matched'
'words'

Definition at line 1101 of file string_ops.h.

natural_split() [2/2]

template<typename RESULT_TYPE = std::string_view, string_or_char DELIM>

std::vector< RESULT_TYPE > ghassanpl::string_ops::natural_split ( std::string_view  source, DELIM &&  delim  )

inlinenoexcept

Performs a more natural split of the string, that is: ignoring multiple delimiters in a row, and empty items; returns a std::vector of the split parts.

See also

natural_split(std::string_view source, char delim, FUNC&& func)

Definition at line 1164 of file string_ops.h.

prefix()

std::string_view ghassanpl::string_ops::prefix ( std::string_view  str, size_t  count  )

inlinenoexcept

Returns a substring containing the count leftmost characters of str. Always valid, clamped to the bounds of str (or empty).

Definition at line 571 of file string_ops.h.

quote()

template<string_or_char DELIMITER = char, string_or_char ESCAPE = char>

void ghassanpl::string_ops::quote ( std::string &  subject, DELIMITER  delimiter = '"', ESCAPE  escape = '\\'  )

inline

Definition at line 1359 of file string_ops.h.

quoted() [1/3]

template<string_or_char DELIMITER = char, string_or_char ESCAPE = char>

std::string ghassanpl::string_ops::quoted ( const char *  subject, DELIMITER &&  delimiter = '"', ESCAPE &&  escape = '\\'  )

inline

Definition at line 1391 of file string_ops.h.

quoted() [2/3]

template<string_or_char DELIMITER = char, string_or_char ESCAPE = char>

std::string ghassanpl::string_ops::quoted ( std::string &&  subject, DELIMITER &&  delimiter = '"', ESCAPE &&  escape = '\\'  )

inline

Definition at line 1376 of file string_ops.h.

quoted() [3/3]

template<string_or_char DELIMITER = char, string_or_char ESCAPE = char>

std::string ghassanpl::string_ops::quoted ( std::string_view  subject, DELIMITER &&  delimiter = '"', ESCAPE &&  escape = '\\'  )

inline

Definition at line 1383 of file string_ops.h.

replace()

template<string_or_char NEEDLE, string_or_char REPLACE>

void ghassanpl::string_ops::replace ( std::string &  subject, NEEDLE &&  search, REPLACE &&  replace  )

inline

Definition at line 1332 of file string_ops.h.

replaced()

template<string_or_char NEEDLE, string_or_char REPLACE>

std::string ghassanpl::string_ops::replaced ( std::string  subject, NEEDLE &&  search, REPLACE &&  replace  )

inline

Definition at line 1352 of file string_ops.h.

single_split() [1/2]

constexpr std::pair< std::string_view, std::string_view > ghassanpl::string_ops::single_split ( std::string_view  src, char  delim  )

constexprnoexcept

Splits src once on the first instance of delim

Returns

a pair of string_views: the left and right parts of src split the first instance of delim; if no delim is found, returns { src, {} }

Definition at line 1058 of file string_ops.h.

single_split() [2/2]

constexpr bool ghassanpl::string_ops::single_split ( std::string_view  src, char  delim, std::string_view &  first, std::string_view &  second  )

constexprnoexcept

Splits src once on the first instance of delim

Returns

whether delim was found

Parameters

first	will be filled with the left part of the string, if delim is found
second	will be filled with the right part of the string, if delim is found

Definition at line 1074 of file string_ops.h.

single_split_last() [1/2]

constexpr std::pair< std::string_view, std::string_view > ghassanpl::string_ops::single_split_last ( std::string_view  src, char  delim  )

constexprnoexcept

Splits src once on the last instance of delim

Returns

a pair of string_views: the left and right parts of src split the first instance of delim; if no delim is found, returns { src, {} }

Definition at line 1065 of file string_ops.h.

single_split_last() [2/2]

constexpr bool ghassanpl::string_ops::single_split_last ( std::string_view  src, char  delim, std::string_view &  first, std::string_view &  second  )

constexprnoexcept

Splits src once on the last instance of delim

Returns

whether delim was found

Parameters

first	will be filled with the left part of the string, if delim is found
second	will be filled with the right part of the string, if delim is found

Definition at line 1083 of file string_ops.h.

split() [1/3]

template<typename FUNC >
requires std::is_invocable_v<FUNC, std::string_view, bool>

constexpr void ghassanpl::string_ops::split ( std::string_view  source, char  delim, FUNC &&  func  )

constexprnoexcept

Performs a basic "split" operation, calling func for each part of source delimited by delim.

If no delimiters are found, calls func for entire string.

Parameters

func	must be invocable as func(string_view, bool); the second argument specifies if the given string is the final part of the split

Definition at line 955 of file string_ops.h.

split() [2/3]

template<typename RESULT_TYPE = std::string_view, string_or_char DELIM>

constexpr std::vector< RESULT_TYPE > ghassanpl::string_ops::split ( std::string_view  source, DELIM &&  delim  )

constexprnoexcept

Performs a basic "split" operation, returning a std::vector of the split parts.

See also

split(std::string_view source, char delim, FUNC&& func)

Template Parameters

RESULT_TYPE

the type of the elements in the resulting vector; must be constructible from string_view

Definition at line 1123 of file string_ops.h.

split() [3/3]

template<typename FUNC >
requires std::is_invocable_v<FUNC, std::string_view, bool>

constexpr void ghassanpl::string_ops::split ( std::string_view  source, std::string_view  delim, FUNC &&  func  )

constexprnoexcept

Performs a basic "split" operation, calling func for each part of source delimited by delim.

If no delimiters are found, calls func for entire string.

Parameters

func	must be invocable as func(string_view, bool); the second argument specifies if the given string is the final part of the split

Definition at line 971 of file string_ops.h.

split_at() [1/2]

constexpr std::pair< std::string_view, std::string_view > ghassanpl::string_ops::split_at ( std::string_view  src, size_t  split_at  )

constexprnoexcept

Does not include the character at split_at in the returned strings.

Definition at line 1039 of file string_ops.h.

split_at() [2/2]

constexpr bool ghassanpl::string_ops::split_at ( std::string_view  src, size_t  split_at, std::string_view &  first, std::string_view &  second  )

constexprnoexcept

Does not include the character at split_at in the returned strings.

Definition at line 1047 of file string_ops.h.

split_on() [1/2]

template<typename RESULT_TYPE = std::string_view, typename DELIM_FUNC >
requires std::is_invocable_r_v<size_t, DELIM_FUNC, std::string_view>

std::vector< RESULT_TYPE > ghassanpl::string_ops::split_on ( std::string_view  source, DELIM_FUNC &&  delim  )

noexcept

Performs a basic "split" operation, returning a std::vector of the split parts.

See also

split_on(std::string_view source, DELIM_FUNC&& delim, FUNC&& func)

Template Parameters

RESULT_TYPE

the type of the elements in the resulting vector; must be constructible from string_view

Definition at line 1152 of file string_ops.h.

split_on() [2/2]

template<typename DELIM_FUNC , typename FUNC >
requires std::is_invocable_v<FUNC, std::string_view, bool>&& std::is_invocable_r_v<size_t, DELIM_FUNC, std::string_view>

void ghassanpl::string_ops::split_on ( std::string_view  source, DELIM_FUNC &&  delim, FUNC &&  func  )

inlinenoexcept

Performs a basic "split" operation, calling func for each part of source delimited by the delim function.

If no delimiters are found, calls func for entire string.

Example

split_on("alpha,beta;gamma", [](auto sv) { return sv.find_first_of(",;"); }), [](auto sv, bool) { println("'{}', sv); });
>> will print
'alpha'
'beta'
'gamma'

Parameters

delim	must be invocable as delim(string_view) -> std::string::size_type; it should return the position in its parameter where the next delimiter is; if it returns std::string::npos, splitting ends there, calling func for the rest of the string
func	must be invocable as func(string_view, bool); the second argument specifies if the given string is the final part of the split

Definition at line 1020 of file string_ops.h.

split_on_any() [1/2]

template<typename RESULT_TYPE = std::string_view>

constexpr std::vector< RESULT_TYPE > ghassanpl::string_ops::split_on_any ( std::string_view  source, std::string_view  delim  )

constexprnoexcept

Performs a basic "split" operation, returning a std::vector of the split parts.

See also

split_on_any(std::string_view source, std::string_view delim, FUNC&& func)

Template Parameters

RESULT_TYPE

the type of the elements in the resulting vector; must be constructible from string_view

Definition at line 1136 of file string_ops.h.

split_on_any() [2/2]

template<typename FUNC >
requires std::is_invocable_v<FUNC, std::string_view, bool>

constexpr void ghassanpl::string_ops::split_on_any ( std::string_view  source, std::string_view  delim, FUNC &&  func  )

constexprnoexcept

Performs a basic "split" operation, calling func for each part of source delimited by any character in delim.

If no delimiters are found, calls func for entire string.

Parameters

func	must be invocable as func(string_view, bool); the second argument specifies if the given string is the final part of the split

Definition at line 990 of file string_ops.h.

stod()

double ghassanpl::string_ops::stod ( std::string_view  str, size_t *  idx = nullptr, std::chars_format  format = std::chars_format::general  )

inline

Definition at line 1739 of file string_ops.h.

stof()

float ghassanpl::string_ops::stof ( std::string_view  str, size_t *  idx = nullptr, std::chars_format  format = std::chars_format::general  )

inline

Definition at line 1738 of file string_ops.h.

stoi()

int ghassanpl::string_ops::stoi ( std::string_view  str, size_t *  idx = nullptr, int  base = 10  )

inline

Definition at line 1733 of file string_ops.h.

stol()

long ghassanpl::string_ops::stol ( std::string_view  str, size_t *  idx = nullptr, int  base = 10  )

inline

Definition at line 1734 of file string_ops.h.

stold()

long double ghassanpl::string_ops::stold ( std::string_view  str, size_t *  idx = nullptr, std::chars_format  format = std::chars_format::general  )

inline

Definition at line 1740 of file string_ops.h.

stoll()

long long ghassanpl::string_ops::stoll ( std::string_view  str, size_t *  idx = nullptr, int  base = 10  )

inline

Definition at line 1735 of file string_ops.h.

stoul()

unsigned long ghassanpl::string_ops::stoul ( std::string_view  str, size_t *  idx = nullptr, int  base = 10  )

inline

Definition at line 1736 of file string_ops.h.

stoull()

unsigned long long ghassanpl::string_ops::stoull ( std::string_view  str, size_t *  idx = nullptr, int  base = 10  )

inline

Definition at line 1737 of file string_ops.h.

string_view_cast()

template<typename COUT , typename CIN >
requires charable<COUT> && charable<CIN> && same_size_and_alignment<COUT, CIN>

constexpr std::basic_string_view< COUT > ghassanpl::string_ops::string_view_cast ( std::basic_string_view< CIN >  id )

constexprnoexcept

Casts a string_view to a string_view with a different char type via a simple reinterpret_cast.

Definition at line 205 of file string_ops.h.

substr()

std::string_view ghassanpl::string_ops::substr ( std::string_view  str, intptr_t  start, size_t  count = std::string::npos  )

inlinenoexcept

Gets a substring of str starting at start and containing count characters.

The result will always be valid, clamped to the bounds of str (or empty).

Parameters

count	the (maximum) number of characters to get
start	if negative, starts -start characters before the end

Definition at line 559 of file string_ops.h.

suffix()

std::string_view ghassanpl::string_ops::suffix ( std::string_view  str, size_t  count  )

inlinenoexcept

Returns a substring containing the count rightmost characters of str. Always valid, clamped to the bounds of str (or empty).

Definition at line 581 of file string_ops.h.

to_string() [1/5]

template<typename T >

std::string ghassanpl::string_ops::to_string ( std::optional< T > const &  o )

inline

Definition at line 225 of file string_ops.h.

to_string() [2/5]

constexpr std::string const & ghassanpl::string_ops::to_string ( std::same_as< std::string > auto const &  s )

constexpr

Definition at line 222 of file string_ops.h.

to_string() [3/5]

std::string ghassanpl::string_ops::to_string ( std::string_view  from )

inlinenoexcept

Definition at line 215 of file string_ops.h.

to_string() [4/5]

std::string ghassanpl::string_ops::to_string ( std::u8string_view  from )

inlinenoexcept

Definition at line 217 of file string_ops.h.

to_string() [5/5]

template<typename T >
requires requires { std::to_string(t); }

std::string ghassanpl::string_ops::to_string ( T const &  t )

inline

Definition at line 220 of file string_ops.h.

trim()

constexpr void ghassanpl::string_ops::trim ( std::string_view &  str, char  chr  )

constexprnoexcept

Definition at line 628 of file string_ops.h.

trim_until()

constexpr void ghassanpl::string_ops::trim_until ( std::string_view &  str, char  chr  )

constexprnoexcept

Definition at line 627 of file string_ops.h.

trim_while()

template<typename FUNC >
requires std::is_invocable_r_v<bool, FUNC, char>

constexpr void ghassanpl::string_ops::trim_while ( std::string_view &  str, FUNC &&  func  )

constexprnoexcept

Definition at line 631 of file string_ops.h.

trim_whitespace()

constexpr void ghassanpl::string_ops::trim_whitespace ( std::string_view &  str )

constexprnoexcept

Definition at line 626 of file string_ops.h.

trim_whitespace_left()

constexpr void ghassanpl::string_ops::trim_whitespace_left ( std::string_view &  str )

constexprnoexcept

Definition at line 625 of file string_ops.h.

trim_whitespace_right()

constexpr void ghassanpl::string_ops::trim_whitespace_right ( std::string_view &  str )

constexprnoexcept

Definition at line 624 of file string_ops.h.

trimmed() [1/2]

constexpr std::string ghassanpl::string_ops::trimmed ( std::string  str, char  chr  )

constexprnoexcept

Definition at line 618 of file string_ops.h.

trimmed() [2/2]

constexpr std::string_view ghassanpl::string_ops::trimmed ( std::string_view  str, char  chr  )

constexprnoexcept

Definition at line 612 of file string_ops.h.

trimmed_until() [1/2]

constexpr std::string ghassanpl::string_ops::trimmed_until ( std::string  str, char  chr  )

constexprnoexcept

Definition at line 617 of file string_ops.h.

trimmed_until() [2/2]

constexpr std::string_view ghassanpl::string_ops::trimmed_until ( std::string_view  str, char  chr  )

constexprnoexcept

Definition at line 611 of file string_ops.h.

trimmed_while()

template<typename FUNC >
requires std::is_invocable_r_v<bool, FUNC, char>

std::string_view ghassanpl::string_ops::trimmed_while ( std::string_view  str, FUNC &&  func  )

inlinenoexcept

Definition at line 622 of file string_ops.h.

trimmed_whitespace() [1/2]

constexpr std::string ghassanpl::string_ops::trimmed_whitespace ( std::string  str )

constexprnoexcept

Definition at line 616 of file string_ops.h.

trimmed_whitespace() [2/2]

constexpr std::string_view ghassanpl::string_ops::trimmed_whitespace ( std::string_view  str )

constexprnoexcept

Definition at line 610 of file string_ops.h.

trimmed_whitespace_left() [1/2]

constexpr std::string ghassanpl::string_ops::trimmed_whitespace_left ( std::string  str )

constexprnoexcept

Definition at line 615 of file string_ops.h.

trimmed_whitespace_left() [2/2]

constexpr std::string_view ghassanpl::string_ops::trimmed_whitespace_left ( std::string_view  str )

constexprnoexcept

Definition at line 609 of file string_ops.h.

trimmed_whitespace_right() [1/2]

constexpr std::string ghassanpl::string_ops::trimmed_whitespace_right ( std::string  str )

constexprnoexcept

Definition at line 614 of file string_ops.h.

trimmed_whitespace_right() [2/2]

constexpr std::string_view ghassanpl::string_ops::trimmed_whitespace_right ( std::string_view  str )

constexprnoexcept

Definition at line 608 of file string_ops.h.

url_encode()

std::string ghassanpl::string_ops::url_encode ( std::string_view  text )

inline

Returns a url-encoded version of the string.

Definition at line 1473 of file string_ops.h.

url_unencode()

std::string ghassanpl::string_ops::url_unencode ( std::string_view  text )

inline

Returns a url-decoded version of the string.

Definition at line 1491 of file string_ops.h.

without_prefix()

std::string_view ghassanpl::string_ops::without_prefix ( std::string_view  str, size_t  count  )

inlinenoexcept

Returns a substring created by removing count characters from the start. Always valid, clamped to the bounds of str (or empty).

Definition at line 586 of file string_ops.h.

without_suffix()

std::string_view ghassanpl::string_ops::without_suffix ( std::string_view  str, size_t  count  )

inlinenoexcept

Returns a substring created by removing count characters from the end. Always valid, clamped to the bounds of str (or empty).

Definition at line 576 of file string_ops.h.

word_wrap() [1/2]

template<typename RESULT_TYPE = std::string_view, typename T , typename FUNC >
requires std::is_arithmetic_v<T>&& std::is_invocable_r_v<T, FUNC, std::string_view>

std::vector< RESULT_TYPE > ghassanpl::string_ops::word_wrap	(	std::string_view	_source,
		T	max_width,
		FUNC	width_getter
	)

Performs a basic word-wrapping split of _source, as if it was constrained to max_width.

Splits will be performed implicitly on ' ' (or character boundaries if no other choice), and explictly on '\n' characters

Template Parameters

T	the type for the width values

Parameters

width_getter

must be invocable as width_getter(string_view) -> T and should return the width of the given string calculating it however it deems appropriate

Returns

a vector containing a string_view for each line

Todo:

example

Definition at line 1631 of file string_ops.h.

word_wrap() [2/2]

template<typename RESULT_TYPE = std::string_view, typename T >
requires std::is_arithmetic_v<T>

std::vector< RESULT_TYPE > ghassanpl::string_ops::word_wrap	(	std::string_view	_source,
		T	max_width,
		T	letter_width
	)

Word-wrapping function for constant-width characters.

See also

word_wrap(std::string_view _source, T max_width, FUNC width_getter)

Definition at line 1668 of file string_ops.h.