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