xtd - Reference Guide  0.1.1
Modern c++17/20 framework to create console, GUI and unit test applications on Windows, macOS, Linux, iOS and android.
ustring.h
Go to the documentation of this file.
1 #pragma once
4 
6 #define __XTD_CORE_INTERNAL__
7 #include "internal/__generic_stream_output.h"
8 #include "internal/__format_information.h"
9 #include "internal/__format_stringer.h"
10 #include "internal/__sprintf.h"
11 #undef __XTD_CORE_INTERNAL__
13 
14 #include <string>
15 #include "string_comparison.h"
16 #include "string_split_options.h"
17 #include "types.h"
18 #include "object.h"
19 #include "parse.h"
20 #include "to_string.h"
21 
22 #if !defined(_WIN32)
23 #include <cxxabi.h>
24 #endif
25 
27 namespace xtd {
28  class ustring;
29 }
30 template<typename ...args_t>
31 void __ustring_extract_format_arg(xtd::ustring& fmt, std::vector<__format_information<char>>& format, args_t&&... args);
32 void __throw_ustring_format_exception();
33 void __throw_ustring_format_exception_close_bracket();
34 void __throw_ustring_format_exception_open_bracket();
35 void __throw_ustring_format_exception_start_colon();
37 
38 namespace xtd {
48  class ustring : public object, public std::basic_string<char> {
49  public:
51  ustring() noexcept;
54  explicit ustring(const allocator_type& allocator) noexcept;
55 
60  ustring(size_t count, value_type character);
66  ustring(size_t count, value_type character, const allocator_type& allocator);
71  ustring(size_t count, char8_t character);
77  ustring(size_t count, char8_t character, const allocator_type& allocator);
82  ustring(size_t count, char16_t character);
88  ustring(size_t count, char16_t character, const allocator_type& allocator);
93  ustring(size_t count, char32_t character);
99  ustring(size_t count, char32_t character, const allocator_type& allocator);
104  ustring(size_t count, wchar_t character);
110  ustring(size_t count, wchar_t character, const allocator_type& allocator);
111 
116  ustring(const ustring& str, size_t index, size_t count);
122  ustring(const ustring& str, size_t index, size_t count, const allocator_type& allocator);
126  ustring(const ustring& str, size_t index);
131  ustring(const ustring& str, size_t index, const allocator_type& allocator);
132 
135  ustring(const value_type* str, size_t count);
140  ustring(const value_type* str, size_t count, const allocator_type& allocator);
141 
143  ustring(const value_type* str);
147  ustring(const value_type* str, const allocator_type& allocator);
148 
150  ustring(value_type* str);
154  ustring(value_type* str, const allocator_type& allocator);
155 
158  ustring(const ustring& str) noexcept;
162  ustring(const ustring& str, const allocator_type& allocator) noexcept;
163 
166  ustring(const std::string& str) noexcept;
170  ustring(const std::string& str, const allocator_type& allocator) noexcept;
171 
174  ustring(const std::u8string& str) noexcept;
178  ustring(const std::u8string& str, const allocator_type& allocator) noexcept;
179 
181  ustring(const char8_t* str);
185  ustring(const char8_t* str, const allocator_type& allocator);
186 
188  ustring(char8_t* str);
192  ustring(char8_t* str, const allocator_type& allocator);
193 
196  ustring(const std::u16string& str) noexcept;
200  ustring(const std::u16string& str, const allocator_type& allocator) noexcept;
201 
203  ustring(const char16_t* str);
207  ustring(const char16_t* str, const allocator_type& allocator);
208 
210  ustring(char16_t* str);
214  ustring(char16_t* str, const allocator_type& allocator);
215 
218  ustring(const std::u32string& str) noexcept;
222  ustring(const std::u32string& str, const allocator_type& allocator) noexcept;
223 
225  ustring(const char32_t* str);
229  ustring(const char32_t* str, const allocator_type& allocator);
230 
232  ustring(char32_t* str);
236  ustring(char32_t* str, const allocator_type& allocator);
237 
240  ustring(const std::wstring& str) noexcept;
244  ustring(const std::wstring& str, const allocator_type& allocator) noexcept;
245 
247  ustring(const wchar_t* str);
251  ustring(const wchar_t* str, const allocator_type& allocator);
252 
254  ustring(wchar_t* str);
258  ustring(wchar_t* str, const allocator_type& allocator);
259 
262  ustring(ustring&& str) noexcept;
266  ustring(ustring&& str, const allocator_type& allocator) noexcept;
267 
271  template<typename input_iterator_t>
272  ustring(input_iterator_t first, input_iterator_t last) : std::basic_string<value_type>(first, last) {}
277  template<typename input_iterator_t>
278  ustring(input_iterator_t first, input_iterator_t last, const allocator_type& allocator) : std::basic_string<value_type>(first, last, allocator) {}
279 
282  ustring(std::initializer_list<value_type> il);
286  ustring(std::initializer_list<value_type> il, const allocator_type& allocator);
287 
290  ustring(std::initializer_list<char8_t> il);
294  ustring(std::initializer_list<char8_t> il, const allocator_type& allocator);
295 
298  ustring(std::initializer_list<char16_t> il);
302  ustring(std::initializer_list<char16_t> il, const allocator_type& allocator);
303 
306  ustring(std::initializer_list<char32_t> il);
310  ustring(std::initializer_list<char32_t> il, const allocator_type& allocator);
311 
314  ustring(std::initializer_list<wchar_t> il);
318  ustring(std::initializer_list<wchar_t> il, const allocator_type& allocator);
319 
321  /*
322  template<typename type_t>
323  ustring(const type_t& object) : std::basic_string<value_type>(object) {}
324  template<typename type_t>
325  ustring(const type_t& object, const allocator_type& allocator) : std::basic_string<value_type>(object, allocator) {}
326  template<typename type_t>
327  ustring(const type_t& object, size_t index, size_t count) : std::basic_string<value_type>(object, index, count) {}
328  template<typename type_t>
329  ustring(const type_t& object, size_t index, size_t count, const allocator_type& allocator) : std::basic_string<value_type>(object, index, count, allocator) {}
330  template<typename type_t>
331  ustring(const type_t& object, size_t count) : std::basic_string<value_type>(object, 0, count) {}
332  template<typename type_t>
333  ustring(const type_t& object, size_t count, const allocator_type& allocator) : std::basic_string<value_type>(object, 0, count, allocator) {}
334  */
335 
336  ustring& operator=(const ustring& str);
337  ustring& operator=(const std::string& str);
338  ustring& operator=(const value_type* str);
339  ustring& operator=(const std::u8string& str);
340  ustring& operator=(const char8_t* str);
341  ustring& operator=(const std::u16string& str);
342  ustring& operator=(const char16_t* str);
343  ustring& operator=(const std::u32string& str);
344  ustring& operator=(const char32_t* str);
345  ustring& operator=(const std::wstring& str);
346  ustring& operator=(const wchar_t* str);
347  ustring& operator=(ustring&& str) noexcept;
348 
349  ustring& operator=(value_type character);
350  ustring& operator=(char8_t character);
351  ustring& operator=(char16_t character);
352  ustring& operator=(char32_t character);
353  ustring& operator=(wchar_t character);
354  ustring& operator=(const std::initializer_list<value_type>& il);
355  ustring& operator=(const std::initializer_list<char8_t>& il);
356  ustring& operator=(const std::initializer_list<char16_t>& il);
357  ustring& operator=(const std::initializer_list<char32_t>& il);
358  ustring& operator=(const std::initializer_list<wchar_t>& il);
359  //template<typename type_t>
360  //ustring& operator=(const type_t& object) {return std::basic_string<value_type>::assign(object);}
361 
362  template<typename type_t>
363  ustring operator+(const type_t& object) const {
364  ustring result(*this);
365  result.append(object);
366  return result;
367  }
368 
369  ustring& operator+=(const ustring& str);
370  ustring& operator+=(const std::string& str);
371  ustring& operator+=(const value_type* str);
372  ustring& operator+=(const std::u8string& str);
373  ustring& operator+=(const char8_t* str);
374  ustring& operator+=(const std::u16string& str);
375  ustring& operator+=(const char16_t* str);
376  ustring& operator+=(const std::u32string& str);
377  ustring& operator+=(const char32_t* str);
378  ustring& operator+=(const std::wstring& str);
379  ustring& operator+=(const wchar_t* str);
380  ustring& operator+=(value_type character);
381  ustring& operator+=(char8_t character);
382  ustring& operator+=(char16_t character);
383  ustring& operator+=(char32_t character);
384  ustring& operator+=(wchar_t character);
385  ustring& operator+=(const std::initializer_list<value_type>& il);
386  ustring& operator+=(const std::initializer_list<char8_t>& il);
387  ustring& operator+=(const std::initializer_list<char16_t>& il);
388  ustring& operator+=(const std::initializer_list<char32_t>& il);
389  ustring& operator+=(const std::initializer_list<wchar_t>& il);
390  template<typename type_t>
391  ustring& operator+=(const type_t& object) {
392  *this = *this + ustring(object);
393  return *this;
394  }
395 
396  bool operator==(const ustring& other) const;
397  bool operator!=(const ustring& other) const;
398  bool operator==(const std::string other) const;
399  bool operator!=(const std::string other) const;
400  bool operator==(const value_type* other) const;
401  bool operator!=(const value_type* other) const;
402  bool operator==(const std::u8string other) const;
403  bool operator!=(const std::u8string other) const;
404  bool operator==(const char8_t* other) const;
405  bool operator!=(const char8_t* other) const;
406  bool operator==(const std::u16string other) const;
407  bool operator!=(const std::u16string other) const;
408  bool operator==(const char16_t* other) const;
409  bool operator!=(const char16_t* other) const;
410  bool operator==(const std::u32string other) const;
411  bool operator!=(const std::u32string other) const;
412  bool operator==(const char32_t* other) const;
413  bool operator!=(const char32_t* other) const;
414  bool operator==(const std::wstring other) const;
415  bool operator!=(const std::wstring other) const;
416  bool operator==(const wchar_t* other) const;
417  bool operator!=(const wchar_t* other) const;
418  const value_type& operator[](size_t index);
419  const value_type& operator[](size_t index) const;
420  ustring substr(size_type index = 0, size_type count = npos) const;
422 
426  template<typename object_t>
427  static ustring full_class_name() {return demangle(typeid(object_t).name());}
428 
432  template<typename object_t>
433  static ustring full_class_name(const object_t& object) {return demangle(typeid(object).name());}
434 
438  static ustring full_class_name(const std::type_info& info) {return demangle(info.name());}
439 
443  template<typename object_t>
444  static ustring class_name() {return get_class_name(full_class_name<object_t>());}
445 
449  template<typename object_t>
450  static ustring class_name(const object_t& object) {return get_class_name(full_class_name(object));}
451 
455  static ustring class_name(const std::type_info& info) {return get_class_name(full_class_name(info));}
456 
457  using std::basic_string<value_type>::compare;
467  static int compare(const ustring& str_a, const ustring& str_b) noexcept;
478  static int compare(const ustring& str_a, const ustring& str_b, bool ignore_case) noexcept;
479 
490  static int compare(const ustring& str_a, const ustring& str_b, xtd::string_comparison comparison_type) noexcept;
503  static int compare(const ustring& str_a, size_t index_a, const ustring& str_b, size_t index_b, size_t length) noexcept;
517  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;
531  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;
532 
539  static ustring concat(const ustring& str_a, const ustring& str_b, const ustring& str_c, const ustring& str_d) noexcept;
540 
547  template<typename object_a_t, typename object_b_t, typename object_c_t, typename object_d_t>
548  static ustring concat(object_a_t obj_a, object_b_t obj_b, object_c_t obj_c, object_d_t obj_d) noexcept {
549  return format("{}{}{}{}", obj_a, obj_b, obj_c, obj_d);
550  }
551 
557  static ustring concat(const ustring& str_a, const ustring& str_b, const ustring& str_c) noexcept;
558 
564  template<typename object_a_t, typename object_b_t, typename object_c_t>
565  static ustring concat(object_a_t obj_a, object_b_t obj_b, object_c_t obj_c) noexcept {
566  return format("{}{}{}", obj_a, obj_b, obj_c);
567  }
568 
573  static ustring concat(const ustring& str_a, const ustring& str_b) noexcept;
574 
579  template<typename object_a_t, typename object_b_t>
580  static ustring concat(object_a_t obj_a, object_b_t obj_b) noexcept {
581  return format("{}{}", obj_a, obj_b);
582  }
583 
587  static ustring concat(const std::vector<ustring>& values) noexcept;
588 
590  static ustring concat(const std::vector<const value_type*>& values) noexcept;
591  static ustring concat(const std::vector<const char8_t*>& values) noexcept;
592  static ustring concat(const std::initializer_list<ustring>& values) noexcept;
593  static ustring concat(const std::initializer_list<const value_type*>& values) noexcept;
594  static ustring concat(const std::initializer_list<const char8_t*>& values) noexcept;
596 
600  template<typename object_t>
601  static ustring concat(const std::vector<object_t>& args) noexcept {
602  ustring result;
603  for (const auto& arg : args)
604  result += format("{}", arg);
605  return result;
606  }
607 
609  template<typename object_t>
610  static ustring concat(const std::initializer_list<object_t>& args) noexcept {
611  ustring result;
612  for (const auto& arg : args)
613  result += format("{}", arg);
614  return result;
615  }
617 
621  template<typename value_t>
622  static ustring concat(value_t value) noexcept {
623  return format("{}", value);
624  }
625 
628  static ustring demangle(const ustring& name) {
629 #if defined(_WIN32)
630  ustring result = name;
631  for (auto& item : {"enum ", "class ", "union ", "struct "})
632  result = result.replace(item, "");
633  return result;
634 #else
635  class auto_delete_char_pointer {
636  public:
637  auto_delete_char_pointer(char* value) : value_(value) {}
638  ~auto_delete_char_pointer() {free(value_);}
639  char* operator()() const {return value_;}
640  private:
641  char* value_;
642  };
643  int32_t status = 0;
644  return auto_delete_char_pointer(abi::__cxa_demangle(name.c_str(), 0, 0, &status))();
645 #endif
646  }
647 
651  bool contains(const ustring& value) const noexcept;
652 
655  static ustring empty_string() noexcept;
656 
660  bool ends_with(value_type value) const noexcept;
661 
665  bool ends_with(char8_t value) const noexcept;
666 
670  bool ends_with(const ustring& value) const noexcept;
671 
675  bool ends_with(const ustring& value, bool ignore_case) const noexcept;
676 
680  bool ends_with(const ustring& value, xtd::string_comparison comparison_type) const noexcept;
681 
688  template<typename ...args_t>
689  static ustring format(const ustring& fmt, args_t&&... args) {
690  ustring result;
691  size_t index = 0;
692  std::vector<__format_information<char>> formats;
693  typename ustring::const_iterator begin_format_iterator = fmt.cend();
694  typename ustring::const_iterator end_format_iterator = fmt.cend();
695  for (typename ustring::const_iterator iterator = fmt.cbegin(); iterator != fmt.cend(); ++iterator) {
696  if (*iterator == '{') {
697  ++iterator;
698  if (*iterator == '{')
699  result += *iterator;
700  else {
701  begin_format_iterator = iterator;
702  while (*iterator != '}' && iterator != fmt.end()) ++iterator;
703  if (iterator == fmt.end())
704  __throw_ustring_format_exception_open_bracket();
705  end_format_iterator = iterator;
706  __format_information<char> fi;
707  fi.location = result.size();
708  std::string format {begin_format_iterator, end_format_iterator};
709  if (format.size() == 0)
710  fi.index = index++;
711  else {
712  size_t index_alignment_separator = ustring(format).index_of(',');
713  size_t index_format_separator = ustring(format).index_of(u8':');
714 
715  if (index_alignment_separator != std::string::npos && index_format_separator != std::string::npos && index_alignment_separator > index_format_separator)
716  index_alignment_separator = std::string::npos;
717 
718  if (index_alignment_separator != std::string::npos)
719  fi.alignment = format.substr(index_alignment_separator + 1, index_format_separator != std::string::npos ? index_format_separator - index_alignment_separator - 1 : std::string::npos);
720 
721  if (index_format_separator != std::string::npos)
722  fi.format = format.substr(index_format_separator + 1);
723 
724  if (index_alignment_separator == 0 || index_format_separator == 0)
725  fi.index = index++;
726  else {
727  std::string index_str;
728  if (index_alignment_separator != std::string::npos)
729  index_str = format.substr(0, index_alignment_separator);
730  else if (index_format_separator != std::string::npos)
731  index_str = format.substr(0, index_format_separator);
732  else
733  index_str = format;
734  try {
735  for (auto c : index_str)
736  if (!std::isdigit(c)) __throw_ustring_format_exception_start_colon();
737  fi.index = std::stoi(index_str);
738  } catch(...) {
739  __throw_ustring_format_exception_start_colon();
740  }
741  }
742  }
743  formats.push_back(fi);
744  }
745  } else if (*iterator == '}') {
746  if (++iterator == fmt.cend())
747  __throw_ustring_format_exception_close_bracket();
748  if (*iterator != '}')
749  __throw_ustring_format_exception_close_bracket();
750  result += *iterator;
751  } else
752  result += *iterator;
753  }
754 
755  __ustring_extract_format_arg(result, formats, std::forward<args_t>(args)...);
756  return result.c_str();
757  }
758 
761  size_t get_hash_code() const noexcept override;
762 
766  size_t index_of(value_type value) const noexcept;
767 
771  size_t index_of(const ustring& value) const noexcept;
772 
777  size_t index_of(value_type value, size_t start_index) const noexcept;
778 
783  size_t index_of(const ustring& value, size_t start_index) const noexcept;
784 
790  size_t index_of(value_type value, size_t start_index, size_t count) const noexcept;
791 
797  size_t index_of(const ustring& value, size_t start_index, size_t count) const noexcept;
798 
802  size_t index_of_any(const std::vector<value_type>& values) const noexcept;
803 
808  size_t index_of_any(const std::vector<value_type>& values, size_t start_index) const noexcept;
809 
815  size_t index_of_any(const std::vector<value_type>& values, size_t start_index, size_t count) const noexcept;
816 
818  size_t index_of_any(const std::initializer_list<value_type>& values) const noexcept;
819  size_t index_of_any(const std::initializer_list<value_type>& values, size_t start_index) const noexcept;
820  size_t index_of_any(const std::initializer_list<value_type>& values, size_t start_index, size_t count) const noexcept;
822 
829  ustring insert(size_t start_index, const ustring& value) const noexcept;
830 
833  bool is_empty() const noexcept;
834 
841  template<typename collection_t>
842  static ustring join(const ustring separator, const collection_t& values) noexcept {return join(separator, values, 0, values.size());}
843 
851  template<typename collection_t>
852  static ustring join(const ustring& separator, const collection_t& values, size_t index) noexcept {return join(separator, values, index, values.size()-index);}
853 
862  template<typename collection_t>
863  static ustring join(const ustring& separator, const collection_t& values, size_t index, size_t count) noexcept {
864  size_t i = 0;
865  ustring result;
866  for (const auto& item : values) {
867  if (i >= index) {
868  if (i != index) result += separator;
869  result += format("{}", item);
870  }
871  if (++i >= index + count) break;
872  }
873  return result;
874  }
875 
877  template<typename value_t>
878  static ustring join(const ustring& separator, const std::initializer_list<value_t>& values) noexcept {return join(separator, std::vector<value_t>(values));}
879  template<typename value_t>
880  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);}
881  template<typename value_t>
882  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);}
884 
888  size_t last_index_of(value_type value) const noexcept;
889 
893  size_t last_index_of(const ustring& value) const noexcept;
894 
899  size_t last_index_of(value_type value, size_t start_index) const noexcept;
900 
905  size_t last_index_of(const ustring& value, size_t start_index) const noexcept;
906 
913  size_t last_index_of(value_type value, size_t start_index, size_t count) const noexcept;
914 
920  size_t last_index_of(const ustring& value, size_t start_index, size_t count) const noexcept;
921 
925  size_t last_index_of_any(const std::vector<value_type>& values) const noexcept;
926 
931  size_t last_index_of_any(const std::vector<value_type>& values, size_t start_index) const noexcept;
932 
938  size_t last_index_of_any(const std::vector<value_type>& values, size_t start_index, size_t count) const noexcept;
939 
941  size_t last_index_of_any(const std::initializer_list<value_type>& values) const noexcept;
942  size_t last_index_of_any(const std::initializer_list<value_type>& values, size_t start_index) const noexcept;
943  size_t last_index_of_any(const std::initializer_list<value_type>& values, size_t start_index, size_t count) const noexcept;
945 
951  ustring pad_left(size_t total_width) const noexcept;
952 
959  ustring pad_left(size_t total_width, value_type padding_char) const noexcept;
960 
966  ustring pad_right(size_t total_width) const noexcept;
967 
974  ustring pad_right(size_t total_width, value_type padding_char) const noexcept;
975 
979  ustring remove(size_t start_index) const noexcept;
980 
985  ustring remove(size_t start_index, size_t count) const noexcept;
986 
991  ustring replace(value_type old_char, value_type new_char) const noexcept;
992 
998  ustring replace(const ustring& old_string, const ustring& new_string) const noexcept;
999 
1011  std::vector<ustring> split(const std::vector<value_type>& separators, size_t count, string_split_options options) const noexcept;
1012 
1017  std::vector<ustring> split() const noexcept;
1018 
1024  std::vector<ustring> split(const std::vector<value_type>& separators) const noexcept;
1025 
1042  std::vector<ustring> split(const std::vector<value_type>& separators, string_split_options options) const noexcept;
1043 
1052  std::vector<ustring> split(const std::vector<value_type>& separators, size_t count) const noexcept;
1053 
1113  template<typename ... args_t>
1114  static ustring sprintf(const ustring& fmt, args_t&& ... args) noexcept {return __sprintf(fmt.c_str(), convert_param(std::forward<args_t>(args)) ...);}
1115 
1120  bool starts_with(value_type value) const noexcept;
1121 
1127  bool starts_with(value_type value, bool ignore_case) const noexcept;
1128 
1133  bool starts_with(const ustring& value) const noexcept;
1134 
1140  bool starts_with(const ustring& value, bool ignore_case) const noexcept;
1141 
1146  ustring substring(size_t start_index) const noexcept;
1147 
1152  ustring substring(size_t start_index, size_t length) const noexcept;
1153 
1156  std::vector<value_type> to_array() const noexcept;
1157 
1161  std::vector<value_type> to_array(size_t start_index) const noexcept;
1162 
1167  std::vector<value_type> to_array(size_t start_index, size_t length) const noexcept;
1168 
1171  ustring to_lower() const noexcept;
1172 
1173  //ustring to_string() const noexcept override;
1174  ustring to_string() const noexcept override;
1175 
1178  ustring to_upper() const noexcept;
1179 
1184  ustring trim() const noexcept;
1185 
1190  ustring trim(value_type trim_char) const noexcept;
1191 
1196  ustring trim(const std::vector<value_type>& trim_chars) const noexcept;
1197 
1202  ustring trim_end() const noexcept;
1203 
1208  ustring trim_end(value_type trim_char) const noexcept;
1209 
1214  ustring trim_end(const std::vector<value_type>& trim_chars) const noexcept;
1215 
1220  ustring trim_start() const noexcept;
1221 
1226  ustring trim_start(value_type trim_char) const noexcept;
1227 
1232  ustring trim_start(const std::vector<value_type>& trim_chars) const noexcept;
1233 
1234  template<typename value_t>
1235  static value_t parse(const ustring& str) {
1236  return xtd::parse<value_t>(str);
1237  }
1238 
1239  template<typename value_t>
1240  static bool try_parse(const ustring& str, value_t& value) {
1241  try {
1242  value = parse<value_t>(str);
1243  return true;
1244  } catch(...) {
1245  return false;
1246  }
1247  }
1248 
1250  friend std::ostream& operator<<(std::ostream& stream, const ustring& str) {return stream << str.c_str();}
1251  friend std::istream& operator>>(std::istream& stream, ustring& str) {
1252  std::string s;
1253  stream >> s;
1254  str = s;
1255  return stream;
1256  }
1257 
1258  friend ustring operator+(const ustring& str_a, const ustring& str_b) {
1259  ustring result = str_a;
1260  result.append(str_b);
1261  return result;
1262  }
1263 
1264  friend ustring operator+(const ustring& str_a, const std::string& str_b) {
1265  ustring result = str_a;
1266  result.append(ustring(str_b));
1267  return result;
1268  }
1269 
1270  friend ustring operator+(const ustring& str_a, const value_type* str_b) {
1271  ustring result = str_a;
1272  result.append(ustring(str_b));
1273  return result;
1274  }
1275 
1276  friend ustring operator+(const ustring& str_a, const std::u8string& str_b) {
1277  ustring result = str_a;
1278  result.append(ustring(str_b));
1279  return result;
1280  }
1281 
1282  friend ustring operator+(const ustring& str_a, const char8_t* str_b) {
1283  ustring result = str_a;
1284  result.append(ustring(str_b));
1285  return result;
1286  }
1287 
1288  friend ustring operator+(const ustring& str_a, const std::u16string& str_b) {
1289  ustring result = str_a;
1290  result.append(ustring(str_b));
1291  return result;
1292  }
1293 
1294  friend ustring operator+(const ustring& str_a, const char16_t* str_b) {
1295  ustring result = str_a;
1296  result.append(ustring(str_b));
1297  return result;
1298  }
1299 
1300  friend ustring operator+(const ustring& str_a, const std::u32string& str_b) {
1301  ustring result = str_a;
1302  result.append(ustring(str_b));
1303  return result;
1304  }
1305 
1306  friend ustring operator+(const ustring& str_a, const char32_t* str_b) {
1307  ustring result = str_a;
1308  result.append(ustring(str_b));
1309  return result;
1310  }
1311 
1312  friend ustring operator+(const ustring& str_a, const std::wstring& str_b) {
1313  ustring result = str_a;
1314  result.append(ustring(str_b));
1315  return result;
1316  }
1317 
1318  friend ustring operator+(const ustring& str_a, const wchar_t* str_b) {
1319  ustring result = str_a;
1320  result.append(ustring(str_b));
1321  return result;
1322  }
1323 
1324  friend ustring operator+(const ustring& str_a, value_type character) {
1325  ustring result = str_a;
1326  result.append(ustring(1, character));
1327  return result;
1328  }
1329 
1330  friend ustring operator+(const ustring& str_a, char8_t character) {
1331  ustring result = str_a;
1332  result.append(ustring(1, character));
1333  return result;
1334  }
1335 
1336  friend ustring operator+(const ustring& str_a, char16_t character) {
1337  ustring result = str_a;
1338  result.append(ustring(1, character));
1339  return result;
1340  }
1341 
1342  friend ustring operator+(const ustring& str_a, char32_t character) {
1343  ustring result = str_a;
1344  result.append(ustring(1, character));
1345  return result;
1346  }
1347 
1348  friend ustring operator+(const ustring& str_a, wchar_t character) {
1349  ustring result = str_a;
1350  result.append(ustring(1, character));
1351  return result;
1352  }
1353 
1354  friend ustring operator+(const ustring& str_a, const std::initializer_list<value_type>& il) {
1355  ustring result = str_a;
1356  result.append(ustring(il));
1357  return result;
1358  }
1359 
1360  friend ustring operator+(const ustring& str_a, const std::initializer_list<char8_t>& il) {
1361  ustring result = str_a;
1362  result.append(ustring(il));
1363  return result;
1364  }
1365 
1366  friend ustring operator+(const ustring& str_a, const std::initializer_list<char16_t>& il) {
1367  ustring result = str_a;
1368  result.append(ustring(il));
1369  return result;
1370  }
1371 
1372  friend ustring operator+(const ustring& str_a, const std::initializer_list<char32_t>& il) {
1373  ustring result = str_a;
1374  result.append(ustring(il));
1375  return result;
1376  }
1377 
1378  friend ustring operator+(const ustring& str_a, const std::initializer_list<wchar_t>& il) {
1379  ustring result = str_a;
1380  result.append(ustring(il));
1381  return result;
1382  }
1383 
1384  friend ustring operator+(const std::string& str_a, const ustring& str_b) {
1385  ustring result(str_a);
1386  result.append(str_b);
1387  return result;
1388  }
1389 
1390  friend ustring operator+(const value_type* str_a, const ustring& str_b) {
1391  ustring result(str_a);
1392  result.append(str_b);
1393  return result;
1394  }
1395 
1396  friend ustring operator+(const std::u8string& str_a, const ustring& str_b) {
1397  ustring result(str_a);
1398  result.append(str_b);
1399  return result;
1400  }
1401 
1402  friend ustring operator+(const char8_t* str_a, const ustring& str_b) {
1403  ustring result(str_a);
1404  result.append(str_b);
1405  return result;
1406  }
1407 
1408  friend ustring operator+(const std::u16string& str_a, const ustring& str_b) {
1409  ustring result(str_a);
1410  result.append(str_b);
1411  return result;
1412  }
1413 
1414  friend ustring operator+(const char16_t* str_a, const ustring& str_b) {
1415  ustring result(str_a);
1416  result.append(str_b);
1417  return result;
1418  }
1419 
1420  friend ustring operator+(const std::u32string& str_a, const ustring& str_b) {
1421  ustring result(str_a);
1422  result.append(str_b);
1423  return result;
1424  }
1425 
1426  friend ustring operator+(const char32_t* str_a, const ustring& str_b) {
1427  ustring result(str_a);
1428  result.append(str_b);
1429  return result;
1430  }
1431 
1432  friend ustring operator+(const std::wstring& str_a, const ustring& str_b) {
1433  ustring result(str_a);
1434  result.append(str_b);
1435  return result;
1436  }
1437 
1438  friend ustring operator+(const wchar_t* str_a, const ustring& str_b) {
1439  ustring result(str_a);
1440  result.append(str_b);
1441  return result;
1442  }
1443 
1444  friend ustring operator+(value_type character, const ustring& str_b) {
1445  ustring result(1, character);
1446  result.append(str_b);
1447  return result;
1448  }
1449 
1450  friend ustring operator+(char8_t character, const ustring& str_b) {
1451  ustring result(1, character);
1452  result.append(str_b);
1453  return result;
1454  }
1455 
1456  friend ustring operator+(char16_t character, const ustring& str_b) {
1457  ustring result(1, character);
1458  result.append(str_b);
1459  return result;
1460  }
1461 
1462  friend ustring operator+(char32_t character, const ustring& str_b) {
1463  ustring result(1, character);
1464  result.append(str_b);
1465  return result;
1466  }
1467 
1468  friend ustring operator+(wchar_t character, const ustring& str_b) {
1469  ustring result(1, character);
1470  result.append(str_b);
1471  return result;
1472  }
1473 
1474  friend ustring operator+(const std::initializer_list<value_type>& il, const ustring& str_b) {
1475  ustring result(il);
1476  result.append(str_b);
1477  return result;
1478  }
1479 
1480  friend ustring operator+(const std::initializer_list<char8_t>& il, const ustring& str_b) {
1481  ustring result(il);
1482  result.append(str_b);
1483  return result;
1484  }
1485 
1486  friend ustring operator+(const std::initializer_list<char16_t>& il, const ustring& str_b) {
1487  ustring result(il);
1488  result.append(str_b);
1489  return result;
1490  }
1491 
1492  friend ustring operator+(const std::initializer_list<char32_t>& il, const ustring& str_b) {
1493  ustring result(il);
1494  result.append(str_b);
1495  return result;
1496  }
1497 
1498  friend ustring operator+(const std::initializer_list<wchar_t>& il, const ustring& str_b) {
1499  ustring result(il);
1500  result.append(str_b);
1501  return result;
1502  }
1504 
1505  private:
1506  template<typename arg_t>
1507  static auto convert_param(arg_t&& arg) noexcept {
1508  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();
1509  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();
1510  else return std::forward<arg_t>(arg);
1511  }
1512 
1513  static ustring get_class_name(const ustring& full_name);
1514 
1515  using std::basic_string<value_type>::assign;
1516  using std::basic_string<value_type>::reserve;
1517  using std::basic_string<value_type>::shrink_to_fit;
1518  using std::basic_string<value_type>::clear;
1519  using std::basic_string<value_type>::erase;
1520  using std::basic_string<value_type>::push_back;
1521  using std::basic_string<value_type>::pop_back;
1522  using std::basic_string<value_type>::append;
1523  using std::basic_string<value_type>::replace;
1524  using std::basic_string<value_type>::resize;
1525  };
1526 
1530  ustring to_ustring(int val);
1534  ustring to_ustring(unsigned val);
1538  ustring to_ustring(long val);
1542  ustring to_ustring(unsigned long val);
1546  ustring to_ustring(long long val);
1550  ustring to_ustring(unsigned long long val);
1554  ustring to_ustring(float val);
1558  ustring to_ustring(double val);
1562  ustring to_ustring(long double val);
1566  template <typename type_t>
1567  ustring to_ustring(type_t val) {
1568  return ustring::format("{}", val);
1569  }
1570 }
1571 
1573 template<typename arg_t>
1574 void __ustring_extract_format_arg(std::string& fmt, size_t& index, std::vector<__format_information<char>>& formats, arg_t&& arg) {
1575  size_t offset = 0;
1576  for (auto& format : formats) {
1577  format.location += offset;
1578  if (format.index == index) {
1579  xtd::ustring arg_str = format.format.empty() ? __format_stringer<char, arg_t>(arg) : xtd::to_string(arg, format.format);
1580 
1581  if (!format.alignment.empty()) {
1582  int alignment = 0;
1583  try {
1584  alignment = std::stoi(format.alignment);
1585  } catch(...) {
1586  __throw_ustring_format_exception();
1587  }
1588  if (alignment > 0) arg_str = arg_str.pad_left(alignment);
1589  else if (alignment < 0) arg_str = arg_str.pad_right(-alignment);
1590  }
1591  fmt.insert(format.location, arg_str);
1592  offset += arg_str.size();
1593  }
1594  }
1595  ++index;
1596 }
1597 
1598 template <typename ...args_t>
1599 void __xtd_ustrings_unused(args_t&& ... args) {}
1600 
1601 template<typename ...args_t>
1602 void __ustring_extract_format_arg(xtd::ustring& fmt, std::vector<__format_information<char>>& formats, args_t&&... args) {
1603  size_t index = 0;
1604  (__ustring_extract_format_arg(fmt, index, formats, args),...);
1605  __xtd_ustrings_unused(index); // workaround to mute gcc warning: unused-but-set-variable
1606 }
xtd::object
Supports all classes in the xtd class hierarchy and provides low-level services to derived classes....
Definition: object.h:26
xtd::ustring
Represents text as a sequence of UTF-8 code units.
Definition: ustring.h:48
xtd::ustring::ustring
ustring(std::initializer_list< value_type > il, const allocator_type &allocator)
Initializes a new instance of xtd::ustring with specified initializer list and allocator.
xtd::ustring::remove
ustring remove(size_t start_index, size_t count) const noexcept
Deletes all the characters from this string beginning at a specified position and continuing through ...
xtd::ustring::concat
static ustring concat(object_a_t obj_a, object_b_t obj_b, object_c_t obj_c) noexcept
Concatenates three specified instances of object.
Definition: ustring.h:565
xtd::ustring::last_index_of_any
size_t last_index_of_any(const std::vector< value_type > &values) const noexcept
Reports the index of the last occurrence in this instance of any character in a specified array of ch...
xtd::ustring::split
std::vector< ustring > split() const noexcept
Splits this string into substrings that are based on the default white-space characters....
xtd::ustring::last_index_of
size_t last_index_of(const ustring &value, size_t start_index) const noexcept
Reports the index of the last occurrence of the specified character in this string....
xtd::ustring::last_index_of
size_t last_index_of(const ustring &value, size_t start_index, size_t count) const noexcept
Reports the index of the last occurrence of the specified character in this string....
xtd::ustring::ustring
ustring(std::initializer_list< char32_t > il, const allocator_type &allocator)
Initializes a new instance of xtd::ustring with specified initializer list and allocator.
xtd::ustring::ustring
ustring(std::initializer_list< char32_t > il)
Initializes a new instance of xtd::ustring with specified initializer list.
xtd::ustring::last_index_of
size_t last_index_of(value_type value) const noexcept
Reports the index of the last occurrence of the specified character in this tring.
xtd::ustring::ustring
ustring(std::initializer_list< wchar_t > il)
Initializes a new instance of xtd::ustring with specified initializer list.
xtd::ustring::is_empty
bool is_empty() const noexcept
Indicates whether this string is an empty string ("").
xtd::ustring::ustring
ustring(input_iterator_t first, input_iterator_t last, const allocator_type &allocator)
Initializes a new instance of xtd::ustring with specified first and last iterators of substring and a...
Definition: ustring.h:278
xtd::ustring::demangle
static ustring demangle(const ustring &name)
Gets demangled string of name,.
Definition: ustring.h:628
xtd::ustring::compare
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
Compares substrings of two specified string objects using the specified rules, and returns an integer...
xtd::ustring::ustring
ustring(std::initializer_list< char8_t > il)
Initializes a new instance of xtd::ustring with specified initializer list.
xtd::ustring::ustring
ustring(std::initializer_list< value_type > il)
Initializes a new instance of xtd::ustring with specified initializer list.
xtd::ustring::last_index_of
size_t last_index_of(value_type value, size_t start_index) const noexcept
Reports the index of the last occurrence of the specified character in this string....
xtd::ustring::substring
ustring substring(size_t start_index, size_t length) const noexcept
Retrieves a substring from this instance. The substring starts at a specified character position and ...
xtd::ustring::concat
static ustring concat(value_t value) noexcept
Creates the string representation of a specified object.
Definition: ustring.h:622
xtd::ustring::replace
ustring replace(const ustring &old_string, const ustring &new_string) const noexcept
Replaces all occurrences of a specified string in this string with another specified string.
xtd::ustring::pad_left
ustring pad_left(size_t total_width, value_type padding_char) const noexcept
Right-aligns the characters in this string, padding with spaces on the left for a specified total len...
xtd::ustring::to_upper
ustring to_upper() const noexcept
Returns a copy of the current string converted to uppercase.
xtd::ustring::compare
static int compare(const ustring &str_a, const ustring &str_b, bool ignore_case) noexcept
Compares two specified string objects, ignoring or honoring their case, and returns an integer that i...
xtd::ustring::pad_right
ustring pad_right(size_t total_width, value_type padding_char) const noexcept
Left-aligns the characters in this string, padding with spaces on the right for a specified total len...
xtd::ustring::insert
ustring insert(size_t start_index, const ustring &value) const noexcept
Inserts a specified instance of string at a specified index position in this instance.
xtd::ustring::join
static ustring join(const ustring &separator, const collection_t &values, size_t index, size_t count) noexcept
Concatenates a specified separator string between each element of a specified Object array,...
Definition: ustring.h:863
xtd::ustring::index_of_any
size_t index_of_any(const std::vector< value_type > &values) const noexcept
Reports the index of the first occurrence in this instance of any character in a specified array of c...
xtd::ustring::ustring
ustring(std::initializer_list< char16_t > il)
Initializes a new instance of xtd::ustring with specified initializer list.
xtd::ustring::class_name
static ustring class_name(const object_t &object)
Gets the class name of the specified object.
Definition: ustring.h:450
xtd::ustring::trim
ustring trim() const noexcept
Removes all leading and trailing occurrences of white-space characters from the specified String.
xtd::ustring::trim_end
ustring trim_end() const noexcept
Removes all trailing occurrences of white-space characters from the specified String.
xtd::ustring::concat
static ustring concat(object_a_t obj_a, object_b_t obj_b, object_c_t obj_c, object_d_t obj_d) noexcept
Concatenates four specified instances of object.
Definition: ustring.h:548
xtd::ustring::index_of
size_t index_of(value_type value) const noexcept
Reports the index of the first occurrence of the specified character in this string.
xtd::ustring::to_array
std::vector< value_type > to_array() const noexcept
Copies the characters in this instance to a Unicode character array.
xtd::ustring::pad_right
ustring pad_right(size_t total_width) const noexcept
Left-aligns the characters in this string, padding with spaces on the right for a specified total len...
xtd::ustring::starts_with
bool starts_with(value_type value, bool ignore_case) const noexcept
Determines whether the beginning of this instance of String matches a specified String,...
xtd::ustring::class_name
static ustring class_name(const std::type_info &info)
Gets the class name of the specified object.
Definition: ustring.h:455
xtd::ustring::concat
static ustring concat(const std::vector< object_t > &args) noexcept
Concatenates the string representations of the elements in a specified object array.
Definition: ustring.h:601
xtd::ustring::full_class_name
static ustring full_class_name(const object_t &object)
Gets the fully qualified class name of the specified object, including the namespace of the specified...
Definition: ustring.h:433
xtd::ustring::ustring
ustring(std::initializer_list< char16_t > il, const allocator_type &allocator)
Initializes a new instance of xtd::ustring with specified initializer list and allocator.
xtd::ustring::trim_start
ustring trim_start() const noexcept
Removes all leading occurrences of white-space characters from the specified String.
xtd::ustring::last_index_of
size_t last_index_of(const ustring &value) const noexcept
Reports the index of the last occurrence of the specified string in this string.
xtd::ustring::replace
ustring replace(value_type old_char, value_type new_char) const noexcept
Replaces all occurrences of a specified char_t in this string with another specified char_t.
xtd::ustring::compare
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
Compares substrings of two specified string objects, ignoring or honoring their case,...
xtd::ustring::empty_string
static ustring empty_string() noexcept
Represents the empty string.
xtd::ustring::last_index_of_any
size_t last_index_of_any(const std::vector< value_type > &values, size_t start_index, size_t count) const noexcept
Reports the index of the last occurrence in this instance of any character in a specified array of ch...
xtd::ustring::join
static ustring join(const ustring separator, const collection_t &values) noexcept
Concatenates a specified separator string between each element of a specified object array,...
Definition: ustring.h:842
xtd::ustring::split
std::vector< ustring > split(const std::vector< value_type > &separators, size_t count, string_split_options options) const noexcept
Splits this string into a maximum number of substrings based on the characters in an array.
xtd::ustring::concat
static ustring concat(const ustring &str_a, const ustring &str_b, const ustring &str_c, const ustring &str_d) noexcept
Concatenates four specified instances of string.
xtd::ustring::full_class_name
static ustring full_class_name()
Gets the fully qualified class name of the objec_t, including the namespace of the objec_t.
Definition: ustring.h:427
xtd::ustring::concat
static ustring concat(object_a_t obj_a, object_b_t obj_b) noexcept
Concatenates two specified instances of object.
Definition: ustring.h:580
xtd::ustring::compare
static int compare(const ustring &str_a, const ustring &str_b, xtd::string_comparison comparison_type) noexcept
Compares two specified string objects using the specified rules, and returns an integer that indicate...
xtd::ustring::compare
static int compare(const ustring &str_a, const ustring &str_b) noexcept
Compares two specified string objects and returns an integer that indicates their relative position i...
xtd::ustring::pad_left
ustring pad_left(size_t total_width) const noexcept
Right-aligns the characters in this string, padding with spaces on the left for a specified total len...
xtd::ustring::class_name
static ustring class_name()
Gets the class name of the object_t.
Definition: ustring.h:444
xtd::ustring::last_index_of
size_t last_index_of(value_type value, size_t start_index, size_t count) const noexcept
Reports the index of the last occurrence of the specified character in this string....
xtd::ustring::ends_with
bool ends_with(value_type value) const noexcept
Determines whether the end of this string matches the specified character.
xtd::ustring::get_hash_code
size_t get_hash_code() const noexcept override
Returns the hash code for this string.
xtd::ustring::starts_with
bool starts_with(const ustring &value) const noexcept
Determines whether the beginning of this instance of String matches a specified String.
xtd::ustring::ustring
ustring(std::initializer_list< wchar_t > il, const allocator_type &allocator)
Initializes a new instance of xtd::ustring with specified initializer list and allocator.
xtd::ustring::remove
ustring remove(size_t start_index) const noexcept
Deletes all the characters from this string beginning at a specified position and continuing through ...
xtd::ustring::concat
static ustring concat(const std::vector< ustring > &values) noexcept
Concatenates the elements of a specified string array.
xtd::ustring::concat
static ustring concat(const ustring &str_a, const ustring &str_b, const ustring &str_c) noexcept
Concatenates three specified instances of string.
xtd::ustring::substring
ustring substring(size_t start_index) const noexcept
Retrieves a substring from this instance. The substring starts at a specified character position and ...
xtd::ustring::ustring
ustring() noexcept
Initializes a new instance of xtd::ustring.
xtd::ustring::starts_with
bool starts_with(value_type value) const noexcept
Determines whether the beginning of this instance of String matches a specified String.
xtd::ustring::to_string
ustring to_string() const noexcept override
Returns a std::string that represents the current object.
xtd::ustring::ustring
ustring(std::initializer_list< char8_t > il, const allocator_type &allocator)
Initializes a new instance of xtd::ustring with specified initializer list and allocator.
xtd::ustring::join
static ustring join(const ustring &separator, const collection_t &values, size_t index) noexcept
Concatenates a specified separator string between each element of a specified object array,...
Definition: ustring.h:852
xtd::ustring::concat
static ustring concat(const ustring &str_a, const ustring &str_b) noexcept
Concatenates two specified instances of string.
xtd::ustring::contains
bool contains(const ustring &value) const noexcept
Returns a value indicating whether a specified substring occurs within this string.
xtd::ustring::last_index_of_any
size_t last_index_of_any(const std::vector< value_type > &values, size_t start_index) const noexcept
Reports the index of the last occurrence in this instance of any character in a specified array of ch...
xtd::ustring::to_lower
ustring to_lower() const noexcept
Returns a copy of the current string converted to lowercase.
xtd::ustring::compare
static int compare(const ustring &str_a, size_t index_a, const ustring &str_b, size_t index_b, size_t length) noexcept
Compares substrings of two specified string objects and returns an integer that indicates their relat...
xtd::ustring::starts_with
bool starts_with(const ustring &value, bool ignore_case) const noexcept
Determines whether the beginning of this instance of String matches a specified String,...
xtd::ustring::full_class_name
static ustring full_class_name(const std::type_info &info)
Gets the fully qualified class name of the specified object, including the namespace of the specified...
Definition: ustring.h:438
xtd::ustring::sprintf
static ustring sprintf(const ustring &fmt, args_t &&... args) noexcept
Writes the text representation of the specified arguments list, to string using the specified format ...
Definition: ustring.h:1114
xtd::ustring::format
static ustring format(const ustring &fmt, args_t &&... args)
Writes the text representation of the specified arguments list, to string using the specified format ...
Definition: ustring.h:689
xtd::string_comparison
string_comparison
Specifies the culture, case, and sort rules to be used by certain overloads of the xtd::ustring::comp...
Definition: string_comparison.h:17
xtd::string_split_options
string_split_options
Specifies whether applicable xtd::ustring::split method overloads include or omit empty substrings fr...
Definition: string_split_options.h:17
xtd::to_string
std::string to_string(const value_t &value, const std::string &fmt, const std::locale &loc)
Convert a specified value into a string with specified format and locale.
Definition: to_string.h:37
xtd::console_key::s
@ s
The S key.
xtd::console_key::c
@ c
The C key.
xtd::console_key::i
@ i
The I key.
xtd::console_key::separator
@ separator
The Separator key.
xtd::net::sockets::socket_type::stream
@ stream
Supports reliable, two-way, connection-based byte streams without the duplication of data and without...
xtd::forms::size_type
size_type
Specifies how rows or columns of user interface (UI) elements should be sized relative to their conta...
Definition: size_type.h:18
xtd
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition: system_report.h:17
xtd::to_ustring
ustring to_ustring(int val)
Converts a signed integer to xtd::ustring.
object.h
Contains xtd::object class.
parse.h
Contains xtd::parse methods.
string_comparison.h
Contains xtd::string_comparison enum class.
string_split_options.h
Contains xtd::string_split_options enum class.
to_string.h
Contains xtd::to_string methods.
types.h
Contains xtd fundamental types.
Generated on Mon Jul 17 2023 23:13:04 for xtd - Reference Guide by Gammasoft. All rights reserved.