Embedded Template Library 1.0
u16string.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_U16STRING_INCLUDED
32#define ETL_U16STRING_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::u16string_view operator ""_sv(const char16_t* str, size_t length) noexcept
50 {
51 return etl::u16string_view{ str, length };
52 }
53 }
54 }
55#endif
56
57 typedef ibasic_string<char16_t> iu16string;
58
59 //***************************************************************************
63 //***************************************************************************
64 template <size_t MAX_SIZE_>
65 class u16string : public iu16string
66 {
67 public:
68
69 typedef iu16string base_type;
71
72 typedef iu16string::value_type value_type;
73
74 static const size_t MAX_SIZE = MAX_SIZE_;
75
76 //*************************************************************************
78 //*************************************************************************
80 : iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
81 {
82 this->initialise();
83 }
84
85 //*************************************************************************
88 //*************************************************************************
90 : iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
91 {
92 this->assign(other);
93 }
94
95 //*************************************************************************
98 //*************************************************************************
100 : iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
101 {
102 this->assign(other);
103 }
104
105 //*************************************************************************
110 //*************************************************************************
111 u16string(const etl::iu16string& other, size_type position, size_type length = npos)
112 : iu16string(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 u16string(const value_type* text)
124 : iu16string(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 u16string(const value_type* text, size_type count)
135 : iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
136 {
137 this->assign(text, text + count);
138 }
139
140 //*************************************************************************
144 //*************************************************************************
145 u16string(size_type count, value_type c)
146 : iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
147 {
148 this->initialise();
149 this->resize(count, c);
150 }
151
152 //*************************************************************************
157 //*************************************************************************
158 template <typename TIterator>
159 u16string(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
160 : iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
161 {
162 this->assign(first, last);
163 }
164
165#if ETL_HAS_INITIALIZER_LIST
166 //*************************************************************************
168 //*************************************************************************
169 u16string(std::initializer_list<value_type> init)
170 : iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
171 {
172 this->assign(init.begin(), init.end());
173 }
174#endif
175
176 //*************************************************************************
179 //*************************************************************************
180 explicit u16string(const etl::u16string_view& view)
181 : iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
182 {
183 this->assign(view.begin(), view.end());
184 }
185
186 //*************************************************************************
190 //*************************************************************************
191 etl::u16string<MAX_SIZE_> substr(size_type position = 0, size_type length_ = npos) const
192 {
193 etl::u16string<MAX_SIZE_> new_string;
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 u16string& operator = (const value_type* text)
224 {
225 this->assign(text);
226
227 return *this;
228 }
229
230 //*************************************************************************
232 //*************************************************************************
233 void repair()
234#if ETL_HAS_ISTRING_REPAIR
235 ETL_OVERRIDE
236#endif
237 {
239 }
240
241 private:
242
243 value_type buffer[MAX_SIZE + 1];
244 };
245
246 //***************************************************************************
249 //***************************************************************************
251 {
252 public:
253
254 typedef iu16string base_type;
256
257 typedef iu16string::value_type value_type;
258
259 //*************************************************************************
261 //*************************************************************************
262 u16string_ext(value_type* buffer, size_type buffer_size)
263 : iu16string(buffer, buffer_size - 1U)
264 {
265 this->initialise();
266 }
267
268 //*************************************************************************
271 //*************************************************************************
272 u16string_ext(const etl::u16string_ext& other, value_type* buffer, size_type buffer_size)
273 : iu16string(buffer, buffer_size - 1U)
274 {
275 this->assign(other);
276 }
277
278 //*************************************************************************
281 //*************************************************************************
282 u16string_ext(const etl::iu16string& other, value_type* buffer, size_type buffer_size)
283 : iu16string(buffer, buffer_size - 1U)
284 {
285 this->assign(other);
286 }
287
288 //*************************************************************************
293 //*************************************************************************
294 u16string_ext(const etl::iu16string& other, value_type* buffer, size_type buffer_size, size_type position, size_type length = npos)
295 : iu16string(buffer, buffer_size - 1U)
296 {
297 ETL_ASSERT(position < other.size(), ETL_ERROR(string_out_of_bounds));
298
299 this->assign(other, position, length);
300 }
301
302 //*************************************************************************
305 //*************************************************************************
306 u16string_ext(const value_type* text, value_type* buffer, size_type buffer_size)
307 : iu16string(buffer, buffer_size - 1U)
308 {
309 // Is the initial text at the same address as the buffer?
310 if (text == buffer)
311 {
312 this->current_size = etl::strlen(buffer);
313 }
314 else
315 {
316 this->assign(text, text + etl::strlen(text));
317 }
318 }
319
320 //*************************************************************************
324 //*************************************************************************
325 u16string_ext(const value_type* text, size_type count, value_type* buffer, size_type buffer_size)
326 : iu16string(buffer, buffer_size - 1U)
327 {
328 this->assign(text, text + count);
329 }
330
331 //*************************************************************************
335 //*************************************************************************
336 u16string_ext(size_type count, value_type c, value_type* buffer, size_type buffer_size)
337 : iu16string(buffer, buffer_size - 1U)
338 {
339 this->initialise();
340 this->resize(count, c);
341 }
342
343 //*************************************************************************
348 //*************************************************************************
349 template <typename TIterator>
350 u16string_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
351 : iu16string(buffer, buffer_size - 1U)
352 {
353 this->assign(first, last);
354 }
355
356#if ETL_HAS_INITIALIZER_LIST
357 //*************************************************************************
359 //*************************************************************************
360 u16string_ext(std::initializer_list<value_type> init, value_type* buffer, size_type buffer_size)
361 : iu16string(buffer, buffer_size - 1U)
362 {
363 this->assign(init.begin(), init.end());
364 }
365#endif
366
367 //*************************************************************************
370 //*************************************************************************
371 explicit u16string_ext(const etl::u16string_view& view, value_type* buffer, size_type buffer_size)
372 : iu16string(buffer, buffer_size - 1U)
373 {
374 this->assign(view.begin(), view.end());
375 }
376
377 //*************************************************************************
379 //*************************************************************************
381 {
382 if (&rhs != this)
383 {
384 this->assign(rhs);
385 }
386
387 return *this;
388 }
389
390
391 //*************************************************************************
393 //*************************************************************************
395 {
396 if (&rhs != this)
397 {
398 this->assign(rhs);
399 }
400
401 return *this;
402 }
403
404 //*************************************************************************
406 //*************************************************************************
407 u16string_ext& operator = (const value_type* text)
408 {
409 this->assign(text);
410
411 return *this;
412 }
413
414 //*************************************************************************
416 //*************************************************************************
417 void repair()
418#if ETL_HAS_ISTRING_REPAIR
419 ETL_OVERRIDE
420#endif
421 {
422 }
423
424 private:
425
426 //*************************************************************************
428 //*************************************************************************
429 u16string_ext(const u16string_ext& other) ETL_DELETE;
430 };
431
432 //*************************************************************************
434 //*************************************************************************
435#if ETL_USING_8BIT_TYPES
436 template <>
437 struct hash<etl::iu16string>
438 {
439 size_t operator()(const etl::iu16string& text) const
440 {
441 return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
442 reinterpret_cast<const uint8_t*>(text.data() + text.size()));
443 }
444 };
445
446 template <size_t SIZE>
447 struct hash<etl::u16string<SIZE> >
448 {
449 size_t operator()(const etl::u16string<SIZE>& text) const
450 {
451 return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
452 reinterpret_cast<const uint8_t*>(text.data() + text.size()));
453 }
454 };
455
456 template <>
457 struct hash<etl::u16string_ext >
458 {
459 size_t operator()(const etl::u16string_ext& text) const
460 {
461 return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
462 reinterpret_cast<const uint8_t*>(text.data() + text.size()));
463 }
464 };
465#endif
466
467 //***************************************************************************
469 //***************************************************************************
470 template<size_t Array_Size>
471 etl::u16string<Array_Size - 1U> make_string(const char16_t(&text)[Array_Size])
472 {
473 return etl::u16string<Array_Size - 1U>(text, etl::strlen(text, Array_Size - 1U));
474 }
475
476 //***************************************************************************
478 //***************************************************************************
479 template<size_t MAX_SIZE, size_t SIZE>
481 {
482 return etl::u16string<MAX_SIZE>(text, etl::strlen(text, SIZE));
483 }
484}
485
486#include "private/minmax_pop.h"
487
488#endif
String view.
Definition: string_view.h:96
ETL_CONSTEXPR const_iterator begin() const
Returns a const iterator to the beginning of the array.
Definition: string_view.h:193
ETL_CONSTEXPR const_iterator end() const
Returns a const iterator to the end of the array.
Definition: string_view.h:209
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:626
pointer data()
Definition: basic_string.h:589
void initialise()
Initialise the string.
Definition: basic_string.h:2289
void repair_buffer(T *p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition: basic_string.h:2302
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: u16string.h:251
u16string_ext & operator=(const u16string_ext &rhs)
Assignment operator.
Definition: u16string.h:380
u16string_ext(size_type count, value_type c, value_type *buffer, size_type buffer_size)
Definition: u16string.h:336
u16string_ext(value_type *buffer, size_type buffer_size)
Constructor.
Definition: u16string.h:262
u16string_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: u16string.h:350
u16string_ext(const etl::u16string_view &view, value_type *buffer, size_type buffer_size)
Definition: u16string.h:371
u16string_ext(const value_type *text, size_type count, value_type *buffer, size_type buffer_size)
Definition: u16string.h:325
u16string_ext(const etl::iu16string &other, value_type *buffer, size_type buffer_size, size_type position, size_type length=npos)
Definition: u16string.h:294
u16string_ext(const etl::iu16string &other, value_type *buffer, size_type buffer_size)
Definition: u16string.h:282
void repair()
Fix the internal pointers after a low level memory copy.
Definition: u16string.h:417
u16string_ext(const value_type *text, value_type *buffer, size_type buffer_size)
Definition: u16string.h:306
u16string_ext(const etl::u16string_ext &other, value_type *buffer, size_type buffer_size)
Definition: u16string.h:272
Definition: u16string.h:66
u16string(const etl::iu16string &other)
Definition: u16string.h:99
u16string(const etl::iu16string &other, size_type position, size_type length=npos)
Definition: u16string.h:111
etl::u16string< MAX_SIZE_ > substr(size_type position=0, size_type length_=npos) const
Definition: u16string.h:191
u16string(size_type count, value_type c)
Definition: u16string.h:145
u16string(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition: u16string.h:159
u16string & operator=(const u16string &rhs)
Assignment operator.
Definition: u16string.h:210
u16string(const etl::u16string_view &view)
Definition: u16string.h:180
u16string(const etl::u16string< MAX_SIZE_ > &other)
Definition: u16string.h:89
u16string()
Constructor.
Definition: u16string.h:79
u16string(const value_type *text, size_type count)
Definition: u16string.h:134
void repair()
Fix the internal pointers after a low level memory copy.
Definition: u16string.h:233
#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:491
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:500
ETL_CONSTEXPR size_t strlen(const T *t)
Alternative strlen for all character types.
Definition: char_traits.h:267
Character traits for any character type.
Definition: char_traits.h:102