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