blob: 336922ebefb15120380b138c03a63fd6e5029cd9 [file] [log] [blame]
Howard Hinnantc51e1022010-05-11 19:42:16 +00001// -*- C++ -*-
2//===--------------------------- string -----------------------------------===//
3//
Chandler Carruth7642bb12019-01-19 08:50:56 +00004// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Howard Hinnantc51e1022010-05-11 19:42:16 +00007//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_STRING
11#define _LIBCPP_STRING
12
13/*
14 string synopsis
15
16namespace std
17{
18
19template <class stateT>
20class fpos
21{
22private:
23 stateT st;
24public:
25 fpos(streamoff = streamoff());
26
27 operator streamoff() const;
28
29 stateT state() const;
30 void state(stateT);
31
32 fpos& operator+=(streamoff);
33 fpos operator+ (streamoff) const;
34 fpos& operator-=(streamoff);
35 fpos operator- (streamoff) const;
36};
37
38template <class stateT> streamoff operator-(const fpos<stateT>& x, const fpos<stateT>& y);
39
40template <class stateT> bool operator==(const fpos<stateT>& x, const fpos<stateT>& y);
41template <class stateT> bool operator!=(const fpos<stateT>& x, const fpos<stateT>& y);
42
43template <class charT>
44struct char_traits
45{
46 typedef charT char_type;
47 typedef ... int_type;
48 typedef streamoff off_type;
49 typedef streampos pos_type;
50 typedef mbstate_t state_type;
51
Howard Hinnantaeb17d82011-05-29 19:57:12 +000052 static void assign(char_type& c1, const char_type& c2) noexcept;
Howard Hinnant270c00e2012-07-20 19:09:12 +000053 static constexpr bool eq(char_type c1, char_type c2) noexcept;
54 static constexpr bool lt(char_type c1, char_type c2) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +000055
56 static int compare(const char_type* s1, const char_type* s2, size_t n);
57 static size_t length(const char_type* s);
58 static const char_type* find(const char_type* s, size_t n, const char_type& a);
59 static char_type* move(char_type* s1, const char_type* s2, size_t n);
60 static char_type* copy(char_type* s1, const char_type* s2, size_t n);
61 static char_type* assign(char_type* s, size_t n, char_type a);
62
Howard Hinnant270c00e2012-07-20 19:09:12 +000063 static constexpr int_type not_eof(int_type c) noexcept;
64 static constexpr char_type to_char_type(int_type c) noexcept;
65 static constexpr int_type to_int_type(char_type c) noexcept;
66 static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
67 static constexpr int_type eof() noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +000068};
69
70template <> struct char_traits<char>;
71template <> struct char_traits<wchar_t>;
Marek Kurdeje3ac4e22021-03-23 17:15:07 +010072template <> struct char_traits<char8_t>; // C++20
73template <> struct char_traits<char16_t>;
74template <> struct char_traits<char32_t>;
Howard Hinnantc51e1022010-05-11 19:42:16 +000075
Howard Hinnant3b6579a2010-08-22 00:02:43 +000076template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
Howard Hinnantc51e1022010-05-11 19:42:16 +000077class basic_string
78{
Howard Hinnant3b6579a2010-08-22 00:02:43 +000079public:
80// types:
Howard Hinnantc51e1022010-05-11 19:42:16 +000081 typedef traits traits_type;
82 typedef typename traits_type::char_type value_type;
83 typedef Allocator allocator_type;
84 typedef typename allocator_type::size_type size_type;
85 typedef typename allocator_type::difference_type difference_type;
86 typedef typename allocator_type::reference reference;
87 typedef typename allocator_type::const_reference const_reference;
88 typedef typename allocator_type::pointer pointer;
89 typedef typename allocator_type::const_pointer const_pointer;
90 typedef implementation-defined iterator;
91 typedef implementation-defined const_iterator;
92 typedef std::reverse_iterator<iterator> reverse_iterator;
93 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
94
95 static const size_type npos = -1;
96
Howard Hinnant3e276872011-06-03 18:40:47 +000097 basic_string()
98 noexcept(is_nothrow_default_constructible<allocator_type>::value);
99 explicit basic_string(const allocator_type& a);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000100 basic_string(const basic_string& str);
Howard Hinnant3e276872011-06-03 18:40:47 +0000101 basic_string(basic_string&& str)
102 noexcept(is_nothrow_move_constructible<allocator_type>::value);
Marshall Clow83445802016-04-07 18:13:41 +0000103 basic_string(const basic_string& str, size_type pos,
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000104 const allocator_type& a = allocator_type());
Marshall Clow83445802016-04-07 18:13:41 +0000105 basic_string(const basic_string& str, size_type pos, size_type n,
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000106 const Allocator& a = Allocator());
Marshall Clow78dbe462016-11-14 18:22:19 +0000107 template<class T>
108 basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator()); // C++17
Marshall Clowe46031a2018-07-02 18:41:15 +0000109 template <class T>
110 explicit basic_string(const T& t, const Allocator& a = Allocator()); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000111 basic_string(const value_type* s, const allocator_type& a = allocator_type());
112 basic_string(const value_type* s, size_type n, const allocator_type& a = allocator_type());
Howard Hinnantc51e1022010-05-11 19:42:16 +0000113 basic_string(size_type n, value_type c, const allocator_type& a = allocator_type());
114 template<class InputIterator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000115 basic_string(InputIterator begin, InputIterator end,
116 const allocator_type& a = allocator_type());
Howard Hinnantc51e1022010-05-11 19:42:16 +0000117 basic_string(initializer_list<value_type>, const Allocator& = Allocator());
118 basic_string(const basic_string&, const Allocator&);
119 basic_string(basic_string&&, const Allocator&);
120
121 ~basic_string();
122
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000123 operator basic_string_view<charT, traits>() const noexcept;
124
Howard Hinnantc51e1022010-05-11 19:42:16 +0000125 basic_string& operator=(const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000126 template <class T>
127 basic_string& operator=(const T& t); // C++17
Howard Hinnant3e276872011-06-03 18:40:47 +0000128 basic_string& operator=(basic_string&& str)
129 noexcept(
Marshall Clow2fe8a8d2015-08-18 18:57:00 +0000130 allocator_type::propagate_on_container_move_assignment::value ||
131 allocator_type::is_always_equal::value ); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000132 basic_string& operator=(const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000133 basic_string& operator=(value_type c);
134 basic_string& operator=(initializer_list<value_type>);
135
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000136 iterator begin() noexcept;
137 const_iterator begin() const noexcept;
138 iterator end() noexcept;
139 const_iterator end() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000140
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000141 reverse_iterator rbegin() noexcept;
142 const_reverse_iterator rbegin() const noexcept;
143 reverse_iterator rend() noexcept;
144 const_reverse_iterator rend() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000145
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000146 const_iterator cbegin() const noexcept;
147 const_iterator cend() const noexcept;
148 const_reverse_iterator crbegin() const noexcept;
149 const_reverse_iterator crend() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000150
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000151 size_type size() const noexcept;
152 size_type length() const noexcept;
153 size_type max_size() const noexcept;
154 size_type capacity() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000155
156 void resize(size_type n, value_type c);
157 void resize(size_type n);
158
Marek Kurdejc9848142020-11-26 10:07:16 +0100159 void reserve(size_type res_arg);
160 void reserve(); // deprecated in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000161 void shrink_to_fit();
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000162 void clear() noexcept;
163 bool empty() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000164
165 const_reference operator[](size_type pos) const;
166 reference operator[](size_type pos);
167
168 const_reference at(size_type n) const;
169 reference at(size_type n);
170
171 basic_string& operator+=(const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000172 template <class T>
173 basic_string& operator+=(const T& t); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000174 basic_string& operator+=(const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000175 basic_string& operator+=(value_type c);
176 basic_string& operator+=(initializer_list<value_type>);
177
178 basic_string& append(const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000179 template <class T>
180 basic_string& append(const T& t); // C++17
Marshall Clow8db7fb02014-03-04 19:17:19 +0000181 basic_string& append(const basic_string& str, size_type pos, size_type n=npos); //C++14
Marshall Clow82513342016-09-24 22:45:42 +0000182 template <class T>
183 basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000184 basic_string& append(const value_type* s, size_type n);
185 basic_string& append(const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000186 basic_string& append(size_type n, value_type c);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000187 template<class InputIterator>
188 basic_string& append(InputIterator first, InputIterator last);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000189 basic_string& append(initializer_list<value_type>);
190
191 void push_back(value_type c);
192 void pop_back();
193 reference front();
194 const_reference front() const;
195 reference back();
196 const_reference back() const;
197
198 basic_string& assign(const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000199 template <class T>
200 basic_string& assign(const T& t); // C++17
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000201 basic_string& assign(basic_string&& str);
Marshall Clow8db7fb02014-03-04 19:17:19 +0000202 basic_string& assign(const basic_string& str, size_type pos, size_type n=npos); // C++14
Marshall Clow82513342016-09-24 22:45:42 +0000203 template <class T>
204 basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000205 basic_string& assign(const value_type* s, size_type n);
206 basic_string& assign(const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000207 basic_string& assign(size_type n, value_type c);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000208 template<class InputIterator>
209 basic_string& assign(InputIterator first, InputIterator last);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000210 basic_string& assign(initializer_list<value_type>);
211
212 basic_string& insert(size_type pos1, const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000213 template <class T>
214 basic_string& insert(size_type pos1, const T& t);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000215 basic_string& insert(size_type pos1, const basic_string& str,
216 size_type pos2, size_type n);
Marshall Clow82513342016-09-24 22:45:42 +0000217 template <class T>
218 basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n); // C++17
Marshall Clow8db7fb02014-03-04 19:17:19 +0000219 basic_string& insert(size_type pos, const value_type* s, size_type n=npos); //C++14
Howard Hinnantd17880b2013-06-28 16:59:19 +0000220 basic_string& insert(size_type pos, const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000221 basic_string& insert(size_type pos, size_type n, value_type c);
222 iterator insert(const_iterator p, value_type c);
223 iterator insert(const_iterator p, size_type n, value_type c);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000224 template<class InputIterator>
225 iterator insert(const_iterator p, InputIterator first, InputIterator last);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000226 iterator insert(const_iterator p, initializer_list<value_type>);
227
228 basic_string& erase(size_type pos = 0, size_type n = npos);
229 iterator erase(const_iterator position);
230 iterator erase(const_iterator first, const_iterator last);
231
232 basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000233 template <class T>
234 basic_string& replace(size_type pos1, size_type n1, const T& t); // C++17
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000235 basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
Marshall Clow8db7fb02014-03-04 19:17:19 +0000236 size_type pos2, size_type n2=npos); // C++14
Marshall Clow82513342016-09-24 22:45:42 +0000237 template <class T>
238 basic_string& replace(size_type pos1, size_type n1, const T& t,
239 size_type pos2, size_type n); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000240 basic_string& replace(size_type pos, size_type n1, const value_type* s, size_type n2);
241 basic_string& replace(size_type pos, size_type n1, const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000242 basic_string& replace(size_type pos, size_type n1, size_type n2, value_type c);
Howard Hinnant990d6e82010-11-17 21:11:40 +0000243 basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000244 template <class T>
245 basic_string& replace(const_iterator i1, const_iterator i2, const T& t); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000246 basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s, size_type n);
247 basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s);
Howard Hinnant990d6e82010-11-17 21:11:40 +0000248 basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000249 template<class InputIterator>
Howard Hinnant990d6e82010-11-17 21:11:40 +0000250 basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2);
251 basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000252
Howard Hinnantd17880b2013-06-28 16:59:19 +0000253 size_type copy(value_type* s, size_type n, size_type pos = 0) const;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000254 basic_string substr(size_type pos = 0, size_type n = npos) const;
255
Howard Hinnant3e276872011-06-03 18:40:47 +0000256 void swap(basic_string& str)
Marshall Clow8982dcd2015-07-13 20:04:56 +0000257 noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
258 allocator_traits<allocator_type>::is_always_equal::value); // C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000259
Howard Hinnantd17880b2013-06-28 16:59:19 +0000260 const value_type* c_str() const noexcept;
261 const value_type* data() const noexcept;
Marshall Clowd3c22392016-03-08 15:44:30 +0000262 value_type* data() noexcept; // C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000263
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000264 allocator_type get_allocator() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000265
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000266 size_type find(const basic_string& str, size_type pos = 0) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000267 template <class T>
zoecarver1997e0a2021-02-05 11:54:47 -0800268 size_type find(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension
Howard Hinnantd17880b2013-06-28 16:59:19 +0000269 size_type find(const value_type* s, size_type pos, size_type n) const noexcept;
270 size_type find(const value_type* s, size_type pos = 0) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000271 size_type find(value_type c, size_type pos = 0) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000272
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000273 size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000274 template <class T>
zoecarver1997e0a2021-02-05 11:54:47 -0800275 size_type rfind(const T& t, size_type pos = npos) const noexcept; // C++17, noexcept as an extension
Howard Hinnantd17880b2013-06-28 16:59:19 +0000276 size_type rfind(const value_type* s, size_type pos, size_type n) const noexcept;
277 size_type rfind(const value_type* s, size_type pos = npos) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000278 size_type rfind(value_type c, size_type pos = npos) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000279
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000280 size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000281 template <class T>
zoecarver1997e0a2021-02-05 11:54:47 -0800282 size_type find_first_of(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension
Howard Hinnantd17880b2013-06-28 16:59:19 +0000283 size_type find_first_of(const value_type* s, size_type pos, size_type n) const noexcept;
284 size_type find_first_of(const value_type* s, size_type pos = 0) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000285 size_type find_first_of(value_type c, size_type pos = 0) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000286
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000287 size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000288 template <class T>
zoecarver1997e0a2021-02-05 11:54:47 -0800289 size_type find_last_of(const T& t, size_type pos = npos) const noexcept noexcept; // C++17, noexcept as an extension
Howard Hinnantd17880b2013-06-28 16:59:19 +0000290 size_type find_last_of(const value_type* s, size_type pos, size_type n) const noexcept;
291 size_type find_last_of(const value_type* s, size_type pos = npos) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000292 size_type find_last_of(value_type c, size_type pos = npos) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000293
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000294 size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000295 template <class T>
zoecarver1997e0a2021-02-05 11:54:47 -0800296 size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension
Howard Hinnantd17880b2013-06-28 16:59:19 +0000297 size_type find_first_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
298 size_type find_first_not_of(const value_type* s, size_type pos = 0) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000299 size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000300
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000301 size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000302 template <class T>
zoecarver1997e0a2021-02-05 11:54:47 -0800303 size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept; // C++17, noexcept as an extension
Howard Hinnantd17880b2013-06-28 16:59:19 +0000304 size_type find_last_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
305 size_type find_last_not_of(const value_type* s, size_type pos = npos) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000306 size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000307
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000308 int compare(const basic_string& str) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000309 template <class T>
zoecarver1997e0a2021-02-05 11:54:47 -0800310 int compare(const T& t) const noexcept; // C++17, noexcept as an extension
Howard Hinnantc51e1022010-05-11 19:42:16 +0000311 int compare(size_type pos1, size_type n1, const basic_string& str) const;
Marshall Clowe46031a2018-07-02 18:41:15 +0000312 template <class T>
313 int compare(size_type pos1, size_type n1, const T& t) const; // C++17
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000314 int compare(size_type pos1, size_type n1, const basic_string& str,
Marshall Clow8db7fb02014-03-04 19:17:19 +0000315 size_type pos2, size_type n2=npos) const; // C++14
Marshall Clow82513342016-09-24 22:45:42 +0000316 template <class T>
317 int compare(size_type pos1, size_type n1, const T& t,
318 size_type pos2, size_type n2=npos) const; // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000319 int compare(const value_type* s) const noexcept;
320 int compare(size_type pos1, size_type n1, const value_type* s) const;
321 int compare(size_type pos1, size_type n1, const value_type* s, size_type n2) const;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000322
Marek Kurdej24b4c512021-01-07 12:29:04 +0100323 bool starts_with(basic_string_view<charT, traits> sv) const noexcept; // C++20
324 bool starts_with(charT c) const noexcept; // C++20
325 bool starts_with(const charT* s) const; // C++20
326 bool ends_with(basic_string_view<charT, traits> sv) const noexcept; // C++20
327 bool ends_with(charT c) const noexcept; // C++20
328 bool ends_with(const charT* s) const; // C++20
Marshall Clow18c293b2017-12-04 20:11:38 +0000329
Wim Leflere023c3542021-01-19 14:33:30 -0500330 constexpr bool contains(basic_string_view<charT, traits> sv) const noexcept; // C++2b
331 constexpr bool contains(charT c) const noexcept; // C++2b
332 constexpr bool contains(const charT* s) const; // C++2b
333
Howard Hinnantc51e1022010-05-11 19:42:16 +0000334 bool __invariants() const;
335};
336
Marshall Clowa0563332018-02-08 06:34:03 +0000337template<class InputIterator,
338 class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
339basic_string(InputIterator, InputIterator, Allocator = Allocator())
340 -> basic_string<typename iterator_traits<InputIterator>::value_type,
341 char_traits<typename iterator_traits<InputIterator>::value_type>,
342 Allocator>; // C++17
343
Howard Hinnantc51e1022010-05-11 19:42:16 +0000344template<class charT, class traits, class Allocator>
345basic_string<charT, traits, Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000346operator+(const basic_string<charT, traits, Allocator>& lhs,
347 const basic_string<charT, traits, Allocator>& rhs);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000348
349template<class charT, class traits, class Allocator>
350basic_string<charT, traits, Allocator>
351operator+(const charT* lhs , const basic_string<charT,traits,Allocator>&rhs);
352
353template<class charT, class traits, class Allocator>
354basic_string<charT, traits, Allocator>
355operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs);
356
357template<class charT, class traits, class Allocator>
358basic_string<charT, traits, Allocator>
359operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
360
361template<class charT, class traits, class Allocator>
362basic_string<charT, traits, Allocator>
363operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);
364
365template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000366bool operator==(const basic_string<charT, traits, Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000367 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000368
369template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000370bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000371
372template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000373bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000374
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000375template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000376bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000377 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000378
379template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000380bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000381
382template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000383bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000384
385template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000386bool operator< (const basic_string<charT, traits, Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000387 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000388
389template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000390bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000391
392template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000393bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000394
395template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000396bool operator> (const basic_string<charT, traits, Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000397 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000398
399template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000400bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000401
402template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000403bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000404
405template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000406bool operator<=(const basic_string<charT, traits, Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000407 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000408
409template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000410bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000411
412template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000413bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000414
415template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000416bool operator>=(const basic_string<charT, traits, Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000417 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000418
419template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000420bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000421
422template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000423bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000424
425template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000426void swap(basic_string<charT, traits, Allocator>& lhs,
Howard Hinnant3e276872011-06-03 18:40:47 +0000427 basic_string<charT, traits, Allocator>& rhs)
428 noexcept(noexcept(lhs.swap(rhs)));
Howard Hinnantc51e1022010-05-11 19:42:16 +0000429
430template<class charT, class traits, class Allocator>
431basic_istream<charT, traits>&
432operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
433
434template<class charT, class traits, class Allocator>
435basic_ostream<charT, traits>&
436operator<<(basic_ostream<charT, traits>& os, const basic_string<charT, traits, Allocator>& str);
437
438template<class charT, class traits, class Allocator>
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000439basic_istream<charT, traits>&
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000440getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str,
441 charT delim);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000442
443template<class charT, class traits, class Allocator>
444basic_istream<charT, traits>&
445getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
446
Marshall Clow29b53f22018-12-14 18:49:35 +0000447template<class charT, class traits, class Allocator, class U>
Marek Kurdeja98b1412020-05-02 13:58:03 +0200448typename basic_string<charT, traits, Allocator>::size_type
449erase(basic_string<charT, traits, Allocator>& c, const U& value); // C++20
Marshall Clow29b53f22018-12-14 18:49:35 +0000450template<class charT, class traits, class Allocator, class Predicate>
Marek Kurdeja98b1412020-05-02 13:58:03 +0200451typename basic_string<charT, traits, Allocator>::size_type
452erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20
Marshall Clow29b53f22018-12-14 18:49:35 +0000453
Howard Hinnantc51e1022010-05-11 19:42:16 +0000454typedef basic_string<char> string;
455typedef basic_string<wchar_t> wstring;
Marek Kurdeje3ac4e22021-03-23 17:15:07 +0100456typedef basic_string<char8_t> u8string; // C++20
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000457typedef basic_string<char16_t> u16string;
458typedef basic_string<char32_t> u32string;
459
Bruce Mitchener170d8972020-11-24 12:53:53 -0500460int stoi (const string& str, size_t* idx = nullptr, int base = 10);
461long stol (const string& str, size_t* idx = nullptr, int base = 10);
462unsigned long stoul (const string& str, size_t* idx = nullptr, int base = 10);
463long long stoll (const string& str, size_t* idx = nullptr, int base = 10);
464unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000465
Bruce Mitchener170d8972020-11-24 12:53:53 -0500466float stof (const string& str, size_t* idx = nullptr);
467double stod (const string& str, size_t* idx = nullptr);
468long double stold(const string& str, size_t* idx = nullptr);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000469
470string to_string(int val);
471string to_string(unsigned val);
472string to_string(long val);
473string to_string(unsigned long val);
474string to_string(long long val);
475string to_string(unsigned long long val);
476string to_string(float val);
477string to_string(double val);
478string to_string(long double val);
479
Bruce Mitchener170d8972020-11-24 12:53:53 -0500480int stoi (const wstring& str, size_t* idx = nullptr, int base = 10);
481long stol (const wstring& str, size_t* idx = nullptr, int base = 10);
482unsigned long stoul (const wstring& str, size_t* idx = nullptr, int base = 10);
483long long stoll (const wstring& str, size_t* idx = nullptr, int base = 10);
484unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000485
Bruce Mitchener170d8972020-11-24 12:53:53 -0500486float stof (const wstring& str, size_t* idx = nullptr);
487double stod (const wstring& str, size_t* idx = nullptr);
488long double stold(const wstring& str, size_t* idx = nullptr);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000489
490wstring to_wstring(int val);
491wstring to_wstring(unsigned val);
492wstring to_wstring(long val);
493wstring to_wstring(unsigned long val);
494wstring to_wstring(long long val);
495wstring to_wstring(unsigned long long val);
496wstring to_wstring(float val);
497wstring to_wstring(double val);
498wstring to_wstring(long double val);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000499
500template <> struct hash<string>;
Marek Kurdeje3ac4e22021-03-23 17:15:07 +0100501template <> struct hash<u8string>; // C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000502template <> struct hash<u16string>;
503template <> struct hash<u32string>;
504template <> struct hash<wstring>;
505
Marshall Clowcba751f2013-07-23 17:05:24 +0000506basic_string<char> operator "" s( const char *str, size_t len ); // C++14
507basic_string<wchar_t> operator "" s( const wchar_t *str, size_t len ); // C++14
Marek Kurdeje3ac4e22021-03-23 17:15:07 +0100508basic_string<char8_t> operator "" s( const char8_t *str, size_t len ); // C++20
Marshall Clowcba751f2013-07-23 17:05:24 +0000509basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14
510basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14
511
Howard Hinnantc51e1022010-05-11 19:42:16 +0000512} // std
513
514*/
515
516#include <__config>
Arthur O'Dwyer7deec122021-03-24 18:19:12 -0400517#include <compare>
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000518#include <string_view>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000519#include <iosfwd>
520#include <cstring>
Howard Hinnant155c2af2010-05-24 17:49:41 +0000521#include <cstdio> // For EOF.
Howard Hinnantc51e1022010-05-11 19:42:16 +0000522#include <cwchar>
523#include <algorithm>
524#include <iterator>
525#include <utility>
526#include <memory>
527#include <stdexcept>
528#include <type_traits>
529#include <initializer_list>
530#include <__functional_base>
Marshall Clow0a1e7502018-09-12 19:41:40 +0000531#include <version>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000532#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
533#include <cstdint>
534#endif
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000535
Eric Fiselier14b6de92014-08-10 23:53:08 +0000536#include <__debug>
537
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000538#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000539#pragma GCC system_header
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000540#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000541
Eric Fiselierf4433a32017-05-31 22:07:49 +0000542_LIBCPP_PUSH_MACROS
543#include <__undef_macros>
544
545
Howard Hinnantc51e1022010-05-11 19:42:16 +0000546_LIBCPP_BEGIN_NAMESPACE_STD
547
548// fpos
549
550template <class _StateT>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000551class _LIBCPP_TEMPLATE_VIS fpos
Howard Hinnantc51e1022010-05-11 19:42:16 +0000552{
553private:
554 _StateT __st_;
555 streamoff __off_;
556public:
557 _LIBCPP_INLINE_VISIBILITY fpos(streamoff __off = streamoff()) : __st_(), __off_(__off) {}
558
559 _LIBCPP_INLINE_VISIBILITY operator streamoff() const {return __off_;}
560
561 _LIBCPP_INLINE_VISIBILITY _StateT state() const {return __st_;}
562 _LIBCPP_INLINE_VISIBILITY void state(_StateT __st) {__st_ = __st;}
563
564 _LIBCPP_INLINE_VISIBILITY fpos& operator+=(streamoff __off) {__off_ += __off; return *this;}
565 _LIBCPP_INLINE_VISIBILITY fpos operator+ (streamoff __off) const {fpos __t(*this); __t += __off; return __t;}
566 _LIBCPP_INLINE_VISIBILITY fpos& operator-=(streamoff __off) {__off_ -= __off; return *this;}
567 _LIBCPP_INLINE_VISIBILITY fpos operator- (streamoff __off) const {fpos __t(*this); __t -= __off; return __t;}
568};
569
570template <class _StateT>
571inline _LIBCPP_INLINE_VISIBILITY
572streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
573 {return streamoff(__x) - streamoff(__y);}
574
575template <class _StateT>
576inline _LIBCPP_INLINE_VISIBILITY
577bool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
578 {return streamoff(__x) == streamoff(__y);}
579
580template <class _StateT>
581inline _LIBCPP_INLINE_VISIBILITY
582bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
583 {return streamoff(__x) != streamoff(__y);}
584
Howard Hinnantc51e1022010-05-11 19:42:16 +0000585// basic_string
586
587template<class _CharT, class _Traits, class _Allocator>
588basic_string<_CharT, _Traits, _Allocator>
Howard Hinnant944510a2011-06-14 19:58:17 +0000589operator+(const basic_string<_CharT, _Traits, _Allocator>& __x,
590 const basic_string<_CharT, _Traits, _Allocator>& __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000591
592template<class _CharT, class _Traits, class _Allocator>
593basic_string<_CharT, _Traits, _Allocator>
Howard Hinnant944510a2011-06-14 19:58:17 +0000594operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000595
596template<class _CharT, class _Traits, class _Allocator>
597basic_string<_CharT, _Traits, _Allocator>
Howard Hinnant944510a2011-06-14 19:58:17 +0000598operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000599
600template<class _CharT, class _Traits, class _Allocator>
Louis Dionne8f8d95d2018-11-21 17:31:55 +0000601inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +0000602basic_string<_CharT, _Traits, _Allocator>
Howard Hinnant944510a2011-06-14 19:58:17 +0000603operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000604
605template<class _CharT, class _Traits, class _Allocator>
606basic_string<_CharT, _Traits, _Allocator>
Howard Hinnant944510a2011-06-14 19:58:17 +0000607operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000608
Shoaib Meenaiea363712017-07-29 02:54:41 +0000609_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&))
610
Howard Hinnantc51e1022010-05-11 19:42:16 +0000611template <bool>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000612class _LIBCPP_TEMPLATE_VIS __basic_string_common
Howard Hinnantc51e1022010-05-11 19:42:16 +0000613{
614protected:
Marshall Clow8fea1612016-08-25 15:09:01 +0000615 _LIBCPP_NORETURN void __throw_length_error() const;
616 _LIBCPP_NORETURN void __throw_out_of_range() const;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000617};
618
619template <bool __b>
620void
621__basic_string_common<__b>::__throw_length_error() const
622{
Marshall Clow8fea1612016-08-25 15:09:01 +0000623 _VSTD::__throw_length_error("basic_string");
Howard Hinnantc51e1022010-05-11 19:42:16 +0000624}
625
626template <bool __b>
627void
628__basic_string_common<__b>::__throw_out_of_range() const
629{
Marshall Clow8fea1612016-08-25 15:09:01 +0000630 _VSTD::__throw_out_of_range("basic_string");
Howard Hinnantc51e1022010-05-11 19:42:16 +0000631}
632
Eric Fiselier1b57fa82016-09-15 22:27:07 +0000633_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __basic_string_common<true>)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000634
Marshall Clow039b2f02016-01-13 21:54:34 +0000635#ifdef _LIBCPP_NO_EXCEPTIONS
636template <class _Iter>
637struct __libcpp_string_gets_noexcept_iterator_impl : public true_type {};
638#elif defined(_LIBCPP_HAS_NO_NOEXCEPT)
639template <class _Iter>
640struct __libcpp_string_gets_noexcept_iterator_impl : public false_type {};
641#else
Eric Fiseliercd5a6772019-11-18 01:46:58 -0500642template <class _Iter, bool = __is_cpp17_forward_iterator<_Iter>::value>
Marshall Clow039b2f02016-01-13 21:54:34 +0000643struct __libcpp_string_gets_noexcept_iterator_impl : public _LIBCPP_BOOL_CONSTANT((
Louis Dionne173f29e2019-05-29 16:01:36 +0000644 noexcept(++(declval<_Iter&>())) &&
645 is_nothrow_assignable<_Iter&, _Iter>::value &&
646 noexcept(declval<_Iter>() == declval<_Iter>()) &&
Marshall Clow039b2f02016-01-13 21:54:34 +0000647 noexcept(*declval<_Iter>())
648)) {};
649
Louis Dionne173f29e2019-05-29 16:01:36 +0000650template <class _Iter>
Marshall Clow039b2f02016-01-13 21:54:34 +0000651struct __libcpp_string_gets_noexcept_iterator_impl<_Iter, false> : public false_type {};
652#endif
653
654
655template <class _Iter>
656struct __libcpp_string_gets_noexcept_iterator
657 : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value || __libcpp_string_gets_noexcept_iterator_impl<_Iter>::value) {};
658
Marshall Clow82513342016-09-24 22:45:42 +0000659template <class _CharT, class _Traits, class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500660struct __can_be_converted_to_string_view : public _BoolConstant<
661 is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
662 !is_convertible<const _Tp&, const _CharT*>::value
663 > {};
Marshall Clow82513342016-09-24 22:45:42 +0000664
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +0000665#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +0000666
667template <class _CharT, size_t = sizeof(_CharT)>
668struct __padding
669{
670 unsigned char __xx[sizeof(_CharT)-1];
671};
672
673template <class _CharT>
674struct __padding<_CharT, 1>
675{
676};
677
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +0000678#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +0000679
Richard Smith256954d2020-11-11 17:12:18 -0800680#ifndef _LIBCPP_NO_HAS_CHAR8_T
681typedef basic_string<char8_t> u8string;
682#endif
683
684#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
685typedef basic_string<char16_t> u16string;
686typedef basic_string<char32_t> u32string;
687#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
688
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000689template<class _CharT, class _Traits, class _Allocator>
Richard Smith256954d2020-11-11 17:12:18 -0800690class
691 _LIBCPP_TEMPLATE_VIS
692#ifndef _LIBCPP_NO_HAS_CHAR8_T
693 _LIBCPP_PREFERRED_NAME(u8string)
694#endif
695#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
696 _LIBCPP_PREFERRED_NAME(u16string)
697 _LIBCPP_PREFERRED_NAME(u32string)
698#endif
699 basic_string
Howard Hinnantc51e1022010-05-11 19:42:16 +0000700 : private __basic_string_common<true>
701{
702public:
703 typedef basic_string __self;
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000704 typedef basic_string_view<_CharT, _Traits> __self_view;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000705 typedef _Traits traits_type;
Marshall Clowa3a74e02017-03-15 18:41:11 +0000706 typedef _CharT value_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000707 typedef _Allocator allocator_type;
Howard Hinnantea8f7e12010-11-17 17:55:08 +0000708 typedef allocator_traits<allocator_type> __alloc_traits;
709 typedef typename __alloc_traits::size_type size_type;
710 typedef typename __alloc_traits::difference_type difference_type;
Howard Hinnant3e276872011-06-03 18:40:47 +0000711 typedef value_type& reference;
712 typedef const value_type& const_reference;
Howard Hinnantea8f7e12010-11-17 17:55:08 +0000713 typedef typename __alloc_traits::pointer pointer;
714 typedef typename __alloc_traits::const_pointer const_pointer;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000715
Marshall Clow79f33542018-03-21 00:36:05 +0000716 static_assert((!is_array<value_type>::value), "Character type of basic_string must not be an array");
717 static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string must be standard-layout");
718 static_assert(( is_trivial<value_type>::value), "Character type of basic_string must be trivial");
719 static_assert(( is_same<_CharT, typename traits_type::char_type>::value),
Howard Hinnant8ea98242013-08-23 17:37:05 +0000720 "traits_type::char_type must be the same type as CharT");
Marshall Clow79f33542018-03-21 00:36:05 +0000721 static_assert(( is_same<typename allocator_type::value_type, value_type>::value),
Howard Hinnant8ea98242013-08-23 17:37:05 +0000722 "Allocator::value_type must be same type as value_type");
Marshall Clowe46031a2018-07-02 18:41:15 +0000723
Howard Hinnantc51e1022010-05-11 19:42:16 +0000724 typedef __wrap_iter<pointer> iterator;
725 typedef __wrap_iter<const_pointer> const_iterator;
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000726 typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
727 typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000728
729private:
Howard Hinnant68bf1812013-04-30 21:44:48 +0000730
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +0000731#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +0000732
733 struct __long
734 {
735 pointer __data_;
736 size_type __size_;
737 size_type __cap_;
738 };
739
Eric Fiseliere9cc5922017-10-17 13:16:01 +0000740#ifdef _LIBCPP_BIG_ENDIAN
Ben Craig4b6f5f12017-07-12 01:45:13 +0000741 static const size_type __short_mask = 0x01;
742 static const size_type __long_mask = 0x1ul;
Howard Hinnant68bf1812013-04-30 21:44:48 +0000743#else // _LIBCPP_BIG_ENDIAN
Ben Craig4b6f5f12017-07-12 01:45:13 +0000744 static const size_type __short_mask = 0x80;
745 static const size_type __long_mask = ~(size_type(~0) >> 1);
Howard Hinnant68bf1812013-04-30 21:44:48 +0000746#endif // _LIBCPP_BIG_ENDIAN
747
748 enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
749 (sizeof(__long) - 1)/sizeof(value_type) : 2};
750
751 struct __short
752 {
753 value_type __data_[__min_cap];
754 struct
755 : __padding<value_type>
756 {
757 unsigned char __size_;
758 };
759 };
760
761#else
762
Howard Hinnantc51e1022010-05-11 19:42:16 +0000763 struct __long
764 {
765 size_type __cap_;
766 size_type __size_;
767 pointer __data_;
768 };
769
Eric Fiseliere9cc5922017-10-17 13:16:01 +0000770#ifdef _LIBCPP_BIG_ENDIAN
Ben Craig4b6f5f12017-07-12 01:45:13 +0000771 static const size_type __short_mask = 0x80;
772 static const size_type __long_mask = ~(size_type(~0) >> 1);
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000773#else // _LIBCPP_BIG_ENDIAN
Ben Craig4b6f5f12017-07-12 01:45:13 +0000774 static const size_type __short_mask = 0x01;
775 static const size_type __long_mask = 0x1ul;
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000776#endif // _LIBCPP_BIG_ENDIAN
Howard Hinnantc51e1022010-05-11 19:42:16 +0000777
Howard Hinnantc51e1022010-05-11 19:42:16 +0000778 enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
779 (sizeof(__long) - 1)/sizeof(value_type) : 2};
780
781 struct __short
782 {
783 union
784 {
785 unsigned char __size_;
Howard Hinnant49e145e2012-10-30 19:06:59 +0000786 value_type __lx;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000787 };
788 value_type __data_[__min_cap];
789 };
790
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +0000791#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +0000792
Howard Hinnant8ea98242013-08-23 17:37:05 +0000793 union __ulx{__long __lx; __short __lxx;};
Howard Hinnantc51e1022010-05-11 19:42:16 +0000794
Howard Hinnant8ea98242013-08-23 17:37:05 +0000795 enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
Howard Hinnantc51e1022010-05-11 19:42:16 +0000796
797 struct __raw
798 {
799 size_type __words[__n_words];
800 };
801
802 struct __rep
803 {
804 union
805 {
806 __long __l;
807 __short __s;
808 __raw __r;
809 };
810 };
811
812 __compressed_pair<__rep, allocator_type> __r_;
813
Howard Hinnantc51e1022010-05-11 19:42:16 +0000814public:
Martin Storsjö88890c22021-02-22 01:13:13 +0200815 _LIBCPP_TEMPLATE_DATA_VIS
Howard Hinnantc51e1022010-05-11 19:42:16 +0000816 static const size_type npos = -1;
817
Howard Hinnant3e276872011-06-03 18:40:47 +0000818 _LIBCPP_INLINE_VISIBILITY basic_string()
819 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
Marshall Clowa80abc72015-06-03 19:56:43 +0000820
821 _LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a)
822#if _LIBCPP_STD_VER <= 14
823 _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
824#else
825 _NOEXCEPT;
826#endif
827
Howard Hinnantc51e1022010-05-11 19:42:16 +0000828 basic_string(const basic_string& __str);
829 basic_string(const basic_string& __str, const allocator_type& __a);
Marshall Clowa80abc72015-06-03 19:56:43 +0000830
Eric Fiselierfc92be82017-04-19 00:28:44 +0000831#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantebb0edf2011-01-26 00:06:59 +0000832 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e276872011-06-03 18:40:47 +0000833 basic_string(basic_string&& __str)
Marshall Clowa80abc72015-06-03 19:56:43 +0000834#if _LIBCPP_STD_VER <= 14
Howard Hinnant3e276872011-06-03 18:40:47 +0000835 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
Marshall Clowa80abc72015-06-03 19:56:43 +0000836#else
837 _NOEXCEPT;
838#endif
839
Howard Hinnantebb0edf2011-01-26 00:06:59 +0000840 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +0000841 basic_string(basic_string&& __str, const allocator_type& __a);
Eric Fiselierfc92be82017-04-19 00:28:44 +0000842#endif // _LIBCPP_CXX03_LANG
Marshall Clowe46031a2018-07-02 18:41:15 +0000843
Eric Fiselierfe7fe0a2020-01-15 17:29:55 -0500844 template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> >
Eric Fiseliera8567862018-07-17 05:48:48 +0000845 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier5169d1c2019-12-16 19:03:23 -0500846 basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) {
Eric Fiseliera8567862018-07-17 05:48:48 +0000847 _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
848 __init(__s, traits_type::length(__s));
Louis Dionneba400782020-10-02 15:02:52 -0400849# if _LIBCPP_DEBUG_LEVEL == 2
Eric Fiseliera8567862018-07-17 05:48:48 +0000850 __get_db()->__insert_c(this);
851# endif
852 }
Marshall Clowe46031a2018-07-02 18:41:15 +0000853
Eric Fiselierfe7fe0a2020-01-15 17:29:55 -0500854 template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> >
Marshall Clowe46031a2018-07-02 18:41:15 +0000855 _LIBCPP_INLINE_VISIBILITY
856 basic_string(const _CharT* __s, const _Allocator& __a);
857
Howard Hinnantcf823322010-12-17 14:46:43 +0000858 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier812882b2017-02-17 01:17:10 +0000859 basic_string(const _CharT* __s, size_type __n);
Howard Hinnantcf823322010-12-17 14:46:43 +0000860 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier812882b2017-02-17 01:17:10 +0000861 basic_string(const _CharT* __s, size_type __n, const _Allocator& __a);
Howard Hinnantcf823322010-12-17 14:46:43 +0000862 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier812882b2017-02-17 01:17:10 +0000863 basic_string(size_type __n, _CharT __c);
Marshall Clowe46031a2018-07-02 18:41:15 +0000864
Eric Fiselierfe7fe0a2020-01-15 17:29:55 -0500865 template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> >
Marshall Clowe46031a2018-07-02 18:41:15 +0000866 _LIBCPP_INLINE_VISIBILITY
867 basic_string(size_type __n, _CharT __c, const _Allocator& __a);
868
Marshall Clow83445802016-04-07 18:13:41 +0000869 basic_string(const basic_string& __str, size_type __pos, size_type __n,
Eric Fiselier812882b2017-02-17 01:17:10 +0000870 const _Allocator& __a = _Allocator());
Marshall Clow83445802016-04-07 18:13:41 +0000871 _LIBCPP_INLINE_VISIBILITY
872 basic_string(const basic_string& __str, size_type __pos,
Eric Fiselier812882b2017-02-17 01:17:10 +0000873 const _Allocator& __a = _Allocator());
Marshall Clowe46031a2018-07-02 18:41:15 +0000874
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500875 template<class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
Shoaib Meenai69c57412017-03-02 03:02:50 +0000876 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselier812882b2017-02-17 01:17:10 +0000877 basic_string(const _Tp& __t, size_type __pos, size_type __n,
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500878 const allocator_type& __a = allocator_type());
Marshall Clowe46031a2018-07-02 18:41:15 +0000879
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500880 template<class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
881 !__is_same_uncvref<_Tp, basic_string>::value> >
Marshall Clowe46031a2018-07-02 18:41:15 +0000882 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
883 explicit basic_string(const _Tp& __t);
884
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500885 template<class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
Marshall Clowe46031a2018-07-02 18:41:15 +0000886 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
887 explicit basic_string(const _Tp& __t, const allocator_type& __a);
888
Eric Fiselierfe7fe0a2020-01-15 17:29:55 -0500889 template<class _InputIterator, class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value> >
Howard Hinnantcf823322010-12-17 14:46:43 +0000890 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +0000891 basic_string(_InputIterator __first, _InputIterator __last);
Eric Fiselierfe7fe0a2020-01-15 17:29:55 -0500892 template<class _InputIterator, class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value> >
Howard Hinnantcf823322010-12-17 14:46:43 +0000893 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +0000894 basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
Eric Fiselierfc92be82017-04-19 00:28:44 +0000895#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantcf823322010-12-17 14:46:43 +0000896 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier812882b2017-02-17 01:17:10 +0000897 basic_string(initializer_list<_CharT> __il);
Howard Hinnantcf823322010-12-17 14:46:43 +0000898 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier812882b2017-02-17 01:17:10 +0000899 basic_string(initializer_list<_CharT> __il, const _Allocator& __a);
Eric Fiselierfc92be82017-04-19 00:28:44 +0000900#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +0000901
Eric Fiselierd9a702a2016-10-31 03:42:50 +0000902 inline ~basic_string();
Howard Hinnantc51e1022010-05-11 19:42:16 +0000903
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000904 _LIBCPP_INLINE_VISIBILITY
905 operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); }
906
Howard Hinnantea8f7e12010-11-17 17:55:08 +0000907 basic_string& operator=(const basic_string& __str);
Eric Fiselier5ec13b12017-01-23 21:24:58 +0000908
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500909 template <class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> >
Marshall Clowe46031a2018-07-02 18:41:15 +0000910 basic_string& operator=(const _Tp& __t)
911 {__self_view __sv = __t; return assign(__sv);}
912
Eric Fiselierfc92be82017-04-19 00:28:44 +0000913#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantcf823322010-12-17 14:46:43 +0000914 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e276872011-06-03 18:40:47 +0000915 basic_string& operator=(basic_string&& __str)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +0000916 _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
Eric Fiselierfc92be82017-04-19 00:28:44 +0000917 _LIBCPP_INLINE_VISIBILITY
918 basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000919#endif
Howard Hinnantd17880b2013-06-28 16:59:19 +0000920 _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000921 basic_string& operator=(value_type __c);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000922
Louis Dionneba400782020-10-02 15:02:52 -0400923#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +0000924 _LIBCPP_INLINE_VISIBILITY
925 iterator begin() _NOEXCEPT
926 {return iterator(this, __get_pointer());}
927 _LIBCPP_INLINE_VISIBILITY
928 const_iterator begin() const _NOEXCEPT
929 {return const_iterator(this, __get_pointer());}
930 _LIBCPP_INLINE_VISIBILITY
931 iterator end() _NOEXCEPT
932 {return iterator(this, __get_pointer() + size());}
933 _LIBCPP_INLINE_VISIBILITY
934 const_iterator end() const _NOEXCEPT
935 {return const_iterator(this, __get_pointer() + size());}
936#else
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000937 _LIBCPP_INLINE_VISIBILITY
938 iterator begin() _NOEXCEPT
939 {return iterator(__get_pointer());}
940 _LIBCPP_INLINE_VISIBILITY
941 const_iterator begin() const _NOEXCEPT
Howard Hinnantd17880b2013-06-28 16:59:19 +0000942 {return const_iterator(__get_pointer());}
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000943 _LIBCPP_INLINE_VISIBILITY
944 iterator end() _NOEXCEPT
945 {return iterator(__get_pointer() + size());}
946 _LIBCPP_INLINE_VISIBILITY
947 const_iterator end() const _NOEXCEPT
Howard Hinnantd17880b2013-06-28 16:59:19 +0000948 {return const_iterator(__get_pointer() + size());}
Louis Dionneba400782020-10-02 15:02:52 -0400949#endif // _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000950 _LIBCPP_INLINE_VISIBILITY
951 reverse_iterator rbegin() _NOEXCEPT
952 {return reverse_iterator(end());}
953 _LIBCPP_INLINE_VISIBILITY
954 const_reverse_iterator rbegin() const _NOEXCEPT
955 {return const_reverse_iterator(end());}
956 _LIBCPP_INLINE_VISIBILITY
957 reverse_iterator rend() _NOEXCEPT
958 {return reverse_iterator(begin());}
959 _LIBCPP_INLINE_VISIBILITY
960 const_reverse_iterator rend() const _NOEXCEPT
961 {return const_reverse_iterator(begin());}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000962
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000963 _LIBCPP_INLINE_VISIBILITY
964 const_iterator cbegin() const _NOEXCEPT
965 {return begin();}
966 _LIBCPP_INLINE_VISIBILITY
967 const_iterator cend() const _NOEXCEPT
968 {return end();}
969 _LIBCPP_INLINE_VISIBILITY
970 const_reverse_iterator crbegin() const _NOEXCEPT
971 {return rbegin();}
972 _LIBCPP_INLINE_VISIBILITY
973 const_reverse_iterator crend() const _NOEXCEPT
974 {return rend();}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000975
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000976 _LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +0000977 {return __is_long() ? __get_long_size() : __get_short_size();}
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000978 _LIBCPP_INLINE_VISIBILITY size_type length() const _NOEXCEPT {return size();}
979 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT;
980 _LIBCPP_INLINE_VISIBILITY size_type capacity() const _NOEXCEPT
Eric Fiselier8599fcc2015-08-28 07:02:42 +0000981 {return (__is_long() ? __get_long_cap()
982 : static_cast<size_type>(__min_cap)) - 1;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000983
984 void resize(size_type __n, value_type __c);
985 _LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());}
986
Marek Kurdejc9848142020-11-26 10:07:16 +0100987 void reserve(size_type __requested_capacity);
Eric Fiselier451d5582018-11-26 20:15:38 +0000988 _LIBCPP_INLINE_VISIBILITY void __resize_default_init(size_type __n);
989
Marek Kurdejc9848142020-11-26 10:07:16 +0100990 _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY
991 void reserve() _NOEXCEPT {shrink_to_fit();}
Marshall Clow6ae12a82018-11-28 18:18:34 +0000992 _LIBCPP_INLINE_VISIBILITY
Marek Kurdejc9848142020-11-26 10:07:16 +0100993 void shrink_to_fit() _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +0000994 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000995 void clear() _NOEXCEPT;
Marshall Clowb7db4972017-11-15 20:02:27 +0000996 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
997 bool empty() const _NOEXCEPT {return size() == 0;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000998
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000999 _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __pos) const _NOEXCEPT;
1000 _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __pos) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001001
1002 const_reference at(size_type __n) const;
1003 reference at(size_type __n);
1004
1005 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const basic_string& __str) {return append(__str);}
Marshall Clowe46031a2018-07-02 18:41:15 +00001006
1007 template <class _Tp>
1008 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001009 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001010 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001011 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
1012 && !__is_same_uncvref<_Tp, basic_string >::value,
Marshall Clowe46031a2018-07-02 18:41:15 +00001013 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001014 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001015 operator+=(const _Tp& __t) {__self_view __sv = __t; return append(__sv);}
Marshall Clowdf63a6d2016-07-21 05:31:24 +00001016 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const value_type* __s) {return append(__s);}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001017 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c) {push_back(__c); return *this;}
Eric Fiselierfc92be82017-04-19 00:28:44 +00001018#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001019 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);}
Eric Fiselierfc92be82017-04-19 00:28:44 +00001020#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001021
Howard Hinnantcf823322010-12-17 14:46:43 +00001022 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001023 basic_string& append(const basic_string& __str);
Marshall Clowe46031a2018-07-02 18:41:15 +00001024
1025 template <class _Tp>
1026 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001027 _EnableIf<
1028 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
1029 && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clowe46031a2018-07-02 18:41:15 +00001030 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001031 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001032 append(const _Tp& __t) { __self_view __sv = __t; return append(__sv.data(), __sv.size()); }
Marshall Clow8db7fb02014-03-04 19:17:19 +00001033 basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos);
Marshall Clowe46031a2018-07-02 18:41:15 +00001034
Marshall Clow62953962016-10-03 23:40:48 +00001035 template <class _Tp>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001036 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001037 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00001038 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001039 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
1040 && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clow82513342016-09-24 22:45:42 +00001041 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001042 >
Marshall Clow82513342016-09-24 22:45:42 +00001043 append(const _Tp& __t, size_type __pos, size_type __n=npos);
Howard Hinnantd17880b2013-06-28 16:59:19 +00001044 basic_string& append(const value_type* __s, size_type __n);
1045 basic_string& append(const value_type* __s);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001046 basic_string& append(size_type __n, value_type __c);
Eric Fiselier451d5582018-11-26 20:15:38 +00001047
1048 _LIBCPP_INLINE_VISIBILITY
1049 void __append_default_init(size_type __n);
1050
Eric Fiselierdb7ee8f2016-10-31 02:46:25 +00001051 template <class _ForwardIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001052 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1053 basic_string& __append_forward_unsafe(_ForwardIterator, _ForwardIterator);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001054 template<class _InputIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001055 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001056 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001057 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001058 __is_exactly_cpp17_input_iterator<_InputIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001059 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001060 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001061 >
Eric Fiselierdb7ee8f2016-10-31 02:46:25 +00001062 _LIBCPP_INLINE_VISIBILITY
1063 append(_InputIterator __first, _InputIterator __last) {
1064 const basic_string __temp (__first, __last, __alloc());
1065 append(__temp.data(), __temp.size());
1066 return *this;
1067 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001068 template<class _ForwardIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001069 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001070 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001071 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001072 __is_cpp17_forward_iterator<_ForwardIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001073 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001074 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001075 >
Eric Fiselierdb7ee8f2016-10-31 02:46:25 +00001076 _LIBCPP_INLINE_VISIBILITY
1077 append(_ForwardIterator __first, _ForwardIterator __last) {
1078 return __append_forward_unsafe(__first, __last);
1079 }
1080
Eric Fiselierfc92be82017-04-19 00:28:44 +00001081#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant186dca82010-09-23 17:31:07 +00001082 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001083 basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
Eric Fiselierfc92be82017-04-19 00:28:44 +00001084#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001085
1086 void push_back(value_type __c);
Howard Hinnantcf823322010-12-17 14:46:43 +00001087 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001088 void pop_back();
Marshall Clow05cf6692019-03-19 03:30:07 +00001089 _LIBCPP_INLINE_VISIBILITY reference front() _NOEXCEPT;
1090 _LIBCPP_INLINE_VISIBILITY const_reference front() const _NOEXCEPT;
1091 _LIBCPP_INLINE_VISIBILITY reference back() _NOEXCEPT;
1092 _LIBCPP_INLINE_VISIBILITY const_reference back() const _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001093
Marshall Clowe46031a2018-07-02 18:41:15 +00001094 template <class _Tp>
1095 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001096 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001097 <
1098 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1099 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001100 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001101 assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); }
Marshall Clowdf63a6d2016-07-21 05:31:24 +00001102 _LIBCPP_INLINE_VISIBILITY
Marshall Clow95d5e9a2016-03-09 18:08:29 +00001103 basic_string& assign(const basic_string& __str) { return *this = __str; }
Eric Fiselierfc92be82017-04-19 00:28:44 +00001104#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001105 _LIBCPP_INLINE_VISIBILITY
Eric Fiselierc5ea1ae2017-06-01 02:29:37 +00001106 basic_string& assign(basic_string&& __str)
Marshall Clow5aa9e942015-10-05 16:17:34 +00001107 _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
Eric Fiselierc5ea1ae2017-06-01 02:29:37 +00001108 {*this = _VSTD::move(__str); return *this;}
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001109#endif
Marshall Clow8db7fb02014-03-04 19:17:19 +00001110 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos);
Marshall Clow62953962016-10-03 23:40:48 +00001111 template <class _Tp>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001112 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001113 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00001114 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001115 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
1116 && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clow82513342016-09-24 22:45:42 +00001117 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001118 >
Eric Fiselierc5ea1ae2017-06-01 02:29:37 +00001119 assign(const _Tp & __t, size_type __pos, size_type __n=npos);
Howard Hinnantd17880b2013-06-28 16:59:19 +00001120 basic_string& assign(const value_type* __s, size_type __n);
1121 basic_string& assign(const value_type* __s);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001122 basic_string& assign(size_type __n, value_type __c);
1123 template<class _InputIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001124 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001125 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001126 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001127 __is_exactly_cpp17_input_iterator<_InputIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001128 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001129 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001130 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001131 assign(_InputIterator __first, _InputIterator __last);
1132 template<class _ForwardIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001133 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001134 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001135 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001136 __is_cpp17_forward_iterator<_ForwardIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001137 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001138 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001139 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001140 assign(_ForwardIterator __first, _ForwardIterator __last);
Eric Fiselierfc92be82017-04-19 00:28:44 +00001141#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant186dca82010-09-23 17:31:07 +00001142 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001143 basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
Eric Fiselierfc92be82017-04-19 00:28:44 +00001144#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001145
Howard Hinnantcf823322010-12-17 14:46:43 +00001146 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001147 basic_string& insert(size_type __pos1, const basic_string& __str);
Marshall Clowe46031a2018-07-02 18:41:15 +00001148
1149 template <class _Tp>
1150 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001151 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001152 <
1153 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1154 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001155 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001156 insert(size_type __pos1, const _Tp& __t)
1157 { __self_view __sv = __t; return insert(__pos1, __sv.data(), __sv.size()); }
1158
Marshall Clow82513342016-09-24 22:45:42 +00001159 template <class _Tp>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001160 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001161 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00001162 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001163 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clow82513342016-09-24 22:45:42 +00001164 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001165 >
Marshall Clow82513342016-09-24 22:45:42 +00001166 insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos);
Marshall Clow8db7fb02014-03-04 19:17:19 +00001167 basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos);
Howard Hinnantd17880b2013-06-28 16:59:19 +00001168 basic_string& insert(size_type __pos, const value_type* __s, size_type __n);
1169 basic_string& insert(size_type __pos, const value_type* __s);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001170 basic_string& insert(size_type __pos, size_type __n, value_type __c);
1171 iterator insert(const_iterator __pos, value_type __c);
Howard Hinnantcf823322010-12-17 14:46:43 +00001172 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001173 iterator insert(const_iterator __pos, size_type __n, value_type __c);
1174 template<class _InputIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001175 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001176 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001177 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001178 __is_exactly_cpp17_input_iterator<_InputIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001179 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001180 iterator
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001181 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001182 insert(const_iterator __pos, _InputIterator __first, _InputIterator __last);
1183 template<class _ForwardIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001184 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001185 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001186 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001187 __is_cpp17_forward_iterator<_ForwardIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001188 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001189 iterator
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001190 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001191 insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last);
Eric Fiselierfc92be82017-04-19 00:28:44 +00001192#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant186dca82010-09-23 17:31:07 +00001193 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001194 iterator insert(const_iterator __pos, initializer_list<value_type> __il)
1195 {return insert(__pos, __il.begin(), __il.end());}
Eric Fiselierfc92be82017-04-19 00:28:44 +00001196#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001197
1198 basic_string& erase(size_type __pos = 0, size_type __n = npos);
Howard Hinnantcf823322010-12-17 14:46:43 +00001199 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001200 iterator erase(const_iterator __pos);
Howard Hinnantcf823322010-12-17 14:46:43 +00001201 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001202 iterator erase(const_iterator __first, const_iterator __last);
1203
Howard Hinnantcf823322010-12-17 14:46:43 +00001204 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001205 basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str);
Marshall Clowe46031a2018-07-02 18:41:15 +00001206
1207 template <class _Tp>
1208 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001209 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001210 <
1211 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1212 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001213 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001214 replace(size_type __pos1, size_type __n1, const _Tp& __t) { __self_view __sv = __t; return replace(__pos1, __n1, __sv.data(), __sv.size()); }
Marshall Clow8db7fb02014-03-04 19:17:19 +00001215 basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos);
Marshall Clow82513342016-09-24 22:45:42 +00001216 template <class _Tp>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001217 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001218 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00001219 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001220 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clow82513342016-09-24 22:45:42 +00001221 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001222 >
Marshall Clow82513342016-09-24 22:45:42 +00001223 replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos);
Howard Hinnantd17880b2013-06-28 16:59:19 +00001224 basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2);
1225 basic_string& replace(size_type __pos, size_type __n1, const value_type* __s);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001226 basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);
Howard Hinnantcf823322010-12-17 14:46:43 +00001227 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant990d6e82010-11-17 21:11:40 +00001228 basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str);
Marshall Clowe46031a2018-07-02 18:41:15 +00001229
1230 template <class _Tp>
1231 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001232 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001233 <
1234 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1235 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001236 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001237 replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); }
1238
Marshall Clowdf63a6d2016-07-21 05:31:24 +00001239 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001240 basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n);
Howard Hinnantcf823322010-12-17 14:46:43 +00001241 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001242 basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s);
Howard Hinnantcf823322010-12-17 14:46:43 +00001243 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant990d6e82010-11-17 21:11:40 +00001244 basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001245 template<class _InputIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001246 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001247 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001248 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001249 __is_cpp17_input_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001250 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001251 >
Howard Hinnant990d6e82010-11-17 21:11:40 +00001252 replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
Eric Fiselierfc92be82017-04-19 00:28:44 +00001253#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant186dca82010-09-23 17:31:07 +00001254 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant990d6e82010-11-17 21:11:40 +00001255 basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001256 {return replace(__i1, __i2, __il.begin(), __il.end());}
Eric Fiselierfc92be82017-04-19 00:28:44 +00001257#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001258
Howard Hinnantd17880b2013-06-28 16:59:19 +00001259 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
Howard Hinnantcf823322010-12-17 14:46:43 +00001260 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001261 basic_string substr(size_type __pos = 0, size_type __n = npos) const;
1262
Howard Hinnantcf823322010-12-17 14:46:43 +00001263 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e276872011-06-03 18:40:47 +00001264 void swap(basic_string& __str)
Marshall Clow8982dcd2015-07-13 20:04:56 +00001265#if _LIBCPP_STD_VER >= 14
Eric Fiselier873b8d32019-03-18 21:50:12 +00001266 _NOEXCEPT;
Marshall Clow8982dcd2015-07-13 20:04:56 +00001267#else
Eric Fiselier873b8d32019-03-18 21:50:12 +00001268 _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
Marshall Clow8982dcd2015-07-13 20:04:56 +00001269 __is_nothrow_swappable<allocator_type>::value);
1270#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001271
Howard Hinnantcf823322010-12-17 14:46:43 +00001272 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001273 const value_type* c_str() const _NOEXCEPT {return data();}
Howard Hinnantcf823322010-12-17 14:46:43 +00001274 _LIBCPP_INLINE_VISIBILITY
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001275 const value_type* data() const _NOEXCEPT {return _VSTD::__to_address(__get_pointer());}
Eric Fiselier4ee2a892017-11-20 20:23:27 +00001276#if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY)
Marshall Clowd3c22392016-03-08 15:44:30 +00001277 _LIBCPP_INLINE_VISIBILITY
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001278 value_type* data() _NOEXCEPT {return _VSTD::__to_address(__get_pointer());}
Marshall Clowd3c22392016-03-08 15:44:30 +00001279#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001280
Howard Hinnantcf823322010-12-17 14:46:43 +00001281 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001282 allocator_type get_allocator() const _NOEXCEPT {return __alloc();}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001283
Howard Hinnantcf823322010-12-17 14:46:43 +00001284 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001285 size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001286
1287 template <class _Tp>
1288 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001289 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001290 <
1291 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1292 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001293 >
zoecarver1997e0a2021-02-05 11:54:47 -08001294 find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001295 size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001296 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001297 size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001298 size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001299
Howard Hinnantcf823322010-12-17 14:46:43 +00001300 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001301 size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001302
1303 template <class _Tp>
1304 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001305 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001306 <
1307 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1308 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001309 >
zoecarver1997e0a2021-02-05 11:54:47 -08001310 rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001311 size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001312 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001313 size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001314 size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001315
Howard Hinnantcf823322010-12-17 14:46:43 +00001316 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001317 size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001318
1319 template <class _Tp>
1320 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001321 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001322 <
1323 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1324 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001325 >
zoecarver1997e0a2021-02-05 11:54:47 -08001326 find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001327 size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001328 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001329 size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001330 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001331 size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001332
Howard Hinnantcf823322010-12-17 14:46:43 +00001333 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001334 size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001335
1336 template <class _Tp>
1337 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001338 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001339 <
1340 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1341 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001342 >
zoecarver1997e0a2021-02-05 11:54:47 -08001343 find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001344 size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001345 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001346 size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001347 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001348 size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001349
Howard Hinnantcf823322010-12-17 14:46:43 +00001350 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001351 size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001352
1353 template <class _Tp>
1354 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001355 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001356 <
1357 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1358 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001359 >
zoecarver1997e0a2021-02-05 11:54:47 -08001360 find_first_not_of(const _Tp &__t, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001361 size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001362 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001363 size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001364 _LIBCPP_INLINE_VISIBILITY
1365 size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
1366
1367 _LIBCPP_INLINE_VISIBILITY
1368 size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001369
1370 template <class _Tp>
1371 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001372 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001373 <
1374 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1375 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001376 >
zoecarver1997e0a2021-02-05 11:54:47 -08001377 find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001378 size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001379 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001380 size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001381 _LIBCPP_INLINE_VISIBILITY
1382 size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
1383
1384 _LIBCPP_INLINE_VISIBILITY
1385 int compare(const basic_string& __str) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001386
1387 template <class _Tp>
1388 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001389 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001390 <
1391 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1392 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001393 >
zoecarver1997e0a2021-02-05 11:54:47 -08001394 compare(const _Tp &__t) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001395
1396 template <class _Tp>
1397 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001398 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001399 <
1400 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1401 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001402 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001403 compare(size_type __pos1, size_type __n1, const _Tp& __t) const;
1404
Marshall Clowdf63a6d2016-07-21 05:31:24 +00001405 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001406 int compare(size_type __pos1, size_type __n1, const basic_string& __str) const;
Marshall Clow8db7fb02014-03-04 19:17:19 +00001407 int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos) const;
Marshall Clowe46031a2018-07-02 18:41:15 +00001408
Marshall Clow82513342016-09-24 22:45:42 +00001409 template <class _Tp>
Eric Fiselier7d4aa5c2016-10-14 05:29:46 +00001410 inline _LIBCPP_INLINE_VISIBILITY
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001411 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00001412 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001413 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clow82513342016-09-24 22:45:42 +00001414 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001415 >
Marshall Clow82513342016-09-24 22:45:42 +00001416 compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001417 int compare(const value_type* __s) const _NOEXCEPT;
1418 int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
1419 int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001420
Marshall Clow18c293b2017-12-04 20:11:38 +00001421#if _LIBCPP_STD_VER > 17
1422 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1423 bool starts_with(__self_view __sv) const _NOEXCEPT
1424 { return __self_view(data(), size()).starts_with(__sv); }
1425
1426 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1427 bool starts_with(value_type __c) const _NOEXCEPT
1428 { return !empty() && _Traits::eq(front(), __c); }
1429
1430 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1431 bool starts_with(const value_type* __s) const _NOEXCEPT
1432 { return starts_with(__self_view(__s)); }
1433
1434 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1435 bool ends_with(__self_view __sv) const _NOEXCEPT
1436 { return __self_view(data(), size()).ends_with( __sv); }
1437
1438 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1439 bool ends_with(value_type __c) const _NOEXCEPT
1440 { return !empty() && _Traits::eq(back(), __c); }
1441
1442 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1443 bool ends_with(const value_type* __s) const _NOEXCEPT
1444 { return ends_with(__self_view(__s)); }
1445#endif
1446
Wim Leflere023c3542021-01-19 14:33:30 -05001447#if _LIBCPP_STD_VER > 20
1448 constexpr _LIBCPP_INLINE_VISIBILITY
1449 bool contains(__self_view __sv) const noexcept
1450 { return __self_view(data(), size()).contains(__sv); }
1451
1452 constexpr _LIBCPP_INLINE_VISIBILITY
1453 bool contains(value_type __c) const noexcept
1454 { return __self_view(data(), size()).contains(__c); }
1455
1456 constexpr _LIBCPP_INLINE_VISIBILITY
1457 bool contains(const value_type* __s) const
1458 { return __self_view(data(), size()).contains(__s); }
1459#endif
1460
Howard Hinnantcf823322010-12-17 14:46:43 +00001461 _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
Howard Hinnantaaeb1132013-04-22 23:55:13 +00001462
Marshall Clowe60a7182018-05-29 17:04:37 +00001463 _LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT;
Marshall Clow851b9ec2019-05-20 21:56:51 +00001464
Marek Kurdejc9848142020-11-26 10:07:16 +01001465 _LIBCPP_INLINE_VISIBILITY void __shrink_or_extend(size_type __target_capacity);
1466
Howard Hinnantaaeb1132013-04-22 23:55:13 +00001467 _LIBCPP_INLINE_VISIBILITY
1468 bool __is_long() const _NOEXCEPT
1469 {return bool(__r_.first().__s.__size_ & __short_mask);}
1470
Louis Dionneba400782020-10-02 15:02:52 -04001471#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001472
1473 bool __dereferenceable(const const_iterator* __i) const;
1474 bool __decrementable(const const_iterator* __i) const;
1475 bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
1476 bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
1477
Louis Dionneba400782020-10-02 15:02:52 -04001478#endif // _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001479
Howard Hinnantc51e1022010-05-11 19:42:16 +00001480private:
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001481 _LIBCPP_INLINE_VISIBILITY
1482 allocator_type& __alloc() _NOEXCEPT
1483 {return __r_.second();}
1484 _LIBCPP_INLINE_VISIBILITY
1485 const allocator_type& __alloc() const _NOEXCEPT
1486 {return __r_.second();}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001487
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +00001488#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +00001489
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001490 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001491 void __set_short_size(size_type __s) _NOEXCEPT
Eric Fiseliere9cc5922017-10-17 13:16:01 +00001492# ifdef _LIBCPP_BIG_ENDIAN
Howard Hinnantc51e1022010-05-11 19:42:16 +00001493 {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
Howard Hinnant68bf1812013-04-30 21:44:48 +00001494# else
1495 {__r_.first().__s.__size_ = (unsigned char)(__s);}
1496# endif
1497
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001498 _LIBCPP_INLINE_VISIBILITY
1499 size_type __get_short_size() const _NOEXCEPT
Eric Fiseliere9cc5922017-10-17 13:16:01 +00001500# ifdef _LIBCPP_BIG_ENDIAN
Howard Hinnantc51e1022010-05-11 19:42:16 +00001501 {return __r_.first().__s.__size_ >> 1;}
Howard Hinnant68bf1812013-04-30 21:44:48 +00001502# else
1503 {return __r_.first().__s.__size_;}
1504# endif
1505
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +00001506#else // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +00001507
1508 _LIBCPP_INLINE_VISIBILITY
1509 void __set_short_size(size_type __s) _NOEXCEPT
Eric Fiseliere9cc5922017-10-17 13:16:01 +00001510# ifdef _LIBCPP_BIG_ENDIAN
Howard Hinnant68bf1812013-04-30 21:44:48 +00001511 {__r_.first().__s.__size_ = (unsigned char)(__s);}
1512# else
1513 {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
1514# endif
1515
1516 _LIBCPP_INLINE_VISIBILITY
1517 size_type __get_short_size() const _NOEXCEPT
Eric Fiseliere9cc5922017-10-17 13:16:01 +00001518# ifdef _LIBCPP_BIG_ENDIAN
Howard Hinnant68bf1812013-04-30 21:44:48 +00001519 {return __r_.first().__s.__size_;}
1520# else
1521 {return __r_.first().__s.__size_ >> 1;}
1522# endif
1523
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +00001524#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +00001525
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001526 _LIBCPP_INLINE_VISIBILITY
1527 void __set_long_size(size_type __s) _NOEXCEPT
1528 {__r_.first().__l.__size_ = __s;}
1529 _LIBCPP_INLINE_VISIBILITY
1530 size_type __get_long_size() const _NOEXCEPT
1531 {return __r_.first().__l.__size_;}
1532 _LIBCPP_INLINE_VISIBILITY
1533 void __set_size(size_type __s) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001534 {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}
1535
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001536 _LIBCPP_INLINE_VISIBILITY
1537 void __set_long_cap(size_type __s) _NOEXCEPT
1538 {__r_.first().__l.__cap_ = __long_mask | __s;}
1539 _LIBCPP_INLINE_VISIBILITY
1540 size_type __get_long_cap() const _NOEXCEPT
Howard Hinnant28b24882011-12-01 20:21:04 +00001541 {return __r_.first().__l.__cap_ & size_type(~__long_mask);}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001542
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001543 _LIBCPP_INLINE_VISIBILITY
1544 void __set_long_pointer(pointer __p) _NOEXCEPT
1545 {__r_.first().__l.__data_ = __p;}
1546 _LIBCPP_INLINE_VISIBILITY
1547 pointer __get_long_pointer() _NOEXCEPT
1548 {return __r_.first().__l.__data_;}
1549 _LIBCPP_INLINE_VISIBILITY
1550 const_pointer __get_long_pointer() const _NOEXCEPT
1551 {return __r_.first().__l.__data_;}
1552 _LIBCPP_INLINE_VISIBILITY
1553 pointer __get_short_pointer() _NOEXCEPT
Howard Hinnantd17880b2013-06-28 16:59:19 +00001554 {return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);}
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001555 _LIBCPP_INLINE_VISIBILITY
1556 const_pointer __get_short_pointer() const _NOEXCEPT
Howard Hinnantd17880b2013-06-28 16:59:19 +00001557 {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001558 _LIBCPP_INLINE_VISIBILITY
1559 pointer __get_pointer() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001560 {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001561 _LIBCPP_INLINE_VISIBILITY
1562 const_pointer __get_pointer() const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001563 {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
1564
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001565 _LIBCPP_INLINE_VISIBILITY
1566 void __zero() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001567 {
1568 size_type (&__a)[__n_words] = __r_.first().__r.__words;
1569 for (unsigned __i = 0; __i < __n_words; ++__i)
1570 __a[__i] = 0;
1571 }
1572
1573 template <size_type __a> static
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001574 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantea382952013-08-14 18:00:20 +00001575 size_type __align_it(size_type __s) _NOEXCEPT
Eric Fiselier8599fcc2015-08-28 07:02:42 +00001576 {return (__s + (__a-1)) & ~(__a-1);}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001577 enum {__alignment = 16};
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001578 static _LIBCPP_INLINE_VISIBILITY
1579 size_type __recommend(size_type __s) _NOEXCEPT
Marshall Clow80584522018-02-07 21:30:17 +00001580 {
1581 if (__s < __min_cap) return static_cast<size_type>(__min_cap) - 1;
1582 size_type __guess = __align_it<sizeof(value_type) < __alignment ?
1583 __alignment/sizeof(value_type) : 1 > (__s+1) - 1;
1584 if (__guess == __min_cap) ++__guess;
1585 return __guess;
1586 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001587
Duncan P. N. Exon Smitheb584632017-04-01 03:20:48 +00001588 inline
Howard Hinnantd17880b2013-06-28 16:59:19 +00001589 void __init(const value_type* __s, size_type __sz, size_type __reserve);
Duncan P. N. Exon Smitheb584632017-04-01 03:20:48 +00001590 inline
Howard Hinnantd17880b2013-06-28 16:59:19 +00001591 void __init(const value_type* __s, size_type __sz);
Duncan P. N. Exon Smitheb584632017-04-01 03:20:48 +00001592 inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00001593 void __init(size_type __n, value_type __c);
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001594
Martijn Vels5e7c9752020-03-04 17:52:46 -05001595 // Slow path for the (inlined) copy constructor for 'long' strings.
1596 // Always externally instantiated and not inlined.
1597 // Requires that __s is zero terminated.
1598 // The main reason for this function to exist is because for unstable, we
1599 // want to allow inlining of the copy constructor. However, we don't want
1600 // to call the __init() functions as those are marked as inline which may
1601 // result in over-aggressive inlining by the compiler, where our aim is
1602 // to only inline the fast path code directly in the ctor.
1603 void __init_copy_ctor_external(const value_type* __s, size_type __sz);
1604
Howard Hinnantc51e1022010-05-11 19:42:16 +00001605 template <class _InputIterator>
Duncan P. N. Exon Smitheb584632017-04-01 03:20:48 +00001606 inline
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001607 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001608 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001609 __is_exactly_cpp17_input_iterator<_InputIterator>::value
1610 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001611 __init(_InputIterator __first, _InputIterator __last);
1612
1613 template <class _ForwardIterator>
Duncan P. N. Exon Smitheb584632017-04-01 03:20:48 +00001614 inline
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001615 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001616 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001617 __is_cpp17_forward_iterator<_ForwardIterator>::value
1618 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001619 __init(_ForwardIterator __first, _ForwardIterator __last);
1620
1621 void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001622 size_type __n_copy, size_type __n_del, size_type __n_add = 0);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001623 void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
1624 size_type __n_copy, size_type __n_del,
Howard Hinnantd17880b2013-06-28 16:59:19 +00001625 size_type __n_add, const value_type* __p_new_stuff);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001626
Martijn Vels596e3de2020-02-26 15:55:49 -05001627 // __assign_no_alias is invoked for assignment operations where we
1628 // have proof that the input does not alias the current instance.
1629 // For example, operator=(basic_string) performs a 'self' check.
1630 template <bool __is_short>
Martijn Velsb6a08b62020-04-10 18:36:31 -04001631 basic_string& __assign_no_alias(const value_type* __s, size_type __n);
Martijn Vels596e3de2020-02-26 15:55:49 -05001632
Howard Hinnantcf823322010-12-17 14:46:43 +00001633 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001634 void __erase_to_end(size_type __pos);
1635
Martijn Velsa81fc792020-02-26 13:25:43 -05001636 // __erase_external_with_move is invoked for erase() invocations where
1637 // `n ~= npos`, likely requiring memory moves on the string data.
1638 void __erase_external_with_move(size_type __pos, size_type __n);
1639
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001640 _LIBCPP_INLINE_VISIBILITY
1641 void __copy_assign_alloc(const basic_string& __str)
1642 {__copy_assign_alloc(__str, integral_constant<bool,
1643 __alloc_traits::propagate_on_container_copy_assignment::value>());}
1644
1645 _LIBCPP_INLINE_VISIBILITY
1646 void __copy_assign_alloc(const basic_string& __str, true_type)
1647 {
Marshall Clowf258c202017-01-31 03:40:52 +00001648 if (__alloc() == __str.__alloc())
1649 __alloc() = __str.__alloc();
1650 else
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001651 {
Marshall Clowf258c202017-01-31 03:40:52 +00001652 if (!__str.__is_long())
1653 {
Vedant Kumar55e007e2018-03-08 21:15:26 +00001654 __clear_and_shrink();
Marshall Clowf258c202017-01-31 03:40:52 +00001655 __alloc() = __str.__alloc();
1656 }
1657 else
1658 {
1659 allocator_type __a = __str.__alloc();
1660 pointer __p = __alloc_traits::allocate(__a, __str.__get_long_cap());
Vedant Kumar55e007e2018-03-08 21:15:26 +00001661 __clear_and_shrink();
Marshall Clowf258c202017-01-31 03:40:52 +00001662 __alloc() = _VSTD::move(__a);
1663 __set_long_pointer(__p);
1664 __set_long_cap(__str.__get_long_cap());
1665 __set_long_size(__str.size());
1666 }
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001667 }
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001668 }
1669
1670 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant28b24882011-12-01 20:21:04 +00001671 void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001672 {}
1673
Eric Fiselierfc92be82017-04-19 00:28:44 +00001674#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantcf823322010-12-17 14:46:43 +00001675 _LIBCPP_INLINE_VISIBILITY
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00001676 void __move_assign(basic_string& __str, false_type)
1677 _NOEXCEPT_(__alloc_traits::is_always_equal::value);
Howard Hinnantcf823322010-12-17 14:46:43 +00001678 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e276872011-06-03 18:40:47 +00001679 void __move_assign(basic_string& __str, true_type)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00001680#if _LIBCPP_STD_VER > 14
1681 _NOEXCEPT;
1682#else
Howard Hinnant3e276872011-06-03 18:40:47 +00001683 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001684#endif
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00001685#endif
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001686
1687 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant58fe91b2011-08-17 20:36:18 +00001688 void
Howard Hinnantc2734962011-09-02 20:42:31 +00001689 __move_assign_alloc(basic_string& __str)
Howard Hinnant58fe91b2011-08-17 20:36:18 +00001690 _NOEXCEPT_(
1691 !__alloc_traits::propagate_on_container_move_assignment::value ||
1692 is_nothrow_move_assignable<allocator_type>::value)
1693 {__move_assign_alloc(__str, integral_constant<bool,
1694 __alloc_traits::propagate_on_container_move_assignment::value>());}
1695
1696 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc2734962011-09-02 20:42:31 +00001697 void __move_assign_alloc(basic_string& __c, true_type)
Howard Hinnant58fe91b2011-08-17 20:36:18 +00001698 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
1699 {
1700 __alloc() = _VSTD::move(__c.__alloc());
1701 }
1702
1703 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant28b24882011-12-01 20:21:04 +00001704 void __move_assign_alloc(basic_string&, false_type)
Howard Hinnant58fe91b2011-08-17 20:36:18 +00001705 _NOEXCEPT
1706 {}
1707
Martijn Velsda7d94f2020-06-19 14:24:03 -04001708 basic_string& __assign_external(const value_type* __s);
1709 basic_string& __assign_external(const value_type* __s, size_type __n);
1710
1711 // Assigns the value in __s, guaranteed to be __n < __min_cap in length.
1712 inline basic_string& __assign_short(const value_type* __s, size_type __n) {
1713 pointer __p = __is_long()
1714 ? (__set_long_size(__n), __get_long_pointer())
1715 : (__set_short_size(__n), __get_short_pointer());
1716 traits_type::move(_VSTD::__to_address(__p), __s, __n);
1717 traits_type::assign(__p[__n], value_type());
1718 return *this;
1719 }
1720
Howard Hinnantcf823322010-12-17 14:46:43 +00001721 _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
1722 _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001723
1724 friend basic_string operator+<>(const basic_string&, const basic_string&);
1725 friend basic_string operator+<>(const value_type*, const basic_string&);
1726 friend basic_string operator+<>(value_type, const basic_string&);
1727 friend basic_string operator+<>(const basic_string&, const value_type*);
1728 friend basic_string operator+<>(const basic_string&, value_type);
1729};
1730
Eric Fiselier2ed640b2020-03-04 13:54:04 -05001731// These declarations must appear before any functions are implicitly used
1732// so that they have the correct visibility specifier.
1733#ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
1734_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)
1735_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)
1736#else
1737_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)
1738_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)
1739#endif
1740
1741
Marshall Clowa0563332018-02-08 06:34:03 +00001742#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
1743template<class _InputIterator,
Arthur O'Dwyer56226762021-03-03 23:02:20 -05001744 class _CharT = __iter_value_type<_InputIterator>,
Marshall Clowa0563332018-02-08 06:34:03 +00001745 class _Allocator = allocator<_CharT>,
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001746 class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value>,
1747 class = _EnableIf<__is_allocator<_Allocator>::value>
Marshall Clowa0563332018-02-08 06:34:03 +00001748 >
1749basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
1750 -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
Marshall Clowe46031a2018-07-02 18:41:15 +00001751
1752template<class _CharT,
1753 class _Traits,
1754 class _Allocator = allocator<_CharT>,
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001755 class = _EnableIf<__is_allocator<_Allocator>::value>
Marshall Clowe46031a2018-07-02 18:41:15 +00001756 >
1757explicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
1758 -> basic_string<_CharT, _Traits, _Allocator>;
1759
1760template<class _CharT,
1761 class _Traits,
1762 class _Allocator = allocator<_CharT>,
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001763 class = _EnableIf<__is_allocator<_Allocator>::value>,
Marshall Clowe46031a2018-07-02 18:41:15 +00001764 class _Sz = typename allocator_traits<_Allocator>::size_type
1765 >
1766basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())
1767 -> basic_string<_CharT, _Traits, _Allocator>;
Marshall Clowa0563332018-02-08 06:34:03 +00001768#endif
1769
Howard Hinnantc51e1022010-05-11 19:42:16 +00001770template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001771inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00001772void
1773basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators()
1774{
Louis Dionneba400782020-10-02 15:02:52 -04001775#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001776 __get_db()->__invalidate_all(this);
Louis Dionneba400782020-10-02 15:02:52 -04001777#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001778}
1779
1780template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001781inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00001782void
Howard Hinnant28b24882011-12-01 20:21:04 +00001783basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type
Louis Dionneba400782020-10-02 15:02:52 -04001784#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant28b24882011-12-01 20:21:04 +00001785 __pos
1786#endif
1787 )
Howard Hinnantc51e1022010-05-11 19:42:16 +00001788{
Louis Dionneba400782020-10-02 15:02:52 -04001789#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001790 __c_node* __c = __get_db()->__find_c_and_lock(this);
1791 if (__c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001792 {
Howard Hinnant8ea98242013-08-23 17:37:05 +00001793 const_pointer __new_last = __get_pointer() + __pos;
1794 for (__i_node** __p = __c->end_; __p != __c->beg_; )
Howard Hinnantc51e1022010-05-11 19:42:16 +00001795 {
Howard Hinnant8ea98242013-08-23 17:37:05 +00001796 --__p;
1797 const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
1798 if (__i->base() > __new_last)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001799 {
Howard Hinnant8ea98242013-08-23 17:37:05 +00001800 (*__p)->__c_ = nullptr;
1801 if (--__c->end_ != __p)
Arthur O'Dwyer22236632020-12-07 21:50:15 -05001802 _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001803 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001804 }
Howard Hinnant8ea98242013-08-23 17:37:05 +00001805 __get_db()->unlock();
Howard Hinnantc51e1022010-05-11 19:42:16 +00001806 }
Louis Dionneba400782020-10-02 15:02:52 -04001807#endif // _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnantc51e1022010-05-11 19:42:16 +00001808}
1809
1810template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001811inline
Howard Hinnant3e276872011-06-03 18:40:47 +00001812basic_string<_CharT, _Traits, _Allocator>::basic_string()
Marshall Clowe546cbb2015-06-04 02:05:41 +00001813 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001814 : __r_(__default_init_tag(), __default_init_tag())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001815{
Louis Dionneba400782020-10-02 15:02:52 -04001816#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001817 __get_db()->__insert_c(this);
1818#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001819 __zero();
1820}
1821
1822template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001823inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00001824basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a)
Eric Fiseliere012bf22015-07-18 20:40:46 +00001825#if _LIBCPP_STD_VER <= 14
1826 _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
1827#else
1828 _NOEXCEPT
1829#endif
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001830: __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001831{
Louis Dionneba400782020-10-02 15:02:52 -04001832#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001833 __get_db()->__insert_c(this);
1834#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001835 __zero();
1836}
1837
1838template <class _CharT, class _Traits, class _Allocator>
Eric Fiselier815ed732016-09-16 00:00:48 +00001839void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
1840 size_type __sz,
1841 size_type __reserve)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001842{
1843 if (__reserve > max_size())
1844 this->__throw_length_error();
1845 pointer __p;
1846 if (__reserve < __min_cap)
1847 {
1848 __set_short_size(__sz);
1849 __p = __get_short_pointer();
1850 }
1851 else
1852 {
1853 size_type __cap = __recommend(__reserve);
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001854 __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001855 __set_long_pointer(__p);
1856 __set_long_cap(__cap+1);
1857 __set_long_size(__sz);
1858 }
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001859 traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001860 traits_type::assign(__p[__sz], value_type());
1861}
1862
1863template <class _CharT, class _Traits, class _Allocator>
1864void
Howard Hinnantd17880b2013-06-28 16:59:19 +00001865basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001866{
1867 if (__sz > max_size())
1868 this->__throw_length_error();
1869 pointer __p;
1870 if (__sz < __min_cap)
1871 {
1872 __set_short_size(__sz);
1873 __p = __get_short_pointer();
1874 }
1875 else
1876 {
1877 size_type __cap = __recommend(__sz);
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001878 __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001879 __set_long_pointer(__p);
1880 __set_long_cap(__cap+1);
1881 __set_long_size(__sz);
1882 }
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001883 traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001884 traits_type::assign(__p[__sz], value_type());
1885}
1886
1887template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00001888template <class>
Eric Fiselier812882b2017-02-17 01:17:10 +00001889basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001890 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001891{
Howard Hinnant8ea98242013-08-23 17:37:05 +00001892 _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00001893 __init(__s, traits_type::length(__s));
Louis Dionneba400782020-10-02 15:02:52 -04001894#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001895 __get_db()->__insert_c(this);
1896#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001897}
1898
1899template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001900inline
Eric Fiselier812882b2017-02-17 01:17:10 +00001901basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001902 : __r_(__default_init_tag(), __default_init_tag())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001903{
Howard Hinnant8ea98242013-08-23 17:37:05 +00001904 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00001905 __init(__s, __n);
Louis Dionneba400782020-10-02 15:02:52 -04001906#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001907 __get_db()->__insert_c(this);
1908#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001909}
1910
1911template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001912inline
Eric Fiselier812882b2017-02-17 01:17:10 +00001913basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001914 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001915{
Howard Hinnant8ea98242013-08-23 17:37:05 +00001916 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00001917 __init(__s, __n);
Louis Dionneba400782020-10-02 15:02:52 -04001918#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001919 __get_db()->__insert_c(this);
1920#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001921}
1922
1923template <class _CharT, class _Traits, class _Allocator>
1924basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001925 : __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
Howard Hinnantc51e1022010-05-11 19:42:16 +00001926{
1927 if (!__str.__is_long())
1928 __r_.first().__r = __str.__r_.first().__r;
1929 else
Martijn Vels5e7c9752020-03-04 17:52:46 -05001930 __init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()),
1931 __str.__get_long_size());
1932
Louis Dionneba400782020-10-02 15:02:52 -04001933#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001934 __get_db()->__insert_c(this);
1935#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001936}
1937
1938template <class _CharT, class _Traits, class _Allocator>
Eric Fiselier812882b2017-02-17 01:17:10 +00001939basic_string<_CharT, _Traits, _Allocator>::basic_string(
1940 const basic_string& __str, const allocator_type& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001941 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001942{
1943 if (!__str.__is_long())
1944 __r_.first().__r = __str.__r_.first().__r;
1945 else
Martijn Vels5e7c9752020-03-04 17:52:46 -05001946 __init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()),
1947 __str.__get_long_size());
Louis Dionneba400782020-10-02 15:02:52 -04001948#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001949 __get_db()->__insert_c(this);
1950#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001951}
1952
Martijn Vels5e7c9752020-03-04 17:52:46 -05001953template <class _CharT, class _Traits, class _Allocator>
1954void basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(
1955 const value_type* __s, size_type __sz) {
1956 pointer __p;
1957 if (__sz < __min_cap) {
1958 __p = __get_short_pointer();
1959 __set_short_size(__sz);
1960 } else {
1961 if (__sz > max_size())
1962 this->__throw_length_error();
1963 size_t __cap = __recommend(__sz);
1964 __p = __alloc_traits::allocate(__alloc(), __cap + 1);
1965 __set_long_pointer(__p);
1966 __set_long_cap(__cap + 1);
1967 __set_long_size(__sz);
1968 }
1969 traits_type::copy(_VSTD::__to_address(__p), __s, __sz + 1);
1970}
1971
Eric Fiselierfc92be82017-04-19 00:28:44 +00001972#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001973
1974template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001975inline
Howard Hinnant3e276872011-06-03 18:40:47 +00001976basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
Marshall Clowa80abc72015-06-03 19:56:43 +00001977#if _LIBCPP_STD_VER <= 14
Howard Hinnant3e276872011-06-03 18:40:47 +00001978 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
Marshall Clowa80abc72015-06-03 19:56:43 +00001979#else
1980 _NOEXCEPT
1981#endif
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001982 : __r_(_VSTD::move(__str.__r_))
Howard Hinnantc51e1022010-05-11 19:42:16 +00001983{
1984 __str.__zero();
Louis Dionneba400782020-10-02 15:02:52 -04001985#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00001986 __get_db()->__insert_c(this);
1987 if (__is_long())
1988 __get_db()->swap(this, &__str);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001989#endif
1990}
1991
1992template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001993inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00001994basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001995 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001996{
Marshall Clowd2d24692014-07-17 15:32:20 +00001997 if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001998 __init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
Marshall Clowd2d24692014-07-17 15:32:20 +00001999 else
2000 {
2001 __r_.first().__r = __str.__r_.first().__r;
2002 __str.__zero();
2003 }
Louis Dionneba400782020-10-02 15:02:52 -04002004#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002005 __get_db()->__insert_c(this);
2006 if (__is_long())
2007 __get_db()->swap(this, &__str);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002008#endif
2009}
2010
Eric Fiselierfc92be82017-04-19 00:28:44 +00002011#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00002012
2013template <class _CharT, class _Traits, class _Allocator>
2014void
2015basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
2016{
2017 if (__n > max_size())
2018 this->__throw_length_error();
2019 pointer __p;
2020 if (__n < __min_cap)
2021 {
2022 __set_short_size(__n);
2023 __p = __get_short_pointer();
2024 }
2025 else
2026 {
2027 size_type __cap = __recommend(__n);
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002028 __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002029 __set_long_pointer(__p);
2030 __set_long_cap(__cap+1);
2031 __set_long_size(__n);
2032 }
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002033 traits_type::assign(_VSTD::__to_address(__p), __n, __c);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002034 traits_type::assign(__p[__n], value_type());
2035}
2036
2037template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002038inline
Eric Fiselier812882b2017-02-17 01:17:10 +00002039basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002040 : __r_(__default_init_tag(), __default_init_tag())
Howard Hinnantc51e1022010-05-11 19:42:16 +00002041{
2042 __init(__n, __c);
Louis Dionneba400782020-10-02 15:02:52 -04002043#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002044 __get_db()->__insert_c(this);
2045#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002046}
2047
2048template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00002049template <class>
Eric Fiselier812882b2017-02-17 01:17:10 +00002050basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002051 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002052{
2053 __init(__n, __c);
Louis Dionneba400782020-10-02 15:02:52 -04002054#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002055 __get_db()->__insert_c(this);
2056#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002057}
2058
Howard Hinnantc51e1022010-05-11 19:42:16 +00002059template <class _CharT, class _Traits, class _Allocator>
Eric Fiselier812882b2017-02-17 01:17:10 +00002060basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,
2061 size_type __pos, size_type __n,
2062 const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002063 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002064{
2065 size_type __str_sz = __str.size();
2066 if (__pos > __str_sz)
2067 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002068 __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
Louis Dionneba400782020-10-02 15:02:52 -04002069#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002070 __get_db()->__insert_c(this);
2071#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002072}
2073
2074template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002075inline
Marshall Clow83445802016-04-07 18:13:41 +00002076basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
Eric Fiselier812882b2017-02-17 01:17:10 +00002077 const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002078 : __r_(__default_init_tag(), __a)
Marshall Clow83445802016-04-07 18:13:41 +00002079{
2080 size_type __str_sz = __str.size();
2081 if (__pos > __str_sz)
2082 this->__throw_out_of_range();
2083 __init(__str.data() + __pos, __str_sz - __pos);
Louis Dionneba400782020-10-02 15:02:52 -04002084#if _LIBCPP_DEBUG_LEVEL == 2
Marshall Clow83445802016-04-07 18:13:41 +00002085 __get_db()->__insert_c(this);
2086#endif
2087}
2088
2089template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00002090template <class _Tp, class>
Marshall Clow78dbe462016-11-14 18:22:19 +00002091basic_string<_CharT, _Traits, _Allocator>::basic_string(
Marshall Clowe46031a2018-07-02 18:41:15 +00002092 const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002093 : __r_(__default_init_tag(), __a)
Marshall Clow78dbe462016-11-14 18:22:19 +00002094{
Marshall Clowe46031a2018-07-02 18:41:15 +00002095 __self_view __sv0 = __t;
2096 __self_view __sv = __sv0.substr(__pos, __n);
Marshall Clow78dbe462016-11-14 18:22:19 +00002097 __init(__sv.data(), __sv.size());
Louis Dionneba400782020-10-02 15:02:52 -04002098#if _LIBCPP_DEBUG_LEVEL == 2
Marshall Clow78dbe462016-11-14 18:22:19 +00002099 __get_db()->__insert_c(this);
Eric Fiselier812882b2017-02-17 01:17:10 +00002100#endif
Marshall Clow78dbe462016-11-14 18:22:19 +00002101}
2102
2103template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00002104template <class _Tp, class>
2105basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002106 : __r_(__default_init_tag(), __default_init_tag())
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002107{
Marshall Clowe46031a2018-07-02 18:41:15 +00002108 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002109 __init(__sv.data(), __sv.size());
Louis Dionneba400782020-10-02 15:02:52 -04002110#if _LIBCPP_DEBUG_LEVEL == 2
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002111 __get_db()->__insert_c(this);
2112#endif
2113}
2114
2115template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00002116template <class _Tp, class>
2117basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002118 : __r_(__default_init_tag(), __a)
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002119{
Marshall Clowe46031a2018-07-02 18:41:15 +00002120 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002121 __init(__sv.data(), __sv.size());
Louis Dionneba400782020-10-02 15:02:52 -04002122#if _LIBCPP_DEBUG_LEVEL == 2
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002123 __get_db()->__insert_c(this);
2124#endif
2125}
2126
2127template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002128template <class _InputIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002129_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002130<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002131 __is_exactly_cpp17_input_iterator<_InputIterator>::value
2132>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002133basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
2134{
2135 __zero();
2136#ifndef _LIBCPP_NO_EXCEPTIONS
2137 try
2138 {
Howard Hinnant3b6579a2010-08-22 00:02:43 +00002139#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantc51e1022010-05-11 19:42:16 +00002140 for (; __first != __last; ++__first)
2141 push_back(*__first);
2142#ifndef _LIBCPP_NO_EXCEPTIONS
2143 }
2144 catch (...)
2145 {
2146 if (__is_long())
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002147 __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002148 throw;
2149 }
Howard Hinnant3b6579a2010-08-22 00:02:43 +00002150#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantc51e1022010-05-11 19:42:16 +00002151}
2152
2153template <class _CharT, class _Traits, class _Allocator>
2154template <class _ForwardIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002155_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002156<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002157 __is_cpp17_forward_iterator<_ForwardIterator>::value
2158>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002159basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
2160{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002161 size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002162 if (__sz > max_size())
2163 this->__throw_length_error();
2164 pointer __p;
2165 if (__sz < __min_cap)
2166 {
2167 __set_short_size(__sz);
2168 __p = __get_short_pointer();
2169 }
2170 else
2171 {
2172 size_type __cap = __recommend(__sz);
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002173 __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002174 __set_long_pointer(__p);
2175 __set_long_cap(__cap+1);
2176 __set_long_size(__sz);
2177 }
Eric Fiseliera09a3b42014-10-27 19:28:20 +00002178 for (; __first != __last; ++__first, (void) ++__p)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002179 traits_type::assign(*__p, *__first);
2180 traits_type::assign(*__p, value_type());
2181}
2182
2183template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierc0f566d2019-03-14 12:31:10 +00002184template<class _InputIterator, class>
Eric Fiselierbea70602018-11-26 22:51:35 +00002185inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002186basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002187 : __r_(__default_init_tag(), __default_init_tag())
Howard Hinnantc51e1022010-05-11 19:42:16 +00002188{
2189 __init(__first, __last);
Louis Dionneba400782020-10-02 15:02:52 -04002190#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002191 __get_db()->__insert_c(this);
2192#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002193}
2194
2195template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierc0f566d2019-03-14 12:31:10 +00002196template<class _InputIterator, class>
Eric Fiselierbea70602018-11-26 22:51:35 +00002197inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002198basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
2199 const allocator_type& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002200 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002201{
2202 __init(__first, __last);
Louis Dionneba400782020-10-02 15:02:52 -04002203#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002204 __get_db()->__insert_c(this);
2205#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002206}
2207
Eric Fiselierfc92be82017-04-19 00:28:44 +00002208#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002209
Howard Hinnantc51e1022010-05-11 19:42:16 +00002210template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002211inline
Eric Fiselier812882b2017-02-17 01:17:10 +00002212basic_string<_CharT, _Traits, _Allocator>::basic_string(
2213 initializer_list<_CharT> __il)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002214 : __r_(__default_init_tag(), __default_init_tag())
Howard Hinnantc51e1022010-05-11 19:42:16 +00002215{
2216 __init(__il.begin(), __il.end());
Louis Dionneba400782020-10-02 15:02:52 -04002217#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002218 __get_db()->__insert_c(this);
2219#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002220}
2221
2222template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002223inline
Eric Fiselier9d355982017-04-12 23:45:53 +00002224
Eric Fiselier812882b2017-02-17 01:17:10 +00002225basic_string<_CharT, _Traits, _Allocator>::basic_string(
2226 initializer_list<_CharT> __il, const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002227 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002228{
2229 __init(__il.begin(), __il.end());
Louis Dionneba400782020-10-02 15:02:52 -04002230#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002231 __get_db()->__insert_c(this);
2232#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002233}
2234
Eric Fiselierfc92be82017-04-19 00:28:44 +00002235#endif // _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002236
Howard Hinnantc51e1022010-05-11 19:42:16 +00002237template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002238basic_string<_CharT, _Traits, _Allocator>::~basic_string()
2239{
Louis Dionneba400782020-10-02 15:02:52 -04002240#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002241 __get_db()->__erase_c(this);
2242#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002243 if (__is_long())
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002244 __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002245}
2246
2247template <class _CharT, class _Traits, class _Allocator>
2248void
2249basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
2250 (size_type __old_cap, size_type __delta_cap, size_type __old_sz,
Howard Hinnantd17880b2013-06-28 16:59:19 +00002251 size_type __n_copy, size_type __n_del, size_type __n_add, const value_type* __p_new_stuff)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002252{
2253 size_type __ms = max_size();
2254 if (__delta_cap > __ms - __old_cap - 1)
2255 this->__throw_length_error();
2256 pointer __old_p = __get_pointer();
2257 size_type __cap = __old_cap < __ms / 2 - __alignment ?
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002258 __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
Howard Hinnantc51e1022010-05-11 19:42:16 +00002259 __ms - 1;
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002260 pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002261 __invalidate_all_iterators();
2262 if (__n_copy != 0)
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002263 traits_type::copy(_VSTD::__to_address(__p),
2264 _VSTD::__to_address(__old_p), __n_copy);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002265 if (__n_add != 0)
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002266 traits_type::copy(_VSTD::__to_address(__p) + __n_copy, __p_new_stuff, __n_add);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002267 size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
2268 if (__sec_cp_sz != 0)
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002269 traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
2270 _VSTD::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002271 if (__old_cap+1 != __min_cap)
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002272 __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002273 __set_long_pointer(__p);
2274 __set_long_cap(__cap+1);
2275 __old_sz = __n_copy + __n_add + __sec_cp_sz;
2276 __set_long_size(__old_sz);
2277 traits_type::assign(__p[__old_sz], value_type());
2278}
2279
2280template <class _CharT, class _Traits, class _Allocator>
2281void
2282basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
2283 size_type __n_copy, size_type __n_del, size_type __n_add)
2284{
2285 size_type __ms = max_size();
Marshall Clow2267c5d2013-11-06 14:24:38 +00002286 if (__delta_cap > __ms - __old_cap)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002287 this->__throw_length_error();
2288 pointer __old_p = __get_pointer();
2289 size_type __cap = __old_cap < __ms / 2 - __alignment ?
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002290 __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
Howard Hinnantc51e1022010-05-11 19:42:16 +00002291 __ms - 1;
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002292 pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002293 __invalidate_all_iterators();
2294 if (__n_copy != 0)
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002295 traits_type::copy(_VSTD::__to_address(__p),
2296 _VSTD::__to_address(__old_p), __n_copy);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002297 size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
2298 if (__sec_cp_sz != 0)
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002299 traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
2300 _VSTD::__to_address(__old_p) + __n_copy + __n_del,
Howard Hinnantd17880b2013-06-28 16:59:19 +00002301 __sec_cp_sz);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002302 if (__old_cap+1 != __min_cap)
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002303 __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002304 __set_long_pointer(__p);
2305 __set_long_cap(__cap+1);
2306}
2307
2308// assign
2309
2310template <class _CharT, class _Traits, class _Allocator>
Martijn Vels596e3de2020-02-26 15:55:49 -05002311template <bool __is_short>
Martijn Velsb6a08b62020-04-10 18:36:31 -04002312basic_string<_CharT, _Traits, _Allocator>&
2313basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(
Martijn Vels596e3de2020-02-26 15:55:49 -05002314 const value_type* __s, size_type __n) {
2315 size_type __cap = __is_short ? __min_cap : __get_long_cap();
2316 if (__n < __cap) {
2317 pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer();
2318 __is_short ? __set_short_size(__n) : __set_long_size(__n);
2319 traits_type::copy(_VSTD::__to_address(__p), __s, __n);
2320 traits_type::assign(__p[__n], value_type());
2321 __invalidate_iterators_past(__n);
2322 } else {
2323 size_type __sz = __is_short ? __get_short_size() : __get_long_size();
2324 __grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __s);
2325 }
Martijn Velsb6a08b62020-04-10 18:36:31 -04002326 return *this;
Martijn Vels596e3de2020-02-26 15:55:49 -05002327}
2328
2329template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002330basic_string<_CharT, _Traits, _Allocator>&
Martijn Velsda7d94f2020-06-19 14:24:03 -04002331basic_string<_CharT, _Traits, _Allocator>::__assign_external(
2332 const value_type* __s, size_type __n) {
2333 size_type __cap = capacity();
2334 if (__cap >= __n) {
2335 value_type* __p = _VSTD::__to_address(__get_pointer());
2336 traits_type::move(__p, __s, __n);
2337 traits_type::assign(__p[__n], value_type());
2338 __set_size(__n);
2339 __invalidate_iterators_past(__n);
2340 } else {
2341 size_type __sz = size();
2342 __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s);
2343 }
2344 return *this;
2345}
2346
2347template <class _CharT, class _Traits, class _Allocator>
2348basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002349basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002350{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002351 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr");
Martijn Velsda7d94f2020-06-19 14:24:03 -04002352 return (_LIBCPP_BUILTIN_CONSTANT_P(__n) && __n < __min_cap)
2353 ? __assign_short(__s, __n)
2354 : __assign_external(__s, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002355}
2356
2357template <class _CharT, class _Traits, class _Allocator>
2358basic_string<_CharT, _Traits, _Allocator>&
2359basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
2360{
2361 size_type __cap = capacity();
2362 if (__cap < __n)
2363 {
2364 size_type __sz = size();
2365 __grow_by(__cap, __n - __cap, __sz, 0, __sz);
2366 }
2367 else
2368 __invalidate_iterators_past(__n);
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002369 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002370 traits_type::assign(__p, __n, __c);
2371 traits_type::assign(__p[__n], value_type());
2372 __set_size(__n);
2373 return *this;
2374}
2375
2376template <class _CharT, class _Traits, class _Allocator>
2377basic_string<_CharT, _Traits, _Allocator>&
2378basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
2379{
2380 pointer __p;
2381 if (__is_long())
2382 {
2383 __p = __get_long_pointer();
2384 __set_long_size(1);
2385 }
2386 else
2387 {
2388 __p = __get_short_pointer();
2389 __set_short_size(1);
2390 }
2391 traits_type::assign(*__p, __c);
2392 traits_type::assign(*++__p, value_type());
2393 __invalidate_iterators_past(1);
2394 return *this;
2395}
2396
2397template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002398basic_string<_CharT, _Traits, _Allocator>&
2399basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
2400{
Martijn Vels596e3de2020-02-26 15:55:49 -05002401 if (this != &__str) {
2402 __copy_assign_alloc(__str);
2403 if (!__is_long()) {
2404 if (!__str.__is_long()) {
Eric Fiselier03bbc922020-01-15 17:27:10 -05002405 __r_.first().__r = __str.__r_.first().__r;
Martijn Vels596e3de2020-02-26 15:55:49 -05002406 } else {
Martijn Velsb6a08b62020-04-10 18:36:31 -04002407 return __assign_no_alias<true>(__str.data(), __str.size());
Martijn Vels596e3de2020-02-26 15:55:49 -05002408 }
2409 } else {
Martijn Velsb6a08b62020-04-10 18:36:31 -04002410 return __assign_no_alias<false>(__str.data(), __str.size());
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002411 }
Martijn Vels596e3de2020-02-26 15:55:49 -05002412 }
2413 return *this;
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002414}
2415
Eric Fiselierfc92be82017-04-19 00:28:44 +00002416#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002417
2418template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002419inline
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002420void
2421basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00002422 _NOEXCEPT_(__alloc_traits::is_always_equal::value)
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002423{
2424 if (__alloc() != __str.__alloc())
2425 assign(__str);
2426 else
2427 __move_assign(__str, true_type());
2428}
2429
2430template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002431inline
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002432void
2433basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00002434#if _LIBCPP_STD_VER > 14
2435 _NOEXCEPT
2436#else
Howard Hinnant3e276872011-06-03 18:40:47 +00002437 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00002438#endif
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002439{
marshall2ed41622019-11-27 07:13:00 -08002440 if (__is_long()) {
2441 __alloc_traits::deallocate(__alloc(), __get_long_pointer(),
2442 __get_long_cap());
2443#if _LIBCPP_STD_VER <= 14
2444 if (!is_nothrow_move_assignable<allocator_type>::value) {
2445 __set_short_size(0);
2446 traits_type::assign(__get_short_pointer()[0], value_type());
2447 }
2448#endif
2449 }
2450 __move_assign_alloc(__str);
2451 __r_.first() = __str.__r_.first();
2452 __str.__set_short_size(0);
2453 traits_type::assign(__str.__get_short_pointer()[0], value_type());
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002454}
2455
2456template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002457inline
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002458basic_string<_CharT, _Traits, _Allocator>&
2459basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00002460 _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002461{
2462 __move_assign(__str, integral_constant<bool,
2463 __alloc_traits::propagate_on_container_move_assignment::value>());
2464 return *this;
2465}
2466
2467#endif
2468
2469template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002470template<class _InputIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002471_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002472<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002473 __is_exactly_cpp17_input_iterator <_InputIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00002474 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00002475 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002476>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002477basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
2478{
Marshall Clow958362f2016-09-05 01:54:30 +00002479 const basic_string __temp(__first, __last, __alloc());
Marshall Clow039b2f02016-01-13 21:54:34 +00002480 assign(__temp.data(), __temp.size());
Argyrios Kyrtzidisaf904652012-10-13 02:03:45 +00002481 return *this;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002482}
2483
2484template <class _CharT, class _Traits, class _Allocator>
2485template<class _ForwardIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002486_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002487<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002488 __is_cpp17_forward_iterator<_ForwardIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00002489 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00002490 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002491>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002492basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
2493{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002494 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002495 size_type __cap = capacity();
2496 if (__cap < __n)
2497 {
2498 size_type __sz = size();
2499 __grow_by(__cap, __n - __cap, __sz, 0, __sz);
2500 }
2501 else
2502 __invalidate_iterators_past(__n);
2503 pointer __p = __get_pointer();
2504 for (; __first != __last; ++__first, ++__p)
2505 traits_type::assign(*__p, *__first);
2506 traits_type::assign(*__p, value_type());
2507 __set_size(__n);
2508 return *this;
2509}
2510
2511template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002512basic_string<_CharT, _Traits, _Allocator>&
2513basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
2514{
2515 size_type __sz = __str.size();
2516 if (__pos > __sz)
2517 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002518 return assign(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002519}
2520
2521template <class _CharT, class _Traits, class _Allocator>
Marshall Clow82513342016-09-24 22:45:42 +00002522template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002523_EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00002524<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002525 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
2526 && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
Marshall Clowb7db4972017-11-15 20:02:27 +00002527 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002528>
Marshall Clow82513342016-09-24 22:45:42 +00002529basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n)
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002530{
Marshall Clow82513342016-09-24 22:45:42 +00002531 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002532 size_type __sz = __sv.size();
2533 if (__pos > __sz)
2534 this->__throw_out_of_range();
2535 return assign(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
2536}
2537
2538
2539template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002540basic_string<_CharT, _Traits, _Allocator>&
Martijn Velsda7d94f2020-06-19 14:24:03 -04002541basic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __s) {
2542 return __assign_external(__s, traits_type::length(__s));
2543}
2544
2545template <class _CharT, class _Traits, class _Allocator>
2546basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002547basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002548{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002549 _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr");
Martijn Velsda7d94f2020-06-19 14:24:03 -04002550 return _LIBCPP_BUILTIN_CONSTANT_P(*__s)
2551 ? (traits_type::length(__s) < __min_cap
2552 ? __assign_short(__s, traits_type::length(__s))
2553 : __assign_external(__s, traits_type::length(__s)))
2554 : __assign_external(__s);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002555}
Howard Hinnantc51e1022010-05-11 19:42:16 +00002556// append
2557
2558template <class _CharT, class _Traits, class _Allocator>
2559basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002560basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002561{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002562 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002563 size_type __cap = capacity();
2564 size_type __sz = size();
2565 if (__cap - __sz >= __n)
2566 {
2567 if (__n)
2568 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002569 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002570 traits_type::copy(__p + __sz, __s, __n);
2571 __sz += __n;
2572 __set_size(__sz);
2573 traits_type::assign(__p[__sz], value_type());
2574 }
2575 }
2576 else
2577 __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);
2578 return *this;
2579}
2580
2581template <class _CharT, class _Traits, class _Allocator>
2582basic_string<_CharT, _Traits, _Allocator>&
2583basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)
2584{
2585 if (__n)
2586 {
2587 size_type __cap = capacity();
2588 size_type __sz = size();
2589 if (__cap - __sz < __n)
2590 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
2591 pointer __p = __get_pointer();
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002592 traits_type::assign(_VSTD::__to_address(__p) + __sz, __n, __c);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002593 __sz += __n;
2594 __set_size(__sz);
2595 traits_type::assign(__p[__sz], value_type());
2596 }
2597 return *this;
2598}
2599
2600template <class _CharT, class _Traits, class _Allocator>
Eric Fiselier451d5582018-11-26 20:15:38 +00002601inline void
2602basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n)
2603{
2604 if (__n)
2605 {
2606 size_type __cap = capacity();
2607 size_type __sz = size();
2608 if (__cap - __sz < __n)
2609 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
2610 pointer __p = __get_pointer();
2611 __sz += __n;
2612 __set_size(__sz);
2613 traits_type::assign(__p[__sz], value_type());
2614 }
2615}
2616
2617template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002618void
2619basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c)
2620{
Howard Hinnant68bf1812013-04-30 21:44:48 +00002621 bool __is_short = !__is_long();
2622 size_type __cap;
2623 size_type __sz;
2624 if (__is_short)
2625 {
2626 __cap = __min_cap - 1;
2627 __sz = __get_short_size();
2628 }
2629 else
2630 {
2631 __cap = __get_long_cap() - 1;
2632 __sz = __get_long_size();
2633 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00002634 if (__sz == __cap)
Howard Hinnant68bf1812013-04-30 21:44:48 +00002635 {
Howard Hinnantc51e1022010-05-11 19:42:16 +00002636 __grow_by(__cap, 1, __sz, __sz, 0);
Howard Hinnant68bf1812013-04-30 21:44:48 +00002637 __is_short = !__is_long();
2638 }
2639 pointer __p;
2640 if (__is_short)
2641 {
2642 __p = __get_short_pointer() + __sz;
2643 __set_short_size(__sz+1);
2644 }
2645 else
2646 {
2647 __p = __get_long_pointer() + __sz;
2648 __set_long_size(__sz+1);
2649 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00002650 traits_type::assign(*__p, __c);
2651 traits_type::assign(*++__p, value_type());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002652}
2653
Marshall Clow6ebbf662016-09-07 03:32:06 +00002654template <class _Tp>
Marshall Clow958362f2016-09-05 01:54:30 +00002655bool __ptr_in_range (const _Tp* __p, const _Tp* __first, const _Tp* __last)
2656{
2657 return __first <= __p && __p < __last;
2658}
2659
Marshall Clow6ebbf662016-09-07 03:32:06 +00002660template <class _Tp1, class _Tp2>
Eric Fiselier6003c772016-12-23 23:37:52 +00002661bool __ptr_in_range (const _Tp1*, const _Tp2*, const _Tp2*)
Marshall Clow6ebbf662016-09-07 03:32:06 +00002662{
2663 return false;
2664}
2665
Howard Hinnantc51e1022010-05-11 19:42:16 +00002666template <class _CharT, class _Traits, class _Allocator>
2667template<class _ForwardIterator>
Eric Fiselierdb7ee8f2016-10-31 02:46:25 +00002668basic_string<_CharT, _Traits, _Allocator>&
2669basic_string<_CharT, _Traits, _Allocator>::__append_forward_unsafe(
2670 _ForwardIterator __first, _ForwardIterator __last)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002671{
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002672 static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
Eric Fiselierdb7ee8f2016-10-31 02:46:25 +00002673 "function requires a ForwardIterator");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002674 size_type __sz = size();
2675 size_type __cap = capacity();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002676 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002677 if (__n)
2678 {
Eric Fiselier96866b52017-04-15 06:49:02 +00002679 typedef typename iterator_traits<_ForwardIterator>::reference _CharRef;
2680 _CharRef __tmp_ref = *__first;
2681 if (__ptr_in_range(_VSTD::addressof(__tmp_ref), data(), data() + size()))
Marshall Clow958362f2016-09-05 01:54:30 +00002682 {
2683 const basic_string __temp (__first, __last, __alloc());
2684 append(__temp.data(), __temp.size());
2685 }
Louis Dionne173f29e2019-05-29 16:01:36 +00002686 else
Marshall Clow958362f2016-09-05 01:54:30 +00002687 {
2688 if (__cap - __sz < __n)
2689 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
2690 pointer __p = __get_pointer() + __sz;
2691 for (; __first != __last; ++__p, ++__first)
2692 traits_type::assign(*__p, *__first);
2693 traits_type::assign(*__p, value_type());
2694 __set_size(__sz + __n);
2695 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00002696 }
2697 return *this;
2698}
2699
2700template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002701inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002702basic_string<_CharT, _Traits, _Allocator>&
2703basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str)
2704{
2705 return append(__str.data(), __str.size());
2706}
2707
2708template <class _CharT, class _Traits, class _Allocator>
2709basic_string<_CharT, _Traits, _Allocator>&
2710basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n)
2711{
2712 size_type __sz = __str.size();
2713 if (__pos > __sz)
2714 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002715 return append(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002716}
2717
2718template <class _CharT, class _Traits, class _Allocator>
Marshall Clow62953962016-10-03 23:40:48 +00002719template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002720 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00002721 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002722 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
Marshall Clow82513342016-09-24 22:45:42 +00002723 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002724 >
Marshall Clow82513342016-09-24 22:45:42 +00002725basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n)
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002726{
Marshall Clow82513342016-09-24 22:45:42 +00002727 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002728 size_type __sz = __sv.size();
2729 if (__pos > __sz)
2730 this->__throw_out_of_range();
2731 return append(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
2732}
2733
2734template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002735basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002736basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002737{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002738 _LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002739 return append(__s, traits_type::length(__s));
2740}
2741
2742// insert
2743
2744template <class _CharT, class _Traits, class _Allocator>
2745basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002746basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002747{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002748 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002749 size_type __sz = size();
2750 if (__pos > __sz)
2751 this->__throw_out_of_range();
2752 size_type __cap = capacity();
2753 if (__cap - __sz >= __n)
2754 {
2755 if (__n)
2756 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002757 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002758 size_type __n_move = __sz - __pos;
2759 if (__n_move != 0)
2760 {
2761 if (__p + __pos <= __s && __s < __p + __sz)
2762 __s += __n;
2763 traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
2764 }
2765 traits_type::move(__p + __pos, __s, __n);
2766 __sz += __n;
2767 __set_size(__sz);
2768 traits_type::assign(__p[__sz], value_type());
2769 }
2770 }
2771 else
2772 __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
2773 return *this;
2774}
2775
2776template <class _CharT, class _Traits, class _Allocator>
2777basic_string<_CharT, _Traits, _Allocator>&
2778basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c)
2779{
2780 size_type __sz = size();
2781 if (__pos > __sz)
2782 this->__throw_out_of_range();
2783 if (__n)
2784 {
2785 size_type __cap = capacity();
Howard Hinnantd17880b2013-06-28 16:59:19 +00002786 value_type* __p;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002787 if (__cap - __sz >= __n)
2788 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002789 __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002790 size_type __n_move = __sz - __pos;
2791 if (__n_move != 0)
2792 traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
2793 }
2794 else
2795 {
2796 __grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002797 __p = _VSTD::__to_address(__get_long_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002798 }
2799 traits_type::assign(__p + __pos, __n, __c);
2800 __sz += __n;
2801 __set_size(__sz);
2802 traits_type::assign(__p[__sz], value_type());
2803 }
2804 return *this;
2805}
2806
2807template <class _CharT, class _Traits, class _Allocator>
2808template<class _InputIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002809_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002810<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002811 __is_exactly_cpp17_input_iterator<_InputIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00002812 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
2813 typename basic_string<_CharT, _Traits, _Allocator>::iterator
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002814>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002815basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
2816{
Louis Dionneba400782020-10-02 15:02:52 -04002817#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002818 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
2819 "string::insert(iterator, range) called with an iterator not"
2820 " referring to this string");
2821#endif
Marshall Clow958362f2016-09-05 01:54:30 +00002822 const basic_string __temp(__first, __last, __alloc());
Marshall Clow039b2f02016-01-13 21:54:34 +00002823 return insert(__pos, __temp.data(), __temp.data() + __temp.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002824}
2825
2826template <class _CharT, class _Traits, class _Allocator>
2827template<class _ForwardIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002828_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002829<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002830 __is_cpp17_forward_iterator<_ForwardIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00002831 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00002832 typename basic_string<_CharT, _Traits, _Allocator>::iterator
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002833>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002834basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
2835{
Louis Dionneba400782020-10-02 15:02:52 -04002836#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002837 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
2838 "string::insert(iterator, range) called with an iterator not"
2839 " referring to this string");
2840#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002841 size_type __ip = static_cast<size_type>(__pos - begin());
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002842 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002843 if (__n)
2844 {
Eric Fiselier96866b52017-04-15 06:49:02 +00002845 typedef typename iterator_traits<_ForwardIterator>::reference _CharRef;
2846 _CharRef __tmp_char = *__first;
2847 if (__ptr_in_range(_VSTD::addressof(__tmp_char), data(), data() + size()))
Marshall Clow958362f2016-09-05 01:54:30 +00002848 {
2849 const basic_string __temp(__first, __last, __alloc());
2850 return insert(__pos, __temp.data(), __temp.data() + __temp.size());
2851 }
2852
2853 size_type __sz = size();
2854 size_type __cap = capacity();
Howard Hinnantd17880b2013-06-28 16:59:19 +00002855 value_type* __p;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002856 if (__cap - __sz >= __n)
2857 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002858 __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002859 size_type __n_move = __sz - __ip;
2860 if (__n_move != 0)
2861 traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
2862 }
2863 else
2864 {
2865 __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002866 __p = _VSTD::__to_address(__get_long_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002867 }
2868 __sz += __n;
2869 __set_size(__sz);
2870 traits_type::assign(__p[__sz], value_type());
2871 for (__p += __ip; __first != __last; ++__p, ++__first)
2872 traits_type::assign(*__p, *__first);
2873 }
2874 return begin() + __ip;
2875}
2876
2877template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002878inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002879basic_string<_CharT, _Traits, _Allocator>&
2880basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str)
2881{
2882 return insert(__pos1, __str.data(), __str.size());
2883}
2884
2885template <class _CharT, class _Traits, class _Allocator>
2886basic_string<_CharT, _Traits, _Allocator>&
2887basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str,
2888 size_type __pos2, size_type __n)
2889{
2890 size_type __str_sz = __str.size();
2891 if (__pos2 > __str_sz)
2892 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002893 return insert(__pos1, __str.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002894}
2895
2896template <class _CharT, class _Traits, class _Allocator>
Marshall Clow82513342016-09-24 22:45:42 +00002897template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002898_EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00002899<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002900 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
Marshall Clowb7db4972017-11-15 20:02:27 +00002901 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002902>
Marshall Clow82513342016-09-24 22:45:42 +00002903basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t,
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002904 size_type __pos2, size_type __n)
2905{
Marshall Clow82513342016-09-24 22:45:42 +00002906 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002907 size_type __str_sz = __sv.size();
2908 if (__pos2 > __str_sz)
2909 this->__throw_out_of_range();
2910 return insert(__pos1, __sv.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
2911}
2912
2913template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002914basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002915basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002916{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002917 _LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002918 return insert(__pos, __s, traits_type::length(__s));
2919}
2920
2921template <class _CharT, class _Traits, class _Allocator>
2922typename basic_string<_CharT, _Traits, _Allocator>::iterator
2923basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
2924{
2925 size_type __ip = static_cast<size_type>(__pos - begin());
2926 size_type __sz = size();
2927 size_type __cap = capacity();
Howard Hinnantd17880b2013-06-28 16:59:19 +00002928 value_type* __p;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002929 if (__cap == __sz)
2930 {
2931 __grow_by(__cap, 1, __sz, __ip, 0, 1);
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002932 __p = _VSTD::__to_address(__get_long_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002933 }
2934 else
2935 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002936 __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002937 size_type __n_move = __sz - __ip;
2938 if (__n_move != 0)
2939 traits_type::move(__p + __ip + 1, __p + __ip, __n_move);
2940 }
2941 traits_type::assign(__p[__ip], __c);
2942 traits_type::assign(__p[++__sz], value_type());
2943 __set_size(__sz);
2944 return begin() + static_cast<difference_type>(__ip);
2945}
2946
2947template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002948inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002949typename basic_string<_CharT, _Traits, _Allocator>::iterator
2950basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c)
2951{
Louis Dionneba400782020-10-02 15:02:52 -04002952#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00002953 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
2954 "string::insert(iterator, n, value) called with an iterator not"
2955 " referring to this string");
2956#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002957 difference_type __p = __pos - begin();
2958 insert(static_cast<size_type>(__p), __n, __c);
2959 return begin() + __p;
2960}
2961
2962// replace
2963
2964template <class _CharT, class _Traits, class _Allocator>
2965basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002966basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
Eric Fiseliere5b21842017-03-09 01:54:13 +00002967 _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
Howard Hinnantc51e1022010-05-11 19:42:16 +00002968{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002969 _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002970 size_type __sz = size();
2971 if (__pos > __sz)
2972 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002973 __n1 = _VSTD::min(__n1, __sz - __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002974 size_type __cap = capacity();
2975 if (__cap - __sz + __n1 >= __n2)
2976 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002977 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002978 if (__n1 != __n2)
2979 {
2980 size_type __n_move = __sz - __pos - __n1;
2981 if (__n_move != 0)
2982 {
2983 if (__n1 > __n2)
2984 {
2985 traits_type::move(__p + __pos, __s, __n2);
2986 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
2987 goto __finish;
2988 }
2989 if (__p + __pos < __s && __s < __p + __sz)
2990 {
2991 if (__p + __pos + __n1 <= __s)
2992 __s += __n2 - __n1;
2993 else // __p + __pos < __s < __p + __pos + __n1
2994 {
2995 traits_type::move(__p + __pos, __s, __n1);
2996 __pos += __n1;
2997 __s += __n2;
2998 __n2 -= __n1;
2999 __n1 = 0;
3000 }
3001 }
3002 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
3003 }
3004 }
3005 traits_type::move(__p + __pos, __s, __n2);
3006__finish:
Martijn Vels1c48afb2020-01-28 13:43:19 -05003007// __sz += __n2 - __n1; in this and the below function below can cause unsigned
3008// integer overflow, but this is a safe operation, so we disable the check.
Howard Hinnantc51e1022010-05-11 19:42:16 +00003009 __sz += __n2 - __n1;
3010 __set_size(__sz);
3011 __invalidate_iterators_past(__sz);
3012 traits_type::assign(__p[__sz], value_type());
3013 }
3014 else
3015 __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
3016 return *this;
3017}
3018
3019template <class _CharT, class _Traits, class _Allocator>
3020basic_string<_CharT, _Traits, _Allocator>&
3021basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c)
Eric Fiseliere5b21842017-03-09 01:54:13 +00003022 _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
Howard Hinnantc51e1022010-05-11 19:42:16 +00003023{
3024 size_type __sz = size();
3025 if (__pos > __sz)
3026 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003027 __n1 = _VSTD::min(__n1, __sz - __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003028 size_type __cap = capacity();
Howard Hinnantd17880b2013-06-28 16:59:19 +00003029 value_type* __p;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003030 if (__cap - __sz + __n1 >= __n2)
3031 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05003032 __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003033 if (__n1 != __n2)
3034 {
3035 size_type __n_move = __sz - __pos - __n1;
3036 if (__n_move != 0)
3037 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
3038 }
3039 }
3040 else
3041 {
3042 __grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2);
Eric Fiselierc1b87a72019-11-16 17:13:26 -05003043 __p = _VSTD::__to_address(__get_long_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003044 }
3045 traits_type::assign(__p + __pos, __n2, __c);
3046 __sz += __n2 - __n1;
3047 __set_size(__sz);
3048 __invalidate_iterators_past(__sz);
3049 traits_type::assign(__p[__sz], value_type());
3050 return *this;
3051}
3052
3053template <class _CharT, class _Traits, class _Allocator>
3054template<class _InputIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003055_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00003056<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05003057 __is_cpp17_input_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00003058 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003059>
Howard Hinnant990d6e82010-11-17 21:11:40 +00003060basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,
Howard Hinnantc51e1022010-05-11 19:42:16 +00003061 _InputIterator __j1, _InputIterator __j2)
3062{
Marshall Clow958362f2016-09-05 01:54:30 +00003063 const basic_string __temp(__j1, __j2, __alloc());
Marshall Clow039b2f02016-01-13 21:54:34 +00003064 return this->replace(__i1, __i2, __temp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003065}
3066
3067template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003068inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003069basic_string<_CharT, _Traits, _Allocator>&
3070basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str)
3071{
3072 return replace(__pos1, __n1, __str.data(), __str.size());
3073}
3074
3075template <class _CharT, class _Traits, class _Allocator>
3076basic_string<_CharT, _Traits, _Allocator>&
3077basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str,
3078 size_type __pos2, size_type __n2)
3079{
3080 size_type __str_sz = __str.size();
3081 if (__pos2 > __str_sz)
3082 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003083 return replace(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003084}
3085
3086template <class _CharT, class _Traits, class _Allocator>
Marshall Clow82513342016-09-24 22:45:42 +00003087template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003088_EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00003089<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003090 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
Marshall Clowb7db4972017-11-15 20:02:27 +00003091 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003092>
Marshall Clow82513342016-09-24 22:45:42 +00003093basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t,
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003094 size_type __pos2, size_type __n2)
3095{
Marshall Clow82513342016-09-24 22:45:42 +00003096 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003097 size_type __str_sz = __sv.size();
3098 if (__pos2 > __str_sz)
3099 this->__throw_out_of_range();
3100 return replace(__pos1, __n1, __sv.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
3101}
3102
3103template <class _CharT, class _Traits, class _Allocator>
3104basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00003105basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003106{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003107 _LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003108 return replace(__pos, __n1, __s, traits_type::length(__s));
3109}
3110
3111template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003112inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003113basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnant990d6e82010-11-17 21:11:40 +00003114basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003115{
3116 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1),
3117 __str.data(), __str.size());
3118}
3119
3120template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003121inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003122basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00003123basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003124{
3125 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n);
3126}
3127
3128template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003129inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003130basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00003131basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003132{
3133 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s);
3134}
3135
3136template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003137inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003138basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnant990d6e82010-11-17 21:11:40 +00003139basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003140{
3141 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c);
3142}
3143
3144// erase
3145
Martijn Velsa81fc792020-02-26 13:25:43 -05003146// 'externally instantiated' erase() implementation, called when __n != npos.
3147// Does not check __pos against size()
Howard Hinnantc51e1022010-05-11 19:42:16 +00003148template <class _CharT, class _Traits, class _Allocator>
Martijn Velsa81fc792020-02-26 13:25:43 -05003149void
3150basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move(
3151 size_type __pos, size_type __n)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003152{
Howard Hinnantc51e1022010-05-11 19:42:16 +00003153 if (__n)
3154 {
Martijn Velsa81fc792020-02-26 13:25:43 -05003155 size_type __sz = size();
Eric Fiselierc1b87a72019-11-16 17:13:26 -05003156 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003157 __n = _VSTD::min(__n, __sz - __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003158 size_type __n_move = __sz - __pos - __n;
3159 if (__n_move != 0)
3160 traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
3161 __sz -= __n;
3162 __set_size(__sz);
3163 __invalidate_iterators_past(__sz);
3164 traits_type::assign(__p[__sz], value_type());
3165 }
Martijn Velsa81fc792020-02-26 13:25:43 -05003166}
3167
3168template <class _CharT, class _Traits, class _Allocator>
3169basic_string<_CharT, _Traits, _Allocator>&
3170basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos,
3171 size_type __n) {
3172 if (__pos > size()) this->__throw_out_of_range();
3173 if (__n == npos) {
3174 __erase_to_end(__pos);
3175 } else {
3176 __erase_external_with_move(__pos, __n);
3177 }
3178 return *this;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003179}
3180
3181template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003182inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003183typename basic_string<_CharT, _Traits, _Allocator>::iterator
3184basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
3185{
Louis Dionneba400782020-10-02 15:02:52 -04003186#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00003187 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
3188 "string::erase(iterator) called with an iterator not"
3189 " referring to this string");
3190#endif
3191 _LIBCPP_ASSERT(__pos != end(),
3192 "string::erase(iterator) called with a non-dereferenceable iterator");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003193 iterator __b = begin();
3194 size_type __r = static_cast<size_type>(__pos - __b);
3195 erase(__r, 1);
Howard Hinnant28b24882011-12-01 20:21:04 +00003196 return __b + static_cast<difference_type>(__r);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003197}
3198
3199template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003200inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003201typename basic_string<_CharT, _Traits, _Allocator>::iterator
3202basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last)
3203{
Louis Dionneba400782020-10-02 15:02:52 -04003204#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00003205 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
3206 "string::erase(iterator, iterator) called with an iterator not"
3207 " referring to this string");
3208#endif
3209 _LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003210 iterator __b = begin();
3211 size_type __r = static_cast<size_type>(__first - __b);
3212 erase(__r, static_cast<size_type>(__last - __first));
Howard Hinnant28b24882011-12-01 20:21:04 +00003213 return __b + static_cast<difference_type>(__r);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003214}
3215
3216template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003217inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003218void
3219basic_string<_CharT, _Traits, _Allocator>::pop_back()
3220{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003221 _LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003222 size_type __sz;
3223 if (__is_long())
3224 {
3225 __sz = __get_long_size() - 1;
3226 __set_long_size(__sz);
3227 traits_type::assign(*(__get_long_pointer() + __sz), value_type());
3228 }
3229 else
3230 {
3231 __sz = __get_short_size() - 1;
3232 __set_short_size(__sz);
3233 traits_type::assign(*(__get_short_pointer() + __sz), value_type());
3234 }
3235 __invalidate_iterators_past(__sz);
3236}
3237
3238template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003239inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003240void
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003241basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003242{
3243 __invalidate_all_iterators();
3244 if (__is_long())
3245 {
3246 traits_type::assign(*__get_long_pointer(), value_type());
3247 __set_long_size(0);
3248 }
3249 else
3250 {
3251 traits_type::assign(*__get_short_pointer(), value_type());
3252 __set_short_size(0);
3253 }
3254}
3255
3256template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003257inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003258void
3259basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos)
3260{
3261 if (__is_long())
3262 {
3263 traits_type::assign(*(__get_long_pointer() + __pos), value_type());
3264 __set_long_size(__pos);
3265 }
3266 else
3267 {
3268 traits_type::assign(*(__get_short_pointer() + __pos), value_type());
3269 __set_short_size(__pos);
3270 }
3271 __invalidate_iterators_past(__pos);
3272}
3273
3274template <class _CharT, class _Traits, class _Allocator>
3275void
3276basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c)
3277{
3278 size_type __sz = size();
3279 if (__n > __sz)
3280 append(__n - __sz, __c);
3281 else
3282 __erase_to_end(__n);
3283}
3284
3285template <class _CharT, class _Traits, class _Allocator>
Eric Fiselier451d5582018-11-26 20:15:38 +00003286inline void
3287basic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n)
3288{
3289 size_type __sz = size();
3290 if (__n > __sz) {
3291 __append_default_init(__n - __sz);
3292 } else
3293 __erase_to_end(__n);
3294}
3295
3296template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003297inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003298typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003299basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003300{
Howard Hinnantea8f7e12010-11-17 17:55:08 +00003301 size_type __m = __alloc_traits::max_size(__alloc());
Eric Fiseliere9cc5922017-10-17 13:16:01 +00003302#ifdef _LIBCPP_BIG_ENDIAN
Marshall Clow6dd6cb72013-10-31 17:23:08 +00003303 return (__m <= ~__long_mask ? __m : __m/2) - __alignment;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003304#else
Marshall Clow6dd6cb72013-10-31 17:23:08 +00003305 return __m - __alignment;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003306#endif
3307}
3308
3309template <class _CharT, class _Traits, class _Allocator>
3310void
Marek Kurdejc9848142020-11-26 10:07:16 +01003311basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003312{
Marek Kurdejc9848142020-11-26 10:07:16 +01003313 if (__requested_capacity > max_size())
Howard Hinnantc51e1022010-05-11 19:42:16 +00003314 this->__throw_length_error();
Marek Kurdejc9848142020-11-26 10:07:16 +01003315
3316#if _LIBCPP_STD_VER > 17
3317 // Reserve never shrinks as of C++20.
3318 if (__requested_capacity <= capacity()) return;
3319#endif
3320
3321 size_type __target_capacity = _VSTD::max(__requested_capacity, size());
3322 __target_capacity = __recommend(__target_capacity);
3323 if (__target_capacity == capacity()) return;
3324
3325 __shrink_or_extend(__target_capacity);
3326}
3327
3328template <class _CharT, class _Traits, class _Allocator>
3329void
3330basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT
3331{
3332 size_type __target_capacity = __recommend(size());
3333 if (__target_capacity == capacity()) return;
3334
3335 __shrink_or_extend(__target_capacity);
3336}
3337
3338template <class _CharT, class _Traits, class _Allocator>
3339void
3340basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity)
3341{
Howard Hinnantc51e1022010-05-11 19:42:16 +00003342 size_type __cap = capacity();
3343 size_type __sz = size();
Marek Kurdejc9848142020-11-26 10:07:16 +01003344
3345 pointer __new_data, __p;
3346 bool __was_long, __now_long;
3347 if (__target_capacity == __min_cap - 1)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003348 {
Marek Kurdejc9848142020-11-26 10:07:16 +01003349 __was_long = true;
3350 __now_long = false;
3351 __new_data = __get_short_pointer();
3352 __p = __get_long_pointer();
Howard Hinnantc51e1022010-05-11 19:42:16 +00003353 }
Marek Kurdejc9848142020-11-26 10:07:16 +01003354 else
3355 {
3356 if (__target_capacity > __cap)
3357 __new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1);
3358 else
3359 {
3360 #ifndef _LIBCPP_NO_EXCEPTIONS
3361 try
3362 {
3363 #endif // _LIBCPP_NO_EXCEPTIONS
3364 __new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1);
3365 #ifndef _LIBCPP_NO_EXCEPTIONS
3366 }
3367 catch (...)
3368 {
3369 return;
3370 }
3371 #else // _LIBCPP_NO_EXCEPTIONS
3372 if (__new_data == nullptr)
3373 return;
3374 #endif // _LIBCPP_NO_EXCEPTIONS
3375 }
3376 __now_long = true;
3377 __was_long = __is_long();
3378 __p = __get_pointer();
3379 }
3380 traits_type::copy(_VSTD::__to_address(__new_data),
3381 _VSTD::__to_address(__p), size()+1);
3382 if (__was_long)
3383 __alloc_traits::deallocate(__alloc(), __p, __cap+1);
3384 if (__now_long)
3385 {
3386 __set_long_cap(__target_capacity+1);
3387 __set_long_size(__sz);
3388 __set_long_pointer(__new_data);
3389 }
3390 else
3391 __set_short_size(__sz);
3392 __invalidate_all_iterators();
Howard Hinnantc51e1022010-05-11 19:42:16 +00003393}
3394
3395template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003396inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003397typename basic_string<_CharT, _Traits, _Allocator>::const_reference
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003398basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003399{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003400 _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003401 return *(data() + __pos);
3402}
3403
3404template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003405inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003406typename basic_string<_CharT, _Traits, _Allocator>::reference
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003407basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003408{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003409 _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003410 return *(__get_pointer() + __pos);
3411}
3412
3413template <class _CharT, class _Traits, class _Allocator>
3414typename basic_string<_CharT, _Traits, _Allocator>::const_reference
3415basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const
3416{
3417 if (__n >= size())
3418 this->__throw_out_of_range();
3419 return (*this)[__n];
3420}
3421
3422template <class _CharT, class _Traits, class _Allocator>
3423typename basic_string<_CharT, _Traits, _Allocator>::reference
3424basic_string<_CharT, _Traits, _Allocator>::at(size_type __n)
3425{
3426 if (__n >= size())
3427 this->__throw_out_of_range();
3428 return (*this)[__n];
3429}
3430
3431template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003432inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003433typename basic_string<_CharT, _Traits, _Allocator>::reference
Marshall Clow05cf6692019-03-19 03:30:07 +00003434basic_string<_CharT, _Traits, _Allocator>::front() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003435{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003436 _LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003437 return *__get_pointer();
3438}
3439
3440template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003441inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003442typename basic_string<_CharT, _Traits, _Allocator>::const_reference
Marshall Clow05cf6692019-03-19 03:30:07 +00003443basic_string<_CharT, _Traits, _Allocator>::front() const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003444{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003445 _LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003446 return *data();
3447}
3448
3449template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003450inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003451typename basic_string<_CharT, _Traits, _Allocator>::reference
Marshall Clow05cf6692019-03-19 03:30:07 +00003452basic_string<_CharT, _Traits, _Allocator>::back() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003453{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003454 _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003455 return *(__get_pointer() + size() - 1);
3456}
3457
3458template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003459inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003460typename basic_string<_CharT, _Traits, _Allocator>::const_reference
Marshall Clow05cf6692019-03-19 03:30:07 +00003461basic_string<_CharT, _Traits, _Allocator>::back() const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003462{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003463 _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003464 return *(data() + size() - 1);
3465}
3466
3467template <class _CharT, class _Traits, class _Allocator>
3468typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003469basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const
Howard Hinnantc51e1022010-05-11 19:42:16 +00003470{
3471 size_type __sz = size();
3472 if (__pos > __sz)
3473 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003474 size_type __rlen = _VSTD::min(__n, __sz - __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003475 traits_type::copy(__s, data() + __pos, __rlen);
3476 return __rlen;
3477}
3478
3479template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003480inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003481basic_string<_CharT, _Traits, _Allocator>
3482basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const
3483{
3484 return basic_string(*this, __pos, __n, __alloc());
3485}
3486
3487template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003488inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003489void
3490basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
Marshall Clow8982dcd2015-07-13 20:04:56 +00003491#if _LIBCPP_STD_VER >= 14
Eric Fiselier873b8d32019-03-18 21:50:12 +00003492 _NOEXCEPT
Marshall Clow8982dcd2015-07-13 20:04:56 +00003493#else
Eric Fiselier873b8d32019-03-18 21:50:12 +00003494 _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
Marshall Clow8982dcd2015-07-13 20:04:56 +00003495 __is_nothrow_swappable<allocator_type>::value)
3496#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00003497{
Louis Dionneba400782020-10-02 15:02:52 -04003498#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00003499 if (!__is_long())
3500 __get_db()->__invalidate_all(this);
3501 if (!__str.__is_long())
3502 __get_db()->__invalidate_all(&__str);
3503 __get_db()->swap(this, &__str);
3504#endif
Eric Fiselier9bf691f2016-12-28 05:53:01 +00003505 _LIBCPP_ASSERT(
3506 __alloc_traits::propagate_on_container_swap::value ||
3507 __alloc_traits::is_always_equal::value ||
3508 __alloc() == __str.__alloc(), "swapping non-equal allocators");
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003509 _VSTD::swap(__r_.first(), __str.__r_.first());
Arthur O'Dwyer4e0de312020-11-18 18:54:38 -05003510 _VSTD::__swap_allocator(__alloc(), __str.__alloc());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003511}
3512
3513// find
3514
3515template <class _Traits>
3516struct _LIBCPP_HIDDEN __traits_eq
3517{
3518 typedef typename _Traits::char_type char_type;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003519 _LIBCPP_INLINE_VISIBILITY
3520 bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT
3521 {return _Traits::eq(__x, __y);}
Howard Hinnantc51e1022010-05-11 19:42:16 +00003522};
3523
3524template<class _CharT, class _Traits, class _Allocator>
3525typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003526basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003527 size_type __pos,
3528 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003529{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003530 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003531 return __str_find<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003532 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003533}
3534
3535template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003536inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003537typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003538basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
3539 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003540{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003541 return __str_find<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003542 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003543}
3544
3545template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003546template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003547_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003548<
3549 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3550 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003551>
Marshall Clowe46031a2018-07-02 18:41:15 +00003552basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t,
zoecarver1997e0a2021-02-05 11:54:47 -08003553 size_type __pos) const _NOEXCEPT
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003554{
Marshall Clowe46031a2018-07-02 18:41:15 +00003555 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003556 return __str_find<value_type, size_type, traits_type, npos>
3557 (data(), size(), __sv.data(), __pos, __sv.size());
3558}
3559
3560template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003561inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003562typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003563basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003564 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003565{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003566 _LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003567 return __str_find<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003568 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003569}
3570
3571template<class _CharT, class _Traits, class _Allocator>
3572typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003573basic_string<_CharT, _Traits, _Allocator>::find(value_type __c,
3574 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003575{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003576 return __str_find<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003577 (data(), size(), __c, __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003578}
3579
3580// rfind
3581
3582template<class _CharT, class _Traits, class _Allocator>
3583typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003584basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003585 size_type __pos,
3586 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003587{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003588 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003589 return __str_rfind<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003590 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003591}
3592
3593template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003594inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003595typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003596basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
3597 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003598{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003599 return __str_rfind<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003600 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003601}
3602
3603template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003604template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003605_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003606<
3607 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3608 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003609>
Marshall Clowe46031a2018-07-02 18:41:15 +00003610basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t,
zoecarver1997e0a2021-02-05 11:54:47 -08003611 size_type __pos) const _NOEXCEPT
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003612{
Marshall Clowe46031a2018-07-02 18:41:15 +00003613 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003614 return __str_rfind<value_type, size_type, traits_type, npos>
3615 (data(), size(), __sv.data(), __pos, __sv.size());
3616}
3617
3618template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003619inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003620typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003621basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003622 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003623{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003624 _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003625 return __str_rfind<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003626 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003627}
3628
3629template<class _CharT, class _Traits, class _Allocator>
3630typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003631basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c,
3632 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003633{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003634 return __str_rfind<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003635 (data(), size(), __c, __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003636}
3637
3638// find_first_of
3639
3640template<class _CharT, class _Traits, class _Allocator>
3641typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003642basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003643 size_type __pos,
3644 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003645{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003646 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003647 return __str_find_first_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003648 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003649}
3650
3651template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003652inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003653typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003654basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str,
3655 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003656{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003657 return __str_find_first_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003658 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003659}
3660
3661template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003662template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003663_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003664<
3665 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3666 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003667>
Marshall Clowe46031a2018-07-02 18:41:15 +00003668basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t,
zoecarver1997e0a2021-02-05 11:54:47 -08003669 size_type __pos) const _NOEXCEPT
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003670{
Marshall Clowe46031a2018-07-02 18:41:15 +00003671 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003672 return __str_find_first_of<value_type, size_type, traits_type, npos>
3673 (data(), size(), __sv.data(), __pos, __sv.size());
3674}
3675
3676template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003677inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003678typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003679basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003680 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003681{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003682 _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003683 return __str_find_first_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003684 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003685}
3686
3687template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003688inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003689typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003690basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
3691 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003692{
3693 return find(__c, __pos);
3694}
3695
3696// find_last_of
3697
3698template<class _CharT, class _Traits, class _Allocator>
3699typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003700basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003701 size_type __pos,
3702 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003703{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003704 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003705 return __str_find_last_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003706 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003707}
3708
3709template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003710inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003711typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003712basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str,
3713 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003714{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003715 return __str_find_last_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003716 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003717}
3718
3719template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003720template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003721_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003722<
3723 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3724 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003725>
Marshall Clowe46031a2018-07-02 18:41:15 +00003726basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t,
zoecarver1997e0a2021-02-05 11:54:47 -08003727 size_type __pos) const _NOEXCEPT
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003728{
Marshall Clowe46031a2018-07-02 18:41:15 +00003729 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003730 return __str_find_last_of<value_type, size_type, traits_type, npos>
3731 (data(), size(), __sv.data(), __pos, __sv.size());
3732}
3733
3734template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003735inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003736typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003737basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003738 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003739{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003740 _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003741 return __str_find_last_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003742 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003743}
3744
3745template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003746inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003747typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003748basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
3749 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003750{
3751 return rfind(__c, __pos);
3752}
3753
3754// find_first_not_of
3755
3756template<class _CharT, class _Traits, class _Allocator>
3757typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003758basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003759 size_type __pos,
3760 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003761{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003762 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003763 return __str_find_first_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003764 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003765}
3766
3767template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003768inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003769typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003770basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str,
3771 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003772{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003773 return __str_find_first_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003774 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003775}
3776
3777template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003778template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003779_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003780<
3781 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3782 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003783>
Marshall Clowe46031a2018-07-02 18:41:15 +00003784basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t,
zoecarver1997e0a2021-02-05 11:54:47 -08003785 size_type __pos) const _NOEXCEPT
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003786{
Marshall Clowe46031a2018-07-02 18:41:15 +00003787 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003788 return __str_find_first_not_of<value_type, size_type, traits_type, npos>
3789 (data(), size(), __sv.data(), __pos, __sv.size());
3790}
3791
3792template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003793inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003794typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003795basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003796 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003797{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003798 _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003799 return __str_find_first_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003800 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003801}
3802
3803template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003804inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003805typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003806basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
3807 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003808{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003809 return __str_find_first_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003810 (data(), size(), __c, __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003811}
3812
3813// find_last_not_of
3814
3815template<class _CharT, class _Traits, class _Allocator>
3816typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003817basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003818 size_type __pos,
3819 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003820{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003821 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003822 return __str_find_last_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003823 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003824}
3825
3826template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003827inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003828typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003829basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str,
3830 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003831{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003832 return __str_find_last_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003833 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003834}
3835
3836template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003837template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003838_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003839<
3840 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3841 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003842>
Marshall Clowe46031a2018-07-02 18:41:15 +00003843basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t,
zoecarver1997e0a2021-02-05 11:54:47 -08003844 size_type __pos) const _NOEXCEPT
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003845{
Marshall Clowe46031a2018-07-02 18:41:15 +00003846 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003847 return __str_find_last_not_of<value_type, size_type, traits_type, npos>
3848 (data(), size(), __sv.data(), __pos, __sv.size());
3849}
3850
3851template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003852inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003853typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003854basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003855 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003856{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003857 _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003858 return __str_find_last_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003859 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003860}
3861
3862template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003863inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003864typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003865basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
3866 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003867{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003868 return __str_find_last_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003869 (data(), size(), __c, __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003870}
3871
3872// compare
3873
3874template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003875template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003876_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003877<
3878 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3879 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003880>
zoecarver1997e0a2021-02-05 11:54:47 -08003881basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003882{
Marshall Clowe46031a2018-07-02 18:41:15 +00003883 __self_view __sv = __t;
Howard Hinnantb0485532011-07-24 21:45:06 +00003884 size_t __lhs_sz = size();
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003885 size_t __rhs_sz = __sv.size();
3886 int __result = traits_type::compare(data(), __sv.data(),
Howard Hinnantb0485532011-07-24 21:45:06 +00003887 _VSTD::min(__lhs_sz, __rhs_sz));
3888 if (__result != 0)
3889 return __result;
3890 if (__lhs_sz < __rhs_sz)
3891 return -1;
3892 if (__lhs_sz > __rhs_sz)
3893 return 1;
3894 return 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003895}
3896
3897template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003898inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003899int
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003900basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003901{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003902 return compare(__self_view(__str));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003903}
3904
3905template <class _CharT, class _Traits, class _Allocator>
3906int
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003907basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3908 size_type __n1,
Howard Hinnantd17880b2013-06-28 16:59:19 +00003909 const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003910 size_type __n2) const
Howard Hinnantc51e1022010-05-11 19:42:16 +00003911{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003912 _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003913 size_type __sz = size();
3914 if (__pos1 > __sz || __n2 == npos)
3915 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003916 size_type __rlen = _VSTD::min(__n1, __sz - __pos1);
3917 int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003918 if (__r == 0)
3919 {
3920 if (__rlen < __n2)
3921 __r = -1;
3922 else if (__rlen > __n2)
3923 __r = 1;
3924 }
3925 return __r;
3926}
3927
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003928template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003929template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003930_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003931<
3932 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3933 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003934>
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003935basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3936 size_type __n1,
Marshall Clowe46031a2018-07-02 18:41:15 +00003937 const _Tp& __t) const
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003938{
Marshall Clowe46031a2018-07-02 18:41:15 +00003939 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003940 return compare(__pos1, __n1, __sv.data(), __sv.size());
3941}
3942
3943template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003944inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003945int
3946basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3947 size_type __n1,
3948 const basic_string& __str) const
3949{
3950 return compare(__pos1, __n1, __str.data(), __str.size());
3951}
3952
3953template <class _CharT, class _Traits, class _Allocator>
Marshall Clow82513342016-09-24 22:45:42 +00003954template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003955_EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00003956<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003957 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
3958 && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
Marshall Clowb7db4972017-11-15 20:02:27 +00003959 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003960>
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003961basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3962 size_type __n1,
Marshall Clow82513342016-09-24 22:45:42 +00003963 const _Tp& __t,
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003964 size_type __pos2,
3965 size_type __n2) const
3966{
Marshall Clow82513342016-09-24 22:45:42 +00003967 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003968 return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
3969}
3970
3971template <class _CharT, class _Traits, class _Allocator>
3972int
3973basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3974 size_type __n1,
3975 const basic_string& __str,
3976 size_type __pos2,
3977 size_type __n2) const
3978{
3979 return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);
3980}
3981
3982template <class _CharT, class _Traits, class _Allocator>
3983int
3984basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT
3985{
3986 _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
3987 return compare(0, npos, __s, traits_type::length(__s));
3988}
3989
3990template <class _CharT, class _Traits, class _Allocator>
3991int
3992basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3993 size_type __n1,
3994 const value_type* __s) const
3995{
3996 _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
3997 return compare(__pos1, __n1, __s, traits_type::length(__s));
3998}
3999
Howard Hinnantc51e1022010-05-11 19:42:16 +00004000// __invariants
4001
4002template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00004003inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00004004bool
4005basic_string<_CharT, _Traits, _Allocator>::__invariants() const
4006{
4007 if (size() > capacity())
4008 return false;
4009 if (capacity() < __min_cap - 1)
4010 return false;
Bruce Mitchener170d8972020-11-24 12:53:53 -05004011 if (data() == nullptr)
Howard Hinnantc51e1022010-05-11 19:42:16 +00004012 return false;
Louis Dionne663415f2020-10-05 16:16:13 -04004013 if (data()[size()] != value_type())
Howard Hinnantc51e1022010-05-11 19:42:16 +00004014 return false;
4015 return true;
4016}
4017
Vedant Kumar55e007e2018-03-08 21:15:26 +00004018// __clear_and_shrink
4019
4020template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00004021inline
Louis Dionne173f29e2019-05-29 16:01:36 +00004022void
Marshall Clowe60a7182018-05-29 17:04:37 +00004023basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
Vedant Kumar55e007e2018-03-08 21:15:26 +00004024{
4025 clear();
4026 if(__is_long())
4027 {
4028 __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
4029 __set_long_cap(0);
4030 __set_short_size(0);
Louis Dionne663415f2020-10-05 16:16:13 -04004031 traits_type::assign(*__get_short_pointer(), value_type());
Vedant Kumar55e007e2018-03-08 21:15:26 +00004032 }
Louis Dionne173f29e2019-05-29 16:01:36 +00004033}
Vedant Kumar55e007e2018-03-08 21:15:26 +00004034
Howard Hinnantc51e1022010-05-11 19:42:16 +00004035// operator==
4036
4037template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004038inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004039bool
4040operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004041 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004042{
Howard Hinnantaaeb1132013-04-22 23:55:13 +00004043 size_t __lhs_sz = __lhs.size();
4044 return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(),
4045 __rhs.data(),
4046 __lhs_sz) == 0;
4047}
4048
4049template<class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004050inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaaeb1132013-04-22 23:55:13 +00004051bool
4052operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
4053 const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
4054{
4055 size_t __lhs_sz = __lhs.size();
4056 if (__lhs_sz != __rhs.size())
4057 return false;
4058 const char* __lp = __lhs.data();
4059 const char* __rp = __rhs.data();
4060 if (__lhs.__is_long())
4061 return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0;
4062 for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp)
4063 if (*__lp != *__rp)
4064 return false;
4065 return true;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004066}
4067
4068template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004069inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004070bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004071operator==(const _CharT* __lhs,
4072 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004073{
Eric Fiselier0cafa3f2015-08-28 03:02:37 +00004074 typedef basic_string<_CharT, _Traits, _Allocator> _String;
4075 _LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr");
4076 size_t __lhs_len = _Traits::length(__lhs);
4077 if (__lhs_len != __rhs.size()) return false;
4078 return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004079}
4080
Howard Hinnantc51e1022010-05-11 19:42:16 +00004081template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004082inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004083bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004084operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
4085 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004086{
Eric Fiselier0cafa3f2015-08-28 03:02:37 +00004087 typedef basic_string<_CharT, _Traits, _Allocator> _String;
4088 _LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
4089 size_t __rhs_len = _Traits::length(__rhs);
4090 if (__rhs_len != __lhs.size()) return false;
4091 return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004092}
4093
Howard Hinnant3b6579a2010-08-22 00:02:43 +00004094template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004095inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004096bool
4097operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004098 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004099{
4100 return !(__lhs == __rhs);
4101}
4102
4103template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004104inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004105bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004106operator!=(const _CharT* __lhs,
4107 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004108{
4109 return !(__lhs == __rhs);
4110}
4111
4112template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004113inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004114bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004115operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
4116 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004117{
4118 return !(__lhs == __rhs);
4119}
4120
4121// operator<
4122
4123template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004124inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004125bool
4126operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004127 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004128{
Howard Hinnanta2660c12011-07-24 15:07:21 +00004129 return __lhs.compare(__rhs) < 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004130}
4131
4132template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004133inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004134bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004135operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
4136 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004137{
Howard Hinnanta2660c12011-07-24 15:07:21 +00004138 return __lhs.compare(__rhs) < 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004139}
4140
4141template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004142inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004143bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004144operator< (const _CharT* __lhs,
4145 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004146{
4147 return __rhs.compare(__lhs) > 0;
4148}
4149
Howard Hinnantc51e1022010-05-11 19:42:16 +00004150// operator>
4151
4152template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004153inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004154bool
4155operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004156 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004157{
4158 return __rhs < __lhs;
4159}
4160
4161template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004162inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004163bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004164operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
4165 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004166{
4167 return __rhs < __lhs;
4168}
4169
4170template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004171inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004172bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004173operator> (const _CharT* __lhs,
4174 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004175{
4176 return __rhs < __lhs;
4177}
4178
4179// operator<=
4180
4181template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004182inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004183bool
4184operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004185 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004186{
4187 return !(__rhs < __lhs);
4188}
4189
4190template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004191inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004192bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004193operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
4194 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004195{
4196 return !(__rhs < __lhs);
4197}
4198
4199template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004200inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004201bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004202operator<=(const _CharT* __lhs,
4203 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004204{
4205 return !(__rhs < __lhs);
4206}
4207
4208// operator>=
4209
4210template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004211inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004212bool
4213operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004214 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004215{
4216 return !(__lhs < __rhs);
4217}
4218
4219template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004220inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004221bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004222operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
4223 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004224{
4225 return !(__lhs < __rhs);
4226}
4227
4228template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004229inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004230bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004231operator>=(const _CharT* __lhs,
4232 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004233{
4234 return !(__lhs < __rhs);
4235}
4236
4237// operator +
4238
4239template<class _CharT, class _Traits, class _Allocator>
4240basic_string<_CharT, _Traits, _Allocator>
4241operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
4242 const basic_string<_CharT, _Traits, _Allocator>& __rhs)
4243{
4244 basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
4245 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
4246 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
4247 __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
4248 __r.append(__rhs.data(), __rhs_sz);
4249 return __r;
4250}
4251
4252template<class _CharT, class _Traits, class _Allocator>
4253basic_string<_CharT, _Traits, _Allocator>
4254operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs)
4255{
4256 basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
4257 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = _Traits::length(__lhs);
4258 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
4259 __r.__init(__lhs, __lhs_sz, __lhs_sz + __rhs_sz);
4260 __r.append(__rhs.data(), __rhs_sz);
4261 return __r;
4262}
4263
4264template<class _CharT, class _Traits, class _Allocator>
4265basic_string<_CharT, _Traits, _Allocator>
4266operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs)
4267{
4268 basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
4269 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
4270 __r.__init(&__lhs, 1, 1 + __rhs_sz);
4271 __r.append(__rhs.data(), __rhs_sz);
4272 return __r;
4273}
4274
4275template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00004276inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00004277basic_string<_CharT, _Traits, _Allocator>
4278operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs)
4279{
4280 basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
4281 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
4282 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = _Traits::length(__rhs);
4283 __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
4284 __r.append(__rhs, __rhs_sz);
4285 return __r;
4286}
4287
4288template<class _CharT, class _Traits, class _Allocator>
4289basic_string<_CharT, _Traits, _Allocator>
4290operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
4291{
4292 basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
4293 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
4294 __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + 1);
4295 __r.push_back(__rhs);
4296 return __r;
4297}
4298
Eric Fiselierfc92be82017-04-19 00:28:44 +00004299#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00004300
4301template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004302inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004303basic_string<_CharT, _Traits, _Allocator>
4304operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs)
4305{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004306 return _VSTD::move(__lhs.append(__rhs));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004307}
4308
4309template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004310inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004311basic_string<_CharT, _Traits, _Allocator>
4312operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
4313{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004314 return _VSTD::move(__rhs.insert(0, __lhs));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004315}
4316
4317template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004318inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004319basic_string<_CharT, _Traits, _Allocator>
4320operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
4321{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004322 return _VSTD::move(__lhs.append(__rhs));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004323}
4324
4325template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004326inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004327basic_string<_CharT, _Traits, _Allocator>
4328operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
4329{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004330 return _VSTD::move(__rhs.insert(0, __lhs));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004331}
4332
4333template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004334inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004335basic_string<_CharT, _Traits, _Allocator>
4336operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
4337{
4338 __rhs.insert(__rhs.begin(), __lhs);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004339 return _VSTD::move(__rhs);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004340}
4341
4342template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004343inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004344basic_string<_CharT, _Traits, _Allocator>
4345operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs)
4346{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004347 return _VSTD::move(__lhs.append(__rhs));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004348}
4349
4350template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004351inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004352basic_string<_CharT, _Traits, _Allocator>
4353operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
4354{
4355 __lhs.push_back(__rhs);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004356 return _VSTD::move(__lhs);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004357}
4358
Eric Fiselierfc92be82017-04-19 00:28:44 +00004359#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00004360
4361// swap
4362
4363template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004364inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004365void
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004366swap(basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnant3e276872011-06-03 18:40:47 +00004367 basic_string<_CharT, _Traits, _Allocator>& __rhs)
4368 _NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs)))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004369{
4370 __lhs.swap(__rhs);
4371}
4372
Bruce Mitchener170d8972020-11-24 12:53:53 -05004373_LIBCPP_FUNC_VIS int stoi (const string& __str, size_t* __idx = nullptr, int __base = 10);
4374_LIBCPP_FUNC_VIS long stol (const string& __str, size_t* __idx = nullptr, int __base = 10);
4375_LIBCPP_FUNC_VIS unsigned long stoul (const string& __str, size_t* __idx = nullptr, int __base = 10);
4376_LIBCPP_FUNC_VIS long long stoll (const string& __str, size_t* __idx = nullptr, int __base = 10);
4377_LIBCPP_FUNC_VIS unsigned long long stoull(const string& __str, size_t* __idx = nullptr, int __base = 10);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004378
Bruce Mitchener170d8972020-11-24 12:53:53 -05004379_LIBCPP_FUNC_VIS float stof (const string& __str, size_t* __idx = nullptr);
4380_LIBCPP_FUNC_VIS double stod (const string& __str, size_t* __idx = nullptr);
4381_LIBCPP_FUNC_VIS long double stold(const string& __str, size_t* __idx = nullptr);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004382
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004383_LIBCPP_FUNC_VIS string to_string(int __val);
4384_LIBCPP_FUNC_VIS string to_string(unsigned __val);
4385_LIBCPP_FUNC_VIS string to_string(long __val);
4386_LIBCPP_FUNC_VIS string to_string(unsigned long __val);
4387_LIBCPP_FUNC_VIS string to_string(long long __val);
4388_LIBCPP_FUNC_VIS string to_string(unsigned long long __val);
4389_LIBCPP_FUNC_VIS string to_string(float __val);
4390_LIBCPP_FUNC_VIS string to_string(double __val);
4391_LIBCPP_FUNC_VIS string to_string(long double __val);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004392
Bruce Mitchener170d8972020-11-24 12:53:53 -05004393_LIBCPP_FUNC_VIS int stoi (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
4394_LIBCPP_FUNC_VIS long stol (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
4395_LIBCPP_FUNC_VIS unsigned long stoul (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
4396_LIBCPP_FUNC_VIS long long stoll (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
4397_LIBCPP_FUNC_VIS unsigned long long stoull(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004398
Bruce Mitchener170d8972020-11-24 12:53:53 -05004399_LIBCPP_FUNC_VIS float stof (const wstring& __str, size_t* __idx = nullptr);
4400_LIBCPP_FUNC_VIS double stod (const wstring& __str, size_t* __idx = nullptr);
4401_LIBCPP_FUNC_VIS long double stold(const wstring& __str, size_t* __idx = nullptr);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004402
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004403_LIBCPP_FUNC_VIS wstring to_wstring(int __val);
4404_LIBCPP_FUNC_VIS wstring to_wstring(unsigned __val);
4405_LIBCPP_FUNC_VIS wstring to_wstring(long __val);
4406_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long __val);
4407_LIBCPP_FUNC_VIS wstring to_wstring(long long __val);
4408_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long long __val);
4409_LIBCPP_FUNC_VIS wstring to_wstring(float __val);
4410_LIBCPP_FUNC_VIS wstring to_wstring(double __val);
4411_LIBCPP_FUNC_VIS wstring to_wstring(long double __val);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004412
Howard Hinnantc51e1022010-05-11 19:42:16 +00004413template<class _CharT, class _Traits, class _Allocator>
Martin Storsjö88890c22021-02-22 01:13:13 +02004414_LIBCPP_TEMPLATE_DATA_VIS
Eric Fiselierc9fdaf12020-01-15 17:02:17 -05004415const typename basic_string<_CharT, _Traits, _Allocator>::size_type
4416 basic_string<_CharT, _Traits, _Allocator>::npos;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004417
Marshall Clow851b9ec2019-05-20 21:56:51 +00004418template <class _CharT, class _Allocator>
4419struct _LIBCPP_TEMPLATE_VIS
4420 hash<basic_string<_CharT, char_traits<_CharT>, _Allocator> >
4421 : public unary_function<
4422 basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t>
Howard Hinnantc51e1022010-05-11 19:42:16 +00004423{
4424 size_t
Marshall Clow851b9ec2019-05-20 21:56:51 +00004425 operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT
4426 { return __do_string_hash(__val.data(), __val.data() + __val.size()); }
Howard Hinnantc51e1022010-05-11 19:42:16 +00004427};
4428
Howard Hinnantc51e1022010-05-11 19:42:16 +00004429
Howard Hinnantdc095972011-07-18 15:51:59 +00004430template<class _CharT, class _Traits, class _Allocator>
4431basic_ostream<_CharT, _Traits>&
4432operator<<(basic_ostream<_CharT, _Traits>& __os,
4433 const basic_string<_CharT, _Traits, _Allocator>& __str);
4434
4435template<class _CharT, class _Traits, class _Allocator>
4436basic_istream<_CharT, _Traits>&
4437operator>>(basic_istream<_CharT, _Traits>& __is,
4438 basic_string<_CharT, _Traits, _Allocator>& __str);
4439
4440template<class _CharT, class _Traits, class _Allocator>
4441basic_istream<_CharT, _Traits>&
4442getline(basic_istream<_CharT, _Traits>& __is,
4443 basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
4444
4445template<class _CharT, class _Traits, class _Allocator>
4446inline _LIBCPP_INLINE_VISIBILITY
4447basic_istream<_CharT, _Traits>&
4448getline(basic_istream<_CharT, _Traits>& __is,
4449 basic_string<_CharT, _Traits, _Allocator>& __str);
4450
Eric Fiselierfc92be82017-04-19 00:28:44 +00004451#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantdc095972011-07-18 15:51:59 +00004452
4453template<class _CharT, class _Traits, class _Allocator>
4454inline _LIBCPP_INLINE_VISIBILITY
4455basic_istream<_CharT, _Traits>&
4456getline(basic_istream<_CharT, _Traits>&& __is,
4457 basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
4458
4459template<class _CharT, class _Traits, class _Allocator>
4460inline _LIBCPP_INLINE_VISIBILITY
4461basic_istream<_CharT, _Traits>&
4462getline(basic_istream<_CharT, _Traits>&& __is,
4463 basic_string<_CharT, _Traits, _Allocator>& __str);
4464
Eric Fiselierfc92be82017-04-19 00:28:44 +00004465#endif // _LIBCPP_CXX03_LANG
Howard Hinnantdc095972011-07-18 15:51:59 +00004466
Marshall Clow29b53f22018-12-14 18:49:35 +00004467#if _LIBCPP_STD_VER > 17
Marek Kurdeja98b1412020-05-02 13:58:03 +02004468template <class _CharT, class _Traits, class _Allocator, class _Up>
Marshall Clow29b53f22018-12-14 18:49:35 +00004469inline _LIBCPP_INLINE_VISIBILITY
Marek Kurdeja98b1412020-05-02 13:58:03 +02004470 typename basic_string<_CharT, _Traits, _Allocator>::size_type
4471 erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) {
4472 auto __old_size = __str.size();
4473 __str.erase(_VSTD::remove(__str.begin(), __str.end(), __v), __str.end());
4474 return __old_size - __str.size();
4475}
Marshall Clow29b53f22018-12-14 18:49:35 +00004476
Marek Kurdeja98b1412020-05-02 13:58:03 +02004477template <class _CharT, class _Traits, class _Allocator, class _Predicate>
Marshall Clow29b53f22018-12-14 18:49:35 +00004478inline _LIBCPP_INLINE_VISIBILITY
Marek Kurdeja98b1412020-05-02 13:58:03 +02004479 typename basic_string<_CharT, _Traits, _Allocator>::size_type
4480 erase_if(basic_string<_CharT, _Traits, _Allocator>& __str,
4481 _Predicate __pred) {
4482 auto __old_size = __str.size();
4483 __str.erase(_VSTD::remove_if(__str.begin(), __str.end(), __pred),
4484 __str.end());
4485 return __old_size - __str.size();
4486}
Marshall Clow29b53f22018-12-14 18:49:35 +00004487#endif
4488
Louis Dionneba400782020-10-02 15:02:52 -04004489#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00004490
4491template<class _CharT, class _Traits, class _Allocator>
4492bool
4493basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const
4494{
Eric Fiselierc1b87a72019-11-16 17:13:26 -05004495 return this->data() <= _VSTD::__to_address(__i->base()) &&
4496 _VSTD::__to_address(__i->base()) < this->data() + this->size();
Howard Hinnant8ea98242013-08-23 17:37:05 +00004497}
4498
4499template<class _CharT, class _Traits, class _Allocator>
4500bool
4501basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const
4502{
Eric Fiselierc1b87a72019-11-16 17:13:26 -05004503 return this->data() < _VSTD::__to_address(__i->base()) &&
4504 _VSTD::__to_address(__i->base()) <= this->data() + this->size();
Howard Hinnant8ea98242013-08-23 17:37:05 +00004505}
4506
4507template<class _CharT, class _Traits, class _Allocator>
4508bool
4509basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
4510{
Eric Fiselierc1b87a72019-11-16 17:13:26 -05004511 const value_type* __p = _VSTD::__to_address(__i->base()) + __n;
Howard Hinnant8ea98242013-08-23 17:37:05 +00004512 return this->data() <= __p && __p <= this->data() + this->size();
4513}
4514
4515template<class _CharT, class _Traits, class _Allocator>
4516bool
4517basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
4518{
Eric Fiselierc1b87a72019-11-16 17:13:26 -05004519 const value_type* __p = _VSTD::__to_address(__i->base()) + __n;
Howard Hinnant8ea98242013-08-23 17:37:05 +00004520 return this->data() <= __p && __p < this->data() + this->size();
4521}
4522
Louis Dionneba400782020-10-02 15:02:52 -04004523#endif // _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant8ea98242013-08-23 17:37:05 +00004524
Louis Dionne173f29e2019-05-29 16:01:36 +00004525#if _LIBCPP_STD_VER > 11
Marshall Clowcba751f2013-07-23 17:05:24 +00004526// Literal suffixes for basic_string [basic.string.literals]
Marshall Clowac868372013-10-05 21:18:32 +00004527inline namespace literals
Marshall Clowcba751f2013-07-23 17:05:24 +00004528{
4529 inline namespace string_literals
4530 {
Howard Hinnant5c167562013-08-07 19:39:48 +00004531 inline _LIBCPP_INLINE_VISIBILITY
4532 basic_string<char> operator "" s( const char *__str, size_t __len )
4533 {
4534 return basic_string<char> (__str, __len);
4535 }
Marshall Clowcba751f2013-07-23 17:05:24 +00004536
Howard Hinnant5c167562013-08-07 19:39:48 +00004537 inline _LIBCPP_INLINE_VISIBILITY
4538 basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len )
4539 {
4540 return basic_string<wchar_t> (__str, __len);
4541 }
Marshall Clowcba751f2013-07-23 17:05:24 +00004542
Marshall Clow8732fed2018-12-11 04:35:44 +00004543#ifndef _LIBCPP_NO_HAS_CHAR8_T
4544 inline _LIBCPP_INLINE_VISIBILITY
4545 basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len) _NOEXCEPT
4546 {
4547 return basic_string<char8_t> (__str, __len);
4548 }
4549#endif
4550
Howard Hinnant5c167562013-08-07 19:39:48 +00004551 inline _LIBCPP_INLINE_VISIBILITY
4552 basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len )
4553 {
4554 return basic_string<char16_t> (__str, __len);
4555 }
Marshall Clowcba751f2013-07-23 17:05:24 +00004556
Howard Hinnant5c167562013-08-07 19:39:48 +00004557 inline _LIBCPP_INLINE_VISIBILITY
4558 basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
4559 {
4560 return basic_string<char32_t> (__str, __len);
4561 }
Marshall Clowcba751f2013-07-23 17:05:24 +00004562 }
4563}
4564#endif
4565
Howard Hinnantc51e1022010-05-11 19:42:16 +00004566_LIBCPP_END_NAMESPACE_STD
4567
Eric Fiselierf4433a32017-05-31 22:07:49 +00004568_LIBCPP_POP_MACROS
4569
Howard Hinnantc51e1022010-05-11 19:42:16 +00004570#endif // _LIBCPP_STRING