Строковые выражения

Строковые выражения Подробнее...

Концепты
concept	simstr::StrExpr
	Концепт "Строковых выражений".
concept	simstr::StrExprForType
	Концепт строкового выражения заданного типа символов

Классы
struct	simstr::expr_replaced< K >
	Строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки. Подробнее...
struct	simstr::expr_replace_symbols< K, UseVectorForReplace >
	Тип для строкового выражения, генерирующее строку, в которой заданные символы заменяются на заданные строки. Подробнее...
struct	simstr::strexprjoin< A, B >
	Шаблонный класс для конкатенации двух строковых выражений в одно с помощью operator + Подробнее...
struct	simstr::strexprjoin_c< A, B, last >
	Конкатенация ссылки на строковое выражение и значения строкового выражения Подробнее...
struct	simstr::empty_expr< K >
	"Пустое" строковое выражение Подробнее...
struct	simstr::expr_spaces< K, N, S >
	Тип строкового выражения, возвращающего N заданных символов. Подробнее...
struct	simstr::expr_pad< K >
	Тип строкового выражения, возвращающего N заданных символов. Подробнее...
struct	simstr::expr_choice< A, B >
	Строковое выражение условного выбора Подробнее...
struct	simstr::expr_if< A >
	Строковое выражение условного выбора Подробнее...
struct	simstr::expr_choice_one_lit< A, N, Compare >
	Строковое выражение условного выбора Подробнее...
struct	simstr::expr_choice_two_lit< K, N, M >
	Строковое выражение условного выбора Подробнее...
struct	simstr::expr_stdstr< K, T >
	Тип для использования std::string и std::string_view как источников в строковых выражениях Подробнее...

Функции
template<StrExpr A, FromIntNumber T>
constexpr auto	simstr::operator+ (const A &a, T s)
	Оператор конкатенации для строкового выражения и целого числа.
template<StrExpr A, FromIntNumber T>
constexpr auto	simstr::operator+ (T s, const A &a)
	Оператор конкатенации для целого числа и строкового выражения.
template<typename K, typename T>
constexpr auto	simstr::e_num (T t)
	Преобразование целого числа в строковое выражение
template<StrExpr A, typename R> requires (is_one_of_std_char_v<typename A::symb_type> && (std::is_same_v<R, double> || std::is_same_v<R, float>))
constexpr auto	simstr::operator+ (const A &a, R s)
	Оператор конкатенации для строкового выражения и вещественного числа (float, double).
template<StrExpr A, typename R> requires (is_one_of_std_char_v<typename A::symb_type> && (std::is_same_v<R, double> || std::is_same_v<R, float>))
constexpr auto	simstr::operator+ (R s, const A &a)
	Оператор конкатенации для вещественного числа (float, double) и строкового выражения.
template<typename K> requires (is_one_of_std_char_v<K>)
constexpr auto	simstr::e_real (double t)
	Преобразование double числа в строковое выражение
template<bool tail = false, bool skip_empty = false, typename L, typename K = typename const_lit<L>::symb_type, size_t I = const_lit<L>::Count, typename T>
constexpr auto	simstr::e_join (const T &s, L &&d)
	Получить строковое выражение, конкатенирующее строки в контейнере в одну строку с заданным разделителем
template<typename K, typename T, size_t N = const_lit_for<K, T>::Count, typename X, size_t L = const_lit_for<K, X>::Count> requires (N > 1)
constexpr auto	simstr::e_repl (simple_str< K > w, T &&p, X &&r)
	Получить строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки
template<bool UseVector = false, typename K, typename ... Repl> requires (sizeof...(Repl) % 2 == 0)
auto	simstr::e_repl_const_symbols (simple_str< K > src, Repl &&... other)
	Возвращает строковое выражение, генерирующее строку, в которой заданные символы заменены на заданные подстроки.
template<StrExpr A, StrExprForType< typename A::symb_type > B>
auto	simstr::operator+ (const A &a, const B &b)
	Оператор сложения двух произвольных строковых выражения для одинакового типа символов.
template<typename K, StrExprForType< K > A>
constexpr auto	simstr::operator+ (const A &a, K s)
	Оператор сложения строкового выражения и одного символа
template<typename K>
constexpr auto	simstr::e_char (K s)
	Генерирует строку из 1 заданного символа
template<typename T, size_t N = const_lit<T>::Count>
constexpr auto	simstr::e_t (T &&s)
	Преобразует строковый литерал в строковое выражение.
template<StrExpr A, typename K = typename A::symb_type, typename T, size_t N = const_lit_for<K, T>::Count>
constexpr auto	simstr::operator+ (const A &a, T &&s)
	Оператор сложения для строкового выражения и строкового литерала такого же типа символов
template<StrExpr A, typename K = typename A::symb_type, typename T, size_t N = const_lit_for<K, T>::Count>
constexpr auto	simstr::operator+ (T &&s, const A &a)
	Оператор сложения для строкового литерала такого же типа символов и строкового выражения
template<size_t N>
constexpr auto	simstr::e_spca ()
	Генерирует строку из N char пробелов
template<size_t N>
constexpr auto	simstr::e_spcw ()
	Генерирует строку из N wchar_t пробелов
template<typename K>
constexpr auto	simstr::e_c (size_t l, K s)
	Генерирует строку из l символов s типа K.
template<StrExpr A, StrExprForType< typename A::symb_type > B>
constexpr auto	simstr::e_choice (bool c, const A &a, const B &b)
	Создание условного строкового выражения expr_choice.
template<StrExpr A, typename T, size_t N = const_lit_for<typename A::symb_type, T>::Count>
constexpr auto	simstr::e_choice (bool c, const A &a, T &&str)
	Перегрузка e_choice, когда третий аргумент - строковый литерал
template<StrExpr A, typename T, size_t N = const_lit_for<typename A::symb_type, T>::Count>
constexpr auto	simstr::e_choice (bool c, T &&str, const A &a)
	Перегрузка e_choice, когда второй аргумент - строковый литерал
template<typename T, typename L, size_t N = const_lit<T>::Count, size_t M = const_lit_for<typename const_lit<T>::symb_type, L>::Count>
constexpr auto	simstr::e_choice (bool c, T &&str_a, L &&str_b)
	Перегрузка e_choice, когда второй и третий аргумент - строковые литералы
template<StrExpr A>
constexpr auto	simstr::e_if (bool c, const A &a)
	Создание условного строкового выражения expr_if.
template<typename T, size_t N = const_lit<T>::Count>
constexpr auto	simstr::e_if (bool c, T &&str)
	Перегрузка e_if, когда второй аргумент - строковый литерал
template<StrExprForType< u8s > A>
auto	simstr::operator+ (const A &a, const std::string &s)
	Оператор сложения для char строкового выражения и std::string.
template<StrExprForType< u8s > A>
auto	simstr::operator+ (const std::string &s, const A &a)
	Оператор сложения для std::string и char строкового выражения
template<StrExprForType< u8s > A>
auto	simstr::operator+ (const A &a, const std::string_view &s)
	Оператор сложения для char строкового выражения и std::string_view.
template<StrExprForType< u8s > A>
auto	simstr::operator+ (const std::string_view &s, const A &a)
	Оператор сложения для std::string_view и char строкового выражения
template<StrExprForType< uws > A>
auto	simstr::operator+ (const A &a, const std::wstring &s)
	Оператор сложения для wchar_t строкового выражения и std::wstring.
template<StrExprForType< uws > A>
auto	simstr::operator+ (const std::wstring &s, const A &a)
	Оператор сложения для std::wstring и wchar_t строкового выражения
template<StrExprForType< uws > A>
auto	simstr::operator+ (const A &a, const std::wstring_view &s)
	Оператор сложения для wchar_t строкового выражения и std::wstring_view.
template<StrExprForType< uws > A>
auto	simstr::operator+ (const std::wstring_view &s, const A &a)
	Оператор сложения для std::wstring_view и wchar_t строкового выражения

Переменные
constexpr empty_expr< u8s >	simstr::eea {}
	Пустое строковое выражение типа char.
constexpr empty_expr< uws >	simstr::eew {}
	Пустое строковое выражение типа wchar_t.
constexpr empty_expr< u16s >	simstr::eeu {}
	Пустое строковое выражение типа char16_t.
constexpr empty_expr< u32s >	simstr::eeuu {}
	Пустое строковое выражение типа char32_t.

Подробное описание

Строковые выражения

Все типы владеющих строк могут инициализироваться с помощью "строковых выражений" (по сути это вариант https://en.wikipedia.org/wiki/Expression_templates для строк). Строковое выражение - это объект произвольного типа, у которого имеются методы:

• size_t length() const: выдает длину строки
• K* place(K*) const: скопировать символы строки в предназначенный буфер и вернуть указатель за последним символом
• typename symb_type: показывает, с каким типом символов он работает.

При инициализации строковый объект запрашивает у строкового выражения его размер, выделяет необходимую память, и передает память строковому выражению, которое помещает символы в отведённый буфер.

Все строковые объекты библиотеки сами являются строковыми выражениями, которые просто копирует исходную строку. В-основном строковые выражения используются для конкатенации или конвертации строк.

Для всех строковых выражений определен operator +, который из двух операндов создает новое строковое выражение simstr::strexprjoin, объединяющее два строковых выражения, и которое в методе length возвращает сумму length исходных операндов, а в методе place - размещает в буфер результата сначала первый операнд, потом второй. И так как этот оператор сам возвращает строковое выражение, то к нему снова можно применить operator +, формируя цепочку из нескольких строковых выражений, и в итоге "материализовать" последний получившийся объект, который сначала посчитает размер всей общей памяти для конечного результата, а затем разместит вложенные подвыражения в один буфер.

Также operator + определён для строковых выражений и строковых литералов, строковых выражений и чисел (числа конвертируются в десятичное представление), а также вы можете сами добавить желаемые типы строковых выражений. Пример:

stringa text = header + ", count = " + count + ", done"; 

Существует несколько типов строковых выражений "из коробки", для выполнения различных операций со строками

• expr_spaces<ТипСимвола, КоличествоСимволов, Символ>{}: выдает строку длиной КоличествоСимволов, заполненную заданным символом. Количество символов и символ - константы времени компиляции. Для некоторых случаев есть сокращенная запись:
  • e_spca<КоличествоСимволов>(): строка char пробелов
  • e_spcw<КоличествоСимволов>(): строка w_char пробелов
• expr_pad<ТипСимвола>{КоличествоСимволов, Символ}: выдает строку длинной КоличествоСимволов, заполненную заданным символом. Количество символов и символ могут задаваться в рантайме. Сокращенная запись: e_c(КоличествоСимволов, Символ)
• e_choice(bool Condition, StrExpr1, StrExpr2): если Condition == true, результат будет равен StrExpr1, иначе StrExpr2
• e_num<ТипСимвола>(ЦелоеЧисло): конвертирует число в десятичное представление. Редко используется, так как для строковых выражений и чисел переопределен оператор "+", и число можно просто написать как text + number;
• e_real<ТипСимвола>(ВещественноеЧисло): конвертирует число в десятичное представление. Редко используется, так как для строковых выражений и чисел переопределен оператор "+", и число можно просто написать как text + number;
• e_join<bool ПослеПоследнего = false, bool ПропускатьПустые = false>(контейнер, "Разделитель"): конкатенирует все строки в контейнере, используя разделитель. Если ПослеПоследнего == true, то разделитель добавляется и после последнего элемента контейнера, иначе только между элементами. Если ПропускатьПустые == true, то пустые строки не добавляют разделитель, иначе для каждой пустой строки тоже вставляется разделитель
• e_repl(ИсходнаяСтрока, "Искать", "Заменять"): заменяет в исходной строке вхождения "Искать" на "Заменять". Шаблоны поиска и замены - строковые литералы времени компиляции.
• expr_replaced<ТипСимвола>{ИсходнаяСтрока, Искать, Заменять}: заменяет в исходной строке вхождения Искать на Заменять. Шаблоны поиска и замены - могут быть любыми строковыми объектами в рантайме.

и т.д. и т.п.

Функции

e_c()

template<typename K>

auto simstr::e_c ( size_t l, K s )

inlineconstexpr

Генерирует строку из l символов s типа K.

Параметры шаблона

K	- тип символа

Аргументы

l	- количество символов
s	- символ

Возвращает

строковое выражение, генерирующее строку из l символов k

e_char()

template<typename K>

auto simstr::e_char ( K s )

inlineconstexpr

Генерирует строку из 1 заданного символа

Аргументы

S

- символ

Возвращает

строковое выражение для строки из одного символа

e_choice()

template<StrExpr A, StrExprForType< typename A::symb_type > B>

auto simstr::e_choice ( bool c, const A & a, const B & b )

inlineconstexpr

Создание условного строкового выражения expr_choice.

Параметры шаблона

A	- Тип выражение при истинности условия, выводится из аргумента
B	- Тип выражения при ложности условия, выводится из аргумента

Аргументы

c	- булево условие
a	- строковое выражение, выполняющееся при c == true
b	- строковое выражение, выполняющееся при c == false

Служит для возможности в одном выражении выбирать разные варианты в зависимости от условия.

Примеры:

columns_metadata.emplace_back(e_choice(name.is_empty(), "?column?", name) + "::" + metadata_column.type.to_string());

lstringa<512> str = e_choice(!ret_type_resolver_, sql_value::type_name(ret_type_), "any") + " " + name_ + "(";

Иначе такие операции приходилось бы разбивать на несколько модификаций строки или применению временных строк, что не оптимально и снизит производительность. (Это проверяется в бенчмарке "Build Full Func Name")

e_if()

template<StrExpr A>

auto simstr::e_if ( bool c, const A & a )

inlineconstexpr

Создание условного строкового выражения expr_if.

Параметры шаблона

A	- Тип выражение при истинности условия, выводится из аргумента

Аргументы

c	- булево условие
a	- строковое выражение, выполняющееся при c == true

Служит для возможности в одном выражении генерировать в зависимости от условия либо указанный вариант, либо пустую строку.

Примеры:

void sql_func_info::build_full_name() {
    // Временный буфер для результата, возьмём с запасом
    lstringa<512> str = e_choice(!ret_type_resolver_, sql_value::type_name(ret_type_), "any") + " " + name_ + "(";
 
    bool add_comma = false;
 
    for (const auto& param : params_) {
        str += e_if(add_comma, ", ") + e_if(param.optional_, "[");
        param.allowed_types.to_string(str); // Добавляет к str названия допустимых типов
        if (param.optional_) {
            str += "]";
        }
        add_comma = true;
    }
    // Сохраним в stringa
    full_name_ = str + e_if(unlim_params_, e_if(add_comma, ", ") + "...") + ")";
}

Иначе такие операции приходилось бы разбивать на несколько модификаций строки или применению временных строк, что не оптимально и снизит производительность. (Этот пример проверяется в бенчмарке "Build Full Func Name")

e_join()

template<bool tail = false, bool skip_empty = false, typename L, typename K = typename const_lit<L>::symb_type, size_t I = const_lit<L>::Count, typename T>

auto simstr::e_join ( const T & s, L && d )

inlineconstexpr

Получить строковое выражение, конкатенирующее строки в контейнере в одну строку с заданным разделителем

Параметры шаблона

tail	- добавлять ли разделитель после последней строки
skip_empty	- пропускать пустые строки без добавления разделителя

Аргументы

s	- контейнер со строками, должен поддерживать range for.
d	- разделитель, строковый литерал

e_num()

template<typename K, typename T>

auto simstr::e_num ( T t )

inlineconstexpr

Преобразование целого числа в строковое выражение

Параметры шаблона

K	- тип символов
T	- тип числа, выводится из аргумента

Аргументы

t

- число

Возвращает строковое выражение, которое генерирует десятичное представление заданного числа. Может использоваться, когда надо конкатенировть число и строковый литерал

e_real()

template<typename K>
requires (is_one_of_std_char_v<K>)

auto simstr::e_real ( double t )

inlineconstexpr

Преобразование double числа в строковое выражение

Аргументы

t

- число

Возвращает строковое выражение, которое генерирует десятичное представление заданного числа с помощью sprintf("%.16g"). Может использоваться, когда надо конкатенировть число и строковый литерал

e_repl()

template<typename K, typename T, size_t N = const_lit_for<K, T>::Count, typename X, size_t L = const_lit_for<K, X>::Count>
requires (N > 1)

auto simstr::e_repl ( simple_str< K > w, T && p, X && r )

inlineconstexpr

Получить строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки

Параметры шаблона

K	- тип символа, выводится из первого аргумента

Аргументы

w	- начальная строка
p	- строковый литерал, искомая подстрока
r	- строковый литерал, на что заменять

e_repl_const_symbols()

template<bool UseVector = false, typename K, typename ... Repl>
requires (sizeof...(Repl) % 2 == 0)

auto simstr::e_repl_const_symbols	(	simple_str< K >	src,
		Repl &&...	other )

Возвращает строковое выражение, генерирующее строку, в которой заданные символы заменены на заданные подстроки.

Параметры шаблона

UseVector

- использовать вектор для сохранения результатов поиска символов. Более подробно описано в expr_replace_symbols.

Аргументы

src	- исходная строка
symbol	- константный символ, который надо заменять
repl	- строковый литерал, на который заменять символ
...	symbol, repl - другие символы и строки

Применяется для генерации замены символов на строки, в случае если все они известны в compile time. Пример:

out += "<div>" + e_repl_const_symbols(text, '\"', "&quot;", '<', "&lt;", '\'', "&#39;", '&', "&amp;") + "</div>";

В принипе, e_repl_const_symbols вполне безопасно возвращать из функции, если исходная строка внешняя по отношению к функции

auto repl_html_symbols(ssa text) {
    return e_repl_const_symbols(text, '\"', "&quot;", '<', "&lt;", '\'', "&#39;", '&', "&amp;");
}
....
out += "<div>" + repl_html_symbols(content) + "</div>";

e_spca()

template<size_t N>

auto simstr::e_spca ( )

inlineconstexpr

Генерирует строку из N char пробелов

Параметры шаблона

N	- Количество пробелов

Возвращает

строковое выражение для N char пробелов

Пример:

stringa text = e_spca<10>() + text + e_spca<10>();

e_spcw()

template<size_t N>

auto simstr::e_spcw ( )

inlineconstexpr

Генерирует строку из N wchar_t пробелов

Параметры шаблона

N	- Количество пробелов

Возвращает

строковое выражение для N wchar_t пробелов

Пример:

stringw text = e_spcw<10>() + text + e_spcw<10>();

e_t()

template<typename T, size_t N = const_lit<T>::Count>

auto simstr::e_t ( T && s )

inlineconstexpr

Преобразует строковый литерал в строковое выражение.

Строковые литералы сами по себе не являются строковыми выражениями. Обычно в операциях конкатенации это не вызывает проблем, так как второй операнд уже является строковым выражением, и для него срабатывает сложение с литералом. Но есть ситуации, когда второй операнд тоже не является строковым выражением. Например:

int intVar = calculate();
...
res = "text" + intVar;
...
res = intVar + "text";

В этом случае можно преобразовать литерал в строковое выражение двумя способами:

• дописать _ss: "text"_ss, что преобразует литерал в simple_str_nt: res = "text"_ss + intVar
• применить e_t: e_t("text"), что преобразует литерал в expr_literal: res = e_t("text") + intVar

Во втором способе компилятор может более агрессивно применить оптимизации, связанные с известным при компиляции размером литерала.

Хотя строго говоря, в этих ситуации можно пользоваться и другими способами:

• Добавить операнд - пустое строковое выражение: result = eea + "text" + intVar, result = "text" + eea + intVar
• Преобразовать другой операнд в строковое выражение: result = "text" + e_num<u8s>(intVar).

Все эти способы работают и выдают одинаковый результат. Каким пользоваться - дело вкуса.

operator+() [1/12]

template<StrExpr A, StrExprForType< typename A::symb_type > B>

auto simstr::operator+ ( const A & a, const B & b )

inline

Оператор сложения двух произвольных строковых выражения для одинакового типа символов.

Аргументы

a	- первое строковое выражение
b	- второе строковое выражение

Возвращает

strexprjoin<A, B>, строковое выражение, генерирующее объединение переданных выражений

Когда складываются два объекта - строковых выражения, один типа A, другой типа B, мы возвращаем объект типа strexprjoin<A, B>, который содержит ссылки на два этих операнда. А сам объект strexprjoin<A, B> тоже в свою очередь является строковым выражением, и может участвовать в следующих операциях сложения. Таким образом формируется "дерево" из исходных строковых выражений, которое потом за один вызов "материализуется" в конечный результат.

operator+() [2/12]

template<StrExprForType< uws > A>

auto simstr::operator+	(	const A &	a,
		const std::wstring &	s )

Оператор сложения для wchar_t строкового выражения и std::wstring.

Оператор сложения для совместимого с wchar_t строкового выражения (char16_t или char32_t, в зависимости от компилятора) и std::wstring.

operator+() [3/12]

template<StrExprForType< uws > A>

auto simstr::operator+	(	const A &	a,
		const std::wstring_view &	s )

Оператор сложения для wchar_t строкового выражения и std::wstring_view.

Оператор сложения для совместимого с wchar_t строкового выражения (char16_t или char32_t, в зависимости от компилятора) и std::wstring_view.

operator+() [4/12]

template<typename K, StrExprForType< K > A>

auto simstr::operator+ ( const A & a, K s )

inlineconstexpr

Оператор сложения строкового выражения и одного символа

Возвращает

строковое выражение, объединяющее переданное выражение и символ

Пример:

reply = prompt + '>' + result;

operator+() [5/12]

template<StrExpr A, typename R>
requires (is_one_of_std_char_v<typename A::symb_type> && (std::is_same_v<R, double> || std::is_same_v<R, float>))

auto simstr::operator+ ( const A & a, R s )

inlineconstexpr

Оператор конкатенации для строкового выражения и вещественного числа (float, double).

Аргументы

a	- строковое выражение
s	- число

Число конвертируется в строковое представление через sprintf("%.16g").

operator+() [6/12]

template<StrExpr A, typename K = typename A::symb_type, typename T, size_t N = const_lit_for<K, T>::Count>

auto simstr::operator+ ( const A & a, T && s )

inlineconstexpr

Оператор сложения для строкового выражения и строкового литерала такого же типа символов

Возвращает

Строковое выражение, объединяющее операнды

operator+() [7/12]

template<StrExpr A, FromIntNumber T>

auto simstr::operator+ ( const A & a, T s )

inlineconstexpr

Оператор конкатенации для строкового выражения и целого числа.

Аргументы

a	- строковое выражение
s	- число

Число конвертируется в десятичное строковое представление.

operator+() [8/12]

template<StrExprForType< uws > A>

auto simstr::operator+	(	const std::wstring &	s,
		const A &	a )

Оператор сложения для std::wstring и wchar_t строкового выражения

Оператор сложения для std::wstring и совместимого с wchar_t строкового выражения (char16_t или char32_t, в зависимости от компилятора)

operator+() [9/12]

template<StrExprForType< uws > A>

auto simstr::operator+	(	const std::wstring_view &	s,
		const A &	a )

Оператор сложения для std::wstring_view и wchar_t строкового выражения

Оператор сложения для std::wstring_view и совместимого с wchar_t строкового выражения (char16_t или char32_t, в зависимости от компилятора)

operator+() [10/12]

template<StrExpr A, typename R>
requires (is_one_of_std_char_v<typename A::symb_type> && (std::is_same_v<R, double> || std::is_same_v<R, float>))

auto simstr::operator+ ( R s, const A & a )

inlineconstexpr

Оператор конкатенации для вещественного числа (float, double) и строкового выражения.

Аргументы

s	- число
a	- строковое выражение

Число конвертируется в строковое представление через sprintf("%.16g").

operator+() [11/12]

template<StrExpr A, typename K = typename A::symb_type, typename T, size_t N = const_lit_for<K, T>::Count>

auto simstr::operator+ ( T && s, const A & a )

inlineconstexpr

Оператор сложения для строкового литерала такого же типа символов и строкового выражения

Возвращает

Строковое выражение, объединяющее операнды

operator+() [12/12]

template<StrExpr A, FromIntNumber T>

auto simstr::operator+ ( T s, const A & a )

inlineconstexpr

Оператор конкатенации для целого числа и строкового выражения.

Аргументы

s	- число
a	- строковое выражение

Число конвертируется в десятичное строковое представление.