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

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

Концепты
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 >
	Тип для строкового выражения, генерирующее строку, в которой заданные символы заменяются на заданные строки. Подробнее...
struct	simstr::e_concat< K, G, Arg, Args >
	Строковое выражения, объединяющее указанные строковые выражения, с использованием заданного разделителя. Подробнее...
struct	simstr::e_subst< K, PtLen, Args >
	Строковое выражение, которое подставляет в заданные места в строковом литерале - образце значения переданных строковых выражений. Подробнее...
struct	simstr::e_vsubst< K, Args >
	Строковое выражение, которое подставляет в заданные места в строке-образце, задаваемой в рантайме, значения переданных строковых выражений. Подробнее...

Перечисления
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<unsigned R, auto fp = f::df, FromIntNumber T> requires good_int_flags<flags_checker<R, T, decltype(fp)>, false>
constexpr auto	simstr::e_int (T v)
	Создает объект, который преобразовывается в строковое выражение, генерирующее строковое представление числа.
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<char... Chars>
SS_CONSTEVAL auto	simstr::operator""_fmt ()
	Создает набор из основания системы счисления и флагов, который может быть применён к целым числам для задания параметров форматирования с помощью оператора деления: num / 0xПараметрыФорматирования_fmt. Параметры форматирования задаются следующим образом: сначала идёт 0x, затем основание счисления, записанное в десятичном виде. Далее могут идти символы, обозначающие различные флаги:
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<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_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	- тип числа, выводится автоматически.

Аргументы

v

- число.

Это более быстрое преобразование в строку в 16ричном виде, чем через e_int, однако с меньшими возможностями форматирования. По умолчанию создается представление в виде 0x000012AB, то есть префикс 0x и дополнения нулями до ширины по размеру типа числа (2 символа на байт). Можно указать флаги:

• HexFlags::Short - не дополнять нулями до фиксированной ширины.
• HexFlags::Lcase - выводить символы в нижнем регистре.
• HexFlags::No0x - не выводить префикс.

Кроме того, возможна краткая запись этого выражения в виде num / N_f16 N обозначает флаги форматирования

• 1 - HexFlags::Short
• 2 - HexFlags::Lcase
• 3 - HexFlags::No0x

Пример

stringa text = +"val = "sv + e_hex(10);
EXPECT_EQ(text, "val = 0x0000000A");
 
stringu textu = +u"val = 0X"sv + e_hex<HexFlags::No0x | HexFlags::Short | HexFlags::Lcase>(0x12A);
EXPECT_EQ(textu, u"val = 0X12a");
 
text = "Num in hex: " + num / 0_f16;      // same as e_hex(num);
text = "Num in hex: " + num / 13_f16;     // same as e_hex<HexFlags::Short | HexFlags::No0x>(num);
text = "Num in hex: " + num / 123_f16;    // same as e_hex<HexFlags::Short | HexFlags::No0x | HexFlags::Lcase>(num);
text = "Num in hex: " + num / 2_f16;      // same as e_hex<HexFlags::No0x | HexFlags::Lcase>(num);

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_int()

template<unsigned R, auto fp = f::df, FromIntNumber T>
requires good_int_flags<flags_checker<R, T, decltype(fp)>, false>

auto simstr::e_int ( T v )

constexpr

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

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

R	- Основание счисления, должно быть от 2 до 36.
fp	- параметры для форматирования числа.
T	- тип числа, выводится из аргумента.

Аргументы

v

- число.

Возвращает

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

параметры форматирования числа задаются набором констант, через '|'.

• f::l при задании ширины поля выравнивать влево.
• f::r при задании ширины поля выравнивать вправо.
• f::с при задании ширины поля выравнивать по центру.
• f::p выводить префикс системы счисления, 0b для 2, 0 для 8, 0x для 16.
• f::P выводить префикс системы счисления, 0B для 2, 0 для 8, 0X для 16.
• f::z дополнять число до заданной ширины нулями слева. Не совместимо с опциями выравнивания.
• f::u Для систем счисления более 10, выводить символы в верхнем регистре.
• f::sp Для знаковых типов чисел для положительных значений выводить '+' перед числом.
• f::ss Для знаковых типов чисел для положительных значений выводить пробел перед числом.
• f::f<'c'>‘ Задаёт символ-заполнитель при указании ширины поля. По умолчанию - пробел.
• f::w<N> Задаёт ширину поля. При указании ширины можно либо указать желаемое выравнивание (r, l, c), либо дополнение нулями (z), но не оба сразу. Если ничего из этого не указано, применяется выравнивание вправо. Число дополняется до заданной ширины, если оно короче. Если длиннее, то выводится всё число.
• f::wp То же самое, что и f::w<-1>. В этом случае ширина должна передаваться дополнительным аргументом e_int.
  Пример:

  stringu u16t = u"Number "_ss + num
      + " in octal is " + e_int<8, f::w<16> | f::z>(num)
      + ", in binary is " + e_int<2, f::w<32> | f::p | f::z>(num);

  Возможна также сокращённая запись этой функции в виде num / 0xПараметрыФорматирования_fmt. Параметры форматирования задаются следующим образом: сначала идёт 0x, затем основание счисления, записанное в десятичном виде. Далее могут идти символы, обозначающие различные флаги:
• b при задании ширины поля выравнивать влево, аналог f::l.
• d при задании ширины поля выравнивать вправо, аналог f::r.
• с при задании ширины поля выравнивать по центру, аналог f::c.
• a выводить префикс системы счисления, 0b для 2, 0 для 8, 0x для 16, аналог f::p.
• A выводить префикс системы счисления, 0B для 2, 0 для 8, 0X для 16, аналог f::P.
• 0 дополнять число до заданной ширины нулями слева. Не совместимо с опциями выравнивания, аналог f::z.
• E Для систем счисления более 10, выводить символы в верхнем регистре, аналог f::u.
• e Для знаковых типов чисел для положительных значений выводить '+' перед числом, аналог f::sp.
• f Для знаковых типов чисел для положительных значений выводить пробел перед числом, аналог f::ss.
• FКодCимволаВhex Задаёт код символа-заполнителя при указании ширины поля, аналог f::f<'c'>.
• Число в десятичном виде, начинающееся не с 0. Задаёт ширину поля, аналог f::w<N>. При указании ширины можно либо указать желаемое выравнивание (b, c, d), либо дополнение нулями (0), но не оба сразу. Если ничего из этого не указано, применяется выравнивание вправо. Число дополняется до заданной ширины, если оно короче. Если длиннее, то выводится всё число.
• ' разделитель, пропускается.

Так как после F все символы воспринимаются как hex код символа разделителя, при необходимости его использования лучше ставить его в конце литерала форматирования, или отделять '.
Пример:

stringu u16t = u"Number "_ss + num
    + " in octal is " + num / 0x8'016_fmt      // same as e_int<8, f::w<16> | f::z>(num)
    + ", in binary is " + num / 0x2a032_fmt;   // same as e_int<2, f::w<32> | f::p | f::z>(num);
 ....
stringa text = "Count is "_ss + count / 0x16A08E_fmt; // same as e_int<16, f::P | f::z | f::w<8> | f::u>(count)
 ....
stringa text = "Number "_ss + count / 0x16c20EF5F_fmt; // same as e_int<16, f::c | f::w<20> | f::u | f::f<'_'>>(count)

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_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""_fmt()

template<char... Chars>

SS_CONSTEVAL auto simstr::literals::operator""_fmt

(

)

Создает набор из основания системы счисления и флагов, который может быть применён к целым числам для задания параметров форматирования с помощью оператора деления: num / 0xПараметрыФорматирования_fmt. Параметры форматирования задаются следующим образом: сначала идёт 0x, затем основание счисления, записанное в десятичном виде. Далее могут идти символы, обозначающие различные флаги:

• b при задании ширины поля выравнивать влево, аналог f::l.
• d при задании ширины поля выравнивать вправо, аналог f::r.
• c при задании ширины поля выравнивать по центру, аналог f::c.
• a выводить префикс системы счисления, 0b для 2, 0 для 8, 0x для 16, аналог f::p.
• A выводить префикс системы счисления, 0B для 2, 0 для 8, 0X для 16, аналог f::P.
• 0 дополнять число до заданной ширины нулями слева. Не совместимо с опциями выравнивания, аналог f::z.
• E Для систем счисления более 10, выводить символы в верхнем регистре, аналог f::u.
• e Для знаковых типов чисел для положительных значений выводить '+' перед числом, аналог f::sp.
• f Для знаковых типов чисел для положительных значений выводить пробел перед числом, аналог f::ss.
• FКодCимволаВhex Задаёт код символа-заполнителя при указании ширины поля, аналог f::f<'c'>.
• Число в десятичном виде, начинающееся не с 0. Задаёт ширину поля, аналог f::w<N>. При указании ширины можно либо указать желаемое выравнивание (b, c, d), либо дополнение нулями (0), но не оба сразу. Если ничего из этого не указано, применяется выравнивание вправо. Число дополняется до заданной ширины, если оно короче. Если длиннее, то выводится всё число.
• ' разделитель, пропускается.

Так как после F все символы воспринимаются как hex код символа разделителя, при необходимости его использования лучше ставить его в конце литерала форматирования, или отделять '.
Пример:

stringu u16t = u"Number "_ss + num
    + " in octal is " + num / 0x8'016_fmt      // same as e_int<8, f::w<16> | f::z>(num)
    + ", in binary is " + num / 0x2a032_fmt;   // same as e_int<2, f::w<32> | f::p | f::z>(num);
 ....
stringa text = "Count is "_ss + count / 0x16A08E_fmt; // same as e_int<16, f::P | f::z | f::w<8> | f::u>(count)
 ....
stringa text = "Number "_ss + count / 0x16c20EF5F_fmt; // same as e_int<16, f::c | f::w<20> | f::u | f::f<'_'>>(count)

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));
}