1 // -*- C++ -*- 2 //===--------------------------- string -----------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is distributed under the University of Illinois Open Source 7 // License. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP_STRING 12 #define _LIBCPP_STRING 13 14 /* 15 string synopsis 16 17 namespace std 18 { 19 20 template <class stateT> 21 class fpos 22 { 23 private: 24 stateT st; 25 public: 26 fpos(streamoff = streamoff()); 27 28 operator streamoff() const; 29 30 stateT state() const; 31 void state(stateT); 32 33 fpos& operator+=(streamoff); 34 fpos operator+ (streamoff) const; 35 fpos& operator-=(streamoff); 36 fpos operator- (streamoff) const; 37 }; 38 39 template <class stateT> streamoff operator-(const fpos<stateT>& x, const fpos<stateT>& y); 40 41 template <class stateT> bool operator==(const fpos<stateT>& x, const fpos<stateT>& y); 42 template <class stateT> bool operator!=(const fpos<stateT>& x, const fpos<stateT>& y); 43 44 template <class charT> 45 struct char_traits 46 { 47 typedef charT char_type; 48 typedef ... int_type; 49 typedef streamoff off_type; 50 typedef streampos pos_type; 51 typedef mbstate_t state_type; 52 53 static void assign(char_type& c1, const char_type& c2) noexcept; 54 static constexpr bool eq(char_type c1, char_type c2) noexcept; 55 static constexpr bool lt(char_type c1, char_type c2) noexcept; 56 57 static int compare(const char_type* s1, const char_type* s2, size_t n); 58 static size_t length(const char_type* s); 59 static const char_type* find(const char_type* s, size_t n, const char_type& a); 60 static char_type* move(char_type* s1, const char_type* s2, size_t n); 61 static char_type* copy(char_type* s1, const char_type* s2, size_t n); 62 static char_type* assign(char_type* s, size_t n, char_type a); 63 64 static constexpr int_type not_eof(int_type c) noexcept; 65 static constexpr char_type to_char_type(int_type c) noexcept; 66 static constexpr int_type to_int_type(char_type c) noexcept; 67 static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept; 68 static constexpr int_type eof() noexcept; 69 }; 70 71 template <> struct char_traits<char>; 72 template <> struct char_traits<wchar_t>; 73 74 template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > 75 class basic_string 76 { 77 public: 78 // types: 79 typedef traits traits_type; 80 typedef typename traits_type::char_type value_type; 81 typedef Allocator allocator_type; 82 typedef typename allocator_type::size_type size_type; 83 typedef typename allocator_type::difference_type difference_type; 84 typedef typename allocator_type::reference reference; 85 typedef typename allocator_type::const_reference const_reference; 86 typedef typename allocator_type::pointer pointer; 87 typedef typename allocator_type::const_pointer const_pointer; 88 typedef implementation-defined iterator; 89 typedef implementation-defined const_iterator; 90 typedef std::reverse_iterator<iterator> reverse_iterator; 91 typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 92 93 static const size_type npos = -1; 94 95 basic_string() 96 noexcept(is_nothrow_default_constructible<allocator_type>::value); 97 explicit basic_string(const allocator_type& a); 98 basic_string(const basic_string& str); 99 basic_string(basic_string&& str) 100 noexcept(is_nothrow_move_constructible<allocator_type>::value); 101 basic_string(const basic_string& str, size_type pos, 102 const allocator_type& a = allocator_type()); 103 basic_string(const basic_string& str, size_type pos, size_type n, 104 const Allocator& a = Allocator()); 105 template<class T> 106 basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator()); // C++17 107 explicit basic_string(const basic_string_view<charT, traits> sv, const Allocator& a = Allocator()); 108 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()); 110 basic_string(size_type n, value_type c, const allocator_type& a = allocator_type()); 111 template<class InputIterator> 112 basic_string(InputIterator begin, InputIterator end, 113 const allocator_type& a = allocator_type()); 114 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 120 operator basic_string_view<charT, traits>() const noexcept; 121 122 basic_string& operator=(const basic_string& str); 123 basic_string& operator=(basic_string_view<charT, traits> sv); 124 basic_string& operator=(basic_string&& str) 125 noexcept( 126 allocator_type::propagate_on_container_move_assignment::value || 127 allocator_type::is_always_equal::value ); // C++17 128 basic_string& operator=(const value_type* s); 129 basic_string& operator=(value_type c); 130 basic_string& operator=(initializer_list<value_type>); 131 132 iterator begin() noexcept; 133 const_iterator begin() const noexcept; 134 iterator end() noexcept; 135 const_iterator end() const noexcept; 136 137 reverse_iterator rbegin() noexcept; 138 const_reverse_iterator rbegin() const noexcept; 139 reverse_iterator rend() noexcept; 140 const_reverse_iterator rend() const noexcept; 141 142 const_iterator cbegin() const noexcept; 143 const_iterator cend() const noexcept; 144 const_reverse_iterator crbegin() const noexcept; 145 const_reverse_iterator crend() const noexcept; 146 147 size_type size() const noexcept; 148 size_type length() const noexcept; 149 size_type max_size() const noexcept; 150 size_type capacity() const noexcept; 151 152 void resize(size_type n, value_type c); 153 void resize(size_type n); 154 155 void reserve(size_type res_arg = 0); 156 void shrink_to_fit(); 157 void clear() noexcept; 158 bool empty() const noexcept; 159 160 const_reference operator[](size_type pos) const; 161 reference operator[](size_type pos); 162 163 const_reference at(size_type n) const; 164 reference at(size_type n); 165 166 basic_string& operator+=(const basic_string& str); 167 basic_string& operator+=(basic_string_view<charT, traits> sv); 168 basic_string& operator+=(const value_type* s); 169 basic_string& operator+=(value_type c); 170 basic_string& operator+=(initializer_list<value_type>); 171 172 basic_string& append(const basic_string& str); 173 basic_string& append(basic_string_view<charT, traits> sv); 174 basic_string& append(const basic_string& str, size_type pos, size_type n=npos); //C++14 175 template <class T> 176 basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17 177 basic_string& append(const value_type* s, size_type n); 178 basic_string& append(const value_type* s); 179 basic_string& append(size_type n, value_type c); 180 template<class InputIterator> 181 basic_string& append(InputIterator first, InputIterator last); 182 basic_string& append(initializer_list<value_type>); 183 184 void push_back(value_type c); 185 void pop_back(); 186 reference front(); 187 const_reference front() const; 188 reference back(); 189 const_reference back() const; 190 191 basic_string& assign(const basic_string& str); 192 basic_string& assign(basic_string_view<charT, traits> sv); 193 basic_string& assign(basic_string&& str); 194 basic_string& assign(const basic_string& str, size_type pos, size_type n=npos); // C++14 195 template <class T> 196 basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17 197 basic_string& assign(const value_type* s, size_type n); 198 basic_string& assign(const value_type* s); 199 basic_string& assign(size_type n, value_type c); 200 template<class InputIterator> 201 basic_string& assign(InputIterator first, InputIterator last); 202 basic_string& assign(initializer_list<value_type>); 203 204 basic_string& insert(size_type pos1, const basic_string& str); 205 basic_string& insert(size_type pos1, basic_string_view<charT, traits> sv); 206 basic_string& insert(size_type pos1, const basic_string& str, 207 size_type pos2, size_type n); 208 template <class T> 209 basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n); // C++17 210 basic_string& insert(size_type pos, const value_type* s, size_type n=npos); //C++14 211 basic_string& insert(size_type pos, const value_type* s); 212 basic_string& insert(size_type pos, size_type n, value_type c); 213 iterator insert(const_iterator p, value_type c); 214 iterator insert(const_iterator p, size_type n, value_type c); 215 template<class InputIterator> 216 iterator insert(const_iterator p, InputIterator first, InputIterator last); 217 iterator insert(const_iterator p, initializer_list<value_type>); 218 219 basic_string& erase(size_type pos = 0, size_type n = npos); 220 iterator erase(const_iterator position); 221 iterator erase(const_iterator first, const_iterator last); 222 223 basic_string& replace(size_type pos1, size_type n1, const basic_string& str); 224 basic_string& replace(size_type pos1, size_type n1, basic_string_view<charT, traits> sv); 225 basic_string& replace(size_type pos1, size_type n1, const basic_string& str, 226 size_type pos2, size_type n2=npos); // C++14 227 template <class T> 228 basic_string& replace(size_type pos1, size_type n1, const T& t, 229 size_type pos2, size_type n); // C++17 230 basic_string& replace(size_type pos, size_type n1, const value_type* s, size_type n2); 231 basic_string& replace(size_type pos, size_type n1, const value_type* s); 232 basic_string& replace(size_type pos, size_type n1, size_type n2, value_type c); 233 basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str); 234 basic_string& replace(const_iterator i1, const_iterator i2, basic_string_view<charT, traits> sv); 235 basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s, size_type n); 236 basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s); 237 basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c); 238 template<class InputIterator> 239 basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2); 240 basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>); 241 242 size_type copy(value_type* s, size_type n, size_type pos = 0) const; 243 basic_string substr(size_type pos = 0, size_type n = npos) const; 244 245 void swap(basic_string& str) 246 noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value || 247 allocator_traits<allocator_type>::is_always_equal::value); // C++17 248 249 const value_type* c_str() const noexcept; 250 const value_type* data() const noexcept; 251 value_type* data() noexcept; // C++17 252 253 allocator_type get_allocator() const noexcept; 254 255 size_type find(const basic_string& str, size_type pos = 0) const noexcept; 256 size_type find(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept; 257 size_type find(const value_type* s, size_type pos, size_type n) const noexcept; 258 size_type find(const value_type* s, size_type pos = 0) const noexcept; 259 size_type find(value_type c, size_type pos = 0) const noexcept; 260 261 size_type rfind(const basic_string& str, size_type pos = npos) const noexcept; 262 size_type rfind(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept; 263 size_type rfind(const value_type* s, size_type pos, size_type n) const noexcept; 264 size_type rfind(const value_type* s, size_type pos = npos) const noexcept; 265 size_type rfind(value_type c, size_type pos = npos) const noexcept; 266 267 size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept; 268 size_type find_first_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept; 269 size_type find_first_of(const value_type* s, size_type pos, size_type n) const noexcept; 270 size_type find_first_of(const value_type* s, size_type pos = 0) const noexcept; 271 size_type find_first_of(value_type c, size_type pos = 0) const noexcept; 272 273 size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept; 274 size_type find_last_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept; 275 size_type find_last_of(const value_type* s, size_type pos, size_type n) const noexcept; 276 size_type find_last_of(const value_type* s, size_type pos = npos) const noexcept; 277 size_type find_last_of(value_type c, size_type pos = npos) const noexcept; 278 279 size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept; 280 size_type find_first_not_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept; 281 size_type find_first_not_of(const value_type* s, size_type pos, size_type n) const noexcept; 282 size_type find_first_not_of(const value_type* s, size_type pos = 0) const noexcept; 283 size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept; 284 285 size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept; 286 size_type find_last_not_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept; 287 size_type find_last_not_of(const value_type* s, size_type pos, size_type n) const noexcept; 288 size_type find_last_not_of(const value_type* s, size_type pos = npos) const noexcept; 289 size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept; 290 291 int compare(const basic_string& str) const noexcept; 292 int compare(basic_string_view<charT, traits> sv) const noexcept; 293 int compare(size_type pos1, size_type n1, const basic_string& str) const; 294 int compare(size_type pos1, size_type n1, basic_string_view<charT, traits> sv) const; 295 int compare(size_type pos1, size_type n1, const basic_string& str, 296 size_type pos2, size_type n2=npos) const; // C++14 297 template <class T> 298 int compare(size_type pos1, size_type n1, const T& t, 299 size_type pos2, size_type n2=npos) const; // C++17 300 int compare(const value_type* s) const noexcept; 301 int compare(size_type pos1, size_type n1, const value_type* s) const; 302 int compare(size_type pos1, size_type n1, const value_type* s, size_type n2) const; 303 304 bool starts_with(basic_string_view<charT, traits> sv) const noexcept; // C++2a 305 bool starts_with(charT c) const noexcept; // C++2a 306 bool starts_with(const charT* s) const; // C++2a 307 bool ends_with(basic_string_view<charT, traits> sv) const noexcept; // C++2a 308 bool ends_with(charT c) const noexcept; // C++2a 309 bool ends_with(const charT* s) const; // C++2a 310 311 bool __invariants() const; 312 }; 313 314 template<class charT, class traits, class Allocator> 315 basic_string<charT, traits, Allocator> 316 operator+(const basic_string<charT, traits, Allocator>& lhs, 317 const basic_string<charT, traits, Allocator>& rhs); 318 319 template<class charT, class traits, class Allocator> 320 basic_string<charT, traits, Allocator> 321 operator+(const charT* lhs , const basic_string<charT,traits,Allocator>&rhs); 322 323 template<class charT, class traits, class Allocator> 324 basic_string<charT, traits, Allocator> 325 operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs); 326 327 template<class charT, class traits, class Allocator> 328 basic_string<charT, traits, Allocator> 329 operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs); 330 331 template<class charT, class traits, class Allocator> 332 basic_string<charT, traits, Allocator> 333 operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs); 334 335 template<class charT, class traits, class Allocator> 336 bool operator==(const basic_string<charT, traits, Allocator>& lhs, 337 const basic_string<charT, traits, Allocator>& rhs) noexcept; 338 339 template<class charT, class traits, class Allocator> 340 bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 341 342 template<class charT, class traits, class Allocator> 343 bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept; 344 345 template<class charT, class traits, class Allocator> 346 bool operator!=(const basic_string<charT,traits,Allocator>& lhs, 347 const basic_string<charT, traits, Allocator>& rhs) noexcept; 348 349 template<class charT, class traits, class Allocator> 350 bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 351 352 template<class charT, class traits, class Allocator> 353 bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 354 355 template<class charT, class traits, class Allocator> 356 bool operator< (const basic_string<charT, traits, Allocator>& lhs, 357 const basic_string<charT, traits, Allocator>& rhs) noexcept; 358 359 template<class charT, class traits, class Allocator> 360 bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 361 362 template<class charT, class traits, class Allocator> 363 bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 364 365 template<class charT, class traits, class Allocator> 366 bool operator> (const basic_string<charT, traits, Allocator>& lhs, 367 const basic_string<charT, traits, Allocator>& rhs) noexcept; 368 369 template<class charT, class traits, class Allocator> 370 bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 371 372 template<class charT, class traits, class Allocator> 373 bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 374 375 template<class charT, class traits, class Allocator> 376 bool operator<=(const basic_string<charT, traits, Allocator>& lhs, 377 const basic_string<charT, traits, Allocator>& rhs) noexcept; 378 379 template<class charT, class traits, class Allocator> 380 bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 381 382 template<class charT, class traits, class Allocator> 383 bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 384 385 template<class charT, class traits, class Allocator> 386 bool operator>=(const basic_string<charT, traits, Allocator>& lhs, 387 const basic_string<charT, traits, Allocator>& rhs) noexcept; 388 389 template<class charT, class traits, class Allocator> 390 bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 391 392 template<class charT, class traits, class Allocator> 393 bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 394 395 template<class charT, class traits, class Allocator> 396 void swap(basic_string<charT, traits, Allocator>& lhs, 397 basic_string<charT, traits, Allocator>& rhs) 398 noexcept(noexcept(lhs.swap(rhs))); 399 400 template<class charT, class traits, class Allocator> 401 basic_istream<charT, traits>& 402 operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str); 403 404 template<class charT, class traits, class Allocator> 405 basic_ostream<charT, traits>& 406 operator<<(basic_ostream<charT, traits>& os, const basic_string<charT, traits, Allocator>& str); 407 408 template<class charT, class traits, class Allocator> 409 basic_istream<charT, traits>& 410 getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str, 411 charT delim); 412 413 template<class charT, class traits, class Allocator> 414 basic_istream<charT, traits>& 415 getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str); 416 417 typedef basic_string<char> string; 418 typedef basic_string<wchar_t> wstring; 419 typedef basic_string<char16_t> u16string; 420 typedef basic_string<char32_t> u32string; 421 422 int stoi (const string& str, size_t* idx = 0, int base = 10); 423 long stol (const string& str, size_t* idx = 0, int base = 10); 424 unsigned long stoul (const string& str, size_t* idx = 0, int base = 10); 425 long long stoll (const string& str, size_t* idx = 0, int base = 10); 426 unsigned long long stoull(const string& str, size_t* idx = 0, int base = 10); 427 428 float stof (const string& str, size_t* idx = 0); 429 double stod (const string& str, size_t* idx = 0); 430 long double stold(const string& str, size_t* idx = 0); 431 432 string to_string(int val); 433 string to_string(unsigned val); 434 string to_string(long val); 435 string to_string(unsigned long val); 436 string to_string(long long val); 437 string to_string(unsigned long long val); 438 string to_string(float val); 439 string to_string(double val); 440 string to_string(long double val); 441 442 int stoi (const wstring& str, size_t* idx = 0, int base = 10); 443 long stol (const wstring& str, size_t* idx = 0, int base = 10); 444 unsigned long stoul (const wstring& str, size_t* idx = 0, int base = 10); 445 long long stoll (const wstring& str, size_t* idx = 0, int base = 10); 446 unsigned long long stoull(const wstring& str, size_t* idx = 0, int base = 10); 447 448 float stof (const wstring& str, size_t* idx = 0); 449 double stod (const wstring& str, size_t* idx = 0); 450 long double stold(const wstring& str, size_t* idx = 0); 451 452 wstring to_wstring(int val); 453 wstring to_wstring(unsigned val); 454 wstring to_wstring(long val); 455 wstring to_wstring(unsigned long val); 456 wstring to_wstring(long long val); 457 wstring to_wstring(unsigned long long val); 458 wstring to_wstring(float val); 459 wstring to_wstring(double val); 460 wstring to_wstring(long double val); 461 462 template <> struct hash<string>; 463 template <> struct hash<u16string>; 464 template <> struct hash<u32string>; 465 template <> struct hash<wstring>; 466 467 basic_string<char> operator "" s( const char *str, size_t len ); // C++14 468 basic_string<wchar_t> operator "" s( const wchar_t *str, size_t len ); // C++14 469 basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14 470 basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14 471 472 } // std 473 474 */ 475 476 #include <__config> 477 #include <string_view> 478 #include <iosfwd> 479 #include <cstring> 480 #include <cstdio> // For EOF. 481 #include <cwchar> 482 #include <algorithm> 483 #include <iterator> 484 #include <utility> 485 #include <memory> 486 #include <stdexcept> 487 #include <type_traits> 488 #include <initializer_list> 489 #include <__functional_base> 490 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS 491 #include <cstdint> 492 #endif 493 494 #include <__debug> 495 496 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 497 #pragma GCC system_header 498 #endif 499 500 _LIBCPP_PUSH_MACROS 501 #include <__undef_macros> 502 503 504 _LIBCPP_BEGIN_NAMESPACE_STD 505 506 // fpos 507 508 template <class _StateT> 509 class _LIBCPP_TEMPLATE_VIS fpos 510 { 511 private: 512 _StateT __st_; 513 streamoff __off_; 514 public: 515 _LIBCPP_INLINE_VISIBILITY fpos(streamoff __off = streamoff()) : __st_(), __off_(__off) {} 516 517 _LIBCPP_INLINE_VISIBILITY operator streamoff() const {return __off_;} 518 519 _LIBCPP_INLINE_VISIBILITY _StateT state() const {return __st_;} 520 _LIBCPP_INLINE_VISIBILITY void state(_StateT __st) {__st_ = __st;} 521 522 _LIBCPP_INLINE_VISIBILITY fpos& operator+=(streamoff __off) {__off_ += __off; return *this;} 523 _LIBCPP_INLINE_VISIBILITY fpos operator+ (streamoff __off) const {fpos __t(*this); __t += __off; return __t;} 524 _LIBCPP_INLINE_VISIBILITY fpos& operator-=(streamoff __off) {__off_ -= __off; return *this;} 525 _LIBCPP_INLINE_VISIBILITY fpos operator- (streamoff __off) const {fpos __t(*this); __t -= __off; return __t;} 526 }; 527 528 template <class _StateT> 529 inline _LIBCPP_INLINE_VISIBILITY 530 streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y) 531 {return streamoff(__x) - streamoff(__y);} 532 533 template <class _StateT> 534 inline _LIBCPP_INLINE_VISIBILITY 535 bool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y) 536 {return streamoff(__x) == streamoff(__y);} 537 538 template <class _StateT> 539 inline _LIBCPP_INLINE_VISIBILITY 540 bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y) 541 {return streamoff(__x) != streamoff(__y);} 542 543 // basic_string 544 545 template<class _CharT, class _Traits, class _Allocator> 546 basic_string<_CharT, _Traits, _Allocator> 547 operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, 548 const basic_string<_CharT, _Traits, _Allocator>& __y); 549 550 template<class _CharT, class _Traits, class _Allocator> 551 basic_string<_CharT, _Traits, _Allocator> 552 operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y); 553 554 template<class _CharT, class _Traits, class _Allocator> 555 basic_string<_CharT, _Traits, _Allocator> 556 operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y); 557 558 template<class _CharT, class _Traits, class _Allocator> 559 basic_string<_CharT, _Traits, _Allocator> 560 operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y); 561 562 template<class _CharT, class _Traits, class _Allocator> 563 basic_string<_CharT, _Traits, _Allocator> 564 operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y); 565 566 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&)) 567 568 template <bool> 569 class _LIBCPP_TEMPLATE_VIS __basic_string_common 570 { 571 protected: 572 _LIBCPP_NORETURN void __throw_length_error() const; 573 _LIBCPP_NORETURN void __throw_out_of_range() const; 574 }; 575 576 template <bool __b> 577 void 578 __basic_string_common<__b>::__throw_length_error() const 579 { 580 _VSTD::__throw_length_error("basic_string"); 581 } 582 583 template <bool __b> 584 void 585 __basic_string_common<__b>::__throw_out_of_range() const 586 { 587 _VSTD::__throw_out_of_range("basic_string"); 588 } 589 590 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __basic_string_common<true>) 591 592 #ifdef _LIBCPP_NO_EXCEPTIONS 593 template <class _Iter> 594 struct __libcpp_string_gets_noexcept_iterator_impl : public true_type {}; 595 #elif defined(_LIBCPP_HAS_NO_NOEXCEPT) 596 template <class _Iter> 597 struct __libcpp_string_gets_noexcept_iterator_impl : public false_type {}; 598 #else 599 template <class _Iter, bool = __is_forward_iterator<_Iter>::value> 600 struct __libcpp_string_gets_noexcept_iterator_impl : public _LIBCPP_BOOL_CONSTANT(( 601 noexcept(++(declval<_Iter&>())) && 602 is_nothrow_assignable<_Iter&, _Iter>::value && 603 noexcept(declval<_Iter>() == declval<_Iter>()) && 604 noexcept(*declval<_Iter>()) 605 )) {}; 606 607 template <class _Iter> 608 struct __libcpp_string_gets_noexcept_iterator_impl<_Iter, false> : public false_type {}; 609 #endif 610 611 612 template <class _Iter> 613 struct __libcpp_string_gets_noexcept_iterator 614 : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value || __libcpp_string_gets_noexcept_iterator_impl<_Iter>::value) {}; 615 616 template <class _CharT, class _Traits, class _Tp> 617 struct __can_be_converted_to_string_view : public _LIBCPP_BOOL_CONSTANT( 618 ( is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value && 619 !is_convertible<const _Tp&, const _CharT*>::value)) {}; 620 621 #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 622 623 template <class _CharT, size_t = sizeof(_CharT)> 624 struct __padding 625 { 626 unsigned char __xx[sizeof(_CharT)-1]; 627 }; 628 629 template <class _CharT> 630 struct __padding<_CharT, 1> 631 { 632 }; 633 634 #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 635 636 template<class _CharT, class _Traits, class _Allocator> 637 class _LIBCPP_TEMPLATE_VIS basic_string 638 : private __basic_string_common<true> 639 { 640 public: 641 typedef basic_string __self; 642 typedef basic_string_view<_CharT, _Traits> __self_view; 643 typedef _Traits traits_type; 644 typedef _CharT value_type; 645 typedef _Allocator allocator_type; 646 typedef allocator_traits<allocator_type> __alloc_traits; 647 typedef typename __alloc_traits::size_type size_type; 648 typedef typename __alloc_traits::difference_type difference_type; 649 typedef value_type& reference; 650 typedef const value_type& const_reference; 651 typedef typename __alloc_traits::pointer pointer; 652 typedef typename __alloc_traits::const_pointer const_pointer; 653 654 static_assert(is_trivial<value_type>::value, "Character type of basic_string must be trivial"); 655 static_assert((is_same<_CharT, typename traits_type::char_type>::value), 656 "traits_type::char_type must be the same type as CharT"); 657 static_assert((is_same<typename allocator_type::value_type, value_type>::value), 658 "Allocator::value_type must be same type as value_type"); 659 #if defined(_LIBCPP_RAW_ITERATORS) 660 typedef pointer iterator; 661 typedef const_pointer const_iterator; 662 #else // defined(_LIBCPP_RAW_ITERATORS) 663 typedef __wrap_iter<pointer> iterator; 664 typedef __wrap_iter<const_pointer> const_iterator; 665 #endif // defined(_LIBCPP_RAW_ITERATORS) 666 typedef _VSTD::reverse_iterator<iterator> reverse_iterator; 667 typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; 668 669 private: 670 671 #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 672 673 struct __long 674 { 675 pointer __data_; 676 size_type __size_; 677 size_type __cap_; 678 }; 679 680 #ifdef _LIBCPP_BIG_ENDIAN 681 static const size_type __short_mask = 0x01; 682 static const size_type __long_mask = 0x1ul; 683 #else // _LIBCPP_BIG_ENDIAN 684 static const size_type __short_mask = 0x80; 685 static const size_type __long_mask = ~(size_type(~0) >> 1); 686 #endif // _LIBCPP_BIG_ENDIAN 687 688 enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ? 689 (sizeof(__long) - 1)/sizeof(value_type) : 2}; 690 691 struct __short 692 { 693 value_type __data_[__min_cap]; 694 struct 695 : __padding<value_type> 696 { 697 unsigned char __size_; 698 }; 699 }; 700 701 #else 702 703 struct __long 704 { 705 size_type __cap_; 706 size_type __size_; 707 pointer __data_; 708 }; 709 710 #ifdef _LIBCPP_BIG_ENDIAN 711 static const size_type __short_mask = 0x80; 712 static const size_type __long_mask = ~(size_type(~0) >> 1); 713 #else // _LIBCPP_BIG_ENDIAN 714 static const size_type __short_mask = 0x01; 715 static const size_type __long_mask = 0x1ul; 716 #endif // _LIBCPP_BIG_ENDIAN 717 718 enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ? 719 (sizeof(__long) - 1)/sizeof(value_type) : 2}; 720 721 struct __short 722 { 723 union 724 { 725 unsigned char __size_; 726 value_type __lx; 727 }; 728 value_type __data_[__min_cap]; 729 }; 730 731 #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 732 733 union __ulx{__long __lx; __short __lxx;}; 734 735 enum {__n_words = sizeof(__ulx) / sizeof(size_type)}; 736 737 struct __raw 738 { 739 size_type __words[__n_words]; 740 }; 741 742 struct __rep 743 { 744 union 745 { 746 __long __l; 747 __short __s; 748 __raw __r; 749 }; 750 }; 751 752 __compressed_pair<__rep, allocator_type> __r_; 753 754 public: 755 static const size_type npos = -1; 756 757 _LIBCPP_INLINE_VISIBILITY basic_string() 758 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value); 759 760 _LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a) 761 #if _LIBCPP_STD_VER <= 14 762 _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value); 763 #else 764 _NOEXCEPT; 765 #endif 766 767 basic_string(const basic_string& __str); 768 basic_string(const basic_string& __str, const allocator_type& __a); 769 770 #ifndef _LIBCPP_CXX03_LANG 771 _LIBCPP_INLINE_VISIBILITY 772 basic_string(basic_string&& __str) 773 #if _LIBCPP_STD_VER <= 14 774 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); 775 #else 776 _NOEXCEPT; 777 #endif 778 779 _LIBCPP_INLINE_VISIBILITY 780 basic_string(basic_string&& __str, const allocator_type& __a); 781 #endif // _LIBCPP_CXX03_LANG 782 _LIBCPP_INLINE_VISIBILITY basic_string(const _CharT* __s); 783 _LIBCPP_INLINE_VISIBILITY 784 basic_string(const _CharT* __s, const _Allocator& __a); 785 _LIBCPP_INLINE_VISIBILITY 786 basic_string(const _CharT* __s, size_type __n); 787 _LIBCPP_INLINE_VISIBILITY 788 basic_string(const _CharT* __s, size_type __n, const _Allocator& __a); 789 _LIBCPP_INLINE_VISIBILITY 790 basic_string(size_type __n, _CharT __c); 791 _LIBCPP_INLINE_VISIBILITY 792 basic_string(size_type __n, _CharT __c, const _Allocator& __a); 793 basic_string(const basic_string& __str, size_type __pos, size_type __n, 794 const _Allocator& __a = _Allocator()); 795 _LIBCPP_INLINE_VISIBILITY 796 basic_string(const basic_string& __str, size_type __pos, 797 const _Allocator& __a = _Allocator()); 798 template<class _Tp> 799 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 800 basic_string(const _Tp& __t, size_type __pos, size_type __n, 801 const allocator_type& __a = allocator_type(), 802 typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type* = 0); 803 _LIBCPP_INLINE_VISIBILITY explicit 804 basic_string(__self_view __sv); 805 _LIBCPP_INLINE_VISIBILITY 806 basic_string(__self_view __sv, const _Allocator& __a); 807 template<class _InputIterator> 808 _LIBCPP_INLINE_VISIBILITY 809 basic_string(_InputIterator __first, _InputIterator __last); 810 template<class _InputIterator> 811 _LIBCPP_INLINE_VISIBILITY 812 basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a); 813 #ifndef _LIBCPP_CXX03_LANG 814 _LIBCPP_INLINE_VISIBILITY 815 basic_string(initializer_list<_CharT> __il); 816 _LIBCPP_INLINE_VISIBILITY 817 basic_string(initializer_list<_CharT> __il, const _Allocator& __a); 818 #endif // _LIBCPP_CXX03_LANG 819 820 inline ~basic_string(); 821 822 _LIBCPP_INLINE_VISIBILITY 823 operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); } 824 825 basic_string& operator=(const basic_string& __str); 826 827 #ifndef _LIBCPP_CXX03_LANG 828 template <class = void> 829 #endif 830 _LIBCPP_INLINE_VISIBILITY 831 basic_string& operator=(__self_view __sv) {return assign(__sv);} 832 #ifndef _LIBCPP_CXX03_LANG 833 _LIBCPP_INLINE_VISIBILITY 834 basic_string& operator=(basic_string&& __str) 835 _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)); 836 _LIBCPP_INLINE_VISIBILITY 837 basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());} 838 #endif 839 _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);} 840 basic_string& operator=(value_type __c); 841 842 #if _LIBCPP_DEBUG_LEVEL >= 2 843 _LIBCPP_INLINE_VISIBILITY 844 iterator begin() _NOEXCEPT 845 {return iterator(this, __get_pointer());} 846 _LIBCPP_INLINE_VISIBILITY 847 const_iterator begin() const _NOEXCEPT 848 {return const_iterator(this, __get_pointer());} 849 _LIBCPP_INLINE_VISIBILITY 850 iterator end() _NOEXCEPT 851 {return iterator(this, __get_pointer() + size());} 852 _LIBCPP_INLINE_VISIBILITY 853 const_iterator end() const _NOEXCEPT 854 {return const_iterator(this, __get_pointer() + size());} 855 #else 856 _LIBCPP_INLINE_VISIBILITY 857 iterator begin() _NOEXCEPT 858 {return iterator(__get_pointer());} 859 _LIBCPP_INLINE_VISIBILITY 860 const_iterator begin() const _NOEXCEPT 861 {return const_iterator(__get_pointer());} 862 _LIBCPP_INLINE_VISIBILITY 863 iterator end() _NOEXCEPT 864 {return iterator(__get_pointer() + size());} 865 _LIBCPP_INLINE_VISIBILITY 866 const_iterator end() const _NOEXCEPT 867 {return const_iterator(__get_pointer() + size());} 868 #endif // _LIBCPP_DEBUG_LEVEL >= 2 869 _LIBCPP_INLINE_VISIBILITY 870 reverse_iterator rbegin() _NOEXCEPT 871 {return reverse_iterator(end());} 872 _LIBCPP_INLINE_VISIBILITY 873 const_reverse_iterator rbegin() const _NOEXCEPT 874 {return const_reverse_iterator(end());} 875 _LIBCPP_INLINE_VISIBILITY 876 reverse_iterator rend() _NOEXCEPT 877 {return reverse_iterator(begin());} 878 _LIBCPP_INLINE_VISIBILITY 879 const_reverse_iterator rend() const _NOEXCEPT 880 {return const_reverse_iterator(begin());} 881 882 _LIBCPP_INLINE_VISIBILITY 883 const_iterator cbegin() const _NOEXCEPT 884 {return begin();} 885 _LIBCPP_INLINE_VISIBILITY 886 const_iterator cend() const _NOEXCEPT 887 {return end();} 888 _LIBCPP_INLINE_VISIBILITY 889 const_reverse_iterator crbegin() const _NOEXCEPT 890 {return rbegin();} 891 _LIBCPP_INLINE_VISIBILITY 892 const_reverse_iterator crend() const _NOEXCEPT 893 {return rend();} 894 895 _LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT 896 {return __is_long() ? __get_long_size() : __get_short_size();} 897 _LIBCPP_INLINE_VISIBILITY size_type length() const _NOEXCEPT {return size();} 898 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT; 899 _LIBCPP_INLINE_VISIBILITY size_type capacity() const _NOEXCEPT 900 {return (__is_long() ? __get_long_cap() 901 : static_cast<size_type>(__min_cap)) - 1;} 902 903 void resize(size_type __n, value_type __c); 904 _LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());} 905 906 void reserve(size_type __res_arg = 0); 907 _LIBCPP_INLINE_VISIBILITY 908 void shrink_to_fit() _NOEXCEPT {reserve();} 909 _LIBCPP_INLINE_VISIBILITY 910 void clear() _NOEXCEPT; 911 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 912 bool empty() const _NOEXCEPT {return size() == 0;} 913 914 _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __pos) const _NOEXCEPT; 915 _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __pos) _NOEXCEPT; 916 917 const_reference at(size_type __n) const; 918 reference at(size_type __n); 919 920 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const basic_string& __str) {return append(__str);} 921 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(__self_view __sv) {return append(__sv);} 922 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const value_type* __s) {return append(__s);} 923 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c) {push_back(__c); return *this;} 924 #ifndef _LIBCPP_CXX03_LANG 925 _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);} 926 #endif // _LIBCPP_CXX03_LANG 927 928 _LIBCPP_INLINE_VISIBILITY 929 basic_string& append(const basic_string& __str); 930 _LIBCPP_INLINE_VISIBILITY 931 basic_string& append(__self_view __sv) { return append(__sv.data(), __sv.size()); } 932 basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos); 933 template <class _Tp> 934 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 935 typename enable_if 936 < 937 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 938 basic_string& 939 >::type 940 append(const _Tp& __t, size_type __pos, size_type __n=npos); 941 basic_string& append(const value_type* __s, size_type __n); 942 basic_string& append(const value_type* __s); 943 basic_string& append(size_type __n, value_type __c); 944 template <class _ForwardIterator> 945 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 946 basic_string& __append_forward_unsafe(_ForwardIterator, _ForwardIterator); 947 template<class _InputIterator> 948 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 949 typename enable_if 950 < 951 __is_exactly_input_iterator<_InputIterator>::value 952 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value, 953 basic_string& 954 >::type 955 _LIBCPP_INLINE_VISIBILITY 956 append(_InputIterator __first, _InputIterator __last) { 957 const basic_string __temp (__first, __last, __alloc()); 958 append(__temp.data(), __temp.size()); 959 return *this; 960 } 961 template<class _ForwardIterator> 962 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 963 typename enable_if 964 < 965 __is_forward_iterator<_ForwardIterator>::value 966 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value, 967 basic_string& 968 >::type 969 _LIBCPP_INLINE_VISIBILITY 970 append(_ForwardIterator __first, _ForwardIterator __last) { 971 return __append_forward_unsafe(__first, __last); 972 } 973 974 #ifndef _LIBCPP_CXX03_LANG 975 _LIBCPP_INLINE_VISIBILITY 976 basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());} 977 #endif // _LIBCPP_CXX03_LANG 978 979 void push_back(value_type __c); 980 _LIBCPP_INLINE_VISIBILITY 981 void pop_back(); 982 _LIBCPP_INLINE_VISIBILITY reference front(); 983 _LIBCPP_INLINE_VISIBILITY const_reference front() const; 984 _LIBCPP_INLINE_VISIBILITY reference back(); 985 _LIBCPP_INLINE_VISIBILITY const_reference back() const; 986 987 _LIBCPP_INLINE_VISIBILITY 988 basic_string& assign(__self_view __sv) { return assign(__sv.data(), __sv.size()); } 989 _LIBCPP_INLINE_VISIBILITY 990 basic_string& assign(const basic_string& __str) { return *this = __str; } 991 #ifndef _LIBCPP_CXX03_LANG 992 _LIBCPP_INLINE_VISIBILITY 993 basic_string& assign(basic_string&& __str) 994 _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) 995 {*this = _VSTD::move(__str); return *this;} 996 #endif 997 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos); 998 template <class _Tp> 999 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1000 typename enable_if 1001 < 1002 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 1003 basic_string& 1004 >::type 1005 assign(const _Tp & __t, size_type __pos, size_type __n=npos); 1006 basic_string& assign(const value_type* __s, size_type __n); 1007 basic_string& assign(const value_type* __s); 1008 basic_string& assign(size_type __n, value_type __c); 1009 template<class _InputIterator> 1010 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1011 typename enable_if 1012 < 1013 __is_exactly_input_iterator<_InputIterator>::value 1014 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value, 1015 basic_string& 1016 >::type 1017 assign(_InputIterator __first, _InputIterator __last); 1018 template<class _ForwardIterator> 1019 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1020 typename enable_if 1021 < 1022 __is_forward_iterator<_ForwardIterator>::value 1023 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value, 1024 basic_string& 1025 >::type 1026 assign(_ForwardIterator __first, _ForwardIterator __last); 1027 #ifndef _LIBCPP_CXX03_LANG 1028 _LIBCPP_INLINE_VISIBILITY 1029 basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());} 1030 #endif // _LIBCPP_CXX03_LANG 1031 1032 _LIBCPP_INLINE_VISIBILITY 1033 basic_string& insert(size_type __pos1, const basic_string& __str); 1034 _LIBCPP_INLINE_VISIBILITY 1035 basic_string& insert(size_type __pos1, __self_view __sv) { return insert(__pos1, __sv.data(), __sv.size()); } 1036 template <class _Tp> 1037 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1038 typename enable_if 1039 < 1040 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 1041 basic_string& 1042 >::type 1043 insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos); 1044 basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos); 1045 basic_string& insert(size_type __pos, const value_type* __s, size_type __n); 1046 basic_string& insert(size_type __pos, const value_type* __s); 1047 basic_string& insert(size_type __pos, size_type __n, value_type __c); 1048 iterator insert(const_iterator __pos, value_type __c); 1049 _LIBCPP_INLINE_VISIBILITY 1050 iterator insert(const_iterator __pos, size_type __n, value_type __c); 1051 template<class _InputIterator> 1052 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1053 typename enable_if 1054 < 1055 __is_exactly_input_iterator<_InputIterator>::value 1056 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value, 1057 iterator 1058 >::type 1059 insert(const_iterator __pos, _InputIterator __first, _InputIterator __last); 1060 template<class _ForwardIterator> 1061 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1062 typename enable_if 1063 < 1064 __is_forward_iterator<_ForwardIterator>::value 1065 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value, 1066 iterator 1067 >::type 1068 insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last); 1069 #ifndef _LIBCPP_CXX03_LANG 1070 _LIBCPP_INLINE_VISIBILITY 1071 iterator insert(const_iterator __pos, initializer_list<value_type> __il) 1072 {return insert(__pos, __il.begin(), __il.end());} 1073 #endif // _LIBCPP_CXX03_LANG 1074 1075 basic_string& erase(size_type __pos = 0, size_type __n = npos); 1076 _LIBCPP_INLINE_VISIBILITY 1077 iterator erase(const_iterator __pos); 1078 _LIBCPP_INLINE_VISIBILITY 1079 iterator erase(const_iterator __first, const_iterator __last); 1080 1081 _LIBCPP_INLINE_VISIBILITY 1082 basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str); 1083 _LIBCPP_INLINE_VISIBILITY 1084 basic_string& replace(size_type __pos1, size_type __n1, __self_view __sv) { return replace(__pos1, __n1, __sv.data(), __sv.size()); } 1085 basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos); 1086 template <class _Tp> 1087 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1088 typename enable_if 1089 < 1090 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 1091 basic_string& 1092 >::type 1093 replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos); 1094 basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2); 1095 basic_string& replace(size_type __pos, size_type __n1, const value_type* __s); 1096 basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c); 1097 _LIBCPP_INLINE_VISIBILITY 1098 basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str); 1099 _LIBCPP_INLINE_VISIBILITY 1100 basic_string& replace(const_iterator __i1, const_iterator __i2, __self_view __sv) { return replace(__i1 - begin(), __i2 - __i1, __sv); } 1101 _LIBCPP_INLINE_VISIBILITY 1102 basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n); 1103 _LIBCPP_INLINE_VISIBILITY 1104 basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s); 1105 _LIBCPP_INLINE_VISIBILITY 1106 basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c); 1107 template<class _InputIterator> 1108 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1109 typename enable_if 1110 < 1111 __is_input_iterator<_InputIterator>::value, 1112 basic_string& 1113 >::type 1114 replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2); 1115 #ifndef _LIBCPP_CXX03_LANG 1116 _LIBCPP_INLINE_VISIBILITY 1117 basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il) 1118 {return replace(__i1, __i2, __il.begin(), __il.end());} 1119 #endif // _LIBCPP_CXX03_LANG 1120 1121 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const; 1122 _LIBCPP_INLINE_VISIBILITY 1123 basic_string substr(size_type __pos = 0, size_type __n = npos) const; 1124 1125 _LIBCPP_INLINE_VISIBILITY 1126 void swap(basic_string& __str) 1127 #if _LIBCPP_STD_VER >= 14 1128 _NOEXCEPT_DEBUG; 1129 #else 1130 _NOEXCEPT_DEBUG_(!__alloc_traits::propagate_on_container_swap::value || 1131 __is_nothrow_swappable<allocator_type>::value); 1132 #endif 1133 1134 _LIBCPP_INLINE_VISIBILITY 1135 const value_type* c_str() const _NOEXCEPT {return data();} 1136 _LIBCPP_INLINE_VISIBILITY 1137 const value_type* data() const _NOEXCEPT {return _VSTD::__to_raw_pointer(__get_pointer());} 1138 #if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY) 1139 _LIBCPP_INLINE_VISIBILITY 1140 value_type* data() _NOEXCEPT {return _VSTD::__to_raw_pointer(__get_pointer());} 1141 #endif 1142 1143 _LIBCPP_INLINE_VISIBILITY 1144 allocator_type get_allocator() const _NOEXCEPT {return __alloc();} 1145 1146 _LIBCPP_INLINE_VISIBILITY 1147 size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; 1148 _LIBCPP_INLINE_VISIBILITY 1149 size_type find(__self_view __sv, size_type __pos = 0) const _NOEXCEPT; 1150 size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 1151 _LIBCPP_INLINE_VISIBILITY 1152 size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; 1153 size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT; 1154 1155 _LIBCPP_INLINE_VISIBILITY 1156 size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; 1157 _LIBCPP_INLINE_VISIBILITY 1158 size_type rfind(__self_view __sv, size_type __pos = npos) const _NOEXCEPT; 1159 size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 1160 _LIBCPP_INLINE_VISIBILITY 1161 size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; 1162 size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT; 1163 1164 _LIBCPP_INLINE_VISIBILITY 1165 size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; 1166 _LIBCPP_INLINE_VISIBILITY 1167 size_type find_first_of(__self_view __sv, size_type __pos = 0) const _NOEXCEPT; 1168 size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 1169 _LIBCPP_INLINE_VISIBILITY 1170 size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; 1171 _LIBCPP_INLINE_VISIBILITY 1172 size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT; 1173 1174 _LIBCPP_INLINE_VISIBILITY 1175 size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; 1176 _LIBCPP_INLINE_VISIBILITY 1177 size_type find_last_of(__self_view __sv, size_type __pos = npos) const _NOEXCEPT; 1178 size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 1179 _LIBCPP_INLINE_VISIBILITY 1180 size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; 1181 _LIBCPP_INLINE_VISIBILITY 1182 size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT; 1183 1184 _LIBCPP_INLINE_VISIBILITY 1185 size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; 1186 _LIBCPP_INLINE_VISIBILITY 1187 size_type find_first_not_of(__self_view __sv, size_type __pos = 0) const _NOEXCEPT; 1188 size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 1189 _LIBCPP_INLINE_VISIBILITY 1190 size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; 1191 _LIBCPP_INLINE_VISIBILITY 1192 size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT; 1193 1194 _LIBCPP_INLINE_VISIBILITY 1195 size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; 1196 _LIBCPP_INLINE_VISIBILITY 1197 size_type find_last_not_of(__self_view __sv, size_type __pos = npos) const _NOEXCEPT; 1198 size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 1199 _LIBCPP_INLINE_VISIBILITY 1200 size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; 1201 _LIBCPP_INLINE_VISIBILITY 1202 size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT; 1203 1204 _LIBCPP_INLINE_VISIBILITY 1205 int compare(const basic_string& __str) const _NOEXCEPT; 1206 _LIBCPP_INLINE_VISIBILITY 1207 int compare(__self_view __sv) const _NOEXCEPT; 1208 _LIBCPP_INLINE_VISIBILITY 1209 int compare(size_type __pos1, size_type __n1, __self_view __sv) const; 1210 _LIBCPP_INLINE_VISIBILITY 1211 int compare(size_type __pos1, size_type __n1, const basic_string& __str) const; 1212 int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos) const; 1213 template <class _Tp> 1214 inline _LIBCPP_INLINE_VISIBILITY 1215 typename enable_if 1216 < 1217 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 1218 int 1219 >::type 1220 compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const; 1221 int compare(const value_type* __s) const _NOEXCEPT; 1222 int compare(size_type __pos1, size_type __n1, const value_type* __s) const; 1223 int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const; 1224 1225 #if _LIBCPP_STD_VER > 17 1226 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 1227 bool starts_with(__self_view __sv) const _NOEXCEPT 1228 { return __self_view(data(), size()).starts_with(__sv); } 1229 1230 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 1231 bool starts_with(value_type __c) const _NOEXCEPT 1232 { return !empty() && _Traits::eq(front(), __c); } 1233 1234 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 1235 bool starts_with(const value_type* __s) const _NOEXCEPT 1236 { return starts_with(__self_view(__s)); } 1237 1238 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 1239 bool ends_with(__self_view __sv) const _NOEXCEPT 1240 { return __self_view(data(), size()).ends_with( __sv); } 1241 1242 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 1243 bool ends_with(value_type __c) const _NOEXCEPT 1244 { return !empty() && _Traits::eq(back(), __c); } 1245 1246 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 1247 bool ends_with(const value_type* __s) const _NOEXCEPT 1248 { return ends_with(__self_view(__s)); } 1249 #endif 1250 1251 _LIBCPP_INLINE_VISIBILITY bool __invariants() const; 1252 1253 _LIBCPP_INLINE_VISIBILITY 1254 bool __is_long() const _NOEXCEPT 1255 {return bool(__r_.first().__s.__size_ & __short_mask);} 1256 1257 #if _LIBCPP_DEBUG_LEVEL >= 2 1258 1259 bool __dereferenceable(const const_iterator* __i) const; 1260 bool __decrementable(const const_iterator* __i) const; 1261 bool __addable(const const_iterator* __i, ptrdiff_t __n) const; 1262 bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const; 1263 1264 #endif // _LIBCPP_DEBUG_LEVEL >= 2 1265 1266 private: 1267 _LIBCPP_INLINE_VISIBILITY 1268 allocator_type& __alloc() _NOEXCEPT 1269 {return __r_.second();} 1270 _LIBCPP_INLINE_VISIBILITY 1271 const allocator_type& __alloc() const _NOEXCEPT 1272 {return __r_.second();} 1273 1274 #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 1275 1276 _LIBCPP_INLINE_VISIBILITY 1277 void __set_short_size(size_type __s) _NOEXCEPT 1278 # ifdef _LIBCPP_BIG_ENDIAN 1279 {__r_.first().__s.__size_ = (unsigned char)(__s << 1);} 1280 # else 1281 {__r_.first().__s.__size_ = (unsigned char)(__s);} 1282 # endif 1283 1284 _LIBCPP_INLINE_VISIBILITY 1285 size_type __get_short_size() const _NOEXCEPT 1286 # ifdef _LIBCPP_BIG_ENDIAN 1287 {return __r_.first().__s.__size_ >> 1;} 1288 # else 1289 {return __r_.first().__s.__size_;} 1290 # endif 1291 1292 #else // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 1293 1294 _LIBCPP_INLINE_VISIBILITY 1295 void __set_short_size(size_type __s) _NOEXCEPT 1296 # ifdef _LIBCPP_BIG_ENDIAN 1297 {__r_.first().__s.__size_ = (unsigned char)(__s);} 1298 # else 1299 {__r_.first().__s.__size_ = (unsigned char)(__s << 1);} 1300 # endif 1301 1302 _LIBCPP_INLINE_VISIBILITY 1303 size_type __get_short_size() const _NOEXCEPT 1304 # ifdef _LIBCPP_BIG_ENDIAN 1305 {return __r_.first().__s.__size_;} 1306 # else 1307 {return __r_.first().__s.__size_ >> 1;} 1308 # endif 1309 1310 #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 1311 1312 _LIBCPP_INLINE_VISIBILITY 1313 void __set_long_size(size_type __s) _NOEXCEPT 1314 {__r_.first().__l.__size_ = __s;} 1315 _LIBCPP_INLINE_VISIBILITY 1316 size_type __get_long_size() const _NOEXCEPT 1317 {return __r_.first().__l.__size_;} 1318 _LIBCPP_INLINE_VISIBILITY 1319 void __set_size(size_type __s) _NOEXCEPT 1320 {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);} 1321 1322 _LIBCPP_INLINE_VISIBILITY 1323 void __set_long_cap(size_type __s) _NOEXCEPT 1324 {__r_.first().__l.__cap_ = __long_mask | __s;} 1325 _LIBCPP_INLINE_VISIBILITY 1326 size_type __get_long_cap() const _NOEXCEPT 1327 {return __r_.first().__l.__cap_ & size_type(~__long_mask);} 1328 1329 _LIBCPP_INLINE_VISIBILITY 1330 void __set_long_pointer(pointer __p) _NOEXCEPT 1331 {__r_.first().__l.__data_ = __p;} 1332 _LIBCPP_INLINE_VISIBILITY 1333 pointer __get_long_pointer() _NOEXCEPT 1334 {return __r_.first().__l.__data_;} 1335 _LIBCPP_INLINE_VISIBILITY 1336 const_pointer __get_long_pointer() const _NOEXCEPT 1337 {return __r_.first().__l.__data_;} 1338 _LIBCPP_INLINE_VISIBILITY 1339 pointer __get_short_pointer() _NOEXCEPT 1340 {return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);} 1341 _LIBCPP_INLINE_VISIBILITY 1342 const_pointer __get_short_pointer() const _NOEXCEPT 1343 {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);} 1344 _LIBCPP_INLINE_VISIBILITY 1345 pointer __get_pointer() _NOEXCEPT 1346 {return __is_long() ? __get_long_pointer() : __get_short_pointer();} 1347 _LIBCPP_INLINE_VISIBILITY 1348 const_pointer __get_pointer() const _NOEXCEPT 1349 {return __is_long() ? __get_long_pointer() : __get_short_pointer();} 1350 1351 _LIBCPP_INLINE_VISIBILITY 1352 void __zero() _NOEXCEPT 1353 { 1354 size_type (&__a)[__n_words] = __r_.first().__r.__words; 1355 for (unsigned __i = 0; __i < __n_words; ++__i) 1356 __a[__i] = 0; 1357 } 1358 1359 template <size_type __a> static 1360 _LIBCPP_INLINE_VISIBILITY 1361 size_type __align_it(size_type __s) _NOEXCEPT 1362 {return (__s + (__a-1)) & ~(__a-1);} 1363 enum {__alignment = 16}; 1364 static _LIBCPP_INLINE_VISIBILITY 1365 size_type __recommend(size_type __s) _NOEXCEPT 1366 { 1367 if (__s < __min_cap) return static_cast<size_type>(__min_cap) - 1; 1368 size_type __guess = __align_it<sizeof(value_type) < __alignment ? 1369 __alignment/sizeof(value_type) : 1 > (__s+1) - 1; 1370 if (__guess == __min_cap) ++__guess; 1371 return __guess; 1372 } 1373 1374 inline 1375 void __init(const value_type* __s, size_type __sz, size_type __reserve); 1376 inline 1377 void __init(const value_type* __s, size_type __sz); 1378 inline 1379 void __init(size_type __n, value_type __c); 1380 1381 template <class _InputIterator> 1382 inline 1383 typename enable_if 1384 < 1385 __is_exactly_input_iterator<_InputIterator>::value, 1386 void 1387 >::type 1388 __init(_InputIterator __first, _InputIterator __last); 1389 1390 template <class _ForwardIterator> 1391 inline 1392 typename enable_if 1393 < 1394 __is_forward_iterator<_ForwardIterator>::value, 1395 void 1396 >::type 1397 __init(_ForwardIterator __first, _ForwardIterator __last); 1398 1399 void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz, 1400 size_type __n_copy, size_type __n_del, size_type __n_add = 0); 1401 void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz, 1402 size_type __n_copy, size_type __n_del, 1403 size_type __n_add, const value_type* __p_new_stuff); 1404 1405 _LIBCPP_INLINE_VISIBILITY 1406 void __erase_to_end(size_type __pos); 1407 1408 _LIBCPP_INLINE_VISIBILITY 1409 void __copy_assign_alloc(const basic_string& __str) 1410 {__copy_assign_alloc(__str, integral_constant<bool, 1411 __alloc_traits::propagate_on_container_copy_assignment::value>());} 1412 1413 _LIBCPP_INLINE_VISIBILITY 1414 void __copy_assign_alloc(const basic_string& __str, true_type) 1415 { 1416 if (__alloc() == __str.__alloc()) 1417 __alloc() = __str.__alloc(); 1418 else 1419 { 1420 if (!__str.__is_long()) 1421 { 1422 clear(); 1423 shrink_to_fit(); 1424 __alloc() = __str.__alloc(); 1425 } 1426 else 1427 { 1428 allocator_type __a = __str.__alloc(); 1429 pointer __p = __alloc_traits::allocate(__a, __str.__get_long_cap()); 1430 clear(); 1431 shrink_to_fit(); 1432 __alloc() = _VSTD::move(__a); 1433 __set_long_pointer(__p); 1434 __set_long_cap(__str.__get_long_cap()); 1435 __set_long_size(__str.size()); 1436 } 1437 } 1438 } 1439 1440 _LIBCPP_INLINE_VISIBILITY 1441 void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT 1442 {} 1443 1444 #ifndef _LIBCPP_CXX03_LANG 1445 _LIBCPP_INLINE_VISIBILITY 1446 void __move_assign(basic_string& __str, false_type) 1447 _NOEXCEPT_(__alloc_traits::is_always_equal::value); 1448 _LIBCPP_INLINE_VISIBILITY 1449 void __move_assign(basic_string& __str, true_type) 1450 #if _LIBCPP_STD_VER > 14 1451 _NOEXCEPT; 1452 #else 1453 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value); 1454 #endif 1455 #endif 1456 1457 _LIBCPP_INLINE_VISIBILITY 1458 void 1459 __move_assign_alloc(basic_string& __str) 1460 _NOEXCEPT_( 1461 !__alloc_traits::propagate_on_container_move_assignment::value || 1462 is_nothrow_move_assignable<allocator_type>::value) 1463 {__move_assign_alloc(__str, integral_constant<bool, 1464 __alloc_traits::propagate_on_container_move_assignment::value>());} 1465 1466 _LIBCPP_INLINE_VISIBILITY 1467 void __move_assign_alloc(basic_string& __c, true_type) 1468 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) 1469 { 1470 __alloc() = _VSTD::move(__c.__alloc()); 1471 } 1472 1473 _LIBCPP_INLINE_VISIBILITY 1474 void __move_assign_alloc(basic_string&, false_type) 1475 _NOEXCEPT 1476 {} 1477 1478 _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators(); 1479 _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type); 1480 1481 friend basic_string operator+<>(const basic_string&, const basic_string&); 1482 friend basic_string operator+<>(const value_type*, const basic_string&); 1483 friend basic_string operator+<>(value_type, const basic_string&); 1484 friend basic_string operator+<>(const basic_string&, const value_type*); 1485 friend basic_string operator+<>(const basic_string&, value_type); 1486 }; 1487 1488 template <class _CharT, class _Traits, class _Allocator> 1489 inline _LIBCPP_INLINE_VISIBILITY 1490 void 1491 basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators() 1492 { 1493 #if _LIBCPP_DEBUG_LEVEL >= 2 1494 __get_db()->__invalidate_all(this); 1495 #endif // _LIBCPP_DEBUG_LEVEL >= 2 1496 } 1497 1498 template <class _CharT, class _Traits, class _Allocator> 1499 inline _LIBCPP_INLINE_VISIBILITY 1500 void 1501 basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type 1502 #if _LIBCPP_DEBUG_LEVEL >= 2 1503 __pos 1504 #endif 1505 ) 1506 { 1507 #if _LIBCPP_DEBUG_LEVEL >= 2 1508 __c_node* __c = __get_db()->__find_c_and_lock(this); 1509 if (__c) 1510 { 1511 const_pointer __new_last = __get_pointer() + __pos; 1512 for (__i_node** __p = __c->end_; __p != __c->beg_; ) 1513 { 1514 --__p; 1515 const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_); 1516 if (__i->base() > __new_last) 1517 { 1518 (*__p)->__c_ = nullptr; 1519 if (--__c->end_ != __p) 1520 memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*)); 1521 } 1522 } 1523 __get_db()->unlock(); 1524 } 1525 #endif // _LIBCPP_DEBUG_LEVEL >= 2 1526 } 1527 1528 template <class _CharT, class _Traits, class _Allocator> 1529 inline _LIBCPP_INLINE_VISIBILITY 1530 basic_string<_CharT, _Traits, _Allocator>::basic_string() 1531 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) 1532 { 1533 #if _LIBCPP_DEBUG_LEVEL >= 2 1534 __get_db()->__insert_c(this); 1535 #endif 1536 __zero(); 1537 } 1538 1539 template <class _CharT, class _Traits, class _Allocator> 1540 inline _LIBCPP_INLINE_VISIBILITY 1541 basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a) 1542 #if _LIBCPP_STD_VER <= 14 1543 _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value) 1544 #else 1545 _NOEXCEPT 1546 #endif 1547 : __r_(__second_tag(), __a) 1548 { 1549 #if _LIBCPP_DEBUG_LEVEL >= 2 1550 __get_db()->__insert_c(this); 1551 #endif 1552 __zero(); 1553 } 1554 1555 template <class _CharT, class _Traits, class _Allocator> 1556 void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, 1557 size_type __sz, 1558 size_type __reserve) 1559 { 1560 if (__reserve > max_size()) 1561 this->__throw_length_error(); 1562 pointer __p; 1563 if (__reserve < __min_cap) 1564 { 1565 __set_short_size(__sz); 1566 __p = __get_short_pointer(); 1567 } 1568 else 1569 { 1570 size_type __cap = __recommend(__reserve); 1571 __p = __alloc_traits::allocate(__alloc(), __cap+1); 1572 __set_long_pointer(__p); 1573 __set_long_cap(__cap+1); 1574 __set_long_size(__sz); 1575 } 1576 traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz); 1577 traits_type::assign(__p[__sz], value_type()); 1578 } 1579 1580 template <class _CharT, class _Traits, class _Allocator> 1581 void 1582 basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz) 1583 { 1584 if (__sz > max_size()) 1585 this->__throw_length_error(); 1586 pointer __p; 1587 if (__sz < __min_cap) 1588 { 1589 __set_short_size(__sz); 1590 __p = __get_short_pointer(); 1591 } 1592 else 1593 { 1594 size_type __cap = __recommend(__sz); 1595 __p = __alloc_traits::allocate(__alloc(), __cap+1); 1596 __set_long_pointer(__p); 1597 __set_long_cap(__cap+1); 1598 __set_long_size(__sz); 1599 } 1600 traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz); 1601 traits_type::assign(__p[__sz], value_type()); 1602 } 1603 1604 template <class _CharT, class _Traits, class _Allocator> 1605 inline _LIBCPP_INLINE_VISIBILITY 1606 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s) 1607 { 1608 _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr"); 1609 __init(__s, traits_type::length(__s)); 1610 #if _LIBCPP_DEBUG_LEVEL >= 2 1611 __get_db()->__insert_c(this); 1612 #endif 1613 } 1614 1615 template <class _CharT, class _Traits, class _Allocator> 1616 inline _LIBCPP_INLINE_VISIBILITY 1617 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a) 1618 : __r_(__second_tag(), __a) 1619 { 1620 _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr"); 1621 __init(__s, traits_type::length(__s)); 1622 #if _LIBCPP_DEBUG_LEVEL >= 2 1623 __get_db()->__insert_c(this); 1624 #endif 1625 } 1626 1627 template <class _CharT, class _Traits, class _Allocator> 1628 inline _LIBCPP_INLINE_VISIBILITY 1629 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n) 1630 { 1631 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr"); 1632 __init(__s, __n); 1633 #if _LIBCPP_DEBUG_LEVEL >= 2 1634 __get_db()->__insert_c(this); 1635 #endif 1636 } 1637 1638 template <class _CharT, class _Traits, class _Allocator> 1639 inline _LIBCPP_INLINE_VISIBILITY 1640 basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a) 1641 : __r_(__second_tag(), __a) 1642 { 1643 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr"); 1644 __init(__s, __n); 1645 #if _LIBCPP_DEBUG_LEVEL >= 2 1646 __get_db()->__insert_c(this); 1647 #endif 1648 } 1649 1650 template <class _CharT, class _Traits, class _Allocator> 1651 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str) 1652 : __r_(__second_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc())) 1653 { 1654 if (!__str.__is_long()) 1655 __r_.first().__r = __str.__r_.first().__r; 1656 else 1657 __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size()); 1658 #if _LIBCPP_DEBUG_LEVEL >= 2 1659 __get_db()->__insert_c(this); 1660 #endif 1661 } 1662 1663 template <class _CharT, class _Traits, class _Allocator> 1664 basic_string<_CharT, _Traits, _Allocator>::basic_string( 1665 const basic_string& __str, const allocator_type& __a) 1666 : __r_(__second_tag(), __a) 1667 { 1668 if (!__str.__is_long()) 1669 __r_.first().__r = __str.__r_.first().__r; 1670 else 1671 __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size()); 1672 #if _LIBCPP_DEBUG_LEVEL >= 2 1673 __get_db()->__insert_c(this); 1674 #endif 1675 } 1676 1677 #ifndef _LIBCPP_CXX03_LANG 1678 1679 template <class _CharT, class _Traits, class _Allocator> 1680 inline _LIBCPP_INLINE_VISIBILITY 1681 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str) 1682 #if _LIBCPP_STD_VER <= 14 1683 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) 1684 #else 1685 _NOEXCEPT 1686 #endif 1687 : __r_(_VSTD::move(__str.__r_)) 1688 { 1689 __str.__zero(); 1690 #if _LIBCPP_DEBUG_LEVEL >= 2 1691 __get_db()->__insert_c(this); 1692 if (__is_long()) 1693 __get_db()->swap(this, &__str); 1694 #endif 1695 } 1696 1697 template <class _CharT, class _Traits, class _Allocator> 1698 inline _LIBCPP_INLINE_VISIBILITY 1699 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a) 1700 : __r_(__second_tag(), __a) 1701 { 1702 if (__str.__is_long() && __a != __str.__alloc()) // copy, not move 1703 __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size()); 1704 else 1705 { 1706 __r_.first().__r = __str.__r_.first().__r; 1707 __str.__zero(); 1708 } 1709 #if _LIBCPP_DEBUG_LEVEL >= 2 1710 __get_db()->__insert_c(this); 1711 if (__is_long()) 1712 __get_db()->swap(this, &__str); 1713 #endif 1714 } 1715 1716 #endif // _LIBCPP_CXX03_LANG 1717 1718 template <class _CharT, class _Traits, class _Allocator> 1719 void 1720 basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c) 1721 { 1722 if (__n > max_size()) 1723 this->__throw_length_error(); 1724 pointer __p; 1725 if (__n < __min_cap) 1726 { 1727 __set_short_size(__n); 1728 __p = __get_short_pointer(); 1729 } 1730 else 1731 { 1732 size_type __cap = __recommend(__n); 1733 __p = __alloc_traits::allocate(__alloc(), __cap+1); 1734 __set_long_pointer(__p); 1735 __set_long_cap(__cap+1); 1736 __set_long_size(__n); 1737 } 1738 traits_type::assign(_VSTD::__to_raw_pointer(__p), __n, __c); 1739 traits_type::assign(__p[__n], value_type()); 1740 } 1741 1742 template <class _CharT, class _Traits, class _Allocator> 1743 inline _LIBCPP_INLINE_VISIBILITY 1744 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c) 1745 { 1746 __init(__n, __c); 1747 #if _LIBCPP_DEBUG_LEVEL >= 2 1748 __get_db()->__insert_c(this); 1749 #endif 1750 } 1751 1752 template <class _CharT, class _Traits, class _Allocator> 1753 inline _LIBCPP_INLINE_VISIBILITY 1754 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a) 1755 : __r_(__second_tag(), __a) 1756 { 1757 __init(__n, __c); 1758 #if _LIBCPP_DEBUG_LEVEL >= 2 1759 __get_db()->__insert_c(this); 1760 #endif 1761 } 1762 1763 template <class _CharT, class _Traits, class _Allocator> 1764 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, 1765 size_type __pos, size_type __n, 1766 const _Allocator& __a) 1767 : __r_(__second_tag(), __a) 1768 { 1769 size_type __str_sz = __str.size(); 1770 if (__pos > __str_sz) 1771 this->__throw_out_of_range(); 1772 __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos)); 1773 #if _LIBCPP_DEBUG_LEVEL >= 2 1774 __get_db()->__insert_c(this); 1775 #endif 1776 } 1777 1778 template <class _CharT, class _Traits, class _Allocator> 1779 inline _LIBCPP_INLINE_VISIBILITY 1780 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos, 1781 const _Allocator& __a) 1782 : __r_(__second_tag(), __a) 1783 { 1784 size_type __str_sz = __str.size(); 1785 if (__pos > __str_sz) 1786 this->__throw_out_of_range(); 1787 __init(__str.data() + __pos, __str_sz - __pos); 1788 #if _LIBCPP_DEBUG_LEVEL >= 2 1789 __get_db()->__insert_c(this); 1790 #endif 1791 } 1792 1793 template <class _CharT, class _Traits, class _Allocator> 1794 template <class _Tp> 1795 basic_string<_CharT, _Traits, _Allocator>::basic_string( 1796 const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a, 1797 typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type *) 1798 : __r_(__second_tag(), __a) 1799 { 1800 __self_view __sv = __self_view(__t).substr(__pos, __n); 1801 __init(__sv.data(), __sv.size()); 1802 #if _LIBCPP_DEBUG_LEVEL >= 2 1803 __get_db()->__insert_c(this); 1804 #endif 1805 } 1806 1807 template <class _CharT, class _Traits, class _Allocator> 1808 inline _LIBCPP_INLINE_VISIBILITY 1809 basic_string<_CharT, _Traits, _Allocator>::basic_string(__self_view __sv) 1810 { 1811 __init(__sv.data(), __sv.size()); 1812 #if _LIBCPP_DEBUG_LEVEL >= 2 1813 __get_db()->__insert_c(this); 1814 #endif 1815 } 1816 1817 template <class _CharT, class _Traits, class _Allocator> 1818 inline _LIBCPP_INLINE_VISIBILITY 1819 basic_string<_CharT, _Traits, _Allocator>::basic_string(__self_view __sv, const _Allocator& __a) 1820 : __r_(__second_tag(), __a) 1821 { 1822 __init(__sv.data(), __sv.size()); 1823 #if _LIBCPP_DEBUG_LEVEL >= 2 1824 __get_db()->__insert_c(this); 1825 #endif 1826 } 1827 1828 template <class _CharT, class _Traits, class _Allocator> 1829 template <class _InputIterator> 1830 typename enable_if 1831 < 1832 __is_exactly_input_iterator<_InputIterator>::value, 1833 void 1834 >::type 1835 basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last) 1836 { 1837 __zero(); 1838 #ifndef _LIBCPP_NO_EXCEPTIONS 1839 try 1840 { 1841 #endif // _LIBCPP_NO_EXCEPTIONS 1842 for (; __first != __last; ++__first) 1843 push_back(*__first); 1844 #ifndef _LIBCPP_NO_EXCEPTIONS 1845 } 1846 catch (...) 1847 { 1848 if (__is_long()) 1849 __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); 1850 throw; 1851 } 1852 #endif // _LIBCPP_NO_EXCEPTIONS 1853 } 1854 1855 template <class _CharT, class _Traits, class _Allocator> 1856 template <class _ForwardIterator> 1857 typename enable_if 1858 < 1859 __is_forward_iterator<_ForwardIterator>::value, 1860 void 1861 >::type 1862 basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last) 1863 { 1864 size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last)); 1865 if (__sz > max_size()) 1866 this->__throw_length_error(); 1867 pointer __p; 1868 if (__sz < __min_cap) 1869 { 1870 __set_short_size(__sz); 1871 __p = __get_short_pointer(); 1872 } 1873 else 1874 { 1875 size_type __cap = __recommend(__sz); 1876 __p = __alloc_traits::allocate(__alloc(), __cap+1); 1877 __set_long_pointer(__p); 1878 __set_long_cap(__cap+1); 1879 __set_long_size(__sz); 1880 } 1881 for (; __first != __last; ++__first, (void) ++__p) 1882 traits_type::assign(*__p, *__first); 1883 traits_type::assign(*__p, value_type()); 1884 } 1885 1886 template <class _CharT, class _Traits, class _Allocator> 1887 template<class _InputIterator> 1888 inline _LIBCPP_INLINE_VISIBILITY 1889 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last) 1890 { 1891 __init(__first, __last); 1892 #if _LIBCPP_DEBUG_LEVEL >= 2 1893 __get_db()->__insert_c(this); 1894 #endif 1895 } 1896 1897 template <class _CharT, class _Traits, class _Allocator> 1898 template<class _InputIterator> 1899 inline _LIBCPP_INLINE_VISIBILITY 1900 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last, 1901 const allocator_type& __a) 1902 : __r_(__second_tag(), __a) 1903 { 1904 __init(__first, __last); 1905 #if _LIBCPP_DEBUG_LEVEL >= 2 1906 __get_db()->__insert_c(this); 1907 #endif 1908 } 1909 1910 #ifndef _LIBCPP_CXX03_LANG 1911 1912 template <class _CharT, class _Traits, class _Allocator> 1913 inline _LIBCPP_INLINE_VISIBILITY 1914 basic_string<_CharT, _Traits, _Allocator>::basic_string( 1915 initializer_list<_CharT> __il) 1916 { 1917 __init(__il.begin(), __il.end()); 1918 #if _LIBCPP_DEBUG_LEVEL >= 2 1919 __get_db()->__insert_c(this); 1920 #endif 1921 } 1922 1923 template <class _CharT, class _Traits, class _Allocator> 1924 inline _LIBCPP_INLINE_VISIBILITY 1925 1926 basic_string<_CharT, _Traits, _Allocator>::basic_string( 1927 initializer_list<_CharT> __il, const _Allocator& __a) 1928 : __r_(__second_tag(), __a) 1929 { 1930 __init(__il.begin(), __il.end()); 1931 #if _LIBCPP_DEBUG_LEVEL >= 2 1932 __get_db()->__insert_c(this); 1933 #endif 1934 } 1935 1936 #endif // _LIBCPP_CXX03_LANG 1937 1938 template <class _CharT, class _Traits, class _Allocator> 1939 basic_string<_CharT, _Traits, _Allocator>::~basic_string() 1940 { 1941 #if _LIBCPP_DEBUG_LEVEL >= 2 1942 __get_db()->__erase_c(this); 1943 #endif 1944 if (__is_long()) 1945 __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); 1946 } 1947 1948 template <class _CharT, class _Traits, class _Allocator> 1949 void 1950 basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace 1951 (size_type __old_cap, size_type __delta_cap, size_type __old_sz, 1952 size_type __n_copy, size_type __n_del, size_type __n_add, const value_type* __p_new_stuff) 1953 { 1954 size_type __ms = max_size(); 1955 if (__delta_cap > __ms - __old_cap - 1) 1956 this->__throw_length_error(); 1957 pointer __old_p = __get_pointer(); 1958 size_type __cap = __old_cap < __ms / 2 - __alignment ? 1959 __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) : 1960 __ms - 1; 1961 pointer __p = __alloc_traits::allocate(__alloc(), __cap+1); 1962 __invalidate_all_iterators(); 1963 if (__n_copy != 0) 1964 traits_type::copy(_VSTD::__to_raw_pointer(__p), 1965 _VSTD::__to_raw_pointer(__old_p), __n_copy); 1966 if (__n_add != 0) 1967 traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy, __p_new_stuff, __n_add); 1968 size_type __sec_cp_sz = __old_sz - __n_del - __n_copy; 1969 if (__sec_cp_sz != 0) 1970 traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy + __n_add, 1971 _VSTD::__to_raw_pointer(__old_p) + __n_copy + __n_del, __sec_cp_sz); 1972 if (__old_cap+1 != __min_cap) 1973 __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1); 1974 __set_long_pointer(__p); 1975 __set_long_cap(__cap+1); 1976 __old_sz = __n_copy + __n_add + __sec_cp_sz; 1977 __set_long_size(__old_sz); 1978 traits_type::assign(__p[__old_sz], value_type()); 1979 } 1980 1981 template <class _CharT, class _Traits, class _Allocator> 1982 void 1983 basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz, 1984 size_type __n_copy, size_type __n_del, size_type __n_add) 1985 { 1986 size_type __ms = max_size(); 1987 if (__delta_cap > __ms - __old_cap) 1988 this->__throw_length_error(); 1989 pointer __old_p = __get_pointer(); 1990 size_type __cap = __old_cap < __ms / 2 - __alignment ? 1991 __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) : 1992 __ms - 1; 1993 pointer __p = __alloc_traits::allocate(__alloc(), __cap+1); 1994 __invalidate_all_iterators(); 1995 if (__n_copy != 0) 1996 traits_type::copy(_VSTD::__to_raw_pointer(__p), 1997 _VSTD::__to_raw_pointer(__old_p), __n_copy); 1998 size_type __sec_cp_sz = __old_sz - __n_del - __n_copy; 1999 if (__sec_cp_sz != 0) 2000 traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy + __n_add, 2001 _VSTD::__to_raw_pointer(__old_p) + __n_copy + __n_del, 2002 __sec_cp_sz); 2003 if (__old_cap+1 != __min_cap) 2004 __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1); 2005 __set_long_pointer(__p); 2006 __set_long_cap(__cap+1); 2007 } 2008 2009 // assign 2010 2011 template <class _CharT, class _Traits, class _Allocator> 2012 basic_string<_CharT, _Traits, _Allocator>& 2013 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n) 2014 { 2015 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr"); 2016 size_type __cap = capacity(); 2017 if (__cap >= __n) 2018 { 2019 value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); 2020 traits_type::move(__p, __s, __n); 2021 traits_type::assign(__p[__n], value_type()); 2022 __set_size(__n); 2023 __invalidate_iterators_past(__n); 2024 } 2025 else 2026 { 2027 size_type __sz = size(); 2028 __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s); 2029 } 2030 return *this; 2031 } 2032 2033 template <class _CharT, class _Traits, class _Allocator> 2034 basic_string<_CharT, _Traits, _Allocator>& 2035 basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c) 2036 { 2037 size_type __cap = capacity(); 2038 if (__cap < __n) 2039 { 2040 size_type __sz = size(); 2041 __grow_by(__cap, __n - __cap, __sz, 0, __sz); 2042 } 2043 else 2044 __invalidate_iterators_past(__n); 2045 value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); 2046 traits_type::assign(__p, __n, __c); 2047 traits_type::assign(__p[__n], value_type()); 2048 __set_size(__n); 2049 return *this; 2050 } 2051 2052 template <class _CharT, class _Traits, class _Allocator> 2053 basic_string<_CharT, _Traits, _Allocator>& 2054 basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c) 2055 { 2056 pointer __p; 2057 if (__is_long()) 2058 { 2059 __p = __get_long_pointer(); 2060 __set_long_size(1); 2061 } 2062 else 2063 { 2064 __p = __get_short_pointer(); 2065 __set_short_size(1); 2066 } 2067 traits_type::assign(*__p, __c); 2068 traits_type::assign(*++__p, value_type()); 2069 __invalidate_iterators_past(1); 2070 return *this; 2071 } 2072 2073 template <class _CharT, class _Traits, class _Allocator> 2074 basic_string<_CharT, _Traits, _Allocator>& 2075 basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str) 2076 { 2077 if (this != &__str) 2078 { 2079 __copy_assign_alloc(__str); 2080 assign(__str.data(), __str.size()); 2081 } 2082 return *this; 2083 } 2084 2085 #ifndef _LIBCPP_CXX03_LANG 2086 2087 template <class _CharT, class _Traits, class _Allocator> 2088 inline _LIBCPP_INLINE_VISIBILITY 2089 void 2090 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type) 2091 _NOEXCEPT_(__alloc_traits::is_always_equal::value) 2092 { 2093 if (__alloc() != __str.__alloc()) 2094 assign(__str); 2095 else 2096 __move_assign(__str, true_type()); 2097 } 2098 2099 template <class _CharT, class _Traits, class _Allocator> 2100 inline _LIBCPP_INLINE_VISIBILITY 2101 void 2102 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type) 2103 #if _LIBCPP_STD_VER > 14 2104 _NOEXCEPT 2105 #else 2106 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) 2107 #endif 2108 { 2109 clear(); 2110 shrink_to_fit(); 2111 __r_.first() = __str.__r_.first(); 2112 __move_assign_alloc(__str); 2113 __str.__zero(); 2114 } 2115 2116 template <class _CharT, class _Traits, class _Allocator> 2117 inline _LIBCPP_INLINE_VISIBILITY 2118 basic_string<_CharT, _Traits, _Allocator>& 2119 basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str) 2120 _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) 2121 { 2122 __move_assign(__str, integral_constant<bool, 2123 __alloc_traits::propagate_on_container_move_assignment::value>()); 2124 return *this; 2125 } 2126 2127 #endif 2128 2129 template <class _CharT, class _Traits, class _Allocator> 2130 template<class _InputIterator> 2131 typename enable_if 2132 < 2133 __is_exactly_input_iterator <_InputIterator>::value 2134 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value, 2135 basic_string<_CharT, _Traits, _Allocator>& 2136 >::type 2137 basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last) 2138 { 2139 const basic_string __temp(__first, __last, __alloc()); 2140 assign(__temp.data(), __temp.size()); 2141 return *this; 2142 } 2143 2144 template <class _CharT, class _Traits, class _Allocator> 2145 template<class _ForwardIterator> 2146 typename enable_if 2147 < 2148 __is_forward_iterator<_ForwardIterator>::value 2149 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value, 2150 basic_string<_CharT, _Traits, _Allocator>& 2151 >::type 2152 basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) 2153 { 2154 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); 2155 size_type __cap = capacity(); 2156 if (__cap < __n) 2157 { 2158 size_type __sz = size(); 2159 __grow_by(__cap, __n - __cap, __sz, 0, __sz); 2160 } 2161 else 2162 __invalidate_iterators_past(__n); 2163 pointer __p = __get_pointer(); 2164 for (; __first != __last; ++__first, ++__p) 2165 traits_type::assign(*__p, *__first); 2166 traits_type::assign(*__p, value_type()); 2167 __set_size(__n); 2168 return *this; 2169 } 2170 2171 template <class _CharT, class _Traits, class _Allocator> 2172 basic_string<_CharT, _Traits, _Allocator>& 2173 basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n) 2174 { 2175 size_type __sz = __str.size(); 2176 if (__pos > __sz) 2177 this->__throw_out_of_range(); 2178 return assign(__str.data() + __pos, _VSTD::min(__n, __sz - __pos)); 2179 } 2180 2181 template <class _CharT, class _Traits, class _Allocator> 2182 template <class _Tp> 2183 typename enable_if 2184 < 2185 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 2186 basic_string<_CharT, _Traits, _Allocator>& 2187 >::type 2188 basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n) 2189 { 2190 __self_view __sv = __t; 2191 size_type __sz = __sv.size(); 2192 if (__pos > __sz) 2193 this->__throw_out_of_range(); 2194 return assign(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos)); 2195 } 2196 2197 2198 template <class _CharT, class _Traits, class _Allocator> 2199 basic_string<_CharT, _Traits, _Allocator>& 2200 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s) 2201 { 2202 _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr"); 2203 return assign(__s, traits_type::length(__s)); 2204 } 2205 2206 // append 2207 2208 template <class _CharT, class _Traits, class _Allocator> 2209 basic_string<_CharT, _Traits, _Allocator>& 2210 basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n) 2211 { 2212 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr"); 2213 size_type __cap = capacity(); 2214 size_type __sz = size(); 2215 if (__cap - __sz >= __n) 2216 { 2217 if (__n) 2218 { 2219 value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); 2220 traits_type::copy(__p + __sz, __s, __n); 2221 __sz += __n; 2222 __set_size(__sz); 2223 traits_type::assign(__p[__sz], value_type()); 2224 } 2225 } 2226 else 2227 __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s); 2228 return *this; 2229 } 2230 2231 template <class _CharT, class _Traits, class _Allocator> 2232 basic_string<_CharT, _Traits, _Allocator>& 2233 basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c) 2234 { 2235 if (__n) 2236 { 2237 size_type __cap = capacity(); 2238 size_type __sz = size(); 2239 if (__cap - __sz < __n) 2240 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); 2241 pointer __p = __get_pointer(); 2242 traits_type::assign(_VSTD::__to_raw_pointer(__p) + __sz, __n, __c); 2243 __sz += __n; 2244 __set_size(__sz); 2245 traits_type::assign(__p[__sz], value_type()); 2246 } 2247 return *this; 2248 } 2249 2250 template <class _CharT, class _Traits, class _Allocator> 2251 void 2252 basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c) 2253 { 2254 bool __is_short = !__is_long(); 2255 size_type __cap; 2256 size_type __sz; 2257 if (__is_short) 2258 { 2259 __cap = __min_cap - 1; 2260 __sz = __get_short_size(); 2261 } 2262 else 2263 { 2264 __cap = __get_long_cap() - 1; 2265 __sz = __get_long_size(); 2266 } 2267 if (__sz == __cap) 2268 { 2269 __grow_by(__cap, 1, __sz, __sz, 0); 2270 __is_short = !__is_long(); 2271 } 2272 pointer __p; 2273 if (__is_short) 2274 { 2275 __p = __get_short_pointer() + __sz; 2276 __set_short_size(__sz+1); 2277 } 2278 else 2279 { 2280 __p = __get_long_pointer() + __sz; 2281 __set_long_size(__sz+1); 2282 } 2283 traits_type::assign(*__p, __c); 2284 traits_type::assign(*++__p, value_type()); 2285 } 2286 2287 template <class _Tp> 2288 bool __ptr_in_range (const _Tp* __p, const _Tp* __first, const _Tp* __last) 2289 { 2290 return __first <= __p && __p < __last; 2291 } 2292 2293 template <class _Tp1, class _Tp2> 2294 bool __ptr_in_range (const _Tp1*, const _Tp2*, const _Tp2*) 2295 { 2296 return false; 2297 } 2298 2299 template <class _CharT, class _Traits, class _Allocator> 2300 template<class _ForwardIterator> 2301 basic_string<_CharT, _Traits, _Allocator>& 2302 basic_string<_CharT, _Traits, _Allocator>::__append_forward_unsafe( 2303 _ForwardIterator __first, _ForwardIterator __last) 2304 { 2305 static_assert(__is_forward_iterator<_ForwardIterator>::value, 2306 "function requires a ForwardIterator"); 2307 size_type __sz = size(); 2308 size_type __cap = capacity(); 2309 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); 2310 if (__n) 2311 { 2312 typedef typename iterator_traits<_ForwardIterator>::reference _CharRef; 2313 _CharRef __tmp_ref = *__first; 2314 if (__ptr_in_range(_VSTD::addressof(__tmp_ref), data(), data() + size())) 2315 { 2316 const basic_string __temp (__first, __last, __alloc()); 2317 append(__temp.data(), __temp.size()); 2318 } 2319 else 2320 { 2321 if (__cap - __sz < __n) 2322 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); 2323 pointer __p = __get_pointer() + __sz; 2324 for (; __first != __last; ++__p, ++__first) 2325 traits_type::assign(*__p, *__first); 2326 traits_type::assign(*__p, value_type()); 2327 __set_size(__sz + __n); 2328 } 2329 } 2330 return *this; 2331 } 2332 2333 template <class _CharT, class _Traits, class _Allocator> 2334 inline _LIBCPP_INLINE_VISIBILITY 2335 basic_string<_CharT, _Traits, _Allocator>& 2336 basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str) 2337 { 2338 return append(__str.data(), __str.size()); 2339 } 2340 2341 template <class _CharT, class _Traits, class _Allocator> 2342 basic_string<_CharT, _Traits, _Allocator>& 2343 basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n) 2344 { 2345 size_type __sz = __str.size(); 2346 if (__pos > __sz) 2347 this->__throw_out_of_range(); 2348 return append(__str.data() + __pos, _VSTD::min(__n, __sz - __pos)); 2349 } 2350 2351 template <class _CharT, class _Traits, class _Allocator> 2352 template <class _Tp> 2353 typename enable_if 2354 < 2355 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 2356 basic_string<_CharT, _Traits, _Allocator>& 2357 >::type 2358 basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n) 2359 { 2360 __self_view __sv = __t; 2361 size_type __sz = __sv.size(); 2362 if (__pos > __sz) 2363 this->__throw_out_of_range(); 2364 return append(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos)); 2365 } 2366 2367 template <class _CharT, class _Traits, class _Allocator> 2368 basic_string<_CharT, _Traits, _Allocator>& 2369 basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s) 2370 { 2371 _LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr"); 2372 return append(__s, traits_type::length(__s)); 2373 } 2374 2375 // insert 2376 2377 template <class _CharT, class _Traits, class _Allocator> 2378 basic_string<_CharT, _Traits, _Allocator>& 2379 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n) 2380 { 2381 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr"); 2382 size_type __sz = size(); 2383 if (__pos > __sz) 2384 this->__throw_out_of_range(); 2385 size_type __cap = capacity(); 2386 if (__cap - __sz >= __n) 2387 { 2388 if (__n) 2389 { 2390 value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); 2391 size_type __n_move = __sz - __pos; 2392 if (__n_move != 0) 2393 { 2394 if (__p + __pos <= __s && __s < __p + __sz) 2395 __s += __n; 2396 traits_type::move(__p + __pos + __n, __p + __pos, __n_move); 2397 } 2398 traits_type::move(__p + __pos, __s, __n); 2399 __sz += __n; 2400 __set_size(__sz); 2401 traits_type::assign(__p[__sz], value_type()); 2402 } 2403 } 2404 else 2405 __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s); 2406 return *this; 2407 } 2408 2409 template <class _CharT, class _Traits, class _Allocator> 2410 basic_string<_CharT, _Traits, _Allocator>& 2411 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c) 2412 { 2413 size_type __sz = size(); 2414 if (__pos > __sz) 2415 this->__throw_out_of_range(); 2416 if (__n) 2417 { 2418 size_type __cap = capacity(); 2419 value_type* __p; 2420 if (__cap - __sz >= __n) 2421 { 2422 __p = _VSTD::__to_raw_pointer(__get_pointer()); 2423 size_type __n_move = __sz - __pos; 2424 if (__n_move != 0) 2425 traits_type::move(__p + __pos + __n, __p + __pos, __n_move); 2426 } 2427 else 2428 { 2429 __grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n); 2430 __p = _VSTD::__to_raw_pointer(__get_long_pointer()); 2431 } 2432 traits_type::assign(__p + __pos, __n, __c); 2433 __sz += __n; 2434 __set_size(__sz); 2435 traits_type::assign(__p[__sz], value_type()); 2436 } 2437 return *this; 2438 } 2439 2440 template <class _CharT, class _Traits, class _Allocator> 2441 template<class _InputIterator> 2442 typename enable_if 2443 < 2444 __is_exactly_input_iterator<_InputIterator>::value 2445 || !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value, 2446 typename basic_string<_CharT, _Traits, _Allocator>::iterator 2447 >::type 2448 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last) 2449 { 2450 #if _LIBCPP_DEBUG_LEVEL >= 2 2451 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, 2452 "string::insert(iterator, range) called with an iterator not" 2453 " referring to this string"); 2454 #endif 2455 const basic_string __temp(__first, __last, __alloc()); 2456 return insert(__pos, __temp.data(), __temp.data() + __temp.size()); 2457 } 2458 2459 template <class _CharT, class _Traits, class _Allocator> 2460 template<class _ForwardIterator> 2461 typename enable_if 2462 < 2463 __is_forward_iterator<_ForwardIterator>::value 2464 && __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value, 2465 typename basic_string<_CharT, _Traits, _Allocator>::iterator 2466 >::type 2467 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last) 2468 { 2469 #if _LIBCPP_DEBUG_LEVEL >= 2 2470 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, 2471 "string::insert(iterator, range) called with an iterator not" 2472 " referring to this string"); 2473 #endif 2474 size_type __ip = static_cast<size_type>(__pos - begin()); 2475 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); 2476 if (__n) 2477 { 2478 typedef typename iterator_traits<_ForwardIterator>::reference _CharRef; 2479 _CharRef __tmp_char = *__first; 2480 if (__ptr_in_range(_VSTD::addressof(__tmp_char), data(), data() + size())) 2481 { 2482 const basic_string __temp(__first, __last, __alloc()); 2483 return insert(__pos, __temp.data(), __temp.data() + __temp.size()); 2484 } 2485 2486 size_type __sz = size(); 2487 size_type __cap = capacity(); 2488 value_type* __p; 2489 if (__cap - __sz >= __n) 2490 { 2491 __p = _VSTD::__to_raw_pointer(__get_pointer()); 2492 size_type __n_move = __sz - __ip; 2493 if (__n_move != 0) 2494 traits_type::move(__p + __ip + __n, __p + __ip, __n_move); 2495 } 2496 else 2497 { 2498 __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n); 2499 __p = _VSTD::__to_raw_pointer(__get_long_pointer()); 2500 } 2501 __sz += __n; 2502 __set_size(__sz); 2503 traits_type::assign(__p[__sz], value_type()); 2504 for (__p += __ip; __first != __last; ++__p, ++__first) 2505 traits_type::assign(*__p, *__first); 2506 } 2507 return begin() + __ip; 2508 } 2509 2510 template <class _CharT, class _Traits, class _Allocator> 2511 inline _LIBCPP_INLINE_VISIBILITY 2512 basic_string<_CharT, _Traits, _Allocator>& 2513 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str) 2514 { 2515 return insert(__pos1, __str.data(), __str.size()); 2516 } 2517 2518 template <class _CharT, class _Traits, class _Allocator> 2519 basic_string<_CharT, _Traits, _Allocator>& 2520 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str, 2521 size_type __pos2, size_type __n) 2522 { 2523 size_type __str_sz = __str.size(); 2524 if (__pos2 > __str_sz) 2525 this->__throw_out_of_range(); 2526 return insert(__pos1, __str.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2)); 2527 } 2528 2529 template <class _CharT, class _Traits, class _Allocator> 2530 template <class _Tp> 2531 typename enable_if 2532 < 2533 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 2534 basic_string<_CharT, _Traits, _Allocator>& 2535 >::type 2536 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t, 2537 size_type __pos2, size_type __n) 2538 { 2539 __self_view __sv = __t; 2540 size_type __str_sz = __sv.size(); 2541 if (__pos2 > __str_sz) 2542 this->__throw_out_of_range(); 2543 return insert(__pos1, __sv.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2)); 2544 } 2545 2546 template <class _CharT, class _Traits, class _Allocator> 2547 basic_string<_CharT, _Traits, _Allocator>& 2548 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s) 2549 { 2550 _LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr"); 2551 return insert(__pos, __s, traits_type::length(__s)); 2552 } 2553 2554 template <class _CharT, class _Traits, class _Allocator> 2555 typename basic_string<_CharT, _Traits, _Allocator>::iterator 2556 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c) 2557 { 2558 size_type __ip = static_cast<size_type>(__pos - begin()); 2559 size_type __sz = size(); 2560 size_type __cap = capacity(); 2561 value_type* __p; 2562 if (__cap == __sz) 2563 { 2564 __grow_by(__cap, 1, __sz, __ip, 0, 1); 2565 __p = _VSTD::__to_raw_pointer(__get_long_pointer()); 2566 } 2567 else 2568 { 2569 __p = _VSTD::__to_raw_pointer(__get_pointer()); 2570 size_type __n_move = __sz - __ip; 2571 if (__n_move != 0) 2572 traits_type::move(__p + __ip + 1, __p + __ip, __n_move); 2573 } 2574 traits_type::assign(__p[__ip], __c); 2575 traits_type::assign(__p[++__sz], value_type()); 2576 __set_size(__sz); 2577 return begin() + static_cast<difference_type>(__ip); 2578 } 2579 2580 template <class _CharT, class _Traits, class _Allocator> 2581 inline _LIBCPP_INLINE_VISIBILITY 2582 typename basic_string<_CharT, _Traits, _Allocator>::iterator 2583 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c) 2584 { 2585 #if _LIBCPP_DEBUG_LEVEL >= 2 2586 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, 2587 "string::insert(iterator, n, value) called with an iterator not" 2588 " referring to this string"); 2589 #endif 2590 difference_type __p = __pos - begin(); 2591 insert(static_cast<size_type>(__p), __n, __c); 2592 return begin() + __p; 2593 } 2594 2595 // replace 2596 2597 template <class _CharT, class _Traits, class _Allocator> 2598 basic_string<_CharT, _Traits, _Allocator>& 2599 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2) 2600 _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK 2601 { 2602 _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr"); 2603 size_type __sz = size(); 2604 if (__pos > __sz) 2605 this->__throw_out_of_range(); 2606 __n1 = _VSTD::min(__n1, __sz - __pos); 2607 size_type __cap = capacity(); 2608 if (__cap - __sz + __n1 >= __n2) 2609 { 2610 value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); 2611 if (__n1 != __n2) 2612 { 2613 size_type __n_move = __sz - __pos - __n1; 2614 if (__n_move != 0) 2615 { 2616 if (__n1 > __n2) 2617 { 2618 traits_type::move(__p + __pos, __s, __n2); 2619 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move); 2620 goto __finish; 2621 } 2622 if (__p + __pos < __s && __s < __p + __sz) 2623 { 2624 if (__p + __pos + __n1 <= __s) 2625 __s += __n2 - __n1; 2626 else // __p + __pos < __s < __p + __pos + __n1 2627 { 2628 traits_type::move(__p + __pos, __s, __n1); 2629 __pos += __n1; 2630 __s += __n2; 2631 __n2 -= __n1; 2632 __n1 = 0; 2633 } 2634 } 2635 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move); 2636 } 2637 } 2638 traits_type::move(__p + __pos, __s, __n2); 2639 __finish: 2640 // __sz += __n2 - __n1; in this and the below function below can cause unsigned integer overflow, 2641 // but this is a safe operation, so we disable the check. 2642 __sz += __n2 - __n1; 2643 __set_size(__sz); 2644 __invalidate_iterators_past(__sz); 2645 traits_type::assign(__p[__sz], value_type()); 2646 } 2647 else 2648 __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s); 2649 return *this; 2650 } 2651 2652 template <class _CharT, class _Traits, class _Allocator> 2653 basic_string<_CharT, _Traits, _Allocator>& 2654 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c) 2655 _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK 2656 { 2657 size_type __sz = size(); 2658 if (__pos > __sz) 2659 this->__throw_out_of_range(); 2660 __n1 = _VSTD::min(__n1, __sz - __pos); 2661 size_type __cap = capacity(); 2662 value_type* __p; 2663 if (__cap - __sz + __n1 >= __n2) 2664 { 2665 __p = _VSTD::__to_raw_pointer(__get_pointer()); 2666 if (__n1 != __n2) 2667 { 2668 size_type __n_move = __sz - __pos - __n1; 2669 if (__n_move != 0) 2670 traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move); 2671 } 2672 } 2673 else 2674 { 2675 __grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2); 2676 __p = _VSTD::__to_raw_pointer(__get_long_pointer()); 2677 } 2678 traits_type::assign(__p + __pos, __n2, __c); 2679 __sz += __n2 - __n1; 2680 __set_size(__sz); 2681 __invalidate_iterators_past(__sz); 2682 traits_type::assign(__p[__sz], value_type()); 2683 return *this; 2684 } 2685 2686 template <class _CharT, class _Traits, class _Allocator> 2687 template<class _InputIterator> 2688 typename enable_if 2689 < 2690 __is_input_iterator<_InputIterator>::value, 2691 basic_string<_CharT, _Traits, _Allocator>& 2692 >::type 2693 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, 2694 _InputIterator __j1, _InputIterator __j2) 2695 { 2696 const basic_string __temp(__j1, __j2, __alloc()); 2697 return this->replace(__i1, __i2, __temp); 2698 } 2699 2700 template <class _CharT, class _Traits, class _Allocator> 2701 inline _LIBCPP_INLINE_VISIBILITY 2702 basic_string<_CharT, _Traits, _Allocator>& 2703 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str) 2704 { 2705 return replace(__pos1, __n1, __str.data(), __str.size()); 2706 } 2707 2708 template <class _CharT, class _Traits, class _Allocator> 2709 basic_string<_CharT, _Traits, _Allocator>& 2710 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str, 2711 size_type __pos2, size_type __n2) 2712 { 2713 size_type __str_sz = __str.size(); 2714 if (__pos2 > __str_sz) 2715 this->__throw_out_of_range(); 2716 return replace(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2)); 2717 } 2718 2719 template <class _CharT, class _Traits, class _Allocator> 2720 template <class _Tp> 2721 typename enable_if 2722 < 2723 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 2724 basic_string<_CharT, _Traits, _Allocator>& 2725 >::type 2726 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t, 2727 size_type __pos2, size_type __n2) 2728 { 2729 __self_view __sv = __t; 2730 size_type __str_sz = __sv.size(); 2731 if (__pos2 > __str_sz) 2732 this->__throw_out_of_range(); 2733 return replace(__pos1, __n1, __sv.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2)); 2734 } 2735 2736 template <class _CharT, class _Traits, class _Allocator> 2737 basic_string<_CharT, _Traits, _Allocator>& 2738 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s) 2739 { 2740 _LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr"); 2741 return replace(__pos, __n1, __s, traits_type::length(__s)); 2742 } 2743 2744 template <class _CharT, class _Traits, class _Allocator> 2745 inline _LIBCPP_INLINE_VISIBILITY 2746 basic_string<_CharT, _Traits, _Allocator>& 2747 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str) 2748 { 2749 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), 2750 __str.data(), __str.size()); 2751 } 2752 2753 template <class _CharT, class _Traits, class _Allocator> 2754 inline _LIBCPP_INLINE_VISIBILITY 2755 basic_string<_CharT, _Traits, _Allocator>& 2756 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n) 2757 { 2758 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n); 2759 } 2760 2761 template <class _CharT, class _Traits, class _Allocator> 2762 inline _LIBCPP_INLINE_VISIBILITY 2763 basic_string<_CharT, _Traits, _Allocator>& 2764 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s) 2765 { 2766 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s); 2767 } 2768 2769 template <class _CharT, class _Traits, class _Allocator> 2770 inline _LIBCPP_INLINE_VISIBILITY 2771 basic_string<_CharT, _Traits, _Allocator>& 2772 basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c) 2773 { 2774 return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c); 2775 } 2776 2777 // erase 2778 2779 template <class _CharT, class _Traits, class _Allocator> 2780 basic_string<_CharT, _Traits, _Allocator>& 2781 basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n) 2782 { 2783 size_type __sz = size(); 2784 if (__pos > __sz) 2785 this->__throw_out_of_range(); 2786 if (__n) 2787 { 2788 value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); 2789 __n = _VSTD::min(__n, __sz - __pos); 2790 size_type __n_move = __sz - __pos - __n; 2791 if (__n_move != 0) 2792 traits_type::move(__p + __pos, __p + __pos + __n, __n_move); 2793 __sz -= __n; 2794 __set_size(__sz); 2795 __invalidate_iterators_past(__sz); 2796 traits_type::assign(__p[__sz], value_type()); 2797 } 2798 return *this; 2799 } 2800 2801 template <class _CharT, class _Traits, class _Allocator> 2802 inline _LIBCPP_INLINE_VISIBILITY 2803 typename basic_string<_CharT, _Traits, _Allocator>::iterator 2804 basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos) 2805 { 2806 #if _LIBCPP_DEBUG_LEVEL >= 2 2807 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, 2808 "string::erase(iterator) called with an iterator not" 2809 " referring to this string"); 2810 #endif 2811 _LIBCPP_ASSERT(__pos != end(), 2812 "string::erase(iterator) called with a non-dereferenceable iterator"); 2813 iterator __b = begin(); 2814 size_type __r = static_cast<size_type>(__pos - __b); 2815 erase(__r, 1); 2816 return __b + static_cast<difference_type>(__r); 2817 } 2818 2819 template <class _CharT, class _Traits, class _Allocator> 2820 inline _LIBCPP_INLINE_VISIBILITY 2821 typename basic_string<_CharT, _Traits, _Allocator>::iterator 2822 basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last) 2823 { 2824 #if _LIBCPP_DEBUG_LEVEL >= 2 2825 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this, 2826 "string::erase(iterator, iterator) called with an iterator not" 2827 " referring to this string"); 2828 #endif 2829 _LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range"); 2830 iterator __b = begin(); 2831 size_type __r = static_cast<size_type>(__first - __b); 2832 erase(__r, static_cast<size_type>(__last - __first)); 2833 return __b + static_cast<difference_type>(__r); 2834 } 2835 2836 template <class _CharT, class _Traits, class _Allocator> 2837 inline _LIBCPP_INLINE_VISIBILITY 2838 void 2839 basic_string<_CharT, _Traits, _Allocator>::pop_back() 2840 { 2841 _LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty"); 2842 size_type __sz; 2843 if (__is_long()) 2844 { 2845 __sz = __get_long_size() - 1; 2846 __set_long_size(__sz); 2847 traits_type::assign(*(__get_long_pointer() + __sz), value_type()); 2848 } 2849 else 2850 { 2851 __sz = __get_short_size() - 1; 2852 __set_short_size(__sz); 2853 traits_type::assign(*(__get_short_pointer() + __sz), value_type()); 2854 } 2855 __invalidate_iterators_past(__sz); 2856 } 2857 2858 template <class _CharT, class _Traits, class _Allocator> 2859 inline _LIBCPP_INLINE_VISIBILITY 2860 void 2861 basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT 2862 { 2863 __invalidate_all_iterators(); 2864 if (__is_long()) 2865 { 2866 traits_type::assign(*__get_long_pointer(), value_type()); 2867 __set_long_size(0); 2868 } 2869 else 2870 { 2871 traits_type::assign(*__get_short_pointer(), value_type()); 2872 __set_short_size(0); 2873 } 2874 } 2875 2876 template <class _CharT, class _Traits, class _Allocator> 2877 inline _LIBCPP_INLINE_VISIBILITY 2878 void 2879 basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos) 2880 { 2881 if (__is_long()) 2882 { 2883 traits_type::assign(*(__get_long_pointer() + __pos), value_type()); 2884 __set_long_size(__pos); 2885 } 2886 else 2887 { 2888 traits_type::assign(*(__get_short_pointer() + __pos), value_type()); 2889 __set_short_size(__pos); 2890 } 2891 __invalidate_iterators_past(__pos); 2892 } 2893 2894 template <class _CharT, class _Traits, class _Allocator> 2895 void 2896 basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c) 2897 { 2898 size_type __sz = size(); 2899 if (__n > __sz) 2900 append(__n - __sz, __c); 2901 else 2902 __erase_to_end(__n); 2903 } 2904 2905 template <class _CharT, class _Traits, class _Allocator> 2906 inline _LIBCPP_INLINE_VISIBILITY 2907 typename basic_string<_CharT, _Traits, _Allocator>::size_type 2908 basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT 2909 { 2910 size_type __m = __alloc_traits::max_size(__alloc()); 2911 #ifdef _LIBCPP_BIG_ENDIAN 2912 return (__m <= ~__long_mask ? __m : __m/2) - __alignment; 2913 #else 2914 return __m - __alignment; 2915 #endif 2916 } 2917 2918 template <class _CharT, class _Traits, class _Allocator> 2919 void 2920 basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg) 2921 { 2922 if (__res_arg > max_size()) 2923 this->__throw_length_error(); 2924 size_type __cap = capacity(); 2925 size_type __sz = size(); 2926 __res_arg = _VSTD::max(__res_arg, __sz); 2927 __res_arg = __recommend(__res_arg); 2928 if (__res_arg != __cap) 2929 { 2930 pointer __new_data, __p; 2931 bool __was_long, __now_long; 2932 if (__res_arg == __min_cap - 1) 2933 { 2934 __was_long = true; 2935 __now_long = false; 2936 __new_data = __get_short_pointer(); 2937 __p = __get_long_pointer(); 2938 } 2939 else 2940 { 2941 if (__res_arg > __cap) 2942 __new_data = __alloc_traits::allocate(__alloc(), __res_arg+1); 2943 else 2944 { 2945 #ifndef _LIBCPP_NO_EXCEPTIONS 2946 try 2947 { 2948 #endif // _LIBCPP_NO_EXCEPTIONS 2949 __new_data = __alloc_traits::allocate(__alloc(), __res_arg+1); 2950 #ifndef _LIBCPP_NO_EXCEPTIONS 2951 } 2952 catch (...) 2953 { 2954 return; 2955 } 2956 #else // _LIBCPP_NO_EXCEPTIONS 2957 if (__new_data == nullptr) 2958 return; 2959 #endif // _LIBCPP_NO_EXCEPTIONS 2960 } 2961 __now_long = true; 2962 __was_long = __is_long(); 2963 __p = __get_pointer(); 2964 } 2965 traits_type::copy(_VSTD::__to_raw_pointer(__new_data), 2966 _VSTD::__to_raw_pointer(__p), size()+1); 2967 if (__was_long) 2968 __alloc_traits::deallocate(__alloc(), __p, __cap+1); 2969 if (__now_long) 2970 { 2971 __set_long_cap(__res_arg+1); 2972 __set_long_size(__sz); 2973 __set_long_pointer(__new_data); 2974 } 2975 else 2976 __set_short_size(__sz); 2977 __invalidate_all_iterators(); 2978 } 2979 } 2980 2981 template <class _CharT, class _Traits, class _Allocator> 2982 inline _LIBCPP_INLINE_VISIBILITY 2983 typename basic_string<_CharT, _Traits, _Allocator>::const_reference 2984 basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const _NOEXCEPT 2985 { 2986 _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds"); 2987 return *(data() + __pos); 2988 } 2989 2990 template <class _CharT, class _Traits, class _Allocator> 2991 inline _LIBCPP_INLINE_VISIBILITY 2992 typename basic_string<_CharT, _Traits, _Allocator>::reference 2993 basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) _NOEXCEPT 2994 { 2995 _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds"); 2996 return *(__get_pointer() + __pos); 2997 } 2998 2999 template <class _CharT, class _Traits, class _Allocator> 3000 typename basic_string<_CharT, _Traits, _Allocator>::const_reference 3001 basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const 3002 { 3003 if (__n >= size()) 3004 this->__throw_out_of_range(); 3005 return (*this)[__n]; 3006 } 3007 3008 template <class _CharT, class _Traits, class _Allocator> 3009 typename basic_string<_CharT, _Traits, _Allocator>::reference 3010 basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) 3011 { 3012 if (__n >= size()) 3013 this->__throw_out_of_range(); 3014 return (*this)[__n]; 3015 } 3016 3017 template <class _CharT, class _Traits, class _Allocator> 3018 inline _LIBCPP_INLINE_VISIBILITY 3019 typename basic_string<_CharT, _Traits, _Allocator>::reference 3020 basic_string<_CharT, _Traits, _Allocator>::front() 3021 { 3022 _LIBCPP_ASSERT(!empty(), "string::front(): string is empty"); 3023 return *__get_pointer(); 3024 } 3025 3026 template <class _CharT, class _Traits, class _Allocator> 3027 inline _LIBCPP_INLINE_VISIBILITY 3028 typename basic_string<_CharT, _Traits, _Allocator>::const_reference 3029 basic_string<_CharT, _Traits, _Allocator>::front() const 3030 { 3031 _LIBCPP_ASSERT(!empty(), "string::front(): string is empty"); 3032 return *data(); 3033 } 3034 3035 template <class _CharT, class _Traits, class _Allocator> 3036 inline _LIBCPP_INLINE_VISIBILITY 3037 typename basic_string<_CharT, _Traits, _Allocator>::reference 3038 basic_string<_CharT, _Traits, _Allocator>::back() 3039 { 3040 _LIBCPP_ASSERT(!empty(), "string::back(): string is empty"); 3041 return *(__get_pointer() + size() - 1); 3042 } 3043 3044 template <class _CharT, class _Traits, class _Allocator> 3045 inline _LIBCPP_INLINE_VISIBILITY 3046 typename basic_string<_CharT, _Traits, _Allocator>::const_reference 3047 basic_string<_CharT, _Traits, _Allocator>::back() const 3048 { 3049 _LIBCPP_ASSERT(!empty(), "string::back(): string is empty"); 3050 return *(data() + size() - 1); 3051 } 3052 3053 template <class _CharT, class _Traits, class _Allocator> 3054 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3055 basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const 3056 { 3057 size_type __sz = size(); 3058 if (__pos > __sz) 3059 this->__throw_out_of_range(); 3060 size_type __rlen = _VSTD::min(__n, __sz - __pos); 3061 traits_type::copy(__s, data() + __pos, __rlen); 3062 return __rlen; 3063 } 3064 3065 template <class _CharT, class _Traits, class _Allocator> 3066 inline _LIBCPP_INLINE_VISIBILITY 3067 basic_string<_CharT, _Traits, _Allocator> 3068 basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const 3069 { 3070 return basic_string(*this, __pos, __n, __alloc()); 3071 } 3072 3073 template <class _CharT, class _Traits, class _Allocator> 3074 inline _LIBCPP_INLINE_VISIBILITY 3075 void 3076 basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str) 3077 #if _LIBCPP_STD_VER >= 14 3078 _NOEXCEPT_DEBUG 3079 #else 3080 _NOEXCEPT_DEBUG_(!__alloc_traits::propagate_on_container_swap::value || 3081 __is_nothrow_swappable<allocator_type>::value) 3082 #endif 3083 { 3084 #if _LIBCPP_DEBUG_LEVEL >= 2 3085 if (!__is_long()) 3086 __get_db()->__invalidate_all(this); 3087 if (!__str.__is_long()) 3088 __get_db()->__invalidate_all(&__str); 3089 __get_db()->swap(this, &__str); 3090 #endif 3091 _LIBCPP_ASSERT( 3092 __alloc_traits::propagate_on_container_swap::value || 3093 __alloc_traits::is_always_equal::value || 3094 __alloc() == __str.__alloc(), "swapping non-equal allocators"); 3095 _VSTD::swap(__r_.first(), __str.__r_.first()); 3096 __swap_allocator(__alloc(), __str.__alloc()); 3097 } 3098 3099 // find 3100 3101 template <class _Traits> 3102 struct _LIBCPP_HIDDEN __traits_eq 3103 { 3104 typedef typename _Traits::char_type char_type; 3105 _LIBCPP_INLINE_VISIBILITY 3106 bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT 3107 {return _Traits::eq(__x, __y);} 3108 }; 3109 3110 template<class _CharT, class _Traits, class _Allocator> 3111 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3112 basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s, 3113 size_type __pos, 3114 size_type __n) const _NOEXCEPT 3115 { 3116 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr"); 3117 return __str_find<value_type, size_type, traits_type, npos> 3118 (data(), size(), __s, __pos, __n); 3119 } 3120 3121 template<class _CharT, class _Traits, class _Allocator> 3122 inline _LIBCPP_INLINE_VISIBILITY 3123 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3124 basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str, 3125 size_type __pos) const _NOEXCEPT 3126 { 3127 return __str_find<value_type, size_type, traits_type, npos> 3128 (data(), size(), __str.data(), __pos, __str.size()); 3129 } 3130 3131 template<class _CharT, class _Traits, class _Allocator> 3132 inline _LIBCPP_INLINE_VISIBILITY 3133 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3134 basic_string<_CharT, _Traits, _Allocator>::find(__self_view __sv, 3135 size_type __pos) const _NOEXCEPT 3136 { 3137 return __str_find<value_type, size_type, traits_type, npos> 3138 (data(), size(), __sv.data(), __pos, __sv.size()); 3139 } 3140 3141 template<class _CharT, class _Traits, class _Allocator> 3142 inline _LIBCPP_INLINE_VISIBILITY 3143 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3144 basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s, 3145 size_type __pos) const _NOEXCEPT 3146 { 3147 _LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr"); 3148 return __str_find<value_type, size_type, traits_type, npos> 3149 (data(), size(), __s, __pos, traits_type::length(__s)); 3150 } 3151 3152 template<class _CharT, class _Traits, class _Allocator> 3153 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3154 basic_string<_CharT, _Traits, _Allocator>::find(value_type __c, 3155 size_type __pos) const _NOEXCEPT 3156 { 3157 return __str_find<value_type, size_type, traits_type, npos> 3158 (data(), size(), __c, __pos); 3159 } 3160 3161 // rfind 3162 3163 template<class _CharT, class _Traits, class _Allocator> 3164 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3165 basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s, 3166 size_type __pos, 3167 size_type __n) const _NOEXCEPT 3168 { 3169 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr"); 3170 return __str_rfind<value_type, size_type, traits_type, npos> 3171 (data(), size(), __s, __pos, __n); 3172 } 3173 3174 template<class _CharT, class _Traits, class _Allocator> 3175 inline _LIBCPP_INLINE_VISIBILITY 3176 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3177 basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str, 3178 size_type __pos) const _NOEXCEPT 3179 { 3180 return __str_rfind<value_type, size_type, traits_type, npos> 3181 (data(), size(), __str.data(), __pos, __str.size()); 3182 } 3183 3184 template<class _CharT, class _Traits, class _Allocator> 3185 inline _LIBCPP_INLINE_VISIBILITY 3186 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3187 basic_string<_CharT, _Traits, _Allocator>::rfind(__self_view __sv, 3188 size_type __pos) const _NOEXCEPT 3189 { 3190 return __str_rfind<value_type, size_type, traits_type, npos> 3191 (data(), size(), __sv.data(), __pos, __sv.size()); 3192 } 3193 3194 template<class _CharT, class _Traits, class _Allocator> 3195 inline _LIBCPP_INLINE_VISIBILITY 3196 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3197 basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s, 3198 size_type __pos) const _NOEXCEPT 3199 { 3200 _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr"); 3201 return __str_rfind<value_type, size_type, traits_type, npos> 3202 (data(), size(), __s, __pos, traits_type::length(__s)); 3203 } 3204 3205 template<class _CharT, class _Traits, class _Allocator> 3206 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3207 basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c, 3208 size_type __pos) const _NOEXCEPT 3209 { 3210 return __str_rfind<value_type, size_type, traits_type, npos> 3211 (data(), size(), __c, __pos); 3212 } 3213 3214 // find_first_of 3215 3216 template<class _CharT, class _Traits, class _Allocator> 3217 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3218 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s, 3219 size_type __pos, 3220 size_type __n) const _NOEXCEPT 3221 { 3222 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr"); 3223 return __str_find_first_of<value_type, size_type, traits_type, npos> 3224 (data(), size(), __s, __pos, __n); 3225 } 3226 3227 template<class _CharT, class _Traits, class _Allocator> 3228 inline _LIBCPP_INLINE_VISIBILITY 3229 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3230 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str, 3231 size_type __pos) const _NOEXCEPT 3232 { 3233 return __str_find_first_of<value_type, size_type, traits_type, npos> 3234 (data(), size(), __str.data(), __pos, __str.size()); 3235 } 3236 3237 template<class _CharT, class _Traits, class _Allocator> 3238 inline _LIBCPP_INLINE_VISIBILITY 3239 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3240 basic_string<_CharT, _Traits, _Allocator>::find_first_of(__self_view __sv, 3241 size_type __pos) const _NOEXCEPT 3242 { 3243 return __str_find_first_of<value_type, size_type, traits_type, npos> 3244 (data(), size(), __sv.data(), __pos, __sv.size()); 3245 } 3246 3247 template<class _CharT, class _Traits, class _Allocator> 3248 inline _LIBCPP_INLINE_VISIBILITY 3249 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3250 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s, 3251 size_type __pos) const _NOEXCEPT 3252 { 3253 _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr"); 3254 return __str_find_first_of<value_type, size_type, traits_type, npos> 3255 (data(), size(), __s, __pos, traits_type::length(__s)); 3256 } 3257 3258 template<class _CharT, class _Traits, class _Allocator> 3259 inline _LIBCPP_INLINE_VISIBILITY 3260 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3261 basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c, 3262 size_type __pos) const _NOEXCEPT 3263 { 3264 return find(__c, __pos); 3265 } 3266 3267 // find_last_of 3268 3269 template<class _CharT, class _Traits, class _Allocator> 3270 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3271 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s, 3272 size_type __pos, 3273 size_type __n) const _NOEXCEPT 3274 { 3275 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr"); 3276 return __str_find_last_of<value_type, size_type, traits_type, npos> 3277 (data(), size(), __s, __pos, __n); 3278 } 3279 3280 template<class _CharT, class _Traits, class _Allocator> 3281 inline _LIBCPP_INLINE_VISIBILITY 3282 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3283 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str, 3284 size_type __pos) const _NOEXCEPT 3285 { 3286 return __str_find_last_of<value_type, size_type, traits_type, npos> 3287 (data(), size(), __str.data(), __pos, __str.size()); 3288 } 3289 3290 template<class _CharT, class _Traits, class _Allocator> 3291 inline _LIBCPP_INLINE_VISIBILITY 3292 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3293 basic_string<_CharT, _Traits, _Allocator>::find_last_of(__self_view __sv, 3294 size_type __pos) const _NOEXCEPT 3295 { 3296 return __str_find_last_of<value_type, size_type, traits_type, npos> 3297 (data(), size(), __sv.data(), __pos, __sv.size()); 3298 } 3299 3300 template<class _CharT, class _Traits, class _Allocator> 3301 inline _LIBCPP_INLINE_VISIBILITY 3302 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3303 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s, 3304 size_type __pos) const _NOEXCEPT 3305 { 3306 _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr"); 3307 return __str_find_last_of<value_type, size_type, traits_type, npos> 3308 (data(), size(), __s, __pos, traits_type::length(__s)); 3309 } 3310 3311 template<class _CharT, class _Traits, class _Allocator> 3312 inline _LIBCPP_INLINE_VISIBILITY 3313 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3314 basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c, 3315 size_type __pos) const _NOEXCEPT 3316 { 3317 return rfind(__c, __pos); 3318 } 3319 3320 // find_first_not_of 3321 3322 template<class _CharT, class _Traits, class _Allocator> 3323 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3324 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s, 3325 size_type __pos, 3326 size_type __n) const _NOEXCEPT 3327 { 3328 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr"); 3329 return __str_find_first_not_of<value_type, size_type, traits_type, npos> 3330 (data(), size(), __s, __pos, __n); 3331 } 3332 3333 template<class _CharT, class _Traits, class _Allocator> 3334 inline _LIBCPP_INLINE_VISIBILITY 3335 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3336 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str, 3337 size_type __pos) const _NOEXCEPT 3338 { 3339 return __str_find_first_not_of<value_type, size_type, traits_type, npos> 3340 (data(), size(), __str.data(), __pos, __str.size()); 3341 } 3342 3343 template<class _CharT, class _Traits, class _Allocator> 3344 inline _LIBCPP_INLINE_VISIBILITY 3345 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3346 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(__self_view __sv, 3347 size_type __pos) const _NOEXCEPT 3348 { 3349 return __str_find_first_not_of<value_type, size_type, traits_type, npos> 3350 (data(), size(), __sv.data(), __pos, __sv.size()); 3351 } 3352 3353 template<class _CharT, class _Traits, class _Allocator> 3354 inline _LIBCPP_INLINE_VISIBILITY 3355 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3356 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s, 3357 size_type __pos) const _NOEXCEPT 3358 { 3359 _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr"); 3360 return __str_find_first_not_of<value_type, size_type, traits_type, npos> 3361 (data(), size(), __s, __pos, traits_type::length(__s)); 3362 } 3363 3364 template<class _CharT, class _Traits, class _Allocator> 3365 inline _LIBCPP_INLINE_VISIBILITY 3366 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3367 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c, 3368 size_type __pos) const _NOEXCEPT 3369 { 3370 return __str_find_first_not_of<value_type, size_type, traits_type, npos> 3371 (data(), size(), __c, __pos); 3372 } 3373 3374 // find_last_not_of 3375 3376 template<class _CharT, class _Traits, class _Allocator> 3377 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3378 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s, 3379 size_type __pos, 3380 size_type __n) const _NOEXCEPT 3381 { 3382 _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr"); 3383 return __str_find_last_not_of<value_type, size_type, traits_type, npos> 3384 (data(), size(), __s, __pos, __n); 3385 } 3386 3387 template<class _CharT, class _Traits, class _Allocator> 3388 inline _LIBCPP_INLINE_VISIBILITY 3389 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3390 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str, 3391 size_type __pos) const _NOEXCEPT 3392 { 3393 return __str_find_last_not_of<value_type, size_type, traits_type, npos> 3394 (data(), size(), __str.data(), __pos, __str.size()); 3395 } 3396 3397 template<class _CharT, class _Traits, class _Allocator> 3398 inline _LIBCPP_INLINE_VISIBILITY 3399 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3400 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(__self_view __sv, 3401 size_type __pos) const _NOEXCEPT 3402 { 3403 return __str_find_last_not_of<value_type, size_type, traits_type, npos> 3404 (data(), size(), __sv.data(), __pos, __sv.size()); 3405 } 3406 3407 template<class _CharT, class _Traits, class _Allocator> 3408 inline _LIBCPP_INLINE_VISIBILITY 3409 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3410 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s, 3411 size_type __pos) const _NOEXCEPT 3412 { 3413 _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr"); 3414 return __str_find_last_not_of<value_type, size_type, traits_type, npos> 3415 (data(), size(), __s, __pos, traits_type::length(__s)); 3416 } 3417 3418 template<class _CharT, class _Traits, class _Allocator> 3419 inline _LIBCPP_INLINE_VISIBILITY 3420 typename basic_string<_CharT, _Traits, _Allocator>::size_type 3421 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c, 3422 size_type __pos) const _NOEXCEPT 3423 { 3424 return __str_find_last_not_of<value_type, size_type, traits_type, npos> 3425 (data(), size(), __c, __pos); 3426 } 3427 3428 // compare 3429 3430 template <class _CharT, class _Traits, class _Allocator> 3431 inline _LIBCPP_INLINE_VISIBILITY 3432 int 3433 basic_string<_CharT, _Traits, _Allocator>::compare(__self_view __sv) const _NOEXCEPT 3434 { 3435 size_t __lhs_sz = size(); 3436 size_t __rhs_sz = __sv.size(); 3437 int __result = traits_type::compare(data(), __sv.data(), 3438 _VSTD::min(__lhs_sz, __rhs_sz)); 3439 if (__result != 0) 3440 return __result; 3441 if (__lhs_sz < __rhs_sz) 3442 return -1; 3443 if (__lhs_sz > __rhs_sz) 3444 return 1; 3445 return 0; 3446 } 3447 3448 template <class _CharT, class _Traits, class _Allocator> 3449 inline _LIBCPP_INLINE_VISIBILITY 3450 int 3451 basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT 3452 { 3453 return compare(__self_view(__str)); 3454 } 3455 3456 template <class _CharT, class _Traits, class _Allocator> 3457 int 3458 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 3459 size_type __n1, 3460 const value_type* __s, 3461 size_type __n2) const 3462 { 3463 _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr"); 3464 size_type __sz = size(); 3465 if (__pos1 > __sz || __n2 == npos) 3466 this->__throw_out_of_range(); 3467 size_type __rlen = _VSTD::min(__n1, __sz - __pos1); 3468 int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2)); 3469 if (__r == 0) 3470 { 3471 if (__rlen < __n2) 3472 __r = -1; 3473 else if (__rlen > __n2) 3474 __r = 1; 3475 } 3476 return __r; 3477 } 3478 3479 template <class _CharT, class _Traits, class _Allocator> 3480 inline _LIBCPP_INLINE_VISIBILITY 3481 int 3482 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 3483 size_type __n1, 3484 __self_view __sv) const 3485 { 3486 return compare(__pos1, __n1, __sv.data(), __sv.size()); 3487 } 3488 3489 template <class _CharT, class _Traits, class _Allocator> 3490 inline _LIBCPP_INLINE_VISIBILITY 3491 int 3492 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 3493 size_type __n1, 3494 const basic_string& __str) const 3495 { 3496 return compare(__pos1, __n1, __str.data(), __str.size()); 3497 } 3498 3499 template <class _CharT, class _Traits, class _Allocator> 3500 template <class _Tp> 3501 typename enable_if 3502 < 3503 __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 3504 int 3505 >::type 3506 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 3507 size_type __n1, 3508 const _Tp& __t, 3509 size_type __pos2, 3510 size_type __n2) const 3511 { 3512 __self_view __sv = __t; 3513 return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2)); 3514 } 3515 3516 template <class _CharT, class _Traits, class _Allocator> 3517 int 3518 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 3519 size_type __n1, 3520 const basic_string& __str, 3521 size_type __pos2, 3522 size_type __n2) const 3523 { 3524 return compare(__pos1, __n1, __self_view(__str), __pos2, __n2); 3525 } 3526 3527 template <class _CharT, class _Traits, class _Allocator> 3528 int 3529 basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT 3530 { 3531 _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr"); 3532 return compare(0, npos, __s, traits_type::length(__s)); 3533 } 3534 3535 template <class _CharT, class _Traits, class _Allocator> 3536 int 3537 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 3538 size_type __n1, 3539 const value_type* __s) const 3540 { 3541 _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr"); 3542 return compare(__pos1, __n1, __s, traits_type::length(__s)); 3543 } 3544 3545 // __invariants 3546 3547 template<class _CharT, class _Traits, class _Allocator> 3548 inline _LIBCPP_INLINE_VISIBILITY 3549 bool 3550 basic_string<_CharT, _Traits, _Allocator>::__invariants() const 3551 { 3552 if (size() > capacity()) 3553 return false; 3554 if (capacity() < __min_cap - 1) 3555 return false; 3556 if (data() == 0) 3557 return false; 3558 if (data()[size()] != value_type(0)) 3559 return false; 3560 return true; 3561 } 3562 3563 // operator== 3564 3565 template<class _CharT, class _Traits, class _Allocator> 3566 inline _LIBCPP_INLINE_VISIBILITY 3567 bool 3568 operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3569 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3570 { 3571 size_t __lhs_sz = __lhs.size(); 3572 return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(), 3573 __rhs.data(), 3574 __lhs_sz) == 0; 3575 } 3576 3577 template<class _Allocator> 3578 inline _LIBCPP_INLINE_VISIBILITY 3579 bool 3580 operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs, 3581 const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT 3582 { 3583 size_t __lhs_sz = __lhs.size(); 3584 if (__lhs_sz != __rhs.size()) 3585 return false; 3586 const char* __lp = __lhs.data(); 3587 const char* __rp = __rhs.data(); 3588 if (__lhs.__is_long()) 3589 return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0; 3590 for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp) 3591 if (*__lp != *__rp) 3592 return false; 3593 return true; 3594 } 3595 3596 template<class _CharT, class _Traits, class _Allocator> 3597 inline _LIBCPP_INLINE_VISIBILITY 3598 bool 3599 operator==(const _CharT* __lhs, 3600 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3601 { 3602 typedef basic_string<_CharT, _Traits, _Allocator> _String; 3603 _LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr"); 3604 size_t __lhs_len = _Traits::length(__lhs); 3605 if (__lhs_len != __rhs.size()) return false; 3606 return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0; 3607 } 3608 3609 template<class _CharT, class _Traits, class _Allocator> 3610 inline _LIBCPP_INLINE_VISIBILITY 3611 bool 3612 operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs, 3613 const _CharT* __rhs) _NOEXCEPT 3614 { 3615 typedef basic_string<_CharT, _Traits, _Allocator> _String; 3616 _LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr"); 3617 size_t __rhs_len = _Traits::length(__rhs); 3618 if (__rhs_len != __lhs.size()) return false; 3619 return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0; 3620 } 3621 3622 template<class _CharT, class _Traits, class _Allocator> 3623 inline _LIBCPP_INLINE_VISIBILITY 3624 bool 3625 operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, 3626 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3627 { 3628 return !(__lhs == __rhs); 3629 } 3630 3631 template<class _CharT, class _Traits, class _Allocator> 3632 inline _LIBCPP_INLINE_VISIBILITY 3633 bool 3634 operator!=(const _CharT* __lhs, 3635 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3636 { 3637 return !(__lhs == __rhs); 3638 } 3639 3640 template<class _CharT, class _Traits, class _Allocator> 3641 inline _LIBCPP_INLINE_VISIBILITY 3642 bool 3643 operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3644 const _CharT* __rhs) _NOEXCEPT 3645 { 3646 return !(__lhs == __rhs); 3647 } 3648 3649 // operator< 3650 3651 template<class _CharT, class _Traits, class _Allocator> 3652 inline _LIBCPP_INLINE_VISIBILITY 3653 bool 3654 operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3655 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3656 { 3657 return __lhs.compare(__rhs) < 0; 3658 } 3659 3660 template<class _CharT, class _Traits, class _Allocator> 3661 inline _LIBCPP_INLINE_VISIBILITY 3662 bool 3663 operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3664 const _CharT* __rhs) _NOEXCEPT 3665 { 3666 return __lhs.compare(__rhs) < 0; 3667 } 3668 3669 template<class _CharT, class _Traits, class _Allocator> 3670 inline _LIBCPP_INLINE_VISIBILITY 3671 bool 3672 operator< (const _CharT* __lhs, 3673 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3674 { 3675 return __rhs.compare(__lhs) > 0; 3676 } 3677 3678 // operator> 3679 3680 template<class _CharT, class _Traits, class _Allocator> 3681 inline _LIBCPP_INLINE_VISIBILITY 3682 bool 3683 operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3684 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3685 { 3686 return __rhs < __lhs; 3687 } 3688 3689 template<class _CharT, class _Traits, class _Allocator> 3690 inline _LIBCPP_INLINE_VISIBILITY 3691 bool 3692 operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3693 const _CharT* __rhs) _NOEXCEPT 3694 { 3695 return __rhs < __lhs; 3696 } 3697 3698 template<class _CharT, class _Traits, class _Allocator> 3699 inline _LIBCPP_INLINE_VISIBILITY 3700 bool 3701 operator> (const _CharT* __lhs, 3702 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3703 { 3704 return __rhs < __lhs; 3705 } 3706 3707 // operator<= 3708 3709 template<class _CharT, class _Traits, class _Allocator> 3710 inline _LIBCPP_INLINE_VISIBILITY 3711 bool 3712 operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3713 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3714 { 3715 return !(__rhs < __lhs); 3716 } 3717 3718 template<class _CharT, class _Traits, class _Allocator> 3719 inline _LIBCPP_INLINE_VISIBILITY 3720 bool 3721 operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3722 const _CharT* __rhs) _NOEXCEPT 3723 { 3724 return !(__rhs < __lhs); 3725 } 3726 3727 template<class _CharT, class _Traits, class _Allocator> 3728 inline _LIBCPP_INLINE_VISIBILITY 3729 bool 3730 operator<=(const _CharT* __lhs, 3731 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3732 { 3733 return !(__rhs < __lhs); 3734 } 3735 3736 // operator>= 3737 3738 template<class _CharT, class _Traits, class _Allocator> 3739 inline _LIBCPP_INLINE_VISIBILITY 3740 bool 3741 operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3742 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3743 { 3744 return !(__lhs < __rhs); 3745 } 3746 3747 template<class _CharT, class _Traits, class _Allocator> 3748 inline _LIBCPP_INLINE_VISIBILITY 3749 bool 3750 operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3751 const _CharT* __rhs) _NOEXCEPT 3752 { 3753 return !(__lhs < __rhs); 3754 } 3755 3756 template<class _CharT, class _Traits, class _Allocator> 3757 inline _LIBCPP_INLINE_VISIBILITY 3758 bool 3759 operator>=(const _CharT* __lhs, 3760 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3761 { 3762 return !(__lhs < __rhs); 3763 } 3764 3765 // operator + 3766 3767 template<class _CharT, class _Traits, class _Allocator> 3768 basic_string<_CharT, _Traits, _Allocator> 3769 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3770 const basic_string<_CharT, _Traits, _Allocator>& __rhs) 3771 { 3772 basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator()); 3773 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size(); 3774 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size(); 3775 __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz); 3776 __r.append(__rhs.data(), __rhs_sz); 3777 return __r; 3778 } 3779 3780 template<class _CharT, class _Traits, class _Allocator> 3781 basic_string<_CharT, _Traits, _Allocator> 3782 operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs) 3783 { 3784 basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator()); 3785 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = _Traits::length(__lhs); 3786 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size(); 3787 __r.__init(__lhs, __lhs_sz, __lhs_sz + __rhs_sz); 3788 __r.append(__rhs.data(), __rhs_sz); 3789 return __r; 3790 } 3791 3792 template<class _CharT, class _Traits, class _Allocator> 3793 basic_string<_CharT, _Traits, _Allocator> 3794 operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs) 3795 { 3796 basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator()); 3797 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size(); 3798 __r.__init(&__lhs, 1, 1 + __rhs_sz); 3799 __r.append(__rhs.data(), __rhs_sz); 3800 return __r; 3801 } 3802 3803 template<class _CharT, class _Traits, class _Allocator> 3804 basic_string<_CharT, _Traits, _Allocator> 3805 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) 3806 { 3807 basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator()); 3808 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size(); 3809 typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = _Traits::length(__rhs); 3810 __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz); 3811 __r.append(__rhs, __rhs_sz); 3812 return __r; 3813 } 3814 3815 template<class _CharT, class _Traits, class _Allocator> 3816 basic_string<_CharT, _Traits, _Allocator> 3817 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs) 3818 { 3819 basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator()); 3820 typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size(); 3821 __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + 1); 3822 __r.push_back(__rhs); 3823 return __r; 3824 } 3825 3826 #ifndef _LIBCPP_CXX03_LANG 3827 3828 template<class _CharT, class _Traits, class _Allocator> 3829 inline _LIBCPP_INLINE_VISIBILITY 3830 basic_string<_CharT, _Traits, _Allocator> 3831 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) 3832 { 3833 return _VSTD::move(__lhs.append(__rhs)); 3834 } 3835 3836 template<class _CharT, class _Traits, class _Allocator> 3837 inline _LIBCPP_INLINE_VISIBILITY 3838 basic_string<_CharT, _Traits, _Allocator> 3839 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) 3840 { 3841 return _VSTD::move(__rhs.insert(0, __lhs)); 3842 } 3843 3844 template<class _CharT, class _Traits, class _Allocator> 3845 inline _LIBCPP_INLINE_VISIBILITY 3846 basic_string<_CharT, _Traits, _Allocator> 3847 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) 3848 { 3849 return _VSTD::move(__lhs.append(__rhs)); 3850 } 3851 3852 template<class _CharT, class _Traits, class _Allocator> 3853 inline _LIBCPP_INLINE_VISIBILITY 3854 basic_string<_CharT, _Traits, _Allocator> 3855 operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs) 3856 { 3857 return _VSTD::move(__rhs.insert(0, __lhs)); 3858 } 3859 3860 template<class _CharT, class _Traits, class _Allocator> 3861 inline _LIBCPP_INLINE_VISIBILITY 3862 basic_string<_CharT, _Traits, _Allocator> 3863 operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs) 3864 { 3865 __rhs.insert(__rhs.begin(), __lhs); 3866 return _VSTD::move(__rhs); 3867 } 3868 3869 template<class _CharT, class _Traits, class _Allocator> 3870 inline _LIBCPP_INLINE_VISIBILITY 3871 basic_string<_CharT, _Traits, _Allocator> 3872 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs) 3873 { 3874 return _VSTD::move(__lhs.append(__rhs)); 3875 } 3876 3877 template<class _CharT, class _Traits, class _Allocator> 3878 inline _LIBCPP_INLINE_VISIBILITY 3879 basic_string<_CharT, _Traits, _Allocator> 3880 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs) 3881 { 3882 __lhs.push_back(__rhs); 3883 return _VSTD::move(__lhs); 3884 } 3885 3886 #endif // _LIBCPP_CXX03_LANG 3887 3888 // swap 3889 3890 template<class _CharT, class _Traits, class _Allocator> 3891 inline _LIBCPP_INLINE_VISIBILITY 3892 void 3893 swap(basic_string<_CharT, _Traits, _Allocator>& __lhs, 3894 basic_string<_CharT, _Traits, _Allocator>& __rhs) 3895 _NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs))) 3896 { 3897 __lhs.swap(__rhs); 3898 } 3899 3900 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS 3901 3902 typedef basic_string<char16_t> u16string; 3903 typedef basic_string<char32_t> u32string; 3904 3905 #endif // _LIBCPP_HAS_NO_UNICODE_CHARS 3906 3907 _LIBCPP_FUNC_VIS int stoi (const string& __str, size_t* __idx = 0, int __base = 10); 3908 _LIBCPP_FUNC_VIS long stol (const string& __str, size_t* __idx = 0, int __base = 10); 3909 _LIBCPP_FUNC_VIS unsigned long stoul (const string& __str, size_t* __idx = 0, int __base = 10); 3910 _LIBCPP_FUNC_VIS long long stoll (const string& __str, size_t* __idx = 0, int __base = 10); 3911 _LIBCPP_FUNC_VIS unsigned long long stoull(const string& __str, size_t* __idx = 0, int __base = 10); 3912 3913 _LIBCPP_FUNC_VIS float stof (const string& __str, size_t* __idx = 0); 3914 _LIBCPP_FUNC_VIS double stod (const string& __str, size_t* __idx = 0); 3915 _LIBCPP_FUNC_VIS long double stold(const string& __str, size_t* __idx = 0); 3916 3917 _LIBCPP_FUNC_VIS string to_string(int __val); 3918 _LIBCPP_FUNC_VIS string to_string(unsigned __val); 3919 _LIBCPP_FUNC_VIS string to_string(long __val); 3920 _LIBCPP_FUNC_VIS string to_string(unsigned long __val); 3921 _LIBCPP_FUNC_VIS string to_string(long long __val); 3922 _LIBCPP_FUNC_VIS string to_string(unsigned long long __val); 3923 _LIBCPP_FUNC_VIS string to_string(float __val); 3924 _LIBCPP_FUNC_VIS string to_string(double __val); 3925 _LIBCPP_FUNC_VIS string to_string(long double __val); 3926 3927 _LIBCPP_FUNC_VIS int stoi (const wstring& __str, size_t* __idx = 0, int __base = 10); 3928 _LIBCPP_FUNC_VIS long stol (const wstring& __str, size_t* __idx = 0, int __base = 10); 3929 _LIBCPP_FUNC_VIS unsigned long stoul (const wstring& __str, size_t* __idx = 0, int __base = 10); 3930 _LIBCPP_FUNC_VIS long long stoll (const wstring& __str, size_t* __idx = 0, int __base = 10); 3931 _LIBCPP_FUNC_VIS unsigned long long stoull(const wstring& __str, size_t* __idx = 0, int __base = 10); 3932 3933 _LIBCPP_FUNC_VIS float stof (const wstring& __str, size_t* __idx = 0); 3934 _LIBCPP_FUNC_VIS double stod (const wstring& __str, size_t* __idx = 0); 3935 _LIBCPP_FUNC_VIS long double stold(const wstring& __str, size_t* __idx = 0); 3936 3937 _LIBCPP_FUNC_VIS wstring to_wstring(int __val); 3938 _LIBCPP_FUNC_VIS wstring to_wstring(unsigned __val); 3939 _LIBCPP_FUNC_VIS wstring to_wstring(long __val); 3940 _LIBCPP_FUNC_VIS wstring to_wstring(unsigned long __val); 3941 _LIBCPP_FUNC_VIS wstring to_wstring(long long __val); 3942 _LIBCPP_FUNC_VIS wstring to_wstring(unsigned long long __val); 3943 _LIBCPP_FUNC_VIS wstring to_wstring(float __val); 3944 _LIBCPP_FUNC_VIS wstring to_wstring(double __val); 3945 _LIBCPP_FUNC_VIS wstring to_wstring(long double __val); 3946 3947 template<class _CharT, class _Traits, class _Allocator> 3948 const typename basic_string<_CharT, _Traits, _Allocator>::size_type 3949 basic_string<_CharT, _Traits, _Allocator>::npos; 3950 3951 template<class _CharT, class _Traits, class _Allocator> 3952 struct _LIBCPP_TEMPLATE_VIS hash<basic_string<_CharT, _Traits, _Allocator> > 3953 : public unary_function<basic_string<_CharT, _Traits, _Allocator>, size_t> 3954 { 3955 size_t 3956 operator()(const basic_string<_CharT, _Traits, _Allocator>& __val) const _NOEXCEPT; 3957 }; 3958 3959 template<class _CharT, class _Traits, class _Allocator> 3960 size_t 3961 hash<basic_string<_CharT, _Traits, _Allocator> >::operator()( 3962 const basic_string<_CharT, _Traits, _Allocator>& __val) const _NOEXCEPT 3963 { 3964 return __do_string_hash(__val.data(), __val.data() + __val.size()); 3965 } 3966 3967 template<class _CharT, class _Traits, class _Allocator> 3968 basic_ostream<_CharT, _Traits>& 3969 operator<<(basic_ostream<_CharT, _Traits>& __os, 3970 const basic_string<_CharT, _Traits, _Allocator>& __str); 3971 3972 template<class _CharT, class _Traits, class _Allocator> 3973 basic_istream<_CharT, _Traits>& 3974 operator>>(basic_istream<_CharT, _Traits>& __is, 3975 basic_string<_CharT, _Traits, _Allocator>& __str); 3976 3977 template<class _CharT, class _Traits, class _Allocator> 3978 basic_istream<_CharT, _Traits>& 3979 getline(basic_istream<_CharT, _Traits>& __is, 3980 basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm); 3981 3982 template<class _CharT, class _Traits, class _Allocator> 3983 inline _LIBCPP_INLINE_VISIBILITY 3984 basic_istream<_CharT, _Traits>& 3985 getline(basic_istream<_CharT, _Traits>& __is, 3986 basic_string<_CharT, _Traits, _Allocator>& __str); 3987 3988 #ifndef _LIBCPP_CXX03_LANG 3989 3990 template<class _CharT, class _Traits, class _Allocator> 3991 inline _LIBCPP_INLINE_VISIBILITY 3992 basic_istream<_CharT, _Traits>& 3993 getline(basic_istream<_CharT, _Traits>&& __is, 3994 basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm); 3995 3996 template<class _CharT, class _Traits, class _Allocator> 3997 inline _LIBCPP_INLINE_VISIBILITY 3998 basic_istream<_CharT, _Traits>& 3999 getline(basic_istream<_CharT, _Traits>&& __is, 4000 basic_string<_CharT, _Traits, _Allocator>& __str); 4001 4002 #endif // _LIBCPP_CXX03_LANG 4003 4004 #if _LIBCPP_DEBUG_LEVEL >= 2 4005 4006 template<class _CharT, class _Traits, class _Allocator> 4007 bool 4008 basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const 4009 { 4010 return this->data() <= _VSTD::__to_raw_pointer(__i->base()) && 4011 _VSTD::__to_raw_pointer(__i->base()) < this->data() + this->size(); 4012 } 4013 4014 template<class _CharT, class _Traits, class _Allocator> 4015 bool 4016 basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const 4017 { 4018 return this->data() < _VSTD::__to_raw_pointer(__i->base()) && 4019 _VSTD::__to_raw_pointer(__i->base()) <= this->data() + this->size(); 4020 } 4021 4022 template<class _CharT, class _Traits, class _Allocator> 4023 bool 4024 basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const 4025 { 4026 const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n; 4027 return this->data() <= __p && __p <= this->data() + this->size(); 4028 } 4029 4030 template<class _CharT, class _Traits, class _Allocator> 4031 bool 4032 basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const 4033 { 4034 const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n; 4035 return this->data() <= __p && __p < this->data() + this->size(); 4036 } 4037 4038 #endif // _LIBCPP_DEBUG_LEVEL >= 2 4039 4040 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<char>) 4041 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<wchar_t>) 4042 4043 #if _LIBCPP_STD_VER > 11 4044 // Literal suffixes for basic_string [basic.string.literals] 4045 inline namespace literals 4046 { 4047 inline namespace string_literals 4048 { 4049 inline _LIBCPP_INLINE_VISIBILITY 4050 basic_string<char> operator "" s( const char *__str, size_t __len ) 4051 { 4052 return basic_string<char> (__str, __len); 4053 } 4054 4055 inline _LIBCPP_INLINE_VISIBILITY 4056 basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len ) 4057 { 4058 return basic_string<wchar_t> (__str, __len); 4059 } 4060 4061 inline _LIBCPP_INLINE_VISIBILITY 4062 basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len ) 4063 { 4064 return basic_string<char16_t> (__str, __len); 4065 } 4066 4067 inline _LIBCPP_INLINE_VISIBILITY 4068 basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len ) 4069 { 4070 return basic_string<char32_t> (__str, __len); 4071 } 4072 } 4073 } 4074 #endif 4075 4076 _LIBCPP_END_NAMESPACE_STD 4077 4078 _LIBCPP_POP_MACROS 4079 4080 #endif // _LIBCPP_STRING 4081
