xtd 0.2.0
basic_string_.hpp
Go to the documentation of this file.
1
4#pragma once
6#if !defined(__XTD_BASIC_STRING_INTERNAL__)
7#error "Do not include this file: Internal use only. Include <xtd/basic_string> or <xtd/basic_string.hpp> instead."
8#endif
9
10#include "array.hpp"
11//#include "formatter.hpp"
12
14template<class char_t, class traits_t, class allocator_t>
15inline xtd::basic_string<char_t, traits_t, allocator_t>::basic_string(const allocator_type& allocator) noexcept : chars_(allocator) {}
16
17template<class char_t, class traits_t, class allocator_t>
18inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::index_of_any(const xtd::array<value_type>& values) const noexcept {
19 return index_of_any(values, 0, size());
20}
21
22template<class char_t, class traits_t, class allocator_t>
23xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::index_of_any(const xtd::array<value_type>& values, xtd::size start_index) const {
24 return index_of_any(values, start_index, size() - start_index);
25}
26
27template<class char_t, class traits_t, class allocator_t>
28inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::index_of_any(const xtd::array<value_type>& values, xtd::size start_index, xtd::size count) const {
29 if (start_index > size() || start_index + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
30 auto index = xtd::size {0};
31 for (const auto& item : *this) {
32 if (index++ < start_index) continue;
33 if (index - 1 > start_index + count) break;
34 if (std::find(values.begin(), values.end(), item) != values.end()) return index - 1;
35 }
36 return npos;
37}
38
39template<class char_t, class traits_t, class allocator_t>
40inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::index_of_any(const std::initializer_list<value_type>& values) const noexcept {
41 return index_of_any(xtd::array<value_type>(values));
42}
43
44template<class char_t, class traits_t, class allocator_t>
45inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::index_of_any(const std::initializer_list<value_type>& values, xtd::size start_index) const {
46 return index_of_any(xtd::array<value_type>(values), start_index);
47}
48
49template<class char_t, class traits_t, class allocator_t>
50inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::index_of_any(const std::initializer_list<value_type>& values, xtd::size start_index, xtd::size count) const {
51 return index_of_any(xtd::array<value_type>(values), start_index, count);
52}
53
54template<class char_t, class traits_t, class allocator_t>
55inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::last_index_of_any(const xtd::array<value_type>& values) const noexcept {
56 return last_index_of_any(values, 0, size());
57}
58
59template<class char_t, class traits_t, class allocator_t>
60inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::last_index_of_any(const xtd::array<value_type>& values, xtd::size start_index) const {
61 return last_index_of_any(values, start_index, size() - start_index);
62}
63
64template<class char_t, class traits_t, class allocator_t>
65inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::last_index_of_any(const xtd::array<value_type>& values, xtd::size start_index, xtd::size count) const {
66 if (start_index > size() || start_index + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
67 auto index = size() - 1;
68 for (auto iterator = crbegin(); iterator != crend(); ++iterator) {
69 if (index-- > start_index + count) continue;
70 if (index + 1 < start_index) break;
71 if (std::find(values.begin(), values.end(), *iterator) != values.end()) return index + 1;
72 }
73 return npos;
74}
75
76template<class char_t, class traits_t, class allocator_t>
77inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::last_index_of_any(const std::initializer_list<value_type>& values) const noexcept {
78 return last_index_of_any(xtd::array<value_type>(values));
79}
80
81template<class char_t, class traits_t, class allocator_t>
82inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::last_index_of_any(const std::initializer_list<value_type>& values, xtd::size start_index) const {
83 return last_index_of_any(xtd::array<value_type>(values), start_index);
84}
85
86template<class char_t, class traits_t, class allocator_t>
87inline xtd::size xtd::basic_string<char_t, traits_t, allocator_t>::last_index_of_any(const std::initializer_list<value_type>& values, xtd::size start_index, xtd::size count) const {
88 return last_index_of_any(xtd::array<value_type>(values), start_index, count);
89}
90
91template<class char_t, class traits_t, class allocator_t>
92inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>> xtd::basic_string<char_t, traits_t, allocator_t>::split() const noexcept {
93 return split(default_split_separators, std::numeric_limits<xtd::size>::max(), xtd::string_split_options::none);
94}
95
96template<class char_t, class traits_t, class allocator_t>
97inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>> xtd::basic_string<char_t, traits_t, allocator_t>::split(value_type separator) const noexcept {
98 return split(xtd::array<value_type> {separator}, std::numeric_limits<xtd::size>::max(), xtd::string_split_options::none);
99}
100
101template<class char_t, class traits_t, class allocator_t>
102inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>> xtd::basic_string<char_t, traits_t, allocator_t>::split(value_type separator, xtd::string_split_options options) const noexcept {
103 return split(xtd::array<value_type> {separator}, std::numeric_limits<xtd::size>::max(), options);
104}
105
106template<class char_t, class traits_t, class allocator_t>
107inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>> xtd::basic_string<char_t, traits_t, allocator_t>::split(value_type separator, xtd::size count) const noexcept {
108 return split(xtd::array<value_type> {separator}, count, xtd::string_split_options::none);
109}
110
111template<class char_t, class traits_t, class allocator_t>
112inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>> xtd::basic_string<char_t, traits_t, allocator_t>::split(value_type separator, xtd::size count, xtd::string_split_options options) const noexcept {
113 return split(xtd::array<value_type> {separator}, count, options);
114}
115
116template<class char_t, class traits_t, class allocator_t>
117inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>> xtd::basic_string<char_t, traits_t, allocator_t>::split(const xtd::array<value_type>& separators) const noexcept {
118 return split(separators, std::numeric_limits<xtd::size>::max(), xtd::string_split_options::none);
119}
120
121template<class char_t, class traits_t, class allocator_t>
122inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>> xtd::basic_string<char_t, traits_t, allocator_t>::split(const xtd::array<value_type>& separators, xtd::string_split_options options) const noexcept {
123 return split(separators, std::numeric_limits<xtd::size>::max(), options);
124}
125
126template<class char_t, class traits_t, class allocator_t>
127inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>> xtd::basic_string<char_t, traits_t, allocator_t>::split(const xtd::array<value_type>& separators, xtd::size count) const noexcept {
128 return split(separators, count, xtd::string_split_options::none);
129}
130
131template<class char_t, class traits_t, class allocator_t>
132inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>> xtd::basic_string<char_t, traits_t, allocator_t>::split(const xtd::array<value_type>& separators, xtd::size count, xtd::string_split_options options) const noexcept {
133 if (count == 0) return {};
134 if (count == 1) return {*this};
135
136 auto list = std::vector<basic_string> {};
137 auto sub_string = basic_string::empty_string;
138 auto split_char_separators = separators.size() == 0 ? default_split_separators : separators;
139 for (auto it = begin(); it != end(); ++it) {
140 auto is_separator = std::find(split_char_separators.begin(), split_char_separators.end(), *it) != split_char_separators.end();
141 if (!is_separator) sub_string.chars_.append(basic_string(1, *it));
142 if ((static_cast<xtd::size>(it - begin()) == length() - 1 || is_separator) && (sub_string.length() > 0 || (sub_string.length() == 0 && options != xtd::string_split_options::remove_empty_entries))) {
143 if (list.size() == count - 1) {
144 list.push_back(sub_string + basic_string(c_str(), it - begin() + (is_separator ? 0 : 1), length() - (it - begin()) + (is_separator ? 0 : 1)));
145 return list;
146 }
147 list.push_back(sub_string);
148 sub_string.chars_.clear();
149 }
150 }
151 return list;
152}
153
154template<class char_t, class traits_t, class allocator_t>
155inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>::value_type> xtd::basic_string<char_t, traits_t, allocator_t>::to_array() const noexcept {
156 return to_array(0, size());
157}
158
159template<class char_t, class traits_t, class allocator_t>
160inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>::value_type> xtd::basic_string<char_t, traits_t, allocator_t>::to_array(xtd::size start_index) const {
161 return to_array(start_index, size() - start_index);
162}
163
164template<class char_t, class traits_t, class allocator_t>
165inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>::value_type> xtd::basic_string<char_t, traits_t, allocator_t>::to_array(xtd::size start_index, xtd::size length) const {
166 if (start_index >= size()) return {};
167 if (start_index + length >= size()) return {begin() + start_index, end()};
168 return {begin() + start_index, begin() + start_index + length};
169}
170
171template<class char_t, class traits_t, class allocator_t>
172inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>::value_type> xtd::basic_string<char_t, traits_t, allocator_t>::to_char_array() const noexcept {
173 return to_array(0, size());
174}
175
176template<class char_t, class traits_t, class allocator_t>
177inline xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>::value_type> xtd::basic_string<char_t, traits_t, allocator_t>::to_char_array(xtd::size start_index, xtd::size length) const {
178 return to_array(start_index, length);
179}
180
181template<class char_t, class traits_t, class allocator_t>
182inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::to_title_case() const noexcept {
183 auto words = split({' '});
184 for (auto& word : words)
185 if (word.size() && word != word.to_upper()) word = static_cast<value_type>(toupper(word[0])) + word.substring(1).to_lower();
186 return basic_string::join(" ", words);
187}
188
189template<class char_t, class traits_t, class allocator_t>
190inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::trim(value_type trim_char) const noexcept {
191 return trim(xtd::array<value_type> {trim_char});}
192
193template<class char_t, class traits_t, class allocator_t>
194inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::trim(const xtd::array<value_type>& trim_chars) const noexcept {
195 return trim_start(trim_chars).trim_end(trim_chars);
196}
197
198template<class char_t, class traits_t, class allocator_t>
199inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::trim_end(value_type trim_char) const noexcept {
200 return trim_end(xtd::array<value_type> {trim_char});
201}
202
203template<class char_t, class traits_t, class allocator_t>
204inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::trim_end(const xtd::array<value_type>& trim_chars) const noexcept {
205 if (!size()) return *this;
206 auto result = chars_;
207 while (std::find(trim_chars.begin(), trim_chars.end(), result[result.size() - 1]) != trim_chars.end())
208 result.erase(result.size() - 1, 1);
209 return result;
210}
211
212template<class char_t, class traits_t, class allocator_t>
213inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::trim_start(value_type trim_char) const noexcept {return trim_start(xtd::array<value_type> {trim_char});}
214
215template<class char_t, class traits_t, class allocator_t>
216inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::trim_start(const xtd::array<value_type>& trim_chars) const noexcept {
217 if (!size()) return *this;
218 auto result = chars_;
219 while (std::find(trim_chars.begin(), trim_chars.end(), result[0]) != trim_chars.end())
220 result.erase(0, 1);
221 return result;
222}
223
224template<class char_t, class traits_t, class allocator_t>
225inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::concat(const xtd::array<basic_string>& values) noexcept {
226 auto result = basic_string::empty_string;
227 std::for_each(values.begin(), values.end(), [&](const auto & item) {result += item;});
228 return result;
229}
230
231template<class char_t, class traits_t, class allocator_t>
232inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::concat(const xtd::array<const_pointer>& values) noexcept {
233 auto result = basic_string::empty_string;
234 std::for_each(values.begin(), values.end(), [&](const auto & item) {result += item;});
235 return result;
236}
237
238template<class char_t, class traits_t, class allocator_t>
239template<class other_char_t>
240inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::concat(const xtd::array<const other_char_t*>& values) noexcept {
241 auto result = basic_string::empty_string;
242 std::for_each(values.begin(), values.end(), [&](const auto & item) {result += item;});
243 return result;
244}
245
246
247template<class char_t, class traits_t, class allocator_t>
248template<class object_t>
249inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::concat(const xtd::array<object_t>& args) noexcept {
250 basic_string result;
251 for (const auto& arg : args)
252 result += format("{}", arg);
253 return result;
254}
255
256template<class char_t, class traits_t, class allocator_t>
257template<class ...args_t>
258inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::format(const basic_string<char>& fmt, args_t&& ... args) {
259 auto result = basic_string<char> {};
260 auto index = xtd::size {0};
261 auto formats = std::vector<__format_information<char>> {};
262 auto begin_format_iterator = fmt.end();
263 auto end_format_iterator = fmt.end();
264 for (auto iterator = fmt.begin(); iterator != fmt.end(); ++iterator) {
265 if (*iterator == '{') {
266 if (++iterator == fmt.end())
267 xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::format_opened_bracket_without_end_bracket);
268 if (*iterator == '{')
269 result += *iterator;
270 else {
271 begin_format_iterator = iterator;
272 while (iterator != fmt.end() && *iterator != '}') ++iterator;
273 if (iterator == fmt.end())
274 xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::format_opened_bracket_without_end_bracket);
275 end_format_iterator = iterator;
276 __format_information<char> fi;
277 fi.location = result.size();
278 auto format_str = std::basic_string<char> {begin_format_iterator, end_format_iterator};
279 if (format_str.size() == 0)
280 fi.index = index++;
281 else {
282 xtd::size index_alignment_separator = basic_string(format_str).index_of(',');
283 xtd::size index_format_separator = basic_string(format_str).index_of(u':');
284
285 if (index_alignment_separator != std::basic_string<char>::npos && index_format_separator != std::basic_string<char>::npos && index_alignment_separator > index_format_separator)
286 index_alignment_separator = std::basic_string<char>::npos;
287
288 if (index_alignment_separator != basic_string<char_t>::npos)
289 fi.alignment = format_str.substr(index_alignment_separator + 1, index_format_separator != std::basic_string<char>::npos ? index_format_separator - index_alignment_separator - 1 : std::basic_string<char>::npos);
290
291 if (index_format_separator != basic_string<char>::npos)
292 fi.format = format_str.substr(index_format_separator + 1);
293
294 if (index_alignment_separator == 0 || index_format_separator == 0)
295 fi.index = index++;
296 else {
297 auto index_str = std::basic_string<char> {};
298 if (index_alignment_separator != basic_string<char>::npos)
299 index_str = format_str.substr(0, index_alignment_separator);
300 else if (index_format_separator != basic_string<char>::npos)
301 index_str = format_str.substr(0, index_format_separator);
302 else
303 index_str = std::move(format_str);
304 try {
305 for (auto c : index_str)
306 if (!std::isdigit(c)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::format);
307 fi.index = std::stoi(index_str);
308 } catch (...) {
309 xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::format);
310 }
311 }
312 }
313 formats.push_back(fi);
314 }
315 } else if (*iterator == '}') {
316 if (++iterator == fmt.end())
317 xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::format_closing_bracket_without_open_bracket);
318 if (*iterator != '}')
319 xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::format_closing_bracket_without_open_bracket);
320 result += *iterator;
321 } else
322 result += *iterator;
323 }
324
325 __basic_string_extract_format_arg(result, formats, std::forward<args_t>(args)...);
326 return result.c_str();
327}
328
329template<class char_t, class traits_t, class allocator_t>
330template<class value_t>
331inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::join(const basic_string& separator, const std::initializer_list<value_t>& values) noexcept {
332 return join(separator, xtd::array<value_t>(values));
333}
334
335template<class char_t, class traits_t, class allocator_t>
336template<class value_t>
337inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::join(const basic_string& separator, const std::initializer_list<value_t>& values, xtd::size index) {
338 return join(separator, xtd::array<value_t>(values), index);
339}
340
341template<class char_t, class traits_t, class allocator_t>
342template<class value_t>
343inline xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::join(const basic_string& separator, const std::initializer_list<value_t>& values, xtd::size index, xtd::size count) {
344 return join(separator, xtd::array<value_t>(values), index, count);
345}
346
347template<class char_t, class traits_t, class allocator_t>
348inline const xtd::basic_string<char_t, traits_t, allocator_t> xtd::basic_string<char_t, traits_t, allocator_t>::empty_string;
349
350template<class char_t, class traits_t, class allocator_t>
351inline const xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>::value_type> xtd::basic_string<char_t, traits_t, allocator_t>::default_split_separators = {9, 10, 11, 12, 13, 32};
352
353template<class char_t, class traits_t, class allocator_t>
354inline const xtd::array<typename xtd::basic_string<char_t, traits_t, allocator_t>::value_type> xtd::basic_string<char_t, traits_t, allocator_t>::default_trim_chars = {9, 10, 11, 12, 13, 32};
355
356template<class arg_t>
357void __basic_string_extract_format_arg(std::basic_string<char>& fmt, xtd::size& index, std::vector<__format_information<char>>& formats, arg_t&& arg) {
358//void __basic_string_extract_format_arg(xtd::basic_string<char>& fmt, xtd::size& index, std::vector<__format_information<char>>& formats, arg_t&& arg) {
359 auto offset = xtd::size {0};
360 for (auto& format : formats) {
361 format.location += offset;
362 if (format.index == index) {
363 //xtd::basic_string<char> arg_str = xtd::formatter<arg_t> {}(arg, format.format, std::locale());
364 xtd::basic_string<char> arg_str = xtd::to_string(arg, format.format);
365
366 if (!format.alignment.empty()) {
367 xtd::int32 alignment = 0;
368 try {
369 alignment = std::stoi(format.alignment);
370 } catch (...) {
371 xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::format);
372 }
373 if (alignment > 0) arg_str = arg_str.pad_left(alignment);
374 else if (alignment < 0) arg_str = arg_str.pad_right(-alignment);
375 }
376 fmt.insert(format.location, arg_str);
377 offset += arg_str.size();
378 }
379 }
380 ++index;
381}
382
383template<class ...args_t>
384void __basic_string_extract_format_arg(xtd::basic_string<char>& fmt, std::vector<__format_information<char>>& formats, args_t&&... args) {
385 auto index = xtd::size {0};
386 (__basic_string_extract_format_arg(const_cast<std::basic_string<char>&>(fmt.chars()), index, formats, args), ...);
387 //(__basic_string_extract_format_arg(fmt, index, formats, args), ...);
388 unused_(index); // workaround to mute gcc warning: unused-but-set-variable
389}
390
391template<class target_t, class source_t>
392inline std::basic_string<target_t> __xtd_convert_to_string(std::basic_string<source_t>&& str) noexcept {
393 auto out = std::basic_string<target_t> {};
394 auto codepoint = 0u;
395 for (const auto& character : str) {
396 if (character >= 0xd800 && character <= 0xdbff)
397 codepoint = ((character - 0xd800) << 10) + 0x10000;
398 else {
399 if (character >= 0xdc00 && character <= 0xdfff) codepoint |= character - 0xdc00;
400 else codepoint = character;
401
402 if (codepoint <= 0x7f)
403 out.append(1, static_cast<target_t>(codepoint));
404 else if (codepoint <= 0x7ff) {
405 out.append(1, static_cast<target_t>(0xc0 | ((codepoint >> 6) & 0x1f)));
406 out.append(1, static_cast<target_t>(0x80 | (codepoint & 0x3f)));
407 } else if (codepoint <= 0xffff) {
408 out.append(1, static_cast<target_t>(0xe0 | ((codepoint >> 12) & 0x0f)));
409 out.append(1, static_cast<target_t>(0x80 | ((codepoint >> 6) & 0x3f)));
410 out.append(1, static_cast<target_t>(0x80 | (codepoint & 0x3f)));
411 } else {
412 out.append(1, static_cast<target_t>(0xf0 | ((codepoint >> 18) & 0x07)));
413 out.append(1, static_cast<target_t>(0x80 | ((codepoint >> 12) & 0x3f)));
414 out.append(1, static_cast<target_t>(0x80 | ((codepoint >> 6) & 0x3f)));
415 out.append(1, static_cast<target_t>(0x80 | (codepoint & 0x3f)));
416 }
417 codepoint = 0;
418 }
419 }
420 return out;
421}
422
423template<>
424inline std::basic_string<xtd::char16> __xtd_convert_to_string<xtd::char16, char>(std::basic_string<char>&& str) noexcept {
425 auto out = std::basic_string<xtd::char16> {};
426 auto codepoint = 0u;
427 auto str_ptr = str.data();
428 while (*str_ptr != 0) {
429 auto ch = static_cast<unsigned char>(*str_ptr);
430 if (ch <= 0x7f) codepoint = ch;
431 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
432 else if (ch <= 0xdf) codepoint = ch & 0x1f;
433 else if (ch <= 0xef) codepoint = ch & 0x0f;
434 else codepoint = ch & 0x07;
435 ++str_ptr;
436 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff)) {
437 if (codepoint > 0xffff) {
438 out.append(1, static_cast<xtd::char16>(0xd800 + (static_cast<xtd::char16>(codepoint) >> 10)));
439 out.append(1, static_cast<xtd::char16>(0xdc00 + (static_cast<xtd::char16>(codepoint) & 0x03ff)));
440 } else if (codepoint < 0xd800 || codepoint >= 0xe000)
441 out.append(1, static_cast<xtd::char16>(codepoint));
442 }
443 }
444 return out;
445}
446
447#if defined(__xtd__cpp_lib_char8_t)
448template<>
449inline std::basic_string<xtd::char16> __xtd_convert_to_string<xtd::char16, xtd::char8>(std::basic_string<xtd::char8>&& str) noexcept {
450 auto out = std::basic_string<xtd::char16> {};
451 auto codepoint = 0u;
452 auto str_ptr = str.data();
453 while (*str_ptr != 0) {
454 auto ch = static_cast<unsigned char>(*str_ptr);
455 if (ch <= 0x7f) codepoint = ch;
456 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
457 else if (ch <= 0xdf) codepoint = ch & 0x1f;
458 else if (ch <= 0xef) codepoint = ch & 0x0f;
459 else codepoint = ch & 0x07;
460 ++str_ptr;
461 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff)) {
462 if (codepoint > 0xffff) {
463 out.append(1, static_cast<xtd::char16>(0xd800 + (static_cast<xtd::char16>(codepoint) >> 10)));
464 out.append(1, static_cast<xtd::char16>(0xdc00 + (static_cast<xtd::char16>(codepoint) & 0x03ff)));
465 } else if (codepoint < 0xd800 || codepoint >= 0xe000)
466 out.append(1, static_cast<xtd::char16>(codepoint));
467 }
468 }
469 return out;
470}
471#endif
472
473template<>
474inline std::basic_string<xtd::wchar> __xtd_convert_to_string<xtd::wchar, char>(std::basic_string<char>&& str) noexcept {
475 auto out = std::basic_string<xtd::wchar> {};
476 auto codepoint = 0u;
477 auto str_ptr = str.data();
478 while (*str_ptr != 0) {
479 auto ch = static_cast<unsigned char>(*str_ptr);
480 if (ch <= 0x7f) codepoint = ch;
481 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
482 else if (ch <= 0xdf) codepoint = ch & 0x1f;
483 else if (ch <= 0xef) codepoint = ch & 0x0f;
484 else codepoint = ch & 0x07;
485 ++str_ptr;
486 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff)) {
487 if (sizeof(xtd::wchar) > 2)
488 out.append(1, static_cast<xtd::wchar>(codepoint));
489 else if (codepoint > 0xffff) {
490 out.append(1, static_cast<xtd::wchar>(0xd800 + (static_cast<xtd::wchar>(codepoint) >> 10)));
491 out.append(1, static_cast<xtd::wchar>(0xdc00 + (static_cast<xtd::wchar>(codepoint) & 0x03ff)));
492 } else if (codepoint < 0xd800 || codepoint >= 0xe000)
493 out.append(1, static_cast<xtd::wchar>(codepoint));
494 }
495 }
496 return out;
497}
498
499#if defined(__xtd__cpp_lib_char8_t)
500template<>
501inline std::basic_string<xtd::wchar> __xtd_convert_to_string<xtd::wchar, xtd::char8>(std::basic_string<xtd::char8>&& str) noexcept {
502 auto out = std::basic_string<xtd::wchar> {};
503 auto codepoint = 0u;
504 auto str_ptr = str.data();
505 while (*str_ptr != 0) {
506 auto ch = static_cast<unsigned char>(*str_ptr);
507 if (ch <= 0x7f) codepoint = ch;
508 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
509 else if (ch <= 0xdf) codepoint = ch & 0x1f;
510 else if (ch <= 0xef) codepoint = ch & 0x0f;
511 else codepoint = ch & 0x07;
512 ++str_ptr;
513 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff)) {
514 if (sizeof(xtd::wchar) > 2)
515 out.append(1, static_cast<xtd::wchar>(codepoint));
516 else if (codepoint > 0xffff) {
517 out.append(1, static_cast<xtd::wchar>(0xd800 + (static_cast<xtd::wchar>(codepoint) >> 10)));
518 out.append(1, static_cast<xtd::wchar>(0xdc00 + (static_cast<xtd::wchar>(codepoint) & 0x03ff)));
519 } else if (codepoint < 0xd800 || codepoint >= 0xe000)
520 out.append(1, static_cast<xtd::wchar>(codepoint));
521 }
522 }
523 return out;
524}
525#endif
526
527template<>
528inline std::basic_string<xtd::char32> __xtd_convert_to_string<xtd::char32, char>(std::basic_string<char>&& str) noexcept {
529 auto out = std::basic_string<xtd::char32> {};
530 auto codepoint = 0u;
531 auto str_ptr = str.data();
532 while (*str_ptr != 0) {
533 auto ch = static_cast<unsigned char>(*str_ptr);
534 if (ch <= 0x7f) codepoint = ch;
535 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
536 else if (ch <= 0xdf) codepoint = ch & 0x1f;
537 else if (ch <= 0xef) codepoint = ch & 0x0f;
538 else codepoint = ch & 0x07;
539 ++str_ptr;
540 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff))
541 out.append(1, static_cast<xtd::char32>(codepoint));
542 }
543 return out;
544}
545
546#if defined(__xtd__cpp_lib_char8_t)
547template<>
548inline std::basic_string<xtd::char32> __xtd_convert_to_string<xtd::char32, xtd::char8>(std::basic_string<xtd::char8>&& str) noexcept {
549 auto out = std::basic_string<xtd::char32> {};
550 auto codepoint = 0u;
551 auto str_ptr = str.data();
552 while (*str_ptr != 0) {
553 auto ch = static_cast<unsigned char>(*str_ptr);
554 if (ch <= 0x7f) codepoint = ch;
555 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
556 else if (ch <= 0xdf) codepoint = ch & 0x1f;
557 else if (ch <= 0xef) codepoint = ch & 0x0f;
558 else codepoint = ch & 0x07;
559 ++str_ptr;
560 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff))
561 out.append(1, static_cast<xtd::char32>(codepoint));
562 }
563 return out;
564}
565#endif
566
567template<>
568inline std::basic_string<char> __xtd_convert_to_string<char, char>(std::basic_string<char>&& str) noexcept {
569 return std::move(str);
570}
571
572template<>
573inline std::basic_string<xtd::char16> __xtd_convert_to_string<xtd::char16, xtd::char16>(std::basic_string<xtd::char16>&& str) noexcept {
574 return std::move(str);
575}
576
577template<>
578inline std::basic_string<xtd::char32> __xtd_convert_to_string<xtd::char32, xtd::char32>(std::basic_string<xtd::char32>&& str) noexcept {
579 return std::move(str);
580}
581
582#if defined(__xtd__cpp_lib_char8_t)
583template<>
584inline std::basic_string<xtd::char8> __xtd_convert_to_string<xtd::char8, xtd::char8>(std::basic_string<xtd::char8>&& str) noexcept {
585 return std::move(str);
586}
587#endif
588
589template<>
590inline std::basic_string<xtd::wchar> __xtd_convert_to_string<xtd::wchar, xtd::wchar>(std::basic_string<xtd::wchar>&& str) noexcept {
591 return std::move(str);
592}
593
594#if defined(__xtd__cpp_lib_char8_t)
595template<>
596inline std::basic_string<xtd::char8> __xtd_convert_to_string<xtd::char8, char>(std::basic_string<char>&& str) noexcept {
597 return std::basic_string<xtd::char8> {reinterpret_cast<const xtd::char8*>(str.c_str())};
598}
599
600template<>
601inline std::basic_string<char> __xtd_convert_to_string<char, xtd::char8>(std::basic_string<xtd::char8>&& str) noexcept {
602 return std::basic_string<char> {reinterpret_cast<const char*>(str.c_str())};
603}
604#endif
605
606template<>
607inline std::basic_string<xtd::char16> __xtd_convert_to_string<xtd::char16, xtd::char32>(std::basic_string<xtd::char32>&& str) noexcept {
608 return __xtd_convert_to_string<xtd::char16>(__xtd_convert_to_string<char>(std::move(str)));
609}
610
611template<>
612inline std::basic_string<xtd::char16> __xtd_convert_to_string<xtd::char16, xtd::wchar>(std::basic_string<xtd::wchar>&& str) noexcept {
613 return __xtd_convert_to_string<xtd::char16>(__xtd_convert_to_string<char>(std::move(str)));
614}
615
616template<>
617inline std::basic_string<xtd::char32> __xtd_convert_to_string<xtd::char32, xtd::char16>(std::basic_string<xtd::char16>&& str) noexcept {
618 return __xtd_convert_to_string<xtd::char32>(__xtd_convert_to_string<char>(std::move(str)));
619}
620
621template<>
622inline std::basic_string<xtd::char32> __xtd_convert_to_string<xtd::char32, xtd::wchar>(std::basic_string<xtd::wchar>&& str) noexcept {
623 return __xtd_convert_to_string<xtd::char32>(__xtd_convert_to_string<char>(std::move(str)));
624}
625
626template<>
627inline std::basic_string<xtd::wchar> __xtd_convert_to_string<xtd::wchar, xtd::char16>(std::basic_string<xtd::char16>&& str) noexcept {
628 return __xtd_convert_to_string<xtd::wchar>(__xtd_convert_to_string<char>(std::move(str)));}
629
630template<>
631inline std::basic_string<xtd::wchar> __xtd_convert_to_string<xtd::wchar, xtd::char32>(std::basic_string<xtd::char32>&& str) noexcept {
632 return __xtd_convert_to_string<xtd::wchar>(__xtd_convert_to_string<char>(std::move(str)));
633}
634
635template<class target_t, class source_t>
636inline std::basic_string<target_t> __xtd_convert_to_string(const std::basic_string<source_t>& str) noexcept {
637 auto out = std::basic_string<target_t> {};
638 auto codepoint = 0u;
639 for (const auto& character : str) {
640 if (character >= 0xd800 && character <= 0xdbff)
641 codepoint = ((character - 0xd800) << 10) + 0x10000;
642 else {
643 if (character >= 0xdc00 && character <= 0xdfff) codepoint |= character - 0xdc00;
644 else codepoint = character;
645
646 if (codepoint <= 0x7f)
647 out.append(1, static_cast<target_t>(codepoint));
648 else if (codepoint <= 0x7ff) {
649 out.append(1, static_cast<target_t>(0xc0 | ((codepoint >> 6) & 0x1f)));
650 out.append(1, static_cast<target_t>(0x80 | (codepoint & 0x3f)));
651 } else if (codepoint <= 0xffff) {
652 out.append(1, static_cast<target_t>(0xe0 | ((codepoint >> 12) & 0x0f)));
653 out.append(1, static_cast<target_t>(0x80 | ((codepoint >> 6) & 0x3f)));
654 out.append(1, static_cast<target_t>(0x80 | (codepoint & 0x3f)));
655 } else {
656 out.append(1, static_cast<target_t>(0xf0 | ((codepoint >> 18) & 0x07)));
657 out.append(1, static_cast<target_t>(0x80 | ((codepoint >> 12) & 0x3f)));
658 out.append(1, static_cast<target_t>(0x80 | ((codepoint >> 6) & 0x3f)));
659 out.append(1, static_cast<target_t>(0x80 | (codepoint & 0x3f)));
660 }
661 codepoint = 0;
662 }
663 }
664 return out;
665}
666
667template<>
668inline std::basic_string<xtd::char16> __xtd_convert_to_string<xtd::char16, char>(const std::basic_string<char>& str) noexcept {
669 auto out = std::basic_string<xtd::char16> {};
670 auto codepoint = 0u;
671 auto str_ptr = str.data();
672 while (*str_ptr != 0) {
673 auto ch = static_cast<unsigned char>(*str_ptr);
674 if (ch <= 0x7f) codepoint = ch;
675 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
676 else if (ch <= 0xdf) codepoint = ch & 0x1f;
677 else if (ch <= 0xef) codepoint = ch & 0x0f;
678 else codepoint = ch & 0x07;
679 ++str_ptr;
680 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff)) {
681 if (codepoint > 0xffff) {
682 out.append(1, static_cast<xtd::char16>(0xd800 + (static_cast<xtd::char16>(codepoint) >> 10)));
683 out.append(1, static_cast<xtd::char16>(0xdc00 + (static_cast<xtd::char16>(codepoint) & 0x03ff)));
684 } else if (codepoint < 0xd800 || codepoint >= 0xe000)
685 out.append(1, static_cast<xtd::char16>(codepoint));
686 }
687 }
688 return out;
689}
690
691#if defined(__xtd__cpp_lib_char8_t)
692template<>
693inline std::basic_string<xtd::char16> __xtd_convert_to_string<xtd::char16, xtd::char8>(const std::basic_string<xtd::char8>& str) noexcept {
694 auto out = std::basic_string<xtd::char16> {};
695 auto codepoint = 0u;
696 auto str_ptr = str.data();
697 while (*str_ptr != 0) {
698 auto ch = static_cast<unsigned char>(*str_ptr);
699 if (ch <= 0x7f) codepoint = ch;
700 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
701 else if (ch <= 0xdf) codepoint = ch & 0x1f;
702 else if (ch <= 0xef) codepoint = ch & 0x0f;
703 else codepoint = ch & 0x07;
704 ++str_ptr;
705 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff)) {
706 if (codepoint > 0xffff) {
707 out.append(1, static_cast<xtd::char16>(0xd800 + (static_cast<xtd::char16>(codepoint) >> 10)));
708 out.append(1, static_cast<xtd::char16>(0xdc00 + (static_cast<xtd::char16>(codepoint) & 0x03ff)));
709 } else if (codepoint < 0xd800 || codepoint >= 0xe000)
710 out.append(1, static_cast<xtd::char16>(codepoint));
711 }
712 }
713 return out;
714}
715#endif
716
717template<>
718inline std::basic_string<xtd::wchar> __xtd_convert_to_string<xtd::wchar, char>(const std::basic_string<char>& str) noexcept {
719 auto out = std::basic_string<xtd::wchar> {};
720 auto codepoint = 0u;
721 auto str_ptr = str.data();
722 while (*str_ptr != 0) {
723 auto ch = static_cast<unsigned char>(*str_ptr);
724 if (ch <= 0x7f) codepoint = ch;
725 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
726 else if (ch <= 0xdf) codepoint = ch & 0x1f;
727 else if (ch <= 0xef) codepoint = ch & 0x0f;
728 else codepoint = ch & 0x07;
729 ++str_ptr;
730 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff)) {
731 if (sizeof(xtd::wchar) > 2)
732 out.append(1, static_cast<xtd::wchar>(codepoint));
733 else if (codepoint > 0xffff) {
734 out.append(1, static_cast<xtd::wchar>(0xd800 + (static_cast<xtd::wchar>(codepoint) >> 10)));
735 out.append(1, static_cast<xtd::wchar>(0xdc00 + (static_cast<xtd::wchar>(codepoint) & 0x03ff)));
736 } else if (codepoint < 0xd800 || codepoint >= 0xe000)
737 out.append(1, static_cast<xtd::wchar>(codepoint));
738 }
739 }
740 return out;
741}
742
743#if defined(__xtd__cpp_lib_char8_t)
744template<>
745inline std::basic_string<xtd::wchar> __xtd_convert_to_string<xtd::wchar, xtd::char8>(const std::basic_string<xtd::char8>& str) noexcept {
746 auto out = std::basic_string<xtd::wchar> {};
747 auto codepoint = 0u;
748 auto str_ptr = str.data();
749 while (*str_ptr != 0) {
750 auto ch = static_cast<unsigned char>(*str_ptr);
751 if (ch <= 0x7f) codepoint = ch;
752 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
753 else if (ch <= 0xdf) codepoint = ch & 0x1f;
754 else if (ch <= 0xef) codepoint = ch & 0x0f;
755 else codepoint = ch & 0x07;
756 ++str_ptr;
757 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff)) {
758 if (sizeof(xtd::wchar) > 2)
759 out.append(1, static_cast<xtd::wchar>(codepoint));
760 else if (codepoint > 0xffff) {
761 out.append(1, static_cast<xtd::wchar>(0xd800 + (static_cast<xtd::wchar>(codepoint) >> 10)));
762 out.append(1, static_cast<xtd::wchar>(0xdc00 + (static_cast<xtd::wchar>(codepoint) & 0x03ff)));
763 } else if (codepoint < 0xd800 || codepoint >= 0xe000)
764 out.append(1, static_cast<xtd::wchar>(codepoint));
765 }
766 }
767 return out;
768}
769#endif
770
771template<>
772inline std::basic_string<xtd::char32> __xtd_convert_to_string<xtd::char32, char>(const std::basic_string<char>& str) noexcept {
773 auto out = std::basic_string<xtd::char32> {};
774 auto codepoint = 0u;
775 auto str_ptr = str.data();
776 while (*str_ptr != 0) {
777 auto ch = static_cast<unsigned char>(*str_ptr);
778 if (ch <= 0x7f) codepoint = ch;
779 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
780 else if (ch <= 0xdf) codepoint = ch & 0x1f;
781 else if (ch <= 0xef) codepoint = ch & 0x0f;
782 else codepoint = ch & 0x07;
783 ++str_ptr;
784 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff))
785 out.append(1, static_cast<xtd::char32>(codepoint));
786 }
787 return out;
788}
789
790#if defined(__xtd__cpp_lib_char8_t)
791template<>
792inline std::basic_string<xtd::char32> __xtd_convert_to_string<xtd::char32, xtd::char8>(const std::basic_string<xtd::char8>& str) noexcept {
793 auto out = std::basic_string<xtd::char32> {};
794 auto codepoint = 0u;
795 auto str_ptr = str.data();
796 while (*str_ptr != 0) {
797 auto ch = static_cast<unsigned char>(*str_ptr);
798 if (ch <= 0x7f) codepoint = ch;
799 else if (ch <= 0xbf) codepoint = (codepoint << 6) | (ch & 0x3f);
800 else if (ch <= 0xdf) codepoint = ch & 0x1f;
801 else if (ch <= 0xef) codepoint = ch & 0x0f;
802 else codepoint = ch & 0x07;
803 ++str_ptr;
804 if (((*str_ptr & 0xc0) != 0x80) && (codepoint <= 0x10ffff))
805 out.append(1, static_cast<xtd::char32>(codepoint));
806 }
807 return out;
808}
809#endif
810
811template<>
812inline std::basic_string<char> __xtd_convert_to_string<char, char>(const std::basic_string<char>& str) noexcept {
813 return str;
814}
815
816template<>
817inline std::basic_string<xtd::char16> __xtd_convert_to_string<xtd::char16, xtd::char16>(const std::basic_string<xtd::char16>& str) noexcept {
818 return str;
819}
820
821template<>
822inline std::basic_string<xtd::char32> __xtd_convert_to_string<xtd::char32, xtd::char32>(const std::basic_string<xtd::char32>& str) noexcept {
823 return str;
824}
825
826#if defined(__xtd__cpp_lib_char8_t)
827template<>
828inline std::basic_string<xtd::char8> __xtd_convert_to_string<xtd::char8, xtd::char8>(const std::basic_string<xtd::char8>& str) noexcept {
829 return str;
830}
831#endif
832
833template<>
834inline std::basic_string<xtd::wchar> __xtd_convert_to_string<xtd::wchar, xtd::wchar>(const std::basic_string<xtd::wchar>& str) noexcept {
835 return str;
836}
837
838#if defined(__xtd__cpp_lib_char8_t)
839template<>
840inline std::basic_string<xtd::char8> __xtd_convert_to_string<xtd::char8, char>(const std::basic_string<char>& str) noexcept {
841 return reinterpret_cast<const xtd::char8*>(str.c_str());
842}
843
844template<>
845inline std::basic_string<char> __xtd_convert_to_string<char, xtd::char8>(const std::basic_string<xtd::char8>& str) noexcept {
846 return reinterpret_cast<const char*>(str.c_str());
847}
848#endif
849
850template<>
851inline std::basic_string<xtd::char16> __xtd_convert_to_string<xtd::char16, xtd::char32>(const std::basic_string<xtd::char32>& str) noexcept {
852 return __xtd_convert_to_string<xtd::char16>(__xtd_convert_to_string<char>(str));
853}
854
855template<>
856inline std::basic_string<xtd::char16> __xtd_convert_to_string<xtd::char16, xtd::wchar>(const std::basic_string<xtd::wchar>& str) noexcept {
857 return __xtd_convert_to_string<xtd::char16>(__xtd_convert_to_string<char>(str));
858}
859
860template<>
861inline std::basic_string<xtd::char32> __xtd_convert_to_string<xtd::char32, xtd::char16>(const std::basic_string<xtd::char16>& str) noexcept {
862 return __xtd_convert_to_string<xtd::char32>(__xtd_convert_to_string<char>(str));
863}
864
865template<>
866inline std::basic_string<xtd::char32> __xtd_convert_to_string<xtd::char32, xtd::wchar>(const std::basic_string<xtd::wchar>& str) noexcept {
867 return __xtd_convert_to_string<xtd::char32>(__xtd_convert_to_string<char>(str));
868}
869
870template<>
871inline std::basic_string<xtd::wchar> __xtd_convert_to_string<xtd::wchar, xtd::char16>(const std::basic_string<xtd::char16>& str) noexcept {
872 return __xtd_convert_to_string<xtd::wchar>(__xtd_convert_to_string<char>(str));
873}
874
875template<>
876inline std::basic_string<xtd::wchar> __xtd_convert_to_string<xtd::wchar, xtd::char32>(const std::basic_string<xtd::char32>& str) noexcept {
877 return __xtd_convert_to_string<xtd::wchar>(__xtd_convert_to_string<char>(str));
878}
array.hpp
Contains xtd::array class.
xtd::array
Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the ba...
Definition array.hpp:59
xtd::basic_array::end
const_iterator end() const noexcept override
Returns an iterator to the element following the last element of the enumarable.
Definition basic_array.hpp:161
xtd::basic_array::begin
const_iterator begin() const noexcept override
Returns an iterator to the first element of the enumarable.
Definition basic_array.hpp:117
xtd::basic_string
Represents text as a sequence of character units.
Definition basic_string.hpp:71
xtd::basic_string::pad_left
basic_string pad_left(xtd::size total_width) const noexcept
Right-aligns the characters in this basic_string, padding with spaces on the left for a specified tot...
Definition basic_string.hpp:1575
xtd::basic_string::trim
basic_string trim() const noexcept
Removes all leading and trailing occurrences of white-space characters from the specified xtd::basic_...
Definition basic_string.hpp:1962
xtd::basic_string::split
xtd::array< basic_string > split() const noexcept
Splits this basic_string into substrings that are based on the default white-space characters....
xtd::basic_string::insert
basic_string insert(xtd::size start_index, const basic_string &value) const
Inserts a specified instance of basic_string at a specified index position in this instance.
Definition basic_string.hpp:1492
xtd::basic_string::chars
const base_type & chars() const noexcept
Returns a reference to the underlying base type.
Definition basic_string.hpp:875
xtd::basic_string::index_of_any
xtd::size index_of_any(const xtd::array< 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::basic_string::to_char_array
xtd::array< value_type > to_char_array() const noexcept
Copies the characters in this instance to a Unicode character array.
xtd::basic_string::end
const_iterator end() const override
Returns an iterator to the character following the last character of the string. This character acts ...
Definition basic_string.hpp:900
xtd::basic_string::concat
static basic_string concat(const basic_string &str_a, const basic_string &str_b, const basic_string &str_c, const basic_string &str_d) noexcept
Concatenates four specified instances of basic_string.
Definition basic_string.hpp:2111
xtd::basic_string::join
static basic_string join(const basic_string separator, const collection_t &values) noexcept
Concatenates a specified separator basic_string between each element of a specified object array,...
Definition basic_string.hpp:2288
xtd::basic_string::trim_end
basic_string trim_end() const noexcept
Removes all trailing occurrences of white-space characters from the specified xtd::basic_string.
Definition basic_string.hpp:1978
xtd::basic_string::last_index_of_any
xtd::size last_index_of_any(const xtd::array< 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::basic_string::size
size_type size() const noexcept
Returns the number of char_t elements in the string, i.e. std::distance(begin(), end()).
Definition basic_string.hpp:926
xtd::basic_string::to_title_case
basic_string to_title_case() const noexcept
Converts the current basic_string to title case (except for words that are entirely in uppercase,...
xtd::basic_string::pad_right
basic_string pad_right(xtd::size total_width) const noexcept
Left-aligns the characters in this basic_string, padding with spaces on the right for a specified tot...
Definition basic_string.hpp:1589
xtd::basic_string::trim_start
basic_string trim_start() const noexcept
Removes all leading occurrences of white-space characters from the specified xtd::basic_string.
Definition basic_string.hpp:1994
xtd::basic_string::basic_string
basic_string()=default
Initializes a new instance of xtd::basic_string.
xtd::basic_string::empty
bool empty() const noexcept
Checks if the string has no characters, i.e. whether begin() == end().
Definition basic_string.hpp:896
xtd::basic_string::to_array
xtd::array< value_type > to_array() const noexcept
Copies the characters in this instance to a Unicode character array.
xtd::helpers::throw_helper::throws
static void throws(xtd::helpers::exception_case exception_case, const source_location &location=source_location::current())
Throws an exption with specified exception case.
xtd::basic_string::format
static basic_string format(const basic_string< char > &fmt, args_t &&... args)
Writes the text representation of the specified arguments list, to string using the specified format ...
xtd::format
xtd::string format(const xtd::string &fmt, args_t &&... args)
Writes the text representation of the specified arguments list, to string using the specified format ...
Definition format.hpp:20
xtd::helpers::exception_case
exception_case
Represents the exception case used by the xtd::helpers::exception helper class.
Definition exception_case.hpp:25
xtd::helpers::exception_case::format
@ format
The format is not valid.
xtd::helpers::exception_case::index_out_of_range
@ index_out_of_range
The index is out of range.
xtd::helpers::exception_case::format_opened_bracket_without_end_bracket
@ format_opened_bracket_without_end_bracket
The format contains open backet_without_end_bracket.
xtd::helpers::exception_case::format_closing_bracket_without_open_bracket
@ format_closing_bracket_without_open_bracket
The format contains close backet_without_open_bracket.
unused_
#define unused_
It may be used to suppress the "unused variable" or "unused local typedefs" compiler warnings when th...
Definition unused.hpp:30
xtd::drawing::string_trimming::character
@ character
Specifies that the text is trimmed to the nearest character.
xtd::drawing::string_trimming::word
@ word
Specifies that text is trimmed to the nearest word.
xtd::char8
char8_t char8
Represents a 8-bit unicode character.
Definition char8.hpp:27
xtd::wchar
wchar_t wchar
Represents a wide character.
Definition wchar.hpp:24
xtd::int32
int32_t int32
Represents a 32-bit signed integer.
Definition int32.hpp:23
xtd::char16
char16_t char16
Represents a 16-bit unicode character.
Definition char16.hpp:26
xtd::size
size_t size
Represents a size of any object in bytes.
Definition size.hpp:23
xtd::char32
char32_t char32
Represents a 32-bit unicode character.
Definition char32.hpp:26
xtd::string_split_options
string_split_options
Specifies whether applicable xtd::string::split method overloads include or omit empty substrings fro...
Definition string_split_options.hpp:14
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.hpp:41
xtd::string_split_options::none
@ none
The return value includes array elements that contain an empty string.
xtd::string_split_options::remove_empty_entries
@ remove_empty_entries
The return value does not include array elements that contain an empty string.
xtd::io::seek_origin::begin
@ begin
Specifies the beginning of a stream.
xtd::console_key::c
@ c
The C key.
xtd::console_key::u
@ u
The U key.
xtd::console_key::end
@ end
The END key.
xtd::console_key::separator
@ separator
The Separator key.
xtd
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition xtd_about_box.hpp:10
Generated on Sun Mar 9 2025 23:56:05 for xtd by Gammasoft. All rights reserved.