ustring.h

Go to the documentation of this file.

#pragma once

#define __XTD_CORE_INTERNAL__
#include "internal/__generic_stream_output.h"
#include "internal/__format_information.h"
#include "internal/__format_stringer.h"
#include "internal/__sprintf.h"
#undef __XTD_CORE_INTERNAL__

#include <string>
#include "icomparable.h"
#include "iequatable.h"
#include "string_comparison.h"
#include "string_split_options.h"
#include "types.h"
#include "object.h"
#include "parse.h"
#include "to_string.h"

#if !defined(_WIN32)
#include <cxxabi.h>
#endif

namespace xtd {
  class ustring;
}
template<typename ...args_t>
void __ustring_extract_format_arg(xtd::ustring& fmt, std::vector<__format_information<char>>& format, args_t&& ... args);
void __throw_ustring_format_exception();
void __throw_ustring_format_exception_close_bracket();
void __throw_ustring_format_exception_open_bracket();
void __throw_ustring_format_exception_start_colon();

namespace xtd {
  class ustring : public xtd::icomparable<ustring>, public object, public std::basic_string<char> {
  public:
    
    static ustring empty_string() noexcept;
    
    
    ustring() noexcept;
    explicit ustring(const allocator_type& allocator) noexcept;
    
    ustring(size_t count, value_type character);
    ustring(size_t count, value_type character, const allocator_type& allocator);
    ustring(size_t count, char8_t character);
    ustring(size_t count, char8_t character, const allocator_type& allocator);
    ustring(size_t count, char16_t character);
    ustring(size_t count, char16_t character, const allocator_type& allocator);
    ustring(size_t count, char32_t character);
    ustring(size_t count, char32_t character, const allocator_type& allocator);
    ustring(size_t count, wchar_t character);
    ustring(size_t count, wchar_t character, const allocator_type& allocator);
    
    ustring(const ustring& str, size_t index, size_t count);
    ustring(const ustring& str, size_t index, size_t count, const allocator_type& allocator);
    ustring(const ustring& str, size_t index);
    ustring(const ustring& str, size_t index, const allocator_type& allocator);
    
    ustring(const value_type* str, size_t count);
    ustring(const value_type* str, size_t count, const allocator_type& allocator);
    
    ustring(const value_type* str);
    ustring(const value_type* str, const allocator_type& allocator);
    
    ustring(value_type* str);
    ustring(value_type* str, const allocator_type& allocator);
    
    ustring(const ustring& str) noexcept;
    ustring(const ustring& str, const allocator_type& allocator) noexcept;
    
    ustring(const std::string& str) noexcept;
    ustring(const std::string& str, const allocator_type& allocator) noexcept;
    
    ustring(const std::u8string& str) noexcept;
    ustring(const std::u8string& str, const allocator_type& allocator) noexcept;
    
    ustring(const char8_t* str);
    ustring(const char8_t* str, const allocator_type& allocator);
    
    ustring(char8_t* str);
    ustring(char8_t* str, const allocator_type& allocator);
    
    ustring(const std::u16string& str) noexcept;
    ustring(const std::u16string& str, const allocator_type& allocator) noexcept;
    
    ustring(const char16_t* str);
    ustring(const char16_t* str, const allocator_type& allocator);
    
    ustring(char16_t* str);
    ustring(char16_t* str, const allocator_type& allocator);
    
    ustring(const std::u32string& str) noexcept;
    ustring(const std::u32string& str, const allocator_type& allocator) noexcept;
    
    ustring(const char32_t* str);
    ustring(const char32_t* str, const allocator_type& allocator);
    
    ustring(char32_t* str);
    ustring(char32_t* str, const allocator_type& allocator);
    
    ustring(const std::wstring& str) noexcept;
    ustring(const std::wstring& str, const allocator_type& allocator) noexcept;
    
    ustring(const wchar_t* str);
    ustring(const wchar_t* str, const allocator_type& allocator);
    
    ustring(wchar_t* str);
    ustring(wchar_t* str, const allocator_type& allocator);
    
    ustring(ustring&& str) noexcept;
    ustring(ustring&& str, const allocator_type& allocator) noexcept;
    
    template<typename input_iterator_t>
    ustring(input_iterator_t first, input_iterator_t last) : std::basic_string<value_type>(first, last) {}
    template<typename input_iterator_t>
    ustring(input_iterator_t first, input_iterator_t last, const allocator_type& allocator) : std::basic_string<value_type>(first, last, allocator) {}
    
    ustring(std::initializer_list<value_type> il);
    ustring(std::initializer_list<value_type> il, const allocator_type& allocator);
    
    ustring(std::initializer_list<char8_t> il);
    ustring(std::initializer_list<char8_t> il, const allocator_type& allocator);
    
    ustring(std::initializer_list<char16_t> il);
    ustring(std::initializer_list<char16_t> il, const allocator_type& allocator);
    
    ustring(std::initializer_list<char32_t> il);
    ustring(std::initializer_list<char32_t> il, const allocator_type& allocator);
    
    ustring(std::initializer_list<wchar_t> il);
    ustring(std::initializer_list<wchar_t> il, const allocator_type& allocator);
    
    /*
    template<typename type_t>
    ustring(const type_t& object) : std::basic_string<value_type>(object) {}
    template<typename type_t>
    ustring(const type_t& object, const allocator_type& allocator) : std::basic_string<value_type>(object, allocator) {}
    template<typename type_t>
    ustring(const type_t& object, size_t index, size_t count) : std::basic_string<value_type>(object, index, count) {}
    template<typename type_t>
    ustring(const type_t& object, size_t index, size_t count, const allocator_type& allocator) : std::basic_string<value_type>(object, index, count, allocator) {}
    template<typename type_t>
    ustring(const type_t& object, size_t count) : std::basic_string<value_type>(object, 0, count) {}
    template<typename type_t>
    ustring(const type_t& object, size_t count, const allocator_type& allocator) : std::basic_string<value_type>(object, 0, count, allocator) {}
     */
    
    ustring& operator=(const ustring& str);
    ustring& operator=(const std::string& str);
    ustring& operator=(const value_type* str);
    ustring& operator=(const std::u8string& str);
    ustring& operator=(const char8_t* str);
    ustring& operator=(const std::u16string& str);
    ustring& operator=(const char16_t* str);
    ustring& operator=(const std::u32string& str);
    ustring& operator=(const char32_t* str);
    ustring& operator=(const std::wstring& str);
    ustring& operator=(const wchar_t* str);
    ustring& operator=(ustring&& str) noexcept;
    
    ustring& operator=(value_type character);
    ustring& operator=(char8_t character);
    ustring& operator=(char16_t character);
    ustring& operator=(char32_t character);
    ustring& operator=(wchar_t character);
    ustring& operator=(const std::initializer_list<value_type>& il);
    ustring& operator=(const std::initializer_list<char8_t>& il);
    ustring& operator=(const std::initializer_list<char16_t>& il);
    ustring& operator=(const std::initializer_list<char32_t>& il);
    ustring& operator=(const std::initializer_list<wchar_t>& il);
    //template<typename type_t>
    //ustring& operator=(const type_t& object) {return std::basic_string<value_type>::assign(object);}
    
    template<typename type_t>
    ustring operator+(const type_t& object) const {
      ustring result(*this);
      result.append(object);
      return result;
    }
    
    ustring& operator+=(const ustring& str);
    ustring& operator+=(const std::string& str);
    ustring& operator+=(const value_type* str);
    ustring& operator+=(const std::u8string& str);
    ustring& operator+=(const char8_t* str);
    ustring& operator+=(const std::u16string& str);
    ustring& operator+=(const char16_t* str);
    ustring& operator+=(const std::u32string& str);
    ustring& operator+=(const char32_t* str);
    ustring& operator+=(const std::wstring& str);
    ustring& operator+=(const wchar_t* str);
    ustring& operator+=(value_type character);
    ustring& operator+=(char8_t character);
    ustring& operator+=(char16_t character);
    ustring& operator+=(char32_t character);
    ustring& operator+=(wchar_t character);
    ustring& operator+=(const std::initializer_list<value_type>& il);
    ustring& operator+=(const std::initializer_list<char8_t>& il);
    ustring& operator+=(const std::initializer_list<char16_t>& il);
    ustring& operator+=(const std::initializer_list<char32_t>& il);
    ustring& operator+=(const std::initializer_list<wchar_t>& il);
    template<typename type_t>
    ustring& operator+=(const type_t& object) {
      *this = *this + ustring(object);
      return *this;
    }
    
    bool operator==(const ustring& other) const;
    bool operator!=(const ustring& other) const;
    bool operator==(const std::string& other) const;
    bool operator!=(const std::string& other) const;
    bool operator==(const value_type* other) const;
    bool operator!=(const value_type* other) const;
    bool operator==(const std::u8string& other) const;
    bool operator!=(const std::u8string& other) const;
    bool operator==(const char8_t* other) const;
    bool operator!=(const char8_t* other) const;
    bool operator==(const std::u16string& other) const;
    bool operator!=(const std::u16string& other) const;
    bool operator==(const char16_t* other) const;
    bool operator!=(const char16_t* other) const;
    bool operator==(const std::u32string& other) const;
    bool operator!=(const std::u32string& other) const;
    bool operator==(const char32_t* other) const;
    bool operator!=(const char32_t* other) const;
    bool operator==(const std::wstring& other) const;
    bool operator!=(const std::wstring& other) const;
    bool operator==(const wchar_t* other) const;
    bool operator!=(const wchar_t* other) const;
    const value_type& operator[](size_t index);
    const value_type& operator[](size_t index) const;
    ustring substr(size_type index = 0, size_type count = npos) const;
    
    
    template<typename object_t>
    static ustring full_class_name() {return demangle(typeid(object_t).name());}
    
    template<typename object_t>
    static ustring full_class_name(const object_t& object) {return demangle(typeid(object).name());}
    
    static ustring full_class_name(const std::type_info& info) {return demangle(info.name());}
    
    template<typename object_t>
    static ustring class_name() {return get_class_name(full_class_name<object_t>());}
    
    template<typename object_t>
    static ustring class_name(const object_t& object) {return get_class_name(full_class_name(object));}
    
    static ustring class_name(const std::type_info& info) {return get_class_name(full_class_name(info));}
    
    using std::basic_string<value_type>::compare;
    static int compare(const ustring& str_a, const ustring& str_b) noexcept;
    static int compare(const ustring& str_a, const ustring& str_b, bool ignore_case) noexcept;
    
    static int compare(const ustring& str_a, const ustring& str_b, xtd::string_comparison comparison_type) noexcept;
    static int compare(const ustring& str_a, size_t index_a, const ustring& str_b, size_t index_b, size_t length) noexcept;
    static int compare(const ustring& str_a, size_t index_a, const ustring& str_b, size_t index_b, size_t length, bool ignore_case) noexcept;
    static int compare(const ustring& str_a, size_t index_a, const ustring& str_b, size_t index_b, size_t length, xtd::string_comparison comparison_type) noexcept;
    
    int32_t compare_to(const ustring& tzi) const noexcept override;
    int32_t compare_to(const object& obj) const noexcept override;
    
    static ustring concat(const ustring& str_a, const ustring& str_b, const ustring& str_c, const ustring& str_d) noexcept;
    
    template<typename object_a_t, typename object_b_t, typename object_c_t, typename object_d_t>
    static ustring concat(object_a_t obj_a, object_b_t obj_b, object_c_t obj_c, object_d_t obj_d) noexcept {
      return format("{}{}{}{}", obj_a, obj_b, obj_c, obj_d);
    }
    
    static ustring concat(const ustring& str_a, const ustring& str_b, const ustring& str_c) noexcept;
    
    template<typename object_a_t, typename object_b_t, typename object_c_t>
    static ustring concat(object_a_t obj_a, object_b_t obj_b, object_c_t obj_c) noexcept {
      return format("{}{}{}", obj_a, obj_b, obj_c);
    }
    
    static ustring concat(const ustring& str_a, const ustring& str_b) noexcept;
    
    template<typename object_a_t, typename object_b_t>
    static ustring concat(object_a_t obj_a, object_b_t obj_b) noexcept {
      return format("{}{}", obj_a, obj_b);
    }
    
    static ustring concat(const std::vector<ustring>& values) noexcept;
    
    static ustring concat(const std::vector<const value_type*>& values) noexcept;
    static ustring concat(const std::vector<const char8_t*>& values) noexcept;
    static ustring concat(const std::initializer_list<ustring>& values) noexcept;
    static ustring concat(const std::initializer_list<const value_type*>& values) noexcept;
    static ustring concat(const std::initializer_list<const char8_t*>& values) noexcept;
    
    template<typename object_t>
    static ustring concat(const std::vector<object_t>& args) noexcept {
      ustring result;
      for (const auto& arg : args)
        result += format("{}", arg);
      return result;
    }
    
    template<typename object_t>
    static ustring concat(const std::initializer_list<object_t>& args) noexcept {
      ustring result;
      for (const auto& arg : args)
        result += format("{}", arg);
      return result;
    }
    
    template<typename value_t>
    static ustring concat(value_t value) noexcept {
      return format("{}", value);
    }
    
    static ustring demangle(const ustring& name) {
      #if defined(_WIN32)
      ustring result = name;
      for (auto& item : {"enum ", "class ", "union ", "struct "})
        result = result.replace(item, "");
      return result;
      #else
      class auto_delete_char_pointer {
      public:
        auto_delete_char_pointer(char* value) : value_(value) {}
        ~auto_delete_char_pointer() {free(value_);}
        char* operator()() const {return value_;}
      private:
        char* value_;
      };
      int32_t status = 0;
      return auto_delete_char_pointer(abi::__cxa_demangle(name.c_str(), 0, 0, &status))();
      #endif
    }
    
    bool contains(const ustring& value) const noexcept;
    
    bool equals(const ustring& tzi) const noexcept;
    bool equals(const object& obj) const noexcept override;
    
    bool ends_with(value_type value) const noexcept;
    
    bool ends_with(char8_t value) const noexcept;
    
    bool ends_with(const ustring& value) const noexcept;
    
    bool ends_with(const ustring& value, bool ignore_case) const noexcept;
    
    bool ends_with(const ustring& value, xtd::string_comparison comparison_type) const noexcept;
    
    template<typename ...args_t>
    static ustring format(const ustring& fmt, args_t&& ... args) {
      ustring result;
      size_t index = 0;
      std::vector<__format_information<char>> formats;
      auto begin_format_iterator =  fmt.end();
      auto end_format_iterator =  fmt.end();
      for (auto iterator = fmt.begin(); iterator != fmt.end(); ++iterator) {
        if (*iterator == '{') {
          if (++iterator == fmt.end())
            __throw_ustring_format_exception_open_bracket();
          if (*iterator == '{')
            result += *iterator;
          else {
            begin_format_iterator = iterator;
            while (iterator != fmt.end() && *iterator != '}') ++iterator;
            if (iterator == fmt.end())
              __throw_ustring_format_exception_open_bracket();
            end_format_iterator = iterator;
            __format_information<char> fi;
            fi.location = result.size();
            std::string format_str {begin_format_iterator, end_format_iterator};
            if (format_str.size() == 0)
              fi.index = index++;
            else {
              size_t index_alignment_separator = ustring(format_str).index_of(',');
              size_t index_format_separator = ustring(format_str).index_of(u8':');
              
              if (index_alignment_separator != std::string::npos && index_format_separator != std::string::npos && index_alignment_separator > index_format_separator)
                index_alignment_separator = std::string::npos;
                
              if (index_alignment_separator != std::string::npos)
                fi.alignment = format_str.substr(index_alignment_separator + 1, index_format_separator != std::string::npos ? index_format_separator - index_alignment_separator - 1 : std::string::npos);
                
              if (index_format_separator != std::string::npos)
                fi.format = format_str.substr(index_format_separator + 1);
                
              if (index_alignment_separator == 0 || index_format_separator == 0)
                fi.index = index++;
              else {
                std::string index_str;
                if (index_alignment_separator != std::string::npos)
                  index_str = format_str.substr(0, index_alignment_separator);
                else if (index_format_separator != std::string::npos)
                  index_str = format_str.substr(0, index_format_separator);
                else
                  index_str = format_str;
                try {
                  for (auto c : index_str)
                    if (!std::isdigit(c)) __throw_ustring_format_exception_start_colon();
                  fi.index = std::stoi(index_str);
                } catch (...) {
                  __throw_ustring_format_exception_start_colon();
                }
              }
            }
            formats.push_back(fi);
          }
        } else if (*iterator == '}') {
          if (++iterator == fmt.end())
            __throw_ustring_format_exception_close_bracket();
          if (*iterator != '}')
            __throw_ustring_format_exception_close_bracket();
          result += *iterator;
        } else
          result += *iterator;
      }
      
      __ustring_extract_format_arg(result, formats, std::forward<args_t>(args)...);
      return result.c_str();
    }
    
    size_t get_hash_code() const noexcept override;
    
    size_t index_of(value_type value) const noexcept;
    
    size_t index_of(const ustring& value) const noexcept;
    
    size_t index_of(value_type value, size_t start_index) const noexcept;
    
    size_t index_of(const ustring& value, size_t start_index) const noexcept;
    
    size_t index_of(value_type value, size_t start_index, size_t count) const noexcept;
    
    size_t index_of(const ustring& value, size_t start_index, size_t count) const noexcept;
    
    size_t index_of_any(const std::vector<value_type>& values) const noexcept;
    
    size_t index_of_any(const std::vector<value_type>& values, size_t start_index) const noexcept;
    
    size_t index_of_any(const std::vector<value_type>& values, size_t start_index, size_t count) const noexcept;
    
    size_t index_of_any(const std::initializer_list<value_type>& values) const noexcept;
    size_t index_of_any(const std::initializer_list<value_type>& values, size_t start_index) const noexcept;
    size_t index_of_any(const std::initializer_list<value_type>& values, size_t start_index, size_t count) const noexcept;
    
    ustring insert(size_t start_index, const ustring& value) const noexcept;
    
    [[deprecated("Replaced by xtd::ustring::is_empty(const xtd::ustring&) - Will be removed in version 0.4.0")]]
    bool is_empty() const noexcept {return is_empty(*this);}
    
    static bool is_empty(const xtd::ustring& string) noexcept;
    
    template<typename collection_t>
    static ustring join(const ustring separator, const collection_t& values) noexcept {return join(separator, values, 0, values.size());}
    
    template<typename collection_t>
    static ustring join(const ustring& separator, const collection_t& values, size_t index) noexcept {return join(separator, values, index, values.size() - index);}
    
    template<typename collection_t>
    static ustring join(const ustring& separator, const collection_t& values, size_t index, size_t count) noexcept {
      size_t i = 0;
      ustring result;
      for (const auto& item : values) {
        if (i >= index) {
          if (i != index) result += separator;
          result += format("{}", item);
        }
        if (++i >= index + count) break;
      }
      return result;
    }
    
    template<typename value_t>
    static ustring join(const ustring& separator, const std::initializer_list<value_t>& values) noexcept {return join(separator, std::vector<value_t>(values));}
    template<typename value_t>
    static ustring join(const ustring& separator, const std::initializer_list<value_t>& values, size_t index) noexcept {return join(separator, std::vector<value_t>(values), index);}
    template<typename value_t>
    static ustring join(const ustring& separator, const std::initializer_list<value_t>& values, size_t index, size_t count) noexcept {return join(separator, std::vector<value_t>(values), index, count);}
    
    size_t last_index_of(value_type value) const noexcept;
    
    size_t last_index_of(const ustring& value) const noexcept;
    
    size_t last_index_of(value_type value, size_t start_index) const noexcept;
    
    size_t last_index_of(const ustring& value, size_t start_index) const noexcept;
    
    size_t last_index_of(value_type value, size_t start_index, size_t count) const noexcept;
    
    size_t last_index_of(const ustring& value, size_t start_index, size_t count) const noexcept;
    
    size_t last_index_of_any(const std::vector<value_type>& values) const noexcept;
    
    size_t last_index_of_any(const std::vector<value_type>& values, size_t start_index) const noexcept;
    
    size_t last_index_of_any(const std::vector<value_type>& values, size_t start_index, size_t count) const noexcept;
    
    size_t last_index_of_any(const std::initializer_list<value_type>& values) const noexcept;
    size_t last_index_of_any(const std::initializer_list<value_type>& values, size_t start_index) const noexcept;
    size_t last_index_of_any(const std::initializer_list<value_type>& values, size_t start_index, size_t count) const noexcept;
    
    ustring pad_left(size_t total_width) const noexcept;
    
    ustring pad_left(size_t total_width, value_type padding_char) const noexcept;
    
    ustring pad_right(size_t total_width) const noexcept;
    
    ustring pad_right(size_t total_width, value_type padding_char) const noexcept;
    
    ustring remove(size_t start_index) const noexcept;
    
    ustring remove(size_t start_index, size_t count) const noexcept;
    
    ustring replace(value_type old_char, value_type new_char) const noexcept;
    
    ustring replace(const ustring& old_string, const ustring& new_string) const noexcept;
    
    std::vector<ustring> split(const std::vector<value_type>& separators, size_t count, string_split_options options) const noexcept;
    
    std::vector<ustring> split() const noexcept;
    
    std::vector<ustring> split(const std::vector<value_type>& separators) const noexcept;
    
    std::vector<ustring> split(const std::vector<value_type>& separators, string_split_options options) const noexcept;
    
    std::vector<ustring> split(const std::vector<value_type>& separators, size_t count) const noexcept;
    
    template<typename ... args_t>
    static ustring sprintf(const ustring& fmt, args_t&& ... args) noexcept {return __sprintf(fmt.c_str(), convert_param(std::forward<args_t>(args)) ...);}
    
    bool starts_with(value_type value) const noexcept;
    
    bool starts_with(value_type value, bool ignore_case) const noexcept;
    
    bool starts_with(const ustring& value) const noexcept;
    
    bool starts_with(const ustring& value, bool ignore_case) const noexcept;
    
    ustring substring(size_t start_index) const noexcept;
    
    ustring substring(size_t start_index, size_t length) const noexcept;
    
    std::vector<value_type> to_array() const noexcept;
    
    std::vector<value_type> to_array(size_t start_index) const noexcept;
    
    std::vector<value_type> to_array(size_t start_index, size_t length) const noexcept;
    
    ustring to_lower() const noexcept;
    
    //ustring to_string() const noexcept override;
    ustring to_string() const noexcept override;
    
    ustring to_upper() const noexcept;
    
    ustring trim() const noexcept;
    
    ustring trim(value_type trim_char) const noexcept;
    
    ustring trim(const std::vector<value_type>& trim_chars) const noexcept;
    
    ustring trim_end() const noexcept;
    
    ustring trim_end(value_type trim_char) const noexcept;
    
    ustring trim_end(const std::vector<value_type>& trim_chars) const noexcept;
    
    ustring trim_start() const noexcept;
    
    ustring trim_start(value_type trim_char) const noexcept;
    
    ustring trim_start(const std::vector<value_type>& trim_chars) const noexcept;
    
    template<typename value_t>
    static value_t parse(const ustring& str) {
      return xtd::parse<value_t>(str);
    }
    
    template<typename value_t>
    static bool try_parse(const ustring& str, value_t& value) {
      try {
        value = parse<value_t>(str);
        return true;
      } catch (...) {
        return false;
      }
    }
    
    friend std::ostream& operator<<(std::ostream& stream, const ustring& str) {return stream << str.c_str();}
    friend std::istream& operator>>(std::istream& stream, ustring& str) {
      std::string s;
      stream >> s;
      str = s;
      return stream;
    }
    
    friend ustring operator+(const ustring& str_a, const ustring& str_b) {
      ustring result = str_a;
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const std::string& str_b) {
      ustring result = str_a;
      result.append(ustring(str_b));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const value_type* str_b) {
      ustring result = str_a;
      result.append(ustring(str_b));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const std::u8string& str_b) {
      ustring result = str_a;
      result.append(ustring(str_b));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const char8_t* str_b) {
      ustring result = str_a;
      result.append(ustring(str_b));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const std::u16string& str_b) {
      ustring result = str_a;
      result.append(ustring(str_b));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const char16_t* str_b) {
      ustring result = str_a;
      result.append(ustring(str_b));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const std::u32string& str_b) {
      ustring result = str_a;
      result.append(ustring(str_b));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const char32_t* str_b) {
      ustring result = str_a;
      result.append(ustring(str_b));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const std::wstring& str_b) {
      ustring result = str_a;
      result.append(ustring(str_b));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const wchar_t* str_b) {
      ustring result = str_a;
      result.append(ustring(str_b));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, value_type character) {
      ustring result = str_a;
      result.append(ustring(1, character));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, char8_t character) {
      ustring result = str_a;
      result.append(ustring(1, character));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, char16_t character) {
      ustring result = str_a;
      result.append(ustring(1, character));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, char32_t character) {
      ustring result = str_a;
      result.append(ustring(1, character));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, wchar_t character) {
      ustring result = str_a;
      result.append(ustring(1, character));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const std::initializer_list<value_type>& il) {
      ustring result = str_a;
      result.append(ustring(il));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const std::initializer_list<char8_t>& il) {
      ustring result = str_a;
      result.append(ustring(il));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const std::initializer_list<char16_t>& il) {
      ustring result = str_a;
      result.append(ustring(il));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const std::initializer_list<char32_t>& il) {
      ustring result = str_a;
      result.append(ustring(il));
      return result;
    }
    
    friend ustring operator+(const ustring& str_a, const std::initializer_list<wchar_t>& il) {
      ustring result = str_a;
      result.append(ustring(il));
      return result;
    }
    
    friend ustring operator+(const std::string& str_a, const ustring& str_b) {
      ustring result(str_a);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const value_type* str_a, const ustring& str_b) {
      ustring result(str_a);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const std::u8string& str_a, const ustring& str_b) {
      ustring result(str_a);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const char8_t* str_a, const ustring& str_b) {
      ustring result(str_a);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const std::u16string& str_a, const ustring& str_b) {
      ustring result(str_a);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const char16_t* str_a, const ustring& str_b) {
      ustring result(str_a);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const std::u32string& str_a, const ustring& str_b) {
      ustring result(str_a);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const char32_t* str_a, const ustring& str_b) {
      ustring result(str_a);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const std::wstring& str_a, const ustring& str_b) {
      ustring result(str_a);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const wchar_t* str_a, const ustring& str_b) {
      ustring result(str_a);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(value_type character, const ustring& str_b) {
      ustring result(1, character);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(char8_t character, const ustring& str_b) {
      ustring result(1, character);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(char16_t character, const ustring& str_b) {
      ustring result(1, character);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(char32_t character, const ustring& str_b) {
      ustring result(1, character);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(wchar_t character, const ustring& str_b) {
      ustring result(1, character);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const std::initializer_list<value_type>& il, const ustring& str_b) {
      ustring result(il);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const std::initializer_list<char8_t>& il, const ustring& str_b) {
      ustring result(il);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const std::initializer_list<char16_t>& il, const ustring& str_b) {
      ustring result(il);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const std::initializer_list<char32_t>& il, const ustring& str_b) {
      ustring result(il);
      result.append(str_b);
      return result;
    }
    
    friend ustring operator+(const std::initializer_list<wchar_t>& il, const ustring& str_b) {
      ustring result(il);
      result.append(str_b);
      return result;
    }
    
  private:
    template<typename arg_t>
    static auto convert_param(arg_t&& arg) noexcept {
      if constexpr(std::is_same<std::remove_cv_t<std::remove_reference_t<arg_t>>, std::string>::value) return std::forward<arg_t>(arg).c_str();
      else if constexpr(std::is_same<std::remove_cv_t<std::remove_reference_t<arg_t>>, std::wstring>::value) return std::forward<arg_t>(arg).c_str();
      else return std::forward<arg_t>(arg);
    }
    
    static ustring get_class_name(const ustring& full_name);
    
    using std::basic_string<value_type>::assign;
    using std::basic_string<value_type>::reserve;
    using std::basic_string<value_type>::shrink_to_fit;
    using std::basic_string<value_type>::clear;
    using std::basic_string<value_type>::erase;
    using std::basic_string<value_type>::push_back;
    using std::basic_string<value_type>::pop_back;
    using std::basic_string<value_type>::append;
    using std::basic_string<value_type>::replace;
    using std::basic_string<value_type>::resize;
  };
  
  ustring to_ustring(int val);
  ustring to_ustring(unsigned val);
  ustring to_ustring(long val);
  ustring to_ustring(unsigned long val);
  ustring to_ustring(long long val);
  ustring to_ustring(unsigned long long val);
  ustring to_ustring(float val);
  ustring to_ustring(double val);
  ustring to_ustring(long double val);
  template <typename type_t>
  ustring to_ustring(type_t val) {
    return ustring::format("{}", val);
  }
}

template<typename arg_t>
void __ustring_extract_format_arg(std::string& fmt, size_t& index, std::vector<__format_information<char>>& formats, arg_t&& arg) {
  size_t offset = 0;
  for (auto& format : formats) {
    format.location += offset;
    if (format.index == index) {
      xtd::ustring arg_str = format.format.empty() ? __format_stringer<char, arg_t>(arg) : xtd::to_string(arg, format.format);
      
      if (!format.alignment.empty()) {
        int alignment = 0;
        try {
          alignment = std::stoi(format.alignment);
        } catch (...) {
          __throw_ustring_format_exception();
        }
        if (alignment > 0) arg_str = arg_str.pad_left(alignment);
        else if (alignment < 0) arg_str = arg_str.pad_right(-alignment);
      }
      fmt.insert(format.location, arg_str);
      offset += arg_str.size();
    }
  }
  ++index;
}

template <typename ...args_t>
void __xtd_ustrings_unused(args_t&& ... args) {}

template<typename ...args_t>
void __ustring_extract_format_arg(xtd::ustring& fmt, std::vector<__format_information<char>>& formats, args_t&& ... args) {
  size_t index = 0;
  (__ustring_extract_format_arg(fmt, index, formats, args), ...);
  __xtd_ustrings_unused(index); // workaround to mute gcc warning: unused-but-set-variable
}