sstring.h

/*
* ver. 1.8.1
 * (c) Проект "SimStr", Александр Орефков orefkov@gmail.com
 * Классы для работы со строками
* (c) Project "SimStr", Aleksandr Orefkov orefkov@gmail.com
* Classes for working with strings
 */

#pragma once
 
#ifndef __has_declspec_attribute
#define __has_declspec_attribute(x) 0
#endif
const bool isWindowsOs = // NOLINT
#ifdef _WIN32
    true
#else
    false
#endif
    ;
 
#ifdef SIMSTR_IN_SHARED
    #if defined(_MSC_VER) || (defined(__clang__) && __has_declspec_attribute(dllexport))
        #ifdef SIMSTR_EXPORT
            #define SIMSTR_API __declspec(dllexport)
        #else
            #define SIMSTR_API __declspec(dllimport)
        #endif
    #elif (defined(__GNUC__) || defined(__GNUG__)) && defined(SIMSTR_EXPORT)
        #define SIMSTR_API __attribute__((visibility("default")))
    #else
        #define SIMSTR_API
    #endif
#else
    #define SIMSTR_API
#endif
 
#define IN_FULL_SIMSTR
#include "strexpr.h"
 
#include <format>
#include <unordered_map>
#include <atomic>
#include <memory>
#include <string.h>
#include <iostream>
#include <cmath>
 
#ifdef _WIN32
#include <stdio.h>
#endif
 
#ifdef _MSC_VER
// warning C4201 : nonstandard extension used : nameless struct / union
#pragma warning(disable : 4201)
#endif
 
namespace simstr {
 
template<typename T>
struct unicode_traits {};   // NOLINT
 
template<>
struct unicode_traits<u8s> {
    // Эти операции с utf-8 могут изменить длину строки
    // Поэтому их специализации отличаются
    // В функцию помимо текста и адреса буфера для записи передается размер буфера
    // Возвращает длину получающейся строки.
    // Если получающеюся строка не влезает в отведенный буфер, указатели устанавливаются на последние
    // обработанные символы, для повторного возобновления работы,
    // а для оставшихся символов считается нужный размер буфера.
    // These utf-8 operations can change the length of the string
    // Therefore their specializations are different
    // In addition to the text and address of the buffer for writing, the buffer size is passed to the function
    // Returns the length of the resulting string.
    // If the resulting string does not fit into the allocated buffer, pointers are set to the last
    // processed characters to resume work again,
    // and for the remaining characters the required buffer size is calculated.
    static SIMSTR_API size_t upper(const u8s*& src, size_t len, u8s*& dest, size_t lenBuf);
    static SIMSTR_API size_t lower(const u8s*& src, size_t len, u8s*& dest, size_t lenBuf);
    static SIMSTR_API size_t upper_len(const u8s* src, size_t len);
    static SIMSTR_API size_t lower_len(const u8s* src, size_t len);
 
    static SIMSTR_API int compareiu(const u8s* text1, size_t len1, const u8s* text2, size_t len2);
 
    static SIMSTR_API size_t hashia(const u8s* src, size_t l);
    static SIMSTR_API size_t hashiu(const u8s* src, size_t l);
};
 
template<>
struct unicode_traits<u16s> {
    static SIMSTR_API void upper(const u16s* src, size_t len, u16s* dest);
    static SIMSTR_API void lower(const u16s* src, size_t len, u16s* dest);
 
    static SIMSTR_API int compareiu(const u16s* text1, size_t len1, const u16s* text2, size_t len2);
    static SIMSTR_API size_t hashia(const u16s* src, size_t l);
    static SIMSTR_API size_t hashiu(const u16s* src, size_t l);
};
 
template<>
struct unicode_traits<u32s> {
    static SIMSTR_API void upper(const u32s* src, size_t len, u32s* dest);
    static SIMSTR_API void lower(const u32s* src, size_t len, u32s* dest);
 
    static SIMSTR_API int compareiu(const u32s* text1, size_t len1, const u32s* text2, size_t len2);
    static SIMSTR_API size_t hashia(const u32s* src, size_t s);
    static SIMSTR_API size_t hashiu(const u32s* src, size_t s);
};
 
template<>
struct unicode_traits<wchar_t> {
    static void upper(const wchar_t* src, size_t len, wchar_t* dest) {
        unicode_traits<wchar_type>::upper(to_w(src), len, to_w(dest));
    }
    static void lower(const wchar_t* src, size_t len, wchar_t* dest) {
        unicode_traits<wchar_type>::lower(to_w(src), len, to_w(dest));
    }
 
    static int compareiu(const wchar_t* text1, size_t len1, const wchar_t* text2, size_t len2) {
        return unicode_traits<wchar_type>::compareiu(to_w(text1), len1, to_w(text2), len2);
    }
    static size_t hashia(const wchar_t* src, size_t s) {
        return unicode_traits<wchar_type>::hashia(to_w(src), s);
    }
    static size_t hashiu(const wchar_t* src, size_t s) {
        return unicode_traits<wchar_type>::hashiu(to_w(src), s);
    }
};
 
template<>
struct unicode_traits<char8_t> {
    static size_t upper(const ubs*& src, size_t lenStr, ubs*& dest, size_t lenBuf) {
        return unicode_traits<char>::upper((const u8s*&)src, lenStr, (u8s*&)dest, lenBuf);
    }
    static size_t lower(const ubs*& src, size_t len, ubs*& dest, size_t lenBuf) {
        return unicode_traits<char>::lower((const u8s*&)src, len, (u8s*&)dest, lenBuf);
    }
    static size_t upper_len(const ubs* src, size_t len) {
        return unicode_traits<char>::upper_len((const u8s*)src, len);
    }
    static size_t lower_len(const ubs* src, size_t len) {
        return unicode_traits<char>::lower_len((const u8s*)src, len);
    }
 
    static int compareiu(const char8_t* text1, size_t len1, const char8_t* text2, size_t len2) {
        return unicode_traits<char>::compareiu((const char*)text1, len1, (const char*)text2, len2);
    }
    static size_t hashia(const char8_t* src, size_t s) {
        return unicode_traits<char>::hashia((const char*)src, s);
    }
    static size_t hashiu(const char8_t* src, size_t s) {
        return unicode_traits<char>::hashiu((const char*)src, s);
    }
};
 
#if defined(_MSC_VER) && _MSC_VER <= 1933
template<typename K, typename... Args>
using FmtString = std::_Basic_format_string<K, std::type_identity_t<Args>...>;
#elif __clang_major__ >= 15 || _MSC_VER > 1933 || __GNUC__ >= 13
template<typename K, typename... Args>
using FmtString = std::basic_format_string<K, std::type_identity_t<Args>...>;
#else
template<typename K, typename... Args>
using FmtString = std::basic_string_view<K>;
#endif
 
template<typename K>
SIMSTR_API std::optional<double> impl_to_double(const K* start, const K* end);

template<typename K, typename StrRef, typename Impl, bool Mutable>
class str_algs : public str_src_algs<K, StrRef, Impl, Mutable> {
    constexpr const Impl& d() const noexcept {
        return *static_cast<const Impl*>(this);
    }
    constexpr size_t _len() const noexcept {
        return d().length();
    }
    constexpr const K* _str() const noexcept {
        return d().symbols();
    }
    constexpr bool _is_empty() const noexcept {
        return d().is_empty();
    }
 
public:
    using symb_type = K;
    using str_piece = StrRef;
    using traits = ch_traits<K>;
    using uni = unicode_traits<K>;
    using uns_type = std::make_unsigned_t<K>;
    using my_type = Impl;
    using base = str_src_algs<K, StrRef, Impl, Mutable>;
    str_algs() = default;
 
    int compare_iu(const K* text, size_t len) const noexcept { // NOLINT
        if (!len)
            return _is_empty() ? 0 : 1;
        return uni::compareiu(_str(), _len(), text, len);
    }
    int compare_iu(str_piece text) const noexcept { // NOLINT
        return compare_iu(text.symbols(), text.length());
    }

    bool equal_iu(str_piece text) const noexcept { // NOLINT
        return text.length() == _len() && compare_iu(text.symbols(), text.length()) == 0;
    }

    bool less_iu(str_piece text) const noexcept { // NOLINT
        return compare_iu(text.symbols(), text.length()) < 0;
    }
    // Начинается ли эта строка с указанной подстроки без учета unicode регистра
    // Does this string begin with the specified substring, insensitive to unicode case
    bool starts_with_iu(const K* prefix, size_t len) const noexcept {
        return _len() >= len && 0 == uni::compareiu(_str(), len, prefix, len);
    }
    bool starts_with_iu(str_piece prefix) const noexcept {
        return starts_with_iu(prefix.symbols(), prefix.length());
    }
    // Заканчивается ли строка указанной подстрокой без учета регистра UNICODE
    // Whether the string ends with the specified substring, case insensitive UNICODE
    constexpr bool ends_with_iu(const K* suffix, size_t len) const noexcept {
        size_t myLen = _len();
        return myLen >= len && 0 == uni::compareiu(_str() + myLen - len, len, suffix, len);
    }
    constexpr bool ends_with_iu(str_piece suffix) const noexcept {
        return ends_with_iu(suffix.symbols(), suffix.length());
    }

    template<typename R = my_type>
    R upperred() const {
        return R::upperred_from(d());
    }

    template<typename R = my_type>
    R lowered() const {
        return R::lowered_from(d());
    }

    template<bool SkipWS = true, bool AllowPlus = true>
    std::optional<double> to_double() const noexcept {
        size_t len = _len();
        const K* ptr = _str();
        if constexpr (SkipWS) {
            while (len && uns_type(*ptr) <= ' ') {
                len--;
                ptr++;
            }
        }
        if constexpr (AllowPlus) {
            if (len && *ptr == K('+')) {
                ptr++;
                len--;
            }
        }
        if (!len) {
            return {};
        }
        #ifdef __linux__
        if constexpr(sizeof(K) == 1 && requires {std::from_chars(std::declval<const K*>(), std::declval<const K*>(), std::declval<double&>()); }) {
            double d{};
            if (std::from_chars((const K*)ptr, (const K*)ptr + len, d).ec == std::errc{}) {
                return d;
            }
            return {};
        }
        #endif
        if constexpr (sizeof(K) == 1) {
            return impl_to_double((const char*)ptr, (const char*)ptr + len);
        } else if constexpr (sizeof(K) == 2) {
            return impl_to_double((const char16_t*)ptr, (const char16_t*)ptr + len);
        } else {
            return impl_to_double((const char32_t*)ptr, (const char32_t*)ptr + len);
        }
    }

    void as_number(double& t) const {
        auto res = to_double();
        t = res ? *res : std::nan("0");
    }

    template<ToIntNumber T>
    constexpr void as_number(T& t) const {
        base::as_number(t);
    }

    template<typename R = str_piece>
    constexpr std::optional<R> strip_prefix_iu(str_piece prefix) const {
        if (starts_with_iu(prefix)) {
            return R{operator()(prefix.length())};
        }
        return {};
    }

    template<typename R = str_piece>
    constexpr std::optional<R> strip_suffix_iu(str_piece suffix) const {
        if (ends_with_iu(suffix)) {
            return R{operator()(0, -suffix.length())};
        }
        return {};
    }

    template<typename R = str_piece>
    constexpr R trimmed_prefix_iu(str_piece prefix, size_t max_count = 0) const {
        str_piece res = *this;
        while(res.starts_with_iu(prefix)) {
            res = res(prefix.length());
            if (--max_count == 0) {
                break;
            }
        }
        return res;
    }

    template<typename R = str_piece>
    constexpr R trimmed_suffix_iu(str_piece suffix) const {
        str_piece res = *this;
        while(res.ends_with_iu(suffix)) {
            res = res(0, -suffix.length());
        }
        return res;
    }
};
 
/*
* Базовая структура с информацией о строке.
* Это структура для не владеющих строк.
* Так как здесь только один базовый класс, MSVC компилятор автоматом применяет empty base optimization,
* в результате размер класса не увеличивается
* Basic structure with string information.
* This is the structure for non-owning strings.
* Since there is only one base class, the MSVC compiler automatically applies empty base optimization,
* as a result the class size does not increase
*/

template<typename K>
struct simple_str : str_algs<K, simple_str<K>, simple_str<K>, false> {
    using symb_type = K;
    using my_type = simple_str<K>;
 
    const symb_type* str;
    size_t len;
 
    constexpr simple_str() = default;
 
    constexpr simple_str(str_src<K> src) : str(src.str), len(src.len){}

    template<typename T, size_t N = const_lit_for<K, T>::Count>
    constexpr simple_str(T&& v) noexcept : str((const K*)v), len(N - 1) {}
    constexpr simple_str(const K* p, size_t l) noexcept : str(p), len(l) {}
    template<typename A>
    constexpr simple_str(const std::basic_string<K, std::char_traits<K>, A>& s) noexcept : str(s.data()), len(s.length()) {}
    constexpr simple_str(const std::basic_string_view<K, std::char_traits<K>>& s) noexcept : str(s.data()), len(s.length()) {}
    constexpr size_t length() const noexcept {
        return len;
    }

    constexpr const symb_type* symbols() const noexcept {
        return str;
    }

    constexpr bool is_empty() const noexcept {
        return len == 0;
    }

    constexpr bool is_same(simple_str<K> other) const noexcept {
        return str == other.str && len == other.len;
    }

    constexpr bool is_part_of(simple_str<K> other) const noexcept {
        return str >= other.str && str + len <= other.str + other.len;
    }

    constexpr K operator[](size_t idx) const {
        return str[idx];
    }

    constexpr my_type& remove_prefix(size_t delta) {
        str += delta;
        len -= delta;
        return *this;
    }

    constexpr my_type& remove_suffix(size_t delta) {
        len -= delta;
        return *this;
    }
};
 
template<typename K>
struct simple_str_selector {
    using type = simple_str<K>;
};

template<typename K>
struct simple_str_nt : simple_str<K>, null_terminated<K, simple_str_nt<K>> {
    using symb_type = K;
    using my_type = simple_str_nt<K>;
    using base = simple_str<K>;
 
    constexpr static const K empty_string[1] = {0};
 
    simple_str_nt() = default;
    template<typename T> requires is_one_of_type<std::remove_cvref_t<T>, const K*, K*>::value
    constexpr explicit simple_str_nt(T&& p) noexcept {
        base::len = p ? static_cast<size_t>(base::traits::length(p)) : 0;
        base::str = base::len ? p : empty_string;
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
    constexpr simple_str_nt(T&& v) noexcept : base(std::forward<T>(v)) {}

    constexpr simple_str_nt(const K* p, size_t l) noexcept : base(p, l) {}
 
    template<StrType<K> T>
    constexpr simple_str_nt(T&& t) {
        base::str = t.symbols();
        base::len = t.length();
    }
    template<typename A>
    constexpr simple_str_nt(const std::basic_string<K, std::char_traits<K>, A>& s) noexcept : base(s) {}
 
    static const my_type empty_str;
    constexpr my_type to_nts(size_t from) {
        if (from > base::len) {
            from = base::len;
        }
        return {base::str + from, base::len - from};
    }
};
 
template<typename K>
inline const simple_str_nt<K> simple_str_nt<K>::empty_str{simple_str_nt<K>::empty_string, 0};
 
template<typename K>
using Splitter = SplitterBase<K, simple_str<K>>;
 
using ssa = simple_str<u8s>;
using ssb = simple_str<ubs>;
using ssw = simple_str<wchar_t>;
using ssu = simple_str<u16s>;
using ssuu = simple_str<u32s>;
using stra = simple_str_nt<u8s>;
using strb = simple_str_nt<ubs>;
using strw = simple_str_nt<wchar_t>;
using stru = simple_str_nt<u16s>;
using struu = simple_str_nt<u32s>;
 
template<typename Src, typename Dest>
struct utf_convert_selector;
 
template<typename Src>
struct utf_convert_selector<Src, Src> {
    static size_t need_len(const Src* src, size_t srcLen) {
        return srcLen;
    }
    static size_t convert(const Src* src, size_t srcLen, Src* dest) {
        ch_traits<Src>::copy(dest, src, srcLen + 1);
        return srcLen;
    }
};
 
template<>
struct utf_convert_selector<u8s, u16s> {
    static SIMSTR_API size_t need_len(const u8s* src, size_t srcLen);
    static SIMSTR_API size_t convert(const u8s* src, size_t srcLen, u16s* dest);
};
 
template<>
struct utf_convert_selector<u8s, u32s> {
    static SIMSTR_API size_t need_len(const u8s* src, size_t srcLen);
    static SIMSTR_API size_t convert(const u8s* src, size_t srcLen, u32s* dest);
};
 
template<>
struct utf_convert_selector<u16s, u8s> {
    static SIMSTR_API size_t need_len(const u16s* src, size_t srcLen);
    static SIMSTR_API size_t convert(const u16s* src, size_t srcLen, u8s* dest);
};
 
template<>
struct utf_convert_selector<u16s, u32s> {
    static SIMSTR_API size_t need_len(const u16s* src, size_t srcLen);
    static SIMSTR_API size_t convert(const u16s* src, size_t srcLen, u32s* dest);
};
 
template<>
struct utf_convert_selector<u32s, u8s> {
    static SIMSTR_API size_t need_len(const u32s* src, size_t srcLen);
    static SIMSTR_API size_t convert(const u32s* src, size_t srcLen, u8s* dest);
};
 
template<>
struct utf_convert_selector<u32s, u16s> {
    static SIMSTR_API size_t need_len(const u32s* src, size_t srcLen);
    static SIMSTR_API size_t convert(const u32s* src, size_t srcLen, u16s* dest);
};

template<typename K, typename Impl>
class from_utf_convertible {
protected:
    from_utf_convertible() = default;
    using my_type = Impl;
    /*
     Эти методы должен реализовать класс-наследник.
     вызывается только при создании объекта
       init(size_t size)
    */
    template<typename O>
        requires(!std::is_same_v<O, K>)
    void init_from_utf_convertible(simple_str<O> init) {
        using from_t = to_base_char_t<O>;
        using to_t = to_base_char_t<K>;
 
        using worker = utf_convert_selector<from_t, to_t>;
        Impl* d = static_cast<Impl*>(this);
        size_t len = init.length();
        if (!len)
            d->create_empty();
        else {
            size_t need = worker::need_len((const from_t*)init.symbols(), len);
            K* str = d->init(need);
            str[need] = 0;
            worker::convert((const from_t*)init.symbols(), len, (to_t*)str);
        }
    }
};

template<typename From, typename To> requires (!std::is_same_v<From, To>)
struct expr_utf : expr_to_std_string<expr_utf<From, To>> {
    using symb_type = To;
    using from_t = to_base_char_t<From>;
    using to_t = to_base_char_t<To>;
    using worker = utf_convert_selector<from_t, to_t>;
 
    simple_str<From> source_;
 
    constexpr expr_utf(simple_str<From> source) : source_(source){}
 
    size_t length() const noexcept {
        return worker::need_len((const from_t*)source_.symbols(), source_.length());
    }
    To* place(To* ptr) const noexcept {
        return ptr + worker::convert((const from_t*)source_.symbols(), source_.length(), (to_t*)ptr);
    }
};

template<typename To, typename From> requires (!std::is_same_v<From, To>)
expr_utf<From, To> e_utf(simple_str<From> from) {
    return {from};
}
 
template<is_one_of_char_v K, bool upper>
struct expr_change_case : expr_to_std_string<expr_change_case<K, upper>>{
    using symb_type = K;
 
    str_src<K> src_;
    mutable size_t len_{};
 
    template<StrSource S>
    expr_change_case(S&& s) : src_(std::forward<S>(s)){}
 
    constexpr size_t length() const noexcept {
        if constexpr (sizeof(K) > 1) {
            return src_.length();
        } else {
            if constexpr (upper) {
                len_ = unicode_traits<K>::upper_len(src_.str, src_.len);
            } else {
                len_ = unicode_traits<K>::lower_len(src_.str, src_.len);
            }
            return len_;
        }
    }
    constexpr K* place(K* ptr) const noexcept {
        if constexpr (sizeof(K) > 1) {
            if constexpr (upper) {
                unicode_traits<K>::upper(src_.str, src_.len, ptr);
            } else {
                unicode_traits<K>::lower(src_.str, src_.len, ptr);
            }
            return ptr + src_.len;
        } else {
            const K* src = src_.str;
            if constexpr (upper) {
                unicode_traits<K>::upper(src, src_.len, ptr, len_);
            } else {
                unicode_traits<K>::lower(src, src_.len, ptr, len_);
            }
            return ptr;
        }
    }
};

template<is_one_of_char_v K>
struct e_upper : expr_change_case<K, true> {
    using base = expr_change_case<K, true>;
    using base::base;
};
 
template<StrSource S>
e_upper(S&&) -> e_upper<symb_type_from_src_t<S>>;

template<is_one_of_char_v K>
struct e_lower : expr_change_case<K, false> {
    using base = expr_change_case<K, false>;
    using base::base;
};
 
template<StrSource S>
e_lower(S&&) -> e_lower<symb_type_from_src_t<S>>;

template<typename A, typename K>
concept storable_str = requires {
    A::is_str_storable == true;
    std::is_same_v<typename A::symb_type, K>;
};

template<typename A, typename K>
concept mutable_str = storable_str<A, K> && requires { A::is_str_mutable == true; };

template<typename A, typename K>
concept immutable_str = storable_str<A, K> && !mutable_str<A, K>;

template<typename K, typename Impl, typename Allocator>
class str_storable : protected Allocator {
public:
    using my_type = Impl;
    using traits = ch_traits<K>;
    using allocator_t = Allocator;
    using s_str = simple_str<K>;
    using s_str_nt = simple_str_nt<K>;
 
protected:
    constexpr allocator_t& allocator() {
        return *static_cast<Allocator*>(this);
    }
    constexpr const allocator_t& allocator() const {
        return *static_cast<const Allocator*>(this);
    }
 
    using uni = unicode_traits<K>;
 
    constexpr Impl& d() noexcept {
        return *static_cast<Impl*>(this);
    }
    constexpr const Impl& d() const noexcept {
        return *static_cast<const Impl*>(this);
    }

    template<typename... Args>
    explicit constexpr str_storable(Args&&... args) : Allocator(std::forward<Args>(args)...) {}

    constexpr void init_from_str_other(s_str other) {
        if (other.length()) {
            K* ptr = d().init(other.length());
            traits::copy(ptr, other.symbols(), other.length());
            ptr[other.length()] = 0;
        } else
            d().create_empty();
    }

    constexpr void init_str_repeat(size_t repeat, s_str pattern) {
        size_t l = pattern.length(), allLen = l * repeat;
        if (allLen) {
            K* ptr = d().init(allLen);
            for (size_t i = 0; i < repeat; i++) {
                traits::copy(ptr, pattern.symbols(), l);
                ptr += l;
            }
            *ptr = 0;
        } else
            d().create_empty();
    }

    constexpr void init_symb_repeat(size_t count, K pad) {
        if (count) {
            K* str = d().init(count);
            traits::assign(str, count, pad);
            str[count] = 0;
        } else
            d().create_empty();
    }

    template<StrExprForType<K> A>
    constexpr void init_str_expr(const A& expr) {
        size_t len = expr.length();
        if (len)
            *expr.place((typename A::symb_type*)d().init(len)) = 0;
        else
            d().create_empty();
    }

    template<StrType<K> From>
    void init_replaced(const From& f, s_str pattern, s_str repl, size_t offset = 0, size_t maxCount = 0) {
        auto findes = f.find_all(pattern, offset, maxCount);
        if (!findes.size()) {
            new (this) my_type{f};
            return;
        }
        size_t srcLen = f.length();
        size_t newSize = srcLen + static_cast<ptrdiff_t>(repl.len - pattern.len) * findes.size();
 
        if (!newSize) {
            new (this) my_type{};
            return;
        }
 
        K* ptr = d().init(newSize);
        const K* src = f.symbols();
        size_t from = 0;
        for (const auto& s: findes) {
            size_t copyLen = s - from;
            if (copyLen) {
                traits::copy(ptr, src + from, copyLen);
                ptr += copyLen;
            }
            if (repl.len) {
                traits::copy(ptr, repl.str, repl.len);
                ptr += repl.len;
            }
            from = s + pattern.len;
        }
        srcLen -= from;
        if (srcLen) {
            traits::copy(ptr, src + from, srcLen);
            ptr += srcLen;
        }
        *ptr = 0;
    }
 
public:
 
    inline static constexpr bool is_str_storable = true;
    constexpr operator const K*() const noexcept {
        return d().symbols();
    }

    constexpr s_str_nt to_nts(size_t from = 0) const {
        size_t len = d().length();
        if (from >= len) {
            from = len;
        }
        return {d().symbols() + from, len - from};
    }

    constexpr operator s_str_nt() const {
        return {d().symbols(), d().length()};
    }

    template<typename T, typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    static my_type join(const T& strings, s_str delimiter, bool tail = false, bool skip_empty = false, Args&&... args) {
        my_type result(std::forward<Args>(args)...);
        if (strings.size()) {
            if (strings.size() == 1 && (!delimiter.length() || !tail)) {
                result = strings.front();
            } else {
                size_t commonLen = 0;
                for (const auto& t: strings) {
                    size_t len = t.length();
                    if (len > 0 || !skip_empty) {
                        if (commonLen > 0) {
                            commonLen += delimiter.len;
                        }
                        commonLen += len;
                    }
                }
                commonLen += (tail && delimiter.len > 0 && (commonLen > 0 || (!skip_empty && strings.size() > 0))? delimiter.len : 0);
                if (commonLen) {
                    K* ptr = result.init(commonLen);
                    K* write = ptr;
                    for (const auto& t: strings) {
                        size_t copyLen = t.length();
                        if (delimiter.len > 0 && write != ptr && (copyLen || !skip_empty)) {
                            ch_traits<K>::copy(write, delimiter.str, delimiter.len);
                            write += delimiter.len;
                        }
                        ch_traits<K>::copy(write, t.symbols(), copyLen);
                        write += copyLen;
                    }
                    if (delimiter.len > 0 && tail && (write != ptr || (!skip_empty && strings.size() > 0))) {
                        ch_traits<K>::copy(write, delimiter.str, delimiter.len);
                        write += delimiter.len;
                    }
                    *write = 0;
                } else {
                    result.create_empty();
                }
            }
        }
        return result;
    }

    template<StrType<K> From, typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    static my_type upperred_only_ascii_from(const From& f, Args&&... args) {
        return my_type{e_ascii_upper<K>{f}, std::forward<Args>(args)...};
    }

    template<StrType<K> From, typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    static my_type lowered_only_ascii_from(const From& f, Args&&... args) {
        return my_type{e_ascii_lower<K>{f}, std::forward<Args>(args)...};
    }

    template<StrType<K> From, typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    static my_type upperred_from(const From& f, Args&&... args) {
        return my_type{e_upper<K>{f}, std::forward<Args>(args)...};
    }

    template<StrType<K> From, typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    static my_type lowered_from(const From& f, Args&&... args) {
        return my_type{e_lower<K>{f}, std::forward<Args>(args)...};
    }

    template<StrType<K> From, typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    static my_type replaced_from(const From& f, s_str pattern, s_str repl, size_t offset = 0, size_t maxCount = 0, Args&&... args) {
        return my_type{f, pattern, repl, offset, maxCount, std::forward<Args>(args)...};
    }
};

template<typename A>
concept AllocatableNoSized = requires(A& a, size_t size, void* void_ptr) {
    { a.allocate(size) } -> std::same_as<void*>;
    { a.deallocate(void_ptr) } noexcept -> std::same_as<void>;
};

template<typename A>
concept AllocatableSized = requires(A& a, size_t size, void* void_ptr) {
    { a.allocate(size) } -> std::same_as<void*>;
    { a.deallocate(void_ptr, size) } noexcept -> std::same_as<void>;
};

template<typename A>
concept Allocatable = AllocatableNoSized<A> || AllocatableSized<A>;
 
struct printf_selector {
    template<typename K, typename... T>  requires (is_one_of_std_char_v<K>)
    static int snprintf(K* buffer, size_t count, const K* format, T&&... args) {
        if constexpr (sizeof(K) == 1) {
          #ifndef _WIN32
            return std::snprintf(to_one_of_std_char(buffer), count, to_one_of_std_char(format), std::forward<T>(args)...);
          #else
            // Поддерживает позиционные параметры
            // Supports positional parameters
            return _sprintf_p(to_one_of_std_char(buffer), count, to_one_of_std_char(format), args...);
          #endif
        } else {
          #ifndef _WIN32
            return std::swprintf(to_one_of_std_char(buffer), count, to_one_of_std_char(format), args...);
          #else
            // Поддерживает позиционные параметры
            // Supports positional parameters
            return _swprintf_p(to_one_of_std_char(buffer), count, to_one_of_std_char(format), args...);
          #endif
        }
    }
    template<typename K>  requires (is_one_of_std_char_v<K>)
    static int vsnprintf(K* buffer, size_t count, const K* format, va_list args) {
        if constexpr (std::is_same_v<K, u8s>) {
          #ifndef _WIN32
            return std::vsnprintf(buffer, count, format, args);
          #else
            // Поддерживает позиционные параметры
            // Supports positional parameters
            return _vsprintf_p(buffer, count, format, args);
          #endif
        } else {
          #ifndef _WIN32
            return std::vswprintf(to_one_of_std_char(buffer), count, to_one_of_std_char(format), args);
          #else
            // Поддерживает позиционные параметры
            // Supports positional parameters
            return _vswprintf_p(buffer, count, format, args);
          #endif
        }
    }
};
 
inline size_t grow2(size_t ret, size_t currentCapacity) {
    return ret <= currentCapacity ? ret : ret * 2;
}

template<typename K, typename Impl>
class str_mutable {
public:
    using my_type = Impl;
 
private:
    Impl& d() {
        return *static_cast<Impl*>(this);
    }
    const Impl& d() const {
        return *static_cast<const Impl*>(this);
    }
    size_t _len() const noexcept {
        return d().length();
    }
    const K* _str() const noexcept {
        return d().symbols();
    }
    using str_piece = simple_str<K>;
    using symb_type = K;
    using traits = ch_traits<K>;
    using uni = unicode_traits<K>;
    using uns_type = std::make_unsigned_t<K>;
 
    template<typename Op>
    Impl& make_trim_op(const Op& op) {
        str_piece me = d(), pos = op(me);
        if (me.length() != pos.length()) {
            if (me.symbols() != pos.symbols())
                traits::move(const_cast<K*>(me.symbols()), pos.symbols(), pos.length());
            d().set_size(pos.length());
        }
        return d();
    }
 
    template<auto Op>
    Impl& commonChangeCase() {
        size_t len = _len();
        if (len)
            Op(_str(), len, str());
        return d();
    }
    // GCC до сих пор не позволяет делать внутри класса полную специализацию вложенного класса,
    // только частичную. Поэтому добавим неиспользуемый параметр шаблона.
    // GCC still does not allow full specialization of a nested class within a class,
    // only partial. Resources additive unused parameter template.
    template<typename T, bool Dummy = true>
    struct CaseTraits {
        static Impl& upper(Impl& obj) {
            return obj.template commonChangeCase<unicode_traits<K>::upper>();
        }
        static Impl& lower(Impl& obj) {
            return obj.template commonChangeCase<unicode_traits<K>::lower>();
        }
    };
 
    template<auto Op>
    Impl& utf8CaseChange() {
        // Для utf-8 такая операция может изменить длину строки, поэтому для них делаем разные специализации
        // For utf-8, such an operation can change the length of the string, so we make different specializations for them
        size_t len = _len();
        if (len) {
            u8s* writePos = str();
            const u8s *startData = writePos, *readPos = writePos;
            size_t newLen = Op(readPos, len, writePos, len);
            if (newLen < len) {
                // Строка просто укоротилась
                // The string was simply shortened
                d().set_size(newLen);
            } else if (newLen > len) {
                // Строка не влезла в буфер.
                // The string did not fit into the buffer.
                size_t readed = static_cast<size_t>(readPos - startData);
                size_t writed = static_cast<size_t>(writePos - startData);
                d().set_size(newLen);
                startData = str(); // при изменении размера могло изменится | may change when resizing
                readPos = startData + readed;
                writePos = const_cast<u8s*>(startData) + writed;
                Op(readPos, len - readed, writePos, newLen - writed);
            }
        }
        return d();
    }
    template<bool Dummy>
    struct CaseTraits<u8s, Dummy> {
        static Impl& upper(Impl& obj) {
            return obj.template utf8CaseChange<unicode_traits<u8s>::upper>();
        }
        static Impl& lower(Impl& obj) {
            return obj.template utf8CaseChange<unicode_traits<u8s>::lower>();
        }
    };
 
    template<TrimSides S, bool withSpaces, typename T, size_t N = const_lit_for<K, T>::Count>
    Impl& makeTrim(T&& pattern) {
        return make_trim_op(trim_operator<S, K, N - 1, withSpaces>{pattern});
    }
 
    template<TrimSides S, bool withSpaces>
    Impl& makeTrim(str_piece pattern) {
        return make_trim_op(trim_operator<S, K, 0, withSpaces>{{pattern}});
    }
 
public:
    K* str() noexcept {
        return d().str();
    }

    explicit operator K*() noexcept {
        return str();
    }

    Impl& trim() {
        return make_trim_op(SimpleTrim<TrimSides::TrimAll, K>{});
    }

    Impl& trim_left() {
        return make_trim_op(SimpleTrim<TrimSides::TrimLeft, K>{});
    }

    Impl& trim_right() {
        return make_trim_op(SimpleTrim<TrimSides::TrimRight, K>{});
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    Impl& trim(T&& pattern) {
        return makeTrim<TrimSides::TrimAll, false>(pattern);
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    Impl& trim_left(T&& pattern) {
        return makeTrim<TrimSides::TrimLeft, false>(pattern);
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    Impl& trim_right(T&& pattern) {
        return makeTrim<TrimSides::TrimRight, false>(pattern);
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    Impl& trim_with_spaces(T&& pattern) {
        return makeTrim<TrimSides::TrimAll, true>(pattern);
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    Impl& trim_left_with_spaces(T&& pattern) {
        return makeTrim<TrimSides::TrimLeft, true>(pattern);
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
        requires is_const_pattern<N>
    Impl& trim_right_with_wpaces(T&& pattern) {
        return makeTrim<TrimSides::TrimRight, true>(pattern);
    }

    Impl& trim(str_piece pattern) {
        return pattern.length() ? makeTrim<TrimSides::TrimAll, false>(pattern) : d();
    }

    Impl& trim_left(str_piece pattern) {
        return pattern.length() ? makeTrim<TrimSides::TrimLeft, false>(pattern) : d();
    }

    Impl& trim_right(str_piece pattern) {
        return pattern.length() ? makeTrim<TrimSides::TrimRight, false>(pattern) : d();
    }

    Impl& trim_with_spaces(str_piece pattern) {
        return makeTrim<TrimSides::TrimAll, true>(pattern);
    }

    Impl& trim_left_with_spaces(str_piece pattern) {
        return makeTrim<TrimSides::TrimLeft, true>(pattern);
    }

    Impl& trim_right_with_spaces(str_piece pattern) {
        return makeTrim<TrimSides::TrimRight, true>(pattern);
    }

    Impl& upper_only_ascii() {
        K* ptr = str();
        for (size_t i = 0, l = _len(); i < l; i++, ptr++) {
            K s = *ptr;
            if (isAsciiLower(s))
                *ptr = s & ~0x20;
        }
        return d();
    }

    Impl& lower_only_ascii() {
        K* ptr = str();
        for (size_t i = 0, l = _len(); i < l; i++, ptr++) {
            K s = *ptr;
            if (isAsciiUpper(s))
                *ptr = s | 0x20;
        }
        return d();
    }

    Impl& upper() {
        // Для utf-8 такая операция может изменить длину строки, поэтому для них делаем разные специализации
        // For utf-8, such an operation can change the length of the string, so we make different specializations for them
        return CaseTraits<K>::upper(d());
    }

    Impl& lower() {
        // Для utf-8 такая операция может изменить длину строки, поэтому для них делаем разные специализации
        // For utf-8, such an operation can change the length of the string, so we make different specializations for them
        return CaseTraits<K>::lower(d());
    }
 
private:
    template<typename T>
    Impl& changeImpl(size_t from, size_t len, T expr) {
        size_t myLen = _len();
        if (from > myLen) {
            from = myLen;
        }
        if (from + len > myLen) {
            len = myLen - from;
        }
        K* buffer = str();
        size_t otherLen = expr.length();
        if (len == otherLen) {
            expr.place(buffer + from);
        } else {
            size_t tailLen = myLen - from - len;
            if (len > otherLen) {
                expr.place(buffer + from);
                traits::move(buffer + from + otherLen, buffer + from + len, tailLen);
                d().set_size(myLen - (len - otherLen));
            } else {
                buffer = d().set_size(myLen + otherLen - len);
                traits::move(buffer + from + otherLen, buffer + from + len, tailLen);
                expr.place(buffer + from);
            }
        }
        return d();
    }
 
    template<typename T>
    Impl& appendImpl(T expr) {
        if (size_t len = expr.length(); len) {
            size_t size = _len();
            expr.place(d().set_size(size + len) + size);
        }
        return d();
    }
 
    template<typename T>
    Impl& appendFromImpl(size_t pos, T expr) {
        if (pos > _len())
            pos = _len();
        if (size_t len = expr.length())
            expr.place(d().set_size(pos + len) + pos);
        else
            d().set_size(pos);
        return d();
    }
 
public:
    inline static constexpr bool is_str_mutable = true;
    Impl& append(str_piece other) {
        return appendImpl<str_piece>(other);
    }

    template<StrExprForType<K> A>
    Impl& append(const A& expr) {
        return appendImpl<const A&>(expr);
    }

    Impl& operator+=(str_piece other) {
        return appendImpl<str_piece>(other);
    }

    template<StrExprForType<K> A>
    Impl& operator+=(const A& expr) {
        return appendImpl<const A&>(expr);
    }

    Impl& append_in(size_t pos, str_piece other) {
        return appendFromImpl<str_piece>(pos, other);
    }

    template<StrExprForType<K> A>
    Impl& append_in(size_t pos, const A& expr) {
        return appendFromImpl<const A&>(pos, expr);
    }

    Impl& change(size_t from, size_t len, str_piece other) {
        return changeImpl<str_piece>(from, len, other);
    }

    template<StrExprForType<K> A>
    Impl& change(size_t from, size_t len, const A& expr) {
        return changeImpl<const A&>(from, len, expr);
    }

    Impl& insert(size_t to, str_piece other) {
        return changeImpl<str_piece>(to, 0, other);
    }

    template<StrExprForType<K> A>
    Impl& insert(size_t to, const A& expr) {
        return changeImpl<const A&>(to, 0, expr);
    }

    Impl& remove(size_t from, size_t len) {
        return changeImpl<const empty_expr<K>&>(from, len, {});
    }

    Impl& prepend(str_piece other) {
        return changeImpl<str_piece>(0, 0, other);
    }

    template<StrExprForType<K> A>
    Impl& prepend(const A& expr) {
        return changeImpl<const A&>(0, 0, expr);
    }

    Impl& replace(str_piece pattern, str_piece repl, size_t offset = 0, size_t maxCount = 0) {
        offset = d().find(pattern, offset);
        if (offset == str::npos) {
            return d();
        }
        if (!maxCount)
            maxCount--;
        size_t replLength = repl.length(), patternLength = pattern.length();
 
        if (patternLength == replLength) {
            // Заменяем inplace на подстроку такой же длины
            // Replace inplace with a substring of the same length
            K* ptr = str();
            while (maxCount--) {
                traits::copy(ptr + offset, repl.symbols(), replLength);
                offset = d().find(pattern, offset + replLength);// replLength == patternLength
                if (offset == str::npos)
                    break;
            }
        } else if (patternLength > replLength) {
            // Заменяем на более короткий кусок, длина текста уменьшится, идём слева направо
            // Replace with a shorter piece, the length of the text will decrease, go from left to right
            K* ptr = str();
            traits::copy(ptr + offset, repl.symbols(), replLength);
            size_t posWrite = offset + replLength;
            offset += patternLength;
 
            while (--maxCount) {
                size_t idx = d().find(pattern, offset);
                if (idx == str::npos)
                    break;
                size_t lenOfPiece = idx - offset;
                traits::move(ptr + posWrite, ptr + offset, lenOfPiece);
                posWrite += lenOfPiece;
                traits::copy(ptr + posWrite, repl.symbols(), replLength);
                posWrite += replLength;
                offset = idx + patternLength;
            }
            size_t tailLen = _len() - offset;
            traits::move(ptr + posWrite, ptr + offset, tailLen);
            d().set_size(posWrite + tailLen);
        } else {
            struct replace_grow_helper {
                replace_grow_helper(my_type& src, str_piece p, str_piece r, size_t mc, size_t d)
                    : source(src), pattern(p), repl(r), maxCount(mc), delta(d) {}
                my_type& source;
                const str_piece pattern;
                const str_piece repl;
                size_t maxCount;
                const size_t delta;
                size_t all_delta{};
                K* reserve_for_copy{};
                size_t end_of_piece{};
                size_t total_length{};
 
                void replace(size_t offset) {
                    size_t found[16] = {offset};
                    maxCount--;
                    offset += pattern.length();
                    all_delta += delta;
                    size_t idx = 1;
                    for (; idx < std::size(found) && maxCount > 0; idx++, maxCount--) {
                        found[idx] = source.find(pattern, offset);
                        if (found[idx] == str::npos) {
                            break;
                        }
                        offset = found[idx] + pattern.length();
                        all_delta += delta;
                    }
                    if (idx == std::size(found) && maxCount > 0 && (offset = source.find(pattern, offset)) != str::npos) {
                        replace(offset); // здесь произойдут замены в оставшемся хвосте | replacements will be made here in the remaining tail
                    }
                    // Теперь делаем свои замены
                    // Now we make our replacements
                    if (!reserve_for_copy) {
                        // Только начинаем
                        // Just getting started
                        end_of_piece = source.length();
                        total_length = end_of_piece + all_delta;
                        reserve_for_copy = source.alloc_for_copy(total_length);
                    }
                    K* dst_start = reserve_for_copy;
                    const K* src_start = source.symbols();
                    while(idx-- > 0) {
                        size_t pos = found[idx] + pattern.length();
                        size_t lenOfPiece = end_of_piece - pos;
                        ch_traits<K>::move(dst_start + pos + all_delta, src_start + pos, lenOfPiece);
                        ch_traits<K>::copy(dst_start + pos + all_delta - repl.length(), repl.symbols(), repl.length());
                        all_delta -= delta;
                        end_of_piece = found[idx];
                    }
                    if (!all_delta && reserve_for_copy != src_start) {
                        ch_traits<K>::copy(dst_start, src_start, found[0]);
                    }
                }
            } helper(d(), pattern, repl, maxCount, repl.length() - pattern.length());
            helper.replace(offset);
            d().set_from_copy(helper.reserve_for_copy, helper.total_length);
        }
        return d();
    }

    template<StrType<K> From>
    Impl& replace_from(const From& f, str_piece pattern, str_piece repl, size_t offset = 0, size_t maxCount = 0) {
        if (pattern.length() >= repl.length()) {
            K* dst = d().reserve_no_preserve(f.length());
            const K* src = f.symbols();
            size_t delta = 0;
            if (maxCount == 0) {
                maxCount--;
            }
            size_t src_length = f.length(), start = 0;
            while (maxCount--) {
                offset = f.find(pattern, offset);
                if (offset == str::npos) {
                    break;
                }
                size_t piece_len = offset - start;
                if (piece_len) {
                    ch_traits<K>::copy(dst, src + start, piece_len);
                    dst += piece_len;
                }
                if (repl.length()) {
                    ch_traits<K>::copy(dst, repl.symbols(), repl.length());
                    dst += repl.length();
                }
                delta += pattern.length() - repl.length();
                offset += pattern.length();
                start = offset;
            }
            if (start < src_length) {
                ch_traits<K>::copy(dst, src + start, src_length - start);
            }
            d().set_size(src_length - delta);
        } else {
            d() = f;
            replace(pattern, repl, offset, maxCount);
        }
        return d();
    }

    template<typename Op>
    Impl& fill(size_t from, const Op& fillFunction) {
        size_t size = _len();
        if (from > size)
            from = size;
        size_t capacity = d().capacity();
        K* ptr = str();
        capacity -= from;
        for (;;) {
            size_t needSize = static_cast<size_t>(fillFunction(ptr + from, capacity));
            if (capacity >= needSize) {
                d().set_size(from + needSize);
                break;
            }
            ptr = from == 0 ? d().reserve_no_preserve(needSize) : d().set_size(from + needSize);
            capacity = d().capacity() - from;
        }
        return d();
    }

    template<typename Op>
        requires std::is_invocable_v<Op, K*, size_t>
    Impl& operator<<(const Op& fillFunction) {
        return fill(0, fillFunction);
    }

    template<typename Op>
        requires std::is_invocable_v<Op, K*, size_t>
    Impl& operator<<=(const Op& fillFunction) {
        return fill(_len(), fillFunction);
    }

    template<typename Op>
        requires std::is_invocable_v<Op, my_type&>
    Impl& operator<<(const Op& fillFunction) {
        fillFunction(d());
        return d();
    }

    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& printf_from(size_t from, const K* format, T&&... args) {
        size_t size = _len();
        if (from > size)
            from = size;
        size_t capacity = d().capacity();
        K* ptr = str();
        capacity -= from;
 
        int result = 0;
        // Тут грязный хак для u8s и wide_char. u8s версия snprintf сразу возвращает размер нужного буфера, если он мал
        // а swprintf - возвращает -1. Под windows оба варианта xxx_p - тоже возвращают -1.
        // Поэтому для них надо тупо увеличивать буфер наугад, пока не подойдет
        // Here's a dirty hack for u8s and wide_char. u8s version of snprintf immediately returns the size of the required buffer if it is small
        // and swprintf returns -1. Under Windows, both options xxx_p also return -1.
        // Therefore, for them you need to stupidly increase the buffer at random until it fits
        if constexpr (sizeof(K) == 1 && !isWindowsOs) {
            result = printf_selector::snprintf(ptr + from, capacity + 1, format, std::forward<T>(args)...);
            if (result > (int)capacity) {
                ptr = from == 0 ? d().reserve_no_preserve(result) : d().set_size(from + result);
                result = printf_selector::snprintf(ptr + from, result + 1, format, std::forward<T>(args)...);
            }
        } else {
            for (;;) {
                result = printf_selector::snprintf(ptr + from, capacity + 1, format, std::forward<T>(args)...);
                if (result < 0) {
                    // Не хватило буфера или ошибка конвертации.
                    // Попробуем увеличить буфер в два раза
                    // Not enough buffer or conversion error.
                    // Let's try to double the buffer
                    capacity *= 2;
                    ptr = from == 0 ? d().reserve_no_preserve(capacity) : d().set_size(from + capacity);
                } else
                    break;
            }
        }
        if (result < 0)
            d().set_size(static_cast<size_t>(traits::length(_str())));
        else
            d().set_size(from + result);
        return d();
    }

    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& printf(const K* format, T&&... args) {
        return printf_from(0, format, std::forward<T>(args)...);
    }

    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& append_printf(const K* format, T&&... args) {
        return printf_from(_len(), format, std::forward<T>(args)...);
    }
 
    struct writer {
        my_type* store;
        K* ptr;
        const K* end;
        size_t max_write;
        size_t writed = 0;
        inline static K pad;
        K& operator*() const {
            return *ptr;
        }
        writer& operator++() {
            if (writed < max_write) {
                ++ptr;
                if (ptr == end) {
                    size_t l = ptr - store->begin();
                    store->set_size(l);
                    ptr = store->set_size(l + std::min(l / 2, size_t(8192))) + l;
                    end = store->end();
                }
            } else {
                ptr = &pad;
            }
            return *this;
        }
        writer operator++(int) {
            auto ret = *this;
            operator++();
            return ret;
        }
 
        writer(my_type& s, K* p, K* e, size_t ml) : store(&s), ptr(p), end(e), max_write(ml) {}
        writer() = default;
        writer(const writer&) = delete;
        writer& operator=(const writer&) noexcept = delete;
        writer(writer&&) noexcept = default;
        writer& operator=(writer&&) noexcept = default;
        using difference_type = int;
    };
    using fmt_type = to_std_char_t<K>;
    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& format_from(size_t from, const FmtString<fmt_type, T...>& format, T&&... args) {
        size_t size = _len();
        if (from > size)
            from = size;
        size_t capacity = d().capacity();
        K* ptr = str();
 
        auto result = std::format_to(writer{d(), ptr + from, ptr + capacity, size_t(-1)},
            std::forward<decltype(format)>(format), std::forward<T>(args)...);
        d().set_size(result.ptr - _str());
        return d();
    }

    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& vformat_from(size_t from, size_t max_write, str_piece format, T&&... args) {
        size_t size = _len();
        if (from > size)
            from = size;
        size_t capacity = d().capacity();
        K* ptr = str();
 
        if constexpr (std::is_same_v<K, u8s>) {
            auto result = std::vformat_to(
                writer{d(), ptr + from, ptr + capacity, max_write},
                std::basic_string_view<K>{format.symbols(), format.length()},
                std::make_format_args(args...));
            d().set_size(result.ptr - _str());
        } else {
            auto result = std::vformat_to(
                writer{d(), to_one_of_std_char(ptr + from), ptr + capacity, max_write},
                std::basic_string_view<wchar_t>{to_one_of_std_char(format.symbols()), format.length()},
                std::make_wformat_args(std::forward<T>(args)...));
            d().set_size(result.ptr - _str());
        }
        return d();
    }

    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& format(const FmtString<fmt_type, T...>& pattern, T&&... args) {
        return format_from(0, pattern, std::forward<T>(args)...);
    }

    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& append_formatted(const FmtString<fmt_type, T...>& format, T&&... args) {
        return format_from(_len(), format, std::forward<T>(args)...);
    }

    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& vformat(str_piece format, T&&... args) {
        return vformat_from(0, -1, format, std::forward<T>(args)...);
    }

    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& append_vformatted(str_piece format, T&&... args) {
        return vformat_from(_len(), -1, format, std::forward<T>(args)...);
    }

    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& vformat_n(size_t max_write, str_piece format, T&&... args) {
        return vformat_from(0, max_write, format, std::forward<T>(args)...);
    }

    template<typename... T> requires (is_one_of_std_char_v<K>)
    Impl& append_vformatted_n(size_t max_write, str_piece format, T&&... args) {
        return vformat_from(_len(), max_write, format, std::forward<T>(args)...);
    }

    template<typename Op, typename... Args>
    Impl& with(const Op& fillFunction, Args&&... args) {
        fillFunction(d(), std::forward<Args>(args)...);
        return d();
    }
};
 
template<typename K>
struct SharedStringData {
    std::atomic_size_t ref_; // Счетчик ссылок | Reference count
    inline static constexpr size_t mask = (size_t(-1)) >> 1, check = ~mask;
 
    SharedStringData() {
        ref_ = 1;
    }
    SharedStringData(size_t capacity) {
        ref_ = 1 | check;
        reinterpret_cast<size_t*>(this)[-1] = (capacity + 1) * sizeof(K) + sizeof(*this) + sizeof(size_t);
    }
    K* str() const {
        return (K*)(this + 1);
    }
    void incr() {
        ref_.fetch_add(1, std::memory_order_relaxed);
    }
    void decr(AllocatableNoSized auto& allocator) {
        size_t val = ref_.fetch_sub(1, std::memory_order_relaxed);
        if (val == 1) {
            allocator.deallocate(this);
        }
    }
    void decr(AllocatableSized auto& allocator, size_t len) {
        size_t val = ref_.fetch_sub(1, std::memory_order_relaxed);
        if ((val & mask) == 1) {
            if (val & check) {
                // Это блок от перемещённой lstring, перед ним записан размер выделенной памяти.
                // This is a block from the moved lstring, the size of the allocated memory is written in front of it.
                size_t* ptr = reinterpret_cast<size_t*>(this);
                ptr--;
                allocator.deallocate(ptr, *ptr);
            } else {
                allocator.deallocate(this, (len + 1) * sizeof(K) + sizeof(*this));
            }
        }
    }
    static SharedStringData* create(size_t l, Allocatable auto& allocator) {
        size_t size = sizeof(SharedStringData) + (l + 1) * sizeof(K);
        return new (allocator.allocate(size)) SharedStringData();
    }
    static SharedStringData* from_str(const K* p) {
        return (SharedStringData*)p - 1;
    }
    K* place(K* p, size_t len) {
        ch_traits<K>::copy(p, str(), len);
        return p + len;
    }
};
 
// Дефолтный аллокатор для строк, может работать статически
// Default allocator for strings, can work statically
class string_common_allocator {
public:
    void* allocate(size_t bytes) {
        return ::operator new(bytes);
    }
    void deallocate(void* address) noexcept {
        ::operator delete(address);
    }
};
 
string_common_allocator default_string_allocator_selector(...);
// Если вы хотите задать свой дефолтный аллокатор для строк, перед включение sstring.h
// объявите функцию
// ваш_тип_аллокатора default_string_allocator_selector(int);
// If you want to set your default allocator for strings, before including sstring.h
// declare a function
// your_allocator_type default_string_allocator_selector(int);
using allocator_string = decltype(default_string_allocator_selector(int(0)));
 
template<typename K, Allocatable Allocator>
class sstring;
 
/*
* Так как у класса несколько базовых классов, MSVC не применяет автоматом empty base optimization,
* и без явного указания - вставит в начало класса пустые байты, сдвинув поле size на 4-8 байта.
* Укажем ему явно.
* Since a class has several base classes, MSVC does not automatically apply empty base optimization,
* and without explicit indication - will insert empty bytes at the beginning of the class, shifting the size field by 4-8 bytes.
* Let's tell him explicitly.
*/

template<typename K, size_t N, bool forShared = false, Allocatable Allocator = allocator_string>
class decl_empty_bases lstring :
    public str_algs<K, simple_str<K>, lstring<K, N, forShared, Allocator>, true>,
    public str_mutable<K, lstring<K, N, forShared, Allocator>>,
    public str_storable<K, lstring<K, N, forShared, Allocator>, Allocator>,
    public null_terminated<K, lstring<K, N, forShared, Allocator>>,
    public from_utf_convertible<K, lstring<K, N, forShared, Allocator>> {
public:
    using symb_type = K;
    using my_type = lstring<K, N, forShared, Allocator>;
    using allocator_t = Allocator;
 
    enum : size_t {
        LocalCapacity = N | (sizeof(void*) / sizeof(K) - 1),
    };
 
protected:
    enum : size_t {
        extra = forShared ? sizeof(SharedStringData<K>) + (AllocatableSized<Allocator> ? sizeof(size_t) : 0) : 0,
    };
 
    using base_algs = str_algs<K, simple_str<K>, my_type, true>;
    using base_storable = str_storable<K, my_type, Allocator>;
    using base_mutable = str_mutable<K, my_type>;
    using base_utf = from_utf_convertible<K, my_type>;
    using traits = ch_traits<K>;
    using s_str = base_storable::s_str;
 
    friend base_storable;
    friend base_mutable;
    friend base_utf;
    friend class sstring<K, Allocator>;
 
    K* data_;
    size_t size_;
 
    union {
        size_t capacity_;
        K local_[LocalCapacity + 1];
    };
 
    constexpr void create_empty() {
        data_ = local_;
        size_ = 0;
        local_[0] = 0;
    }
    constexpr static size_t calc_capacity(size_t s) {
        const int al = alignof(std::max_align_t) < 16 ? 16 : alignof(std::max_align_t);
        size_t real_need = (s + 1) * sizeof(K) + extra;
        size_t aligned_alloced = (real_need + al - 1) / al * al;
        return (aligned_alloced - extra) / sizeof(K) - 1;
    }
 
    constexpr K* init(size_t s) {
        size_t need_cap = s;
        if (need_cap > LocalCapacity) {
            need_cap = calc_capacity(s);
            data_ = alloc_place(need_cap);
            capacity_ = need_cap;
        } else {
            data_ = local_;
        }
        size_ = s;
        return str();
    }
    // Методы для себя | Methods for yourself
    constexpr bool is_alloced() const noexcept {
        return data_ != local_;
    }
 
    constexpr void dealloc() {
        if (is_alloced()) {
            if constexpr (AllocatableNoSized<Allocator>) {
                base_storable::allocator().deallocate(to_real_address(data_));
            } else {
                base_storable::allocator().deallocate(to_real_address(data_), (capacity_ + 1) * sizeof(K) + extra);
            }
            data_ = local_;
        }
    }
 
    constexpr static K* to_real_address(void* ptr) {
        return reinterpret_cast<K*>(reinterpret_cast<u8s*>(ptr) - extra);
    }
    constexpr static K* from_real_address(void* ptr) {
        return reinterpret_cast<K*>(reinterpret_cast<u8s*>(ptr) + extra);
    }
 
    constexpr K* alloc_place(size_t newSize) {
        return from_real_address(base_storable::allocator().allocate((newSize + 1) * sizeof(K) + extra));
    }
    // Вызывается при replace, когда меняют на более длинную замену
    // Called on replace when changing to a longer replacement
    constexpr K* alloc_for_copy(size_t newSize) {
        if (capacity() >= newSize) {
            // Замена войдёт в текущий буфер
            // Replacement will go into the current buffer
            return data_;
        }
        return alloc_place(calc_capacity(newSize));
    }
    // Вызывается после replace, когда меняли на более длинную замену, могли скопировать в новый буфер
    // Called after replace, when they changed to a longer replacement, they could have copied it to a new buffer
    constexpr void set_from_copy(K* ptr, size_t newSize) {
        if (ptr != data_) {
            // Да, копировали в новый буфер
            // Yes, copied to a new buffer
            dealloc();
            data_ = ptr;
            capacity_ = calc_capacity(newSize);
        }
        size_ = newSize;
        data_[newSize] = 0;
    }
    constexpr void copy_from_another(K* buf, const K* src, size_t size) {
        // Реальный размер буфера всегда кратен sizeof(void*), поэтому копируя по sizeof(void*) байтов, мы не выйдем за пределы буфера
        // The actual buffer size is always a multiple of sizeof(void*), so by copying sizeof(void*) bytes at a time, we won't go beyond the buffer's limits.
        size_t need_copy_bytes = (size + 1) * sizeof(K);
        size_t cnt = (need_copy_bytes + sizeof(void*) - 1) / sizeof(void*) * sizeof(void*);
        traits::copy(buf, src, cnt / sizeof(K));
    }
public:
    template<typename... Args>
        requires (std::is_constructible_v<allocator_t, Args...> && sizeof...(Args) > 0)
    constexpr lstring(Args&&... args) noexcept(std::is_nothrow_constructible_v<allocator_t, Args...>)
        : base_storable(std::forward<Args>(args)...) {
        create_empty();
    }

    template<typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    constexpr lstring(s_str other, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        base_storable::init_from_str_other(other);
    }

    template<typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    constexpr lstring(size_t repeat, s_str pattern, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        base_storable::init_str_repeat(repeat, pattern);
    }

    template<typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    constexpr lstring(size_t count, K pad, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        base_storable::init_symb_repeat(count, pad);
    }

    template<typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    constexpr lstring(const StrExprForType<K> auto& expr, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        base_storable::init_str_expr(expr);
    }

    template<StrType<K> From, typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    constexpr lstring(const From& f, s_str pattern, s_str repl, size_t offset = 0, size_t maxCount = 0, Args&&... args)
        : base_storable(std::forward<Args>(args)...) {
        base_storable::init_replaced(f, pattern, repl, offset, maxCount);
    }
 
    constexpr lstring() {
        create_empty();
    }
 
    constexpr ~lstring() {
        dealloc();
    }

    constexpr lstring(const my_type& other) : base_storable(other.allocator()) {
        struct copy{uint64_t p[2];};
        constexpr size_t short_str = sizeof(copy) / sizeof(K);
        if constexpr (LocalCapacity >= short_str - 1) {
            if (other.size_ < short_str) {
                data_ = local_;
                size_ = other.size_;
                *(copy*)local_ = *(const copy*)other.local_;
                return;
            }
        }
        if (size_t size = other.size_) {
            copy_from_another(init(size), other.symbols(), size);
        } else {
            create_empty();
        }
    }

    template<typename... Args>
        requires(sizeof...(Args) > 0 && std::is_convertible_v<allocator_t, Args...>)
    constexpr lstring(const my_type& other, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        if (other.size_) {
            copy_from_another(init(other.size_), other.symbols(), other.size_);
        } else {
            create_empty();
        }
    }

    template<typename T, size_t I = const_lit_for<K, T>::Count, typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    constexpr lstring(T&& value, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        if constexpr (I > 1) {
            K* ptr = init(I - 1);
            traits::copy(ptr, (const K*)value, I - 1);
            ptr[I - 1] = K{};
        } else {
            create_empty();
        }
    }

    constexpr lstring(my_type&& other) noexcept : base_storable(std::move(other.allocator())) {
        if (other.size_) {
            size_ = other.size_;
            if (other.is_alloced()) {
                data_ = other.data_;
                other.data_ = other.local_;
                capacity_ = other.capacity_;
            } else {
                data_ = local_;
                copy_from_another(data_, other.local_, size_);
            }
            other.size_ = 0;
            other.local_[0] = 0;
        } else {
            create_empty();
        }
    }

    template<typename Op, typename... Args>
        requires(std::is_constructible_v<Allocator, Args...> && (std::is_invocable_v<Op, my_type&> || std::is_invocable_v<Op, K*, size_t>))
    lstring(const Op& op, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        create_empty();
        this->operator<<(op);
    }
    template<typename O>
        requires(!std::is_same_v<O, K>)
    lstring(simple_str<O> init) {
        this->init_from_utf_convertible(init);
    }
 
    template<typename O, typename I, bool M>
        requires(!std::is_same_v<O, K>)
    lstring(const str_algs<O, simple_str<O>, I, M>& init) {
        this->init_from_utf_convertible(init.to_str());
    }
 
    // copy and swap для присваиваний здесь не очень применимо, так как для строк с большим локальным буфером лишняя копия даже перемещением будет дорого стоить
    // Поэтому реализуем копирующее и перемещающее присваивание отдельно
    // copy and swap for assignments is not very applicable here, since for strings with a large local buffer, an extra copy, even by moving, will be expensive
    // Therefore, we implement the copy and move assignment separately

    my_type& operator=(const my_type& other) {
        // Так как между этими объектами не может быть косвенной зависимости, достаточно проверить только на равенство
        // Since there cannot be an indirect dependency between these objects, it is enough to check only for equality
        if (&other != this) {
            traits::copy(reserve_no_preserve(other.size_), other.data_, other.size_ + 1);
            size_ = other.size_;
        }
        return *this;
    }

    my_type& operator=(my_type&& other) noexcept {
        // Так как между этими объектами не может быть косвенной зависимости, достаточно проверить только на равенство
        // Since there cannot be an indirect dependency between these objects, it is enough to check only for equality
        if (&other != this) {
            dealloc();
            if (other.is_alloced()) {
                data_ = other.data_;
                capacity_ = other.capacity_;
            } else {
                traits::copy(data_, other.local_, other.size_ + 1);
            }
            base_storable::allocator() = std::move(other.allocator());
            size_ = other.size_;
            other.create_empty();
        }
        return *this;
    }
 
    my_type& assign(const K* other, size_t len) {
        if (len) {
            bool isIntersect = other >= data_ && other + len <= data_ + size_;
            if (isIntersect) {
                // Особый случай, нам пытаются присвоить кусок нашей же строки.
                // Просто переместим текст в буфере, и установим новый размер
                // A special case, they are trying to assign us a piece of our own string.
                // Just move the text in the buffer and set a new size
                if (other > data_) {
                    traits::move(data_, other, len);
                }
            } else {
                traits::copy(reserve_no_preserve(len), other, len);
            }
        }
        size_ = len;
        data_[size_] = 0;
        return *this;
    }
    my_type& operator=(simple_str<K> other) {
        return assign(other.str, other.len);
    }

    template<typename T, size_t S = const_lit_for<K, T>::Count>
    my_type& operator=(T&& other) {
        return assign((const K*)other, S - 1);
    }

    my_type& operator=(const StrExprForType<K> auto& expr) {
        size_t newLen = expr.length();
        if (newLen) {
            expr.place(reserve_no_preserve(newLen));
        }
        size_ = newLen;
        data_[size_] = 0;
        return *this;
    }

    constexpr size_t length() const noexcept {
        return size_;
    }

    constexpr const K* symbols() const noexcept {
        return data_;
    }

    constexpr K* str() noexcept {
        return data_;
    }

    constexpr bool is_empty() const noexcept {
        return size_ == 0;
    }

    constexpr bool empty() const noexcept {
        return size_ == 0;
    }

    constexpr size_t capacity() const noexcept {
        return is_alloced() ? capacity_ : LocalCapacity;
    }

    constexpr K* reserve_no_preserve(size_t newSize) {
        if (newSize > capacity()) {
            newSize = calc_capacity(newSize);
            K* newData = alloc_place(newSize);
            dealloc();
            data_ = newData;
            capacity_ = newSize;
        }
        return data_;
    }

    constexpr K* reserve(size_t newSize) {
        if (newSize > capacity()) {
            newSize = calc_capacity(newSize);
            K* newData = alloc_place(newSize);
            traits::copy(newData, data_, size_);
            dealloc();
            data_ = newData;
            capacity_ = newSize;
        }
        return data_;
    }

    constexpr K* set_size(size_t newSize) {
        size_t cap = capacity();
        if (newSize > cap) {
            size_t needPlace = newSize;
            if (needPlace < (cap + 1) * 2) {
                needPlace = (cap + 1) * 2 - 1;
            }
            reserve(needPlace);
        }
        size_ = newSize;
        data_[newSize] = 0;
        return data_;
    }

    constexpr bool is_local() const noexcept {
        return !is_alloced();
    }

    constexpr void define_size() {
        size_t cap = capacity();
        for (size_t i = 0; i < cap; i++) {
            if (data_[i] == 0) {
                size_ = i;
                return;
            }
        }
        size_ = cap;
        data_[size_] = 0;
    }

    constexpr void shrink_to_fit() {
        size_t need_capacity = calc_capacity(size_);
        if (is_alloced() && capacity_ > need_capacity) {
            K* newData = size_ <= LocalCapacity ? local_ : alloc_place(need_capacity);
            traits::copy(newData, data_, size_ + 1);
            base_storable::allocator().deallocate(to_real_address(data_));
            data_ = newData;
 
            if (size_ > LocalCapacity) {
                capacity_ = need_capacity;
            }
        }
    }

    constexpr void clear() {
        set_size(0);
    }

    constexpr void reset() {
        dealloc();
        local_[0] = 0;
        size_ = 0;
    }
};
 
template<size_t N = 15>
using lstringa = lstring<u8s, N>;
template<size_t N = 15>
using lstringb = lstring<ubs, N>;
template<size_t N = 15>
using lstringw = lstring<wchar_t, N>;
template<size_t N = 15>
using lstringu = lstring<u16s, N>;
template<size_t N = 15>
using lstringuu = lstring<u32s, N>;
 
template<size_t N = 15>
using lstringsa = lstring<u8s, N, true>;
template<size_t N = 15>
using lstringsb = lstring<ubs, N, true>;
template<size_t N = 15>
using lstringsw = lstring<wchar_t, N, true>;
template<size_t N = 15>
using lstringsu = lstring<u16s, N, true>;
template<size_t N = 15>
using lstringsuu = lstring<u32s, N, true>;
 
 
template<typename T, typename K = typename const_lit<T>::symb_type>
auto getLiteralType(T&&) {
    return K{};
};
 
template<size_t Arch, size_t L>
inline constexpr const size_t _local_count = 0;
 
template<>
inline constexpr const size_t _local_count<8, 1> = 23;
template<>
inline constexpr const size_t _local_count<8, 2> = 15;
template<>
inline constexpr const size_t _local_count<8, 4> = 7;
template<>
inline constexpr const size_t _local_count<4, 1> = 15;
template<>
inline constexpr const size_t _local_count<4, 2> = 11;
template<>
inline constexpr const size_t _local_count<4, 4> = 5;
 
template<typename T>
constexpr const size_t local_count = _local_count<sizeof(size_t), sizeof(T)>;

template<typename K, Allocatable Allocator = allocator_string>
class decl_empty_bases sstring :
    public str_algs<K, simple_str<K>, sstring<K, Allocator>, false>,
    public str_storable<K, sstring<K, Allocator>, Allocator>,
    public null_terminated<K, sstring<K, Allocator>>,
    public from_utf_convertible<K, sstring<K, Allocator>> {
public:
    using symb_type = K;
    using uns_type = std::make_unsigned_t<K>;
    using my_type = sstring<K, Allocator>;
    using allocator_t = Allocator;
 
    enum { LocalCount = local_count<K> };
 
protected:
    using base_algs = str_algs<K, simple_str<K>, my_type, false>;
    using base_storable = str_storable<K, my_type, Allocator>;
    using base_utf = from_utf_convertible<K, my_type>;
    using traits = ch_traits<K>;
    using uni = unicode_traits<K>;
    using s_str = base_storable::s_str;
 
    friend base_storable;
    friend base_utf;
 
    enum Types { Local, Constant, Shared };
 
    union {
        // Когда у нас короткая строка, она лежит в самом объекте, а в localRemain
        // пишется, сколько символов ещё можно вписать. Когда строка занимает всё
        // возможное место, то localRemain становится 0, type в этом случае тоже 0,
        // и в итоге после символов строки получается 0, как и надо!
        // When we have a short string, it lies in the object itself, and in localRemain
        // writes how many more characters can be entered. When a string takes up everything
        // possible location, then localRemain becomes 0, type in this case is also 0,
        // and as a result, after the characters of the string we get 0, as it should!
        struct {
            K buf_[LocalCount]; // Локальный буфер строки | Local string buffer
            uns_type localRemain_ : sizeof(uns_type) * CHAR_BIT - 2;
            uns_type type_ : 2;
        };
        struct {
            union {
                // Указатель на конcтантную строку | Pointer to a constant string
                const K* cstr_;
                // Указатель на строку, перед которой лежит SharedStringData
                // Pointer to the string preceded by SharedStringData
                const K* sstr_;
            };
            size_t bigLen_; // Длина не локальной строки | Non-local string length
        };
    };
 
    constexpr void create_empty() {
        type_ = Local;
        localRemain_ = LocalCount;
        buf_[0] = 0;
    }
    constexpr K* init(size_t s) {
        if (s > LocalCount) {
            type_ = Shared;
            localRemain_ = 0;
            bigLen_ = s;
            sstr_ = SharedStringData<K>::create(s, base_storable::allocator())->str();
            return (K*)sstr_;
        } else {
            type_ = Local;
            localRemain_ = LocalCount - s;
            return buf_;
        }
    }
 
    void dealloc() {
        if (type_ == Shared) {
            if constexpr (AllocatableNoSized<Allocator>) {
                SharedStringData<K>::from_str(sstr_)->decr(base_storable::allocator());
            } else {
                SharedStringData<K>::from_str(sstr_)->decr(base_storable::allocator(), bigLen_);
            }
        }
    }
public:
 
    sstring() {
        create_empty();
    }

    template<typename... Args>
        requires (std::is_constructible_v<allocator_t, Args...> && sizeof...(Args) > 0)
    sstring(Args&&... args) noexcept(std::is_nothrow_constructible_v<allocator_t, Args...>)
        : base_storable(std::forward<Args>(args)...) {
        create_empty();
    }

    template<typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    sstring(s_str other, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        base_storable::init_from_str_other(other);
    }

    template<typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    sstring(size_t repeat, s_str pattern, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        base_storable::init_str_repeat(repeat, pattern);
    }

    template<typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    sstring(size_t count, K pad, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        base_storable::init_symb_repeat(count, pad);
    }

    template<typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    constexpr sstring(const StrExprForType<K> auto& expr, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        base_storable::init_str_expr(expr);
    }

    template<StrType<K> From, typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    sstring(const From& f, s_str pattern, s_str repl, size_t offset = 0, size_t maxCount = 0, Args&&... args)
        : base_storable(std::forward<Args>(args)...) {
        base_storable::init_replaced(f, pattern, repl, offset, maxCount);
    }
 
    static const sstring<K> empty_str;
    constexpr ~sstring() {
        dealloc();
    }

    constexpr sstring(const my_type& other) noexcept : base_storable(other.allocator()) {
        memcpy(buf_, other.buf_, sizeof(buf_) + sizeof(K));
        if (type_ == Shared)
            SharedStringData<K>::from_str(sstr_)->incr();
    }

    constexpr sstring(my_type&& other) noexcept : base_storable(std::move(other.allocator())) {
        memcpy(buf_, other.buf_, sizeof(buf_) + sizeof(K));
        other.create_empty();
    }

    template<size_t N>
    constexpr sstring(lstring<K, N, true, Allocator>&& src) : base_storable(std::move(src.allocator())) {
        size_t size = src.length();
        if (size) {
            if (src.is_alloced()) {
                // Там динамический буфер, выделенный с запасом для SharedStringData и size_t.
                // There is a dynamic buffer allocated with a reserve for SharedStringData and size_t.
                K* str = src.str();
                if (size > LocalCount) {
                    // Просто присвоим его себе.
                    // Let's just assign it to ourselves.
                    sstr_ = str;
                    bigLen_ = size;
                    type_ = Shared;
                    localRemain_ = 0;
                    if constexpr (AllocatableNoSized<Allocator>) {
                        new (SharedStringData<K>::from_str(str)) SharedStringData<K>;
                    } else {
                        new (SharedStringData<K>::from_str(str)) SharedStringData<K>(src.capacity_);
                    }
                } else {
                    // Скопируем локально
                    // Copy locally
                    type_ = Local;
                    localRemain_ = LocalCount - size;
                    traits::copy(buf_, str, size + 1);
                    // Освободим тот буфер, у локальной строки буфер не разделяется с другими
                    // Let's free that buffer; a local string's buffer is not shared with others
                    src.dealloc();
                }
            } else {
                // Копируем из локального буфера
                // Copy from local buffer
                K* str = init(src.size_);
                traits::copy(str, src.symbols(), size + 1);
            }
            src.create_empty();
        } else
            create_empty();
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count, typename... Args>
        requires std::is_constructible_v<allocator_t, Args...>
    sstring(T&& s, Args&&... args) : base_storable(std::forward<Args>(args)...) {
        type_ = Constant;
        localRemain_ = 0;
        cstr_ = (const K*)s;
        bigLen_ = N - 1;
    }

    template<typename O> requires(!std::is_same_v<O, K>)
    sstring(simple_str<O> init) {
        this->init_from_utf_convertible(init);
    }
 
    template<typename O, typename I, bool M> requires(!std::is_same_v<O, K>)
    sstring(const str_algs<O, simple_str<O>, I, M>& init) {
        this->init_from_utf_convertible(init.to_str());
    }
 
    constexpr void swap(my_type&& other) noexcept {
        char buf[sizeof(buf_) + sizeof(K)];
        memcpy(buf, buf_, sizeof(buf));
        memcpy(buf_, other.buf_, sizeof(buf));
        memcpy(other.buf_, buf, sizeof(buf));
 
        std::swap(base_storable::allocator(), other.allocator());
    }
    constexpr my_type& operator=(my_type other) noexcept {
        swap(std::move(other));
        return *this;
    }

    constexpr my_type& operator=(simple_str<K> other) {
        return operator=(my_type{other, base_storable::allocator()});
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
    constexpr my_type& operator=(T&& other) {
        return operator=(my_type{std::forward<T>(other), base_storable::allocator()});
    }

    template<size_t N, bool forShared, typename A>
    constexpr my_type& operator=(const lstring<K, N, forShared, A>& other) {
        return operator=(my_type{other.to_str(), base_storable::allocator()});
    }

    template<size_t N>
    constexpr my_type& operator=(lstring<K, N, true, Allocator>&& other) {
        return operator=(my_type{std::move(other)});
    }

    constexpr my_type& operator=(const StrExprForType<K> auto& expr) {
        return operator=(my_type{expr, base_storable::allocator()});
    }

    constexpr my_type& make_empty() noexcept {
        dealloc();
        create_empty();
        return *this;
    }

    constexpr const K* symbols() const noexcept {
        return type_ == Local ? buf_ : cstr_;
    }

    constexpr size_t length() const noexcept {
        return type_ == Local ? LocalCount - localRemain_ : bigLen_;
    }

    constexpr bool is_empty() const noexcept {
        return length() == 0;
    }

    constexpr bool empty() const noexcept {
        return is_empty();
    }

    template<typename... T>
    static my_type printf(const K* pattern, T&&... args) {
        return my_type{lstring<K, 256, true>{}.printf(pattern, std::forward<T>(args)...)};
    }

    template<typename... T>
    static my_type format(const FmtString<to_std_char_t<K>, T...>& fmtString, T&&... args) {
        return my_type{lstring<K, 256, true, Allocator>{}.format(fmtString, std::forward<T>(args)...)};
    }

    template<typename... T>
    static my_type vformat(simple_str<K> fmtString, T&&... args) {
        return my_type{lstring<K, 256, true, Allocator>{}.vformat(fmtString, std::forward<T>(args)...)};
    }
};
 
template<typename K, Allocatable Allocator>
inline const sstring<K> sstring<K, Allocator>::empty_str{};
 
struct no_alloc{};
 
template<typename K, size_t N>
class decl_empty_bases cestring :
    public str_algs<K, simple_str<K>, cestring<K, N>, true>,
    public str_storable<K, cestring<K, N>, no_alloc>,
    public null_terminated<K, lstring<K, N>>
    //, public from_utf_convertible<K, lstring<K, N, forShared, Allocator>>
{
public:
    using symb_type = K;
    using my_type = cestring<K, N>;
 
    enum : size_t {
        LocalCapacity = N | (sizeof(void*) / sizeof(K) - 1),
    };
 
protected:
 
    using base_algs = str_algs<K, simple_str<K>, my_type, true>;
    using base_storable = str_storable<K, my_type, no_alloc>;
    //using base_utf = from_utf_convertible<K, my_type>;
    using traits = ch_traits<K>;
    using s_str = base_storable::s_str;
 
    friend base_storable;
    //friend base_utf;
    const K* cstr_{};
    size_t size_{};
    bool is_cstr_{};
    K local_[LocalCapacity + 1]{};
 
    constexpr void create_empty() {
        is_cstr_ = false;
        size_ = 0;
        local_[0] = 0;
    }
 
    constexpr K* init(size_t s) {
        size_ = s;
        if (size_ > LocalCapacity) {
            throw std::bad_alloc{};
        }
        is_cstr_ = false;
        return local_;
    }
public:
    constexpr size_t length() const noexcept {
        return size_;
    }
    constexpr const K* symbols() const noexcept {
        return is_cstr_ ? cstr_ : local_;
    }
    constexpr bool is_empty() const noexcept {
        return size_ == 0;
    }
    constexpr bool empty() const noexcept {
        return size_ == 0;
    }
    constexpr size_t capacity() const noexcept {
        return LocalCapacity;
    }
    constexpr cestring() noexcept = default;

    constexpr cestring(s_str other) : base_storable() {
        base_storable::init_from_str_other(other);
    }
    constexpr cestring(size_t repeat, s_str pattern) : base_storable() {
        base_storable::init_str_repeat(repeat, pattern);
    }
    constexpr cestring(size_t count, K pad) : base_storable() {
        base_storable::init_symb_repeat(count, pad);
    }
    constexpr  cestring(const StrExprForType<K> auto& expr) : base_storable() {
        base_storable::init_str_expr(expr);
    }
    template<StrType<K> From>
    constexpr cestring(const From& f, s_str pattern, s_str repl, size_t offset = 0, size_t maxCount = 0)
        : base_storable() {
        base_storable::init_replaced(f, pattern, repl, offset, maxCount);
    }

    constexpr ~cestring() {}

    template<typename T, size_t M = const_lit_for<K, T>::Count>
    constexpr cestring(T&& s) : base_storable(), cstr_((const K*)s), size_(M - 1), is_cstr_(true), local_{0} {}
};
 
template<typename K>
consteval simple_str_nt<K> select_str(simple_str_nt<u8s> s8, simple_str_nt<ubs> sb, simple_str_nt<uws> sw, simple_str_nt<u16s> s16, simple_str_nt<u32s> s32) {
    if constexpr (std::is_same_v<K, u8s>)
        return s8;
    if constexpr (std::is_same_v<K, ubs>)
        return sb;
    if constexpr (std::is_same_v<K, uws>)
        return sw;
    if constexpr (std::is_same_v<K, u16s>)
        return s16;
    if constexpr (std::is_same_v<K, u32s>)
        return s32;
}
 
#define uni_string(K, p) select_str<K>(p, u8##p, L##p, u##p, U##p)
 
template<typename K, template<typename C> typename H>
struct StoreType {
    simple_str<K> str;
    size_t hash;
    char node[sizeof(sstring<K>)];
 
    const simple_str_nt<K>& to_nt() const noexcept {
        return static_cast<const simple_str_nt<K>&>(str);
    }
    const sstring<K>& to_str() const noexcept {
        return *reinterpret_cast<const sstring<K>*>(node);
    }
    bool operator==(const StoreType& other) const {
        return hash == other.hash && typename H<K>::eql{}(*this, other);
    }
};
 
template<bool Wide>
struct fnv_const {
    static inline constexpr size_t basis = static_cast<size_t>(14695981039346656037ULL);
    static inline constexpr size_t prime = static_cast<size_t>(1099511628211ULL);
};
 
template<>
struct fnv_const<false> {
    static inline constexpr size_t basis = static_cast<size_t>(2166136261U);
    static inline constexpr size_t prime = static_cast<size_t>(16777619U);
};
 
using fnv = fnv_const<sizeof(size_t) == 8>;
 
template<typename K>
inline constexpr size_t fnv_hash(const K* ptr, size_t l) {
    size_t h = fnv::basis;
    for (size_t i = 0; i < l; i++) {
        h = (h ^ (std::make_unsigned_t<K>)ptr[i]) * fnv::prime;
    }
    return h;
};
 
template<typename K>
inline constexpr size_t fnv_hash_ia(const K* ptr, size_t l) {
    size_t h = fnv::basis;
    for (size_t i = 0; i < l; i++) {
        std::make_unsigned_t<K> s = (std::make_unsigned_t<K>)ptr[i];
        h = (h ^ (s >= 'A' && s <= 'Z' ? s | 0x20 : s)) * fnv::prime;
    }
    return h;
};
 
template<typename T, typename K = typename const_lit<T>::symb_type, size_t N = const_lit<T>::Count>
inline constexpr size_t fnv_hash(T&& value) {
    size_t h = fnv::basis;
    for (size_t i = 0; i < N - 1; i++) {
        h = (h ^ (std::make_unsigned_t<K>)value[i]) * fnv::prime;
    }
    return h;
};
 
template<typename T, typename K = typename const_lit<T>::symb_type, size_t N = const_lit<T>::Count>
inline constexpr size_t fnv_hash_ia(T&& value) {
    size_t h = fnv::basis;
    for (size_t i = 0; i < N - 1; i++) {
        std::make_unsigned_t<K> s = (std::make_unsigned_t<K>)value[i];
        h = (h ^ (s >= 'A' && s <= 'Z' ? s | 0x20 : s)) * fnv::prime;
    }
    return h;
};
 
template<typename K>
inline consteval size_t fnv_hash_compile(const K* ptr, size_t l) {
    return fnv_hash(ptr, l);
};
 
template<typename K>
inline consteval size_t fnv_hash_ia_compile(const K* ptr, size_t l) {
    return fnv_hash_ia(ptr, l);
};
 
template<typename K>
struct str_exact;
 
static_assert(std::is_trivially_copyable_v<StoreType<u8s, str_exact>>, "Store type must be trivially copyable");
 
 
template<typename K, typename V>
std::allocator<std::pair<K, V>> default_hashstrmap_allocator_selector(...);
// Если вы хотите задать свой дефолтный аллокатор для hashStrmap, перед включение sstring.h
// объявите функцию
// template<typename K, typename V>
// ваш_тип_аллокатора default_hashstrmap_allocator_selector(int);
// If you want to set your default allocator for hashStrMap, before including sstring.h
// declare a function
// template<typename K, typename V>
// your_allocator_type default_hashstrmap_allocator_selector(int);
template<typename K, template<typename C> typename H, typename V>
using allocator_hashstrmap = decltype(default_hashstrmap_allocator_selector<const StoreType<K, H>, V>(int(0)));

template<typename K, typename T, template<typename C> typename HE = str_exact, typename A = allocator_hashstrmap<K, HE, T>>
class hashStrMap : public std::unordered_map<StoreType<K, HE>, T, typename HE<K>::hash, typename HE<K>::eql, A> {
protected:
    using InStore = StoreType<K, HE>;
 
public:
    using hasher = typename HE<K>::hash;
    using comparator = typename HE<K>::eql;
    using my_type = hashStrMap<K, T, HE, A>;
    using hash_t = std::unordered_map<StoreType<K, HE>, T, hasher, comparator, A>;
 
    hashStrMap() = default;
    hashStrMap(const my_type& other) : hash_t(other) {
        for (const auto& [k, v] : *this) {
            InStore& stored = const_cast<InStore&>(k);
            sstring<K> tmp = *(sstring<K>*)stored.node;
            new (stored.node) sstring<K>(std::move(tmp));
            stored.str.str = stored.to_str().symbols();
        }
    }
    ~hashStrMap() {
        for (auto& k: *this)
            ((sstring<K>*)k.first.node)->~sstring();
    }
 
    hashStrMap(my_type&& o) = default;
 
    my_type& operator=(const my_type& other) {
        hash_t::operator=(other);
        for (const auto& [k, v] : *this) {
            InStore& stored = const_cast<InStore&>(k);
            sstring<K> tmp = *(sstring<K>*)stored.node;
            new (stored.node) sstring<K>(std::move(tmp));
            stored.str.str = stored.to_str().symbols();
        }
        return *this;
    };
    my_type& operator=(my_type&&) = default;
 
    hashStrMap(std::initializer_list<std::pair<const InStore, T>>&& init) {
        for (const auto& e: init)
            emplace(e.first, e.second);
    }
 
    using init_str = std::initializer_list<std::pair<const sstring<K>, T>>;
 
    hashStrMap(init_str&& init) {
        for (const auto& e: init)
            emplace(e.first, e.second);
    }
 
    // При входе хэш должен быть уже посчитан
    // When entering, the hash must already be calculated
    template<typename... ValArgs>
    auto try_emplace(const InStore& key, ValArgs&&... args) {
        auto it = hash_t::try_emplace(key, std::forward<ValArgs>(args)...);
        if (it.second) {
            InStore& stored = const_cast<InStore&>(it.first->first);
            new (stored.node) sstring<K>(key.str);
            stored.str.str = stored.to_str().symbols();
        }
        return it;
    }
 
    static InStore toStoreType(simple_str<K> key) {
        return {key, hasher{}(key)};
    }
 
    template<typename Key, typename... ValArgs>
        requires(std::is_convertible_v<Key, simple_str<K>>)
    auto try_emplace(Key&& key, ValArgs&&... args) {
        auto it = hash_t::try_emplace(toStoreType(key), std::forward<ValArgs>(args)...);
        if (it.second) {
            InStore& stored = const_cast<InStore&>(it.first->first);
            new (stored.node) sstring<K>(std::forward<Key>(key));
            stored.str.str = stored.to_str().symbols();
        }
        return it;
    }
 
    template<typename... ValArgs>
    auto emplace(const InStore& key, ValArgs&&... args) {
        auto it = try_emplace(key, std::forward<ValArgs>(args)...);
        if (!it.second) {
            it.first->second = T(std::forward<ValArgs>(args)...);
        }
        return it;
    }
 
    template<typename Key, typename... ValArgs>
        requires(std::is_convertible_v<Key, simple_str<K>>)
    auto emplace(Key&& key, ValArgs&&... args) {
        auto it = try_emplace(std::forward<Key>(key), std::forward<ValArgs>(args)...);
        if (!it.second) {
            it.first->second = T(std::forward<ValArgs>(args)...);
        }
        return it;
    }
 
    auto& operator[](const InStore& key) {
        return try_emplace(key).first->second;
    }
 
    template<typename Key>
        requires(std::is_convertible_v<Key, simple_str<K>>)
    auto& operator[](Key&& key) {
        return try_emplace(std::forward<Key>(key)).first->second;
    }
 
    decltype(auto) at(const InStore& key) {
        return hash_t::at(key);
    }
    decltype(auto) at(const InStore& key) const {
        return hash_t::at(key);
    }
 
    decltype(auto) at(simple_str<K> key) {
        return hash_t::at(toStoreType(key));
    }
    decltype(auto) at(simple_str<K> key) const {
        return hash_t::at(toStoreType(key));
    }
 
    auto find(const InStore& key) const {
        return hash_t::find(key);
    }
 
    auto find(simple_str<K> key) const {
        return find(toStoreType(key));
    }
 
    auto find(const InStore& key) {
        return hash_t::find(key);
    }
 
    auto find(simple_str<K> key) {
        return find(toStoreType(key));
    }
 
    auto erase(typename hash_t::const_iterator it) {
        if (it != hash_t::end()) {
            ((sstring<K>*)it->first.node)->~sstring();
        }
        return hash_t::erase(it);
    }
 
    auto erase(const InStore& key) {
        auto it = hash_t::find(key);
        if (it != hash_t::end()) {
            ((sstring<K>*)it->first.node)->~sstring();
            hash_t::erase(it);
            return 1;
        }
        return 0;
    }
 
    auto erase(simple_str<K> key) {
        return erase(toStoreType(key));
    }
 
    bool lookup(simple_str<K> txt, T& val) const {
        auto it = find(txt);
        if (it != hash_t::end()) {
            val = it->second;
            return true;
        }
        return false;
    }
 
    void clear() {
        for (auto& k: *this)
            ((sstring<K>*)k.first.node)->~sstring();
        hash_t::clear();
    }
    bool contains(const InStore& key) const {
        return hash_t::find(key) != this->end();
    }
 
    bool contains(simple_str<K> key) const {
        return find(toStoreType(key)) != this->end();
    }
};
 
template<typename K>
struct str_exact {
    struct eql {
        bool operator()(const StoreType<K, str_exact>& _Left, const StoreType<K, str_exact>& _Right) const {
            return _Left.hash == _Right.hash && _Left.str == _Right.str;
        }
    };
    struct hash { // hash functor for basic_string
        size_t operator()(simple_str<K> _Keyval) const {
            return fnv_hash(_Keyval.symbols(), _Keyval.length());
        }
        size_t operator()(const StoreType<K, str_exact>& _Keyval) const {
            return _Keyval.hash;
        }
    };
};
 
template<typename K>
struct str_eqlia {
    struct eql {
        bool operator()(const StoreType<K, str_eqlia>& _Left, const StoreType<K, str_eqlia>& _Right) const {
            return _Left.hash == _Right.hash && _Left.str.equal_ia(_Right.str);
        }
    };
    struct hash {
        size_t operator()(simple_str<K> _Keyval) const {
            return fnv_hash_ia(_Keyval.symbols(), _Keyval.length());
        }
        size_t operator()(const StoreType<K, str_eqlia>& _Keyval) const {
            return _Keyval.hash;
        }
    };
};
 
template<typename K>
struct str_eqliu {
    struct eql {
        bool operator()(const StoreType<K, str_eqliu>& _Left, const StoreType<K, str_eqliu>& _Right) const {
            return _Left.hash == _Right.hash && _Left.str.equal_iu(_Right.str);
        }
    };
    struct hash {
        size_t operator()(simple_str<K> _Keyval) const {
            using bc = to_base_char_t<K>;
            return unicode_traits<bc>::hashiu((const bc*)_Keyval.symbols(), _Keyval.length());
        }
        size_t operator()(const StoreType<K, str_eqliu>& _Keyval) const {
            return _Keyval.hash;
        }
    };
};

template<typename K>
class chunked_string_builder : expr_to_std_string<chunked_string_builder<K>> {
    using chunk_t = std::pair<std::unique_ptr<K[]>, size_t>;
    std::vector<chunk_t> chunks; // блоки и длина данных в них | blocks and data length in them
    K* write{};                  // Текущая позиция записи | Current write position
    size_t len{};                // Общая длина | Total length
    size_t remain{};             // Сколько осталось места в текущем блоке | How much space is left in the current block
    size_t align{1024};
 
public:
    using my_type = chunked_string_builder<K>;
    using symb_type = K;
    chunked_string_builder() = default;
    chunked_string_builder(size_t a) : align(a){};
    chunked_string_builder(const my_type&) = delete;
    chunked_string_builder(my_type&& other) noexcept
        : chunks(std::move(other.chunks)), write(other.write), len(other.len), remain(other.remain), align(other.align) {
        other.len = other.remain = 0;
        other.write = nullptr;
    }
    my_type& operator=(my_type other) noexcept {
        chunks.swap(other.chunks);
        write = other.write;
        len = other.len;
        remain = other.remain;
        align = other.align;
        other.len = other.remain = 0;
        other.write = nullptr;
        return *this;
    }

    my_type& operator<<(simple_str<K> data) {
        if (data.len) {
            len += data.len;
            if (data.len <= remain) {
                // Добавляемые данные влезают в выделенный блок, просто скопируем их
                // The added data fits into the selected block, just copy it
                ch_traits<K>::copy(write, data.str, data.len);
                write += data.len;                // Сдвинем позицию  записи | Let's move the recording position
                chunks.back().second += data.len; // Увеличим длину хранимых в блоке данных | Let's increase the length of the data stored in the block
                remain -= data.len;               // Уменьшим остаток места в блоке | Reduce the remaining space in the block
            } else {
                // Не влезают | They don't fit
                if (remain) {
                    // Сначала запишем сколько влезет
                    // First, write down as much as we can
                    ch_traits<K>::copy(write, data.str, remain);
                    data.len -= remain;
                    data.str += remain;
                    chunks.back().second += remain; // Увеличим длину хранимых в блоке данных | Let's increase the length of the data stored in the block
                }
                // Выделим новый блок и впишем в него данные
                // Рассчитаем размер блока, кратного заданному выравниванию
                // Select a new block and write data into it
                // Calculate the block size that is a multiple of the given alignment
                size_t blockSize = (data.len + align - 1) / align * align;
                chunks.emplace_back(std::make_unique<K[]>(blockSize), data.len);
                write = chunks.back().first.get();
                ch_traits<K>::copy(write, data.str, data.len);
                write += data.len;
                remain = blockSize - data.len;
            }
        }
        return *this;
    }

    my_type& operator<<(const StrExprForType<K> auto& expr) {
        size_t l = expr.length();
        if (l) {
            if (l < remain) {
                write = expr.place(write);
                chunks.back().second += l;
                len += l;
                remain -= l;
            } else if (!remain) {
                size_t blockSize = (l + align - 1) / align * align; // Рассчитаем размер блока, кратного заданному выравниванию
                chunks.emplace_back(std::make_unique<K[]>(blockSize), l);
                write = expr.place(chunks.back().first.get());
                len += l;
                remain = blockSize - l;
            } else {
                auto store = std::make_unique<K[]>(l);
                expr.place(store.get());
                return operator<<({store.get(), l});
            }
        }
        return *this;
    }

    template<typename T>
    my_type& operator<<(T data)
        requires std::is_same_v<T, K>
    {
        return operator<<(expr_char<K>(data));
    }

    constexpr size_t length() const noexcept {
        return len;
    }

    void reset() {
        if (chunks.empty()) {
            return;
        }
        if (chunks.size() > 1) {
            remain = 0;
            chunks.resize(1);
        }
        remain += chunks[0].second;
        chunks[0].second = 0;
        len = 0;
        write = chunks[0].first.get();
    }
 
    constexpr K* place(K* p) const noexcept {
        for (const auto& block: chunks) {
            ch_traits<K>::copy(p, block.first.get(), block.second);
            p += block.second;
        }
        return p;
    }
    template<typename Op>
    void out(const Op& o) const {
        for (const auto& block: chunks)
            o(block.first.get(), block.second);
    }

    bool is_continuous() const {
        if (chunks.size()) {
            const K* ptr = chunks.front().first.get();
            for (const auto& chunk: chunks) {
                if (chunk.first.get() != ptr)
                    return false;
                ptr += chunk.second;
            }
        }
        return true;
    }

    const K* begin() const {
        return chunks.size() ? chunks.front().first.get() : simple_str_nt<K>::empty_str.str;
    }

    void clear() {
        chunks.clear();
        write = nullptr;
        len = 0;
        remain = 0;
    }

    struct portion_store {
        typename decltype(chunks)::const_iterator it, end;
        size_t writedFromCurrentChunk;
        bool is_end() {
            return it == end;
        }

        size_t store(K* buffer, size_t size) {
            size_t writed = 0;
            while (size && !is_end()) {
                size_t remain = it->second - writedFromCurrentChunk;
                size_t write = std::min(size, remain);
                ch_traits<K>::copy(buffer, it->first.get() + writedFromCurrentChunk, write);
                writed += write;
                remain -= write;
                size -= write;
                if (!remain) {
                    ++it;
                    writedFromCurrentChunk = 0;
                } else
                    writedFromCurrentChunk += write;
            }
            return writed;
        }
    };

    portion_store get_portion() const {
        return {chunks.begin(), chunks.end(), 0};
    }

    const auto& data() const {
        return chunks;
    }
};
 
using stringa = sstring<u8s>;
using stringb = sstring<ubs>;
using stringw = sstring<wchar_t>;
using stringu = sstring<u16s>;
using stringuu = sstring<u32s>;
static_assert(sizeof(stringa) == (sizeof(void*) == 8 ? 24 : 16), "Bad size of sstring");

template<typename T, typename A = allocator_hashstrmap<u8s, str_exact, T>>
using hashStrMapA = hashStrMap<u8s, T, str_exact, A>;
template<typename T, typename A = allocator_hashstrmap<u8s, str_eqlia, T>>
using hashStrMapAIA = hashStrMap<u8s, T, str_eqlia, A>;
template<typename T, typename A = allocator_hashstrmap<u8s, str_eqliu, T>>
using hashStrMapAIU = hashStrMap<u8s, T, str_eqliu, A>;

template<typename T, typename A = allocator_hashstrmap<ubs, str_exact, T>>
using hashStrMapB = hashStrMap<ubs, T, str_exact, A>;
template<typename T, typename A = allocator_hashstrmap<ubs, str_eqlia, T>>
using hashStrMapBIA = hashStrMap<ubs, T, str_eqlia, A>;
template<typename T, typename A = allocator_hashstrmap<ubs, str_eqliu, T>>
using hashStrMapBIU = hashStrMap<ubs, T, str_eqliu, A>;

template<typename T, typename A = allocator_hashstrmap<wchar_t, str_exact, T>>
using hashStrMapW = hashStrMap<wchar_t, T, str_exact, A>;

template<typename T, typename A = allocator_hashstrmap<wchar_t, str_eqlia, T>>
using hashStrMapWIA = hashStrMap<wchar_t, T, str_eqlia, A>;

template<typename T, typename A = allocator_hashstrmap<wchar_t, str_eqliu, T>>
using hashStrMapWIU = hashStrMap<wchar_t, T, str_eqliu, A>;

template<typename T, typename A = allocator_hashstrmap<u16s, str_exact, T>>
using hashStrMapU = hashStrMap<u16s, T, str_exact, A>;
template<typename T, typename A = allocator_hashstrmap<u16s, str_eqlia, T>>
using hashStrMapUIA = hashStrMap<u16s, T, str_eqlia, A>;
template<typename T, typename A = allocator_hashstrmap<u16s, str_eqliu, T>>
using hashStrMapUIU = hashStrMap<u16s, T, str_eqliu, A>;

template<typename T, typename A = allocator_hashstrmap<u32s, str_exact, T>>
using hashStrMapUU = hashStrMap<u32s, T, str_exact, A>;
template<typename T, typename A = allocator_hashstrmap<u32s, str_eqlia, T>>
using hashStrMapUUIA = hashStrMap<u32s, T, str_eqlia, A>;
template<typename T, typename A = allocator_hashstrmap<u32s, str_eqliu, T>>
using hashStrMapUUIU = hashStrMap<u32s, T, str_eqliu, A>;
 
inline constexpr simple_str_nt<u8s> utf8_bom{"\xEF\xBB\xBF", 3}; // NOLINT
 
inline namespace literals {

SS_CONSTEVAL simple_str_nt<u8s> operator""_ss(const u8s* ptr, size_t l) {
    return simple_str_nt<u8s>{ptr, l};
}

SS_CONSTEVAL simple_str_nt<ubs> operator""_ss(const ubs* ptr, size_t l) {
    return simple_str_nt<ubs>{ptr, l};
}

SS_CONSTEVAL simple_str_nt<uws> operator""_ss(const uws* ptr, size_t l) {
    return simple_str_nt<uws>{ptr, l};
}

SS_CONSTEVAL simple_str_nt<u16s> operator""_ss(const u16s* ptr, size_t l) {
    return simple_str_nt<u16s>{ptr, l};
}

SS_CONSTEVAL simple_str_nt<u32s> operator""_ss(const u32s* ptr, size_t l) {
    return simple_str_nt<u32s>{ptr, l};
}
 
template<typename K> using HashKey = StoreType<K, str_exact>;
template<typename K> using HashKeyIA = StoreType<K, str_eqlia>;
template<typename K> using HashKeyIU = StoreType<K, str_eqliu>;

consteval HashKey<u8s> operator""_h(const u8s* ptr, size_t l) {
    return HashKey<u8s>{{ptr, l}, fnv_hash_compile(ptr, l)};
}

consteval HashKeyIA<u8s> operator""_ia(const u8s* ptr, size_t l) {
    return HashKeyIA<u8s>{{ptr, l}, fnv_hash_ia_compile(ptr, l)};
}

inline HashKeyIU<u8s> operator""_iu(const u8s* ptr, size_t l) {
    return HashKeyIU<u8s>{{ptr, l}, str_eqliu<u8s>::hash{}(simple_str<u8s>{ptr, l})};
}

consteval HashKey<ubs> operator""_h(const ubs* ptr, size_t l) {
    return HashKey<ubs>{{ptr, l}, fnv_hash_compile(ptr, l)};
}

consteval HashKeyIA<ubs> operator""_ia(const ubs* ptr, size_t l) {
    return HashKeyIA<ubs>{{ptr, l}, fnv_hash_ia_compile(ptr, l)};
}

inline HashKeyIU<ubs> operator""_iu(const ubs* ptr, size_t l) {
    return HashKeyIU<ubs>{{ptr, l}, str_eqliu<u8s>::hash{}(simple_str<u8s>{(const u8s*)ptr, l})};
}

consteval HashKey<u16s> operator""_h(const u16s* ptr, size_t l) {
    return HashKey<u16s>{{ptr, l}, fnv_hash_compile(ptr, l)};
}

consteval HashKeyIA<u16s> operator""_ia(const u16s* ptr, size_t l) {
    return HashKeyIA<u16s>{{ptr, l}, fnv_hash_ia_compile(ptr, l)};
}

inline HashKeyIU<u16s> operator""_iu(const u16s* ptr, size_t l) {
    return HashKeyIU<u16s>{{ptr, l}, str_eqliu<u16s>::hash{}(simple_str<u16s>{ptr, l})};
}

consteval HashKey<u32s> operator""_h(const u32s* ptr, size_t l) {
    return HashKey<u32s>{{ptr, l}, fnv_hash_compile(ptr, l)};
}

consteval HashKeyIA<u32s> operator""_ia(const u32s* ptr, size_t l) {
    return HashKeyIA<u32s>{{ptr, l}, fnv_hash_ia_compile(ptr, l)};
}

inline HashKeyIU<u32s> operator""_iu(const u32s* ptr, size_t l) {
    return HashKeyIU<u32s>{{ptr, l}, str_eqliu<u32s>::hash{}(simple_str<u32s>{ptr, l})};
}

consteval HashKey<uws> operator""_h(const uws* ptr, size_t l) {
    return HashKey<uws>{{ptr, l}, fnv_hash_compile(ptr, l)};
}

consteval HashKeyIA<uws> operator""_ia(const uws* ptr, size_t l) {
    return HashKeyIA<uws>{{ptr, l}, fnv_hash_ia_compile(ptr, l)};
}

inline HashKeyIU<uws> operator""_iu(const uws* ptr, size_t l) {
    return HashKeyIU<uws>{{ptr, l}, str_eqliu<uws>::hash{}(simple_str<uws>{ptr, l})};
}
} // namespace literals

inline std::ostream& operator<<(std::ostream& stream, ssa text) {
    return stream << std::string_view{text.symbols(), text.length()};
}

inline std::wostream& operator<<(std::wostream& stream, ssw text) {
    return stream << std::wstring_view{text.symbols(), text.length()};
}

inline std::wostream& operator<<(std::wostream& stream, simple_str<wchar_type> text) {
    return stream << std::wstring_view{from_w(text.symbols()), text.length()};
}

inline std::ostream& operator<<(std::ostream& stream, const stringa& text) {
    return stream << std::string_view{text.symbols(), text.length()};
}

inline std::wostream& operator<<(std::wostream& stream, const stringw& text) {
    return stream << std::wstring_view{text.symbols(), text.length()};
}

inline std::wostream& operator<<(std::wostream& stream, const sstring<wchar_type>& text) {
    return stream << std::wstring_view{from_w(text.symbols()), text.length()};
}

template<size_t N, bool S, simstr::Allocatable A>
inline std::ostream& operator<<(std::ostream& stream, const lstring<u8s, N, S, A>& text) {
    return stream << std::string_view{text.symbols(), text.length()};
}

template<size_t N, bool S, simstr::Allocatable A>
inline std::wostream& operator<<(std::wostream& stream, const lstring<uws, N, S, A>& text) {
    return stream << std::wstring_view{text.symbols(), text.length()};
}

template<size_t N, bool S, simstr::Allocatable A>
inline std::wostream& operator<<(std::wostream& stream, const lstring<wchar_type, N, S, A>& text) {
    return stream << std::wstring_view{from_w(text.symbols()), text.length()};
}
 
} // namespace simstr

template<typename K>
struct std::formatter<simstr::simple_str<K>, K> : std::formatter<std::basic_string_view<K>, K> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(simstr::simple_str<K> t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<K>, K>::format({t.str, t.len}, fc);
    }
};

template<typename K>
struct std::formatter<simstr::simple_str_nt<K>, K> : std::formatter<std::basic_string_view<K>, K> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(simstr::simple_str_nt<K> t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<K>, K>::format({t.str, t.len}, fc);
    }
};

template<typename K>
struct std::formatter<simstr::sstring<K>, K> : std::formatter<std::basic_string_view<K>, K> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(const simstr::sstring<K>& t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<K>, K>::format({t.symbols(), t.length()}, fc);
    }
};

template<typename K, size_t N, bool S, typename A>
struct std::formatter<simstr::lstring<K, N, S, A>, K> : std::formatter<std::basic_string_view<K>, K> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(const simstr::lstring<K, N, S, A>& t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<K>, K>::format({t.symbols(), t.length()}, fc);
    }
};

template<>
struct std::formatter<simstr::simple_str<char8_t>, char> : std::formatter<std::basic_string_view<char>, char> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(simstr::simple_str<char8_t> t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<char>, char>::format({(const char*)t.str, t.len}, fc);
    }
};

template<>
struct std::formatter<simstr::simple_str_nt<char8_t>, char> : std::formatter<std::basic_string_view<char>, char> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(simstr::simple_str_nt<char8_t> t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<char>, char>::format({(const char*)t.str, t.len}, fc);
    }
};

template<>
struct std::formatter<simstr::sstring<char8_t>, char> : std::formatter<std::basic_string_view<char>, char> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(const simstr::sstring<char8_t>& t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<char>, char>::format({(const char*)t.symbols(), t.length()}, fc);
    }
};

template<size_t N, bool S, typename A>
struct std::formatter<simstr::lstring<char8_t, N, S, A>, char> : std::formatter<std::basic_string_view<char>, char> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(const simstr::lstring<char8_t, N, S, A>& t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<char>, char>::format({(const char*)t.symbols(), t.length()}, fc);
    }
};

template<>
struct std::formatter<simstr::simple_str<simstr::wchar_type>, wchar_t> : std::formatter<std::basic_string_view<wchar_t>, wchar_t> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(simstr::simple_str<simstr::wchar_type> t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<wchar_t>, wchar_t>::format({(const wchar_t*)t.str, t.len}, fc);
    }
};

template<>
struct std::formatter<simstr::simple_str_nt<simstr::wchar_type>, wchar_t> : std::formatter<std::basic_string_view<wchar_t>, wchar_t> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(simstr::simple_str_nt<simstr::wchar_type> t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<wchar_t>, wchar_t>::format({(const wchar_t*)t.str, t.len}, fc);
    }
};

template<>
struct std::formatter<simstr::sstring<simstr::wchar_type>, wchar_t> : std::formatter<std::basic_string_view<wchar_t>, wchar_t> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(const simstr::sstring<simstr::wchar_type>& t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<wchar_t>, wchar_t>::format({(const wchar_t*)t.symbols(), t.length()}, fc);
    }
};

template<size_t N, bool S, typename A>
struct std::formatter<simstr::lstring<simstr::wchar_type, N, S, A>, wchar_t> : std::formatter<std::basic_string_view<wchar_t>, wchar_t> {
    // Define format() by calling the base class implementation with the wrapped value
    template<typename FormatContext>
    auto format(const simstr::lstring<simstr::wchar_type, N, S, A>& t, FormatContext& fc) const {
        return std::formatter<std::basic_string_view<wchar_t>, wchar_t>::format({(const wchar_t*)t.symbols(), t.length()}, fc);
    }
};