String.hpp

//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2026 Bruno Van de Velde (vdv_b@tgui.eu)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
//    you must not claim that you wrote the original software.
//    If you use this software in a product, an acknowledgment
//    in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
//    and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
 
#ifndef TGUI_STRING_HPP
#define TGUI_STRING_HPP
 
#include <TGUI/Config.hpp>
 
#include <TGUI/StringView.hpp>
#include <TGUI/Utf.hpp>
 
#include <cstring>
#include <initializer_list>
#include <iomanip>
#include <locale>
#include <ostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
 
#if TGUI_HAS_WINDOW_BACKEND_SFML
    #include <SFML/System/String.hpp>
#endif

 
namespace tgui
{
    [[nodiscard]] TGUI_API bool isWhitespace(char character);

    [[nodiscard]] TGUI_API bool isWhitespace(char32_t character);

    [[nodiscard]] TGUI_API bool isAlpha(char32_t character);

    [[nodiscard]] TGUI_API bool isDigit(char32_t character);

    class TGUI_API String
    {
    private:
        std::u32string m_string;
 
        // Helper to check if template parameter is a string_view
        template <typename StringViewType>
        using IsStringViewType = std::enable_if_t<
            std::is_same_v<StringViewType, std::string_view>
#if defined(__cpp_lib_char8_t) && (__cpp_lib_char8_t >= 201811L)
                || std::is_same_v<StringViewType, std::u8string_view>
#endif
                || std::is_same_v<StringViewType, std::wstring_view> || std::is_same_v<StringViewType, std::u16string_view>
                || std::is_same_v<StringViewType, std::u32string_view>,
            void>;
 
        // Helper to check if iterator is either from std::u32string or std::u32string_view.
        // When compiling with Emscipten (which used Clang 23), those iterators are the same
        // and we can't have a seperate function for each.
        template <typename IteratorType>
        using IsU32Iterator = std::enable_if_t<std::is_convertible_v<IteratorType, std::u32string::const_iterator>
                                                   || std::is_convertible_v<IteratorType, StringView::const_iterator>,
                                               void>;
 
    public:
        static constexpr auto npos = std::u32string_view::npos;
 
        using iterator = std::u32string::iterator;
        using const_iterator = std::u32string::const_iterator;
        using reverse_iterator = std::u32string::reverse_iterator;
        using const_reverse_iterator = std::u32string::const_reverse_iterator;
 
        using value_type = char32_t;
        using reference = char32_t&;
        using const_reference = const char32_t&;
 
    public:
        [[nodiscard]] bool attemptToInt(int& result) const;

        [[nodiscard]] bool attemptToUInt(unsigned int& result) const;

        [[nodiscard]] bool attemptToFloat(float& result) const;

        [[nodiscard]] int toInt(int defaultValue = 0) const;

        [[nodiscard]] unsigned int toUInt(unsigned int defaultValue = 0) const;

        [[nodiscard]] float toFloat(float defaultValue = 0) const;

        [[nodiscard]] String trim() const;

        [[nodiscard]] String toLower() const;

        [[nodiscard]] String toUpper() const;

        [[nodiscard]] bool equalIgnoreCase(const String& other) const;
 
#ifndef TGUI_REMOVE_DEPRECATED_CODE
        TGUI_DEPRECATED("Use starts_with instead") [[nodiscard]] bool startsWith(const String& substring) const;
#endif

        [[nodiscard]] bool startsWithIgnoreCase(const String& substring) const;
 
#ifndef TGUI_REMOVE_DEPRECATED_CODE
        TGUI_DEPRECATED("Use ends_with instead") [[nodiscard]] bool endsWith(const String& substring) const;
#endif

        [[nodiscard]] bool endsWithIgnoreCase(const String& substring) const;

        String& replace(const String& searchFor, const String& replaceWith);

        void remove(const String& substring);

        [[nodiscard]] std::vector<String> split(const String& delimiter, bool trim = false) const;

        [[nodiscard]] static String join(const std::vector<String>& segments, const String& separator);

        template <typename T>
        [[nodiscard]] static String fromNumber(T value)
        {
            // If the value is a floating point then we can't use std::to_string because its result depends on the locale.
            // If the value is an 8-bit type (e.g. uint8_t and int8_t) then using std::ostringstream results in the wrong result,
            // as it will be interpreted as a character instead of a number.
            if constexpr (std::is_integral_v<T>)
            {
                return {std::to_string(value)};
            }
            else
            {
                std::ostringstream oss;
                oss.imbue(std::locale::classic());
                oss << value;
                return {oss.str()};
            }
        }

        template <typename T>
        [[nodiscard]] static String fromNumberRounded(T value, unsigned int decimals)
        {
            // Precision is ignored by std::ostringstream for integers, so we use std::to_string for integers instead.
            // If the value is an 8-bit type (e.g. uint8_t and int8_t) then using std::ostringstream results in the wrong result,
            // as it will be interpreted as a character instead of a number. Which is why this separate branch for integers exists.
            if constexpr (std::is_integral_v<T>)
                return {std::to_string(value)};
            else
            {
                std::ostringstream oss;
                oss.imbue(std::locale::classic());
                oss << std::fixed << std::setprecision(static_cast<int>(decimals));
                oss << value;
                return {oss.str()};
            }
        }

 
    public:
        String() = default;
 
        String(const std::string& str);
        String(const std::wstring& str);
        String(const std::u16string& str);
        String(const std::u32string& str);
 
        String(std::u32string&& str) :
            m_string{std::move(str)}
        {
        }
 
        String(char ansiChar);
        String(wchar_t wideChar);
        String(char16_t utfChar);
        String(char32_t utfChar);
 
        String(const char* str);
        String(const wchar_t* str);
        String(const char16_t* str);
        String(const char32_t* str) :
            m_string{str}
        {
        }
 
        // Constructor to initialize the string from a number (integer or float)
        template <typename T, typename = typename std::enable_if_t<std::is_arithmetic_v<T>, T>>
        explicit String(T number) :
            String{fromNumber(number)}
        {
        }
 
        String(std::size_t count, char ch);
        String(std::size_t count, wchar_t ch);
        String(std::size_t count, char16_t ch);
        String(std::size_t count, char32_t ch);
 
        String(const std::string& str, std::size_t pos);
        String(const std::wstring& str, std::size_t pos);
        String(const std::u16string& str, std::size_t pos);
        String(const std::u32string& str, std::size_t pos);
 
        String(const std::string& str, std::size_t pos, std::size_t count);
        String(const std::wstring& str, std::size_t pos, std::size_t count);
        String(const std::u16string& str, std::size_t pos, std::size_t count);
        String(const std::u32string& str, std::size_t pos, std::size_t count);
 
        String(const char* str, std::size_t count);
        String(const wchar_t* str, std::size_t count);
        String(const char16_t* str, std::size_t count);
        String(const char32_t* str, std::size_t count);
 
        explicit String(std::initializer_list<char> chars);
        explicit String(std::initializer_list<wchar_t> chars);
        explicit String(std::initializer_list<char16_t> chars);
        explicit String(std::initializer_list<char32_t> chars);
 
        // Constructors using iterators have to be explicit to prevent {"1", "2"} to be ambiguous between String and std::vector<String>.
        // The reason these constructors were considered a candicate to clang is due to a private constructor in the iterator class.
        // We can't accept string_view::const_iterator iterators, because it would lead to the same kind of ambiguity even when the
        // constructor is marked explicit (in GCC but not MSVC if we define the function normally, in MSVC but not GCC if we use a template).
        explicit String(std::string::const_iterator first, std::string::const_iterator last);
        explicit String(std::wstring::const_iterator first, std::wstring::const_iterator last);
        explicit String(std::u16string::const_iterator first, std::u16string::const_iterator last);
        explicit String(std::u32string::const_iterator first, std::u32string::const_iterator last);
 
        template <typename StringViewType, typename = IsStringViewType<StringViewType>>
        explicit String(const StringViewType& stringView) :
            String(stringView.data(), stringView.size())
        {
        }
 
        template <typename StringViewType, typename = IsStringViewType<StringViewType>>
        explicit String(const StringViewType& stringView, std::size_t pos, std::size_t count) :
            String(stringView.data() + pos, count)
        {
        }
 
#if TGUI_HAS_WINDOW_BACKEND_SFML
        // This constructor has to be explicit or it will cause MSVC to no longer compile code that performs sf::String + std::string
        explicit String(const sf::String& str) :
    #if SFML_VERSION_MAJOR >= 3
            m_string{str.toUtf32()}
    #else
            m_string{reinterpret_cast<const char32_t*>(str.toUtf32().c_str())}
    #endif
        {
        }
 
    #if (SFML_VERSION_MAJOR < 3) || (SFML_VERSION_MAJOR == 3 && SFML_VERSION_MINOR < 1)
        // When compiling with C++17, the conversion to sf::String is done with the StringView operator for SFML 3.1 or higher
        explicit operator sf::String() const
        {
            return sf::String::fromUtf32(m_string.cbegin(), m_string.cend());
        }
    #endif
#endif // TGUI_HAS_WINDOW_BACKEND_SFML
 
        explicit operator std::string() const;
        explicit operator std::wstring() const;
        explicit operator std::u16string() const;
        explicit operator const std::u32string&() const
        {
            return m_string;
        }
 
        operator StringView() const noexcept
        {
            return m_string;
        }
 
        [[nodiscard]] std::string toStdString() const;
        [[nodiscard]] std::wstring toWideString() const;
        [[nodiscard]] std::u16string toUtf16() const;
        [[nodiscard]] const std::u32string& toUtf32() const
        {
            return m_string;
        }
 
        String& assign(std::size_t count, char ch);
        String& assign(std::size_t count, wchar_t ch);
        String& assign(std::size_t count, char16_t ch);
        String& assign(std::size_t count, char32_t ch);
 
        String& assign(StringView sv);
        String& assign(const char32_t* str);
        String& assign(const std::u32string& str);
        String& assign(const String& str);
 
        String& assign(StringView sv, std::size_t pos, std::size_t count = npos);
        String& assign(const std::string& str, std::size_t pos, std::size_t count = npos);
        String& assign(const std::wstring& str, std::size_t pos, std::size_t count = npos);
        String& assign(const std::u16string& str, std::size_t pos, std::size_t count = npos);
        String& assign(const std::u32string& str, std::size_t pos, std::size_t count = npos);
        String& assign(const String& str, std::size_t pos, std::size_t count = npos);
 
        String& assign(std::u32string&& str);
        String& assign(String&& str);
 
        String& assign(const char* str, std::size_t count);
        String& assign(const wchar_t* str, std::size_t count);
        String& assign(const char16_t* str, std::size_t count);
        String& assign(const char32_t* str, std::size_t count);
 
        String& assign(std::initializer_list<char> chars);
        String& assign(std::initializer_list<wchar_t> chars);
        String& assign(std::initializer_list<char16_t> chars);
        String& assign(std::initializer_list<char32_t> chars);
 
        String& assign(std::string::const_iterator first, std::string::const_iterator last);
        String& assign(std::wstring::const_iterator first, std::wstring::const_iterator last);
        String& assign(std::u16string::const_iterator first, std::u16string::const_iterator last);
 
        template <typename IteratorType, typename = IsU32Iterator<IteratorType>>
        String& assign(IteratorType first, IteratorType last)
        {
            m_string.assign(first, last);
            return *this;
        }
 
        [[nodiscard]] reference at(std::size_t pos);
        [[nodiscard]] const_reference at(std::size_t pos) const;
 
        [[nodiscard]] const_reference operator[](std::size_t index) const;
        [[nodiscard]] reference operator[](std::size_t index);
 
        [[nodiscard]] reference front();
        [[nodiscard]] const_reference front() const;
 
        [[nodiscard]] reference back();
        [[nodiscard]] const_reference back() const;
 
        [[nodiscard]] const char32_t* data() const noexcept
        {
            return m_string.data();
        }
 
        [[nodiscard]] char32_t* data() noexcept
        {
            return m_string.data();
        }
 
        [[nodiscard]] const char32_t* c_str() const noexcept
        {
            return m_string.c_str();
        }
 
        [[nodiscard]] iterator begin() noexcept;
        [[nodiscard]] const_iterator begin() const noexcept;
        [[nodiscard]] const_iterator cbegin() const noexcept;
 
        [[nodiscard]] iterator end() noexcept;
        [[nodiscard]] const_iterator end() const noexcept;
        [[nodiscard]] const_iterator cend() const noexcept;
 
        [[nodiscard]] reverse_iterator rbegin() noexcept;
        [[nodiscard]] const_reverse_iterator rbegin() const noexcept;
        [[nodiscard]] const_reverse_iterator crbegin() const noexcept;
 
        [[nodiscard]] reverse_iterator rend() noexcept;
        [[nodiscard]] const_reverse_iterator rend() const noexcept;
        [[nodiscard]] const_reverse_iterator crend() const noexcept;
 
        [[nodiscard]] bool empty() const noexcept
        {
            return m_string.empty();
        }
 
        [[nodiscard]] std::size_t size() const noexcept
        {
            return m_string.size();
        }
 
        [[nodiscard]] std::size_t length() const noexcept
        {
            return m_string.length();
        }
 
        [[nodiscard]] std::size_t max_size() const noexcept;
 
        void reserve(std::size_t newCap);
        [[nodiscard]] std::size_t capacity() const noexcept;
        void shrink_to_fit();
 
        void clear() noexcept;
 
        String& insert(std::size_t index, std::size_t count, char ch);
        String& insert(std::size_t index, std::size_t count, wchar_t ch);
        String& insert(std::size_t index, std::size_t count, char16_t ch);
        String& insert(std::size_t index, std::size_t count, char32_t ch);
 
        String& insert(std::size_t index, StringView sv);
        String& insert(std::size_t index, const char32_t* str);
        String& insert(std::size_t index, const std::u32string& str);
        String& insert(std::size_t index, const String& str);
 
        String& insert(std::size_t index, StringView sv, std::size_t pos, std::size_t count = npos);
        String& insert(std::size_t index, const std::string& str, std::size_t pos, std::size_t count = npos);
        String& insert(std::size_t index, const std::wstring& str, std::size_t pos, std::size_t count = npos);
        String& insert(std::size_t index, const std::u16string& str, std::size_t pos, std::size_t count = npos);
        String& insert(std::size_t index, const std::u32string& str, std::size_t pos, std::size_t count = npos);
        String& insert(std::size_t index, const String& str, std::size_t pos, std::size_t count = npos);
 
        String& insert(std::size_t index, const char* str, std::size_t count);
        String& insert(std::size_t index, const wchar_t* str, std::size_t count);
        String& insert(std::size_t index, const char16_t* str, std::size_t count);
        String& insert(std::size_t index, const char32_t* str, std::size_t count);
 
        iterator insert(const_iterator pos, char ch);
        iterator insert(const_iterator pos, wchar_t ch);
        iterator insert(const_iterator pos, char16_t ch);
        iterator insert(const_iterator pos, char32_t ch);
 
        iterator insert(const_iterator pos, std::size_t count, char ch);
        iterator insert(const_iterator pos, std::size_t count, wchar_t ch);
        iterator insert(const_iterator pos, std::size_t count, char16_t ch);
        iterator insert(const_iterator pos, std::size_t count, char32_t ch);
 
        iterator insert(const_iterator pos, std::initializer_list<char> chars);
        iterator insert(const_iterator pos, std::initializer_list<wchar_t> chars);
        iterator insert(const_iterator pos, std::initializer_list<char16_t> chars);
        iterator insert(const_iterator pos, std::initializer_list<char32_t> chars);
 
        iterator insert(const_iterator pos, std::string::const_iterator first, std::string::const_iterator last);
        iterator insert(const_iterator pos, std::wstring::const_iterator first, std::wstring::const_iterator last);
        iterator insert(const_iterator pos, std::u16string::const_iterator first, std::u16string::const_iterator last);
 
        template <typename IteratorType, typename = IsU32Iterator<IteratorType>>
        String& insert(const_iterator pos, IteratorType first, IteratorType last)
        {
            m_string.insert(pos, first, last);
            return *this;
        }
 
        String& erase(std::size_t index = 0, std::size_t count = npos);
 
        iterator erase(const_iterator position);
        iterator erase(const_iterator first, const_iterator last);
 
        void push_back(char ch);
        void push_back(wchar_t ch);
        void push_back(char16_t ch);
        void push_back(char32_t ch);
 
        void pop_back();
 
        String& append(std::size_t count, char ch);
        String& append(std::size_t count, wchar_t ch);
        String& append(std::size_t count, char16_t ch);
        String& append(std::size_t count, char32_t ch);
 
        String& append(StringView sv);
        String& append(const char32_t* str);
        String& append(const std::u32string& str);
        String& append(const String& str);
 
        String& append(StringView sv, std::size_t pos, std::size_t count = npos);
        String& append(const std::string& str, std::size_t pos, std::size_t count = npos);
        String& append(const std::wstring& str, std::size_t pos, std::size_t count = npos);
        String& append(const std::u16string& str, std::size_t pos, std::size_t count = npos);
        String& append(const std::u32string& str, std::size_t pos, std::size_t count = npos);
        String& append(const String& str, std::size_t pos, std::size_t count = npos);
 
        String& append(const char* str, std::size_t count);
        String& append(const wchar_t* str, std::size_t count);
        String& append(const char16_t* str, std::size_t count);
        String& append(const char32_t* str, std::size_t count);
 
        String& append(std::string::const_iterator first, std::string::const_iterator last);
        String& append(std::wstring::const_iterator first, std::wstring::const_iterator last);
        String& append(std::u16string::const_iterator first, std::u16string::const_iterator last);
 
        template <typename IteratorType, typename = IsU32Iterator<IteratorType>>
        String& append(IteratorType first, IteratorType last)
        {
            m_string.append(first, last);
            return *this;
        }
 
        String& append(std::initializer_list<char> chars);
        String& append(std::initializer_list<wchar_t> chars);
        String& append(std::initializer_list<char16_t> chars);
        String& append(std::initializer_list<char32_t> chars);
 
        String& operator+=(const String& str);
 
        [[nodiscard]] int compare(StringView sv) const noexcept;
        [[nodiscard]] int compare(const char32_t* s) const;
        [[nodiscard]] int compare(const std::u32string& str) const noexcept;
        [[nodiscard]] int compare(const String& str) const noexcept;
 
        [[nodiscard]] int compare(std::size_t pos1, std::size_t count1, StringView sv) const;
        [[nodiscard]] int compare(std::size_t pos1, std::size_t count1, const char32_t* s) const;
        [[nodiscard]] int compare(std::size_t pos1, std::size_t count1, const std::u32string& str) const;
        [[nodiscard]] int compare(std::size_t pos1, std::size_t count1, const String& str) const;
 
        [[nodiscard]] int compare(std::size_t pos1, std::size_t count1, StringView sv, std::size_t pos2, std::size_t count2 = npos) const;
        [[nodiscard]] int compare(std::size_t pos1,
                                  std::size_t count1,
                                  const std::string& str,
                                  std::size_t pos2,
                                  std::size_t count2 = npos) const;
        [[nodiscard]] int compare(std::size_t pos1,
                                  std::size_t count1,
                                  const std::wstring& str,
                                  std::size_t pos2,
                                  std::size_t count2 = npos) const;
        [[nodiscard]] int compare(std::size_t pos1,
                                  std::size_t count1,
                                  const std::u16string& str,
                                  std::size_t pos2,
                                  std::size_t count2 = npos) const;
        [[nodiscard]] int compare(std::size_t pos1,
                                  std::size_t count1,
                                  const std::u32string& str,
                                  std::size_t pos2,
                                  std::size_t count2 = npos) const;
        [[nodiscard]] int compare(std::size_t pos1, std::size_t count1, const String& str, std::size_t pos2, std::size_t count2 = npos) const;
 
        [[nodiscard]] int compare(std::size_t pos1, std::size_t count1, const char* s, std::size_t count2) const;
        [[nodiscard]] int compare(std::size_t pos1, std::size_t count1, const wchar_t* s, std::size_t count2) const;
        [[nodiscard]] int compare(std::size_t pos1, std::size_t count1, const char16_t* s, std::size_t count2) const;
        [[nodiscard]] int compare(std::size_t pos1, std::size_t count1, const char32_t* s, std::size_t count2) const;
 
        String& replace(std::size_t pos, std::size_t count, StringView sv);
        String& replace(std::size_t pos, std::size_t count, const char32_t* cstr);
        String& replace(std::size_t pos, std::size_t count, const std::u32string& str);
        String& replace(std::size_t pos, std::size_t count, const String& str);
 
        String& replace(const_iterator first, const_iterator last, StringView sv);
        String& replace(const_iterator first, const_iterator last, const char32_t* cstr);
        String& replace(const_iterator first, const_iterator last, const std::u32string& str);
        String& replace(const_iterator first, const_iterator last, const String& str);
 
        String& replace(std::size_t pos, std::size_t count, StringView sv, std::size_t pos2, std::size_t count2 = npos);
        String& replace(std::size_t pos, std::size_t count, const std::string& str, std::size_t pos2, std::size_t count2 = npos);
        String& replace(std::size_t pos, std::size_t count, const std::wstring& str, std::size_t pos2, std::size_t count2 = npos);
        String& replace(std::size_t pos, std::size_t count, const std::u16string& str, std::size_t pos2, std::size_t count2 = npos);
        String& replace(std::size_t pos, std::size_t count, const std::u32string& str, std::size_t pos2, std::size_t count2 = npos);
        String& replace(std::size_t pos, std::size_t count, const String& str, std::size_t pos2, std::size_t count2 = npos);
 
        String& replace(const_iterator first, const_iterator last, std::string::const_iterator first2, std::string::const_iterator last2);
        String& replace(const_iterator first, const_iterator last, std::wstring::const_iterator first2, std::wstring::const_iterator last2);
        String& replace(const_iterator first,
                        const_iterator last,
                        std::u16string::const_iterator first2,
                        std::u16string::const_iterator last2);
 
        template <typename IteratorType, typename = IsU32Iterator<IteratorType>>
        String& replace(const_iterator first, const_iterator last, IteratorType first2, IteratorType last2)
        {
            m_string.replace(first, last, first2, last2);
            return *this;
        }
 
        String& replace(std::size_t pos, std::size_t count, const char* cstr, std::size_t count2);
        String& replace(std::size_t pos, std::size_t count, const wchar_t* cstr, std::size_t count2);
        String& replace(std::size_t pos, std::size_t count, const char16_t* cstr, std::size_t count2);
        String& replace(std::size_t pos, std::size_t count, const char32_t* cstr, std::size_t count2);
 
        String& replace(const_iterator first, const_iterator last, const char* cstr, std::size_t count2);
        String& replace(const_iterator first, const_iterator last, const wchar_t* cstr, std::size_t count2);
        String& replace(const_iterator first, const_iterator last, const char16_t* cstr, std::size_t count2);
        String& replace(const_iterator first, const_iterator last, const char32_t* cstr, std::size_t count2);
 
        String& replace(std::size_t pos, std::size_t count, std::size_t count2, char ch);
        String& replace(std::size_t pos, std::size_t count, std::size_t count2, wchar_t ch);
        String& replace(std::size_t pos, std::size_t count, std::size_t count2, char16_t ch);
        String& replace(std::size_t pos, std::size_t count, std::size_t count2, char32_t ch);
 
        String& replace(const_iterator first, const_iterator last, std::size_t count2, char ch);
        String& replace(const_iterator first, const_iterator last, std::size_t count2, wchar_t ch);
        String& replace(const_iterator first, const_iterator last, std::size_t count2, char16_t ch);
        String& replace(const_iterator first, const_iterator last, std::size_t count2, char32_t ch);
 
        String& replace(const_iterator first, const_iterator last, std::initializer_list<char> chars);
        String& replace(const_iterator first, const_iterator last, std::initializer_list<wchar_t> chars);
        String& replace(const_iterator first, const_iterator last, std::initializer_list<char16_t> chars);
        String& replace(const_iterator first, const_iterator last, std::initializer_list<char32_t> chars);
 
        [[nodiscard]] String substr(std::size_t pos = 0, std::size_t count = npos) const;
 
        std::size_t copy(char32_t* dest, std::size_t count, std::size_t pos = 0) const;
 
        void resize(std::size_t count);
        void resize(std::size_t count, char ch);
        void resize(std::size_t count, wchar_t ch);
        void resize(std::size_t count, char16_t ch);
        void resize(std::size_t count, char32_t ch);
 
        void swap(String& other) noexcept;
 
        [[nodiscard]] bool contains(char c) const noexcept;
        [[nodiscard]] bool contains(wchar_t c) const noexcept;
        [[nodiscard]] bool contains(char16_t c) const noexcept;
        [[nodiscard]] bool contains(char32_t c) const noexcept;
 
        [[nodiscard]] bool contains(StringView sv) const noexcept;
        [[nodiscard]] bool contains(const char32_t* s) const;
        [[nodiscard]] bool contains(const std::u32string& s) const;
        [[nodiscard]] bool contains(const String& s) const;
 
        [[nodiscard]] std::size_t find(StringView sv, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find(const char32_t* s, std::size_t pos = 0) const;
        [[nodiscard]] std::size_t find(const std::u32string& str, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find(const String& str, std::size_t pos = 0) const noexcept;
 
        [[nodiscard]] std::size_t find(const char* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find(const wchar_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find(const char16_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find(const char32_t* s, std::size_t pos, std::size_t count) const;
 
        [[nodiscard]] std::size_t find(char ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find(wchar_t ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find(char16_t ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find(char32_t ch, std::size_t pos = 0) const noexcept;
 
        [[nodiscard]] std::size_t find_first_of(StringView sv, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find_first_of(const char32_t* s, std::size_t pos = 0) const;
        [[nodiscard]] std::size_t find_first_of(const std::u32string& str, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find_first_of(const String& str, std::size_t pos = 0) const noexcept;
 
        [[nodiscard]] std::size_t find_first_of(const char* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_first_of(const wchar_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_first_of(const char16_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_first_of(const char32_t* s, std::size_t pos, std::size_t count) const;
 
        [[nodiscard]] std::size_t find_first_of(char ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find_first_of(wchar_t ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find_first_of(char16_t ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find_first_of(char32_t ch, std::size_t pos = 0) const noexcept;
 
        [[nodiscard]] std::size_t find_first_not_of(StringView sv, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find_first_not_of(const char32_t* s, std::size_t pos = 0) const;
        [[nodiscard]] std::size_t find_first_not_of(const std::u32string& str, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find_first_not_of(const String& str, std::size_t pos = 0) const noexcept;
 
        [[nodiscard]] std::size_t find_first_not_of(const char* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_first_not_of(const wchar_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_first_not_of(const char16_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_first_not_of(const char32_t* s, std::size_t pos, std::size_t count) const;
 
        [[nodiscard]] std::size_t find_first_not_of(char ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find_first_not_of(wchar_t ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find_first_not_of(char16_t ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t find_first_not_of(char32_t ch, std::size_t pos = 0) const noexcept;
 
        [[nodiscard]] std::size_t rfind(StringView sv, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t rfind(const char32_t* s, std::size_t pos = npos) const;
        [[nodiscard]] std::size_t rfind(const std::u32string& str, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t rfind(const String& str, std::size_t pos = npos) const noexcept;
 
        [[nodiscard]] std::size_t rfind(const char* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t rfind(const wchar_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t rfind(const char16_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t rfind(const char32_t* s, std::size_t pos, std::size_t count) const;
 
        [[nodiscard]] std::size_t rfind(char ch, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t rfind(wchar_t ch, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t rfind(char16_t ch, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t rfind(char32_t ch, std::size_t pos = npos) const noexcept;
 
        [[nodiscard]] std::size_t find_last_of(StringView sv, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t find_last_of(const char32_t* s, std::size_t pos = npos) const;
        [[nodiscard]] std::size_t find_last_of(const std::u32string& str, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t find_last_of(const String& str, std::size_t pos = npos) const noexcept;
 
        [[nodiscard]] std::size_t find_last_of(const char* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_last_of(const wchar_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_last_of(const char16_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_last_of(const char32_t* s, std::size_t pos, std::size_t count) const;
 
        [[nodiscard]] std::size_t find_last_of(char ch, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t find_last_of(wchar_t ch, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t find_last_of(char16_t ch, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t find_last_of(char32_t ch, std::size_t pos = npos) const noexcept;
 
        [[nodiscard]] std::size_t find_last_not_of(StringView sv, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t find_last_not_of(const char32_t* s, std::size_t pos = npos) const;
        [[nodiscard]] std::size_t find_last_not_of(const std::u32string& str, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t find_last_not_of(const String& str, std::size_t pos = npos) const noexcept;
 
        [[nodiscard]] std::size_t find_last_not_of(const char* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_last_not_of(const wchar_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_last_not_of(const char16_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] std::size_t find_last_not_of(const char32_t* s, std::size_t pos, std::size_t count) const;
 
        [[nodiscard]] std::size_t find_last_not_of(char ch, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t find_last_not_of(wchar_t ch, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t find_last_not_of(char16_t ch, std::size_t pos = npos) const noexcept;
        [[nodiscard]] std::size_t find_last_not_of(char32_t ch, std::size_t pos = npos) const noexcept;
 
        [[nodiscard]] inline bool starts_with(StringView sv) const noexcept;
        [[nodiscard]] inline bool starts_with(const char32_t* s) const;
        [[nodiscard]] inline bool starts_with(const std::u32string& s) const;
        [[nodiscard]] inline bool starts_with(const String& s) const;
 
        [[nodiscard]] inline bool starts_with(char ch) const noexcept;
        [[nodiscard]] inline bool starts_with(wchar_t ch) const noexcept;
        [[nodiscard]] inline bool starts_with(char16_t ch) const noexcept;
        [[nodiscard]] inline bool starts_with(char32_t ch) const noexcept;
 
        [[nodiscard]] inline bool ends_with(StringView sv) const noexcept;
        [[nodiscard]] inline bool ends_with(const char32_t* s) const;
        [[nodiscard]] inline bool ends_with(const std::u32string& s) const;
        [[nodiscard]] inline bool ends_with(const String& s) const;
 
        [[nodiscard]] inline bool ends_with(char ch) const noexcept;
        [[nodiscard]] inline bool ends_with(wchar_t ch) const noexcept;
        [[nodiscard]] inline bool ends_with(char16_t ch) const noexcept;
        [[nodiscard]] inline bool ends_with(char32_t ch) const noexcept;
 
        [[nodiscard]] std::size_t count(char ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t count(wchar_t ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t count(char16_t ch, std::size_t pos = 0) const noexcept;
        [[nodiscard]] std::size_t count(char32_t ch, std::size_t pos = 0) const noexcept;
 
        inline friend bool operator==(const String& left, StringView right);
        inline friend bool operator==(const String& left, const char32_t* right);
        inline friend bool operator==(const String& left, const std::u32string& right);
        inline friend bool operator==(const String& left, const String& right);
 
        inline friend bool operator!=(const String& left, StringView right);
        inline friend bool operator!=(const String& left, const char32_t* right);
        inline friend bool operator!=(const String& left, const std::u32string& right);
        inline friend bool operator!=(const String& left, const String& right);
 
        inline friend bool operator<(const String& left, StringView right);
        inline friend bool operator<(const String& left, const char32_t* right);
        inline friend bool operator<(const String& left, const std::u32string& right);
        inline friend bool operator<(const String& left, const String& right);
 
        inline friend bool operator<=(const String& left, StringView right);
        inline friend bool operator<=(const String& left, const char32_t* right);
        inline friend bool operator<=(const String& left, const std::u32string& right);
        inline friend bool operator<=(const String& left, const String& right);
 
        inline friend bool operator>(const String& left, StringView right);
        inline friend bool operator>(const String& left, const char32_t* right);
        inline friend bool operator>(const String& left, const std::u32string& right);
        inline friend bool operator>(const String& left, const String& right);
 
        inline friend bool operator>=(const String& left, StringView right);
        inline friend bool operator>=(const String& left, const char32_t* right);
        inline friend bool operator>=(const String& left, const std::u32string& right);
        inline friend bool operator>=(const String& left, const String& right);
 
        inline friend String operator+(const String& left, const String& right);
        inline friend String operator+(const String& left, String&& right);
        inline friend String operator+(String&& left, const String& right);
        inline friend String operator+(String&& left, String&& right);
 
#if defined(__cpp_lib_char8_t) && (__cpp_lib_char8_t >= 201811L)
        inline String(const std::u8string& str);
        inline String(char8_t utfChar);
        inline String(const char8_t* str);
        inline String(std::size_t count, char8_t ch);
        inline String(const std::u8string& str, std::size_t pos);
        inline String(const std::u8string& str, std::size_t pos, std::size_t count);
        inline String(const char8_t* str, std::size_t count);
        inline explicit String(std::initializer_list<char8_t> chars);
        inline explicit String(std::u8string::const_iterator first, std::u8string::const_iterator last);
 
        inline explicit operator std::u8string() const;
 
        [[nodiscard]] inline std::u8string toUtf8() const;
 
        inline String& assign(std::size_t count, char8_t ch);
        inline String& assign(const std::u8string& str, std::size_t pos, std::size_t count = npos);
        inline String& assign(const char8_t* str, std::size_t count);
        inline String& assign(std::initializer_list<char8_t> chars);
        inline String& assign(std::u8string::const_iterator first, std::u8string::const_iterator last);
 
        inline String& insert(std::size_t index, std::size_t count, char8_t ch);
        inline String& insert(std::size_t index, const std::u8string& str, std::size_t pos, std::size_t count = npos);
        inline String& insert(std::size_t index, const char8_t* str, std::size_t count);
        inline iterator insert(const_iterator pos, char8_t ch);
        inline iterator insert(const_iterator pos, std::size_t count, char8_t ch);
        inline iterator insert(const_iterator pos, std::initializer_list<char8_t> chars);
        inline iterator insert(const_iterator pos, std::u8string::const_iterator first, std::u8string::const_iterator last);
 
        inline String& append(std::size_t count, char8_t ch);
        inline String& append(const std::u8string& str, std::size_t pos, std::size_t count = npos);
        inline String& append(const char8_t* str, std::size_t count);
        inline String& append(std::initializer_list<char8_t> chars);
        inline String& append(std::u8string::const_iterator first, std::u8string::const_iterator last);
 
        [[nodiscard]] inline int compare(std::size_t pos1,
                                         std::size_t count1,
                                         const std::u8string& str,
                                         std::size_t pos2,
                                         std::size_t count2 = npos) const;
        [[nodiscard]] inline int compare(std::size_t pos1, std::size_t count1, const char8_t* s, std::size_t count2) const;
 
        inline String& replace(std::size_t pos, std::size_t count, const std::u8string& str, std::size_t pos2, std::size_t count2 = npos);
        inline String& replace(const_iterator first,
                               const_iterator last,
                               std::u8string::const_iterator first2,
                               std::u8string::const_iterator last2);
        inline String& replace(std::size_t pos, std::size_t count, const char8_t* cstr, std::size_t count2);
        inline String& replace(const_iterator first, const_iterator last, const char8_t* cstr, std::size_t count2);
        inline String& replace(std::size_t pos, std::size_t count, std::size_t count2, char8_t ch);
        inline String& replace(const_iterator first, const_iterator last, std::size_t count2, char8_t ch);
        inline String& replace(const_iterator first, const_iterator last, std::initializer_list<char8_t> chars);
 
        inline void resize(std::size_t count, char8_t ch);
 
        [[nodiscard]] inline bool contains(char8_t c) const noexcept;
 
        [[nodiscard]] inline std::size_t find(const char8_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] inline std::size_t find(char8_t ch, std::size_t pos = 0) const noexcept;
 
        [[nodiscard]] inline std::size_t find_first_of(const char8_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] inline std::size_t find_first_of(char8_t ch, std::size_t pos = 0) const noexcept;
 
        [[nodiscard]] inline std::size_t find_first_not_of(const char8_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] inline std::size_t find_first_not_of(char8_t ch, std::size_t pos = 0) const noexcept;
 
        [[nodiscard]] inline std::size_t rfind(const char8_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] inline std::size_t rfind(char8_t ch, std::size_t pos = npos) const noexcept;
 
        [[nodiscard]] inline std::size_t find_last_of(const char8_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] inline std::size_t find_last_of(char8_t ch, std::size_t pos = npos) const noexcept;
 
        [[nodiscard]] inline std::size_t find_last_not_of(const char8_t* s, std::size_t pos, std::size_t count) const;
        [[nodiscard]] inline std::size_t find_last_not_of(char8_t ch, std::size_t pos = npos) const noexcept;
 
        [[nodiscard]] inline bool starts_with(char8_t ch) const noexcept;
        [[nodiscard]] inline bool ends_with(char8_t ch) const noexcept;
#endif
    };

 
    inline bool String::starts_with(StringView sv) const noexcept
    {
        return viewStartsWith(StringView(m_string), sv);
    }
 
    inline bool String::starts_with(const char32_t* s) const
    {
        return viewStartsWith(StringView(m_string), StringView(s));
    }
 
    inline bool String::starts_with(const std::u32string& s) const
    {
        return viewStartsWith(StringView(m_string), StringView(s));
    }
 
    inline bool String::starts_with(const String& s) const
    {
        return viewStartsWith(StringView(m_string), StringView(s));
    }
 
    inline bool String::starts_with(char ch) const noexcept
    {
        return viewStartsWith(StringView(m_string), static_cast<char32_t>(ch));
    }
 
    inline bool String::starts_with(wchar_t ch) const noexcept
    {
        return viewStartsWith(StringView(m_string), static_cast<char32_t>(ch));
    }
 
    inline bool String::starts_with(char16_t ch) const noexcept
    {
        return viewStartsWith(StringView(m_string), static_cast<char32_t>(ch));
    }
 
    inline bool String::starts_with(char32_t ch) const noexcept
    {
        return viewStartsWith(StringView(m_string), ch);
    }
 
    inline bool String::ends_with(StringView sv) const noexcept
    {
        return viewEndsWith(StringView(m_string), sv);
    }
 
    inline bool String::ends_with(const char32_t* s) const
    {
        return viewEndsWith(StringView(m_string), StringView(s));
    }
 
    inline bool String::ends_with(const std::u32string& s) const
    {
        return viewEndsWith(StringView(m_string), StringView(s));
    }
 
    inline bool String::ends_with(const String& s) const
    {
        return viewEndsWith(StringView(m_string), StringView(s));
    }
 
    inline bool String::ends_with(char ch) const noexcept
    {
        return viewEndsWith(StringView(m_string), static_cast<char32_t>(ch));
    }
 
    inline bool String::ends_with(wchar_t ch) const noexcept
    {
        return viewEndsWith(StringView(m_string), static_cast<char32_t>(ch));
    }
 
    inline bool String::ends_with(char16_t ch) const noexcept
    {
        return viewEndsWith(StringView(m_string), static_cast<char32_t>(ch));
    }
 
    inline bool String::ends_with(char32_t ch) const noexcept
    {
        return viewEndsWith(StringView(m_string), ch);
    }
 
    [[nodiscard]] inline bool operator==(const String& left, StringView right)
    {
        return StringView(left) == right;
    }
 
    [[nodiscard]] inline bool operator==(const String& left, const char32_t* right)
    {
        return StringView(left) == right;
    }
 
    [[nodiscard]] inline bool operator==(const String& left, const std::u32string& right)
    {
        return StringView(left) == right;
    }
 
    [[nodiscard]] inline bool operator==(const String& left, const String& right)
    {
        return left.m_string == right.m_string;
    }
 
    [[nodiscard]] inline bool operator!=(const String& left, StringView right)
    {
        return StringView(left) != right;
    }
 
    [[nodiscard]] inline bool operator!=(const String& left, const char32_t* right)
    {
        return StringView(left) != right;
    }
 
    [[nodiscard]] inline bool operator!=(const String& left, const std::u32string& right)
    {
        return StringView(left) != right;
    }
 
    [[nodiscard]] inline bool operator!=(const String& left, const String& right)
    {
        return left.m_string != right.m_string;
    }
 
    [[nodiscard]] inline bool operator<(const String& left, StringView right)
    {
        return StringView(left) < right;
    }
 
    [[nodiscard]] inline bool operator<(const String& left, const char32_t* right)
    {
        return StringView(left) < right;
    }
 
    [[nodiscard]] inline bool operator<(const String& left, const std::u32string& right)
    {
        return StringView(left) < right;
    }
 
    [[nodiscard]] inline bool operator<(const String& left, const String& right)
    {
        return left.m_string < right.m_string;
    }
 
    [[nodiscard]] inline bool operator<=(const String& left, StringView right)
    {
        return StringView(left) <= right;
    }
 
    [[nodiscard]] inline bool operator<=(const String& left, const char32_t* right)
    {
        return StringView(left) <= right;
    }
 
    [[nodiscard]] inline bool operator<=(const String& left, const std::u32string& right)
    {
        return StringView(left) <= right;
    }
 
    [[nodiscard]] inline bool operator<=(const String& left, const String& right)
    {
        return left.m_string <= right.m_string;
    }
 
    [[nodiscard]] inline bool operator>(const String& left, StringView right)
    {
        return StringView(left) > right;
    }
 
    [[nodiscard]] inline bool operator>(const String& left, const char32_t* right)
    {
        return StringView(left) > right;
    }
 
    [[nodiscard]] inline bool operator>(const String& left, const std::u32string& right)
    {
        return StringView(left) > right;
    }
 
    [[nodiscard]] inline bool operator>(const String& left, const String& right)
    {
        return left.m_string > right.m_string;
    }
 
    [[nodiscard]] inline bool operator>=(const String& left, StringView right)
    {
        return StringView(left) >= right;
    }
 
    [[nodiscard]] inline bool operator>=(const String& left, const char32_t* right)
    {
        return StringView(left) >= right;
    }
 
    [[nodiscard]] inline bool operator>=(const String& left, const std::u32string& right)
    {
        return StringView(left) >= right;
    }
 
    [[nodiscard]] inline bool operator>=(const String& left, const String& right)
    {
        return left.m_string >= right.m_string;
    }
 
    [[nodiscard]] inline String operator+(const String& left, const String& right)
    {
        return {left.m_string + right.m_string};
    }
    [[nodiscard]] inline String operator+(String&& left, String&& right)
    {
        return {std::move(left.m_string) + std::move(right.m_string)};
    }
    [[nodiscard]] inline String operator+(String&& left, const String& right)
    {
        return {std::move(left.m_string) + right.m_string};
    }
    [[nodiscard]] inline String operator+(const String& left, String&& right)
    {
        return {left.m_string + std::move(right.m_string)};
    }
 
    // We don't provide operator<< implmentations for basic_ostream<charX_t> streams because
    // even clang 15 can't compile them when using libc++.
    // We could define them for VS, GCC and for clang with libstdc++, but there is no real use for them.
    TGUI_API std::ostream& operator<<(std::ostream& os, const String& str);
    TGUI_API std::wostream& operator<<(std::wostream& wos, const String& str);
 
    TGUI_API std::istream& operator>>(std::istream& is, String& str);
    TGUI_API std::wistream& operator>>(std::wistream& wis, String& str);
 
    // UTF-8 function are defined in the header so that they can be enabled/disabled based on
    // the compiler settings without having to recompile TGUI with a different C++ standard.
#if defined(__cpp_lib_char8_t) && (__cpp_lib_char8_t >= 201811L)
    inline String::String(const std::u8string& str) :
        m_string(utf::convertUtf8toUtf32(str.begin(), str.end()))
    {
    }
 
    inline String::String(char8_t utfChar) :
        m_string(1, static_cast<char32_t>(utfChar))
    {
    }
 
    inline String::String(const char8_t* str) :
        String{utf::convertUtf8toUtf32(str, str + std::char_traits<char8_t>::length(str))}
    {
    }
 
    inline String::String(std::size_t count, char8_t ch) :
        m_string(count, static_cast<char32_t>(ch))
    {
    }
 
    inline String::String(const std::u8string& str, std::size_t pos) :
        String{std::u8string(str, pos)}
    {
    }
 
    inline String::String(const std::u8string& str, std::size_t pos, std::size_t count) :
        String{std::u8string(str, pos, count)}
    {
    }
 
    inline String::String(const char8_t* str, std::size_t count) :
        String{std::u8string{str, count}}
    {
    }
 
    inline String::String(std::initializer_list<char8_t> chars) :
        String(std::u8string(chars.begin(), chars.end()))
    {
    }
 
    inline String::String(std::u8string::const_iterator first, std::u8string::const_iterator last) :
        String{std::u8string(first, last)}
    {
    }
 
    inline String::operator std::u8string() const
    {
        return utf::convertUtf32toUtf8(m_string);
    }
 
    inline std::u8string String::toUtf8() const
    {
        return utf::convertUtf32toUtf8(m_string);
    }
 
    inline String& String::assign(const std::u8string& str, std::size_t pos, std::size_t count)
    {
        m_string.assign(String{str, pos, count}.m_string);
        return *this;
    }
 
    inline String& String::assign(const char8_t* str, std::size_t count)
    {
        m_string.assign(String{str, count}.m_string);
        return *this;
    }
 
    inline String& String::assign(std::size_t count, char8_t ch)
    {
        m_string.assign(count, static_cast<char32_t>(ch));
        return *this;
    }
 
    inline String& String::assign(std::initializer_list<char8_t> chars)
    {
        m_string.assign(String{chars}.m_string);
        return *this;
    }
 
    inline String& String::assign(std::u8string::const_iterator first, std::u8string::const_iterator last)
    {
        m_string.assign(String{first, last}.m_string);
        return *this;
    }
 
    inline String& String::insert(std::size_t index, std::size_t count, char8_t ch)
    {
        m_string.insert(index, count, static_cast<char32_t>(ch));
        return *this;
    }
 
    inline String& String::insert(std::size_t index, const std::u8string& str, std::size_t pos, std::size_t count)
    {
        m_string.insert(index, String{str, pos, count}.m_string);
        return *this;
    }
 
    inline String& String::insert(std::size_t index, const char8_t* str, std::size_t count)
    {
        m_string.insert(index, String{str, count}.m_string);
        return *this;
    }
 
    inline String::iterator String::insert(String::const_iterator pos, char8_t ch)
    {
        return m_string.insert(pos, static_cast<char32_t>(ch));
    }
 
    inline String::iterator String::insert(String::const_iterator pos, std::size_t count, char8_t ch)
    {
        return m_string.insert(pos, count, static_cast<char32_t>(ch));
    }
 
    inline String::iterator String::insert(String::const_iterator pos, std::initializer_list<char8_t> chars)
    {
        const std::u32string tmpStr(utf::convertUtf8toUtf32(chars.begin(), chars.end()));
        return m_string.insert(pos, tmpStr.begin(), tmpStr.end());
    }
 
    inline String::iterator String::insert(String::const_iterator pos, std::u8string::const_iterator first, std::u8string::const_iterator last)
    {
        const std::u32string tmpStr(utf::convertUtf8toUtf32(first, last));
        return m_string.insert(pos, tmpStr.begin(), tmpStr.end());
    }
 
    inline String& String::append(std::size_t count, char8_t ch)
    {
        m_string.append(count, static_cast<char32_t>(ch));
        return *this;
    }
 
    inline String& String::append(const std::u8string& str, std::size_t pos, std::size_t count)
    {
        m_string.append(String{str, pos, count}.m_string);
        return *this;
    }
 
    inline String& String::append(const char8_t* str, std::size_t count)
    {
        m_string.append(String{str, count}.m_string);
        return *this;
    }
 
    inline String& String::append(std::initializer_list<char8_t> chars)
    {
        m_string.append(String{chars}.m_string);
        return *this;
    }
 
    inline String& String::append(std::u8string::const_iterator first, std::u8string::const_iterator last)
    {
        m_string.append(String{first, last}.m_string);
        return *this;
    }
 
    inline int String::compare(std::size_t pos1, std::size_t count1, const std::u8string& str, std::size_t pos2, std::size_t count2) const
    {
        return m_string.compare(pos1, count1, String{str, pos2, count2}.m_string);
    }
 
    inline int String::compare(std::size_t pos1, std::size_t count1, const char8_t* s, std::size_t count2) const
    {
        return m_string.compare(pos1, count1, String{s, count2}.m_string);
    }
 
    inline String& String::replace(std::size_t pos, std::size_t count, const std::u8string& str, std::size_t pos2, std::size_t count2)
    {
        m_string.replace(pos, count, String{str, pos2, count2}.m_string);
        return *this;
    }
 
    inline String& String::replace(const_iterator first,
                                   const_iterator last,
                                   std::u8string::const_iterator first2,
                                   std::u8string::const_iterator last2)
    {
        m_string.replace(first, last, String{first2, last2}.m_string);
        return *this;
    }
 
    inline String& String::replace(std::size_t pos, std::size_t count, const char8_t* cstr, std::size_t count2)
    {
        m_string.replace(pos, count, String{cstr, count2}.m_string);
        return *this;
    }
 
    inline String& String::replace(const_iterator first, const_iterator last, const char8_t* cstr, std::size_t count2)
    {
        m_string.replace(first, last, String{cstr, count2}.m_string);
        return *this;
    }
 
    inline String& String::replace(std::size_t pos, std::size_t count, std::size_t count2, char8_t ch)
    {
        m_string.replace(pos, count, String(count2, ch).m_string);
        return *this;
    }
 
    inline String& String::replace(const_iterator first, const_iterator last, std::size_t count2, char8_t ch)
    {
        m_string.replace(first, last, String(count2, ch).m_string);
        return *this;
    }
 
    inline String& String::replace(const_iterator first, const_iterator last, std::initializer_list<char8_t> chars)
    {
        m_string.replace(first, last, String{chars}.m_string);
        return *this;
    }
 
    inline void String::resize(std::size_t count, char8_t ch)
    {
        m_string.resize(count, static_cast<char32_t>(ch));
    }
 
    inline bool String::contains(char8_t c) const noexcept
    {
        return contains(static_cast<char32_t>(c));
    }
 
    inline std::size_t String::find(const char8_t* s, std::size_t pos, std::size_t count) const
    {
        return m_string.find(String{s, count}.m_string, pos);
    }
 
    inline std::size_t String::find(char8_t ch, std::size_t pos) const noexcept
    {
        return m_string.find(static_cast<char32_t>(ch), pos);
    }
 
    inline std::size_t String::find_first_of(const char8_t* s, std::size_t pos, std::size_t count) const
    {
        return m_string.find_first_of(String{s, count}.m_string, pos);
    }
 
    inline std::size_t String::find_first_of(char8_t ch, std::size_t pos) const noexcept
    {
        return m_string.find_first_of(static_cast<char32_t>(ch), pos);
    }
 
    inline std::size_t String::find_first_not_of(const char8_t* s, std::size_t pos, std::size_t count) const
    {
        return m_string.find_first_not_of(String{s, count}.m_string, pos);
    }
 
    inline std::size_t String::find_first_not_of(char8_t ch, std::size_t pos) const noexcept
    {
        return m_string.find_first_not_of(static_cast<char32_t>(ch), pos);
    }
 
    inline std::size_t String::rfind(const char8_t* s, std::size_t pos, std::size_t count) const
    {
        return m_string.rfind(String{s, count}.m_string, pos);
    }
 
    inline std::size_t String::rfind(char8_t ch, std::size_t pos) const noexcept
    {
        return m_string.rfind(static_cast<char32_t>(ch), pos);
    }
 
    inline std::size_t String::find_last_of(const char8_t* s, std::size_t pos, std::size_t count) const
    {
        return m_string.find_last_of(String{s, count}.m_string, pos);
    }
 
    inline std::size_t String::find_last_of(char8_t ch, std::size_t pos) const noexcept
    {
        return m_string.find_last_of(static_cast<char32_t>(ch), pos);
    }
 
    inline std::size_t String::find_last_not_of(const char8_t* s, std::size_t pos, std::size_t count) const
    {
        return m_string.find_last_not_of(String{s, count}.m_string, pos);
    }
 
    inline std::size_t String::find_last_not_of(char8_t ch, std::size_t pos) const noexcept
    {
        return m_string.find_last_not_of(static_cast<char32_t>(ch), pos);
    }
 
    inline bool String::starts_with(char8_t ch) const noexcept
    {
        return viewStartsWith(StringView(m_string), static_cast<char32_t>(ch));
    }
 
    inline bool String::ends_with(char8_t ch) const noexcept
    {
        return viewEndsWith(StringView(m_string), static_cast<char32_t>(ch));
    }
#endif
} // namespace tgui
 
#endif // TGUI_STRING_HPP