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 17namespace std 18{ 19 20template <class stateT> 21class fpos 22{ 23private: 24 stateT st; 25public: 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 39template <class stateT> streamoff operator-(const fpos<stateT>& x, const fpos<stateT>& y); 40 41template <class stateT> bool operator==(const fpos<stateT>& x, const fpos<stateT>& y); 42template <class stateT> bool operator!=(const fpos<stateT>& x, const fpos<stateT>& y); 43 44template <class charT> 45struct 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 71template <> struct char_traits<char>; 72template <> struct char_traits<wchar_t>; 73 74template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > 75class basic_string 76{ 77public: 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 272template<class charT, class traits, class Allocator> 273basic_string<charT, traits, Allocator> 274operator+(const basic_string<charT, traits, Allocator>& lhs, 275 const basic_string<charT, traits, Allocator>& rhs); 276 277template<class charT, class traits, class Allocator> 278basic_string<charT, traits, Allocator> 279operator+(const charT* lhs , const basic_string<charT,traits,Allocator>&rhs); 280 281template<class charT, class traits, class Allocator> 282basic_string<charT, traits, Allocator> 283operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs); 284 285template<class charT, class traits, class Allocator> 286basic_string<charT, traits, Allocator> 287operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs); 288 289template<class charT, class traits, class Allocator> 290basic_string<charT, traits, Allocator> 291operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs); 292 293template<class charT, class traits, class Allocator> 294bool operator==(const basic_string<charT, traits, Allocator>& lhs, 295 const basic_string<charT, traits, Allocator>& rhs) noexcept; 296 297template<class charT, class traits, class Allocator> 298bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 299 300template<class charT, class traits, class Allocator> 301bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept; 302 303template<class charT, class traits, class Allocator> 304bool operator!=(const basic_string<charT,traits,Allocator>& lhs, 305 const basic_string<charT, traits, Allocator>& rhs) noexcept; 306 307template<class charT, class traits, class Allocator> 308bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 309 310template<class charT, class traits, class Allocator> 311bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 312 313template<class charT, class traits, class Allocator> 314bool operator< (const basic_string<charT, traits, Allocator>& lhs, 315 const basic_string<charT, traits, Allocator>& rhs) noexcept; 316 317template<class charT, class traits, class Allocator> 318bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 319 320template<class charT, class traits, class Allocator> 321bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 322 323template<class charT, class traits, class Allocator> 324bool operator> (const basic_string<charT, traits, Allocator>& lhs, 325 const basic_string<charT, traits, Allocator>& rhs) noexcept; 326 327template<class charT, class traits, class Allocator> 328bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 329 330template<class charT, class traits, class Allocator> 331bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 332 333template<class charT, class traits, class Allocator> 334bool operator<=(const basic_string<charT, traits, Allocator>& lhs, 335 const basic_string<charT, traits, Allocator>& rhs) noexcept; 336 337template<class charT, class traits, class Allocator> 338bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 339 340template<class charT, class traits, class Allocator> 341bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 342 343template<class charT, class traits, class Allocator> 344bool operator>=(const basic_string<charT, traits, Allocator>& lhs, 345 const basic_string<charT, traits, Allocator>& rhs) noexcept; 346 347template<class charT, class traits, class Allocator> 348bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 349 350template<class charT, class traits, class Allocator> 351bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 352 353template<class charT, class traits, class Allocator> 354void swap(basic_string<charT, traits, Allocator>& lhs, 355 basic_string<charT, traits, Allocator>& rhs) 356 noexcept(noexcept(lhs.swap(rhs))); 357 358template<class charT, class traits, class Allocator> 359basic_istream<charT, traits>& 360operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str); 361 362template<class charT, class traits, class Allocator> 363basic_ostream<charT, traits>& 364operator<<(basic_ostream<charT, traits>& os, const basic_string<charT, traits, Allocator>& str); 365 366template<class charT, class traits, class Allocator> 367basic_istream<charT, traits>& 368getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str, 369 charT delim); 370 371template<class charT, class traits, class Allocator> 372basic_istream<charT, traits>& 373getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str); 374 375typedef basic_string<char> string; 376typedef basic_string<wchar_t> wstring; 377typedef basic_string<char16_t> u16string; 378typedef basic_string<char32_t> u32string; 379 380int stoi (const string& str, size_t* idx = 0, int base = 10); 381long stol (const string& str, size_t* idx = 0, int base = 10); 382unsigned long stoul (const string& str, size_t* idx = 0, int base = 10); 383long long stoll (const string& str, size_t* idx = 0, int base = 10); 384unsigned long long stoull(const string& str, size_t* idx = 0, int base = 10); 385 386float stof (const string& str, size_t* idx = 0); 387double stod (const string& str, size_t* idx = 0); 388long double stold(const string& str, size_t* idx = 0); 389 390string to_string(int val); 391string to_string(unsigned val); 392string to_string(long val); 393string to_string(unsigned long val); 394string to_string(long long val); 395string to_string(unsigned long long val); 396string to_string(float val); 397string to_string(double val); 398string to_string(long double val); 399 400int stoi (const wstring& str, size_t* idx = 0, int base = 10); 401long stol (const wstring& str, size_t* idx = 0, int base = 10); 402unsigned long stoul (const wstring& str, size_t* idx = 0, int base = 10); 403long long stoll (const wstring& str, size_t* idx = 0, int base = 10); 404unsigned long long stoull(const wstring& str, size_t* idx = 0, int base = 10); 405 406float stof (const wstring& str, size_t* idx = 0); 407double stod (const wstring& str, size_t* idx = 0); 408long double stold(const wstring& str, size_t* idx = 0); 409 410wstring to_wstring(int val); 411wstring to_wstring(unsigned val); 412wstring to_wstring(long val); 413wstring to_wstring(unsigned long val); 414wstring to_wstring(long long val); 415wstring to_wstring(unsigned long long val); 416wstring to_wstring(float val); 417wstring to_wstring(double val); 418wstring to_wstring(long double val); 419 420template <> struct hash<string>; 421template <> struct hash<u16string>; 422template <> struct hash<u32string>; 423template <> 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 459template <class _StateT> 460class _LIBCPP_VISIBLE fpos 461{ 462private: 463 _StateT __st_; 464 streamoff __off_; 465public: 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 479template <class _StateT> 480inline _LIBCPP_INLINE_VISIBILITY 481streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y) 482 {return streamoff(__x) - streamoff(__y);} 483 484template <class _StateT> 485inline _LIBCPP_INLINE_VISIBILITY 486bool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y) 487 {return streamoff(__x) == streamoff(__y);} 488 489template <class _StateT> 490inline _LIBCPP_INLINE_VISIBILITY 491bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y) 492 {return streamoff(__x) != streamoff(__y);} 493 494// char_traits 495 496template <class _CharT> 497struct _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 539template <class _CharT> 540int 541char_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 553template <class _CharT> 554inline _LIBCPP_INLINE_VISIBILITY 555size_t 556char_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 564template <class _CharT> 565inline _LIBCPP_INLINE_VISIBILITY 566const _CharT* 567char_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 578template <class _CharT> 579_CharT* 580char_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 598template <class _CharT> 599inline _LIBCPP_INLINE_VISIBILITY 600_CharT* 601char_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 609template <class _CharT> 610inline _LIBCPP_INLINE_VISIBILITY 611_CharT* 612char_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 622template <> 623struct _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 678template <> 679struct _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 735template <> 736struct _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 778inline _LIBCPP_INLINE_VISIBILITY 779int 780char_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 792inline _LIBCPP_INLINE_VISIBILITY 793size_t 794char_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 802inline _LIBCPP_INLINE_VISIBILITY 803const char16_t* 804char_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 815inline _LIBCPP_INLINE_VISIBILITY 816char16_t* 817char_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 835inline _LIBCPP_INLINE_VISIBILITY 836char16_t* 837char_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 845inline _LIBCPP_INLINE_VISIBILITY 846char16_t* 847char_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 855template <> 856struct _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 898inline _LIBCPP_INLINE_VISIBILITY 899int 900char_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 912inline _LIBCPP_INLINE_VISIBILITY 913size_t 914char_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 922inline _LIBCPP_INLINE_VISIBILITY 923const char32_t* 924char_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 935inline _LIBCPP_INLINE_VISIBILITY 936char32_t* 937char_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 955inline _LIBCPP_INLINE_VISIBILITY 956char32_t* 957char_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 965inline _LIBCPP_INLINE_VISIBILITY 966char32_t* 967char_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 979template<class _CharT, class _Traits, class _Allocator> 980basic_string<_CharT, _Traits, _Allocator> 981operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, 982 const basic_string<_CharT, _Traits, _Allocator>& __y); 983 984template<class _CharT, class _Traits, class _Allocator> 985basic_string<_CharT, _Traits, _Allocator> 986operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y); 987 988template<class _CharT, class _Traits, class _Allocator> 989basic_string<_CharT, _Traits, _Allocator> 990operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y); 991 992template<class _CharT, class _Traits, class _Allocator> 993basic_string<_CharT, _Traits, _Allocator> 994operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y); 995 996template<class _CharT, class _Traits, class _Allocator> 997basic_string<_CharT, _Traits, _Allocator> 998operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y); 999 1000template <bool> 1001class __basic_string_common 1002{ 1003protected: 1004 void __throw_length_error() const; 1005 void __throw_out_of_range() const; 1006}; 1007 1008template <bool __b> 1009void 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 1019template <bool __b> 1020void 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 1039template<class _CharT, class _Traits, class _Allocator> 1040class _LIBCPP_VISIBLE basic_string 1041 : private __basic_string_common<true> 1042{ 1043public: 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 1071private: 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 1132public: 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; 1465private: 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 1656template <class _CharT, class _Traits, class _Allocator> 1657#ifndef _LIBCPP_DEBUG 1658_LIBCPP_INLINE_VISIBILITY inline 1659#endif 1660void 1661basic_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 1669template <class _CharT, class _Traits, class _Allocator> 1670#ifndef _LIBCPP_DEBUG 1671_LIBCPP_INLINE_VISIBILITY inline 1672#endif 1673void 1674basic_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 1713template <class _CharT, class _Traits, class _Allocator> 1714_LIBCPP_INLINE_VISIBILITY inline 1715basic_string<_CharT, _Traits, _Allocator>::basic_string() 1716 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) 1717{ 1718 __zero(); 1719} 1720 1721template <class _CharT, class _Traits, class _Allocator> 1722_LIBCPP_INLINE_VISIBILITY inline 1723basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a) 1724 : __r_(__a) 1725{ 1726 __zero(); 1727} 1728 1729template <class _CharT, class _Traits, class _Allocator> 1730void 1731basic_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 1753template <class _CharT, class _Traits, class _Allocator> 1754void 1755basic_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 1777template <class _CharT, class _Traits, class _Allocator> 1778_LIBCPP_INLINE_VISIBILITY inline 1779basic_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 1787template <class _CharT, class _Traits, class _Allocator> 1788_LIBCPP_INLINE_VISIBILITY inline 1789basic_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 1798template <class _CharT, class _Traits, class _Allocator> 1799_LIBCPP_INLINE_VISIBILITY inline 1800basic_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 1808template <class _CharT, class _Traits, class _Allocator> 1809_LIBCPP_INLINE_VISIBILITY inline 1810basic_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 1819template <class _CharT, class _Traits, class _Allocator> 1820basic_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 1829template <class _CharT, class _Traits, class _Allocator> 1830basic_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 1841template <class _CharT, class _Traits, class _Allocator> 1842_LIBCPP_INLINE_VISIBILITY inline 1843basic_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 1853template <class _CharT, class _Traits, class _Allocator> 1854_LIBCPP_INLINE_VISIBILITY inline 1855basic_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 1870template <class _CharT, class _Traits, class _Allocator> 1871void 1872basic_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 1894template <class _CharT, class _Traits, class _Allocator> 1895_LIBCPP_INLINE_VISIBILITY inline 1896basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, value_type __c) 1897{ 1898 __init(__n, __c); 1899} 1900 1901template <class _CharT, class _Traits, class _Allocator> 1902_LIBCPP_INLINE_VISIBILITY inline 1903basic_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 1909template <class _CharT, class _Traits, class _Allocator> 1910basic_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 1920template <class _CharT, class _Traits, class _Allocator> 1921template <class _InputIterator> 1922typename enable_if 1923< 1924 __is_input_iterator <_InputIterator>::value && 1925 !__is_forward_iterator<_InputIterator>::value, 1926 void 1927>::type 1928basic_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 1948template <class _CharT, class _Traits, class _Allocator> 1949template <class _ForwardIterator> 1950typename enable_if 1951< 1952 __is_forward_iterator<_ForwardIterator>::value, 1953 void 1954>::type 1955basic_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 1979template <class _CharT, class _Traits, class _Allocator> 1980template<class _InputIterator> 1981_LIBCPP_INLINE_VISIBILITY inline 1982basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last) 1983{ 1984 __init(__first, __last); 1985} 1986 1987template <class _CharT, class _Traits, class _Allocator> 1988template<class _InputIterator> 1989_LIBCPP_INLINE_VISIBILITY inline 1990basic_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 1999template <class _CharT, class _Traits, class _Allocator> 2000_LIBCPP_INLINE_VISIBILITY inline 2001basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_type> __il) 2002{ 2003 __init(__il.begin(), __il.end()); 2004} 2005 2006template <class _CharT, class _Traits, class _Allocator> 2007_LIBCPP_INLINE_VISIBILITY inline 2008basic_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 2016template <class _CharT, class _Traits, class _Allocator> 2017basic_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 2024template <class _CharT, class _Traits, class _Allocator> 2025void 2026basic_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 2055template <class _CharT, class _Traits, class _Allocator> 2056void 2057basic_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 2082template <class _CharT, class _Traits, class _Allocator> 2083basic_string<_CharT, _Traits, _Allocator>& 2084basic_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 2106template <class _CharT, class _Traits, class _Allocator> 2107basic_string<_CharT, _Traits, _Allocator>& 2108basic_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 2125template <class _CharT, class _Traits, class _Allocator> 2126basic_string<_CharT, _Traits, _Allocator>& 2127basic_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 2146template <class _CharT, class _Traits, class _Allocator> 2147basic_string<_CharT, _Traits, _Allocator>& 2148basic_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 2160template <class _CharT, class _Traits, class _Allocator> 2161_LIBCPP_INLINE_VISIBILITY inline 2162void 2163basic_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 2171template <class _CharT, class _Traits, class _Allocator> 2172_LIBCPP_INLINE_VISIBILITY inline 2173void 2174basic_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 2184template <class _CharT, class _Traits, class _Allocator> 2185_LIBCPP_INLINE_VISIBILITY inline 2186basic_string<_CharT, _Traits, _Allocator>& 2187basic_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 2198template <class _CharT, class _Traits, class _Allocator> 2199template<class _InputIterator> 2200typename enable_if 2201< 2202 __is_input_iterator <_InputIterator>::value && 2203 !__is_forward_iterator<_InputIterator>::value, 2204 basic_string<_CharT, _Traits, _Allocator>& 2205>::type 2206basic_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 2214template <class _CharT, class _Traits, class _Allocator> 2215template<class _ForwardIterator> 2216typename enable_if 2217< 2218 __is_forward_iterator<_ForwardIterator>::value, 2219 basic_string<_CharT, _Traits, _Allocator>& 2220>::type 2221basic_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 2240template <class _CharT, class _Traits, class _Allocator> 2241_LIBCPP_INLINE_VISIBILITY inline 2242basic_string<_CharT, _Traits, _Allocator>& 2243basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str) 2244{ 2245 return assign(__str.data(), __str.size()); 2246} 2247 2248template <class _CharT, class _Traits, class _Allocator> 2249basic_string<_CharT, _Traits, _Allocator>& 2250basic_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 2258template <class _CharT, class _Traits, class _Allocator> 2259basic_string<_CharT, _Traits, _Allocator>& 2260basic_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 2270template <class _CharT, class _Traits, class _Allocator> 2271basic_string<_CharT, _Traits, _Allocator>& 2272basic_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 2295template <class _CharT, class _Traits, class _Allocator> 2296basic_string<_CharT, _Traits, _Allocator>& 2297basic_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 2314template <class _CharT, class _Traits, class _Allocator> 2315void 2316basic_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 2328template <class _CharT, class _Traits, class _Allocator> 2329template<class _InputIterator> 2330typename enable_if 2331< 2332 __is_input_iterator <_InputIterator>::value && 2333 !__is_forward_iterator<_InputIterator>::value, 2334 basic_string<_CharT, _Traits, _Allocator>& 2335>::type 2336basic_string<_CharT, _Traits, _Allocator>::append(_InputIterator __first, _InputIterator __last) 2337{ 2338 for (; __first != __last; ++__first) 2339 push_back(*__first); 2340 return *this; 2341} 2342 2343template <class _CharT, class _Traits, class _Allocator> 2344template<class _ForwardIterator> 2345typename enable_if 2346< 2347 __is_forward_iterator<_ForwardIterator>::value, 2348 basic_string<_CharT, _Traits, _Allocator>& 2349>::type 2350basic_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 2368template <class _CharT, class _Traits, class _Allocator> 2369_LIBCPP_INLINE_VISIBILITY inline 2370basic_string<_CharT, _Traits, _Allocator>& 2371basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str) 2372{ 2373 return append(__str.data(), __str.size()); 2374} 2375 2376template <class _CharT, class _Traits, class _Allocator> 2377basic_string<_CharT, _Traits, _Allocator>& 2378basic_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 2386template <class _CharT, class _Traits, class _Allocator> 2387basic_string<_CharT, _Traits, _Allocator>& 2388basic_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 2398template <class _CharT, class _Traits, class _Allocator> 2399basic_string<_CharT, _Traits, _Allocator>& 2400basic_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 2432template <class _CharT, class _Traits, class _Allocator> 2433basic_string<_CharT, _Traits, _Allocator>& 2434basic_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 2463template <class _CharT, class _Traits, class _Allocator> 2464template<class _InputIterator> 2465typename 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 2471basic_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 2482template <class _CharT, class _Traits, class _Allocator> 2483template<class _ForwardIterator> 2484typename enable_if 2485< 2486 __is_forward_iterator<_ForwardIterator>::value, 2487 typename basic_string<_CharT, _Traits, _Allocator>::iterator 2488>::type 2489basic_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 2519template <class _CharT, class _Traits, class _Allocator> 2520_LIBCPP_INLINE_VISIBILITY inline 2521basic_string<_CharT, _Traits, _Allocator>& 2522basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str) 2523{ 2524 return insert(__pos1, __str.data(), __str.size()); 2525} 2526 2527template <class _CharT, class _Traits, class _Allocator> 2528basic_string<_CharT, _Traits, _Allocator>& 2529basic_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 2538template <class _CharT, class _Traits, class _Allocator> 2539basic_string<_CharT, _Traits, _Allocator>& 2540basic_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 2548template <class _CharT, class _Traits, class _Allocator> 2549typename basic_string<_CharT, _Traits, _Allocator>::iterator 2550basic_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 2574template <class _CharT, class _Traits, class _Allocator> 2575_LIBCPP_INLINE_VISIBILITY inline 2576typename basic_string<_CharT, _Traits, _Allocator>::iterator 2577basic_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 2586template <class _CharT, class _Traits, class _Allocator> 2587basic_string<_CharT, _Traits, _Allocator>& 2588basic_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 2640template <class _CharT, class _Traits, class _Allocator> 2641basic_string<_CharT, _Traits, _Allocator>& 2642basic_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 2673template <class _CharT, class _Traits, class _Allocator> 2674template<class _InputIterator> 2675typename enable_if 2676< 2677 __is_input_iterator<_InputIterator>::value, 2678 basic_string<_CharT, _Traits, _Allocator>& 2679>::type 2680basic_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 2701template <class _CharT, class _Traits, class _Allocator> 2702_LIBCPP_INLINE_VISIBILITY inline 2703basic_string<_CharT, _Traits, _Allocator>& 2704basic_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 2709template <class _CharT, class _Traits, class _Allocator> 2710basic_string<_CharT, _Traits, _Allocator>& 2711basic_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 2720template <class _CharT, class _Traits, class _Allocator> 2721basic_string<_CharT, _Traits, _Allocator>& 2722basic_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 2730template <class _CharT, class _Traits, class _Allocator> 2731_LIBCPP_INLINE_VISIBILITY inline 2732basic_string<_CharT, _Traits, _Allocator>& 2733basic_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 2739template <class _CharT, class _Traits, class _Allocator> 2740_LIBCPP_INLINE_VISIBILITY inline 2741basic_string<_CharT, _Traits, _Allocator>& 2742basic_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 2747template <class _CharT, class _Traits, class _Allocator> 2748_LIBCPP_INLINE_VISIBILITY inline 2749basic_string<_CharT, _Traits, _Allocator>& 2750basic_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 2755template <class _CharT, class _Traits, class _Allocator> 2756_LIBCPP_INLINE_VISIBILITY inline 2757basic_string<_CharT, _Traits, _Allocator>& 2758basic_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 2765template <class _CharT, class _Traits, class _Allocator> 2766basic_string<_CharT, _Traits, _Allocator>& 2767basic_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 2787template <class _CharT, class _Traits, class _Allocator> 2788_LIBCPP_INLINE_VISIBILITY inline 2789typename basic_string<_CharT, _Traits, _Allocator>::iterator 2790basic_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 2798template <class _CharT, class _Traits, class _Allocator> 2799_LIBCPP_INLINE_VISIBILITY inline 2800typename basic_string<_CharT, _Traits, _Allocator>::iterator 2801basic_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 2809template <class _CharT, class _Traits, class _Allocator> 2810_LIBCPP_INLINE_VISIBILITY inline 2811void 2812basic_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 2833template <class _CharT, class _Traits, class _Allocator> 2834_LIBCPP_INLINE_VISIBILITY inline 2835void 2836basic_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 2851template <class _CharT, class _Traits, class _Allocator> 2852_LIBCPP_INLINE_VISIBILITY inline 2853void 2854basic_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 2869template <class _CharT, class _Traits, class _Allocator> 2870void 2871basic_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 2880template <class _CharT, class _Traits, class _Allocator> 2881_LIBCPP_INLINE_VISIBILITY inline 2882typename basic_string<_CharT, _Traits, _Allocator>::size_type 2883basic_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 2893template <class _CharT, class _Traits, class _Allocator> 2894void 2895basic_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 2955template <class _CharT, class _Traits, class _Allocator> 2956_LIBCPP_INLINE_VISIBILITY inline 2957typename basic_string<_CharT, _Traits, _Allocator>::const_reference 2958basic_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 2966template <class _CharT, class _Traits, class _Allocator> 2967_LIBCPP_INLINE_VISIBILITY inline 2968typename basic_string<_CharT, _Traits, _Allocator>::reference 2969basic_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 2977template <class _CharT, class _Traits, class _Allocator> 2978typename basic_string<_CharT, _Traits, _Allocator>::const_reference 2979basic_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 2986template <class _CharT, class _Traits, class _Allocator> 2987typename basic_string<_CharT, _Traits, _Allocator>::reference 2988basic_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 2995template <class _CharT, class _Traits, class _Allocator> 2996_LIBCPP_INLINE_VISIBILITY inline 2997typename basic_string<_CharT, _Traits, _Allocator>::reference 2998basic_string<_CharT, _Traits, _Allocator>::front() 2999{ 3000#ifdef _LIBCPP_DEBUG 3001 assert(!empty()); 3002#endif 3003 return *__get_pointer(); 3004} 3005 3006template <class _CharT, class _Traits, class _Allocator> 3007_LIBCPP_INLINE_VISIBILITY inline 3008typename basic_string<_CharT, _Traits, _Allocator>::const_reference 3009basic_string<_CharT, _Traits, _Allocator>::front() const 3010{ 3011#ifdef _LIBCPP_DEBUG 3012 assert(!empty()); 3013#endif 3014 return *data(); 3015} 3016 3017template <class _CharT, class _Traits, class _Allocator> 3018_LIBCPP_INLINE_VISIBILITY inline 3019typename basic_string<_CharT, _Traits, _Allocator>::reference 3020basic_string<_CharT, _Traits, _Allocator>::back() 3021{ 3022#ifdef _LIBCPP_DEBUG 3023 assert(!empty()); 3024#endif 3025 return *(__get_pointer() + size() - 1); 3026} 3027 3028template <class _CharT, class _Traits, class _Allocator> 3029_LIBCPP_INLINE_VISIBILITY inline 3030typename basic_string<_CharT, _Traits, _Allocator>::const_reference 3031basic_string<_CharT, _Traits, _Allocator>::back() const 3032{ 3033#ifdef _LIBCPP_DEBUG 3034 assert(!empty()); 3035#endif 3036 return *(data() + size() - 1); 3037} 3038 3039template <class _CharT, class _Traits, class _Allocator> 3040typename basic_string<_CharT, _Traits, _Allocator>::size_type 3041basic_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 3051template <class _CharT, class _Traits, class _Allocator> 3052_LIBCPP_INLINE_VISIBILITY inline 3053basic_string<_CharT, _Traits, _Allocator> 3054basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const 3055{ 3056 return basic_string(*this, __pos, __n, __alloc()); 3057} 3058 3059template <class _CharT, class _Traits, class _Allocator> 3060_LIBCPP_INLINE_VISIBILITY inline 3061void 3062basic_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 3076template <class _Traits> 3077struct _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 3085template<class _CharT, class _Traits, class _Allocator> 3086typename basic_string<_CharT, _Traits, _Allocator>::size_type 3087basic_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 3107template<class _CharT, class _Traits, class _Allocator> 3108_LIBCPP_INLINE_VISIBILITY inline 3109typename basic_string<_CharT, _Traits, _Allocator>::size_type 3110basic_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 3116template<class _CharT, class _Traits, class _Allocator> 3117_LIBCPP_INLINE_VISIBILITY inline 3118typename basic_string<_CharT, _Traits, _Allocator>::size_type 3119basic_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 3128template<class _CharT, class _Traits, class _Allocator> 3129typename basic_string<_CharT, _Traits, _Allocator>::size_type 3130basic_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 3145template<class _CharT, class _Traits, class _Allocator> 3146typename basic_string<_CharT, _Traits, _Allocator>::size_type 3147basic_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 3168template<class _CharT, class _Traits, class _Allocator> 3169_LIBCPP_INLINE_VISIBILITY inline 3170typename basic_string<_CharT, _Traits, _Allocator>::size_type 3171basic_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 3177template<class _CharT, class _Traits, class _Allocator> 3178_LIBCPP_INLINE_VISIBILITY inline 3179typename basic_string<_CharT, _Traits, _Allocator>::size_type 3180basic_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 3189template<class _CharT, class _Traits, class _Allocator> 3190typename basic_string<_CharT, _Traits, _Allocator>::size_type 3191basic_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 3213template<class _CharT, class _Traits, class _Allocator> 3214typename basic_string<_CharT, _Traits, _Allocator>::size_type 3215basic_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 3233template<class _CharT, class _Traits, class _Allocator> 3234_LIBCPP_INLINE_VISIBILITY inline 3235typename basic_string<_CharT, _Traits, _Allocator>::size_type 3236basic_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 3242template<class _CharT, class _Traits, class _Allocator> 3243_LIBCPP_INLINE_VISIBILITY inline 3244typename basic_string<_CharT, _Traits, _Allocator>::size_type 3245basic_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 3254template<class _CharT, class _Traits, class _Allocator> 3255_LIBCPP_INLINE_VISIBILITY inline 3256typename basic_string<_CharT, _Traits, _Allocator>::size_type 3257basic_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 3265template<class _CharT, class _Traits, class _Allocator> 3266typename basic_string<_CharT, _Traits, _Allocator>::size_type 3267basic_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 3292template<class _CharT, class _Traits, class _Allocator> 3293_LIBCPP_INLINE_VISIBILITY inline 3294typename basic_string<_CharT, _Traits, _Allocator>::size_type 3295basic_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 3301template<class _CharT, class _Traits, class _Allocator> 3302_LIBCPP_INLINE_VISIBILITY inline 3303typename basic_string<_CharT, _Traits, _Allocator>::size_type 3304basic_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 3313template<class _CharT, class _Traits, class _Allocator> 3314_LIBCPP_INLINE_VISIBILITY inline 3315typename basic_string<_CharT, _Traits, _Allocator>::size_type 3316basic_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 3324template<class _CharT, class _Traits, class _Allocator> 3325typename basic_string<_CharT, _Traits, _Allocator>::size_type 3326basic_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 3345template<class _CharT, class _Traits, class _Allocator> 3346_LIBCPP_INLINE_VISIBILITY inline 3347typename basic_string<_CharT, _Traits, _Allocator>::size_type 3348basic_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 3354template<class _CharT, class _Traits, class _Allocator> 3355_LIBCPP_INLINE_VISIBILITY inline 3356typename basic_string<_CharT, _Traits, _Allocator>::size_type 3357basic_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 3366template<class _CharT, class _Traits, class _Allocator> 3367_LIBCPP_INLINE_VISIBILITY inline 3368typename basic_string<_CharT, _Traits, _Allocator>::size_type 3369basic_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 3386template<class _CharT, class _Traits, class _Allocator> 3387typename basic_string<_CharT, _Traits, _Allocator>::size_type 3388basic_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 3407template<class _CharT, class _Traits, class _Allocator> 3408_LIBCPP_INLINE_VISIBILITY inline 3409typename basic_string<_CharT, _Traits, _Allocator>::size_type 3410basic_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 3416template<class _CharT, class _Traits, class _Allocator> 3417_LIBCPP_INLINE_VISIBILITY inline 3418typename basic_string<_CharT, _Traits, _Allocator>::size_type 3419basic_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 3428template<class _CharT, class _Traits, class _Allocator> 3429_LIBCPP_INLINE_VISIBILITY inline 3430typename basic_string<_CharT, _Traits, _Allocator>::size_type 3431basic_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 3448template <class _CharT, class _Traits, class _Allocator> 3449_LIBCPP_INLINE_VISIBILITY inline 3450int 3451basic_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 3466template <class _CharT, class _Traits, class _Allocator> 3467_LIBCPP_INLINE_VISIBILITY inline 3468int 3469basic_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 3476template <class _CharT, class _Traits, class _Allocator> 3477int 3478basic_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 3491template <class _CharT, class _Traits, class _Allocator> 3492int 3493basic_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 3501template <class _CharT, class _Traits, class _Allocator> 3502int 3503basic_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 3513template <class _CharT, class _Traits, class _Allocator> 3514int 3515basic_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 3540template<class _CharT, class _Traits, class _Allocator> 3541_LIBCPP_INLINE_VISIBILITY inline 3542bool 3543basic_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 3558template<class _CharT, class _Traits, class _Allocator> 3559_LIBCPP_INLINE_VISIBILITY inline 3560bool 3561operator==(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 3569template<class _CharT, class _Traits, class _Allocator> 3570_LIBCPP_INLINE_VISIBILITY inline 3571bool 3572operator==(const _CharT* __lhs, 3573 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3574{ 3575 return __rhs.compare(__lhs) == 0; 3576} 3577 3578template<class _CharT, class _Traits, class _Allocator> 3579_LIBCPP_INLINE_VISIBILITY inline 3580bool 3581operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs, 3582 const _CharT* __rhs) _NOEXCEPT 3583{ 3584 return __lhs.compare(__rhs) == 0; 3585} 3586 3587// operator!= 3588 3589template<class _CharT, class _Traits, class _Allocator> 3590_LIBCPP_INLINE_VISIBILITY inline 3591bool 3592operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, 3593 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3594{ 3595 return !(__lhs == __rhs); 3596} 3597 3598template<class _CharT, class _Traits, class _Allocator> 3599_LIBCPP_INLINE_VISIBILITY inline 3600bool 3601operator!=(const _CharT* __lhs, 3602 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3603{ 3604 return !(__lhs == __rhs); 3605} 3606 3607template<class _CharT, class _Traits, class _Allocator> 3608_LIBCPP_INLINE_VISIBILITY inline 3609bool 3610operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3611 const _CharT* __rhs) _NOEXCEPT 3612{ 3613 return !(__lhs == __rhs); 3614} 3615 3616// operator< 3617 3618template<class _CharT, class _Traits, class _Allocator> 3619_LIBCPP_INLINE_VISIBILITY inline 3620bool 3621operator< (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 3627template<class _CharT, class _Traits, class _Allocator> 3628_LIBCPP_INLINE_VISIBILITY inline 3629bool 3630operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3631 const _CharT* __rhs) _NOEXCEPT 3632{ 3633 return __lhs.compare(__rhs) < 0; 3634} 3635 3636template<class _CharT, class _Traits, class _Allocator> 3637_LIBCPP_INLINE_VISIBILITY inline 3638bool 3639operator< (const _CharT* __lhs, 3640 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3641{ 3642 return __rhs.compare(__lhs) > 0; 3643} 3644 3645// operator> 3646 3647template<class _CharT, class _Traits, class _Allocator> 3648_LIBCPP_INLINE_VISIBILITY inline 3649bool 3650operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3651 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3652{ 3653 return __rhs < __lhs; 3654} 3655 3656template<class _CharT, class _Traits, class _Allocator> 3657_LIBCPP_INLINE_VISIBILITY inline 3658bool 3659operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3660 const _CharT* __rhs) _NOEXCEPT 3661{ 3662 return __rhs < __lhs; 3663} 3664 3665template<class _CharT, class _Traits, class _Allocator> 3666_LIBCPP_INLINE_VISIBILITY inline 3667bool 3668operator> (const _CharT* __lhs, 3669 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3670{ 3671 return __rhs < __lhs; 3672} 3673 3674// operator<= 3675 3676template<class _CharT, class _Traits, class _Allocator> 3677_LIBCPP_INLINE_VISIBILITY inline 3678bool 3679operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3680 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3681{ 3682 return !(__rhs < __lhs); 3683} 3684 3685template<class _CharT, class _Traits, class _Allocator> 3686_LIBCPP_INLINE_VISIBILITY inline 3687bool 3688operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3689 const _CharT* __rhs) _NOEXCEPT 3690{ 3691 return !(__rhs < __lhs); 3692} 3693 3694template<class _CharT, class _Traits, class _Allocator> 3695_LIBCPP_INLINE_VISIBILITY inline 3696bool 3697operator<=(const _CharT* __lhs, 3698 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3699{ 3700 return !(__rhs < __lhs); 3701} 3702 3703// operator>= 3704 3705template<class _CharT, class _Traits, class _Allocator> 3706_LIBCPP_INLINE_VISIBILITY inline 3707bool 3708operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3709 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3710{ 3711 return !(__lhs < __rhs); 3712} 3713 3714template<class _CharT, class _Traits, class _Allocator> 3715_LIBCPP_INLINE_VISIBILITY inline 3716bool 3717operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 3718 const _CharT* __rhs) _NOEXCEPT 3719{ 3720 return !(__lhs < __rhs); 3721} 3722 3723template<class _CharT, class _Traits, class _Allocator> 3724_LIBCPP_INLINE_VISIBILITY inline 3725bool 3726operator>=(const _CharT* __lhs, 3727 const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 3728{ 3729 return !(__lhs < __rhs); 3730} 3731 3732// operator + 3733 3734template<class _CharT, class _Traits, class _Allocator> 3735basic_string<_CharT, _Traits, _Allocator> 3736operator+(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 3747template<class _CharT, class _Traits, class _Allocator> 3748basic_string<_CharT, _Traits, _Allocator> 3749operator+(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 3759template<class _CharT, class _Traits, class _Allocator> 3760basic_string<_CharT, _Traits, _Allocator> 3761operator+(_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 3770template<class _CharT, class _Traits, class _Allocator> 3771basic_string<_CharT, _Traits, _Allocator> 3772operator+(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 3782template<class _CharT, class _Traits, class _Allocator> 3783basic_string<_CharT, _Traits, _Allocator> 3784operator+(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 3795template<class _CharT, class _Traits, class _Allocator> 3796_LIBCPP_INLINE_VISIBILITY inline 3797basic_string<_CharT, _Traits, _Allocator> 3798operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) 3799{ 3800 return _VSTD::move(__lhs.append(__rhs)); 3801} 3802 3803template<class _CharT, class _Traits, class _Allocator> 3804_LIBCPP_INLINE_VISIBILITY inline 3805basic_string<_CharT, _Traits, _Allocator> 3806operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) 3807{ 3808 return _VSTD::move(__rhs.insert(0, __lhs)); 3809} 3810 3811template<class _CharT, class _Traits, class _Allocator> 3812_LIBCPP_INLINE_VISIBILITY inline 3813basic_string<_CharT, _Traits, _Allocator> 3814operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) 3815{ 3816 return _VSTD::move(__lhs.append(__rhs)); 3817} 3818 3819template<class _CharT, class _Traits, class _Allocator> 3820_LIBCPP_INLINE_VISIBILITY inline 3821basic_string<_CharT, _Traits, _Allocator> 3822operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs) 3823{ 3824 return _VSTD::move(__rhs.insert(0, __lhs)); 3825} 3826 3827template<class _CharT, class _Traits, class _Allocator> 3828_LIBCPP_INLINE_VISIBILITY inline 3829basic_string<_CharT, _Traits, _Allocator> 3830operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs) 3831{ 3832 __rhs.insert(__rhs.begin(), __lhs); 3833 return _VSTD::move(__rhs); 3834} 3835 3836template<class _CharT, class _Traits, class _Allocator> 3837_LIBCPP_INLINE_VISIBILITY inline 3838basic_string<_CharT, _Traits, _Allocator> 3839operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs) 3840{ 3841 return _VSTD::move(__lhs.append(__rhs)); 3842} 3843 3844template<class _CharT, class _Traits, class _Allocator> 3845_LIBCPP_INLINE_VISIBILITY inline 3846basic_string<_CharT, _Traits, _Allocator> 3847operator+(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 3857template<class _CharT, class _Traits, class _Allocator> 3858_LIBCPP_INLINE_VISIBILITY inline 3859void 3860swap(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 3869typedef basic_string<char16_t> u16string; 3870typedef basic_string<char32_t> u32string; 3871 3872#endif // _LIBCPP_HAS_NO_UNICODE_CHARS 3873 3874int stoi (const string& __str, size_t* __idx = 0, int __base = 10); 3875long stol (const string& __str, size_t* __idx = 0, int __base = 10); 3876unsigned long stoul (const string& __str, size_t* __idx = 0, int __base = 10); 3877long long stoll (const string& __str, size_t* __idx = 0, int __base = 10); 3878unsigned long long stoull(const string& __str, size_t* __idx = 0, int __base = 10); 3879 3880float stof (const string& __str, size_t* __idx = 0); 3881double stod (const string& __str, size_t* __idx = 0); 3882long double stold(const string& __str, size_t* __idx = 0); 3883 3884string to_string(int __val); 3885string to_string(unsigned __val); 3886string to_string(long __val); 3887string to_string(unsigned long __val); 3888string to_string(long long __val); 3889string to_string(unsigned long long __val); 3890string to_string(float __val); 3891string to_string(double __val); 3892string to_string(long double __val); 3893 3894int stoi (const wstring& __str, size_t* __idx = 0, int __base = 10); 3895long stol (const wstring& __str, size_t* __idx = 0, int __base = 10); 3896unsigned long stoul (const wstring& __str, size_t* __idx = 0, int __base = 10); 3897long long stoll (const wstring& __str, size_t* __idx = 0, int __base = 10); 3898unsigned long long stoull(const wstring& __str, size_t* __idx = 0, int __base = 10); 3899 3900float stof (const wstring& __str, size_t* __idx = 0); 3901double stod (const wstring& __str, size_t* __idx = 0); 3902long double stold(const wstring& __str, size_t* __idx = 0); 3903 3904wstring to_wstring(int __val); 3905wstring to_wstring(unsigned __val); 3906wstring to_wstring(long __val); 3907wstring to_wstring(unsigned long __val); 3908wstring to_wstring(long long __val); 3909wstring to_wstring(unsigned long long __val); 3910wstring to_wstring(float __val); 3911wstring to_wstring(double __val); 3912wstring to_wstring(long double __val); 3913 3914template<class _CharT, class _Traits, class _Allocator> 3915 const typename basic_string<_CharT, _Traits, _Allocator>::size_type 3916 basic_string<_CharT, _Traits, _Allocator>::npos; 3917 3918template<class _Ptr> 3919size_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 3925template<class _CharT, class _Traits, class _Allocator> 3926struct _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 3933template<class _CharT, class _Traits, class _Allocator> 3934size_t 3935hash<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 3941template<class _CharT, class _Traits, class _Allocator> 3942basic_ostream<_CharT, _Traits>& 3943operator<<(basic_ostream<_CharT, _Traits>& __os, 3944 const basic_string<_CharT, _Traits, _Allocator>& __str); 3945 3946template<class _CharT, class _Traits, class _Allocator> 3947basic_istream<_CharT, _Traits>& 3948operator>>(basic_istream<_CharT, _Traits>& __is, 3949 basic_string<_CharT, _Traits, _Allocator>& __str); 3950 3951template<class _CharT, class _Traits, class _Allocator> 3952basic_istream<_CharT, _Traits>& 3953getline(basic_istream<_CharT, _Traits>& __is, 3954 basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm); 3955 3956template<class _CharT, class _Traits, class _Allocator> 3957inline _LIBCPP_INLINE_VISIBILITY 3958basic_istream<_CharT, _Traits>& 3959getline(basic_istream<_CharT, _Traits>& __is, 3960 basic_string<_CharT, _Traits, _Allocator>& __str); 3961 3962#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3963 3964template<class _CharT, class _Traits, class _Allocator> 3965inline _LIBCPP_INLINE_VISIBILITY 3966basic_istream<_CharT, _Traits>& 3967getline(basic_istream<_CharT, _Traits>&& __is, 3968 basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm); 3969 3970template<class _CharT, class _Traits, class _Allocator> 3971inline _LIBCPP_INLINE_VISIBILITY 3972basic_istream<_CharT, _Traits>& 3973getline(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 3981extern 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