source: mainline/uspace/lib/cpp/include/impl/string.hpp@ 15b8b85e

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 15b8b85e was 2e0256b, checked in by Dzejrou <dzejrou@…>, 7 years ago

cpp: moved string extractors and inserters to their own internal header to avoid circular dependencies, added padding to string extractor, implemented std::getline and fixed formatted string i/o
  • Property mode set to 100644
File size: 58.8 KB
Line 
1/*
2 * Copyright (c) 2017 Jaroslav Jindrak
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#ifndef LIBCPP_STRING
30#define LIBCPP_STRING
31
32#include <algorithm>
33#include <iosfwd>
34#include <iterator>
35#include <cstdio>
36#include <cstdlib>
37#include <cstring>
38#include <cwchar>
39#include <memory>
40#include <utility>
41
42#include <initializer_list>
43
44namespace std
45{
46
47 /**
48 * 21.2, char_traits:
49 */
50
51 template<class Char>
52 struct char_traits;
53
54 /**
55 * 21.2.3, char_traits specializations:
56 */
57
58 template<>
59 struct char_traits<char>
60 {
61 using char_type = char;
62 using int_type = int;
63 using off_type = streamoff;
64 using pos_type = streampos;
65 /* using state_type = mbstate_t; */
66
67 static void assign(char_type& c1, const char_type& c2) noexcept
68 {
69 c1 = c2;
70 }
71
72 static constexpr bool eq(char_type c1, char_type c2) noexcept
73 {
74 return c1 == c2;
75 }
76
77 static constexpr bool lt(char_type c1, char_type c2) noexcept
78 {
79 return c1 < c2;
80 }
81
82 static int compare(const char_type* s1, const char_type* s2, size_t n)
83 {
84 return std::str_lcmp(s1, s2, n);
85 }
86
87 static size_t length(const char_type* s)
88 {
89 return std::str_size(s);
90 }
91
92 static const char_type* find(const char_type* s, size_t n, const char_type& c)
93 {
94 size_t i{};
95 while (i++ < n)
96 {
97 if (s[i] == c)
98 return s + i;
99 }
100
101 return nullptr;
102 }
103
104 static char_type* move(char_type* s1, const char_type* s2, size_t n)
105 {
106 return static_cast<char_type*>(memmove(s1, s2, n));
107 }
108
109 static char_type* copy(char_type* s1, const char_type* s2, size_t n)
110 {
111 return static_cast<char_type*>(memcpy(s1, s2, n));
112 }
113
114 static char_type* assign(char_type* s, size_t n, char_type c)
115 {
116 /**
117 * Note: Even though memset accepts int as its second argument,
118 * the actual implementation assigns that int to a dereferenced
119 * char pointer.
120 */
121 return static_cast<char_type*>(memset(s, static_cast<int>(c), n));
122 }
123
124 static constexpr int_type not_eof(int_type c) noexcept
125 {
126 if (!eq_int_type(c, eof()))
127 return c;
128 else
129 return to_int_type('a'); // We just need something that is not eof.
130 }
131
132 static constexpr char_type to_char_type(int_type c) noexcept
133 {
134 return static_cast<char_type>(c);
135 }
136
137 static constexpr int_type to_int_type(char_type c) noexcept
138 {
139 return static_cast<int_type>(c);
140 }
141
142 static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept
143 {
144 return c1 == c2;
145 }
146
147 static constexpr int_type eof() noexcept
148 {
149 return static_cast<int_type>(EOF);
150 }
151 };
152
153 template<>
154 struct char_traits<char16_t>
155 {
156 // TODO: implement
157 using char_type = char16_t;
158 using int_type = int16_t;
159 using off_type = streamoff;
160 using pos_type = streampos;
161 /* using state_type = mbstate_t; */
162
163 static void assign(char_type& c1, const char_type& c2) noexcept
164 {
165 c1 = c2;
166 }
167
168 static constexpr bool eq(char_type c1, char_type c2) noexcept
169 {
170 return c1 == c2;
171 }
172
173 static constexpr bool lt(char_type c1, char_type c2) noexcept
174 {
175 return c1 < c2;
176 }
177
178 static int compare(const char_type* s1, const char_type* s2, size_t n)
179 {
180 // TODO: implement
181 return 0;
182 }
183
184 static size_t length(const char_type* s)
185 {
186 // TODO: implement
187 return 0;
188 }
189
190 static const char_type* find(const char_type* s, size_t n, const char_type& c)
191 {
192 // TODO: implement
193 return nullptr;
194 }
195
196 static char_type* move(char_type* s1, const char_type* s2, size_t n)
197 {
198 // TODO: implement
199 return nullptr;
200 }
201
202 static char_type* copy(char_type* s1, const char_type* s2, size_t n)
203 {
204 // TODO: implement
205 return nullptr;
206 }
207
208 static char_type* assign(char_type* s, size_t n, char_type c)
209 {
210 // TODO: implement
211 return nullptr;
212 }
213
214 static constexpr int_type not_eof(int_type c) noexcept
215 {
216 // TODO: implement
217 return int_type{};
218 }
219
220 static constexpr char_type to_char_type(int_type c) noexcept
221 {
222 return static_cast<char_type>(c);
223 }
224
225 static constexpr int_type to_int_type(char_type c) noexcept
226 {
227 return static_cast<int_type>(c);
228 }
229
230 static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept
231 {
232 return c1 == c2;
233 }
234
235 static constexpr int_type eof() noexcept
236 {
237 return static_cast<int_type>(EOF);
238 }
239 };
240
241 template<>
242 struct char_traits<char32_t>
243 {
244 // TODO: implement
245 using char_type = char32_t;
246 using int_type = int32_t;
247 using off_type = streamoff;
248 using pos_type = streampos;
249 /* using state_type = mbstate_t; */
250
251 static void assign(char_type& c1, const char_type& c2) noexcept
252 {
253 c1 = c2;
254 }
255
256 static constexpr bool eq(char_type c1, char_type c2) noexcept
257 {
258 return c1 == c2;
259 }
260
261 static constexpr bool lt(char_type c1, char_type c2) noexcept
262 {
263 return c1 < c2;
264 }
265
266 static int compare(const char_type* s1, const char_type* s2, size_t n)
267 {
268 // TODO: implement
269 return 0;
270 }
271
272 static size_t length(const char_type* s)
273 {
274 // TODO: implement
275 return 0;
276 }
277
278 static const char_type* find(const char_type* s, size_t n, const char_type& c)
279 {
280 // TODO: implement
281 return nullptr;
282 }
283
284 static char_type* move(char_type* s1, const char_type* s2, size_t n)
285 {
286 // TODO: implement
287 return nullptr;
288 }
289
290 static char_type* copy(char_type* s1, const char_type* s2, size_t n)
291 {
292 // TODO: implement
293 return nullptr;
294 }
295
296 static char_type* assign(char_type* s, size_t n, char_type c)
297 {
298 // TODO: implement
299 return nullptr;
300 }
301
302 static constexpr int_type not_eof(int_type c) noexcept
303 {
304 // TODO: implement
305 return int_type{};
306 }
307
308 static constexpr char_type to_char_type(int_type c) noexcept
309 {
310 return static_cast<char_type>(c);
311 }
312
313 static constexpr int_type to_int_type(char_type c) noexcept
314 {
315 return static_cast<int_type>(c);
316 }
317
318 static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept
319 {
320 return c1 == c2;
321 }
322
323 static constexpr int_type eof() noexcept
324 {
325 return static_cast<int_type>(EOF);
326 }
327 };
328
329 template<>
330 struct char_traits<wchar_t>
331 {
332 using char_type = wchar_t;
333 using int_type = wint_t;
334 using off_type = streamoff;
335 using pos_type = wstreampos;
336 /* using state_type = mbstate_t; */
337
338 static void assign(char_type& c1, const char_type& c2) noexcept
339 {
340 c1 = c2;
341 }
342
343 static constexpr bool eq(char_type c1, char_type c2) noexcept
344 {
345 return c1 == c2;
346 }
347
348 static constexpr bool lt(char_type c1, char_type c2) noexcept
349 {
350 return c1 < c2;
351 }
352
353 static int compare(const char_type* s1, const char_type* s2, size_t n)
354 {
355 // TODO: This function does not exits...
356 //return std::wstr_lcmp(s1, s2, n);
357 return 0;
358 }
359
360 static size_t length(const char_type* s)
361 {
362 return std::wstr_size(s);
363 }
364
365 static const char_type* find(const char_type* s, size_t n, const char_type& c)
366 {
367 size_t i{};
368 while (i++ < n)
369 {
370 if (s[i] == c)
371 return s + i;
372 }
373
374 return nullptr;
375 }
376
377 static char_type* move(char_type* s1, const char_type* s2, size_t n)
378 {
379 return static_cast<char_type*>(memmove(s1, s2, n * sizeof(wchar_t)));
380 }
381
382 static char_type* copy(char_type* s1, const char_type* s2, size_t n)
383 {
384 return static_cast<char_type*>(memcpy(s1, s2, n * sizeof(wchar_t)));
385 }
386
387 static char_type* assign(char_type* s, size_t n, char_type c)
388 {
389 return static_cast<char_type*>(memset(s, static_cast<int>(c), n * sizeof(wchar_t)));
390 }
391
392 static constexpr int_type not_eof(int_type c) noexcept
393 {
394 if (!eq_int_type(c, eof()))
395 return c;
396 else
397 return to_int_type(L'a'); // We just need something that is not eof.
398 }
399
400 static constexpr char_type to_char_type(int_type c) noexcept
401 {
402 return static_cast<char_type>(c);
403 }
404
405 static constexpr int_type to_int_type(char_type c) noexcept
406 {
407 return static_cast<int_type>(c);
408 }
409
410 static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept
411 {
412 return c1 == c2;
413 }
414
415 static constexpr int_type eof() noexcept
416 {
417 return static_cast<int_type>(EOF);
418 }
419 };
420
421 /**
422 * 21.4, class template basic_string:
423 */
424
425 template<class Char, class Traits = char_traits<Char>,
426 class Allocator = allocator<Char>>
427 class basic_string
428 {
429 public:
430 using traits_type = Traits;
431 using value_type = typename traits_type::char_type;
432 using allocator_type = Allocator;
433 using size_type = typename allocator_traits<allocator_type>::size_type;
434 using difference_type = typename allocator_traits<allocator_type>::difference_type;
435
436 using reference = value_type&;
437 using const_reference = const value_type&;
438 using pointer = typename allocator_traits<allocator_type>::pointer;
439 using const_pointer = typename allocator_traits<allocator_type>::const_pointer;
440
441 using iterator = pointer;
442 using const_iterator = const_pointer;
443 using reverse_iterator = std::reverse_iterator<iterator>;
444 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
445
446 static constexpr size_type npos = -1;
447
448 /**
449 * 21.4.2, construct/copy/destroy:
450 */
451 basic_string() noexcept
452 : basic_string(allocator_type{})
453 { /* DUMMY BODY */ }
454
455 explicit basic_string(const allocator_type& alloc)
456 : data_{}, size_{}, capacity_{}, allocator_{alloc}
457 {
458 /**
459 * Postconditions:
460 * data() = non-null copyable value that can have 0 added to it.
461 * size() = 0
462 * capacity() = unspecified
463 */
464 data_ = allocator_.allocate(default_capacity_);
465 capacity_ = default_capacity_;
466 }
467
468 basic_string(const basic_string& other)
469 : data_{}, size_{other.size_}, capacity_{other.capacity_},
470 allocator_{other.allocator_}
471 {
472 init_(other.data(), size_);
473 }
474
475 basic_string(basic_string&& other)
476 : data_{other.data_}, size_{other.size_},
477 capacity_{other.capacity_}, allocator_{move(other.allocator_)}
478 {
479 other.data_ = nullptr;
480 other.size_ = 0;
481 other.capacity_ = 0;
482 }
483
484 basic_string(const basic_string& other, size_type pos, size_type n = npos,
485 const allocator_type& alloc = allocator_type{})
486 : data_{}, size_{}, capacity_{}, allocator_{alloc}
487 {
488 // TODO: if pos < other.size() throw out_of_range.
489 auto len = min(n, other.size() - pos);
490 init_(other.data() + pos, len);
491 }
492
493 basic_string(const value_type* str, size_type n, const allocator_type& alloc = allocator_type{})
494 : data_{}, size_{n}, capacity_{n}, allocator_{alloc}
495 {
496 init_(str, size_);
497 }
498
499 basic_string(const value_type* str, const allocator_type& alloc = allocator_type{})
500 : data_{}, size_{}, capacity_{}, allocator_{alloc}
501 {
502 init_(str, traits_type::length(str));
503 }
504
505 basic_string(size_type n, value_type c, const allocator_type& alloc = allocator_type{})
506 : data_{}, size_{n}, capacity_{n}, allocator_{alloc}
507 {
508 data_ = allocator_.allocate(capacity_);
509 for (size_type i = 0; i < size_; ++i)
510 traits_type::assign(data_[i], c);
511 ensure_null_terminator_();
512 }
513
514 template<class InputIterator>
515 basic_string(InputIterator first, InputIterator last,
516 const allocator_type& alloc = allocator_type{})
517 : data_{}, size_{}, capacity_{}, allocator_{alloc}
518 {
519 if constexpr (is_integral<InputIterator>::value)
520 { // Required by the standard.
521 size_ = static_cast<size_type>(first);
522 capacity_ = size_;
523 data_ = allocator_.allocate(capacity_);
524
525 for (size_type i = 0; i < size_; ++i)
526 traits_type::assign(data_[i], static_cast<value_type>(last));
527 ensure_null_terminator_();
528 }
529 else
530 {
531 auto len = static_cast<size_type>(last - first);
532 init_(first, len);
533 }
534 }
535
536 basic_string(initializer_list<value_type> init, const allocator_type& alloc = allocator_type{})
537 : basic_string{init.begin(), init.size(), alloc}
538 { /* DUMMY BODY */ }
539
540 basic_string(const basic_string& other, const allocator_type& alloc)
541 : data_{}, size_{other.size_}, capacity_{other.capacity_}, allocator_{alloc}
542 {
543 init_(other.data(), size_);
544 }
545
546 basic_string(basic_string&& other, const allocator_type& alloc)
547 : data_{other.data_}, size_{other.size_}, capacity_{other.capacity_}, allocator_{alloc}
548 {
549 other.data_ = nullptr;
550 other.size_ = 0;
551 other.capacity_ = 0;
552 }
553
554 ~basic_string()
555 {
556 allocator_.deallocate(data_, capacity_);
557 }
558
559 basic_string& operator=(const basic_string& other)
560 {
561 if (this != &other)
562 {
563 basic_string tmp{other};
564 swap(tmp);
565 }
566
567 return *this;
568 }
569
570 basic_string& operator=(basic_string&& other)
571 noexcept(allocator_traits<allocator_type>::propagate_on_container_move_assignment::value ||
572 allocator_traits<allocator_type>::is_always_equal::value)
573 {
574 if (this != &other)
575 swap(other);
576
577 return *this;
578 }
579
580 basic_string& operator=(const value_type* other)
581 {
582 *this = basic_string{other};
583
584 return *this;
585 }
586
587 basic_string& operator=(value_type c)
588 {
589 *this = basic_string{1, c};
590
591 return *this;
592 }
593
594 basic_string& operator=(initializer_list<value_type> init)
595 {
596 *this = basic_string{init};
597
598 return *this;
599 }
600
601 /**
602 * 21.4.3, iterators:
603 */
604
605 iterator begin() noexcept
606 {
607 return &data_[0];
608 }
609
610 const_iterator begin() const noexcept
611 {
612 return &data_[0];
613 }
614
615 iterator end() noexcept
616 {
617 return begin() + size_;
618 }
619
620 const_iterator end() const noexcept
621 {
622 return begin() + size_;
623 }
624
625 reverse_iterator rbegin() noexcept
626 {
627 return make_reverse_iterator(end());
628 }
629
630 const_reverse_iterator rbegin() const noexcept
631 {
632 return make_reverse_iterator(cend());
633 }
634
635 reverse_iterator rend() noexcept
636 {
637 return make_reverse_iterator(begin());
638 }
639
640 const_reverse_iterator rend() const noexcept
641 {
642 return make_reverse_iterator(cbegin());
643 }
644
645 const_iterator cbegin() const noexcept
646 {
647 return &data_[0];
648 }
649
650 const_iterator cend() const noexcept
651 {
652 return cbegin() + size_;
653 }
654
655 const_reverse_iterator crbegin() const noexcept
656 {
657 return rbegin();
658 }
659
660 const_reverse_iterator crend() const noexcept
661 {
662 return rend();
663 }
664
665 /**
666 * 21.4.4, capacity:
667 */
668
669 size_type size() const noexcept
670 {
671 return size_;
672 }
673
674 size_type length() const noexcept
675 {
676 return size();
677 }
678
679 size_type max_size() const noexcept
680 {
681 return 0x7FFF; // TODO: just temporary
682 /* return allocator_traits<allocator_type>::max_size(allocator_); */
683 }
684
685 void resize(size_type new_size, value_type c)
686 {
687 // TODO: if new_size > max_size() throw length_error.
688 if (new_size > size_)
689 {
690 ensure_free_space_(new_size - size_ + 1);
691 for (size_type i = size_; i < new_size; ++i)
692 traits_type::assign(data_[i], i);
693 }
694
695 size_ = new_size;
696 ensure_null_terminator_();
697 }
698
699 void resize(size_type new_size)
700 {
701 resize(new_size, value_type{});
702 }
703
704 size_type capacity() const noexcept
705 {
706 return capacity_;
707 }
708
709 void reserve(size_type new_capacity = 0)
710 {
711 // TODO: if new_capacity > max_size() throw
712 // length_error (this function shall have no
713 // effect in such case)
714 if (new_capacity > capacity_)
715 resize_with_copy_(size_, new_capacity);
716 else if (new_capacity < capacity)
717 shrink_to_fit(); // Non-binding request, but why not.
718 }
719
720 void shrink_to_fit()
721 {
722 if (size_ != capacity_)
723 resize_with_copy_(size_);
724 }
725
726 void clear() noexcept
727 {
728 size_ = 0;
729 }
730
731 bool empty() const noexcept
732 {
733 return size_ == 0;
734 }
735
736 /**
737 * 21.4.5, element access:
738 */
739
740 const_reference operator[](size_type idx) const
741 {
742 return data_[idx];
743 }
744
745 reference operator[](size_type idx)
746 {
747 return data_[idx];
748 }
749
750 const_reference at(size_type idx) const
751 {
752 // TODO: bounds checking
753 return data_[idx];
754 }
755
756 reference at(size_type idx)
757 {
758 // TODO: bounds checking
759 return data_[idx];
760 }
761
762 const_reference front() const
763 {
764 return at(0);
765 }
766
767 reference front()
768 {
769 return at(0);
770 }
771
772 const_reference back() const
773 {
774 return at(size_ - 1);
775 }
776
777 reference back()
778 {
779 return at(size_ - 1);
780 }
781
782 /**
783 * 21.4.6, modifiers:
784 */
785
786 basic_string& operator+=(const basic_string& str)
787 {
788 return append(str);
789 }
790
791 basic_string& operator+=(const value_type* str)
792 {
793 return append(str);
794 }
795
796 basic_string& operator+=(value_type c)
797 {
798 push_back(c);
799 return *this;
800 }
801
802 basic_string& operator+=(initializer_list<value_type> init)
803 {
804 return append(init.begin(), init.size());
805 }
806
807 basic_string& append(const basic_string& str)
808 {
809 return append(str.data(), str.size());
810 }
811
812 basic_string& append(const basic_string& str, size_type pos,
813 size_type n = npos)
814 {
815 if (pos < str.size())
816 {
817 auto len = min(n, str.size() - pos);
818
819 return append(str.data() + pos, len);
820 }
821 // TODO: Else throw out_of_range.
822 }
823
824 basic_string& append(const value_type* str, size_type n)
825 {
826 // TODO: if (size_ + n > max_size()) throw length_error
827 ensure_free_space_(n);
828 traits_type::copy(data_ + size(), str, n);
829 size_ += n;
830 ensure_null_terminator_();
831
832 return *this;
833 }
834
835 basic_string& append(const value_type* str)
836 {
837 return append(str, traits_type::length(str));
838 }
839
840 basic_string& append(size_type n, value_type c)
841 {
842 return append(basic_string(n, c));
843 }
844
845 template<class InputIterator>
846 basic_string& append(InputIterator first, InputIterator last)
847 {
848 return append(basic_string(first, last));
849 }
850
851 basic_string& append(initializer_list<value_type> init)
852 {
853 return append(init.begin(), init.size());
854 }
855
856 void push_back(value_type c)
857 {
858 ensure_free_space_(1);
859 traits_type::assign(data_[size_++], c);
860 ensure_null_terminator_();
861 }
862
863 basic_string& assign(const basic_string& str)
864 {
865 return assign(str, 0, npos);
866 }
867
868 basic_string& assign(basic_string&& str)
869 {
870 swap(str);
871
872 return *this;
873 }
874
875 basic_string& assign(const basic_string& str, size_type pos,
876 size_type n = npos)
877 {
878 if (pos < str.size())
879 {
880 auto len = min(n, str.size() - pos);
881 ensure_free_space_(len);
882
883 return assign(str.data() + pos, len);
884 }
885 // TODO: Else throw out_of_range.
886
887 return *this;
888 }
889
890 basic_string& assign(const value_type* str, size_type n)
891 {
892 // TODO: if (n > max_size()) throw length_error.
893 resize_without_copy_(n);
894 traits_type::copy(begin(), str, n);
895 size_ = n;
896 ensure_null_terminator_();
897
898 return *this;
899 }
900
901 basic_string& assign(const value_type* str)
902 {
903 return assign(str, traits_type::length(str));
904 }
905
906 basic_string& assign(size_type n, value_type c)
907 {
908 return assign(basic_string(n, c));
909 }
910
911 template<class InputIterator>
912 basic_string& assign(InputIterator first, InputIterator last)
913 {
914 return assign(basic_string(first, last));
915 }
916
917 basic_string& assign(initializer_list<value_type> init)
918 {
919 return assign(init.begin(), init.size());
920 }
921
922 basic_string& insert(size_type pos, const basic_string& str)
923 {
924 // TODO: if (pos > str.size()) throw out_of_range.
925 return insert(pos, str.data(), str.size());
926 }
927
928 basic_string& insert(size_type pos1, const basic_string& str,
929 size_type pos2, size_type n = npos)
930 {
931 // TODO: if (pos1 > size() or pos2 > str.size()) throw
932 // out_of_range.
933 auto len = min(n, str.size() - pos2);
934
935 return insert(pos1, str.data() + pos2, len);
936 }
937
938 basic_string& insert(size_type pos, const value_type* str, size_type n)
939 {
940 // TODO: throw out_of_range if pos > size()
941 // TODO: throw length_error if size() + n > max_size()
942 ensure_free_space_(n);
943
944 copy_backward_(begin() + pos, end(), end() + n);
945 copy_(str, str + n, begin() + pos);
946 size_ += n;
947
948 ensure_null_terminator_();
949 return *this;
950 }
951
952 basic_string& insert(size_type pos, const value_type* str)
953 {
954 return insert(pos, str, traits_type::length(str));
955 }
956
957 basic_string& insert(size_type pos, size_type n, value_type c)
958 {
959 return insert(pos, basic_string(n, c));
960 }
961
962 iterator insert(const_iterator pos, value_type c)
963 {
964 auto idx = static_cast<size_type>(pos - begin());
965
966 ensure_free_space_(1);
967 copy_backward_(begin() + idx, end(), end() + 1);
968 traits_type::assign(data_[idx], c);
969
970 ++size_;
971 ensure_null_terminator_();
972
973 return begin() + idx;
974 }
975
976 iterator insert(const_iterator pos, size_type n, value_type c)
977 {
978 if (n == 0)
979 return const_cast<iterator>(pos);
980
981 auto idx = static_cast<size_type>(pos - begin());
982
983 ensure_free_space_(n);
984 copy_backward_(begin() + idx, end(), end() + n);
985
986 auto it = begin() + idx;
987 for (size_type i = 0; i < n; ++i)
988 traits_type::assign(*it++, c);
989 size_ += n;
990 ensure_null_terminator_();
991
992 return begin() + idx;
993 }
994
995 template<class InputIterator>
996 iterator insert(const_iterator pos, InputIterator first,
997 InputIterator last)
998 {
999 if (first == last)
1000 return const_cast<iterator>(pos);
1001
1002 auto idx = static_cast<size_type>(pos - begin());
1003 auto str = basic_string{first, last};
1004 insert(idx, str);
1005
1006 return begin() + idx;
1007 }
1008
1009 iterator insert(const_iterator pos, initializer_list<value_type> init)
1010 {
1011 return insert(pos, init.begin(), init.end());
1012 }
1013
1014 basic_string& erase(size_type pos = 0, size_type n = npos)
1015 {
1016 auto len = min(n, size_ - pos);
1017 copy_(begin() + pos + n, end(), begin() + pos);
1018 size_ -= len;
1019 ensure_null_terminator_();
1020
1021 return *this;
1022 }
1023
1024 iterator erase(const_iterator pos)
1025 {
1026 auto idx = static_cast<size_type>(pos - cbegin());
1027 erase(idx, 1);
1028
1029 return begin() + idx;
1030 }
1031
1032 iterator erase(const_iterator first, const_iterator last)
1033 {
1034 auto idx = static_cast<size_type>(first - cbegin());
1035 auto count = static_cast<size_type>(last - first);
1036 erase(idx, count);
1037
1038 return begin() + idx;
1039 }
1040
1041 void pop_back()
1042 {
1043 --size_;
1044 ensure_null_terminator_();
1045 }
1046
1047 basic_string& replace(size_type pos, size_type n, const basic_string& str)
1048 {
1049 // TODO: throw out_of_range if pos > size()
1050 return replace(pos, n, str.data(), str.size());
1051 }
1052
1053 basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
1054 size_type pos2, size_type n2 = npos)
1055 {
1056 // TODO: throw out_of_range if pos1 > size() or pos2 > str.size()
1057 auto len = min(n2, str.size() - pos2);
1058 return replace(pos1, n1, str.data() + pos2, len);
1059 }
1060
1061 basic_string& replace(size_type pos, size_type n1, const value_type* str,
1062 size_type n2)
1063 {
1064 // TODO: throw out_of_range if pos > size()
1065 // TODO: if size() - len > max_size() - n2 throw length_error
1066 auto len = min(n1, size_ - pos);
1067
1068 basic_string tmp{};
1069 tmp.resize_without_copy_(size_ - len + n2);
1070
1071 // Prefix.
1072 copy_(begin(), begin() + pos, tmp.begin());
1073
1074 // Substitution.
1075 traits_type::copy(tmp.begin() + pos, str, n2);
1076
1077 // Suffix.
1078 copy_(begin() + pos + len, end(), tmp.begin() + pos + n2);
1079
1080 tmp.size_ = size_ - len + n2;
1081 swap(tmp);
1082 return *this;
1083 }
1084
1085 basic_string& replace(size_type pos, size_type n, const value_type* str)
1086 {
1087 return replace(pos, n, str, traits_type::length(str));
1088 }
1089
1090 basic_string& replace(size_type pos, size_type n1, size_type n2,
1091 value_type c)
1092 {
1093 return replace(pos, n1, basic_string(n2, c));
1094 }
1095
1096 basic_string& replace(const_iterator i1, const_iterator i2,
1097 const basic_string& str)
1098 {
1099 return replace(i1 - begin(), i2 - i1, str);
1100 }
1101
1102 basic_string& replace(const_iterator i1, const_iterator i2,
1103 const value_type* str, size_type n)
1104 {
1105 return replace(i1 - begin(), i2 - i1, str, n);
1106 }
1107
1108 basic_string& replace(const_iterator i1, const_iterator i2,
1109 const value_type* str)
1110 {
1111 return replace(i1 - begin(), i2 - i1, str, traits_type::length(str));
1112 }
1113
1114 basic_string& replace(const_iterator i1, const_iterator i2,
1115 size_type n, value_type c)
1116 {
1117 return replace(i1 - begin(), i2 - i1, basic_string(n, c));
1118 }
1119
1120 template<class InputIterator>
1121 basic_string& replace(const_iterator i1, const_iterator i2,
1122 InputIterator j1, InputIterator j2)
1123 {
1124 return replace(i1 - begin(), i2 - i1, basic_string(j1, j2));
1125 }
1126
1127 basic_string& replace(const_iterator i1, const_iterator i2,
1128 initializer_list<value_type> init)
1129 {
1130 return replace(i1 - begin(), i2 - i1, init.begin(), init.size());
1131 }
1132
1133 size_type copy(value_type* str, size_type n, size_type pos = 0) const
1134 {
1135 auto len = min(n , size_ - pos);
1136 for (size_type i = 0; i < len; ++i)
1137 traits_type::assign(str[i], data_[pos + i]);
1138
1139 return len;
1140 }
1141
1142 void swap(basic_string& other)
1143 noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
1144 allocator_traits<allocator_type>::is_always_equal::value)
1145 {
1146 std::swap(data_, other.data_);
1147 std::swap(size_, other.size_);
1148 std::swap(capacity_, other.capacity_);
1149 }
1150
1151 /**
1152 * 21.4.7, string operations:
1153 */
1154
1155 const value_type* c_str() const noexcept
1156 {
1157 return data_;
1158 }
1159
1160 const value_type* data() const noexcept
1161 {
1162 return data_;
1163 }
1164
1165 allocator_type get_allocator() const noexcept
1166 {
1167 return allocator_type{allocator_};
1168 }
1169
1170 /**
1171 * Note: The following find functions have 4 versions each:
1172 * (1) takes basic_string
1173 * (2) takes c string and length
1174 * (3) takes c string
1175 * (4) takes value_type
1176 * According to the C++14 standard, only (1) is marked as
1177 * noexcept and the other three return the first one with
1178 * a newly allocated strings (and thus cannot be noexcept).
1179 * However, allocating a new string results in memory
1180 * allocation and copying of the source and thus we have
1181 * decided to follow C++17 signatures of these functions
1182 * (i.e. all of them being marked as noexcept) and use
1183 * (2) for the actual implementation (and avoiding any
1184 * allocations or copying in the process and also providing
1185 * stronger guarantees to the user).
1186 */
1187
1188 size_type find(const basic_string& str, size_type pos = 0) const noexcept
1189 {
1190 return find(str.c_str(), pos, str.size());
1191 }
1192
1193 size_type find(const value_type* str, size_type pos, size_type len) const noexcept
1194 {
1195 if (empty() || len == 0 || len + pos > size())
1196 return npos;
1197
1198 size_type idx{pos};
1199
1200 while (idx + len < size_)
1201 {
1202 if (substr_starts_at_(idx, str, len))
1203 return idx;
1204 ++idx;
1205 }
1206
1207 return npos;
1208 }
1209
1210 size_type find(const value_type* str, size_type pos = 0) const noexcept
1211 {
1212 return find(str, pos, traits_type::length(str));
1213 }
1214
1215 size_type find(value_type c, size_type pos = 0) const noexcept
1216 {
1217 if (empty())
1218 return npos;
1219
1220 for (size_type i = pos; i < size_; ++i)
1221 {
1222 if (traits_type::eq(c, data_[i]))
1223 return i;
1224 }
1225
1226 return npos;
1227 }
1228
1229 size_type rfind(const basic_string& str, size_type pos = npos) const noexcept
1230 {
1231 return rfind(str.c_str(), pos, str.size());
1232 }
1233
1234 size_type rfind(const value_type* str, size_type pos, size_type len) const noexcept
1235 {
1236 if (empty() || len == 0 || len + pos > size())
1237 return npos;
1238
1239 size_type idx{min(pos, size_ - 1) + 1};
1240
1241 while (idx > 0)
1242 {
1243 if (substr_starts_at_(idx - 1, str, len))
1244 return idx - 1;
1245 --idx;
1246 }
1247
1248 return npos;
1249 }
1250
1251 size_type rfind(const value_type* str, size_type pos = npos) const noexcept
1252 {
1253 return rfind(str, pos, traits_type::length(str));
1254 }
1255
1256 size_type rfind(value_type c, size_type pos = npos) const noexcept
1257 {
1258 if (empty())
1259 return npos;
1260
1261 for (size_type i = min(pos + 1, size_ - 1) + 1; i > 0; --i)
1262 {
1263 if (traits_type::eq(c, data_[i - 1]))
1264 return i - 1;
1265 }
1266
1267 return npos;
1268 }
1269
1270 size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept
1271 {
1272 return find_first_of(str.c_str(), pos, str.size());
1273 }
1274
1275 size_type find_first_of(const value_type* str, size_type pos, size_type len) const noexcept
1276 {
1277 if (empty() || len == 0 || pos >= size())
1278 return npos;
1279
1280 size_type idx{pos};
1281
1282 while (idx < size_)
1283 {
1284 if (is_any_of_(idx, str, len))
1285 return idx;
1286 ++idx;
1287 }
1288
1289 return npos;
1290 }
1291
1292 size_type find_first_of(const value_type* str, size_type pos = 0) const noexcept
1293 {
1294 return find_first_of(str, pos, traits_type::length(str));
1295 }
1296
1297 size_type find_first_of(value_type c, size_type pos = 0) const noexcept
1298 {
1299 return find(c, pos);
1300 }
1301
1302 size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept
1303 {
1304 return find_last_of(str.c_str(), pos, str.size());
1305 }
1306
1307 size_type find_last_of(const value_type* str, size_type pos, size_type len) const noexcept
1308 {
1309 if (empty() || len == 0)
1310 return npos;
1311
1312 for (size_type i = min(pos, size_ - 1) + 1; i > 0; --i)
1313 {
1314 if (is_any_of_(i - 1, str, len))
1315 return i - 1;
1316 }
1317
1318 return npos;
1319 }
1320
1321 size_type find_last_of(const value_type* str, size_type pos = npos) const noexcept
1322 {
1323 return find_last_of(str, pos, traits_type::length(str));
1324 }
1325
1326 size_type find_last_of(value_type c, size_type pos = npos) const noexcept
1327 {
1328 return rfind(c, pos);
1329 }
1330
1331 size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept
1332 {
1333 return find_first_not_of(str.c_str(), pos, str.size());
1334 }
1335
1336 size_type find_first_not_of(const value_type* str, size_type pos, size_type len) const noexcept
1337 {
1338 if (empty() || pos >= size())
1339 return npos;
1340
1341 size_type idx{pos};
1342
1343 while (idx < size_)
1344 {
1345 if (!is_any_of_(idx, str, len))
1346 return idx;
1347 ++idx;
1348 }
1349
1350 return npos;
1351 }
1352
1353 size_type find_first_not_of(const value_type* str, size_type pos = 0) const noexcept
1354 {
1355 return find_first_not_of(str, pos, traits_type::length(str));
1356 }
1357
1358 size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept
1359 {
1360 if (empty())
1361 return npos;
1362
1363 for (size_type i = pos; i < size_; ++i)
1364 {
1365 if (!traits_type::eq(c, data_[i]))
1366 return i;
1367 }
1368
1369 return npos;
1370 }
1371
1372 size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept
1373 {
1374 return find_last_not_of(str.c_str(), pos, str.size());
1375 }
1376
1377 size_type find_last_not_of(const value_type* str, size_type pos, size_type len) const noexcept
1378 {
1379 if (empty())
1380 return npos;
1381
1382 for (size_type i = min(pos, size_ - 1) + 1; i > 0; --i)
1383 {
1384 if (!is_any_of_(i - 1, str, len))
1385 return i - 1;
1386 }
1387
1388 return npos;
1389 }
1390
1391 size_type find_last_not_of(const value_type* str, size_type pos = npos) const noexcept
1392 {
1393 return find_last_not_of(str, pos, traits_type::length(str));
1394 }
1395
1396 size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept
1397 {
1398 if (empty())
1399 return npos;
1400
1401 pos = min(pos, size_ - 1);
1402
1403 for (size_type i = min(pos, size_ - 1) + 1; i > 1; --i)
1404 {
1405 if (!traits_type::eq(c, data_[i - 1]))
1406 return i - 1;
1407 }
1408
1409 return npos;
1410 }
1411
1412 basic_string substr(size_type pos = 0, size_type n = npos) const
1413 {
1414 // TODO: throw out_of_range if pos > size().
1415 auto len = min(n, size_ - pos);
1416 return basic_string{data() + pos, len};
1417 }
1418
1419 int compare(const basic_string& other) const noexcept
1420 {
1421 auto len = min(size(), other.size());
1422 auto comp = traits_type::compare(data_, other.data(), len);
1423
1424 if (comp != 0)
1425 return comp;
1426 else if (size() == other.size())
1427 return 0;
1428 else if (size() > other.size())
1429 return 1;
1430 else
1431 return -1;
1432 }
1433
1434 int compare(size_type pos, size_type n, const basic_string& other) const
1435 {
1436 return basic_string{*this, pos, n}.compare(other);
1437 }
1438
1439 int compare(size_type pos1, size_type n1, const basic_string& other,
1440 size_type pos2, size_type n2 = npos) const
1441 {
1442 return basic_string{*this, pos1, n1}.compare(basic_string{other, pos2, n2});
1443 }
1444
1445 int compare(const value_type* other) const
1446 {
1447 return compare(basic_string(other));
1448 }
1449
1450 int compare(size_type pos, size_type n, const value_type* other) const
1451 {
1452 return basic_string{*this, pos, n}.compare(basic_string{other});
1453 }
1454
1455 int compare(size_type pos, size_type n1,
1456 const value_type* other, size_type n2) const
1457 {
1458 return basic_string{*this, pos, n1}.compare(basic_string{other, n2});
1459 }
1460
1461 private:
1462 value_type* data_;
1463 size_type size_;
1464 size_type capacity_;
1465 allocator_type allocator_;
1466
1467 /**
1468 * Arbitrary value, standard just requires
1469 * data() to have some capacity.
1470 * (Well, we could've done data_ = &data_ and
1471 * set capacity to 0, but that would be too cryptic.)
1472 */
1473 static constexpr size_type default_capacity_{4};
1474
1475 void init_(const value_type* str, size_type size)
1476 {
1477 if (data_)
1478 allocator_.deallocate(data_, capacity_);
1479
1480 size_ = size;
1481 capacity_ = size;
1482
1483 data_ = allocator_.allocate(capacity_);
1484 traits_type::copy(data_, str, size);
1485 ensure_null_terminator_();
1486 }
1487
1488 size_type next_capacity_(size_type hint = 0) const noexcept
1489 {
1490 if (hint != 0)
1491 return max(capacity_ * 2, hint);
1492 else
1493 return max(capacity_ * 2, 2ul);
1494 }
1495
1496 void ensure_free_space_(size_type n)
1497 {
1498 /**
1499 * Note: We cannot use reserve like we
1500 * did in vector, because in string
1501 * reserve can cause shrinking.
1502 */
1503 if (size_ + 1 + n > capacity_)
1504 resize_with_copy_(size_, max(size_ + 1 + n, next_capacity_()));
1505 }
1506
1507 void resize_without_copy_(size_type capacity)
1508 {
1509 if (data_)
1510 allocator_.deallocate(data_, capacity_);
1511
1512 data_ = allocator_.allocate(capacity);
1513 size_ = 0;
1514 capacity_ = capacity;
1515 ensure_null_terminator_();
1516 }
1517
1518 void resize_with_copy_(size_type size, size_type capacity)
1519 {
1520 if(capacity_ == 0 || capacity_ < capacity)
1521 {
1522 auto new_data = allocator_.allocate(capacity);
1523
1524 auto to_copy = min(size, size_);
1525 traits_type::move(new_data, data_, to_copy);
1526
1527 std::swap(data_, new_data);
1528
1529 allocator_.deallocate(new_data, capacity_);
1530 }
1531
1532 capacity_ = capacity;
1533 size_ = size;
1534 ensure_null_terminator_();
1535 }
1536
1537 template<class Iterator1, class Iterator2>
1538 Iterator2 copy_(Iterator1 first, Iterator1 last,
1539 Iterator2 result)
1540 {
1541 while (first != last)
1542 traits_type::assign(*result++, *first++);
1543
1544 return result;
1545 }
1546
1547 template<class Iterator1, class Iterator2>
1548 Iterator2 copy_backward_(Iterator1 first, Iterator1 last,
1549 Iterator2 result)
1550 {
1551 while (last != first)
1552 traits_type::assign(*--result, *--last);
1553
1554 return result;
1555 }
1556
1557 void ensure_null_terminator_()
1558 {
1559 value_type c{};
1560 traits_type::assign(data_[size_], c);
1561 }
1562
1563 bool is_any_of_(size_type idx, const value_type* str, size_type len) const
1564 {
1565 for (size_type i = 0; i < len; ++i)
1566 {
1567 if (traits_type::eq(data_[idx], str[i]))
1568 return true;
1569 }
1570
1571 return false;
1572 }
1573
1574 bool substr_starts_at_(size_type idx, const value_type* str, size_type len) const
1575 {
1576 size_type i{};
1577 for (i = 0; i < len; ++i)
1578 {
1579 if (!traits_type::eq(data_[idx + i], str[i]))
1580 break;
1581 }
1582
1583 return i == len;
1584 }
1585 };
1586
1587 using string = basic_string<char>;
1588 using u16string = basic_string<char16_t>;
1589 using u32string = basic_string<char32_t>;
1590 using wstring = basic_string<wchar_t>;
1591
1592 /**
1593 * 21.4.8, basic_string non-member functions:
1594 */
1595
1596 /**
1597 * 21.4.8.1, operator+:
1598 */
1599
1600 template<class Char, class Traits, class Allocator>
1601 basic_string<Char, Traits, Allocator>
1602 operator+(const basic_string<Char, Traits, Allocator>& lhs,
1603 const basic_string<Char, Traits, Allocator>& rhs)
1604 {
1605 return basic_string<Char, Traits, Allocator>{lhs}.append(rhs);
1606 }
1607
1608 template<class Char, class Traits, class Allocator>
1609 basic_string<Char, Traits, Allocator>
1610 operator+(basic_string<Char, Traits, Allocator>&& lhs,
1611 const basic_string<Char, Traits, Allocator>& rhs)
1612 {
1613 return move(lhs.append(rhs));
1614 }
1615
1616 template<class Char, class Traits, class Allocator>
1617 basic_string<Char, Traits, Allocator>
1618 operator+(const basic_string<Char, Traits, Allocator>& lhs,
1619 basic_string<Char, Traits, Allocator>&& rhs)
1620 {
1621 return move(rhs.insert(0, lhs));
1622 }
1623
1624 template<class Char, class Traits, class Allocator>
1625 basic_string<Char, Traits, Allocator>
1626 operator+(basic_string<Char, Traits, Allocator>&& lhs,
1627 basic_string<Char, Traits, Allocator>&& rhs)
1628 {
1629 return move(lhs.append(rhs));
1630 }
1631
1632 template<class Char, class Traits, class Allocator>
1633 basic_string<Char, Traits, Allocator>
1634 operator+(const Char* lhs,
1635 const basic_string<Char, Traits, Allocator>& rhs)
1636 {
1637 return basic_string<Char, Traits, Allocator>{lhs} + rhs;
1638 }
1639
1640 template<class Char, class Traits, class Allocator>
1641 basic_string<Char, Traits, Allocator>
1642 operator+(const Char* lhs,
1643 basic_string<Char, Traits, Allocator>&& rhs)
1644 {
1645 return move(rhs.insert(0, lhs));
1646 }
1647
1648 template<class Char, class Traits, class Allocator>
1649 basic_string<Char, Traits, Allocator>
1650 operator+(Char lhs,
1651 const basic_string<Char, Traits, Allocator>& rhs)
1652 {
1653 return basic_string<Char, Traits, Allocator>{1, lhs}.append(rhs);
1654 }
1655
1656 template<class Char, class Traits, class Allocator>
1657 basic_string<Char, Traits, Allocator>
1658 operator+(Char lhs,
1659 basic_string<Char, Traits, Allocator>&& rhs)
1660 {
1661 return move(rhs.insert(0, 1, lhs));
1662 }
1663
1664 template<class Char, class Traits, class Allocator>
1665 basic_string<Char, Traits, Allocator>
1666 operator+(const basic_string<Char, Traits, Allocator>& lhs,
1667 const Char* rhs)
1668 {
1669 return lhs + basic_string<Char, Traits, Allocator>{rhs};
1670 }
1671
1672 template<class Char, class Traits, class Allocator>
1673 basic_string<Char, Traits, Allocator>
1674 operator+(basic_string<Char, Traits, Allocator>&& lhs,
1675 const Char* rhs)
1676 {
1677 return move(lhs.append(rhs));
1678 }
1679
1680 template<class Char, class Traits, class Allocator>
1681 basic_string<Char, Traits, Allocator>
1682 operator+(const basic_string<Char, Traits, Allocator>& lhs,
1683 Char rhs)
1684 {
1685 return lhs + basic_string<Char, Traits, Allocator>{1, rhs};
1686 }
1687
1688 template<class Char, class Traits, class Allocator>
1689 basic_string<Char, Traits, Allocator>
1690 operator+(basic_string<Char, Traits, Allocator>&& lhs,
1691 Char rhs)
1692 {
1693 return move(lhs.append(1, rhs));
1694 }
1695
1696 /**
1697 * 21.4.8.2, operator==:
1698 */
1699
1700 template<class Char, class Traits, class Allocator>
1701 bool operator==(const basic_string<Char, Traits, Allocator>& lhs,
1702 const basic_string<Char, Traits, Allocator>& rhs) noexcept
1703 {
1704 return lhs.compare(rhs) == 0;
1705 }
1706
1707 template<class Char, class Traits, class Allocator>
1708 bool operator==(const Char* lhs,
1709 const basic_string<Char, Traits, Allocator>& rhs)
1710 {
1711 return rhs == lhs;
1712 }
1713
1714 template<class Char, class Traits, class Allocator>
1715 bool operator==(const basic_string<Char, Traits, Allocator>& lhs,
1716 const Char* rhs)
1717 {
1718 return lhs.compare(rhs) == 0;
1719 }
1720
1721 /**
1722 * 21.4.8.3, operator!=:
1723 */
1724
1725 template<class Char, class Traits, class Allocator>
1726 bool operator!=(const basic_string<Char, Traits, Allocator>& lhs,
1727 const basic_string<Char, Traits, Allocator>& rhs) noexcept
1728 {
1729 return !(lhs == rhs);
1730 }
1731
1732 template<class Char, class Traits, class Allocator>
1733 bool operator!=(const Char* lhs,
1734 const basic_string<Char, Traits, Allocator>& rhs)
1735 {
1736 return rhs != lhs;
1737 }
1738
1739 template<class Char, class Traits, class Allocator>
1740 bool operator!=(const basic_string<Char, Traits, Allocator>& lhs,
1741 const Char* rhs)
1742 {
1743 return lhs.compare(rhs) != 0;
1744 }
1745
1746 /**
1747 * 21.4.8.4, operator<:
1748 */
1749
1750 template<class Char, class Traits, class Allocator>
1751 bool operator<(const basic_string<Char, Traits, Allocator>& lhs,
1752 const basic_string<Char, Traits, Allocator>& rhs) noexcept
1753 {
1754 return lhs.compare(rhs) < 0;
1755 }
1756
1757 template<class Char, class Traits, class Allocator>
1758 bool operator<(const Char* lhs,
1759 const basic_string<Char, Traits, Allocator>& rhs)
1760 {
1761 return rhs.compare(lhs) > 0;
1762 }
1763
1764 template<class Char, class Traits, class Allocator>
1765 bool operator<(const basic_string<Char, Traits, Allocator>& lhs,
1766 const Char* rhs)
1767 {
1768 return lhs.compare(rhs) < 0;
1769 }
1770
1771 /**
1772 * 21.4.8.5, operator>:
1773 */
1774
1775 template<class Char, class Traits, class Allocator>
1776 bool operator>(const basic_string<Char, Traits, Allocator>& lhs,
1777 const basic_string<Char, Traits, Allocator>& rhs) noexcept
1778 {
1779 return lhs.compare(rhs) > 0;
1780 }
1781
1782 template<class Char, class Traits, class Allocator>
1783 bool operator>(const Char* lhs,
1784 const basic_string<Char, Traits, Allocator>& rhs)
1785 {
1786 return rhs.compare(lhs) < 0;
1787 }
1788
1789 template<class Char, class Traits, class Allocator>
1790 bool operator>(const basic_string<Char, Traits, Allocator>& lhs,
1791 const Char* rhs)
1792 {
1793 return lhs.compare(rhs) > 0;
1794 }
1795
1796 /**
1797 * 21.4.8.6, operator<=:
1798 */
1799
1800 template<class Char, class Traits, class Allocator>
1801 bool operator<=(const basic_string<Char, Traits, Allocator>& lhs,
1802 const basic_string<Char, Traits, Allocator>& rhs) noexcept
1803 {
1804 return lhs.compare(rhs) <= 0;
1805 }
1806
1807 template<class Char, class Traits, class Allocator>
1808 bool operator<=(const Char* lhs,
1809 const basic_string<Char, Traits, Allocator>& rhs)
1810 {
1811 return rhs.compare(lhs) >= 0;
1812 }
1813
1814 template<class Char, class Traits, class Allocator>
1815 bool operator<=(const basic_string<Char, Traits, Allocator>& lhs,
1816 const Char* rhs)
1817 {
1818 return lhs.compare(rhs) <= 0;
1819 }
1820
1821 /**
1822 * 21.4.8.7, operator>=:
1823 */
1824
1825 template<class Char, class Traits, class Allocator>
1826 bool operator>=(const basic_string<Char, Traits, Allocator>& lhs,
1827 const basic_string<Char, Traits, Allocator>& rhs) noexcept
1828 {
1829 return lhs.compare(rhs) >= 0;
1830 }
1831
1832 template<class Char, class Traits, class Allocator>
1833 bool operator>=(const Char* lhs,
1834 const basic_string<Char, Traits, Allocator>& rhs)
1835 {
1836 return rhs.compare(lhs) <= 0;
1837 }
1838
1839 template<class Char, class Traits, class Allocator>
1840 bool operator>=(const basic_string<Char, Traits, Allocator>& lhs,
1841 const Char* rhs)
1842 {
1843 return lhs.compare(rhs) >= 0;
1844 }
1845
1846 /**
1847 * 21.4.8.8, swap:
1848 */
1849
1850 template<class Char, class Traits, class Allocator>
1851 void swap(basic_string<Char, Traits, Allocator>& lhs,
1852 basic_string<Char, Traits, Allocator>& rhs)
1853 noexcept(noexcept(lhs.swap(rhs)))
1854 {
1855 lhs.swap(rhs);
1856 }
1857
1858 /**
1859 * 21.5, numeric conversions:
1860 */
1861
1862 int stoi(const string& str, size_t* idx = nullptr, int base = 10);
1863 long stol(const string& str, size_t* idx = nullptr, int base = 10);
1864 unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
1865 long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
1866 unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
1867
1868 float stof(const string& str, size_t* idx = nullptr);
1869 double stod(const string& str, size_t* idx = nullptr);
1870 long double stold(const string& str, size_t* idx = nullptr);
1871
1872 string to_string(int val);
1873 string to_string(unsigned val);
1874 string to_string(long val);
1875 string to_string(unsigned long val);
1876 string to_string(long long val);
1877 string to_string(unsigned long long val);
1878 string to_string(float val);
1879 string to_string(double val);
1880 string to_string(long double val);
1881
1882 int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
1883 long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
1884 unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
1885 long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
1886 unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
1887
1888 float stof(const wstring& str, size_t* idx = nullptr);
1889 double stod(const wstring& str, size_t* idx = nullptr);
1890 long double stold(const wstring& str, size_t* idx = nullptr);
1891
1892 wstring to_wstring(int val);
1893 wstring to_wstring(unsigned val);
1894 wstring to_wstring(long val);
1895 wstring to_wstring(unsigned long val);
1896 wstring to_wstring(long long val);
1897 wstring to_wstring(unsigned long long val);
1898 wstring to_wstring(float val);
1899 wstring to_wstring(double val);
1900 wstring to_wstring(long double val);
1901
1902 /**
1903 * 21.6, hash support:
1904 */
1905
1906 // TODO: implement
1907
1908 /**
1909 * 21.7, suffix for basic_string literals:
1910 */
1911
1912 /**
1913 * Note: According to the standard, literal suffixes that do not
1914 * start with an underscore are reserved for future standardization,
1915 * but since we are implementing the standard, we're going to ignore it.
1916 * This should work (according to their documentation) work for clang,
1917 * but that should be tested.
1918 */
1919#pragma GCC diagnostic push
1920#pragma GCC diagnostic ignored "-Wliteral-suffix"
1921 string operator "" s(const char* str, size_t len);
1922 u16string operator "" s(const char16_t* str, size_t len);
1923 u32string operator "" s(const char32_t* str, size_t len);
1924
1925 /* Problem: wchar_t == int in HelenOS, but standard forbids it.
1926 wstring operator "" s(const wchar_t* str, size_t len);
1927 */
1928#pragma GCC diagnostic pop
1929}
1930
1931#endif
Note: See TracBrowser for help on using the repository browser.