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

Описание строковых выражений Подробнее...

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

Классы
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< L, A, N, Compare >
	Строковое выражение условного выбора. Подробнее...
struct	simstr::expr_choice_two_lit< K, N, P, M >
	Строковое выражение условного выбора. Подробнее...
struct	simstr::expr_stdstr< K, T >
	Тип для использования std::basic_string и std::basic_string_view как источников в строковых выражениях. Подробнее...
struct	simstr::expr_replaced< K >
	Строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки на другую строку. Подробнее...
struct	simstr::expr_replaced_e< K, E >
	Строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки на строковое выражение. Подробнее...
struct	simstr::expr_replace_symbols< K, UseVectorForReplace >
	Тип для строкового выражения, генерирующее строку, в которой заданные символы заменяются на заданные строки. Подробнее...

Перечисления
enum	simstr::HexFlags : unsigned { simstr::Short = 1 , No0x = 2 , Lcase = 4 }
	Флаги для функции e_hex. Подробнее...

Функции
template<StrExpr A, StrExprForType< typename A::symb_type > B>
constexpr strexprjoin< A, B >	simstr::operator+ (const A &a, const B &b)
	Оператор сложения двух произвольных строковых выражения для одинакового типа символов.
template<typename K, StrExprForType< K > A>
constexpr strexprjoin_c< A, expr_char< K > >	simstr::operator+ (const A &a, K s)
	Оператор сложения строкового выражения и одного символа.
template<typename K>
constexpr expr_char< K >	simstr::e_char (K s)
	Генерирует строку из 1 заданного символа.
template<typename T, size_t N = const_lit<T>::Count>
constexpr expr_literal< typename const_lit< T >::symb_type, static_cast< size_t >(N - 1)>	simstr::e_t (T &&s)
	Преобразует строковый литерал в строковое выражение.
template<StrExpr A, typename T, typename P = typename const_lit<T>::symb_type, size_t N = const_lit<T>::Count> requires is_equal_str_type_v<typename A::symb_type, P>
constexpr expr_literal_join< false, P,(N - 1), A >	simstr::operator+ (const A &a, T &&s)
	Оператор сложения для строкового выражения и строкового литерала такого же типа символов.
template<StrExpr A, typename T, typename P = typename const_lit<T>::symb_type, size_t N = const_lit<T>::Count> requires is_equal_str_type_v<typename A::symb_type, P>
constexpr expr_literal_join< true, P,(N - 1), A >	simstr::operator+ (T &&s, const A &a)
	Оператор сложения для строкового литерала такого же типа символов и строкового выражения.
template<size_t N>
constexpr expr_spaces< u8s, N >	simstr::e_spca ()
	Генерирует строку из N char пробелов.
template<size_t N>
constexpr expr_spaces< uws, N >	simstr::e_spcw ()
	Генерирует строку из N wchar_t пробелов.
template<typename K>
constexpr expr_pad< K >	simstr::e_c (size_t l, K s)
	Генерирует строку из l символов s типа K.
template<typename T, typename K = const_lit<T>::symb_type, size_t M = const_lit<T>::Count> requires (M > 0)
constexpr expr_repeat_lit< K, M - 1 >	simstr::e_repeat (T &&s, size_t l)
	Генерирует строку из l строковых констант s типа K.
template<StrExpr A>
constexpr expr_repeat_expr< A >	simstr::e_repeat (const A &s, size_t l)
	Генерирует строку из l строковых выражений s типа K.
template<StrExpr A, StrExprForType< typename A::symb_type > B>
constexpr expr_choice< A, B >	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 expr_choice_one_lit< typename const_lit< T >::symb_type, A, N - 1, true >	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 expr_choice_one_lit< typename const_lit< T >::symb_type, A, N - 1, false >	simstr::e_choice (bool c, T &&str, const A &a)
	Перегрузка e_choice, когда второй аргумент - строковый литерал.
template<typename T, typename L, typename K = typename const_lit<T>::symb_type, typename P = typename const_lit<L>::symb_type, size_t N = const_lit<T>::Count, size_t M = const_lit_for<typename const_lit<T>::symb_type, L>::Count> requires is_equal_str_type_v<K, P>
constexpr expr_choice_two_lit< K, N -1, P, M - 1 >	simstr::e_choice (bool c, T &&str_a, L &&str_b)
	Перегрузка e_choice, когда второй и третий аргумент - строковые литералы.
template<StrExpr A>
constexpr expr_if< A >	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<typename K, FromIntNumber T>
constexpr expr_num< K, T >	simstr::e_num (T t)
	Преобразование целого числа в строковое выражение.
template<typename K> requires is_one_of_char_v<K>
constexpr expr_real< K >	simstr::e_num (double t)
	Преобразование double числа в строковое выражение.
template<unsigned Flags = 0, FromIntNumber T>
constexpr auto	simstr::e_hex (T v)
	Позволяет конкатенировать текст и беззнаковое число в 16-ричном виде.
template<StrExpr A, typename K = typename A::symb_type>
expr_fill< K, A, true >	simstr::e_fill_left (const A &a, size_t width, K symbol=K(' '))
	Создает выражение, которое дополняет указанное строковое выражение до заданной длины заданным символом слева.
template<StrExpr A, typename K = typename A::symb_type>
expr_fill< K, A, false >	simstr::e_fill_right (const A &a, size_t width, K symbol=K(' '))
	Создает выражение, которое дополняет указанное строковое выражение до заданной длины заданным символом справа.
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<StrSource A, typename K = symb_type_from_src_t<A>, 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 (A &&w, T &&p, X &&r)
	Получить строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки.
template<StrSource A, typename K = symb_type_from_src_t<A>, typename T, typename X> requires (std::is_constructible_v<str_src<K>, T> && std::is_constructible_v<str_src<K>, X> && (!is_const_lit_v<T> || !is_const_lit_v<X>))
constexpr auto	simstr::e_repl (A &&w, T &&p, X &&r)
	Получить строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки.
template<StrSource A, typename K = symb_type_from_src_t<A>, typename T, StrExprForType< K > E> requires std::is_constructible_v<str_src<K>, T>
constexpr auto	simstr::e_repl (A &&w, T &&p, const E &expr)
	Получить строковое выражение, генерирующее строку с заменой всех вхождений заданной подстроки.
template<bool UseVector = false, StrSource A, typename K = symb_type_from_src_t<A>, typename ... Repl> requires (sizeof...(Repl) % 2 == 0)
auto	simstr::e_repl_const_symbols (A &&src, Repl &&... other)
	Возвращает строковое выражение, генерирующее строку, в которой заданные символы заменены на заданные подстроки.
template<typename T, typename K = symb_type_from_src_t<T>, typename ... Args> requires (sizeof...(Args) > 1)
constexpr expr_concat< K, to_str_exp_t< K, T >, to_str_exp_t< K, Args >... >	simstr::e_concat (T &&glue, Args &&...args)
	Создание строкового выражения, объединяющего указанные строковые выражения, с использованием заданного разделителя.
template<typename T, typename... Args> requires (sizeof...(Args) > 0)
constexpr auto	simstr::e_subst (T &&str_pattern, const details::subst_params< typename const_lit< T >::symb_type, std::type_identity_t< T >, std::type_identity_t< Args >... > &pattern, Args &&...args)
	Создает строковое выражение, которое подставляет в заданные места в строковом литерале - образце значения переданных строковых выражений.
template<simstr::StdStrSource T>
simstr::expr_stdstr< typename T::value_type, T >	std::operator+ (const T &str)
	Унарный оператор+ для преобразования стандартных строк в строковые выражения.

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

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

Описание строковых выражений

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

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

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

Кроме того, для совместимости с std, строковые выражения simstr могут конвертироваться в стандартные строки (std::basic_string) совместимых типов. До C++23 используется resize и потом заполнение через data(), начиная с C++23 используется более оптимальный resize_and_overwrite. Это позволяет использовать быструю конкатенацию там, где требуются стандартные строки.

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

Для всех строковых выражений определен 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(ИсходнаяСтрока, Искать, Заменять): заменяет в исходной строке вхождения Искать на Заменять.
• e_hex(Число): генерирует строку с 16ричным представлением числа.
• e_fill_left(StrExpr, width, symbol), e_fill_right(StrExpr, width, symbol): дополняет строковое выражение до нужной длины заданным символом. и т.д. и т.п.

В одно выражение могут объединятся строковые выражения для символов разных, но совместимых типов. То есть можно сочетать char и char8_t, под Linux wchar_t и char32_t, под Windows wchar_t и char16_t.

Помните: строковое выражение - это не строка, это только "инструкция", как собрать строку.

Перечисления

HexFlags

enum simstr::HexFlags : unsigned

Флаги для функции e_hex.

Элементы перечислений
Short	without leading zeroes

Функции

e_c()

template<typename K>

expr_pad< K > simstr::e_c ( size_t l, K s )

constexpr

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

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

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

Аргументы

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

Возвращает

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

e_char()

template<typename K>

expr_char< K > simstr::e_char ( K s )

constexpr

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

Аргументы

s

- символ.

Возвращает

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

e_choice()

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

expr_choice< A, B > simstr::e_choice ( bool c, const A & a, const B & b )

constexpr

Создание условного строкового выражения 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_concat()

template<typename T, typename K = symb_type_from_src_t<T>, typename ... Args>
requires (sizeof...(Args) > 1)

expr_concat< K, to_str_exp_t< K, T >, to_str_exp_t< K, Args >... > simstr::e_concat ( T && glue, Args &&... args )

constexpr

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

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

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

Аргументы

glue	- "клей", используемый при соединении аргументов, вставляется между ними.
args...	- объединяемые аргументы, не менее двух.

"Склеивает" переданные аргументы, вставляя между ними заданный "клей". Соединителем и аргументами могут быть строковые литералы, строковые выражения, стандартные строки. Аргументами также могут быть любые типы, для которых есть преобразование в строковое выражение. (см. Конвертация типов в в строковые выражения). Для аргументов, которые сами являются строковыми выражениями, e_concat сохраняет только ссылку на них. Обычно это не является проблемой, если ссылка не на временный объект, или строковое выражение материализуется сейчас же, до ';'. Если же вам необходимо вернуть e_concat как строковое выражение из функции, можно заставить его сохранить аргументы строковые выражения по копии, обернув их в force_copy{}. См. пример в tests/test_tostrexpr.cpp, Method4. Пример:

std::string t = e_concat("", text, " = ", count, " times.");
....
std::string t = "msg=" + e_concat(", ", text1, text3, text3, count1, count2);

e_fill_left()

template<StrExpr A, typename K = typename A::symb_type>

expr_fill< K, A, true > simstr::e_fill_left	(	const A &	a,
		size_t	width,
		K	symbol = K(' ') )

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

Аргументы

width	- дополнять до этой ширины
symbol	- символ для заполнения

Если строковое выражение выдаёт строку короче заданной длины, добавляет перед ней указанный символ, дополняя до нужной длины. Не обрезает строку до указанной длины. Будьте внимательны, длина берётся в code units, не в code points, а символ заполнения не может быть суррогатным, то есть занимать более одного code unit. Если надо быть точным с Unicode-символами - используйте конвертацию в char32_t и обратно.

e_fill_right()

template<StrExpr A, typename K = typename A::symb_type>

expr_fill< K, A, false > simstr::e_fill_right	(	const A &	a,
		size_t	width,
		K	symbol = K(' ') )

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

Аргументы

width	- дополнять до этой ширины
symbol	- символ для заполнения

Если строковое выражение выдаёт строку короче заданной длины, добавляет к ней указанный символ, дополняя до нужной длины. Не обрезает строку до указанной длины. Будьте внимательны, длина берётся в code units, не в code points, а символ заполнения не может быть суррогатным, то есть занимать более одного code unit. Если надо быть точным с Unicode-символами - используйте конвертацию в char32_t и обратно.

e_hex()

template<unsigned Flags = 0, FromIntNumber T>

auto simstr::e_hex ( T v )

constexpr

Позволяет конкатенировать текст и беззнаковое число в 16-ричном виде.

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

Flags	- флаги форматирования, побитовое ИЛИ из HexFlags.
T	- тип числа, выводится автоматически. Пример stringa text = +"val = "sv + e_hex(10u); EXPECT_EQ(text, "val = 0x0000000A"); stringu textu = +u"val = 0X"sv + e_hex<HexFlags::No0x | HexFlags::Short | HexFlags::Lcase>(0x12Au); EXPECT_EQ(textu, u"val = 0X12a");

e_if()

template<StrExpr A>

expr_if< A > simstr::e_if ( bool c, const A & a )

constexpr

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

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

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

Аргументы

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

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

void sql_func_info::build_full_name() {
    // Временный буфер для результата, возьмём с запасом
    // Temporary buffer for the result, take it with reserve
    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_, "[");
        // Добавляет к str названия допустимых типов
        // Adds the names of valid types to str
        param.allowed_types.to_string(str);
        if (param.optional_) {
            str += "]";
        }
        add_comma = true;
    }
    // Сохраним в stringa
    // Save it in 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() [1/2]

template<typename K>
requires is_one_of_char_v<K>

expr_real< K > simstr::e_num ( double t )

inlineconstexpr

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

Аргументы

t

- число.

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

e_num() [2/2]

template<typename K, FromIntNumber T>

expr_num< K, T > simstr::e_num ( T t )

constexpr

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

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

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

Аргументы

t

- число.

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

e_repeat() [1/2]

template<StrExpr A>

expr_repeat_expr< A > simstr::e_repeat ( const A & s, size_t l )

constexpr

Генерирует строку из l строковых выражений s типа K.

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

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

Аргументы

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

Возвращает

строковое выражение, генерирующее строку из l строковых выражений s

e_repeat() [2/2]

template<typename T, typename K = const_lit<T>::symb_type, size_t M = const_lit<T>::Count>
requires (M > 0)

expr_repeat_lit< K, M - 1 > simstr::e_repeat ( T && s, size_t l )

constexpr

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

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

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

Аргументы

l	- количество повторов
s	- строковый литерал

Возвращает

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

e_repl() [1/3]

template<StrSource A, typename K = symb_type_from_src_t<A>, typename T, StrExprForType< K > E>
requires std::is_constructible_v<str_src<K>, T>

auto simstr::e_repl ( A && w, T && p, const E & expr )

constexpr

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

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

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

Аргументы

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

e_repl() [2/3]

template<StrSource A, typename K = symb_type_from_src_t<A>, 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 ( A && w, T && p, X && r )

constexpr

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

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

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

Аргументы

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

e_repl() [3/3]

template<StrSource A, typename K = symb_type_from_src_t<A>, typename T, typename X>
requires (std::is_constructible_v<str_src<K>, T> && std::is_constructible_v<str_src<K>, X> && (!is_const_lit_v<T> || !is_const_lit_v<X>))

auto simstr::e_repl ( A && w, T && p, X && r )

constexpr

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

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

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

Аргументы

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

e_repl_const_symbols()

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

auto simstr::e_repl_const_symbols	(	A &&	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>

expr_spaces< u8s, N > simstr::e_spca ( )

constexpr

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

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

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

Возвращает

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

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

e_spcw()

template<size_t N>

expr_spaces< uws, N > simstr::e_spcw ( )

constexpr

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

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

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

Возвращает

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

Пример:

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

e_subst()

template<typename T, typename... Args>
requires (sizeof...(Args) > 0)

auto simstr::e_subst ( T && str_pattern, const details::subst_params< typename const_lit< T >::symb_type, std::type_identity_t< T >, std::type_identity_t< Args >... > & pattern, Args &&... args )

constexpr

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

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

T	- тип строки-образца, выводится из аргумента.
Args...	- типы переданных аргументов.

Аргументы

str_pattern	- Строка-образец, строковый литерал, служит для вывода типа символов выражения и получения длины образца во время компиляции.
pattern	- распарсенная во время компиляции информация составе строки-шаблона, содержит длины текстовых порций и места вставки параметров.
args...	- аргументы, которые будут подставляться в заданные места образца. Также, как и в e_concat, могут быть строковые литералы, строковые выражения, стандартные строки, а также любые типы, для которых есть преобразование в строковое выражение.

Функция создаёт строковое выражение, которое при материализации генерирует текст из образца, подставляя в места подстановки значения переданных аргументов. Строка-образец задается строковым литералом, константной времени компиляции. Места вставки обозначаются либо как {}, либо как {номер}. В случае без указания номера, параметры подставляются в переданном в функцию порядке. В случае указания номера, параметры подставляются в соответствии с указанным порядковым номером. Нумерация параметров начинается с 1. Смешивать параметры без номера и с номером нельзя - используется только один из вариантов для всех подстановок. В случае указания номеров - один параметр может участвовать в нескольких подстановках. Все переданные параметры должны участвовать в подстановках. Для вставки самих фигурных скобок они должны удваиваться - {{, }}. Строка-образец обрабатывается во время компиляции, и для неё сразу создаётся массив с информацией о вставках - какие части строки копировать в результат, в какие места вставлять переданные значения. Из-за невозможности вывести компилятором тип для объекта с этой информацией напрямую из строкового литерала, его приходится указывать дважды - первый раз как параметр для вывода типа, второй - как параметр для конструктора типа, выведенного из первого параметра. Для упрощения задания образца используется макрос S_FRM("образец{}"), который просто повторяет параметр два раза. Функция не является заменой std::format, не работает с образцом, задаваемым в рантайм, и не поддерживает каких-либо параметров форматирования подставляемых значений. Все передаваемые аргументы должны сами уметь преобразовывать себя в строковые выражения (см. Конвертация типов в в строковые выражения). Пример:

lstringu<100> u16t = e_subst(S_FRM(u"Test {} from {}, {}."), from, total, success ? u"success"_ss : u"fail"_ss);

e_t()

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

expr_literal< typename const_lit< T >::symb_type, static_cast< size_t >(N - 1)> simstr::e_t ( T && s )

constexpr

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

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

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/5]

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

strexprjoin< A, B > simstr::operator+ ( const A & a, const B & b )

constexpr

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

Аргументы

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

Возвращает

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

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

operator+() [2/5]

template<typename K, StrExprForType< K > A>

strexprjoin_c< A, expr_char< K > > simstr::operator+ ( const A & a, K s )

constexpr

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

Возвращает

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

reply = prompt + '>' + result;

operator+() [3/5]

template<StrExpr A, typename T, typename P = typename const_lit<T>::symb_type, size_t N = const_lit<T>::Count>
requires is_equal_str_type_v<typename A::symb_type, P>

expr_literal_join< false, P,(N - 1), A > simstr::operator+ ( const A & a, T && s )

constexpr

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

Возвращает

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

operator+() [4/5]

template<StrExpr A, typename T, typename P = typename const_lit<T>::symb_type, size_t N = const_lit<T>::Count>
requires is_equal_str_type_v<typename A::symb_type, P>

expr_literal_join< true, P,(N - 1), A > simstr::operator+ ( T && s, const A & a )

constexpr

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

Возвращает

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

operator+() [5/5]

template<simstr::StdStrSource T>

simstr::expr_stdstr< typename T::value_type, T > std::operator+

(

const T &

str

)

Унарный оператор+ для преобразования стандартных строк в строковые выражения.

Стандартные строки могут напрямую участвовать в строковых выражениях только когда другой операнд тоже является строковым выражением. Если другой операнд - не строковое выражение, используйте этот оператор, чтобы превратить std::basic_string или std::basic_string_view в строковое выражение. Пример:

std::string make_text(const std::string& text, int count, std::string_view what, std::string_view what_p = ""sv) {
    return +text + " " + count + " " + e_choice(what_p.empty(), what + e_if(count > 1, "s"), e_choice(count > 1, +what_p, +what));
}