blob: 2c90dae2f735e27ed2bf698e2b9534411c2fb6ad [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>;
72
Howard Hinnant3b6579a2010-08-22 00:02:43 +000073template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
Howard Hinnantc51e1022010-05-11 19:42:16 +000074class basic_string
75{
Howard Hinnant3b6579a2010-08-22 00:02:43 +000076public:
77// types:
Howard Hinnantc51e1022010-05-11 19:42:16 +000078 typedef traits traits_type;
79 typedef typename traits_type::char_type value_type;
80 typedef Allocator allocator_type;
81 typedef typename allocator_type::size_type size_type;
82 typedef typename allocator_type::difference_type difference_type;
83 typedef typename allocator_type::reference reference;
84 typedef typename allocator_type::const_reference const_reference;
85 typedef typename allocator_type::pointer pointer;
86 typedef typename allocator_type::const_pointer const_pointer;
87 typedef implementation-defined iterator;
88 typedef implementation-defined const_iterator;
89 typedef std::reverse_iterator<iterator> reverse_iterator;
90 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
91
92 static const size_type npos = -1;
93
Howard Hinnant3e276872011-06-03 18:40:47 +000094 basic_string()
95 noexcept(is_nothrow_default_constructible<allocator_type>::value);
96 explicit basic_string(const allocator_type& a);
Howard Hinnantc51e1022010-05-11 19:42:16 +000097 basic_string(const basic_string& str);
Howard Hinnant3e276872011-06-03 18:40:47 +000098 basic_string(basic_string&& str)
99 noexcept(is_nothrow_move_constructible<allocator_type>::value);
Marshall Clow83445802016-04-07 18:13:41 +0000100 basic_string(const basic_string& str, size_type pos,
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000101 const allocator_type& a = allocator_type());
Marshall Clow83445802016-04-07 18:13:41 +0000102 basic_string(const basic_string& str, size_type pos, size_type n,
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000103 const Allocator& a = Allocator());
Marshall Clow78dbe462016-11-14 18:22:19 +0000104 template<class T>
105 basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator()); // C++17
Marshall Clowe46031a2018-07-02 18:41:15 +0000106 template <class T>
107 explicit basic_string(const T& t, const Allocator& a = Allocator()); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000108 basic_string(const value_type* s, const allocator_type& a = allocator_type());
109 basic_string(const value_type* s, size_type n, const allocator_type& a = allocator_type());
Howard Hinnantc51e1022010-05-11 19:42:16 +0000110 basic_string(size_type n, value_type c, const allocator_type& a = allocator_type());
111 template<class InputIterator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000112 basic_string(InputIterator begin, InputIterator end,
113 const allocator_type& a = allocator_type());
Howard Hinnantc51e1022010-05-11 19:42:16 +0000114 basic_string(initializer_list<value_type>, const Allocator& = Allocator());
115 basic_string(const basic_string&, const Allocator&);
116 basic_string(basic_string&&, const Allocator&);
117
118 ~basic_string();
119
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000120 operator basic_string_view<charT, traits>() const noexcept;
121
Howard Hinnantc51e1022010-05-11 19:42:16 +0000122 basic_string& operator=(const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000123 template <class T>
124 basic_string& operator=(const T& t); // C++17
Howard Hinnant3e276872011-06-03 18:40:47 +0000125 basic_string& operator=(basic_string&& str)
126 noexcept(
Marshall Clow2fe8a8d2015-08-18 18:57:00 +0000127 allocator_type::propagate_on_container_move_assignment::value ||
128 allocator_type::is_always_equal::value ); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000129 basic_string& operator=(const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000130 basic_string& operator=(value_type c);
131 basic_string& operator=(initializer_list<value_type>);
132
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000133 iterator begin() noexcept;
134 const_iterator begin() const noexcept;
135 iterator end() noexcept;
136 const_iterator end() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000137
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000138 reverse_iterator rbegin() noexcept;
139 const_reverse_iterator rbegin() const noexcept;
140 reverse_iterator rend() noexcept;
141 const_reverse_iterator rend() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000142
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000143 const_iterator cbegin() const noexcept;
144 const_iterator cend() const noexcept;
145 const_reverse_iterator crbegin() const noexcept;
146 const_reverse_iterator crend() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000147
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000148 size_type size() const noexcept;
149 size_type length() const noexcept;
150 size_type max_size() const noexcept;
151 size_type capacity() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000152
153 void resize(size_type n, value_type c);
154 void resize(size_type n);
155
156 void reserve(size_type res_arg = 0);
157 void shrink_to_fit();
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000158 void clear() noexcept;
159 bool empty() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000160
161 const_reference operator[](size_type pos) const;
162 reference operator[](size_type pos);
163
164 const_reference at(size_type n) const;
165 reference at(size_type n);
166
167 basic_string& operator+=(const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000168 template <class T>
169 basic_string& operator+=(const T& t); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000170 basic_string& operator+=(const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000171 basic_string& operator+=(value_type c);
172 basic_string& operator+=(initializer_list<value_type>);
173
174 basic_string& append(const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000175 template <class T>
176 basic_string& append(const T& t); // C++17
Marshall Clow8db7fb02014-03-04 19:17:19 +0000177 basic_string& append(const basic_string& str, size_type pos, size_type n=npos); //C++14
Marshall Clow82513342016-09-24 22:45:42 +0000178 template <class T>
179 basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000180 basic_string& append(const value_type* s, size_type n);
181 basic_string& append(const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000182 basic_string& append(size_type n, value_type c);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000183 template<class InputIterator>
184 basic_string& append(InputIterator first, InputIterator last);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000185 basic_string& append(initializer_list<value_type>);
186
187 void push_back(value_type c);
188 void pop_back();
189 reference front();
190 const_reference front() const;
191 reference back();
192 const_reference back() const;
193
194 basic_string& assign(const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000195 template <class T>
196 basic_string& assign(const T& t); // C++17
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000197 basic_string& assign(basic_string&& str);
Marshall Clow8db7fb02014-03-04 19:17:19 +0000198 basic_string& assign(const basic_string& str, size_type pos, size_type n=npos); // C++14
Marshall Clow82513342016-09-24 22:45:42 +0000199 template <class T>
200 basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000201 basic_string& assign(const value_type* s, size_type n);
202 basic_string& assign(const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000203 basic_string& assign(size_type n, value_type c);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000204 template<class InputIterator>
205 basic_string& assign(InputIterator first, InputIterator last);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000206 basic_string& assign(initializer_list<value_type>);
207
208 basic_string& insert(size_type pos1, const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000209 template <class T>
210 basic_string& insert(size_type pos1, const T& t);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000211 basic_string& insert(size_type pos1, const basic_string& str,
212 size_type pos2, size_type n);
Marshall Clow82513342016-09-24 22:45:42 +0000213 template <class T>
214 basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n); // C++17
Marshall Clow8db7fb02014-03-04 19:17:19 +0000215 basic_string& insert(size_type pos, const value_type* s, size_type n=npos); //C++14
Howard Hinnantd17880b2013-06-28 16:59:19 +0000216 basic_string& insert(size_type pos, const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000217 basic_string& insert(size_type pos, size_type n, value_type c);
218 iterator insert(const_iterator p, value_type c);
219 iterator insert(const_iterator p, size_type n, value_type c);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000220 template<class InputIterator>
221 iterator insert(const_iterator p, InputIterator first, InputIterator last);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000222 iterator insert(const_iterator p, initializer_list<value_type>);
223
224 basic_string& erase(size_type pos = 0, size_type n = npos);
225 iterator erase(const_iterator position);
226 iterator erase(const_iterator first, const_iterator last);
227
228 basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000229 template <class T>
230 basic_string& replace(size_type pos1, size_type n1, const T& t); // C++17
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000231 basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
Marshall Clow8db7fb02014-03-04 19:17:19 +0000232 size_type pos2, size_type n2=npos); // C++14
Marshall Clow82513342016-09-24 22:45:42 +0000233 template <class T>
234 basic_string& replace(size_type pos1, size_type n1, const T& t,
235 size_type pos2, size_type n); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000236 basic_string& replace(size_type pos, size_type n1, const value_type* s, size_type n2);
237 basic_string& replace(size_type pos, size_type n1, const value_type* s);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000238 basic_string& replace(size_type pos, size_type n1, size_type n2, value_type c);
Howard Hinnant990d6e82010-11-17 21:11:40 +0000239 basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000240 template <class T>
241 basic_string& replace(const_iterator i1, const_iterator i2, const T& t); // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000242 basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s, size_type n);
243 basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s);
Howard Hinnant990d6e82010-11-17 21:11:40 +0000244 basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000245 template<class InputIterator>
Howard Hinnant990d6e82010-11-17 21:11:40 +0000246 basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2);
247 basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000248
Howard Hinnantd17880b2013-06-28 16:59:19 +0000249 size_type copy(value_type* s, size_type n, size_type pos = 0) const;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000250 basic_string substr(size_type pos = 0, size_type n = npos) const;
251
Howard Hinnant3e276872011-06-03 18:40:47 +0000252 void swap(basic_string& str)
Marshall Clow8982dcd2015-07-13 20:04:56 +0000253 noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
254 allocator_traits<allocator_type>::is_always_equal::value); // C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000255
Howard Hinnantd17880b2013-06-28 16:59:19 +0000256 const value_type* c_str() const noexcept;
257 const value_type* data() const noexcept;
Marshall Clowd3c22392016-03-08 15:44:30 +0000258 value_type* data() noexcept; // C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000259
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000260 allocator_type get_allocator() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000261
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000262 size_type find(const basic_string& str, size_type pos = 0) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000263 template <class T>
264 size_type find(const T& t, size_type pos = 0) const; // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000265 size_type find(const value_type* s, size_type pos, size_type n) const noexcept;
266 size_type find(const value_type* s, size_type pos = 0) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000267 size_type find(value_type c, size_type pos = 0) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000268
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000269 size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000270 template <class T>
271 size_type rfind(const T& t, size_type pos = npos) const; // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000272 size_type rfind(const value_type* s, size_type pos, size_type n) const noexcept;
273 size_type rfind(const value_type* s, size_type pos = npos) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000274 size_type rfind(value_type c, size_type pos = npos) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000275
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000276 size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000277 template <class T>
278 size_type find_first_of(const T& t, size_type pos = 0) const; // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000279 size_type find_first_of(const value_type* s, size_type pos, size_type n) const noexcept;
280 size_type find_first_of(const value_type* s, size_type pos = 0) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000281 size_type find_first_of(value_type c, size_type pos = 0) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000282
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000283 size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000284 template <class T>
285 size_type find_last_of(const T& t, size_type pos = npos) const noexcept; // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000286 size_type find_last_of(const value_type* s, size_type pos, size_type n) const noexcept;
287 size_type find_last_of(const value_type* s, size_type pos = npos) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000288 size_type find_last_of(value_type c, size_type pos = npos) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000289
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000290 size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000291 template <class T>
292 size_type find_first_not_of(const T& t, size_type pos = 0) const; // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000293 size_type find_first_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
294 size_type find_first_not_of(const value_type* s, size_type pos = 0) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000295 size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000296
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000297 size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000298 template <class T>
299 size_type find_last_not_of(const T& t, size_type pos = npos) const; // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000300 size_type find_last_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
301 size_type find_last_not_of(const value_type* s, size_type pos = npos) const noexcept;
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000302 size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000303
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000304 int compare(const basic_string& str) const noexcept;
Marshall Clowe46031a2018-07-02 18:41:15 +0000305 template <class T>
306 int compare(const T& t) const noexcept; // C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000307 int compare(size_type pos1, size_type n1, const basic_string& str) const;
Marshall Clowe46031a2018-07-02 18:41:15 +0000308 template <class T>
309 int compare(size_type pos1, size_type n1, const T& t) const; // C++17
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000310 int compare(size_type pos1, size_type n1, const basic_string& str,
Marshall Clow8db7fb02014-03-04 19:17:19 +0000311 size_type pos2, size_type n2=npos) const; // C++14
Marshall Clow82513342016-09-24 22:45:42 +0000312 template <class T>
313 int compare(size_type pos1, size_type n1, const T& t,
314 size_type pos2, size_type n2=npos) const; // C++17
Howard Hinnantd17880b2013-06-28 16:59:19 +0000315 int compare(const value_type* s) const noexcept;
316 int compare(size_type pos1, size_type n1, const value_type* s) const;
317 int compare(size_type pos1, size_type n1, const value_type* s, size_type n2) const;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000318
Marshall Clow18c293b2017-12-04 20:11:38 +0000319 bool starts_with(basic_string_view<charT, traits> sv) const noexcept; // C++2a
320 bool starts_with(charT c) const noexcept; // C++2a
321 bool starts_with(const charT* s) const; // C++2a
322 bool ends_with(basic_string_view<charT, traits> sv) const noexcept; // C++2a
323 bool ends_with(charT c) const noexcept; // C++2a
324 bool ends_with(const charT* s) const; // C++2a
325
Howard Hinnantc51e1022010-05-11 19:42:16 +0000326 bool __invariants() const;
327};
328
Marshall Clowa0563332018-02-08 06:34:03 +0000329template<class InputIterator,
330 class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
331basic_string(InputIterator, InputIterator, Allocator = Allocator())
332 -> basic_string<typename iterator_traits<InputIterator>::value_type,
333 char_traits<typename iterator_traits<InputIterator>::value_type>,
334 Allocator>; // C++17
335
Howard Hinnantc51e1022010-05-11 19:42:16 +0000336template<class charT, class traits, class Allocator>
337basic_string<charT, traits, Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000338operator+(const basic_string<charT, traits, Allocator>& lhs,
339 const basic_string<charT, traits, Allocator>& rhs);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000340
341template<class charT, class traits, class Allocator>
342basic_string<charT, traits, Allocator>
343operator+(const charT* lhs , const basic_string<charT,traits,Allocator>&rhs);
344
345template<class charT, class traits, class Allocator>
346basic_string<charT, traits, Allocator>
347operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs);
348
349template<class charT, class traits, class Allocator>
350basic_string<charT, traits, Allocator>
351operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
352
353template<class charT, class traits, class Allocator>
354basic_string<charT, traits, Allocator>
355operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);
356
357template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000358bool operator==(const basic_string<charT, traits, Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000359 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000360
361template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000362bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000363
364template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000365bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000366
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000367template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000368bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000369 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000370
371template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000372bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000373
374template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000375bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000376
377template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000378bool operator< (const basic_string<charT, traits, Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000379 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000380
381template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000382bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000383
384template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000385bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000386
387template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000388bool operator> (const basic_string<charT, traits, Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000389 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000390
391template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000392bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000393
394template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000395bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000396
397template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000398bool operator<=(const basic_string<charT, traits, Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000399 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000400
401template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000402bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000403
404template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000405bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000406
407template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000408bool operator>=(const basic_string<charT, traits, Allocator>& lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000409 const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000410
411template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000412bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000413
414template<class charT, class traits, class Allocator>
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000415bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000416
417template<class charT, class traits, class Allocator>
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000418void swap(basic_string<charT, traits, Allocator>& lhs,
Howard Hinnant3e276872011-06-03 18:40:47 +0000419 basic_string<charT, traits, Allocator>& rhs)
420 noexcept(noexcept(lhs.swap(rhs)));
Howard Hinnantc51e1022010-05-11 19:42:16 +0000421
422template<class charT, class traits, class Allocator>
423basic_istream<charT, traits>&
424operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
425
426template<class charT, class traits, class Allocator>
427basic_ostream<charT, traits>&
428operator<<(basic_ostream<charT, traits>& os, const basic_string<charT, traits, Allocator>& str);
429
430template<class charT, class traits, class Allocator>
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000431basic_istream<charT, traits>&
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000432getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str,
433 charT delim);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000434
435template<class charT, class traits, class Allocator>
436basic_istream<charT, traits>&
437getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
438
Marshall Clow29b53f22018-12-14 18:49:35 +0000439template<class charT, class traits, class Allocator, class U>
440void erase(basic_string<charT, traits, Allocator>& c, const U& value); // C++20
441template<class charT, class traits, class Allocator, class Predicate>
442void erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20
443
Howard Hinnantc51e1022010-05-11 19:42:16 +0000444typedef basic_string<char> string;
445typedef basic_string<wchar_t> wstring;
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +0000446typedef basic_string<char16_t> u16string;
447typedef basic_string<char32_t> u32string;
448
449int stoi (const string& str, size_t* idx = 0, int base = 10);
450long stol (const string& str, size_t* idx = 0, int base = 10);
451unsigned long stoul (const string& str, size_t* idx = 0, int base = 10);
452long long stoll (const string& str, size_t* idx = 0, int base = 10);
453unsigned long long stoull(const string& str, size_t* idx = 0, int base = 10);
454
455float stof (const string& str, size_t* idx = 0);
456double stod (const string& str, size_t* idx = 0);
457long double stold(const string& str, size_t* idx = 0);
458
459string to_string(int val);
460string to_string(unsigned val);
461string to_string(long val);
462string to_string(unsigned long val);
463string to_string(long long val);
464string to_string(unsigned long long val);
465string to_string(float val);
466string to_string(double val);
467string to_string(long double val);
468
469int stoi (const wstring& str, size_t* idx = 0, int base = 10);
470long stol (const wstring& str, size_t* idx = 0, int base = 10);
471unsigned long stoul (const wstring& str, size_t* idx = 0, int base = 10);
472long long stoll (const wstring& str, size_t* idx = 0, int base = 10);
473unsigned long long stoull(const wstring& str, size_t* idx = 0, int base = 10);
474
475float stof (const wstring& str, size_t* idx = 0);
476double stod (const wstring& str, size_t* idx = 0);
477long double stold(const wstring& str, size_t* idx = 0);
478
479wstring to_wstring(int val);
480wstring to_wstring(unsigned val);
481wstring to_wstring(long val);
482wstring to_wstring(unsigned long val);
483wstring to_wstring(long long val);
484wstring to_wstring(unsigned long long val);
485wstring to_wstring(float val);
486wstring to_wstring(double val);
487wstring to_wstring(long double val);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000488
489template <> struct hash<string>;
490template <> struct hash<u16string>;
491template <> struct hash<u32string>;
492template <> struct hash<wstring>;
493
Marshall Clowcba751f2013-07-23 17:05:24 +0000494basic_string<char> operator "" s( const char *str, size_t len ); // C++14
495basic_string<wchar_t> operator "" s( const wchar_t *str, size_t len ); // C++14
496basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14
497basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14
498
Howard Hinnantc51e1022010-05-11 19:42:16 +0000499} // std
500
501*/
502
503#include <__config>
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000504#include <string_view>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000505#include <iosfwd>
506#include <cstring>
Howard Hinnant155c2af2010-05-24 17:49:41 +0000507#include <cstdio> // For EOF.
Howard Hinnantc51e1022010-05-11 19:42:16 +0000508#include <cwchar>
509#include <algorithm>
510#include <iterator>
511#include <utility>
512#include <memory>
513#include <stdexcept>
514#include <type_traits>
515#include <initializer_list>
516#include <__functional_base>
Marshall Clow0a1e7502018-09-12 19:41:40 +0000517#include <version>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000518#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
519#include <cstdint>
520#endif
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000521
Eric Fiselier14b6de92014-08-10 23:53:08 +0000522#include <__debug>
523
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000524#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000525#pragma GCC system_header
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000526#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000527
Eric Fiselierf4433a32017-05-31 22:07:49 +0000528_LIBCPP_PUSH_MACROS
529#include <__undef_macros>
530
531
Howard Hinnantc51e1022010-05-11 19:42:16 +0000532_LIBCPP_BEGIN_NAMESPACE_STD
533
534// fpos
535
536template <class _StateT>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000537class _LIBCPP_TEMPLATE_VIS fpos
Howard Hinnantc51e1022010-05-11 19:42:16 +0000538{
539private:
540 _StateT __st_;
541 streamoff __off_;
542public:
543 _LIBCPP_INLINE_VISIBILITY fpos(streamoff __off = streamoff()) : __st_(), __off_(__off) {}
544
545 _LIBCPP_INLINE_VISIBILITY operator streamoff() const {return __off_;}
546
547 _LIBCPP_INLINE_VISIBILITY _StateT state() const {return __st_;}
548 _LIBCPP_INLINE_VISIBILITY void state(_StateT __st) {__st_ = __st;}
549
550 _LIBCPP_INLINE_VISIBILITY fpos& operator+=(streamoff __off) {__off_ += __off; return *this;}
551 _LIBCPP_INLINE_VISIBILITY fpos operator+ (streamoff __off) const {fpos __t(*this); __t += __off; return __t;}
552 _LIBCPP_INLINE_VISIBILITY fpos& operator-=(streamoff __off) {__off_ -= __off; return *this;}
553 _LIBCPP_INLINE_VISIBILITY fpos operator- (streamoff __off) const {fpos __t(*this); __t -= __off; return __t;}
554};
555
556template <class _StateT>
557inline _LIBCPP_INLINE_VISIBILITY
558streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
559 {return streamoff(__x) - streamoff(__y);}
560
561template <class _StateT>
562inline _LIBCPP_INLINE_VISIBILITY
563bool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
564 {return streamoff(__x) == streamoff(__y);}
565
566template <class _StateT>
567inline _LIBCPP_INLINE_VISIBILITY
568bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
569 {return streamoff(__x) != streamoff(__y);}
570
Howard Hinnantc51e1022010-05-11 19:42:16 +0000571// basic_string
572
573template<class _CharT, class _Traits, class _Allocator>
574basic_string<_CharT, _Traits, _Allocator>
Howard Hinnant944510a2011-06-14 19:58:17 +0000575operator+(const basic_string<_CharT, _Traits, _Allocator>& __x,
576 const basic_string<_CharT, _Traits, _Allocator>& __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000577
578template<class _CharT, class _Traits, class _Allocator>
579basic_string<_CharT, _Traits, _Allocator>
Howard Hinnant944510a2011-06-14 19:58:17 +0000580operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000581
582template<class _CharT, class _Traits, class _Allocator>
583basic_string<_CharT, _Traits, _Allocator>
Howard Hinnant944510a2011-06-14 19:58:17 +0000584operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000585
586template<class _CharT, class _Traits, class _Allocator>
Louis Dionne8f8d95d2018-11-21 17:31:55 +0000587inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +0000588basic_string<_CharT, _Traits, _Allocator>
Howard Hinnant944510a2011-06-14 19:58:17 +0000589operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000590
591template<class _CharT, class _Traits, class _Allocator>
592basic_string<_CharT, _Traits, _Allocator>
Howard Hinnant944510a2011-06-14 19:58:17 +0000593operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000594
Shoaib Meenaiea363712017-07-29 02:54:41 +0000595_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&))
596
Howard Hinnantc51e1022010-05-11 19:42:16 +0000597template <bool>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000598class _LIBCPP_TEMPLATE_VIS __basic_string_common
Howard Hinnantc51e1022010-05-11 19:42:16 +0000599{
600protected:
Marshall Clow8fea1612016-08-25 15:09:01 +0000601 _LIBCPP_NORETURN void __throw_length_error() const;
602 _LIBCPP_NORETURN void __throw_out_of_range() const;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000603};
604
605template <bool __b>
606void
607__basic_string_common<__b>::__throw_length_error() const
608{
Marshall Clow8fea1612016-08-25 15:09:01 +0000609 _VSTD::__throw_length_error("basic_string");
Howard Hinnantc51e1022010-05-11 19:42:16 +0000610}
611
612template <bool __b>
613void
614__basic_string_common<__b>::__throw_out_of_range() const
615{
Marshall Clow8fea1612016-08-25 15:09:01 +0000616 _VSTD::__throw_out_of_range("basic_string");
Howard Hinnantc51e1022010-05-11 19:42:16 +0000617}
618
Eric Fiselier1b57fa82016-09-15 22:27:07 +0000619_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __basic_string_common<true>)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000620
Marshall Clow039b2f02016-01-13 21:54:34 +0000621#ifdef _LIBCPP_NO_EXCEPTIONS
622template <class _Iter>
623struct __libcpp_string_gets_noexcept_iterator_impl : public true_type {};
624#elif defined(_LIBCPP_HAS_NO_NOEXCEPT)
625template <class _Iter>
626struct __libcpp_string_gets_noexcept_iterator_impl : public false_type {};
627#else
Eric Fiseliercd5a6772019-11-18 01:46:58 -0500628template <class _Iter, bool = __is_cpp17_forward_iterator<_Iter>::value>
Marshall Clow039b2f02016-01-13 21:54:34 +0000629struct __libcpp_string_gets_noexcept_iterator_impl : public _LIBCPP_BOOL_CONSTANT((
Louis Dionne173f29e2019-05-29 16:01:36 +0000630 noexcept(++(declval<_Iter&>())) &&
631 is_nothrow_assignable<_Iter&, _Iter>::value &&
632 noexcept(declval<_Iter>() == declval<_Iter>()) &&
Marshall Clow039b2f02016-01-13 21:54:34 +0000633 noexcept(*declval<_Iter>())
634)) {};
635
Louis Dionne173f29e2019-05-29 16:01:36 +0000636template <class _Iter>
Marshall Clow039b2f02016-01-13 21:54:34 +0000637struct __libcpp_string_gets_noexcept_iterator_impl<_Iter, false> : public false_type {};
638#endif
639
640
641template <class _Iter>
642struct __libcpp_string_gets_noexcept_iterator
643 : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value || __libcpp_string_gets_noexcept_iterator_impl<_Iter>::value) {};
644
Marshall Clow82513342016-09-24 22:45:42 +0000645template <class _CharT, class _Traits, class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500646struct __can_be_converted_to_string_view : public _BoolConstant<
647 is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
648 !is_convertible<const _Tp&, const _CharT*>::value
649 > {};
Marshall Clow82513342016-09-24 22:45:42 +0000650
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +0000651#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +0000652
653template <class _CharT, size_t = sizeof(_CharT)>
654struct __padding
655{
656 unsigned char __xx[sizeof(_CharT)-1];
657};
658
659template <class _CharT>
660struct __padding<_CharT, 1>
661{
662};
663
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +0000664#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +0000665
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000666template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000667class _LIBCPP_TEMPLATE_VIS basic_string
Howard Hinnantc51e1022010-05-11 19:42:16 +0000668 : private __basic_string_common<true>
669{
670public:
671 typedef basic_string __self;
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000672 typedef basic_string_view<_CharT, _Traits> __self_view;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000673 typedef _Traits traits_type;
Marshall Clowa3a74e02017-03-15 18:41:11 +0000674 typedef _CharT value_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000675 typedef _Allocator allocator_type;
Howard Hinnantea8f7e12010-11-17 17:55:08 +0000676 typedef allocator_traits<allocator_type> __alloc_traits;
677 typedef typename __alloc_traits::size_type size_type;
678 typedef typename __alloc_traits::difference_type difference_type;
Howard Hinnant3e276872011-06-03 18:40:47 +0000679 typedef value_type& reference;
680 typedef const value_type& const_reference;
Howard Hinnantea8f7e12010-11-17 17:55:08 +0000681 typedef typename __alloc_traits::pointer pointer;
682 typedef typename __alloc_traits::const_pointer const_pointer;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000683
Marshall Clow79f33542018-03-21 00:36:05 +0000684 static_assert((!is_array<value_type>::value), "Character type of basic_string must not be an array");
685 static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string must be standard-layout");
686 static_assert(( is_trivial<value_type>::value), "Character type of basic_string must be trivial");
687 static_assert(( is_same<_CharT, typename traits_type::char_type>::value),
Howard Hinnant8ea98242013-08-23 17:37:05 +0000688 "traits_type::char_type must be the same type as CharT");
Marshall Clow79f33542018-03-21 00:36:05 +0000689 static_assert(( is_same<typename allocator_type::value_type, value_type>::value),
Howard Hinnant8ea98242013-08-23 17:37:05 +0000690 "Allocator::value_type must be same type as value_type");
Marshall Clowe46031a2018-07-02 18:41:15 +0000691
Howard Hinnant8ea98242013-08-23 17:37:05 +0000692#if defined(_LIBCPP_RAW_ITERATORS)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000693 typedef pointer iterator;
694 typedef const_pointer const_iterator;
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000695#else // defined(_LIBCPP_RAW_ITERATORS)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000696 typedef __wrap_iter<pointer> iterator;
697 typedef __wrap_iter<const_pointer> const_iterator;
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000698#endif // defined(_LIBCPP_RAW_ITERATORS)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000699 typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
700 typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000701
702private:
Howard Hinnant68bf1812013-04-30 21:44:48 +0000703
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +0000704#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +0000705
706 struct __long
707 {
708 pointer __data_;
709 size_type __size_;
710 size_type __cap_;
711 };
712
Eric Fiseliere9cc5922017-10-17 13:16:01 +0000713#ifdef _LIBCPP_BIG_ENDIAN
Ben Craig4b6f5f12017-07-12 01:45:13 +0000714 static const size_type __short_mask = 0x01;
715 static const size_type __long_mask = 0x1ul;
Howard Hinnant68bf1812013-04-30 21:44:48 +0000716#else // _LIBCPP_BIG_ENDIAN
Ben Craig4b6f5f12017-07-12 01:45:13 +0000717 static const size_type __short_mask = 0x80;
718 static const size_type __long_mask = ~(size_type(~0) >> 1);
Howard Hinnant68bf1812013-04-30 21:44:48 +0000719#endif // _LIBCPP_BIG_ENDIAN
720
721 enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
722 (sizeof(__long) - 1)/sizeof(value_type) : 2};
723
724 struct __short
725 {
726 value_type __data_[__min_cap];
727 struct
728 : __padding<value_type>
729 {
730 unsigned char __size_;
731 };
732 };
733
734#else
735
Howard Hinnantc51e1022010-05-11 19:42:16 +0000736 struct __long
737 {
738 size_type __cap_;
739 size_type __size_;
740 pointer __data_;
741 };
742
Eric Fiseliere9cc5922017-10-17 13:16:01 +0000743#ifdef _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 Hinnant3b6579a2010-08-22 00:02:43 +0000746#else // _LIBCPP_BIG_ENDIAN
Ben Craig4b6f5f12017-07-12 01:45:13 +0000747 static const size_type __short_mask = 0x01;
748 static const size_type __long_mask = 0x1ul;
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000749#endif // _LIBCPP_BIG_ENDIAN
Howard Hinnantc51e1022010-05-11 19:42:16 +0000750
Howard Hinnantc51e1022010-05-11 19:42:16 +0000751 enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
752 (sizeof(__long) - 1)/sizeof(value_type) : 2};
753
754 struct __short
755 {
756 union
757 {
758 unsigned char __size_;
Howard Hinnant49e145e2012-10-30 19:06:59 +0000759 value_type __lx;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000760 };
761 value_type __data_[__min_cap];
762 };
763
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +0000764#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +0000765
Howard Hinnant8ea98242013-08-23 17:37:05 +0000766 union __ulx{__long __lx; __short __lxx;};
Howard Hinnantc51e1022010-05-11 19:42:16 +0000767
Howard Hinnant8ea98242013-08-23 17:37:05 +0000768 enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
Howard Hinnantc51e1022010-05-11 19:42:16 +0000769
770 struct __raw
771 {
772 size_type __words[__n_words];
773 };
774
775 struct __rep
776 {
777 union
778 {
779 __long __l;
780 __short __s;
781 __raw __r;
782 };
783 };
784
785 __compressed_pair<__rep, allocator_type> __r_;
786
Howard Hinnantc51e1022010-05-11 19:42:16 +0000787public:
Eric Fiselier2ae9e062020-01-16 15:00:34 -0500788 _LIBCPP_FUNC_VIS
Howard Hinnantc51e1022010-05-11 19:42:16 +0000789 static const size_type npos = -1;
790
Howard Hinnant3e276872011-06-03 18:40:47 +0000791 _LIBCPP_INLINE_VISIBILITY basic_string()
792 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
Marshall Clowa80abc72015-06-03 19:56:43 +0000793
794 _LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a)
795#if _LIBCPP_STD_VER <= 14
796 _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
797#else
798 _NOEXCEPT;
799#endif
800
Howard Hinnantc51e1022010-05-11 19:42:16 +0000801 basic_string(const basic_string& __str);
802 basic_string(const basic_string& __str, const allocator_type& __a);
Marshall Clowa80abc72015-06-03 19:56:43 +0000803
Eric Fiselierfc92be82017-04-19 00:28:44 +0000804#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantebb0edf2011-01-26 00:06:59 +0000805 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e276872011-06-03 18:40:47 +0000806 basic_string(basic_string&& __str)
Marshall Clowa80abc72015-06-03 19:56:43 +0000807#if _LIBCPP_STD_VER <= 14
Howard Hinnant3e276872011-06-03 18:40:47 +0000808 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
Marshall Clowa80abc72015-06-03 19:56:43 +0000809#else
810 _NOEXCEPT;
811#endif
812
Howard Hinnantebb0edf2011-01-26 00:06:59 +0000813 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +0000814 basic_string(basic_string&& __str, const allocator_type& __a);
Eric Fiselierfc92be82017-04-19 00:28:44 +0000815#endif // _LIBCPP_CXX03_LANG
Marshall Clowe46031a2018-07-02 18:41:15 +0000816
Eric Fiselierfe7fe0a2020-01-15 17:29:55 -0500817 template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> >
Eric Fiseliera8567862018-07-17 05:48:48 +0000818 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier5169d1c2019-12-16 19:03:23 -0500819 basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) {
Eric Fiseliera8567862018-07-17 05:48:48 +0000820 _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
821 __init(__s, traits_type::length(__s));
822# if _LIBCPP_DEBUG_LEVEL >= 2
823 __get_db()->__insert_c(this);
824# endif
825 }
Marshall Clowe46031a2018-07-02 18:41:15 +0000826
Eric Fiselierfe7fe0a2020-01-15 17:29:55 -0500827 template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> >
Marshall Clowe46031a2018-07-02 18:41:15 +0000828 _LIBCPP_INLINE_VISIBILITY
829 basic_string(const _CharT* __s, const _Allocator& __a);
830
Howard Hinnantcf823322010-12-17 14:46:43 +0000831 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier812882b2017-02-17 01:17:10 +0000832 basic_string(const _CharT* __s, size_type __n);
Howard Hinnantcf823322010-12-17 14:46:43 +0000833 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier812882b2017-02-17 01:17:10 +0000834 basic_string(const _CharT* __s, size_type __n, const _Allocator& __a);
Howard Hinnantcf823322010-12-17 14:46:43 +0000835 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier812882b2017-02-17 01:17:10 +0000836 basic_string(size_type __n, _CharT __c);
Marshall Clowe46031a2018-07-02 18:41:15 +0000837
Eric Fiselierfe7fe0a2020-01-15 17:29:55 -0500838 template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> >
Marshall Clowe46031a2018-07-02 18:41:15 +0000839 _LIBCPP_INLINE_VISIBILITY
840 basic_string(size_type __n, _CharT __c, const _Allocator& __a);
841
Marshall Clow83445802016-04-07 18:13:41 +0000842 basic_string(const basic_string& __str, size_type __pos, size_type __n,
Eric Fiselier812882b2017-02-17 01:17:10 +0000843 const _Allocator& __a = _Allocator());
Marshall Clow83445802016-04-07 18:13:41 +0000844 _LIBCPP_INLINE_VISIBILITY
845 basic_string(const basic_string& __str, size_type __pos,
Eric Fiselier812882b2017-02-17 01:17:10 +0000846 const _Allocator& __a = _Allocator());
Marshall Clowe46031a2018-07-02 18:41:15 +0000847
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500848 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 +0000849 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselier812882b2017-02-17 01:17:10 +0000850 basic_string(const _Tp& __t, size_type __pos, size_type __n,
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500851 const allocator_type& __a = allocator_type());
Marshall Clowe46031a2018-07-02 18:41:15 +0000852
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500853 template<class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
854 !__is_same_uncvref<_Tp, basic_string>::value> >
Marshall Clowe46031a2018-07-02 18:41:15 +0000855 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
856 explicit basic_string(const _Tp& __t);
857
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500858 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 +0000859 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
860 explicit basic_string(const _Tp& __t, const allocator_type& __a);
861
Eric Fiselierfe7fe0a2020-01-15 17:29:55 -0500862 template<class _InputIterator, class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value> >
Howard Hinnantcf823322010-12-17 14:46:43 +0000863 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +0000864 basic_string(_InputIterator __first, _InputIterator __last);
Eric Fiselierfe7fe0a2020-01-15 17:29:55 -0500865 template<class _InputIterator, class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value> >
Howard Hinnantcf823322010-12-17 14:46:43 +0000866 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +0000867 basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
Eric Fiselierfc92be82017-04-19 00:28:44 +0000868#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantcf823322010-12-17 14:46:43 +0000869 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier812882b2017-02-17 01:17:10 +0000870 basic_string(initializer_list<_CharT> __il);
Howard Hinnantcf823322010-12-17 14:46:43 +0000871 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier812882b2017-02-17 01:17:10 +0000872 basic_string(initializer_list<_CharT> __il, const _Allocator& __a);
Eric Fiselierfc92be82017-04-19 00:28:44 +0000873#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +0000874
Eric Fiselierd9a702a2016-10-31 03:42:50 +0000875 inline ~basic_string();
Howard Hinnantc51e1022010-05-11 19:42:16 +0000876
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000877 _LIBCPP_INLINE_VISIBILITY
878 operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); }
879
Howard Hinnantea8f7e12010-11-17 17:55:08 +0000880 basic_string& operator=(const basic_string& __str);
Eric Fiselier5ec13b12017-01-23 21:24:58 +0000881
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500882 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 +0000883 basic_string& operator=(const _Tp& __t)
884 {__self_view __sv = __t; return assign(__sv);}
885
Eric Fiselierfc92be82017-04-19 00:28:44 +0000886#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantcf823322010-12-17 14:46:43 +0000887 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e276872011-06-03 18:40:47 +0000888 basic_string& operator=(basic_string&& __str)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +0000889 _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
Eric Fiselierfc92be82017-04-19 00:28:44 +0000890 _LIBCPP_INLINE_VISIBILITY
891 basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000892#endif
Howard Hinnantd17880b2013-06-28 16:59:19 +0000893 _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000894 basic_string& operator=(value_type __c);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000895
Howard Hinnant8ea98242013-08-23 17:37:05 +0000896#if _LIBCPP_DEBUG_LEVEL >= 2
897 _LIBCPP_INLINE_VISIBILITY
898 iterator begin() _NOEXCEPT
899 {return iterator(this, __get_pointer());}
900 _LIBCPP_INLINE_VISIBILITY
901 const_iterator begin() const _NOEXCEPT
902 {return const_iterator(this, __get_pointer());}
903 _LIBCPP_INLINE_VISIBILITY
904 iterator end() _NOEXCEPT
905 {return iterator(this, __get_pointer() + size());}
906 _LIBCPP_INLINE_VISIBILITY
907 const_iterator end() const _NOEXCEPT
908 {return const_iterator(this, __get_pointer() + size());}
909#else
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000910 _LIBCPP_INLINE_VISIBILITY
911 iterator begin() _NOEXCEPT
912 {return iterator(__get_pointer());}
913 _LIBCPP_INLINE_VISIBILITY
914 const_iterator begin() const _NOEXCEPT
Howard Hinnantd17880b2013-06-28 16:59:19 +0000915 {return const_iterator(__get_pointer());}
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000916 _LIBCPP_INLINE_VISIBILITY
917 iterator end() _NOEXCEPT
918 {return iterator(__get_pointer() + size());}
919 _LIBCPP_INLINE_VISIBILITY
920 const_iterator end() const _NOEXCEPT
Howard Hinnantd17880b2013-06-28 16:59:19 +0000921 {return const_iterator(__get_pointer() + size());}
Howard Hinnant8ea98242013-08-23 17:37:05 +0000922#endif // _LIBCPP_DEBUG_LEVEL >= 2
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000923 _LIBCPP_INLINE_VISIBILITY
924 reverse_iterator rbegin() _NOEXCEPT
925 {return reverse_iterator(end());}
926 _LIBCPP_INLINE_VISIBILITY
927 const_reverse_iterator rbegin() const _NOEXCEPT
928 {return const_reverse_iterator(end());}
929 _LIBCPP_INLINE_VISIBILITY
930 reverse_iterator rend() _NOEXCEPT
931 {return reverse_iterator(begin());}
932 _LIBCPP_INLINE_VISIBILITY
933 const_reverse_iterator rend() const _NOEXCEPT
934 {return const_reverse_iterator(begin());}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000935
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000936 _LIBCPP_INLINE_VISIBILITY
937 const_iterator cbegin() const _NOEXCEPT
938 {return begin();}
939 _LIBCPP_INLINE_VISIBILITY
940 const_iterator cend() const _NOEXCEPT
941 {return end();}
942 _LIBCPP_INLINE_VISIBILITY
943 const_reverse_iterator crbegin() const _NOEXCEPT
944 {return rbegin();}
945 _LIBCPP_INLINE_VISIBILITY
946 const_reverse_iterator crend() const _NOEXCEPT
947 {return rend();}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000948
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000949 _LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +0000950 {return __is_long() ? __get_long_size() : __get_short_size();}
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000951 _LIBCPP_INLINE_VISIBILITY size_type length() const _NOEXCEPT {return size();}
952 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT;
953 _LIBCPP_INLINE_VISIBILITY size_type capacity() const _NOEXCEPT
Eric Fiselier8599fcc2015-08-28 07:02:42 +0000954 {return (__is_long() ? __get_long_cap()
955 : static_cast<size_type>(__min_cap)) - 1;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000956
957 void resize(size_type __n, value_type __c);
958 _LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());}
959
Marshall Clow6ae12a82018-11-28 18:18:34 +0000960 void reserve(size_type __res_arg);
Eric Fiselier451d5582018-11-26 20:15:38 +0000961 _LIBCPP_INLINE_VISIBILITY void __resize_default_init(size_type __n);
962
Marshall Clow6ae12a82018-11-28 18:18:34 +0000963 _LIBCPP_INLINE_VISIBILITY
964 void reserve() _NOEXCEPT {reserve(0);}
Howard Hinnant186dca82010-09-23 17:31:07 +0000965 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e276872011-06-03 18:40:47 +0000966 void shrink_to_fit() _NOEXCEPT {reserve();}
Howard Hinnantcf823322010-12-17 14:46:43 +0000967 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +0000968 void clear() _NOEXCEPT;
Marshall Clowb7db4972017-11-15 20:02:27 +0000969 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
970 bool empty() const _NOEXCEPT {return size() == 0;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000971
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000972 _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __pos) const _NOEXCEPT;
973 _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __pos) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000974
975 const_reference at(size_type __n) const;
976 reference at(size_type __n);
977
978 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const basic_string& __str) {return append(__str);}
Marshall Clowe46031a2018-07-02 18:41:15 +0000979
980 template <class _Tp>
981 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500982 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +0000983 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500984 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
985 && !__is_same_uncvref<_Tp, basic_string >::value,
Marshall Clowe46031a2018-07-02 18:41:15 +0000986 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -0500987 >
Marshall Clowe46031a2018-07-02 18:41:15 +0000988 operator+=(const _Tp& __t) {__self_view __sv = __t; return append(__sv);}
Marshall Clowdf63a6d2016-07-21 05:31:24 +0000989 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const value_type* __s) {return append(__s);}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000990 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c) {push_back(__c); return *this;}
Eric Fiselierfc92be82017-04-19 00:28:44 +0000991#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +0000992 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);}
Eric Fiselierfc92be82017-04-19 00:28:44 +0000993#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +0000994
Howard Hinnantcf823322010-12-17 14:46:43 +0000995 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +0000996 basic_string& append(const basic_string& __str);
Marshall Clowe46031a2018-07-02 18:41:15 +0000997
998 template <class _Tp>
999 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001000 _EnableIf<
1001 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
1002 && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clowe46031a2018-07-02 18:41:15 +00001003 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001004 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001005 append(const _Tp& __t) { __self_view __sv = __t; return append(__sv.data(), __sv.size()); }
Marshall Clow8db7fb02014-03-04 19:17:19 +00001006 basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos);
Marshall Clowe46031a2018-07-02 18:41:15 +00001007
Marshall Clow62953962016-10-03 23:40:48 +00001008 template <class _Tp>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001009 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001010 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00001011 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001012 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
1013 && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clow82513342016-09-24 22:45:42 +00001014 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001015 >
Marshall Clow82513342016-09-24 22:45:42 +00001016 append(const _Tp& __t, size_type __pos, size_type __n=npos);
Howard Hinnantd17880b2013-06-28 16:59:19 +00001017 basic_string& append(const value_type* __s, size_type __n);
1018 basic_string& append(const value_type* __s);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001019 basic_string& append(size_type __n, value_type __c);
Eric Fiselier451d5582018-11-26 20:15:38 +00001020
1021 _LIBCPP_INLINE_VISIBILITY
1022 void __append_default_init(size_type __n);
1023
Eric Fiselierdb7ee8f2016-10-31 02:46:25 +00001024 template <class _ForwardIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001025 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1026 basic_string& __append_forward_unsafe(_ForwardIterator, _ForwardIterator);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001027 template<class _InputIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001028 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001029 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001030 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001031 __is_exactly_cpp17_input_iterator<_InputIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001032 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001033 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001034 >
Eric Fiselierdb7ee8f2016-10-31 02:46:25 +00001035 _LIBCPP_INLINE_VISIBILITY
1036 append(_InputIterator __first, _InputIterator __last) {
1037 const basic_string __temp (__first, __last, __alloc());
1038 append(__temp.data(), __temp.size());
1039 return *this;
1040 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001041 template<class _ForwardIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001042 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001043 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001044 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001045 __is_cpp17_forward_iterator<_ForwardIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001046 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001047 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001048 >
Eric Fiselierdb7ee8f2016-10-31 02:46:25 +00001049 _LIBCPP_INLINE_VISIBILITY
1050 append(_ForwardIterator __first, _ForwardIterator __last) {
1051 return __append_forward_unsafe(__first, __last);
1052 }
1053
Eric Fiselierfc92be82017-04-19 00:28:44 +00001054#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant186dca82010-09-23 17:31:07 +00001055 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001056 basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
Eric Fiselierfc92be82017-04-19 00:28:44 +00001057#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001058
1059 void push_back(value_type __c);
Howard Hinnantcf823322010-12-17 14:46:43 +00001060 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001061 void pop_back();
Marshall Clow05cf6692019-03-19 03:30:07 +00001062 _LIBCPP_INLINE_VISIBILITY reference front() _NOEXCEPT;
1063 _LIBCPP_INLINE_VISIBILITY const_reference front() const _NOEXCEPT;
1064 _LIBCPP_INLINE_VISIBILITY reference back() _NOEXCEPT;
1065 _LIBCPP_INLINE_VISIBILITY const_reference back() const _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001066
Marshall Clowe46031a2018-07-02 18:41:15 +00001067 template <class _Tp>
1068 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001069 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001070 <
1071 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1072 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001073 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001074 assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); }
Marshall Clowdf63a6d2016-07-21 05:31:24 +00001075 _LIBCPP_INLINE_VISIBILITY
Marshall Clow95d5e9a2016-03-09 18:08:29 +00001076 basic_string& assign(const basic_string& __str) { return *this = __str; }
Eric Fiselierfc92be82017-04-19 00:28:44 +00001077#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001078 _LIBCPP_INLINE_VISIBILITY
Eric Fiselierc5ea1ae2017-06-01 02:29:37 +00001079 basic_string& assign(basic_string&& __str)
Marshall Clow5aa9e942015-10-05 16:17:34 +00001080 _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
Eric Fiselierc5ea1ae2017-06-01 02:29:37 +00001081 {*this = _VSTD::move(__str); return *this;}
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001082#endif
Marshall Clow8db7fb02014-03-04 19:17:19 +00001083 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos);
Marshall Clow62953962016-10-03 23:40:48 +00001084 template <class _Tp>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001085 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001086 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00001087 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001088 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
1089 && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clow82513342016-09-24 22:45:42 +00001090 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001091 >
Eric Fiselierc5ea1ae2017-06-01 02:29:37 +00001092 assign(const _Tp & __t, size_type __pos, size_type __n=npos);
Howard Hinnantd17880b2013-06-28 16:59:19 +00001093 basic_string& assign(const value_type* __s, size_type __n);
1094 basic_string& assign(const value_type* __s);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001095 basic_string& assign(size_type __n, value_type __c);
1096 template<class _InputIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001097 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001098 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001099 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001100 __is_exactly_cpp17_input_iterator<_InputIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001101 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001102 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001103 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001104 assign(_InputIterator __first, _InputIterator __last);
1105 template<class _ForwardIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001106 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001107 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001108 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001109 __is_cpp17_forward_iterator<_ForwardIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001110 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001111 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001112 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001113 assign(_ForwardIterator __first, _ForwardIterator __last);
Eric Fiselierfc92be82017-04-19 00:28:44 +00001114#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant186dca82010-09-23 17:31:07 +00001115 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001116 basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
Eric Fiselierfc92be82017-04-19 00:28:44 +00001117#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001118
Howard Hinnantcf823322010-12-17 14:46:43 +00001119 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001120 basic_string& insert(size_type __pos1, const basic_string& __str);
Marshall Clowe46031a2018-07-02 18:41:15 +00001121
1122 template <class _Tp>
1123 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001124 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001125 <
1126 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1127 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001128 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001129 insert(size_type __pos1, const _Tp& __t)
1130 { __self_view __sv = __t; return insert(__pos1, __sv.data(), __sv.size()); }
1131
Marshall Clow82513342016-09-24 22:45:42 +00001132 template <class _Tp>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001133 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001134 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00001135 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001136 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clow82513342016-09-24 22:45:42 +00001137 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001138 >
Marshall Clow82513342016-09-24 22:45:42 +00001139 insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos);
Marshall Clow8db7fb02014-03-04 19:17:19 +00001140 basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos);
Howard Hinnantd17880b2013-06-28 16:59:19 +00001141 basic_string& insert(size_type __pos, const value_type* __s, size_type __n);
1142 basic_string& insert(size_type __pos, const value_type* __s);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001143 basic_string& insert(size_type __pos, size_type __n, value_type __c);
1144 iterator insert(const_iterator __pos, value_type __c);
Howard Hinnantcf823322010-12-17 14:46:43 +00001145 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001146 iterator insert(const_iterator __pos, size_type __n, value_type __c);
1147 template<class _InputIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001148 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001149 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001150 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001151 __is_exactly_cpp17_input_iterator<_InputIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001152 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001153 iterator
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001154 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001155 insert(const_iterator __pos, _InputIterator __first, _InputIterator __last);
1156 template<class _ForwardIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001157 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001158 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001159 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001160 __is_cpp17_forward_iterator<_ForwardIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00001161 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001162 iterator
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001163 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001164 insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last);
Eric Fiselierfc92be82017-04-19 00:28:44 +00001165#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant186dca82010-09-23 17:31:07 +00001166 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001167 iterator insert(const_iterator __pos, initializer_list<value_type> __il)
1168 {return insert(__pos, __il.begin(), __il.end());}
Eric Fiselierfc92be82017-04-19 00:28:44 +00001169#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001170
1171 basic_string& erase(size_type __pos = 0, size_type __n = npos);
Howard Hinnantcf823322010-12-17 14:46:43 +00001172 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001173 iterator erase(const_iterator __pos);
Howard Hinnantcf823322010-12-17 14:46:43 +00001174 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001175 iterator erase(const_iterator __first, const_iterator __last);
1176
Howard Hinnantcf823322010-12-17 14:46:43 +00001177 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001178 basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str);
Marshall Clowe46031a2018-07-02 18:41:15 +00001179
1180 template <class _Tp>
1181 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001182 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001183 <
1184 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1185 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001186 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001187 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 +00001188 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 +00001189 template <class _Tp>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001190 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001191 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00001192 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001193 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clow82513342016-09-24 22:45:42 +00001194 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001195 >
Marshall Clow82513342016-09-24 22:45:42 +00001196 replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos);
Howard Hinnantd17880b2013-06-28 16:59:19 +00001197 basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2);
1198 basic_string& replace(size_type __pos, size_type __n1, const value_type* __s);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001199 basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);
Howard Hinnantcf823322010-12-17 14:46:43 +00001200 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant990d6e82010-11-17 21:11:40 +00001201 basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str);
Marshall Clowe46031a2018-07-02 18:41:15 +00001202
1203 template <class _Tp>
1204 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001205 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001206 <
1207 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1208 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001209 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001210 replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); }
1211
Marshall Clowdf63a6d2016-07-21 05:31:24 +00001212 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001213 basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n);
Howard Hinnantcf823322010-12-17 14:46:43 +00001214 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001215 basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s);
Howard Hinnantcf823322010-12-17 14:46:43 +00001216 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant990d6e82010-11-17 21:11:40 +00001217 basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001218 template<class _InputIterator>
Shoaib Meenai69c57412017-03-02 03:02:50 +00001219 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001220 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001221 <
Eric Fiseliercd5a6772019-11-18 01:46:58 -05001222 __is_cpp17_input_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00001223 basic_string&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001224 >
Howard Hinnant990d6e82010-11-17 21:11:40 +00001225 replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
Eric Fiselierfc92be82017-04-19 00:28:44 +00001226#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant186dca82010-09-23 17:31:07 +00001227 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant990d6e82010-11-17 21:11:40 +00001228 basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001229 {return replace(__i1, __i2, __il.begin(), __il.end());}
Eric Fiselierfc92be82017-04-19 00:28:44 +00001230#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001231
Howard Hinnantd17880b2013-06-28 16:59:19 +00001232 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
Howard Hinnantcf823322010-12-17 14:46:43 +00001233 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001234 basic_string substr(size_type __pos = 0, size_type __n = npos) const;
1235
Howard Hinnantcf823322010-12-17 14:46:43 +00001236 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e276872011-06-03 18:40:47 +00001237 void swap(basic_string& __str)
Marshall Clow8982dcd2015-07-13 20:04:56 +00001238#if _LIBCPP_STD_VER >= 14
Eric Fiselier873b8d32019-03-18 21:50:12 +00001239 _NOEXCEPT;
Marshall Clow8982dcd2015-07-13 20:04:56 +00001240#else
Eric Fiselier873b8d32019-03-18 21:50:12 +00001241 _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
Marshall Clow8982dcd2015-07-13 20:04:56 +00001242 __is_nothrow_swappable<allocator_type>::value);
1243#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001244
Howard Hinnantcf823322010-12-17 14:46:43 +00001245 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001246 const value_type* c_str() const _NOEXCEPT {return data();}
Howard Hinnantcf823322010-12-17 14:46:43 +00001247 _LIBCPP_INLINE_VISIBILITY
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001248 const value_type* data() const _NOEXCEPT {return _VSTD::__to_address(__get_pointer());}
Eric Fiselier4ee2a892017-11-20 20:23:27 +00001249#if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY)
Marshall Clowd3c22392016-03-08 15:44:30 +00001250 _LIBCPP_INLINE_VISIBILITY
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001251 value_type* data() _NOEXCEPT {return _VSTD::__to_address(__get_pointer());}
Marshall Clowd3c22392016-03-08 15:44:30 +00001252#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001253
Howard Hinnantcf823322010-12-17 14:46:43 +00001254 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001255 allocator_type get_allocator() const _NOEXCEPT {return __alloc();}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001256
Howard Hinnantcf823322010-12-17 14:46:43 +00001257 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001258 size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001259
1260 template <class _Tp>
1261 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001262 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001263 <
1264 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1265 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001266 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001267 find(const _Tp& __t, size_type __pos = 0) const;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001268 size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001269 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001270 size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001271 size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001272
Howard Hinnantcf823322010-12-17 14:46:43 +00001273 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001274 size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001275
1276 template <class _Tp>
1277 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001278 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001279 <
1280 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1281 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001282 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001283 rfind(const _Tp& __t, size_type __pos = npos) const;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001284 size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001285 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001286 size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001287 size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001288
Howard Hinnantcf823322010-12-17 14:46:43 +00001289 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001290 size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001291
1292 template <class _Tp>
1293 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001294 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001295 <
1296 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1297 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001298 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001299 find_first_of(const _Tp& __t, size_type __pos = 0) const;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001300 size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001301 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001302 size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001303 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001304 size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001305
Howard Hinnantcf823322010-12-17 14:46:43 +00001306 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001307 size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001308
1309 template <class _Tp>
1310 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001311 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001312 <
1313 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1314 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001315 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001316 find_last_of(const _Tp& __t, size_type __pos = npos) const;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001317 size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001318 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001319 size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantcf823322010-12-17 14:46:43 +00001320 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001321 size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001322
Howard Hinnantcf823322010-12-17 14:46:43 +00001323 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001324 size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001325
1326 template <class _Tp>
1327 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001328 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001329 <
1330 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1331 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001332 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001333 find_first_not_of(const _Tp &__t, size_type __pos = 0) const;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001334 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 +00001335 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001336 size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001337 _LIBCPP_INLINE_VISIBILITY
1338 size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
1339
1340 _LIBCPP_INLINE_VISIBILITY
1341 size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001342
1343 template <class _Tp>
1344 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001345 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001346 <
1347 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1348 size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001349 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001350 find_last_not_of(const _Tp& __t, size_type __pos = npos) const;
Howard Hinnantd17880b2013-06-28 16:59:19 +00001351 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 +00001352 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantd17880b2013-06-28 16:59:19 +00001353 size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001354 _LIBCPP_INLINE_VISIBILITY
1355 size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
1356
1357 _LIBCPP_INLINE_VISIBILITY
1358 int compare(const basic_string& __str) const _NOEXCEPT;
Marshall Clowe46031a2018-07-02 18:41:15 +00001359
1360 template <class _Tp>
1361 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001362 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001363 <
1364 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1365 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001366 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001367 compare(const _Tp &__t) const;
1368
1369 template <class _Tp>
1370 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001371 _EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00001372 <
1373 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
1374 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001375 >
Marshall Clowe46031a2018-07-02 18:41:15 +00001376 compare(size_type __pos1, size_type __n1, const _Tp& __t) const;
1377
Marshall Clowdf63a6d2016-07-21 05:31:24 +00001378 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001379 int compare(size_type __pos1, size_type __n1, const basic_string& __str) const;
Marshall Clow8db7fb02014-03-04 19:17:19 +00001380 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 +00001381
Marshall Clow82513342016-09-24 22:45:42 +00001382 template <class _Tp>
Eric Fiselier7d4aa5c2016-10-14 05:29:46 +00001383 inline _LIBCPP_INLINE_VISIBILITY
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001384 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00001385 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001386 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value,
Marshall Clow82513342016-09-24 22:45:42 +00001387 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001388 >
Marshall Clow82513342016-09-24 22:45:42 +00001389 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 +00001390 int compare(const value_type* __s) const _NOEXCEPT;
1391 int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
1392 int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001393
Marshall Clow18c293b2017-12-04 20:11:38 +00001394#if _LIBCPP_STD_VER > 17
1395 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1396 bool starts_with(__self_view __sv) const _NOEXCEPT
1397 { return __self_view(data(), size()).starts_with(__sv); }
1398
1399 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1400 bool starts_with(value_type __c) const _NOEXCEPT
1401 { return !empty() && _Traits::eq(front(), __c); }
1402
1403 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1404 bool starts_with(const value_type* __s) const _NOEXCEPT
1405 { return starts_with(__self_view(__s)); }
1406
1407 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1408 bool ends_with(__self_view __sv) const _NOEXCEPT
1409 { return __self_view(data(), size()).ends_with( __sv); }
1410
1411 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1412 bool ends_with(value_type __c) const _NOEXCEPT
1413 { return !empty() && _Traits::eq(back(), __c); }
1414
1415 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1416 bool ends_with(const value_type* __s) const _NOEXCEPT
1417 { return ends_with(__self_view(__s)); }
1418#endif
1419
Howard Hinnantcf823322010-12-17 14:46:43 +00001420 _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
Howard Hinnantaaeb1132013-04-22 23:55:13 +00001421
Marshall Clowe60a7182018-05-29 17:04:37 +00001422 _LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT;
Marshall Clow851b9ec2019-05-20 21:56:51 +00001423
Howard Hinnantaaeb1132013-04-22 23:55:13 +00001424 _LIBCPP_INLINE_VISIBILITY
1425 bool __is_long() const _NOEXCEPT
1426 {return bool(__r_.first().__s.__size_ & __short_mask);}
1427
Howard Hinnant8ea98242013-08-23 17:37:05 +00001428#if _LIBCPP_DEBUG_LEVEL >= 2
1429
1430 bool __dereferenceable(const const_iterator* __i) const;
1431 bool __decrementable(const const_iterator* __i) const;
1432 bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
1433 bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
1434
1435#endif // _LIBCPP_DEBUG_LEVEL >= 2
1436
Howard Hinnantc51e1022010-05-11 19:42:16 +00001437private:
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001438 _LIBCPP_INLINE_VISIBILITY
1439 allocator_type& __alloc() _NOEXCEPT
1440 {return __r_.second();}
1441 _LIBCPP_INLINE_VISIBILITY
1442 const allocator_type& __alloc() const _NOEXCEPT
1443 {return __r_.second();}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001444
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +00001445#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +00001446
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001447 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001448 void __set_short_size(size_type __s) _NOEXCEPT
Eric Fiseliere9cc5922017-10-17 13:16:01 +00001449# ifdef _LIBCPP_BIG_ENDIAN
Howard Hinnantc51e1022010-05-11 19:42:16 +00001450 {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
Howard Hinnant68bf1812013-04-30 21:44:48 +00001451# else
1452 {__r_.first().__s.__size_ = (unsigned char)(__s);}
1453# endif
1454
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001455 _LIBCPP_INLINE_VISIBILITY
1456 size_type __get_short_size() const _NOEXCEPT
Eric Fiseliere9cc5922017-10-17 13:16:01 +00001457# ifdef _LIBCPP_BIG_ENDIAN
Howard Hinnantc51e1022010-05-11 19:42:16 +00001458 {return __r_.first().__s.__size_ >> 1;}
Howard Hinnant68bf1812013-04-30 21:44:48 +00001459# else
1460 {return __r_.first().__s.__size_;}
1461# endif
1462
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +00001463#else // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +00001464
1465 _LIBCPP_INLINE_VISIBILITY
1466 void __set_short_size(size_type __s) _NOEXCEPT
Eric Fiseliere9cc5922017-10-17 13:16:01 +00001467# ifdef _LIBCPP_BIG_ENDIAN
Howard Hinnant68bf1812013-04-30 21:44:48 +00001468 {__r_.first().__s.__size_ = (unsigned char)(__s);}
1469# else
1470 {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
1471# endif
1472
1473 _LIBCPP_INLINE_VISIBILITY
1474 size_type __get_short_size() const _NOEXCEPT
Eric Fiseliere9cc5922017-10-17 13:16:01 +00001475# ifdef _LIBCPP_BIG_ENDIAN
Howard Hinnant68bf1812013-04-30 21:44:48 +00001476 {return __r_.first().__s.__size_;}
1477# else
1478 {return __r_.first().__s.__size_ >> 1;}
1479# endif
1480
Evgeniy Stepanovda2ff7e2015-10-13 23:48:28 +00001481#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
Howard Hinnant68bf1812013-04-30 21:44:48 +00001482
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001483 _LIBCPP_INLINE_VISIBILITY
1484 void __set_long_size(size_type __s) _NOEXCEPT
1485 {__r_.first().__l.__size_ = __s;}
1486 _LIBCPP_INLINE_VISIBILITY
1487 size_type __get_long_size() const _NOEXCEPT
1488 {return __r_.first().__l.__size_;}
1489 _LIBCPP_INLINE_VISIBILITY
1490 void __set_size(size_type __s) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001491 {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}
1492
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001493 _LIBCPP_INLINE_VISIBILITY
1494 void __set_long_cap(size_type __s) _NOEXCEPT
1495 {__r_.first().__l.__cap_ = __long_mask | __s;}
1496 _LIBCPP_INLINE_VISIBILITY
1497 size_type __get_long_cap() const _NOEXCEPT
Howard Hinnant28b24882011-12-01 20:21:04 +00001498 {return __r_.first().__l.__cap_ & size_type(~__long_mask);}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001499
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001500 _LIBCPP_INLINE_VISIBILITY
1501 void __set_long_pointer(pointer __p) _NOEXCEPT
1502 {__r_.first().__l.__data_ = __p;}
1503 _LIBCPP_INLINE_VISIBILITY
1504 pointer __get_long_pointer() _NOEXCEPT
1505 {return __r_.first().__l.__data_;}
1506 _LIBCPP_INLINE_VISIBILITY
1507 const_pointer __get_long_pointer() const _NOEXCEPT
1508 {return __r_.first().__l.__data_;}
1509 _LIBCPP_INLINE_VISIBILITY
1510 pointer __get_short_pointer() _NOEXCEPT
Howard Hinnantd17880b2013-06-28 16:59:19 +00001511 {return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);}
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001512 _LIBCPP_INLINE_VISIBILITY
1513 const_pointer __get_short_pointer() const _NOEXCEPT
Howard Hinnantd17880b2013-06-28 16:59:19 +00001514 {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001515 _LIBCPP_INLINE_VISIBILITY
1516 pointer __get_pointer() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001517 {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001518 _LIBCPP_INLINE_VISIBILITY
1519 const_pointer __get_pointer() const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001520 {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
1521
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001522 _LIBCPP_INLINE_VISIBILITY
1523 void __zero() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001524 {
1525 size_type (&__a)[__n_words] = __r_.first().__r.__words;
1526 for (unsigned __i = 0; __i < __n_words; ++__i)
1527 __a[__i] = 0;
1528 }
1529
1530 template <size_type __a> static
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001531 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantea382952013-08-14 18:00:20 +00001532 size_type __align_it(size_type __s) _NOEXCEPT
Eric Fiselier8599fcc2015-08-28 07:02:42 +00001533 {return (__s + (__a-1)) & ~(__a-1);}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001534 enum {__alignment = 16};
Howard Hinnantaeb17d82011-05-29 19:57:12 +00001535 static _LIBCPP_INLINE_VISIBILITY
1536 size_type __recommend(size_type __s) _NOEXCEPT
Marshall Clow80584522018-02-07 21:30:17 +00001537 {
1538 if (__s < __min_cap) return static_cast<size_type>(__min_cap) - 1;
1539 size_type __guess = __align_it<sizeof(value_type) < __alignment ?
1540 __alignment/sizeof(value_type) : 1 > (__s+1) - 1;
1541 if (__guess == __min_cap) ++__guess;
1542 return __guess;
1543 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001544
Duncan P. N. Exon Smitheb584632017-04-01 03:20:48 +00001545 inline
Howard Hinnantd17880b2013-06-28 16:59:19 +00001546 void __init(const value_type* __s, size_type __sz, size_type __reserve);
Duncan P. N. Exon Smitheb584632017-04-01 03:20:48 +00001547 inline
Howard Hinnantd17880b2013-06-28 16:59:19 +00001548 void __init(const value_type* __s, size_type __sz);
Duncan P. N. Exon Smitheb584632017-04-01 03:20:48 +00001549 inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00001550 void __init(size_type __n, value_type __c);
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001551
Howard Hinnantc51e1022010-05-11 19:42:16 +00001552 template <class _InputIterator>
Duncan P. N. Exon Smitheb584632017-04-01 03:20:48 +00001553 inline
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001554 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001555 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001556 __is_exactly_cpp17_input_iterator<_InputIterator>::value
1557 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001558 __init(_InputIterator __first, _InputIterator __last);
1559
1560 template <class _ForwardIterator>
Duncan P. N. Exon Smitheb584632017-04-01 03:20:48 +00001561 inline
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001562 _EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00001563 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001564 __is_cpp17_forward_iterator<_ForwardIterator>::value
1565 >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001566 __init(_ForwardIterator __first, _ForwardIterator __last);
1567
1568 void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001569 size_type __n_copy, size_type __n_del, size_type __n_add = 0);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001570 void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
1571 size_type __n_copy, size_type __n_del,
Howard Hinnantd17880b2013-06-28 16:59:19 +00001572 size_type __n_add, const value_type* __p_new_stuff);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001573
Howard Hinnantcf823322010-12-17 14:46:43 +00001574 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001575 void __erase_to_end(size_type __pos);
1576
Martijn Velsa81fc792020-02-26 13:25:43 -05001577 // __erase_external_with_move is invoked for erase() invocations where
1578 // `n ~= npos`, likely requiring memory moves on the string data.
1579 void __erase_external_with_move(size_type __pos, size_type __n);
1580
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001581 _LIBCPP_INLINE_VISIBILITY
1582 void __copy_assign_alloc(const basic_string& __str)
1583 {__copy_assign_alloc(__str, integral_constant<bool,
1584 __alloc_traits::propagate_on_container_copy_assignment::value>());}
1585
1586 _LIBCPP_INLINE_VISIBILITY
1587 void __copy_assign_alloc(const basic_string& __str, true_type)
1588 {
Marshall Clowf258c202017-01-31 03:40:52 +00001589 if (__alloc() == __str.__alloc())
1590 __alloc() = __str.__alloc();
1591 else
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001592 {
Marshall Clowf258c202017-01-31 03:40:52 +00001593 if (!__str.__is_long())
1594 {
Vedant Kumar55e007e2018-03-08 21:15:26 +00001595 __clear_and_shrink();
Marshall Clowf258c202017-01-31 03:40:52 +00001596 __alloc() = __str.__alloc();
1597 }
1598 else
1599 {
1600 allocator_type __a = __str.__alloc();
1601 pointer __p = __alloc_traits::allocate(__a, __str.__get_long_cap());
Vedant Kumar55e007e2018-03-08 21:15:26 +00001602 __clear_and_shrink();
Marshall Clowf258c202017-01-31 03:40:52 +00001603 __alloc() = _VSTD::move(__a);
1604 __set_long_pointer(__p);
1605 __set_long_cap(__str.__get_long_cap());
1606 __set_long_size(__str.size());
1607 }
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001608 }
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001609 }
1610
1611 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant28b24882011-12-01 20:21:04 +00001612 void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001613 {}
1614
Eric Fiselierfc92be82017-04-19 00:28:44 +00001615#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantcf823322010-12-17 14:46:43 +00001616 _LIBCPP_INLINE_VISIBILITY
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00001617 void __move_assign(basic_string& __str, false_type)
1618 _NOEXCEPT_(__alloc_traits::is_always_equal::value);
Howard Hinnantcf823322010-12-17 14:46:43 +00001619 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e276872011-06-03 18:40:47 +00001620 void __move_assign(basic_string& __str, true_type)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00001621#if _LIBCPP_STD_VER > 14
1622 _NOEXCEPT;
1623#else
Howard Hinnant3e276872011-06-03 18:40:47 +00001624 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001625#endif
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00001626#endif
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001627
1628 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant58fe91b2011-08-17 20:36:18 +00001629 void
Howard Hinnantc2734962011-09-02 20:42:31 +00001630 __move_assign_alloc(basic_string& __str)
Howard Hinnant58fe91b2011-08-17 20:36:18 +00001631 _NOEXCEPT_(
1632 !__alloc_traits::propagate_on_container_move_assignment::value ||
1633 is_nothrow_move_assignable<allocator_type>::value)
1634 {__move_assign_alloc(__str, integral_constant<bool,
1635 __alloc_traits::propagate_on_container_move_assignment::value>());}
1636
1637 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc2734962011-09-02 20:42:31 +00001638 void __move_assign_alloc(basic_string& __c, true_type)
Howard Hinnant58fe91b2011-08-17 20:36:18 +00001639 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
1640 {
1641 __alloc() = _VSTD::move(__c.__alloc());
1642 }
1643
1644 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant28b24882011-12-01 20:21:04 +00001645 void __move_assign_alloc(basic_string&, false_type)
Howard Hinnant58fe91b2011-08-17 20:36:18 +00001646 _NOEXCEPT
1647 {}
1648
Howard Hinnantcf823322010-12-17 14:46:43 +00001649 _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
1650 _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001651
1652 friend basic_string operator+<>(const basic_string&, const basic_string&);
1653 friend basic_string operator+<>(const value_type*, const basic_string&);
1654 friend basic_string operator+<>(value_type, const basic_string&);
1655 friend basic_string operator+<>(const basic_string&, const value_type*);
1656 friend basic_string operator+<>(const basic_string&, value_type);
1657};
1658
Marshall Clowa0563332018-02-08 06:34:03 +00001659#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
1660template<class _InputIterator,
1661 class _CharT = typename iterator_traits<_InputIterator>::value_type,
1662 class _Allocator = allocator<_CharT>,
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001663 class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value>,
1664 class = _EnableIf<__is_allocator<_Allocator>::value>
Marshall Clowa0563332018-02-08 06:34:03 +00001665 >
1666basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
1667 -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
Marshall Clowe46031a2018-07-02 18:41:15 +00001668
1669template<class _CharT,
1670 class _Traits,
1671 class _Allocator = allocator<_CharT>,
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001672 class = _EnableIf<__is_allocator<_Allocator>::value>
Marshall Clowe46031a2018-07-02 18:41:15 +00001673 >
1674explicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
1675 -> basic_string<_CharT, _Traits, _Allocator>;
1676
1677template<class _CharT,
1678 class _Traits,
1679 class _Allocator = allocator<_CharT>,
Eric Fiselierc522ceb2020-01-15 16:57:08 -05001680 class = _EnableIf<__is_allocator<_Allocator>::value>,
Marshall Clowe46031a2018-07-02 18:41:15 +00001681 class _Sz = typename allocator_traits<_Allocator>::size_type
1682 >
1683basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())
1684 -> basic_string<_CharT, _Traits, _Allocator>;
Marshall Clowa0563332018-02-08 06:34:03 +00001685#endif
1686
Howard Hinnantc51e1022010-05-11 19:42:16 +00001687template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001688inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00001689void
1690basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators()
1691{
Howard Hinnant8ea98242013-08-23 17:37:05 +00001692#if _LIBCPP_DEBUG_LEVEL >= 2
1693 __get_db()->__invalidate_all(this);
1694#endif // _LIBCPP_DEBUG_LEVEL >= 2
Howard Hinnantc51e1022010-05-11 19:42:16 +00001695}
1696
1697template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001698inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00001699void
Howard Hinnant28b24882011-12-01 20:21:04 +00001700basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type
Howard Hinnant8ea98242013-08-23 17:37:05 +00001701#if _LIBCPP_DEBUG_LEVEL >= 2
Howard Hinnant28b24882011-12-01 20:21:04 +00001702 __pos
1703#endif
1704 )
Howard Hinnantc51e1022010-05-11 19:42:16 +00001705{
Howard Hinnant8ea98242013-08-23 17:37:05 +00001706#if _LIBCPP_DEBUG_LEVEL >= 2
1707 __c_node* __c = __get_db()->__find_c_and_lock(this);
1708 if (__c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001709 {
Howard Hinnant8ea98242013-08-23 17:37:05 +00001710 const_pointer __new_last = __get_pointer() + __pos;
1711 for (__i_node** __p = __c->end_; __p != __c->beg_; )
Howard Hinnantc51e1022010-05-11 19:42:16 +00001712 {
Howard Hinnant8ea98242013-08-23 17:37:05 +00001713 --__p;
1714 const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
1715 if (__i->base() > __new_last)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001716 {
Howard Hinnant8ea98242013-08-23 17:37:05 +00001717 (*__p)->__c_ = nullptr;
1718 if (--__c->end_ != __p)
1719 memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001720 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001721 }
Howard Hinnant8ea98242013-08-23 17:37:05 +00001722 __get_db()->unlock();
Howard Hinnantc51e1022010-05-11 19:42:16 +00001723 }
Howard Hinnant8ea98242013-08-23 17:37:05 +00001724#endif // _LIBCPP_DEBUG_LEVEL >= 2
Howard Hinnantc51e1022010-05-11 19:42:16 +00001725}
1726
1727template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001728inline
Howard Hinnant3e276872011-06-03 18:40:47 +00001729basic_string<_CharT, _Traits, _Allocator>::basic_string()
Marshall Clowe546cbb2015-06-04 02:05:41 +00001730 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001731 : __r_(__default_init_tag(), __default_init_tag())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001732{
Howard Hinnant8ea98242013-08-23 17:37:05 +00001733#if _LIBCPP_DEBUG_LEVEL >= 2
1734 __get_db()->__insert_c(this);
1735#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001736 __zero();
1737}
1738
1739template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001740inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00001741basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a)
Eric Fiseliere012bf22015-07-18 20:40:46 +00001742#if _LIBCPP_STD_VER <= 14
1743 _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
1744#else
1745 _NOEXCEPT
1746#endif
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001747: __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001748{
Howard Hinnant8ea98242013-08-23 17:37:05 +00001749#if _LIBCPP_DEBUG_LEVEL >= 2
1750 __get_db()->__insert_c(this);
1751#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001752 __zero();
1753}
1754
1755template <class _CharT, class _Traits, class _Allocator>
Eric Fiselier815ed732016-09-16 00:00:48 +00001756void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
1757 size_type __sz,
1758 size_type __reserve)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001759{
1760 if (__reserve > max_size())
1761 this->__throw_length_error();
1762 pointer __p;
1763 if (__reserve < __min_cap)
1764 {
1765 __set_short_size(__sz);
1766 __p = __get_short_pointer();
1767 }
1768 else
1769 {
1770 size_type __cap = __recommend(__reserve);
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001771 __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001772 __set_long_pointer(__p);
1773 __set_long_cap(__cap+1);
1774 __set_long_size(__sz);
1775 }
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001776 traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001777 traits_type::assign(__p[__sz], value_type());
1778}
1779
1780template <class _CharT, class _Traits, class _Allocator>
1781void
Howard Hinnantd17880b2013-06-28 16:59:19 +00001782basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001783{
1784 if (__sz > max_size())
1785 this->__throw_length_error();
1786 pointer __p;
1787 if (__sz < __min_cap)
1788 {
1789 __set_short_size(__sz);
1790 __p = __get_short_pointer();
1791 }
1792 else
1793 {
1794 size_type __cap = __recommend(__sz);
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001795 __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001796 __set_long_pointer(__p);
1797 __set_long_cap(__cap+1);
1798 __set_long_size(__sz);
1799 }
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001800 traits_type::copy(_VSTD::__to_address(__p), __s, __sz);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001801 traits_type::assign(__p[__sz], value_type());
1802}
1803
1804template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00001805template <class>
Eric Fiselier812882b2017-02-17 01:17:10 +00001806basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001807 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001808{
Howard Hinnant8ea98242013-08-23 17:37:05 +00001809 _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00001810 __init(__s, traits_type::length(__s));
Howard Hinnant8ea98242013-08-23 17:37:05 +00001811#if _LIBCPP_DEBUG_LEVEL >= 2
1812 __get_db()->__insert_c(this);
1813#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001814}
1815
1816template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001817inline
Eric Fiselier812882b2017-02-17 01:17:10 +00001818basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001819 : __r_(__default_init_tag(), __default_init_tag())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001820{
Howard Hinnant8ea98242013-08-23 17:37:05 +00001821 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00001822 __init(__s, __n);
Howard Hinnant8ea98242013-08-23 17:37:05 +00001823#if _LIBCPP_DEBUG_LEVEL >= 2
1824 __get_db()->__insert_c(this);
1825#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001826}
1827
1828template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001829inline
Eric Fiselier812882b2017-02-17 01:17:10 +00001830basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001831 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001832{
Howard Hinnant8ea98242013-08-23 17:37:05 +00001833 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00001834 __init(__s, __n);
Howard Hinnant8ea98242013-08-23 17:37:05 +00001835#if _LIBCPP_DEBUG_LEVEL >= 2
1836 __get_db()->__insert_c(this);
1837#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001838}
1839
1840template <class _CharT, class _Traits, class _Allocator>
1841basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001842 : __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
Howard Hinnantc51e1022010-05-11 19:42:16 +00001843{
1844 if (!__str.__is_long())
1845 __r_.first().__r = __str.__r_.first().__r;
1846 else
Eric Fiselier9b56ccb2020-01-20 21:41:58 -05001847 __init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
Howard Hinnant8ea98242013-08-23 17:37:05 +00001848#if _LIBCPP_DEBUG_LEVEL >= 2
1849 __get_db()->__insert_c(this);
1850#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001851}
1852
1853template <class _CharT, class _Traits, class _Allocator>
Eric Fiselier812882b2017-02-17 01:17:10 +00001854basic_string<_CharT, _Traits, _Allocator>::basic_string(
1855 const basic_string& __str, const allocator_type& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001856 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001857{
1858 if (!__str.__is_long())
1859 __r_.first().__r = __str.__r_.first().__r;
1860 else
Eric Fiselier9b56ccb2020-01-20 21:41:58 -05001861 __init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
Howard Hinnant8ea98242013-08-23 17:37:05 +00001862#if _LIBCPP_DEBUG_LEVEL >= 2
1863 __get_db()->__insert_c(this);
1864#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001865}
1866
Eric Fiselierfc92be82017-04-19 00:28:44 +00001867#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001868
1869template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001870inline
Howard Hinnant3e276872011-06-03 18:40:47 +00001871basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
Marshall Clowa80abc72015-06-03 19:56:43 +00001872#if _LIBCPP_STD_VER <= 14
Howard Hinnant3e276872011-06-03 18:40:47 +00001873 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
Marshall Clowa80abc72015-06-03 19:56:43 +00001874#else
1875 _NOEXCEPT
1876#endif
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001877 : __r_(_VSTD::move(__str.__r_))
Howard Hinnantc51e1022010-05-11 19:42:16 +00001878{
1879 __str.__zero();
Howard Hinnant8ea98242013-08-23 17:37:05 +00001880#if _LIBCPP_DEBUG_LEVEL >= 2
1881 __get_db()->__insert_c(this);
1882 if (__is_long())
1883 __get_db()->swap(this, &__str);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001884#endif
1885}
1886
1887template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001888inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00001889basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001890 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001891{
Marshall Clowd2d24692014-07-17 15:32:20 +00001892 if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001893 __init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
Marshall Clowd2d24692014-07-17 15:32:20 +00001894 else
1895 {
1896 __r_.first().__r = __str.__r_.first().__r;
1897 __str.__zero();
1898 }
Howard Hinnant8ea98242013-08-23 17:37:05 +00001899#if _LIBCPP_DEBUG_LEVEL >= 2
1900 __get_db()->__insert_c(this);
1901 if (__is_long())
1902 __get_db()->swap(this, &__str);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001903#endif
1904}
1905
Eric Fiselierfc92be82017-04-19 00:28:44 +00001906#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001907
1908template <class _CharT, class _Traits, class _Allocator>
1909void
1910basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
1911{
1912 if (__n > max_size())
1913 this->__throw_length_error();
1914 pointer __p;
1915 if (__n < __min_cap)
1916 {
1917 __set_short_size(__n);
1918 __p = __get_short_pointer();
1919 }
1920 else
1921 {
1922 size_type __cap = __recommend(__n);
Howard Hinnantea8f7e12010-11-17 17:55:08 +00001923 __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001924 __set_long_pointer(__p);
1925 __set_long_cap(__cap+1);
1926 __set_long_size(__n);
1927 }
Eric Fiselierc1b87a72019-11-16 17:13:26 -05001928 traits_type::assign(_VSTD::__to_address(__p), __n, __c);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001929 traits_type::assign(__p[__n], value_type());
1930}
1931
1932template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001933inline
Eric Fiselier812882b2017-02-17 01:17:10 +00001934basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001935 : __r_(__default_init_tag(), __default_init_tag())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001936{
1937 __init(__n, __c);
Howard Hinnant8ea98242013-08-23 17:37:05 +00001938#if _LIBCPP_DEBUG_LEVEL >= 2
1939 __get_db()->__insert_c(this);
1940#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001941}
1942
1943template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00001944template <class>
Eric Fiselier812882b2017-02-17 01:17:10 +00001945basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001946 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001947{
1948 __init(__n, __c);
Howard Hinnant8ea98242013-08-23 17:37:05 +00001949#if _LIBCPP_DEBUG_LEVEL >= 2
1950 __get_db()->__insert_c(this);
1951#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001952}
1953
Howard Hinnantc51e1022010-05-11 19:42:16 +00001954template <class _CharT, class _Traits, class _Allocator>
Eric Fiselier812882b2017-02-17 01:17:10 +00001955basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,
1956 size_type __pos, size_type __n,
1957 const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001958 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001959{
1960 size_type __str_sz = __str.size();
1961 if (__pos > __str_sz)
1962 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001963 __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
Howard Hinnant8ea98242013-08-23 17:37:05 +00001964#if _LIBCPP_DEBUG_LEVEL >= 2
1965 __get_db()->__insert_c(this);
1966#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001967}
1968
1969template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00001970inline
Marshall Clow83445802016-04-07 18:13:41 +00001971basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
Eric Fiselier812882b2017-02-17 01:17:10 +00001972 const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001973 : __r_(__default_init_tag(), __a)
Marshall Clow83445802016-04-07 18:13:41 +00001974{
1975 size_type __str_sz = __str.size();
1976 if (__pos > __str_sz)
1977 this->__throw_out_of_range();
1978 __init(__str.data() + __pos, __str_sz - __pos);
1979#if _LIBCPP_DEBUG_LEVEL >= 2
1980 __get_db()->__insert_c(this);
1981#endif
1982}
1983
1984template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00001985template <class _Tp, class>
Marshall Clow78dbe462016-11-14 18:22:19 +00001986basic_string<_CharT, _Traits, _Allocator>::basic_string(
Marshall Clowe46031a2018-07-02 18:41:15 +00001987 const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05001988 : __r_(__default_init_tag(), __a)
Marshall Clow78dbe462016-11-14 18:22:19 +00001989{
Marshall Clowe46031a2018-07-02 18:41:15 +00001990 __self_view __sv0 = __t;
1991 __self_view __sv = __sv0.substr(__pos, __n);
Marshall Clow78dbe462016-11-14 18:22:19 +00001992 __init(__sv.data(), __sv.size());
1993#if _LIBCPP_DEBUG_LEVEL >= 2
1994 __get_db()->__insert_c(this);
Eric Fiselier812882b2017-02-17 01:17:10 +00001995#endif
Marshall Clow78dbe462016-11-14 18:22:19 +00001996}
1997
1998template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00001999template <class _Tp, class>
2000basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002001 : __r_(__default_init_tag(), __default_init_tag())
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002002{
Marshall Clowe46031a2018-07-02 18:41:15 +00002003 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002004 __init(__sv.data(), __sv.size());
2005#if _LIBCPP_DEBUG_LEVEL >= 2
2006 __get_db()->__insert_c(this);
2007#endif
2008}
2009
2010template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00002011template <class _Tp, class>
2012basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002013 : __r_(__default_init_tag(), __a)
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002014{
Marshall Clowe46031a2018-07-02 18:41:15 +00002015 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002016 __init(__sv.data(), __sv.size());
2017#if _LIBCPP_DEBUG_LEVEL >= 2
2018 __get_db()->__insert_c(this);
2019#endif
2020}
2021
2022template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002023template <class _InputIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002024_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002025<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002026 __is_exactly_cpp17_input_iterator<_InputIterator>::value
2027>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002028basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
2029{
2030 __zero();
2031#ifndef _LIBCPP_NO_EXCEPTIONS
2032 try
2033 {
Howard Hinnant3b6579a2010-08-22 00:02:43 +00002034#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantc51e1022010-05-11 19:42:16 +00002035 for (; __first != __last; ++__first)
2036 push_back(*__first);
2037#ifndef _LIBCPP_NO_EXCEPTIONS
2038 }
2039 catch (...)
2040 {
2041 if (__is_long())
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002042 __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002043 throw;
2044 }
Howard Hinnant3b6579a2010-08-22 00:02:43 +00002045#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantc51e1022010-05-11 19:42:16 +00002046}
2047
2048template <class _CharT, class _Traits, class _Allocator>
2049template <class _ForwardIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002050_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002051<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002052 __is_cpp17_forward_iterator<_ForwardIterator>::value
2053>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002054basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
2055{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002056 size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002057 if (__sz > max_size())
2058 this->__throw_length_error();
2059 pointer __p;
2060 if (__sz < __min_cap)
2061 {
2062 __set_short_size(__sz);
2063 __p = __get_short_pointer();
2064 }
2065 else
2066 {
2067 size_type __cap = __recommend(__sz);
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002068 __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002069 __set_long_pointer(__p);
2070 __set_long_cap(__cap+1);
2071 __set_long_size(__sz);
2072 }
Eric Fiseliera09a3b42014-10-27 19:28:20 +00002073 for (; __first != __last; ++__first, (void) ++__p)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002074 traits_type::assign(*__p, *__first);
2075 traits_type::assign(*__p, value_type());
2076}
2077
2078template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierc0f566d2019-03-14 12:31:10 +00002079template<class _InputIterator, class>
Eric Fiselierbea70602018-11-26 22:51:35 +00002080inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002081basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002082 : __r_(__default_init_tag(), __default_init_tag())
Howard Hinnantc51e1022010-05-11 19:42:16 +00002083{
2084 __init(__first, __last);
Howard Hinnant8ea98242013-08-23 17:37:05 +00002085#if _LIBCPP_DEBUG_LEVEL >= 2
2086 __get_db()->__insert_c(this);
2087#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002088}
2089
2090template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierc0f566d2019-03-14 12:31:10 +00002091template<class _InputIterator, class>
Eric Fiselierbea70602018-11-26 22:51:35 +00002092inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002093basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
2094 const allocator_type& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002095 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002096{
2097 __init(__first, __last);
Howard Hinnant8ea98242013-08-23 17:37:05 +00002098#if _LIBCPP_DEBUG_LEVEL >= 2
2099 __get_db()->__insert_c(this);
2100#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002101}
2102
Eric Fiselierfc92be82017-04-19 00:28:44 +00002103#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002104
Howard Hinnantc51e1022010-05-11 19:42:16 +00002105template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002106inline
Eric Fiselier812882b2017-02-17 01:17:10 +00002107basic_string<_CharT, _Traits, _Allocator>::basic_string(
2108 initializer_list<_CharT> __il)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002109 : __r_(__default_init_tag(), __default_init_tag())
Howard Hinnantc51e1022010-05-11 19:42:16 +00002110{
2111 __init(__il.begin(), __il.end());
Howard Hinnant8ea98242013-08-23 17:37:05 +00002112#if _LIBCPP_DEBUG_LEVEL >= 2
2113 __get_db()->__insert_c(this);
2114#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002115}
2116
2117template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002118inline
Eric Fiselier9d355982017-04-12 23:45:53 +00002119
Eric Fiselier812882b2017-02-17 01:17:10 +00002120basic_string<_CharT, _Traits, _Allocator>::basic_string(
2121 initializer_list<_CharT> __il, const _Allocator& __a)
Eric Fiselier5169d1c2019-12-16 19:03:23 -05002122 : __r_(__default_init_tag(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002123{
2124 __init(__il.begin(), __il.end());
Howard Hinnant8ea98242013-08-23 17:37:05 +00002125#if _LIBCPP_DEBUG_LEVEL >= 2
2126 __get_db()->__insert_c(this);
2127#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002128}
2129
Eric Fiselierfc92be82017-04-19 00:28:44 +00002130#endif // _LIBCPP_CXX03_LANG
Howard Hinnant33711792011-08-12 21:56:02 +00002131
Howard Hinnantc51e1022010-05-11 19:42:16 +00002132template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002133basic_string<_CharT, _Traits, _Allocator>::~basic_string()
2134{
Howard Hinnant8ea98242013-08-23 17:37:05 +00002135#if _LIBCPP_DEBUG_LEVEL >= 2
2136 __get_db()->__erase_c(this);
2137#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002138 if (__is_long())
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002139 __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002140}
2141
2142template <class _CharT, class _Traits, class _Allocator>
2143void
2144basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
2145 (size_type __old_cap, size_type __delta_cap, size_type __old_sz,
Howard Hinnantd17880b2013-06-28 16:59:19 +00002146 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 +00002147{
2148 size_type __ms = max_size();
2149 if (__delta_cap > __ms - __old_cap - 1)
2150 this->__throw_length_error();
2151 pointer __old_p = __get_pointer();
2152 size_type __cap = __old_cap < __ms / 2 - __alignment ?
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002153 __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
Howard Hinnantc51e1022010-05-11 19:42:16 +00002154 __ms - 1;
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002155 pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002156 __invalidate_all_iterators();
2157 if (__n_copy != 0)
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002158 traits_type::copy(_VSTD::__to_address(__p),
2159 _VSTD::__to_address(__old_p), __n_copy);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002160 if (__n_add != 0)
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002161 traits_type::copy(_VSTD::__to_address(__p) + __n_copy, __p_new_stuff, __n_add);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002162 size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
2163 if (__sec_cp_sz != 0)
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002164 traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
2165 _VSTD::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002166 if (__old_cap+1 != __min_cap)
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002167 __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002168 __set_long_pointer(__p);
2169 __set_long_cap(__cap+1);
2170 __old_sz = __n_copy + __n_add + __sec_cp_sz;
2171 __set_long_size(__old_sz);
2172 traits_type::assign(__p[__old_sz], value_type());
2173}
2174
2175template <class _CharT, class _Traits, class _Allocator>
2176void
2177basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
2178 size_type __n_copy, size_type __n_del, size_type __n_add)
2179{
2180 size_type __ms = max_size();
Marshall Clow2267c5d2013-11-06 14:24:38 +00002181 if (__delta_cap > __ms - __old_cap)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002182 this->__throw_length_error();
2183 pointer __old_p = __get_pointer();
2184 size_type __cap = __old_cap < __ms / 2 - __alignment ?
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002185 __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
Howard Hinnantc51e1022010-05-11 19:42:16 +00002186 __ms - 1;
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002187 pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002188 __invalidate_all_iterators();
2189 if (__n_copy != 0)
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002190 traits_type::copy(_VSTD::__to_address(__p),
2191 _VSTD::__to_address(__old_p), __n_copy);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002192 size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
2193 if (__sec_cp_sz != 0)
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002194 traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add,
2195 _VSTD::__to_address(__old_p) + __n_copy + __n_del,
Howard Hinnantd17880b2013-06-28 16:59:19 +00002196 __sec_cp_sz);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002197 if (__old_cap+1 != __min_cap)
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002198 __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002199 __set_long_pointer(__p);
2200 __set_long_cap(__cap+1);
2201}
2202
2203// assign
2204
2205template <class _CharT, class _Traits, class _Allocator>
2206basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002207basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002208{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002209 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002210 size_type __cap = capacity();
2211 if (__cap >= __n)
2212 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002213 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002214 traits_type::move(__p, __s, __n);
2215 traits_type::assign(__p[__n], value_type());
2216 __set_size(__n);
2217 __invalidate_iterators_past(__n);
2218 }
2219 else
2220 {
2221 size_type __sz = size();
2222 __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s);
2223 }
2224 return *this;
2225}
2226
2227template <class _CharT, class _Traits, class _Allocator>
2228basic_string<_CharT, _Traits, _Allocator>&
2229basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
2230{
2231 size_type __cap = capacity();
2232 if (__cap < __n)
2233 {
2234 size_type __sz = size();
2235 __grow_by(__cap, __n - __cap, __sz, 0, __sz);
2236 }
2237 else
2238 __invalidate_iterators_past(__n);
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002239 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002240 traits_type::assign(__p, __n, __c);
2241 traits_type::assign(__p[__n], value_type());
2242 __set_size(__n);
2243 return *this;
2244}
2245
2246template <class _CharT, class _Traits, class _Allocator>
2247basic_string<_CharT, _Traits, _Allocator>&
2248basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
2249{
2250 pointer __p;
2251 if (__is_long())
2252 {
2253 __p = __get_long_pointer();
2254 __set_long_size(1);
2255 }
2256 else
2257 {
2258 __p = __get_short_pointer();
2259 __set_short_size(1);
2260 }
2261 traits_type::assign(*__p, __c);
2262 traits_type::assign(*++__p, value_type());
2263 __invalidate_iterators_past(1);
2264 return *this;
2265}
2266
2267template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002268basic_string<_CharT, _Traits, _Allocator>&
2269basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
2270{
2271 if (this != &__str)
2272 {
2273 __copy_assign_alloc(__str);
Eric Fiselier03bbc922020-01-15 17:27:10 -05002274 const bool __str_is_long = __str.__is_long(); // Force single branch
2275 if (__is_long() || __str_is_long) {
2276 return assign(__str.data(), __str.size());
2277 }
2278 __r_.first().__r = __str.__r_.first().__r;
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002279 }
2280 return *this;
2281}
2282
Eric Fiselierfc92be82017-04-19 00:28:44 +00002283#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002284
2285template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002286inline
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002287void
2288basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00002289 _NOEXCEPT_(__alloc_traits::is_always_equal::value)
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002290{
2291 if (__alloc() != __str.__alloc())
2292 assign(__str);
2293 else
2294 __move_assign(__str, true_type());
2295}
2296
2297template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002298inline
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002299void
2300basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00002301#if _LIBCPP_STD_VER > 14
2302 _NOEXCEPT
2303#else
Howard Hinnant3e276872011-06-03 18:40:47 +00002304 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00002305#endif
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002306{
marshall2ed41622019-11-27 07:13:00 -08002307 if (__is_long()) {
2308 __alloc_traits::deallocate(__alloc(), __get_long_pointer(),
2309 __get_long_cap());
2310#if _LIBCPP_STD_VER <= 14
2311 if (!is_nothrow_move_assignable<allocator_type>::value) {
2312 __set_short_size(0);
2313 traits_type::assign(__get_short_pointer()[0], value_type());
2314 }
2315#endif
2316 }
2317 __move_assign_alloc(__str);
2318 __r_.first() = __str.__r_.first();
2319 __str.__set_short_size(0);
2320 traits_type::assign(__str.__get_short_pointer()[0], value_type());
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002321}
2322
2323template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002324inline
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002325basic_string<_CharT, _Traits, _Allocator>&
2326basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
Marshall Clow2fe8a8d2015-08-18 18:57:00 +00002327 _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
Howard Hinnantea8f7e12010-11-17 17:55:08 +00002328{
2329 __move_assign(__str, integral_constant<bool,
2330 __alloc_traits::propagate_on_container_move_assignment::value>());
2331 return *this;
2332}
2333
2334#endif
2335
2336template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002337template<class _InputIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002338_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002339<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002340 __is_exactly_cpp17_input_iterator <_InputIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00002341 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00002342 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002343>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002344basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
2345{
Marshall Clow958362f2016-09-05 01:54:30 +00002346 const basic_string __temp(__first, __last, __alloc());
Marshall Clow039b2f02016-01-13 21:54:34 +00002347 assign(__temp.data(), __temp.size());
Argyrios Kyrtzidisaf904652012-10-13 02:03:45 +00002348 return *this;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002349}
2350
2351template <class _CharT, class _Traits, class _Allocator>
2352template<class _ForwardIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002353_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002354<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002355 __is_cpp17_forward_iterator<_ForwardIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00002356 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00002357 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002358>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002359basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
2360{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002361 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002362 size_type __cap = capacity();
2363 if (__cap < __n)
2364 {
2365 size_type __sz = size();
2366 __grow_by(__cap, __n - __cap, __sz, 0, __sz);
2367 }
2368 else
2369 __invalidate_iterators_past(__n);
2370 pointer __p = __get_pointer();
2371 for (; __first != __last; ++__first, ++__p)
2372 traits_type::assign(*__p, *__first);
2373 traits_type::assign(*__p, value_type());
2374 __set_size(__n);
2375 return *this;
2376}
2377
2378template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002379basic_string<_CharT, _Traits, _Allocator>&
2380basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
2381{
2382 size_type __sz = __str.size();
2383 if (__pos > __sz)
2384 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002385 return assign(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002386}
2387
2388template <class _CharT, class _Traits, class _Allocator>
Marshall Clow82513342016-09-24 22:45:42 +00002389template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002390_EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00002391<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002392 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
2393 && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
Marshall Clowb7db4972017-11-15 20:02:27 +00002394 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002395>
Marshall Clow82513342016-09-24 22:45:42 +00002396basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n)
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002397{
Marshall Clow82513342016-09-24 22:45:42 +00002398 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002399 size_type __sz = __sv.size();
2400 if (__pos > __sz)
2401 this->__throw_out_of_range();
2402 return assign(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
2403}
2404
2405
2406template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002407basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002408basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002409{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002410 _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002411 return assign(__s, traits_type::length(__s));
2412}
2413
2414// append
2415
2416template <class _CharT, class _Traits, class _Allocator>
2417basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002418basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002419{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002420 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002421 size_type __cap = capacity();
2422 size_type __sz = size();
2423 if (__cap - __sz >= __n)
2424 {
2425 if (__n)
2426 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002427 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002428 traits_type::copy(__p + __sz, __s, __n);
2429 __sz += __n;
2430 __set_size(__sz);
2431 traits_type::assign(__p[__sz], value_type());
2432 }
2433 }
2434 else
2435 __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);
2436 return *this;
2437}
2438
2439template <class _CharT, class _Traits, class _Allocator>
2440basic_string<_CharT, _Traits, _Allocator>&
2441basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)
2442{
2443 if (__n)
2444 {
2445 size_type __cap = capacity();
2446 size_type __sz = size();
2447 if (__cap - __sz < __n)
2448 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
2449 pointer __p = __get_pointer();
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002450 traits_type::assign(_VSTD::__to_address(__p) + __sz, __n, __c);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002451 __sz += __n;
2452 __set_size(__sz);
2453 traits_type::assign(__p[__sz], value_type());
2454 }
2455 return *this;
2456}
2457
2458template <class _CharT, class _Traits, class _Allocator>
Eric Fiselier451d5582018-11-26 20:15:38 +00002459inline void
2460basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n)
2461{
2462 if (__n)
2463 {
2464 size_type __cap = capacity();
2465 size_type __sz = size();
2466 if (__cap - __sz < __n)
2467 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
2468 pointer __p = __get_pointer();
2469 __sz += __n;
2470 __set_size(__sz);
2471 traits_type::assign(__p[__sz], value_type());
2472 }
2473}
2474
2475template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002476void
2477basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c)
2478{
Howard Hinnant68bf1812013-04-30 21:44:48 +00002479 bool __is_short = !__is_long();
2480 size_type __cap;
2481 size_type __sz;
2482 if (__is_short)
2483 {
2484 __cap = __min_cap - 1;
2485 __sz = __get_short_size();
2486 }
2487 else
2488 {
2489 __cap = __get_long_cap() - 1;
2490 __sz = __get_long_size();
2491 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00002492 if (__sz == __cap)
Howard Hinnant68bf1812013-04-30 21:44:48 +00002493 {
Howard Hinnantc51e1022010-05-11 19:42:16 +00002494 __grow_by(__cap, 1, __sz, __sz, 0);
Howard Hinnant68bf1812013-04-30 21:44:48 +00002495 __is_short = !__is_long();
2496 }
2497 pointer __p;
2498 if (__is_short)
2499 {
2500 __p = __get_short_pointer() + __sz;
2501 __set_short_size(__sz+1);
2502 }
2503 else
2504 {
2505 __p = __get_long_pointer() + __sz;
2506 __set_long_size(__sz+1);
2507 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00002508 traits_type::assign(*__p, __c);
2509 traits_type::assign(*++__p, value_type());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002510}
2511
Marshall Clow6ebbf662016-09-07 03:32:06 +00002512template <class _Tp>
Marshall Clow958362f2016-09-05 01:54:30 +00002513bool __ptr_in_range (const _Tp* __p, const _Tp* __first, const _Tp* __last)
2514{
2515 return __first <= __p && __p < __last;
2516}
2517
Marshall Clow6ebbf662016-09-07 03:32:06 +00002518template <class _Tp1, class _Tp2>
Eric Fiselier6003c772016-12-23 23:37:52 +00002519bool __ptr_in_range (const _Tp1*, const _Tp2*, const _Tp2*)
Marshall Clow6ebbf662016-09-07 03:32:06 +00002520{
2521 return false;
2522}
2523
Howard Hinnantc51e1022010-05-11 19:42:16 +00002524template <class _CharT, class _Traits, class _Allocator>
2525template<class _ForwardIterator>
Eric Fiselierdb7ee8f2016-10-31 02:46:25 +00002526basic_string<_CharT, _Traits, _Allocator>&
2527basic_string<_CharT, _Traits, _Allocator>::__append_forward_unsafe(
2528 _ForwardIterator __first, _ForwardIterator __last)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002529{
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002530 static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
Eric Fiselierdb7ee8f2016-10-31 02:46:25 +00002531 "function requires a ForwardIterator");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002532 size_type __sz = size();
2533 size_type __cap = capacity();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002534 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002535 if (__n)
2536 {
Eric Fiselier96866b52017-04-15 06:49:02 +00002537 typedef typename iterator_traits<_ForwardIterator>::reference _CharRef;
2538 _CharRef __tmp_ref = *__first;
2539 if (__ptr_in_range(_VSTD::addressof(__tmp_ref), data(), data() + size()))
Marshall Clow958362f2016-09-05 01:54:30 +00002540 {
2541 const basic_string __temp (__first, __last, __alloc());
2542 append(__temp.data(), __temp.size());
2543 }
Louis Dionne173f29e2019-05-29 16:01:36 +00002544 else
Marshall Clow958362f2016-09-05 01:54:30 +00002545 {
2546 if (__cap - __sz < __n)
2547 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
2548 pointer __p = __get_pointer() + __sz;
2549 for (; __first != __last; ++__p, ++__first)
2550 traits_type::assign(*__p, *__first);
2551 traits_type::assign(*__p, value_type());
2552 __set_size(__sz + __n);
2553 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00002554 }
2555 return *this;
2556}
2557
2558template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002559inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002560basic_string<_CharT, _Traits, _Allocator>&
2561basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str)
2562{
2563 return append(__str.data(), __str.size());
2564}
2565
2566template <class _CharT, class _Traits, class _Allocator>
2567basic_string<_CharT, _Traits, _Allocator>&
2568basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n)
2569{
2570 size_type __sz = __str.size();
2571 if (__pos > __sz)
2572 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002573 return append(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002574}
2575
2576template <class _CharT, class _Traits, class _Allocator>
Marshall Clow62953962016-10-03 23:40:48 +00002577template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002578 _EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00002579 <
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002580 __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 +00002581 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002582 >
Marshall Clow82513342016-09-24 22:45:42 +00002583basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n)
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002584{
Marshall Clow82513342016-09-24 22:45:42 +00002585 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002586 size_type __sz = __sv.size();
2587 if (__pos > __sz)
2588 this->__throw_out_of_range();
2589 return append(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
2590}
2591
2592template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002593basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002594basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002595{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002596 _LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002597 return append(__s, traits_type::length(__s));
2598}
2599
2600// insert
2601
2602template <class _CharT, class _Traits, class _Allocator>
2603basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002604basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002605{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002606 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002607 size_type __sz = size();
2608 if (__pos > __sz)
2609 this->__throw_out_of_range();
2610 size_type __cap = capacity();
2611 if (__cap - __sz >= __n)
2612 {
2613 if (__n)
2614 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002615 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002616 size_type __n_move = __sz - __pos;
2617 if (__n_move != 0)
2618 {
2619 if (__p + __pos <= __s && __s < __p + __sz)
2620 __s += __n;
2621 traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
2622 }
2623 traits_type::move(__p + __pos, __s, __n);
2624 __sz += __n;
2625 __set_size(__sz);
2626 traits_type::assign(__p[__sz], value_type());
2627 }
2628 }
2629 else
2630 __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
2631 return *this;
2632}
2633
2634template <class _CharT, class _Traits, class _Allocator>
2635basic_string<_CharT, _Traits, _Allocator>&
2636basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c)
2637{
2638 size_type __sz = size();
2639 if (__pos > __sz)
2640 this->__throw_out_of_range();
2641 if (__n)
2642 {
2643 size_type __cap = capacity();
Howard Hinnantd17880b2013-06-28 16:59:19 +00002644 value_type* __p;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002645 if (__cap - __sz >= __n)
2646 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002647 __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002648 size_type __n_move = __sz - __pos;
2649 if (__n_move != 0)
2650 traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
2651 }
2652 else
2653 {
2654 __grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002655 __p = _VSTD::__to_address(__get_long_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002656 }
2657 traits_type::assign(__p + __pos, __n, __c);
2658 __sz += __n;
2659 __set_size(__sz);
2660 traits_type::assign(__p[__sz], value_type());
2661 }
2662 return *this;
2663}
2664
2665template <class _CharT, class _Traits, class _Allocator>
2666template<class _InputIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002667_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002668<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002669 __is_exactly_cpp17_input_iterator<_InputIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00002670 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
2671 typename basic_string<_CharT, _Traits, _Allocator>::iterator
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002672>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002673basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
2674{
Howard Hinnant8ea98242013-08-23 17:37:05 +00002675#if _LIBCPP_DEBUG_LEVEL >= 2
2676 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
2677 "string::insert(iterator, range) called with an iterator not"
2678 " referring to this string");
2679#endif
Marshall Clow958362f2016-09-05 01:54:30 +00002680 const basic_string __temp(__first, __last, __alloc());
Marshall Clow039b2f02016-01-13 21:54:34 +00002681 return insert(__pos, __temp.data(), __temp.data() + __temp.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002682}
2683
2684template <class _CharT, class _Traits, class _Allocator>
2685template<class _ForwardIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002686_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002687<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002688 __is_cpp17_forward_iterator<_ForwardIterator>::value
Marshall Clow039b2f02016-01-13 21:54:34 +00002689 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00002690 typename basic_string<_CharT, _Traits, _Allocator>::iterator
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002691>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002692basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
2693{
Howard Hinnant8ea98242013-08-23 17:37:05 +00002694#if _LIBCPP_DEBUG_LEVEL >= 2
2695 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
2696 "string::insert(iterator, range) called with an iterator not"
2697 " referring to this string");
2698#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002699 size_type __ip = static_cast<size_type>(__pos - begin());
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002700 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002701 if (__n)
2702 {
Eric Fiselier96866b52017-04-15 06:49:02 +00002703 typedef typename iterator_traits<_ForwardIterator>::reference _CharRef;
2704 _CharRef __tmp_char = *__first;
2705 if (__ptr_in_range(_VSTD::addressof(__tmp_char), data(), data() + size()))
Marshall Clow958362f2016-09-05 01:54:30 +00002706 {
2707 const basic_string __temp(__first, __last, __alloc());
2708 return insert(__pos, __temp.data(), __temp.data() + __temp.size());
2709 }
2710
2711 size_type __sz = size();
2712 size_type __cap = capacity();
Howard Hinnantd17880b2013-06-28 16:59:19 +00002713 value_type* __p;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002714 if (__cap - __sz >= __n)
2715 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002716 __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002717 size_type __n_move = __sz - __ip;
2718 if (__n_move != 0)
2719 traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
2720 }
2721 else
2722 {
2723 __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002724 __p = _VSTD::__to_address(__get_long_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002725 }
2726 __sz += __n;
2727 __set_size(__sz);
2728 traits_type::assign(__p[__sz], value_type());
2729 for (__p += __ip; __first != __last; ++__p, ++__first)
2730 traits_type::assign(*__p, *__first);
2731 }
2732 return begin() + __ip;
2733}
2734
2735template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002736inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002737basic_string<_CharT, _Traits, _Allocator>&
2738basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str)
2739{
2740 return insert(__pos1, __str.data(), __str.size());
2741}
2742
2743template <class _CharT, class _Traits, class _Allocator>
2744basic_string<_CharT, _Traits, _Allocator>&
2745basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str,
2746 size_type __pos2, size_type __n)
2747{
2748 size_type __str_sz = __str.size();
2749 if (__pos2 > __str_sz)
2750 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002751 return insert(__pos1, __str.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002752}
2753
2754template <class _CharT, class _Traits, class _Allocator>
Marshall Clow82513342016-09-24 22:45:42 +00002755template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002756_EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00002757<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002758 __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 +00002759 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002760>
Marshall Clow82513342016-09-24 22:45:42 +00002761basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t,
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002762 size_type __pos2, size_type __n)
2763{
Marshall Clow82513342016-09-24 22:45:42 +00002764 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002765 size_type __str_sz = __sv.size();
2766 if (__pos2 > __str_sz)
2767 this->__throw_out_of_range();
2768 return insert(__pos1, __sv.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
2769}
2770
2771template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantc51e1022010-05-11 19:42:16 +00002772basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002773basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002774{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002775 _LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002776 return insert(__pos, __s, traits_type::length(__s));
2777}
2778
2779template <class _CharT, class _Traits, class _Allocator>
2780typename basic_string<_CharT, _Traits, _Allocator>::iterator
2781basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
2782{
2783 size_type __ip = static_cast<size_type>(__pos - begin());
2784 size_type __sz = size();
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)
2788 {
2789 __grow_by(__cap, 1, __sz, __ip, 0, 1);
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002790 __p = _VSTD::__to_address(__get_long_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002791 }
2792 else
2793 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002794 __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002795 size_type __n_move = __sz - __ip;
2796 if (__n_move != 0)
2797 traits_type::move(__p + __ip + 1, __p + __ip, __n_move);
2798 }
2799 traits_type::assign(__p[__ip], __c);
2800 traits_type::assign(__p[++__sz], value_type());
2801 __set_size(__sz);
2802 return begin() + static_cast<difference_type>(__ip);
2803}
2804
2805template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002806inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002807typename basic_string<_CharT, _Traits, _Allocator>::iterator
2808basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c)
2809{
Howard Hinnant8ea98242013-08-23 17:37:05 +00002810#if _LIBCPP_DEBUG_LEVEL >= 2
2811 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
2812 "string::insert(iterator, n, value) called with an iterator not"
2813 " referring to this string");
2814#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00002815 difference_type __p = __pos - begin();
2816 insert(static_cast<size_type>(__p), __n, __c);
2817 return begin() + __p;
2818}
2819
2820// replace
2821
2822template <class _CharT, class _Traits, class _Allocator>
2823basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002824basic_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 +00002825 _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
Howard Hinnantc51e1022010-05-11 19:42:16 +00002826{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002827 _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002828 size_type __sz = size();
2829 if (__pos > __sz)
2830 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002831 __n1 = _VSTD::min(__n1, __sz - __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002832 size_type __cap = capacity();
2833 if (__cap - __sz + __n1 >= __n2)
2834 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002835 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002836 if (__n1 != __n2)
2837 {
2838 size_type __n_move = __sz - __pos - __n1;
2839 if (__n_move != 0)
2840 {
2841 if (__n1 > __n2)
2842 {
2843 traits_type::move(__p + __pos, __s, __n2);
2844 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
2845 goto __finish;
2846 }
2847 if (__p + __pos < __s && __s < __p + __sz)
2848 {
2849 if (__p + __pos + __n1 <= __s)
2850 __s += __n2 - __n1;
2851 else // __p + __pos < __s < __p + __pos + __n1
2852 {
2853 traits_type::move(__p + __pos, __s, __n1);
2854 __pos += __n1;
2855 __s += __n2;
2856 __n2 -= __n1;
2857 __n1 = 0;
2858 }
2859 }
2860 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
2861 }
2862 }
2863 traits_type::move(__p + __pos, __s, __n2);
2864__finish:
Martijn Vels1c48afb2020-01-28 13:43:19 -05002865// __sz += __n2 - __n1; in this and the below function below can cause unsigned
2866// integer overflow, but this is a safe operation, so we disable the check.
Howard Hinnantc51e1022010-05-11 19:42:16 +00002867 __sz += __n2 - __n1;
2868 __set_size(__sz);
2869 __invalidate_iterators_past(__sz);
2870 traits_type::assign(__p[__sz], value_type());
2871 }
2872 else
2873 __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
2874 return *this;
2875}
2876
2877template <class _CharT, class _Traits, class _Allocator>
2878basic_string<_CharT, _Traits, _Allocator>&
2879basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c)
Eric Fiseliere5b21842017-03-09 01:54:13 +00002880 _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
Howard Hinnantc51e1022010-05-11 19:42:16 +00002881{
2882 size_type __sz = size();
2883 if (__pos > __sz)
2884 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002885 __n1 = _VSTD::min(__n1, __sz - __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002886 size_type __cap = capacity();
Howard Hinnantd17880b2013-06-28 16:59:19 +00002887 value_type* __p;
Howard Hinnantc51e1022010-05-11 19:42:16 +00002888 if (__cap - __sz + __n1 >= __n2)
2889 {
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002890 __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002891 if (__n1 != __n2)
2892 {
2893 size_type __n_move = __sz - __pos - __n1;
2894 if (__n_move != 0)
2895 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
2896 }
2897 }
2898 else
2899 {
2900 __grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2);
Eric Fiselierc1b87a72019-11-16 17:13:26 -05002901 __p = _VSTD::__to_address(__get_long_pointer());
Howard Hinnantc51e1022010-05-11 19:42:16 +00002902 }
2903 traits_type::assign(__p + __pos, __n2, __c);
2904 __sz += __n2 - __n1;
2905 __set_size(__sz);
2906 __invalidate_iterators_past(__sz);
2907 traits_type::assign(__p[__sz], value_type());
2908 return *this;
2909}
2910
2911template <class _CharT, class _Traits, class _Allocator>
2912template<class _InputIterator>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002913_EnableIf
Howard Hinnantc51e1022010-05-11 19:42:16 +00002914<
Eric Fiseliercd5a6772019-11-18 01:46:58 -05002915 __is_cpp17_input_iterator<_InputIterator>::value,
Howard Hinnantc51e1022010-05-11 19:42:16 +00002916 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002917>
Howard Hinnant990d6e82010-11-17 21:11:40 +00002918basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,
Howard Hinnantc51e1022010-05-11 19:42:16 +00002919 _InputIterator __j1, _InputIterator __j2)
2920{
Marshall Clow958362f2016-09-05 01:54:30 +00002921 const basic_string __temp(__j1, __j2, __alloc());
Marshall Clow039b2f02016-01-13 21:54:34 +00002922 return this->replace(__i1, __i2, __temp);
Howard Hinnantc51e1022010-05-11 19:42:16 +00002923}
2924
2925template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002926inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002927basic_string<_CharT, _Traits, _Allocator>&
2928basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str)
2929{
2930 return replace(__pos1, __n1, __str.data(), __str.size());
2931}
2932
2933template <class _CharT, class _Traits, class _Allocator>
2934basic_string<_CharT, _Traits, _Allocator>&
2935basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str,
2936 size_type __pos2, size_type __n2)
2937{
2938 size_type __str_sz = __str.size();
2939 if (__pos2 > __str_sz)
2940 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00002941 return replace(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
Howard Hinnantc51e1022010-05-11 19:42:16 +00002942}
2943
2944template <class _CharT, class _Traits, class _Allocator>
Marshall Clow82513342016-09-24 22:45:42 +00002945template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002946_EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00002947<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002948 __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 +00002949 basic_string<_CharT, _Traits, _Allocator>&
Eric Fiselierc522ceb2020-01-15 16:57:08 -05002950>
Marshall Clow82513342016-09-24 22:45:42 +00002951basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t,
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002952 size_type __pos2, size_type __n2)
2953{
Marshall Clow82513342016-09-24 22:45:42 +00002954 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00002955 size_type __str_sz = __sv.size();
2956 if (__pos2 > __str_sz)
2957 this->__throw_out_of_range();
2958 return replace(__pos1, __n1, __sv.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
2959}
2960
2961template <class _CharT, class _Traits, class _Allocator>
2962basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002963basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002964{
Alp Tokerb8a95f52014-05-15 11:27:39 +00002965 _LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00002966 return replace(__pos, __n1, __s, traits_type::length(__s));
2967}
2968
2969template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002970inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002971basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnant990d6e82010-11-17 21:11:40 +00002972basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002973{
2974 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1),
2975 __str.data(), __str.size());
2976}
2977
2978template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002979inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002980basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002981basic_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 +00002982{
2983 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n);
2984}
2985
2986template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002987inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002988basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnantd17880b2013-06-28 16:59:19 +00002989basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002990{
2991 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s);
2992}
2993
2994template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00002995inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00002996basic_string<_CharT, _Traits, _Allocator>&
Howard Hinnant990d6e82010-11-17 21:11:40 +00002997basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00002998{
2999 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c);
3000}
3001
3002// erase
3003
Martijn Velsa81fc792020-02-26 13:25:43 -05003004// 'externally instantiated' erase() implementation, called when __n != npos.
3005// Does not check __pos against size()
Howard Hinnantc51e1022010-05-11 19:42:16 +00003006template <class _CharT, class _Traits, class _Allocator>
Martijn Velsa81fc792020-02-26 13:25:43 -05003007void
3008basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move(
3009 size_type __pos, size_type __n)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003010{
Howard Hinnantc51e1022010-05-11 19:42:16 +00003011 if (__n)
3012 {
Martijn Velsa81fc792020-02-26 13:25:43 -05003013 size_type __sz = size();
Eric Fiselierc1b87a72019-11-16 17:13:26 -05003014 value_type* __p = _VSTD::__to_address(__get_pointer());
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003015 __n = _VSTD::min(__n, __sz - __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003016 size_type __n_move = __sz - __pos - __n;
3017 if (__n_move != 0)
3018 traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
3019 __sz -= __n;
3020 __set_size(__sz);
3021 __invalidate_iterators_past(__sz);
3022 traits_type::assign(__p[__sz], value_type());
3023 }
Martijn Velsa81fc792020-02-26 13:25:43 -05003024}
3025
3026template <class _CharT, class _Traits, class _Allocator>
3027basic_string<_CharT, _Traits, _Allocator>&
3028basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos,
3029 size_type __n) {
3030 if (__pos > size()) this->__throw_out_of_range();
3031 if (__n == npos) {
3032 __erase_to_end(__pos);
3033 } else {
3034 __erase_external_with_move(__pos, __n);
3035 }
3036 return *this;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003037}
3038
3039template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003040inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003041typename basic_string<_CharT, _Traits, _Allocator>::iterator
3042basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
3043{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003044#if _LIBCPP_DEBUG_LEVEL >= 2
3045 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
3046 "string::erase(iterator) called with an iterator not"
3047 " referring to this string");
3048#endif
3049 _LIBCPP_ASSERT(__pos != end(),
3050 "string::erase(iterator) called with a non-dereferenceable iterator");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003051 iterator __b = begin();
3052 size_type __r = static_cast<size_type>(__pos - __b);
3053 erase(__r, 1);
Howard Hinnant28b24882011-12-01 20:21:04 +00003054 return __b + static_cast<difference_type>(__r);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003055}
3056
3057template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003058inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003059typename basic_string<_CharT, _Traits, _Allocator>::iterator
3060basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last)
3061{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003062#if _LIBCPP_DEBUG_LEVEL >= 2
3063 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
3064 "string::erase(iterator, iterator) called with an iterator not"
3065 " referring to this string");
3066#endif
3067 _LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003068 iterator __b = begin();
3069 size_type __r = static_cast<size_type>(__first - __b);
3070 erase(__r, static_cast<size_type>(__last - __first));
Howard Hinnant28b24882011-12-01 20:21:04 +00003071 return __b + static_cast<difference_type>(__r);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003072}
3073
3074template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003075inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003076void
3077basic_string<_CharT, _Traits, _Allocator>::pop_back()
3078{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003079 _LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003080 size_type __sz;
3081 if (__is_long())
3082 {
3083 __sz = __get_long_size() - 1;
3084 __set_long_size(__sz);
3085 traits_type::assign(*(__get_long_pointer() + __sz), value_type());
3086 }
3087 else
3088 {
3089 __sz = __get_short_size() - 1;
3090 __set_short_size(__sz);
3091 traits_type::assign(*(__get_short_pointer() + __sz), value_type());
3092 }
3093 __invalidate_iterators_past(__sz);
3094}
3095
3096template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003097inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003098void
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003099basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003100{
3101 __invalidate_all_iterators();
3102 if (__is_long())
3103 {
3104 traits_type::assign(*__get_long_pointer(), value_type());
3105 __set_long_size(0);
3106 }
3107 else
3108 {
3109 traits_type::assign(*__get_short_pointer(), value_type());
3110 __set_short_size(0);
3111 }
3112}
3113
3114template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003115inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003116void
3117basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos)
3118{
3119 if (__is_long())
3120 {
3121 traits_type::assign(*(__get_long_pointer() + __pos), value_type());
3122 __set_long_size(__pos);
3123 }
3124 else
3125 {
3126 traits_type::assign(*(__get_short_pointer() + __pos), value_type());
3127 __set_short_size(__pos);
3128 }
3129 __invalidate_iterators_past(__pos);
3130}
3131
3132template <class _CharT, class _Traits, class _Allocator>
3133void
3134basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c)
3135{
3136 size_type __sz = size();
3137 if (__n > __sz)
3138 append(__n - __sz, __c);
3139 else
3140 __erase_to_end(__n);
3141}
3142
3143template <class _CharT, class _Traits, class _Allocator>
Eric Fiselier451d5582018-11-26 20:15:38 +00003144inline void
3145basic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n)
3146{
3147 size_type __sz = size();
3148 if (__n > __sz) {
3149 __append_default_init(__n - __sz);
3150 } else
3151 __erase_to_end(__n);
3152}
3153
3154template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003155inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003156typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003157basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003158{
Howard Hinnantea8f7e12010-11-17 17:55:08 +00003159 size_type __m = __alloc_traits::max_size(__alloc());
Eric Fiseliere9cc5922017-10-17 13:16:01 +00003160#ifdef _LIBCPP_BIG_ENDIAN
Marshall Clow6dd6cb72013-10-31 17:23:08 +00003161 return (__m <= ~__long_mask ? __m : __m/2) - __alignment;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003162#else
Marshall Clow6dd6cb72013-10-31 17:23:08 +00003163 return __m - __alignment;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003164#endif
3165}
3166
3167template <class _CharT, class _Traits, class _Allocator>
3168void
3169basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)
3170{
3171 if (__res_arg > max_size())
3172 this->__throw_length_error();
3173 size_type __cap = capacity();
3174 size_type __sz = size();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003175 __res_arg = _VSTD::max(__res_arg, __sz);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003176 __res_arg = __recommend(__res_arg);
3177 if (__res_arg != __cap)
3178 {
3179 pointer __new_data, __p;
3180 bool __was_long, __now_long;
3181 if (__res_arg == __min_cap - 1)
3182 {
3183 __was_long = true;
3184 __now_long = false;
3185 __new_data = __get_short_pointer();
3186 __p = __get_long_pointer();
3187 }
3188 else
3189 {
3190 if (__res_arg > __cap)
Howard Hinnantea8f7e12010-11-17 17:55:08 +00003191 __new_data = __alloc_traits::allocate(__alloc(), __res_arg+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003192 else
3193 {
3194 #ifndef _LIBCPP_NO_EXCEPTIONS
3195 try
3196 {
Howard Hinnant3b6579a2010-08-22 00:02:43 +00003197 #endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantea8f7e12010-11-17 17:55:08 +00003198 __new_data = __alloc_traits::allocate(__alloc(), __res_arg+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003199 #ifndef _LIBCPP_NO_EXCEPTIONS
3200 }
3201 catch (...)
3202 {
3203 return;
3204 }
Howard Hinnant3b6579a2010-08-22 00:02:43 +00003205 #else // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantd17880b2013-06-28 16:59:19 +00003206 if (__new_data == nullptr)
Howard Hinnantc51e1022010-05-11 19:42:16 +00003207 return;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00003208 #endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantc51e1022010-05-11 19:42:16 +00003209 }
3210 __now_long = true;
3211 __was_long = __is_long();
3212 __p = __get_pointer();
3213 }
Eric Fiselierc1b87a72019-11-16 17:13:26 -05003214 traits_type::copy(_VSTD::__to_address(__new_data),
3215 _VSTD::__to_address(__p), size()+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003216 if (__was_long)
Howard Hinnantea8f7e12010-11-17 17:55:08 +00003217 __alloc_traits::deallocate(__alloc(), __p, __cap+1);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003218 if (__now_long)
3219 {
3220 __set_long_cap(__res_arg+1);
3221 __set_long_size(__sz);
3222 __set_long_pointer(__new_data);
3223 }
3224 else
3225 __set_short_size(__sz);
3226 __invalidate_all_iterators();
3227 }
3228}
3229
3230template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003231inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003232typename basic_string<_CharT, _Traits, _Allocator>::const_reference
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003233basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003234{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003235 _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003236 return *(data() + __pos);
3237}
3238
3239template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003240inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003241typename basic_string<_CharT, _Traits, _Allocator>::reference
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003242basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003243{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003244 _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003245 return *(__get_pointer() + __pos);
3246}
3247
3248template <class _CharT, class _Traits, class _Allocator>
3249typename basic_string<_CharT, _Traits, _Allocator>::const_reference
3250basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const
3251{
3252 if (__n >= size())
3253 this->__throw_out_of_range();
3254 return (*this)[__n];
3255}
3256
3257template <class _CharT, class _Traits, class _Allocator>
3258typename basic_string<_CharT, _Traits, _Allocator>::reference
3259basic_string<_CharT, _Traits, _Allocator>::at(size_type __n)
3260{
3261 if (__n >= size())
3262 this->__throw_out_of_range();
3263 return (*this)[__n];
3264}
3265
3266template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003267inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003268typename basic_string<_CharT, _Traits, _Allocator>::reference
Marshall Clow05cf6692019-03-19 03:30:07 +00003269basic_string<_CharT, _Traits, _Allocator>::front() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003270{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003271 _LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003272 return *__get_pointer();
3273}
3274
3275template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003276inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003277typename basic_string<_CharT, _Traits, _Allocator>::const_reference
Marshall Clow05cf6692019-03-19 03:30:07 +00003278basic_string<_CharT, _Traits, _Allocator>::front() const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003279{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003280 _LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003281 return *data();
3282}
3283
3284template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003285inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003286typename basic_string<_CharT, _Traits, _Allocator>::reference
Marshall Clow05cf6692019-03-19 03:30:07 +00003287basic_string<_CharT, _Traits, _Allocator>::back() _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003288{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003289 _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003290 return *(__get_pointer() + size() - 1);
3291}
3292
3293template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003294inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003295typename basic_string<_CharT, _Traits, _Allocator>::const_reference
Marshall Clow05cf6692019-03-19 03:30:07 +00003296basic_string<_CharT, _Traits, _Allocator>::back() const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003297{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003298 _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003299 return *(data() + size() - 1);
3300}
3301
3302template <class _CharT, class _Traits, class _Allocator>
3303typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003304basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const
Howard Hinnantc51e1022010-05-11 19:42:16 +00003305{
3306 size_type __sz = size();
3307 if (__pos > __sz)
3308 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003309 size_type __rlen = _VSTD::min(__n, __sz - __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003310 traits_type::copy(__s, data() + __pos, __rlen);
3311 return __rlen;
3312}
3313
3314template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003315inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003316basic_string<_CharT, _Traits, _Allocator>
3317basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const
3318{
3319 return basic_string(*this, __pos, __n, __alloc());
3320}
3321
3322template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003323inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003324void
3325basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
Marshall Clow8982dcd2015-07-13 20:04:56 +00003326#if _LIBCPP_STD_VER >= 14
Eric Fiselier873b8d32019-03-18 21:50:12 +00003327 _NOEXCEPT
Marshall Clow8982dcd2015-07-13 20:04:56 +00003328#else
Eric Fiselier873b8d32019-03-18 21:50:12 +00003329 _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
Marshall Clow8982dcd2015-07-13 20:04:56 +00003330 __is_nothrow_swappable<allocator_type>::value)
3331#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00003332{
Howard Hinnant8ea98242013-08-23 17:37:05 +00003333#if _LIBCPP_DEBUG_LEVEL >= 2
3334 if (!__is_long())
3335 __get_db()->__invalidate_all(this);
3336 if (!__str.__is_long())
3337 __get_db()->__invalidate_all(&__str);
3338 __get_db()->swap(this, &__str);
3339#endif
Eric Fiselier9bf691f2016-12-28 05:53:01 +00003340 _LIBCPP_ASSERT(
3341 __alloc_traits::propagate_on_container_swap::value ||
3342 __alloc_traits::is_always_equal::value ||
3343 __alloc() == __str.__alloc(), "swapping non-equal allocators");
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003344 _VSTD::swap(__r_.first(), __str.__r_.first());
Marshall Clow8982dcd2015-07-13 20:04:56 +00003345 __swap_allocator(__alloc(), __str.__alloc());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003346}
3347
3348// find
3349
3350template <class _Traits>
3351struct _LIBCPP_HIDDEN __traits_eq
3352{
3353 typedef typename _Traits::char_type char_type;
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003354 _LIBCPP_INLINE_VISIBILITY
3355 bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT
3356 {return _Traits::eq(__x, __y);}
Howard Hinnantc51e1022010-05-11 19:42:16 +00003357};
3358
3359template<class _CharT, class _Traits, class _Allocator>
3360typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003361basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003362 size_type __pos,
3363 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003364{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003365 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003366 return __str_find<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003367 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003368}
3369
3370template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003371inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003372typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003373basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
3374 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003375{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003376 return __str_find<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003377 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003378}
3379
3380template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003381template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003382_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003383<
3384 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3385 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003386>
Marshall Clowe46031a2018-07-02 18:41:15 +00003387basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t,
3388 size_type __pos) const
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003389{
Marshall Clowe46031a2018-07-02 18:41:15 +00003390 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003391 return __str_find<value_type, size_type, traits_type, npos>
3392 (data(), size(), __sv.data(), __pos, __sv.size());
3393}
3394
3395template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003396inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003397typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003398basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003399 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003400{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003401 _LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003402 return __str_find<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003403 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003404}
3405
3406template<class _CharT, class _Traits, class _Allocator>
3407typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003408basic_string<_CharT, _Traits, _Allocator>::find(value_type __c,
3409 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003410{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003411 return __str_find<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003412 (data(), size(), __c, __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003413}
3414
3415// rfind
3416
3417template<class _CharT, class _Traits, class _Allocator>
3418typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003419basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003420 size_type __pos,
3421 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003422{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003423 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003424 return __str_rfind<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003425 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003426}
3427
3428template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003429inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003430typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003431basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
3432 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003433{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003434 return __str_rfind<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003435 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003436}
3437
3438template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003439template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003440_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003441<
3442 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3443 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003444>
Marshall Clowe46031a2018-07-02 18:41:15 +00003445basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t,
3446 size_type __pos) const
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003447{
Marshall Clowe46031a2018-07-02 18:41:15 +00003448 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003449 return __str_rfind<value_type, size_type, traits_type, npos>
3450 (data(), size(), __sv.data(), __pos, __sv.size());
3451}
3452
3453template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003454inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003455typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003456basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003457 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003458{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003459 _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003460 return __str_rfind<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003461 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003462}
3463
3464template<class _CharT, class _Traits, class _Allocator>
3465typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003466basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c,
3467 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003468{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003469 return __str_rfind<value_type, size_type, traits_type, npos>
Marshall Clowc527b6e2014-06-02 02:22:49 +00003470 (data(), size(), __c, __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003471}
3472
3473// find_first_of
3474
3475template<class _CharT, class _Traits, class _Allocator>
3476typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003477basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003478 size_type __pos,
3479 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003480{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003481 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003482 return __str_find_first_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003483 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003484}
3485
3486template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003487inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003488typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003489basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str,
3490 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003491{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003492 return __str_find_first_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003493 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003494}
3495
3496template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003497template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003498_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003499<
3500 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3501 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003502>
Marshall Clowe46031a2018-07-02 18:41:15 +00003503basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t,
3504 size_type __pos) const
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003505{
Marshall Clowe46031a2018-07-02 18:41:15 +00003506 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003507 return __str_find_first_of<value_type, size_type, traits_type, npos>
3508 (data(), size(), __sv.data(), __pos, __sv.size());
3509}
3510
3511template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003512inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003513typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003514basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003515 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003516{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003517 _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003518 return __str_find_first_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003519 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003520}
3521
3522template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003523inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003524typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003525basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
3526 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003527{
3528 return find(__c, __pos);
3529}
3530
3531// find_last_of
3532
3533template<class _CharT, class _Traits, class _Allocator>
3534typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003535basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003536 size_type __pos,
3537 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003538{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003539 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003540 return __str_find_last_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003541 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003542}
3543
3544template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003545inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003546typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003547basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str,
3548 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003549{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003550 return __str_find_last_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003551 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003552}
3553
3554template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003555template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003556_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003557<
3558 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3559 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003560>
Marshall Clowe46031a2018-07-02 18:41:15 +00003561basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t,
3562 size_type __pos) const
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003563{
Marshall Clowe46031a2018-07-02 18:41:15 +00003564 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003565 return __str_find_last_of<value_type, size_type, traits_type, npos>
3566 (data(), size(), __sv.data(), __pos, __sv.size());
3567}
3568
3569template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003570inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003571typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003572basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003573 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003574{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003575 _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003576 return __str_find_last_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003577 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003578}
3579
3580template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003581inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003582typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003583basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
3584 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003585{
3586 return rfind(__c, __pos);
3587}
3588
3589// find_first_not_of
3590
3591template<class _CharT, class _Traits, class _Allocator>
3592typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003593basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003594 size_type __pos,
3595 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003596{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003597 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003598 return __str_find_first_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003599 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003600}
3601
3602template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003603inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003604typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003605basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str,
3606 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003607{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003608 return __str_find_first_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003609 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003610}
3611
3612template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003613template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003614_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003615<
3616 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3617 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003618>
Marshall Clowe46031a2018-07-02 18:41:15 +00003619basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t,
3620 size_type __pos) const
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003621{
Marshall Clowe46031a2018-07-02 18:41:15 +00003622 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003623 return __str_find_first_not_of<value_type, size_type, traits_type, npos>
3624 (data(), size(), __sv.data(), __pos, __sv.size());
3625}
3626
3627template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003628inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003629typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003630basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003631 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003632{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003633 _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003634 return __str_find_first_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003635 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003636}
3637
3638template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003639inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003640typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003641basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
3642 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003643{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003644 return __str_find_first_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003645 (data(), size(), __c, __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003646}
3647
3648// find_last_not_of
3649
3650template<class _CharT, class _Traits, class _Allocator>
3651typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003652basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003653 size_type __pos,
3654 size_type __n) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003655{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003656 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003657 return __str_find_last_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003658 (data(), size(), __s, __pos, __n);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003659}
3660
3661template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003662inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003663typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003664basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str,
3665 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003666{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003667 return __str_find_last_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003668 (data(), size(), __str.data(), __pos, __str.size());
Howard Hinnantc51e1022010-05-11 19:42:16 +00003669}
3670
3671template<class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003672template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003673_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003674<
3675 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3676 typename basic_string<_CharT, _Traits, _Allocator>::size_type
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003677>
Marshall Clowe46031a2018-07-02 18:41:15 +00003678basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t,
3679 size_type __pos) const
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003680{
Marshall Clowe46031a2018-07-02 18:41:15 +00003681 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003682 return __str_find_last_not_of<value_type, size_type, traits_type, npos>
3683 (data(), size(), __sv.data(), __pos, __sv.size());
3684}
3685
3686template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003687inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003688typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantd17880b2013-06-28 16:59:19 +00003689basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003690 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003691{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003692 _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr");
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003693 return __str_find_last_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003694 (data(), size(), __s, __pos, traits_type::length(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003695}
3696
3697template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003698inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003699typename basic_string<_CharT, _Traits, _Allocator>::size_type
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003700basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
3701 size_type __pos) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003702{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003703 return __str_find_last_not_of<value_type, size_type, traits_type, npos>
Marshall Clow4bc2be22014-02-16 01:57:26 +00003704 (data(), size(), __c, __pos);
Howard Hinnantc51e1022010-05-11 19:42:16 +00003705}
3706
3707// compare
3708
3709template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003710template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003711_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003712<
3713 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3714 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003715>
Marshall Clowe46031a2018-07-02 18:41:15 +00003716basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const
Howard Hinnantc51e1022010-05-11 19:42:16 +00003717{
Marshall Clowe46031a2018-07-02 18:41:15 +00003718 __self_view __sv = __t;
Howard Hinnantb0485532011-07-24 21:45:06 +00003719 size_t __lhs_sz = size();
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003720 size_t __rhs_sz = __sv.size();
3721 int __result = traits_type::compare(data(), __sv.data(),
Howard Hinnantb0485532011-07-24 21:45:06 +00003722 _VSTD::min(__lhs_sz, __rhs_sz));
3723 if (__result != 0)
3724 return __result;
3725 if (__lhs_sz < __rhs_sz)
3726 return -1;
3727 if (__lhs_sz > __rhs_sz)
3728 return 1;
3729 return 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003730}
3731
3732template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003733inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003734int
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003735basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003736{
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003737 return compare(__self_view(__str));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003738}
3739
3740template <class _CharT, class _Traits, class _Allocator>
3741int
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003742basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3743 size_type __n1,
Howard Hinnantd17880b2013-06-28 16:59:19 +00003744 const value_type* __s,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003745 size_type __n2) const
Howard Hinnantc51e1022010-05-11 19:42:16 +00003746{
Alp Tokerb8a95f52014-05-15 11:27:39 +00003747 _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr");
Howard Hinnantc51e1022010-05-11 19:42:16 +00003748 size_type __sz = size();
3749 if (__pos1 > __sz || __n2 == npos)
3750 this->__throw_out_of_range();
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00003751 size_type __rlen = _VSTD::min(__n1, __sz - __pos1);
3752 int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2));
Howard Hinnantc51e1022010-05-11 19:42:16 +00003753 if (__r == 0)
3754 {
3755 if (__rlen < __n2)
3756 __r = -1;
3757 else if (__rlen > __n2)
3758 __r = 1;
3759 }
3760 return __r;
3761}
3762
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003763template <class _CharT, class _Traits, class _Allocator>
Marshall Clowe46031a2018-07-02 18:41:15 +00003764template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003765_EnableIf
Marshall Clowe46031a2018-07-02 18:41:15 +00003766<
3767 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
3768 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003769>
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003770basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3771 size_type __n1,
Marshall Clowe46031a2018-07-02 18:41:15 +00003772 const _Tp& __t) const
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003773{
Marshall Clowe46031a2018-07-02 18:41:15 +00003774 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003775 return compare(__pos1, __n1, __sv.data(), __sv.size());
3776}
3777
3778template <class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003779inline
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003780int
3781basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3782 size_type __n1,
3783 const basic_string& __str) const
3784{
3785 return compare(__pos1, __n1, __str.data(), __str.size());
3786}
3787
3788template <class _CharT, class _Traits, class _Allocator>
Marshall Clow82513342016-09-24 22:45:42 +00003789template <class _Tp>
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003790_EnableIf
Marshall Clow82513342016-09-24 22:45:42 +00003791<
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003792 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value
3793 && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value,
Marshall Clowb7db4972017-11-15 20:02:27 +00003794 int
Eric Fiselierc522ceb2020-01-15 16:57:08 -05003795>
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003796basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3797 size_type __n1,
Marshall Clow82513342016-09-24 22:45:42 +00003798 const _Tp& __t,
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003799 size_type __pos2,
3800 size_type __n2) const
3801{
Marshall Clow82513342016-09-24 22:45:42 +00003802 __self_view __sv = __t;
Marshall Clowdf63a6d2016-07-21 05:31:24 +00003803 return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
3804}
3805
3806template <class _CharT, class _Traits, class _Allocator>
3807int
3808basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3809 size_type __n1,
3810 const basic_string& __str,
3811 size_type __pos2,
3812 size_type __n2) const
3813{
3814 return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);
3815}
3816
3817template <class _CharT, class _Traits, class _Allocator>
3818int
3819basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT
3820{
3821 _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
3822 return compare(0, npos, __s, traits_type::length(__s));
3823}
3824
3825template <class _CharT, class _Traits, class _Allocator>
3826int
3827basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
3828 size_type __n1,
3829 const value_type* __s) const
3830{
3831 _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
3832 return compare(__pos1, __n1, __s, traits_type::length(__s));
3833}
3834
Howard Hinnantc51e1022010-05-11 19:42:16 +00003835// __invariants
3836
3837template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003838inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00003839bool
3840basic_string<_CharT, _Traits, _Allocator>::__invariants() const
3841{
3842 if (size() > capacity())
3843 return false;
3844 if (capacity() < __min_cap - 1)
3845 return false;
3846 if (data() == 0)
3847 return false;
3848 if (data()[size()] != value_type(0))
3849 return false;
3850 return true;
3851}
3852
Vedant Kumar55e007e2018-03-08 21:15:26 +00003853// __clear_and_shrink
3854
3855template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00003856inline
Louis Dionne173f29e2019-05-29 16:01:36 +00003857void
Marshall Clowe60a7182018-05-29 17:04:37 +00003858basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
Vedant Kumar55e007e2018-03-08 21:15:26 +00003859{
3860 clear();
3861 if(__is_long())
3862 {
3863 __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
3864 __set_long_cap(0);
3865 __set_short_size(0);
3866 }
Louis Dionne173f29e2019-05-29 16:01:36 +00003867}
Vedant Kumar55e007e2018-03-08 21:15:26 +00003868
Howard Hinnantc51e1022010-05-11 19:42:16 +00003869// operator==
3870
3871template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003872inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003873bool
3874operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003875 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003876{
Howard Hinnantaaeb1132013-04-22 23:55:13 +00003877 size_t __lhs_sz = __lhs.size();
3878 return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(),
3879 __rhs.data(),
3880 __lhs_sz) == 0;
3881}
3882
3883template<class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003884inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaaeb1132013-04-22 23:55:13 +00003885bool
3886operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
3887 const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
3888{
3889 size_t __lhs_sz = __lhs.size();
3890 if (__lhs_sz != __rhs.size())
3891 return false;
3892 const char* __lp = __lhs.data();
3893 const char* __rp = __rhs.data();
3894 if (__lhs.__is_long())
3895 return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0;
3896 for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp)
3897 if (*__lp != *__rp)
3898 return false;
3899 return true;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003900}
3901
3902template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003903inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003904bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003905operator==(const _CharT* __lhs,
3906 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003907{
Eric Fiselier0cafa3f2015-08-28 03:02:37 +00003908 typedef basic_string<_CharT, _Traits, _Allocator> _String;
3909 _LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr");
3910 size_t __lhs_len = _Traits::length(__lhs);
3911 if (__lhs_len != __rhs.size()) return false;
3912 return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003913}
3914
Howard Hinnantc51e1022010-05-11 19:42:16 +00003915template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003916inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003917bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003918operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
3919 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003920{
Eric Fiselier0cafa3f2015-08-28 03:02:37 +00003921 typedef basic_string<_CharT, _Traits, _Allocator> _String;
3922 _LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
3923 size_t __rhs_len = _Traits::length(__rhs);
3924 if (__rhs_len != __lhs.size()) return false;
3925 return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003926}
3927
Howard Hinnant3b6579a2010-08-22 00:02:43 +00003928template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003929inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003930bool
3931operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003932 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003933{
3934 return !(__lhs == __rhs);
3935}
3936
3937template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003938inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003939bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003940operator!=(const _CharT* __lhs,
3941 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003942{
3943 return !(__lhs == __rhs);
3944}
3945
3946template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003947inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003948bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003949operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
3950 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003951{
3952 return !(__lhs == __rhs);
3953}
3954
3955// operator<
3956
3957template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003958inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003959bool
3960operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003961 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003962{
Howard Hinnanta2660c12011-07-24 15:07:21 +00003963 return __lhs.compare(__rhs) < 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003964}
3965
3966template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003967inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003968bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003969operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
3970 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003971{
Howard Hinnanta2660c12011-07-24 15:07:21 +00003972 return __lhs.compare(__rhs) < 0;
Howard Hinnantc51e1022010-05-11 19:42:16 +00003973}
3974
3975template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003976inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003977bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003978operator< (const _CharT* __lhs,
3979 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003980{
3981 return __rhs.compare(__lhs) > 0;
3982}
3983
Howard Hinnantc51e1022010-05-11 19:42:16 +00003984// operator>
3985
3986template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003987inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003988bool
3989operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003990 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00003991{
3992 return __rhs < __lhs;
3993}
3994
3995template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00003996inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00003997bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00003998operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
3999 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004000{
4001 return __rhs < __lhs;
4002}
4003
4004template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004005inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004006bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004007operator> (const _CharT* __lhs,
4008 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004009{
4010 return __rhs < __lhs;
4011}
4012
4013// operator<=
4014
4015template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004016inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004017bool
4018operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004019 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004020{
4021 return !(__rhs < __lhs);
4022}
4023
4024template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004025inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004026bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004027operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
4028 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004029{
4030 return !(__rhs < __lhs);
4031}
4032
4033template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004034inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004035bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004036operator<=(const _CharT* __lhs,
4037 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004038{
4039 return !(__rhs < __lhs);
4040}
4041
4042// operator>=
4043
4044template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004045inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004046bool
4047operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004048 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004049{
4050 return !(__lhs < __rhs);
4051}
4052
4053template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004054inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004055bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004056operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
4057 const _CharT* __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004058{
4059 return !(__lhs < __rhs);
4060}
4061
4062template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004063inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004064bool
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004065operator>=(const _CharT* __lhs,
4066 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00004067{
4068 return !(__lhs < __rhs);
4069}
4070
4071// operator +
4072
4073template<class _CharT, class _Traits, class _Allocator>
4074basic_string<_CharT, _Traits, _Allocator>
4075operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
4076 const basic_string<_CharT, _Traits, _Allocator>& __rhs)
4077{
4078 basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
4079 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
4080 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
4081 __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
4082 __r.append(__rhs.data(), __rhs_sz);
4083 return __r;
4084}
4085
4086template<class _CharT, class _Traits, class _Allocator>
4087basic_string<_CharT, _Traits, _Allocator>
4088operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs)
4089{
4090 basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
4091 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = _Traits::length(__lhs);
4092 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
4093 __r.__init(__lhs, __lhs_sz, __lhs_sz + __rhs_sz);
4094 __r.append(__rhs.data(), __rhs_sz);
4095 return __r;
4096}
4097
4098template<class _CharT, class _Traits, class _Allocator>
4099basic_string<_CharT, _Traits, _Allocator>
4100operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs)
4101{
4102 basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
4103 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
4104 __r.__init(&__lhs, 1, 1 + __rhs_sz);
4105 __r.append(__rhs.data(), __rhs_sz);
4106 return __r;
4107}
4108
4109template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierbea70602018-11-26 22:51:35 +00004110inline
Howard Hinnantc51e1022010-05-11 19:42:16 +00004111basic_string<_CharT, _Traits, _Allocator>
4112operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs)
4113{
4114 basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
4115 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
4116 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = _Traits::length(__rhs);
4117 __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
4118 __r.append(__rhs, __rhs_sz);
4119 return __r;
4120}
4121
4122template<class _CharT, class _Traits, class _Allocator>
4123basic_string<_CharT, _Traits, _Allocator>
4124operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
4125{
4126 basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
4127 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
4128 __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + 1);
4129 __r.push_back(__rhs);
4130 return __r;
4131}
4132
Eric Fiselierfc92be82017-04-19 00:28:44 +00004133#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00004134
4135template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004136inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004137basic_string<_CharT, _Traits, _Allocator>
4138operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs)
4139{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004140 return _VSTD::move(__lhs.append(__rhs));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004141}
4142
4143template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004144inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004145basic_string<_CharT, _Traits, _Allocator>
4146operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
4147{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004148 return _VSTD::move(__rhs.insert(0, __lhs));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004149}
4150
4151template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004152inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004153basic_string<_CharT, _Traits, _Allocator>
4154operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
4155{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004156 return _VSTD::move(__lhs.append(__rhs));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004157}
4158
4159template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004160inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004161basic_string<_CharT, _Traits, _Allocator>
4162operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
4163{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004164 return _VSTD::move(__rhs.insert(0, __lhs));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004165}
4166
4167template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004168inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004169basic_string<_CharT, _Traits, _Allocator>
4170operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
4171{
4172 __rhs.insert(__rhs.begin(), __lhs);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004173 return _VSTD::move(__rhs);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004174}
4175
4176template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004177inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004178basic_string<_CharT, _Traits, _Allocator>
4179operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs)
4180{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004181 return _VSTD::move(__lhs.append(__rhs));
Howard Hinnantc51e1022010-05-11 19:42:16 +00004182}
4183
4184template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004185inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004186basic_string<_CharT, _Traits, _Allocator>
4187operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
4188{
4189 __lhs.push_back(__rhs);
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00004190 return _VSTD::move(__lhs);
Howard Hinnantc51e1022010-05-11 19:42:16 +00004191}
4192
Eric Fiselierfc92be82017-04-19 00:28:44 +00004193#endif // _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +00004194
4195// swap
4196
4197template<class _CharT, class _Traits, class _Allocator>
Howard Hinnantb8a8ca22013-10-04 22:09:00 +00004198inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00004199void
Howard Hinnantaeb17d82011-05-29 19:57:12 +00004200swap(basic_string<_CharT, _Traits, _Allocator>& __lhs,
Howard Hinnant3e276872011-06-03 18:40:47 +00004201 basic_string<_CharT, _Traits, _Allocator>& __rhs)
4202 _NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs)))
Howard Hinnantc51e1022010-05-11 19:42:16 +00004203{
4204 __lhs.swap(__rhs);
4205}
4206
Marshall Clow8732fed2018-12-11 04:35:44 +00004207#ifndef _LIBCPP_NO_HAS_CHAR8_T
4208typedef basic_string<char8_t> u8string;
4209#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00004210
Marshall Clow8732fed2018-12-11 04:35:44 +00004211#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
Howard Hinnantc51e1022010-05-11 19:42:16 +00004212typedef basic_string<char16_t> u16string;
4213typedef basic_string<char32_t> u32string;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00004214#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
Howard Hinnantc51e1022010-05-11 19:42:16 +00004215
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004216_LIBCPP_FUNC_VIS int stoi (const string& __str, size_t* __idx = 0, int __base = 10);
4217_LIBCPP_FUNC_VIS long stol (const string& __str, size_t* __idx = 0, int __base = 10);
4218_LIBCPP_FUNC_VIS unsigned long stoul (const string& __str, size_t* __idx = 0, int __base = 10);
4219_LIBCPP_FUNC_VIS long long stoll (const string& __str, size_t* __idx = 0, int __base = 10);
4220_LIBCPP_FUNC_VIS unsigned long long stoull(const string& __str, size_t* __idx = 0, int __base = 10);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004221
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004222_LIBCPP_FUNC_VIS float stof (const string& __str, size_t* __idx = 0);
4223_LIBCPP_FUNC_VIS double stod (const string& __str, size_t* __idx = 0);
4224_LIBCPP_FUNC_VIS long double stold(const string& __str, size_t* __idx = 0);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004225
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004226_LIBCPP_FUNC_VIS string to_string(int __val);
4227_LIBCPP_FUNC_VIS string to_string(unsigned __val);
4228_LIBCPP_FUNC_VIS string to_string(long __val);
4229_LIBCPP_FUNC_VIS string to_string(unsigned long __val);
4230_LIBCPP_FUNC_VIS string to_string(long long __val);
4231_LIBCPP_FUNC_VIS string to_string(unsigned long long __val);
4232_LIBCPP_FUNC_VIS string to_string(float __val);
4233_LIBCPP_FUNC_VIS string to_string(double __val);
4234_LIBCPP_FUNC_VIS string to_string(long double __val);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004235
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004236_LIBCPP_FUNC_VIS int stoi (const wstring& __str, size_t* __idx = 0, int __base = 10);
4237_LIBCPP_FUNC_VIS long stol (const wstring& __str, size_t* __idx = 0, int __base = 10);
4238_LIBCPP_FUNC_VIS unsigned long stoul (const wstring& __str, size_t* __idx = 0, int __base = 10);
4239_LIBCPP_FUNC_VIS long long stoll (const wstring& __str, size_t* __idx = 0, int __base = 10);
4240_LIBCPP_FUNC_VIS unsigned long long stoull(const wstring& __str, size_t* __idx = 0, int __base = 10);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004241
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004242_LIBCPP_FUNC_VIS float stof (const wstring& __str, size_t* __idx = 0);
4243_LIBCPP_FUNC_VIS double stod (const wstring& __str, size_t* __idx = 0);
4244_LIBCPP_FUNC_VIS long double stold(const wstring& __str, size_t* __idx = 0);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004245
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00004246_LIBCPP_FUNC_VIS wstring to_wstring(int __val);
4247_LIBCPP_FUNC_VIS wstring to_wstring(unsigned __val);
4248_LIBCPP_FUNC_VIS wstring to_wstring(long __val);
4249_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long __val);
4250_LIBCPP_FUNC_VIS wstring to_wstring(long long __val);
4251_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long long __val);
4252_LIBCPP_FUNC_VIS wstring to_wstring(float __val);
4253_LIBCPP_FUNC_VIS wstring to_wstring(double __val);
4254_LIBCPP_FUNC_VIS wstring to_wstring(long double __val);
Howard Hinnanta5f4f8e2010-06-02 18:20:39 +00004255
Howard Hinnantc51e1022010-05-11 19:42:16 +00004256template<class _CharT, class _Traits, class _Allocator>
Eric Fiselierc9fdaf12020-01-15 17:02:17 -05004257_LIBCPP_FUNC_VIS
4258const typename basic_string<_CharT, _Traits, _Allocator>::size_type
4259 basic_string<_CharT, _Traits, _Allocator>::npos;
Howard Hinnantc51e1022010-05-11 19:42:16 +00004260
Marshall Clow851b9ec2019-05-20 21:56:51 +00004261template <class _CharT, class _Allocator>
4262struct _LIBCPP_TEMPLATE_VIS
4263 hash<basic_string<_CharT, char_traits<_CharT>, _Allocator> >
4264 : public unary_function<
4265 basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t>
Howard Hinnantc51e1022010-05-11 19:42:16 +00004266{
4267 size_t
Marshall Clow851b9ec2019-05-20 21:56:51 +00004268 operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT
4269 { return __do_string_hash(__val.data(), __val.data() + __val.size()); }
Howard Hinnantc51e1022010-05-11 19:42:16 +00004270};
4271
Howard Hinnantc51e1022010-05-11 19:42:16 +00004272
Howard Hinnantdc095972011-07-18 15:51:59 +00004273template<class _CharT, class _Traits, class _Allocator>
4274basic_ostream<_CharT, _Traits>&
4275operator<<(basic_ostream<_CharT, _Traits>& __os,
4276 const basic_string<_CharT, _Traits, _Allocator>& __str);
4277
4278template<class _CharT, class _Traits, class _Allocator>
4279basic_istream<_CharT, _Traits>&
4280operator>>(basic_istream<_CharT, _Traits>& __is,
4281 basic_string<_CharT, _Traits, _Allocator>& __str);
4282
4283template<class _CharT, class _Traits, class _Allocator>
4284basic_istream<_CharT, _Traits>&
4285getline(basic_istream<_CharT, _Traits>& __is,
4286 basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
4287
4288template<class _CharT, class _Traits, class _Allocator>
4289inline _LIBCPP_INLINE_VISIBILITY
4290basic_istream<_CharT, _Traits>&
4291getline(basic_istream<_CharT, _Traits>& __is,
4292 basic_string<_CharT, _Traits, _Allocator>& __str);
4293
Eric Fiselierfc92be82017-04-19 00:28:44 +00004294#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantdc095972011-07-18 15:51:59 +00004295
4296template<class _CharT, class _Traits, class _Allocator>
4297inline _LIBCPP_INLINE_VISIBILITY
4298basic_istream<_CharT, _Traits>&
4299getline(basic_istream<_CharT, _Traits>&& __is,
4300 basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
4301
4302template<class _CharT, class _Traits, class _Allocator>
4303inline _LIBCPP_INLINE_VISIBILITY
4304basic_istream<_CharT, _Traits>&
4305getline(basic_istream<_CharT, _Traits>&& __is,
4306 basic_string<_CharT, _Traits, _Allocator>& __str);
4307
Eric Fiselierfc92be82017-04-19 00:28:44 +00004308#endif // _LIBCPP_CXX03_LANG
Howard Hinnantdc095972011-07-18 15:51:59 +00004309
Marshall Clow29b53f22018-12-14 18:49:35 +00004310#if _LIBCPP_STD_VER > 17
4311template<class _CharT, class _Traits, class _Allocator, class _Up>
4312inline _LIBCPP_INLINE_VISIBILITY
4313void erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v)
4314{ __str.erase(_VSTD::remove(__str.begin(), __str.end(), __v), __str.end()); }
4315
4316template<class _CharT, class _Traits, class _Allocator, class _Predicate>
4317inline _LIBCPP_INLINE_VISIBILITY
4318void erase_if(basic_string<_CharT, _Traits, _Allocator>& __str, _Predicate __pred)
4319{ __str.erase(_VSTD::remove_if(__str.begin(), __str.end(), __pred), __str.end()); }
4320#endif
4321
Howard Hinnant8ea98242013-08-23 17:37:05 +00004322#if _LIBCPP_DEBUG_LEVEL >= 2
4323
4324template<class _CharT, class _Traits, class _Allocator>
4325bool
4326basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const
4327{
Eric Fiselierc1b87a72019-11-16 17:13:26 -05004328 return this->data() <= _VSTD::__to_address(__i->base()) &&
4329 _VSTD::__to_address(__i->base()) < this->data() + this->size();
Howard Hinnant8ea98242013-08-23 17:37:05 +00004330}
4331
4332template<class _CharT, class _Traits, class _Allocator>
4333bool
4334basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const
4335{
Eric Fiselierc1b87a72019-11-16 17:13:26 -05004336 return this->data() < _VSTD::__to_address(__i->base()) &&
4337 _VSTD::__to_address(__i->base()) <= this->data() + this->size();
Howard Hinnant8ea98242013-08-23 17:37:05 +00004338}
4339
4340template<class _CharT, class _Traits, class _Allocator>
4341bool
4342basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
4343{
Eric Fiselierc1b87a72019-11-16 17:13:26 -05004344 const value_type* __p = _VSTD::__to_address(__i->base()) + __n;
Howard Hinnant8ea98242013-08-23 17:37:05 +00004345 return this->data() <= __p && __p <= this->data() + this->size();
4346}
4347
4348template<class _CharT, class _Traits, class _Allocator>
4349bool
4350basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
4351{
Eric Fiselierc1b87a72019-11-16 17:13:26 -05004352 const value_type* __p = _VSTD::__to_address(__i->base()) + __n;
Howard Hinnant8ea98242013-08-23 17:37:05 +00004353 return this->data() <= __p && __p < this->data() + this->size();
4354}
4355
4356#endif // _LIBCPP_DEBUG_LEVEL >= 2
4357
Martijn Vels1e63ba02020-02-19 16:27:50 -05004358#if defined(_LIBCPP_ABI_UNSTABLE) || _LIBCPP_ABI_VERSION >= 2
4359_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)
4360_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)
4361#else
4362_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)
4363_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)
4364#endif
Shoaib Meenai6eb5f112017-06-29 02:52:46 +00004365
Louis Dionne173f29e2019-05-29 16:01:36 +00004366#if _LIBCPP_STD_VER > 11
Marshall Clowcba751f2013-07-23 17:05:24 +00004367// Literal suffixes for basic_string [basic.string.literals]
Marshall Clowac868372013-10-05 21:18:32 +00004368inline namespace literals
Marshall Clowcba751f2013-07-23 17:05:24 +00004369{
4370 inline namespace string_literals
4371 {
Howard Hinnant5c167562013-08-07 19:39:48 +00004372 inline _LIBCPP_INLINE_VISIBILITY
4373 basic_string<char> operator "" s( const char *__str, size_t __len )
4374 {
4375 return basic_string<char> (__str, __len);
4376 }
Marshall Clowcba751f2013-07-23 17:05:24 +00004377
Howard Hinnant5c167562013-08-07 19:39:48 +00004378 inline _LIBCPP_INLINE_VISIBILITY
4379 basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len )
4380 {
4381 return basic_string<wchar_t> (__str, __len);
4382 }
Marshall Clowcba751f2013-07-23 17:05:24 +00004383
Marshall Clow8732fed2018-12-11 04:35:44 +00004384#ifndef _LIBCPP_NO_HAS_CHAR8_T
4385 inline _LIBCPP_INLINE_VISIBILITY
4386 basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len) _NOEXCEPT
4387 {
4388 return basic_string<char8_t> (__str, __len);
4389 }
4390#endif
4391
Howard Hinnant5c167562013-08-07 19:39:48 +00004392 inline _LIBCPP_INLINE_VISIBILITY
4393 basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len )
4394 {
4395 return basic_string<char16_t> (__str, __len);
4396 }
Marshall Clowcba751f2013-07-23 17:05:24 +00004397
Howard Hinnant5c167562013-08-07 19:39:48 +00004398 inline _LIBCPP_INLINE_VISIBILITY
4399 basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
4400 {
4401 return basic_string<char32_t> (__str, __len);
4402 }
Marshall Clowcba751f2013-07-23 17:05:24 +00004403 }
4404}
4405#endif
4406
Howard Hinnantc51e1022010-05-11 19:42:16 +00004407_LIBCPP_END_NAMESPACE_STD
4408
Eric Fiselierf4433a32017-05-31 22:07:49 +00004409_LIBCPP_POP_MACROS
4410
Howard Hinnantc51e1022010-05-11 19:42:16 +00004411#endif // _LIBCPP_STRING