Embedded Template Library 1.0
Loading...
Searching...
No Matches
wstring.h
Go to the documentation of this file.
1
2
3/******************************************************************************
4The MIT License(MIT)
5
6Embedded Template Library.
7https://github.com/ETLCPP/etl
8https://www.etlcpp.com
9
10Copyright(c) 2016 John Wellbelove
11
12Permission is hereby granted, free of charge, to any person obtaining a copy
13of this software and associated documentation files(the "Software"), to deal
14in the Software without restriction, including without limitation the rights
15to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
16copies of the Software, and to permit persons to whom the Software is
17furnished to do so, subject to the following conditions :
18
19The above copyright notice and this permission notice shall be included in all
20copies or substantial portions of the Software.
21
22THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
25AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28SOFTWARE.
29******************************************************************************/
30
31#ifndef ETL_WSTRING_INCLUDED
32#define ETL_WSTRING_INCLUDED
33
34#include "platform.h"
35#include "basic_string.h"
36#include "string_view.h"
37#include "hash.h"
38#include "initializer_list.h"
39
40#include "private/minmax_push.h"
41
42namespace etl
43{
44#if ETL_USING_CPP11
45 inline namespace literals
46 {
47 inline namespace string_literals
48 {
49 constexpr etl::wstring_view operator ""_sv(const wchar_t* str, size_t length) noexcept
50 {
51 return etl::wstring_view{ str, length };
52 }
53 }
54 }
55#endif
56
57 typedef ibasic_string<wchar_t> iwstring;
58
59 //***************************************************************************
63 //***************************************************************************
64 template <size_t MAX_SIZE_>
65 class wstring : public iwstring
66 {
67 public:
68
69 typedef iwstring base_type;
71
72 typedef iwstring::value_type value_type;
73
74 static const size_t MAX_SIZE = MAX_SIZE_;
75
76 //*************************************************************************
78 //*************************************************************************
80 : iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
81 {
82 this->initialise();
83 }
84
85 //*************************************************************************
88 //*************************************************************************
90 : iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
91 {
92 this->assign(other);
93 }
94
95 //*************************************************************************
98 //*************************************************************************
100 : iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
101 {
102 this->assign(other);
103 }
104
105 //*************************************************************************
110 //*************************************************************************
112 : iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
113 {
114 ETL_ASSERT(position < other.size(), ETL_ERROR(string_out_of_bounds));
115
116 this->assign(other, position, length);
117 }
118
119 //*************************************************************************
122 //*************************************************************************
123 ETL_EXPLICIT_STRING_FROM_CHAR wstring(const value_type* text)
124 : iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
125 {
126 this->assign(text, text + etl::char_traits<value_type>::length(text));
127 }
128
129 //*************************************************************************
133 //*************************************************************************
134 wstring(const value_type* text, size_type count)
135 : iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
136 {
137 this->assign(text, text + count);
138 }
139
140 //*************************************************************************
144 //*************************************************************************
145 wstring(size_type count, value_type c)
146 : iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
147 {
148 this->initialise();
149 this->resize(count, c);
150 }
151
152 //*************************************************************************
157 //*************************************************************************
158 template <typename TIterator>
160 : iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
161 {
162 this->assign(first, last);
163 }
164
165#if ETL_HAS_INITIALIZER_LIST
166 //*************************************************************************
168 //*************************************************************************
169 wstring(std::initializer_list<value_type> init)
170 : iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
171 {
172 this->assign(init.begin(), init.end());
173 }
174#endif
175
176 //*************************************************************************
179 //*************************************************************************
181 : iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
182 {
183 this->assign(view.begin(), view.end());
184 }
185
186 //*************************************************************************
190 //*************************************************************************
192 {
194
195 if (position != size())
196 {
197 ETL_ASSERT(position < size(), ETL_ERROR(string_out_of_bounds));
198
199 length_ = etl::min(length_, size() - position);
200
201 new_string.assign(buffer + position, buffer + position + length_);
202 }
203
204 return new_string;
205 }
206
207 //*************************************************************************
209 //*************************************************************************
211 {
212 if (&rhs != this)
213 {
214 this->assign(rhs);
215 }
216
217 return *this;
218 }
219
220 //*************************************************************************
222 //*************************************************************************
223 wstring& operator = (const value_type* text)
224 {
225 this->assign(text);
226
227 return *this;
228 }
229
230 //*************************************************************************
232 //*************************************************************************
233#if ETL_HAS_ISTRING_REPAIR
234 virtual void repair() ETL_OVERRIDE
235#else
236 void repair()
237#endif
238 {
240 }
241
242 private:
243
244 value_type buffer[MAX_SIZE + 1];
245 };
246
247 //***************************************************************************
250 //***************************************************************************
251 class wstring_ext : public iwstring
252 {
253 public:
254
255 typedef iwstring base_type;
256 typedef iwstring interface_type;
257
258 typedef iwstring::value_type value_type;
259
260 //*************************************************************************
262 //*************************************************************************
263 wstring_ext(value_type* buffer, size_type buffer_size)
264 : iwstring(buffer, buffer_size - 1U)
265 {
266 this->initialise();
267 }
268
269 //*************************************************************************
272 //*************************************************************************
273 wstring_ext(const etl::wstring_ext& other, value_type* buffer, size_type buffer_size)
274 : iwstring(buffer, buffer_size - 1U)
275 {
276 this->assign(other);
277 }
278
279 //*************************************************************************
282 //*************************************************************************
283 wstring_ext(const etl::iwstring& other, value_type* buffer, size_type buffer_size)
284 : iwstring(buffer, buffer_size - 1U)
285 {
286 this->assign(other);
287 }
288
289 //*************************************************************************
294 //*************************************************************************
295 wstring_ext(const etl::iwstring& other, value_type* buffer, size_type buffer_size, size_type position, size_type length = npos)
296 : iwstring(buffer, buffer_size - 1U)
297 {
298 ETL_ASSERT(position < other.size(), ETL_ERROR(string_out_of_bounds));
299
300 this->assign(other, position, length);
301 }
302
303 //*************************************************************************
306 //*************************************************************************
307 wstring_ext(const value_type* text, value_type* buffer, size_type buffer_size)
308 : iwstring(buffer, buffer_size - 1U)
309 {
310 // Is the initial text at the same address as the buffer?
311 if (text == buffer)
312 {
313 this->current_size = etl::strlen(buffer);
314 }
315 else
316 {
317 this->assign(text, text + etl::strlen(text));
318 }
319 }
320
321 //*************************************************************************
325 //*************************************************************************
326 wstring_ext(const value_type* text, size_type count, value_type* buffer, size_type buffer_size)
327 : iwstring(buffer, buffer_size - 1U)
328 {
329 this->assign(text, text + count);
330 }
331
332 //*************************************************************************
336 //*************************************************************************
337 wstring_ext(size_type count, value_type c, value_type* buffer, size_type buffer_size)
338 : iwstring(buffer, buffer_size - 1U)
339 {
340 this->initialise();
341 this->resize(count, c);
342 }
343
344 //*************************************************************************
349 //*************************************************************************
350 template <typename TIterator>
351 wstring_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
352 : iwstring(buffer, buffer_size - 1U)
353 {
354 this->assign(first, last);
355 }
356
357#if ETL_HAS_INITIALIZER_LIST
358 //*************************************************************************
360 //*************************************************************************
361 wstring_ext(std::initializer_list<value_type> init, value_type* buffer, size_type buffer_size)
362 : iwstring(buffer, buffer_size - 1U)
363 {
364 this->assign(init.begin(), init.end());
365 }
366#endif
367
368 //*************************************************************************
371 //*************************************************************************
372 explicit wstring_ext(const etl::wstring_view& view, value_type* buffer, size_type buffer_size)
373 : iwstring(buffer, buffer_size - 1U)
374 {
375 this->assign(view.begin(), view.end());
376 }
377
378 //*************************************************************************
380 //*************************************************************************
382 {
383 if (&rhs != this)
384 {
385 this->assign(rhs);
386 }
387
388 return *this;
389 }
390
391
392 //*************************************************************************
394 //*************************************************************************
396 {
397 if (&rhs != this)
398 {
399 this->assign(rhs);
400 }
401
402 return *this;
403 }
404
405 //*************************************************************************
407 //*************************************************************************
408 wstring_ext& operator = (const value_type* text)
409 {
410 this->assign(text);
411
412 return *this;
413 }
414
415 //*************************************************************************
417 //*************************************************************************
418#if ETL_HAS_ISTRING_REPAIR
419 virtual void repair() ETL_OVERRIDE
420#else
421 void repair()
422#endif
423 {
424 }
425
426 private:
427
428 //*************************************************************************
430 //*************************************************************************
431 wstring_ext(const wstring_ext& other) ETL_DELETE;
432 };
433
434 //*************************************************************************
436 //*************************************************************************
437#if ETL_USING_8BIT_TYPES
438 template <>
439 struct hash<etl::iwstring>
440 {
441 size_t operator()(const etl::iwstring& text) const
442 {
443 return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
444 reinterpret_cast<const uint8_t*>(text.data() + text.size()));
445 }
446 };
447
448 template <size_t SIZE>
449 struct hash<etl::wstring<SIZE> >
450 {
451 size_t operator()(const etl::wstring<SIZE>& text) const
452 {
453 return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
454 reinterpret_cast<const uint8_t*>(text.data() + text.size()));
455 }
456 };
457
458 template <>
459 struct hash<etl::wstring_ext>
460 {
461 size_t operator()(const etl::wstring_ext& text) const
462 {
463 return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
464 reinterpret_cast<const uint8_t*>(text.data() + text.size()));
465 }
466 };
467#endif
468
469 //***************************************************************************
471 //***************************************************************************
472 template<size_t Array_Size>
473 etl::wstring<Array_Size - 1U> make_string(const wchar_t(&text)[Array_Size])
474 {
475 return etl::wstring<Array_Size - 1U>(text, etl::strlen(text, Array_Size - 1U));
476 }
477
478 //***************************************************************************
480 //***************************************************************************
481 template<size_t MAX_SIZE, size_t SIZE>
483 {
484 return etl::wstring<MAX_SIZE>(text, etl::strlen(text, SIZE));
485 }
486}
487
488#include "private/minmax_pop.h"
489
490#endif
Definition basic_string.h:326
void resize(size_type new_size)
Definition basic_string.h:456
void assign(const etl::ibasic_string< T > &other)
Definition basic_string.h:636
pointer data()
Definition basic_string.h:599
void initialise()
Initialise the string.
Definition basic_string.h:2299
void repair_buffer(T *p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition basic_string.h:2312
size_type length() const
Definition basic_string.h:185
size_type current_size
The current number of elements in the string.
Definition basic_string.h:311
size_type size() const
Definition basic_string.h:176
Definition basic_string.h:98
Definition wstring.h:252
wstring_ext(const etl::iwstring &other, value_type *buffer, size_type buffer_size)
Definition wstring.h:283
wstring_ext(size_type count, value_type c, value_type *buffer, size_type buffer_size)
Definition wstring.h:337
wstring_ext(const value_type *text, value_type *buffer, size_type buffer_size)
Definition wstring.h:307
wstring_ext(value_type *buffer, size_type buffer_size)
Constructor.
Definition wstring.h:263
wstring_ext(TIterator first, TIterator last, value_type *buffer, size_type buffer_size, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition wstring.h:351
wstring_ext & operator=(const wstring_ext &rhs)
Assignment operator.
Definition wstring.h:381
wstring_ext(const etl::wstring_view &view, value_type *buffer, size_type buffer_size)
Definition wstring.h:372
wstring_ext(const etl::iwstring &other, value_type *buffer, size_type buffer_size, size_type position, size_type length=npos)
Definition wstring.h:295
void repair()
Fix the internal pointers after a low level memory copy.
Definition wstring.h:421
wstring_ext(const etl::wstring_ext &other, value_type *buffer, size_type buffer_size)
Definition wstring.h:273
wstring_ext(const value_type *text, size_type count, value_type *buffer, size_type buffer_size)
Definition wstring.h:326
Definition wstring.h:66
wstring(const value_type *text, size_type count)
Definition wstring.h:134
wstring(const etl::iwstring &other)
Definition wstring.h:99
wstring(const etl::iwstring &other, size_type position, size_type length=npos)
Definition wstring.h:111
wstring(const etl::wstring_view &view)
Definition wstring.h:180
ETL_EXPLICIT_STRING_FROM_CHAR wstring(const value_type *text)
Definition wstring.h:123
wstring & operator=(const wstring &rhs)
Assignment operator.
Definition wstring.h:210
void repair()
Fix the internal pointers after a low level memory copy.
Definition wstring.h:236
wstring(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition wstring.h:159
wstring()
Constructor.
Definition wstring.h:79
wstring(size_type count, value_type c)
Definition wstring.h:145
wstring(const etl::wstring< MAX_SIZE_ > &other)
Definition wstring.h:89
etl::wstring< MAX_SIZE_ > substr(size_type position=0, size_type length_=npos) const
Definition wstring.h:191
#define ETL_ASSERT(b, e)
Definition error_handler.h:316
enable_if
Definition type_traits_generator.h:1191
is_integral
Definition type_traits_generator.h:1001
bitset_ext
Definition absolute.h:38
etl::string< Array_Size - 1U > make_string(const char(&text)[Array_Size])
Hash function.
Definition string.h:493
etl::string< MAX_SIZE > make_string_with_capacity(const char(&text)[SIZE])
Make string with max capacity from string literal or array.
Definition string.h:502
ETL_CONSTEXPR14 size_t strlen(const T *t)
Alternative strlen for all character types.
Definition char_traits.h:285
Character traits for any character type.
Definition char_traits.h:120
pair holds two objects of arbitrary type
Definition utility.h:164
ETL_CONSTEXPR pair()
Default constructor.
Definition utility.h:176