10b57cec5SDimitry Andric// -*- C++ -*- 2349cc55cSDimitry Andric//===----------------------------------------------------------------------===// 30b57cec5SDimitry Andric// 40b57cec5SDimitry Andric// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 50b57cec5SDimitry Andric// See https://llvm.org/LICENSE.txt for license information. 60b57cec5SDimitry Andric// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 70b57cec5SDimitry Andric// 80b57cec5SDimitry Andric//===----------------------------------------------------------------------===// 90b57cec5SDimitry Andric 100b57cec5SDimitry Andric#ifndef _LIBCPP_STRING 110b57cec5SDimitry Andric#define _LIBCPP_STRING 120b57cec5SDimitry Andric 130b57cec5SDimitry Andric/* 140b57cec5SDimitry Andric string synopsis 150b57cec5SDimitry Andric 160b57cec5SDimitry Andricnamespace std 170b57cec5SDimitry Andric{ 180b57cec5SDimitry Andric 190b57cec5SDimitry Andrictemplate <class stateT> 200b57cec5SDimitry Andricclass fpos 210b57cec5SDimitry Andric{ 220b57cec5SDimitry Andricprivate: 230b57cec5SDimitry Andric stateT st; 240b57cec5SDimitry Andricpublic: 250b57cec5SDimitry Andric fpos(streamoff = streamoff()); 260b57cec5SDimitry Andric 270b57cec5SDimitry Andric operator streamoff() const; 280b57cec5SDimitry Andric 290b57cec5SDimitry Andric stateT state() const; 300b57cec5SDimitry Andric void state(stateT); 310b57cec5SDimitry Andric 320b57cec5SDimitry Andric fpos& operator+=(streamoff); 330b57cec5SDimitry Andric fpos operator+ (streamoff) const; 340b57cec5SDimitry Andric fpos& operator-=(streamoff); 350b57cec5SDimitry Andric fpos operator- (streamoff) const; 360b57cec5SDimitry Andric}; 370b57cec5SDimitry Andric 380b57cec5SDimitry Andrictemplate <class stateT> streamoff operator-(const fpos<stateT>& x, const fpos<stateT>& y); 390b57cec5SDimitry Andric 400b57cec5SDimitry Andrictemplate <class stateT> bool operator==(const fpos<stateT>& x, const fpos<stateT>& y); 410b57cec5SDimitry Andrictemplate <class stateT> bool operator!=(const fpos<stateT>& x, const fpos<stateT>& y); 420b57cec5SDimitry Andric 430b57cec5SDimitry Andrictemplate <class charT> 440b57cec5SDimitry Andricstruct char_traits 450b57cec5SDimitry Andric{ 460b57cec5SDimitry Andric typedef charT char_type; 470b57cec5SDimitry Andric typedef ... int_type; 480b57cec5SDimitry Andric typedef streamoff off_type; 490b57cec5SDimitry Andric typedef streampos pos_type; 500b57cec5SDimitry Andric typedef mbstate_t state_type; 510b57cec5SDimitry Andric 520b57cec5SDimitry Andric static void assign(char_type& c1, const char_type& c2) noexcept; 530b57cec5SDimitry Andric static constexpr bool eq(char_type c1, char_type c2) noexcept; 540b57cec5SDimitry Andric static constexpr bool lt(char_type c1, char_type c2) noexcept; 550b57cec5SDimitry Andric 560b57cec5SDimitry Andric static int compare(const char_type* s1, const char_type* s2, size_t n); 570b57cec5SDimitry Andric static size_t length(const char_type* s); 580b57cec5SDimitry Andric static const char_type* find(const char_type* s, size_t n, const char_type& a); 590b57cec5SDimitry Andric static char_type* move(char_type* s1, const char_type* s2, size_t n); 600b57cec5SDimitry Andric static char_type* copy(char_type* s1, const char_type* s2, size_t n); 610b57cec5SDimitry Andric static char_type* assign(char_type* s, size_t n, char_type a); 620b57cec5SDimitry Andric 630b57cec5SDimitry Andric static constexpr int_type not_eof(int_type c) noexcept; 640b57cec5SDimitry Andric static constexpr char_type to_char_type(int_type c) noexcept; 650b57cec5SDimitry Andric static constexpr int_type to_int_type(char_type c) noexcept; 660b57cec5SDimitry Andric static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept; 670b57cec5SDimitry Andric static constexpr int_type eof() noexcept; 680b57cec5SDimitry Andric}; 690b57cec5SDimitry Andric 700b57cec5SDimitry Andrictemplate <> struct char_traits<char>; 710b57cec5SDimitry Andrictemplate <> struct char_traits<wchar_t>; 72fe6060f1SDimitry Andrictemplate <> struct char_traits<char8_t>; // C++20 73fe6060f1SDimitry Andrictemplate <> struct char_traits<char16_t>; 74fe6060f1SDimitry Andrictemplate <> struct char_traits<char32_t>; 750b57cec5SDimitry Andric 760b57cec5SDimitry Andrictemplate<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > 770b57cec5SDimitry Andricclass basic_string 780b57cec5SDimitry Andric{ 790b57cec5SDimitry Andricpublic: 800b57cec5SDimitry Andric// types: 810b57cec5SDimitry Andric typedef traits traits_type; 820b57cec5SDimitry Andric typedef typename traits_type::char_type value_type; 830b57cec5SDimitry Andric typedef Allocator allocator_type; 840b57cec5SDimitry Andric typedef typename allocator_type::size_type size_type; 850b57cec5SDimitry Andric typedef typename allocator_type::difference_type difference_type; 860b57cec5SDimitry Andric typedef typename allocator_type::reference reference; 870b57cec5SDimitry Andric typedef typename allocator_type::const_reference const_reference; 880b57cec5SDimitry Andric typedef typename allocator_type::pointer pointer; 890b57cec5SDimitry Andric typedef typename allocator_type::const_pointer const_pointer; 900b57cec5SDimitry Andric typedef implementation-defined iterator; 910b57cec5SDimitry Andric typedef implementation-defined const_iterator; 920b57cec5SDimitry Andric typedef std::reverse_iterator<iterator> reverse_iterator; 930b57cec5SDimitry Andric typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 940b57cec5SDimitry Andric 950b57cec5SDimitry Andric static const size_type npos = -1; 960b57cec5SDimitry Andric 970b57cec5SDimitry Andric basic_string() 980b57cec5SDimitry Andric noexcept(is_nothrow_default_constructible<allocator_type>::value); 990b57cec5SDimitry Andric explicit basic_string(const allocator_type& a); 1000b57cec5SDimitry Andric basic_string(const basic_string& str); 1010b57cec5SDimitry Andric basic_string(basic_string&& str) 1020b57cec5SDimitry Andric noexcept(is_nothrow_move_constructible<allocator_type>::value); 1030b57cec5SDimitry Andric basic_string(const basic_string& str, size_type pos, 1040b57cec5SDimitry Andric const allocator_type& a = allocator_type()); 1050b57cec5SDimitry Andric basic_string(const basic_string& str, size_type pos, size_type n, 1060b57cec5SDimitry Andric const Allocator& a = Allocator()); 1070b57cec5SDimitry Andric template<class T> 1080b57cec5SDimitry Andric basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator()); // C++17 1090b57cec5SDimitry Andric template <class T> 1100b57cec5SDimitry Andric explicit basic_string(const T& t, const Allocator& a = Allocator()); // C++17 1110b57cec5SDimitry Andric basic_string(const value_type* s, const allocator_type& a = allocator_type()); 1120b57cec5SDimitry Andric basic_string(const value_type* s, size_type n, const allocator_type& a = allocator_type()); 113fe6060f1SDimitry Andric basic_string(nullptr_t) = delete; // C++2b 1140b57cec5SDimitry Andric basic_string(size_type n, value_type c, const allocator_type& a = allocator_type()); 1150b57cec5SDimitry Andric template<class InputIterator> 1160b57cec5SDimitry Andric basic_string(InputIterator begin, InputIterator end, 1170b57cec5SDimitry Andric const allocator_type& a = allocator_type()); 1180b57cec5SDimitry Andric basic_string(initializer_list<value_type>, const Allocator& = Allocator()); 1190b57cec5SDimitry Andric basic_string(const basic_string&, const Allocator&); 1200b57cec5SDimitry Andric basic_string(basic_string&&, const Allocator&); 1210b57cec5SDimitry Andric 1220b57cec5SDimitry Andric ~basic_string(); 1230b57cec5SDimitry Andric 1240b57cec5SDimitry Andric operator basic_string_view<charT, traits>() const noexcept; 1250b57cec5SDimitry Andric 1260b57cec5SDimitry Andric basic_string& operator=(const basic_string& str); 1270b57cec5SDimitry Andric template <class T> 1280b57cec5SDimitry Andric basic_string& operator=(const T& t); // C++17 1290b57cec5SDimitry Andric basic_string& operator=(basic_string&& str) 1300b57cec5SDimitry Andric noexcept( 1310b57cec5SDimitry Andric allocator_type::propagate_on_container_move_assignment::value || 1320b57cec5SDimitry Andric allocator_type::is_always_equal::value ); // C++17 1330b57cec5SDimitry Andric basic_string& operator=(const value_type* s); 134fe6060f1SDimitry Andric basic_string& operator=(nullptr_t) = delete; // C++2b 1350b57cec5SDimitry Andric basic_string& operator=(value_type c); 1360b57cec5SDimitry Andric basic_string& operator=(initializer_list<value_type>); 1370b57cec5SDimitry Andric 1380b57cec5SDimitry Andric iterator begin() noexcept; 1390b57cec5SDimitry Andric const_iterator begin() const noexcept; 1400b57cec5SDimitry Andric iterator end() noexcept; 1410b57cec5SDimitry Andric const_iterator end() const noexcept; 1420b57cec5SDimitry Andric 1430b57cec5SDimitry Andric reverse_iterator rbegin() noexcept; 1440b57cec5SDimitry Andric const_reverse_iterator rbegin() const noexcept; 1450b57cec5SDimitry Andric reverse_iterator rend() noexcept; 1460b57cec5SDimitry Andric const_reverse_iterator rend() const noexcept; 1470b57cec5SDimitry Andric 1480b57cec5SDimitry Andric const_iterator cbegin() const noexcept; 1490b57cec5SDimitry Andric const_iterator cend() const noexcept; 1500b57cec5SDimitry Andric const_reverse_iterator crbegin() const noexcept; 1510b57cec5SDimitry Andric const_reverse_iterator crend() const noexcept; 1520b57cec5SDimitry Andric 1530b57cec5SDimitry Andric size_type size() const noexcept; 1540b57cec5SDimitry Andric size_type length() const noexcept; 1550b57cec5SDimitry Andric size_type max_size() const noexcept; 1560b57cec5SDimitry Andric size_type capacity() const noexcept; 1570b57cec5SDimitry Andric 1580b57cec5SDimitry Andric void resize(size_type n, value_type c); 1590b57cec5SDimitry Andric void resize(size_type n); 1600b57cec5SDimitry Andric 161e8d8bef9SDimitry Andric void reserve(size_type res_arg); 162e8d8bef9SDimitry Andric void reserve(); // deprecated in C++20 1630b57cec5SDimitry Andric void shrink_to_fit(); 1640b57cec5SDimitry Andric void clear() noexcept; 1650b57cec5SDimitry Andric bool empty() const noexcept; 1660b57cec5SDimitry Andric 1670b57cec5SDimitry Andric const_reference operator[](size_type pos) const; 1680b57cec5SDimitry Andric reference operator[](size_type pos); 1690b57cec5SDimitry Andric 1700b57cec5SDimitry Andric const_reference at(size_type n) const; 1710b57cec5SDimitry Andric reference at(size_type n); 1720b57cec5SDimitry Andric 1730b57cec5SDimitry Andric basic_string& operator+=(const basic_string& str); 1740b57cec5SDimitry Andric template <class T> 1750b57cec5SDimitry Andric basic_string& operator+=(const T& t); // C++17 1760b57cec5SDimitry Andric basic_string& operator+=(const value_type* s); 1770b57cec5SDimitry Andric basic_string& operator+=(value_type c); 1780b57cec5SDimitry Andric basic_string& operator+=(initializer_list<value_type>); 1790b57cec5SDimitry Andric 1800b57cec5SDimitry Andric basic_string& append(const basic_string& str); 1810b57cec5SDimitry Andric template <class T> 1820b57cec5SDimitry Andric basic_string& append(const T& t); // C++17 1830b57cec5SDimitry Andric basic_string& append(const basic_string& str, size_type pos, size_type n=npos); //C++14 1840b57cec5SDimitry Andric template <class T> 1850b57cec5SDimitry Andric basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17 1860b57cec5SDimitry Andric basic_string& append(const value_type* s, size_type n); 1870b57cec5SDimitry Andric basic_string& append(const value_type* s); 1880b57cec5SDimitry Andric basic_string& append(size_type n, value_type c); 1890b57cec5SDimitry Andric template<class InputIterator> 1900b57cec5SDimitry Andric basic_string& append(InputIterator first, InputIterator last); 1910b57cec5SDimitry Andric basic_string& append(initializer_list<value_type>); 1920b57cec5SDimitry Andric 1930b57cec5SDimitry Andric void push_back(value_type c); 1940b57cec5SDimitry Andric void pop_back(); 1950b57cec5SDimitry Andric reference front(); 1960b57cec5SDimitry Andric const_reference front() const; 1970b57cec5SDimitry Andric reference back(); 1980b57cec5SDimitry Andric const_reference back() const; 1990b57cec5SDimitry Andric 2000b57cec5SDimitry Andric basic_string& assign(const basic_string& str); 2010b57cec5SDimitry Andric template <class T> 2020b57cec5SDimitry Andric basic_string& assign(const T& t); // C++17 2030b57cec5SDimitry Andric basic_string& assign(basic_string&& str); 2040b57cec5SDimitry Andric basic_string& assign(const basic_string& str, size_type pos, size_type n=npos); // C++14 2050b57cec5SDimitry Andric template <class T> 2060b57cec5SDimitry Andric basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17 2070b57cec5SDimitry Andric basic_string& assign(const value_type* s, size_type n); 2080b57cec5SDimitry Andric basic_string& assign(const value_type* s); 2090b57cec5SDimitry Andric basic_string& assign(size_type n, value_type c); 2100b57cec5SDimitry Andric template<class InputIterator> 2110b57cec5SDimitry Andric basic_string& assign(InputIterator first, InputIterator last); 2120b57cec5SDimitry Andric basic_string& assign(initializer_list<value_type>); 2130b57cec5SDimitry Andric 2140b57cec5SDimitry Andric basic_string& insert(size_type pos1, const basic_string& str); 2150b57cec5SDimitry Andric template <class T> 2160b57cec5SDimitry Andric basic_string& insert(size_type pos1, const T& t); 2170b57cec5SDimitry Andric basic_string& insert(size_type pos1, const basic_string& str, 2180b57cec5SDimitry Andric size_type pos2, size_type n); 2190b57cec5SDimitry Andric template <class T> 2200b57cec5SDimitry Andric basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n); // C++17 2210b57cec5SDimitry Andric basic_string& insert(size_type pos, const value_type* s, size_type n=npos); //C++14 2220b57cec5SDimitry Andric basic_string& insert(size_type pos, const value_type* s); 2230b57cec5SDimitry Andric basic_string& insert(size_type pos, size_type n, value_type c); 2240b57cec5SDimitry Andric iterator insert(const_iterator p, value_type c); 2250b57cec5SDimitry Andric iterator insert(const_iterator p, size_type n, value_type c); 2260b57cec5SDimitry Andric template<class InputIterator> 2270b57cec5SDimitry Andric iterator insert(const_iterator p, InputIterator first, InputIterator last); 2280b57cec5SDimitry Andric iterator insert(const_iterator p, initializer_list<value_type>); 2290b57cec5SDimitry Andric 2300b57cec5SDimitry Andric basic_string& erase(size_type pos = 0, size_type n = npos); 2310b57cec5SDimitry Andric iterator erase(const_iterator position); 2320b57cec5SDimitry Andric iterator erase(const_iterator first, const_iterator last); 2330b57cec5SDimitry Andric 2340b57cec5SDimitry Andric basic_string& replace(size_type pos1, size_type n1, const basic_string& str); 2350b57cec5SDimitry Andric template <class T> 2360b57cec5SDimitry Andric basic_string& replace(size_type pos1, size_type n1, const T& t); // C++17 2370b57cec5SDimitry Andric basic_string& replace(size_type pos1, size_type n1, const basic_string& str, 2380b57cec5SDimitry Andric size_type pos2, size_type n2=npos); // C++14 2390b57cec5SDimitry Andric template <class T> 2400b57cec5SDimitry Andric basic_string& replace(size_type pos1, size_type n1, const T& t, 2410b57cec5SDimitry Andric size_type pos2, size_type n); // C++17 2420b57cec5SDimitry Andric basic_string& replace(size_type pos, size_type n1, const value_type* s, size_type n2); 2430b57cec5SDimitry Andric basic_string& replace(size_type pos, size_type n1, const value_type* s); 2440b57cec5SDimitry Andric basic_string& replace(size_type pos, size_type n1, size_type n2, value_type c); 2450b57cec5SDimitry Andric basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str); 2460b57cec5SDimitry Andric template <class T> 2470b57cec5SDimitry Andric basic_string& replace(const_iterator i1, const_iterator i2, const T& t); // C++17 2480b57cec5SDimitry Andric basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s, size_type n); 2490b57cec5SDimitry Andric basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s); 2500b57cec5SDimitry Andric basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c); 2510b57cec5SDimitry Andric template<class InputIterator> 2520b57cec5SDimitry Andric basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2); 2530b57cec5SDimitry Andric basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>); 2540b57cec5SDimitry Andric 2550b57cec5SDimitry Andric size_type copy(value_type* s, size_type n, size_type pos = 0) const; 2560b57cec5SDimitry Andric basic_string substr(size_type pos = 0, size_type n = npos) const; 2570b57cec5SDimitry Andric 2580b57cec5SDimitry Andric void swap(basic_string& str) 2590b57cec5SDimitry Andric noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value || 2600b57cec5SDimitry Andric allocator_traits<allocator_type>::is_always_equal::value); // C++17 2610b57cec5SDimitry Andric 2620b57cec5SDimitry Andric const value_type* c_str() const noexcept; 2630b57cec5SDimitry Andric const value_type* data() const noexcept; 2640b57cec5SDimitry Andric value_type* data() noexcept; // C++17 2650b57cec5SDimitry Andric 2660b57cec5SDimitry Andric allocator_type get_allocator() const noexcept; 2670b57cec5SDimitry Andric 2680b57cec5SDimitry Andric size_type find(const basic_string& str, size_type pos = 0) const noexcept; 2690b57cec5SDimitry Andric template <class T> 270fe6060f1SDimitry Andric size_type find(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension 2710b57cec5SDimitry Andric size_type find(const value_type* s, size_type pos, size_type n) const noexcept; 2720b57cec5SDimitry Andric size_type find(const value_type* s, size_type pos = 0) const noexcept; 2730b57cec5SDimitry Andric size_type find(value_type c, size_type pos = 0) const noexcept; 2740b57cec5SDimitry Andric 2750b57cec5SDimitry Andric size_type rfind(const basic_string& str, size_type pos = npos) const noexcept; 2760b57cec5SDimitry Andric template <class T> 277fe6060f1SDimitry Andric size_type rfind(const T& t, size_type pos = npos) const noexcept; // C++17, noexcept as an extension 2780b57cec5SDimitry Andric size_type rfind(const value_type* s, size_type pos, size_type n) const noexcept; 2790b57cec5SDimitry Andric size_type rfind(const value_type* s, size_type pos = npos) const noexcept; 2800b57cec5SDimitry Andric size_type rfind(value_type c, size_type pos = npos) const noexcept; 2810b57cec5SDimitry Andric 2820b57cec5SDimitry Andric size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept; 2830b57cec5SDimitry Andric template <class T> 284fe6060f1SDimitry Andric size_type find_first_of(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension 2850b57cec5SDimitry Andric size_type find_first_of(const value_type* s, size_type pos, size_type n) const noexcept; 2860b57cec5SDimitry Andric size_type find_first_of(const value_type* s, size_type pos = 0) const noexcept; 2870b57cec5SDimitry Andric size_type find_first_of(value_type c, size_type pos = 0) const noexcept; 2880b57cec5SDimitry Andric 2890b57cec5SDimitry Andric size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept; 2900b57cec5SDimitry Andric template <class T> 291fe6060f1SDimitry Andric size_type find_last_of(const T& t, size_type pos = npos) const noexcept noexcept; // C++17, noexcept as an extension 2920b57cec5SDimitry Andric size_type find_last_of(const value_type* s, size_type pos, size_type n) const noexcept; 2930b57cec5SDimitry Andric size_type find_last_of(const value_type* s, size_type pos = npos) const noexcept; 2940b57cec5SDimitry Andric size_type find_last_of(value_type c, size_type pos = npos) const noexcept; 2950b57cec5SDimitry Andric 2960b57cec5SDimitry Andric size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept; 2970b57cec5SDimitry Andric template <class T> 298fe6060f1SDimitry Andric size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension 2990b57cec5SDimitry Andric size_type find_first_not_of(const value_type* s, size_type pos, size_type n) const noexcept; 3000b57cec5SDimitry Andric size_type find_first_not_of(const value_type* s, size_type pos = 0) const noexcept; 3010b57cec5SDimitry Andric size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept; 3020b57cec5SDimitry Andric 3030b57cec5SDimitry Andric size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept; 3040b57cec5SDimitry Andric template <class T> 305fe6060f1SDimitry Andric size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept; // C++17, noexcept as an extension 3060b57cec5SDimitry Andric size_type find_last_not_of(const value_type* s, size_type pos, size_type n) const noexcept; 3070b57cec5SDimitry Andric size_type find_last_not_of(const value_type* s, size_type pos = npos) const noexcept; 3080b57cec5SDimitry Andric size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept; 3090b57cec5SDimitry Andric 3100b57cec5SDimitry Andric int compare(const basic_string& str) const noexcept; 3110b57cec5SDimitry Andric template <class T> 312fe6060f1SDimitry Andric int compare(const T& t) const noexcept; // C++17, noexcept as an extension 3130b57cec5SDimitry Andric int compare(size_type pos1, size_type n1, const basic_string& str) const; 3140b57cec5SDimitry Andric template <class T> 3150b57cec5SDimitry Andric int compare(size_type pos1, size_type n1, const T& t) const; // C++17 3160b57cec5SDimitry Andric int compare(size_type pos1, size_type n1, const basic_string& str, 3170b57cec5SDimitry Andric size_type pos2, size_type n2=npos) const; // C++14 3180b57cec5SDimitry Andric template <class T> 3190b57cec5SDimitry Andric int compare(size_type pos1, size_type n1, const T& t, 3200b57cec5SDimitry Andric size_type pos2, size_type n2=npos) const; // C++17 3210b57cec5SDimitry Andric int compare(const value_type* s) const noexcept; 3220b57cec5SDimitry Andric int compare(size_type pos1, size_type n1, const value_type* s) const; 3230b57cec5SDimitry Andric int compare(size_type pos1, size_type n1, const value_type* s, size_type n2) const; 3240b57cec5SDimitry Andric 325e8d8bef9SDimitry Andric bool starts_with(basic_string_view<charT, traits> sv) const noexcept; // C++20 326e8d8bef9SDimitry Andric bool starts_with(charT c) const noexcept; // C++20 327e8d8bef9SDimitry Andric bool starts_with(const charT* s) const; // C++20 328e8d8bef9SDimitry Andric bool ends_with(basic_string_view<charT, traits> sv) const noexcept; // C++20 329e8d8bef9SDimitry Andric bool ends_with(charT c) const noexcept; // C++20 330e8d8bef9SDimitry Andric bool ends_with(const charT* s) const; // C++20 331e8d8bef9SDimitry Andric 332e8d8bef9SDimitry Andric constexpr bool contains(basic_string_view<charT, traits> sv) const noexcept; // C++2b 333e8d8bef9SDimitry Andric constexpr bool contains(charT c) const noexcept; // C++2b 334e8d8bef9SDimitry Andric constexpr bool contains(const charT* s) const; // C++2b 3350b57cec5SDimitry Andric 3360b57cec5SDimitry Andric bool __invariants() const; 3370b57cec5SDimitry Andric}; 3380b57cec5SDimitry Andric 3390b57cec5SDimitry Andrictemplate<class InputIterator, 3400b57cec5SDimitry Andric class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> 3410b57cec5SDimitry Andricbasic_string(InputIterator, InputIterator, Allocator = Allocator()) 3420b57cec5SDimitry Andric -> basic_string<typename iterator_traits<InputIterator>::value_type, 3430b57cec5SDimitry Andric char_traits<typename iterator_traits<InputIterator>::value_type>, 3440b57cec5SDimitry Andric Allocator>; // C++17 3450b57cec5SDimitry Andric 3460b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3470b57cec5SDimitry Andricbasic_string<charT, traits, Allocator> 3480b57cec5SDimitry Andricoperator+(const basic_string<charT, traits, Allocator>& lhs, 3490b57cec5SDimitry Andric const basic_string<charT, traits, Allocator>& rhs); 3500b57cec5SDimitry Andric 3510b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3520b57cec5SDimitry Andricbasic_string<charT, traits, Allocator> 3530b57cec5SDimitry Andricoperator+(const charT* lhs , const basic_string<charT,traits,Allocator>&rhs); 3540b57cec5SDimitry Andric 3550b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3560b57cec5SDimitry Andricbasic_string<charT, traits, Allocator> 3570b57cec5SDimitry Andricoperator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs); 3580b57cec5SDimitry Andric 3590b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3600b57cec5SDimitry Andricbasic_string<charT, traits, Allocator> 3610b57cec5SDimitry Andricoperator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs); 3620b57cec5SDimitry Andric 3630b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3640b57cec5SDimitry Andricbasic_string<charT, traits, Allocator> 3650b57cec5SDimitry Andricoperator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs); 3660b57cec5SDimitry Andric 3670b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3680b57cec5SDimitry Andricbool operator==(const basic_string<charT, traits, Allocator>& lhs, 3690b57cec5SDimitry Andric const basic_string<charT, traits, Allocator>& rhs) noexcept; 3700b57cec5SDimitry Andric 3710b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3720b57cec5SDimitry Andricbool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 3730b57cec5SDimitry Andric 3740b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3750b57cec5SDimitry Andricbool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept; 3760b57cec5SDimitry Andric 3770b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3780b57cec5SDimitry Andricbool operator!=(const basic_string<charT,traits,Allocator>& lhs, 3790b57cec5SDimitry Andric const basic_string<charT, traits, Allocator>& rhs) noexcept; 3800b57cec5SDimitry Andric 3810b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3820b57cec5SDimitry Andricbool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 3830b57cec5SDimitry Andric 3840b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3850b57cec5SDimitry Andricbool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 3860b57cec5SDimitry Andric 3870b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3880b57cec5SDimitry Andricbool operator< (const basic_string<charT, traits, Allocator>& lhs, 3890b57cec5SDimitry Andric const basic_string<charT, traits, Allocator>& rhs) noexcept; 3900b57cec5SDimitry Andric 3910b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3920b57cec5SDimitry Andricbool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 3930b57cec5SDimitry Andric 3940b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3950b57cec5SDimitry Andricbool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 3960b57cec5SDimitry Andric 3970b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 3980b57cec5SDimitry Andricbool operator> (const basic_string<charT, traits, Allocator>& lhs, 3990b57cec5SDimitry Andric const basic_string<charT, traits, Allocator>& rhs) noexcept; 4000b57cec5SDimitry Andric 4010b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4020b57cec5SDimitry Andricbool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 4030b57cec5SDimitry Andric 4040b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4050b57cec5SDimitry Andricbool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 4060b57cec5SDimitry Andric 4070b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4080b57cec5SDimitry Andricbool operator<=(const basic_string<charT, traits, Allocator>& lhs, 4090b57cec5SDimitry Andric const basic_string<charT, traits, Allocator>& rhs) noexcept; 4100b57cec5SDimitry Andric 4110b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4120b57cec5SDimitry Andricbool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 4130b57cec5SDimitry Andric 4140b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4150b57cec5SDimitry Andricbool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 4160b57cec5SDimitry Andric 4170b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4180b57cec5SDimitry Andricbool operator>=(const basic_string<charT, traits, Allocator>& lhs, 4190b57cec5SDimitry Andric const basic_string<charT, traits, Allocator>& rhs) noexcept; 4200b57cec5SDimitry Andric 4210b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4220b57cec5SDimitry Andricbool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; 4230b57cec5SDimitry Andric 4240b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4250b57cec5SDimitry Andricbool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; 4260b57cec5SDimitry Andric 4270b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4280b57cec5SDimitry Andricvoid swap(basic_string<charT, traits, Allocator>& lhs, 4290b57cec5SDimitry Andric basic_string<charT, traits, Allocator>& rhs) 4300b57cec5SDimitry Andric noexcept(noexcept(lhs.swap(rhs))); 4310b57cec5SDimitry Andric 4320b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4330b57cec5SDimitry Andricbasic_istream<charT, traits>& 4340b57cec5SDimitry Andricoperator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str); 4350b57cec5SDimitry Andric 4360b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4370b57cec5SDimitry Andricbasic_ostream<charT, traits>& 4380b57cec5SDimitry Andricoperator<<(basic_ostream<charT, traits>& os, const basic_string<charT, traits, Allocator>& str); 4390b57cec5SDimitry Andric 4400b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4410b57cec5SDimitry Andricbasic_istream<charT, traits>& 4420b57cec5SDimitry Andricgetline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str, 4430b57cec5SDimitry Andric charT delim); 4440b57cec5SDimitry Andric 4450b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator> 4460b57cec5SDimitry Andricbasic_istream<charT, traits>& 4470b57cec5SDimitry Andricgetline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str); 4480b57cec5SDimitry Andric 4490b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator, class U> 4505ffd83dbSDimitry Andrictypename basic_string<charT, traits, Allocator>::size_type 4515ffd83dbSDimitry Andricerase(basic_string<charT, traits, Allocator>& c, const U& value); // C++20 4520b57cec5SDimitry Andrictemplate<class charT, class traits, class Allocator, class Predicate> 4535ffd83dbSDimitry Andrictypename basic_string<charT, traits, Allocator>::size_type 4545ffd83dbSDimitry Andricerase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20 4550b57cec5SDimitry Andric 4560b57cec5SDimitry Andrictypedef basic_string<char> string; 4570b57cec5SDimitry Andrictypedef basic_string<wchar_t> wstring; 458fe6060f1SDimitry Andrictypedef basic_string<char8_t> u8string; // C++20 4590b57cec5SDimitry Andrictypedef basic_string<char16_t> u16string; 4600b57cec5SDimitry Andrictypedef basic_string<char32_t> u32string; 4610b57cec5SDimitry Andric 462e8d8bef9SDimitry Andricint stoi (const string& str, size_t* idx = nullptr, int base = 10); 463e8d8bef9SDimitry Andriclong stol (const string& str, size_t* idx = nullptr, int base = 10); 464e8d8bef9SDimitry Andricunsigned long stoul (const string& str, size_t* idx = nullptr, int base = 10); 465e8d8bef9SDimitry Andriclong long stoll (const string& str, size_t* idx = nullptr, int base = 10); 466e8d8bef9SDimitry Andricunsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10); 4670b57cec5SDimitry Andric 468e8d8bef9SDimitry Andricfloat stof (const string& str, size_t* idx = nullptr); 469e8d8bef9SDimitry Andricdouble stod (const string& str, size_t* idx = nullptr); 470e8d8bef9SDimitry Andriclong double stold(const string& str, size_t* idx = nullptr); 4710b57cec5SDimitry Andric 4720b57cec5SDimitry Andricstring to_string(int val); 4730b57cec5SDimitry Andricstring to_string(unsigned val); 4740b57cec5SDimitry Andricstring to_string(long val); 4750b57cec5SDimitry Andricstring to_string(unsigned long val); 4760b57cec5SDimitry Andricstring to_string(long long val); 4770b57cec5SDimitry Andricstring to_string(unsigned long long val); 4780b57cec5SDimitry Andricstring to_string(float val); 4790b57cec5SDimitry Andricstring to_string(double val); 4800b57cec5SDimitry Andricstring to_string(long double val); 4810b57cec5SDimitry Andric 482e8d8bef9SDimitry Andricint stoi (const wstring& str, size_t* idx = nullptr, int base = 10); 483e8d8bef9SDimitry Andriclong stol (const wstring& str, size_t* idx = nullptr, int base = 10); 484e8d8bef9SDimitry Andricunsigned long stoul (const wstring& str, size_t* idx = nullptr, int base = 10); 485e8d8bef9SDimitry Andriclong long stoll (const wstring& str, size_t* idx = nullptr, int base = 10); 486e8d8bef9SDimitry Andricunsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10); 4870b57cec5SDimitry Andric 488e8d8bef9SDimitry Andricfloat stof (const wstring& str, size_t* idx = nullptr); 489e8d8bef9SDimitry Andricdouble stod (const wstring& str, size_t* idx = nullptr); 490e8d8bef9SDimitry Andriclong double stold(const wstring& str, size_t* idx = nullptr); 4910b57cec5SDimitry Andric 4920b57cec5SDimitry Andricwstring to_wstring(int val); 4930b57cec5SDimitry Andricwstring to_wstring(unsigned val); 4940b57cec5SDimitry Andricwstring to_wstring(long val); 4950b57cec5SDimitry Andricwstring to_wstring(unsigned long val); 4960b57cec5SDimitry Andricwstring to_wstring(long long val); 4970b57cec5SDimitry Andricwstring to_wstring(unsigned long long val); 4980b57cec5SDimitry Andricwstring to_wstring(float val); 4990b57cec5SDimitry Andricwstring to_wstring(double val); 5000b57cec5SDimitry Andricwstring to_wstring(long double val); 5010b57cec5SDimitry Andric 5020b57cec5SDimitry Andrictemplate <> struct hash<string>; 503fe6060f1SDimitry Andrictemplate <> struct hash<u8string>; // C++20 5040b57cec5SDimitry Andrictemplate <> struct hash<u16string>; 5050b57cec5SDimitry Andrictemplate <> struct hash<u32string>; 5060b57cec5SDimitry Andrictemplate <> struct hash<wstring>; 5070b57cec5SDimitry Andric 5080b57cec5SDimitry Andricbasic_string<char> operator "" s( const char *str, size_t len ); // C++14 5090b57cec5SDimitry Andricbasic_string<wchar_t> operator "" s( const wchar_t *str, size_t len ); // C++14 510fe6060f1SDimitry Andricbasic_string<char8_t> operator "" s( const char8_t *str, size_t len ); // C++20 5110b57cec5SDimitry Andricbasic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14 5120b57cec5SDimitry Andricbasic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14 5130b57cec5SDimitry Andric 5140b57cec5SDimitry Andric} // std 5150b57cec5SDimitry Andric 5160b57cec5SDimitry Andric*/ 5170b57cec5SDimitry Andric 5180b57cec5SDimitry Andric#include <__config> 519fe6060f1SDimitry Andric#include <__debug> 520fe6060f1SDimitry Andric#include <__functional_base> 521fe6060f1SDimitry Andric#include <__iterator/wrap_iter.h> 5220b57cec5SDimitry Andric#include <algorithm> 523fe6060f1SDimitry Andric#include <compare> 524fe6060f1SDimitry Andric#include <cstdio> // EOF 52569ade1e0SDimitry Andric#include <cstdlib> 526fe6060f1SDimitry Andric#include <cstring> 527fe6060f1SDimitry Andric#include <initializer_list> 528fe6060f1SDimitry Andric#include <iosfwd> 5290b57cec5SDimitry Andric#include <iterator> 5300b57cec5SDimitry Andric#include <memory> 5310b57cec5SDimitry Andric#include <stdexcept> 532fe6060f1SDimitry Andric#include <string_view> 5330b57cec5SDimitry Andric#include <type_traits> 534fe6060f1SDimitry Andric#include <utility> 5350b57cec5SDimitry Andric#include <version> 536fe6060f1SDimitry Andric 537349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 538349cc55cSDimitry Andric# include <cwchar> 539349cc55cSDimitry Andric#endif 540349cc55cSDimitry Andric 5410b57cec5SDimitry Andric#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS 5420b57cec5SDimitry Andric# include <cstdint> 5430b57cec5SDimitry Andric#endif 5440b57cec5SDimitry Andric 5450b57cec5SDimitry Andric#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 5460b57cec5SDimitry Andric#pragma GCC system_header 5470b57cec5SDimitry Andric#endif 5480b57cec5SDimitry Andric 5490b57cec5SDimitry Andric_LIBCPP_PUSH_MACROS 5500b57cec5SDimitry Andric#include <__undef_macros> 5510b57cec5SDimitry Andric 5520b57cec5SDimitry Andric 5530b57cec5SDimitry Andric_LIBCPP_BEGIN_NAMESPACE_STD 5540b57cec5SDimitry Andric 5550b57cec5SDimitry Andric// fpos 5560b57cec5SDimitry Andric 5570b57cec5SDimitry Andrictemplate <class _StateT> 5580b57cec5SDimitry Andricclass _LIBCPP_TEMPLATE_VIS fpos 5590b57cec5SDimitry Andric{ 5600b57cec5SDimitry Andricprivate: 5610b57cec5SDimitry Andric _StateT __st_; 5620b57cec5SDimitry Andric streamoff __off_; 5630b57cec5SDimitry Andricpublic: 5640b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY fpos(streamoff __off = streamoff()) : __st_(), __off_(__off) {} 5650b57cec5SDimitry Andric 5660b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY operator streamoff() const {return __off_;} 5670b57cec5SDimitry Andric 5680b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY _StateT state() const {return __st_;} 5690b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY void state(_StateT __st) {__st_ = __st;} 5700b57cec5SDimitry Andric 5710b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY fpos& operator+=(streamoff __off) {__off_ += __off; return *this;} 5720b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY fpos operator+ (streamoff __off) const {fpos __t(*this); __t += __off; return __t;} 5730b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY fpos& operator-=(streamoff __off) {__off_ -= __off; return *this;} 5740b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY fpos operator- (streamoff __off) const {fpos __t(*this); __t -= __off; return __t;} 5750b57cec5SDimitry Andric}; 5760b57cec5SDimitry Andric 5770b57cec5SDimitry Andrictemplate <class _StateT> 5780b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 5790b57cec5SDimitry Andricstreamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y) 5800b57cec5SDimitry Andric {return streamoff(__x) - streamoff(__y);} 5810b57cec5SDimitry Andric 5820b57cec5SDimitry Andrictemplate <class _StateT> 5830b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 5840b57cec5SDimitry Andricbool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y) 5850b57cec5SDimitry Andric {return streamoff(__x) == streamoff(__y);} 5860b57cec5SDimitry Andric 5870b57cec5SDimitry Andrictemplate <class _StateT> 5880b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 5890b57cec5SDimitry Andricbool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y) 5900b57cec5SDimitry Andric {return streamoff(__x) != streamoff(__y);} 5910b57cec5SDimitry Andric 5920b57cec5SDimitry Andric// basic_string 5930b57cec5SDimitry Andric 5940b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 5950b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 5960b57cec5SDimitry Andricoperator+(const basic_string<_CharT, _Traits, _Allocator>& __x, 5970b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __y); 5980b57cec5SDimitry Andric 5990b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 6000b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 6010b57cec5SDimitry Andricoperator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y); 6020b57cec5SDimitry Andric 6030b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 6040b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 6050b57cec5SDimitry Andricoperator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y); 6060b57cec5SDimitry Andric 6070b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 6080b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 6090b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 6100b57cec5SDimitry Andricoperator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y); 6110b57cec5SDimitry Andric 6120b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 6130b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 6140b57cec5SDimitry Andricoperator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y); 6150b57cec5SDimitry Andric 6160b57cec5SDimitry Andric_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&)) 6170b57cec5SDimitry Andric 6180b57cec5SDimitry Andrictemplate <bool> 619349cc55cSDimitry Andricstruct __basic_string_common; 620349cc55cSDimitry Andric 621349cc55cSDimitry Andrictemplate <> 622349cc55cSDimitry Andricstruct __basic_string_common<true> { 623349cc55cSDimitry Andric // Both are defined in string.cpp 624349cc55cSDimitry Andric _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_length_error() const; 625349cc55cSDimitry Andric _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_out_of_range() const; 6260b57cec5SDimitry Andric}; 6270b57cec5SDimitry Andric 6280b57cec5SDimitry Andrictemplate <class _Iter> 629fe6060f1SDimitry Andricstruct __string_is_trivial_iterator : public false_type {}; 630fe6060f1SDimitry Andric 631fe6060f1SDimitry Andrictemplate <class _Tp> 632fe6060f1SDimitry Andricstruct __string_is_trivial_iterator<_Tp*> 633fe6060f1SDimitry Andric : public is_arithmetic<_Tp> {}; 6340b57cec5SDimitry Andric 6350b57cec5SDimitry Andrictemplate <class _Iter> 636fe6060f1SDimitry Andricstruct __string_is_trivial_iterator<__wrap_iter<_Iter> > 637fe6060f1SDimitry Andric : public __string_is_trivial_iterator<_Iter> {}; 6380b57cec5SDimitry Andric 6390b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Tp> 6405ffd83dbSDimitry Andricstruct __can_be_converted_to_string_view : public _BoolConstant< 6415ffd83dbSDimitry Andric is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value && 6425ffd83dbSDimitry Andric !is_convertible<const _Tp&, const _CharT*>::value 6435ffd83dbSDimitry Andric > {}; 6440b57cec5SDimitry Andric 6450b57cec5SDimitry Andric#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 6460b57cec5SDimitry Andric 6470b57cec5SDimitry Andrictemplate <class _CharT, size_t = sizeof(_CharT)> 6480b57cec5SDimitry Andricstruct __padding 6490b57cec5SDimitry Andric{ 6500b57cec5SDimitry Andric unsigned char __xx[sizeof(_CharT)-1]; 6510b57cec5SDimitry Andric}; 6520b57cec5SDimitry Andric 6530b57cec5SDimitry Andrictemplate <class _CharT> 6540b57cec5SDimitry Andricstruct __padding<_CharT, 1> 6550b57cec5SDimitry Andric{ 6560b57cec5SDimitry Andric}; 6570b57cec5SDimitry Andric 6580b57cec5SDimitry Andric#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 6590b57cec5SDimitry Andric 660fe6060f1SDimitry Andric#ifndef _LIBCPP_HAS_NO_CHAR8_T 661e8d8bef9SDimitry Andrictypedef basic_string<char8_t> u8string; 662e8d8bef9SDimitry Andric#endif 663e8d8bef9SDimitry Andric 664e8d8bef9SDimitry Andric#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS 665e8d8bef9SDimitry Andrictypedef basic_string<char16_t> u16string; 666e8d8bef9SDimitry Andrictypedef basic_string<char32_t> u32string; 667349cc55cSDimitry Andric#endif 668e8d8bef9SDimitry Andric 6690b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 670e8d8bef9SDimitry Andricclass 671e8d8bef9SDimitry Andric _LIBCPP_TEMPLATE_VIS 672fe6060f1SDimitry Andric#ifndef _LIBCPP_HAS_NO_CHAR8_T 673e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(u8string) 674e8d8bef9SDimitry Andric#endif 675e8d8bef9SDimitry Andric#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS 676e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(u16string) 677e8d8bef9SDimitry Andric _LIBCPP_PREFERRED_NAME(u32string) 678e8d8bef9SDimitry Andric#endif 679e8d8bef9SDimitry Andric basic_string 680349cc55cSDimitry Andric : private __basic_string_common<true> // This base class is historical, but it needs to remain for ABI compatibility 6810b57cec5SDimitry Andric{ 6820b57cec5SDimitry Andricpublic: 6830b57cec5SDimitry Andric typedef basic_string __self; 6840b57cec5SDimitry Andric typedef basic_string_view<_CharT, _Traits> __self_view; 6850b57cec5SDimitry Andric typedef _Traits traits_type; 6860b57cec5SDimitry Andric typedef _CharT value_type; 6870b57cec5SDimitry Andric typedef _Allocator allocator_type; 6880b57cec5SDimitry Andric typedef allocator_traits<allocator_type> __alloc_traits; 6890b57cec5SDimitry Andric typedef typename __alloc_traits::size_type size_type; 6900b57cec5SDimitry Andric typedef typename __alloc_traits::difference_type difference_type; 6910b57cec5SDimitry Andric typedef value_type& reference; 6920b57cec5SDimitry Andric typedef const value_type& const_reference; 6930b57cec5SDimitry Andric typedef typename __alloc_traits::pointer pointer; 6940b57cec5SDimitry Andric typedef typename __alloc_traits::const_pointer const_pointer; 6950b57cec5SDimitry Andric 6960b57cec5SDimitry Andric static_assert((!is_array<value_type>::value), "Character type of basic_string must not be an array"); 6970b57cec5SDimitry Andric static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string must be standard-layout"); 6980b57cec5SDimitry Andric static_assert(( is_trivial<value_type>::value), "Character type of basic_string must be trivial"); 6990b57cec5SDimitry Andric static_assert(( is_same<_CharT, typename traits_type::char_type>::value), 7000b57cec5SDimitry Andric "traits_type::char_type must be the same type as CharT"); 7010b57cec5SDimitry Andric static_assert(( is_same<typename allocator_type::value_type, value_type>::value), 7020b57cec5SDimitry Andric "Allocator::value_type must be same type as value_type"); 7030b57cec5SDimitry Andric 7040b57cec5SDimitry Andric typedef __wrap_iter<pointer> iterator; 7050b57cec5SDimitry Andric typedef __wrap_iter<const_pointer> const_iterator; 7060b57cec5SDimitry Andric typedef _VSTD::reverse_iterator<iterator> reverse_iterator; 7070b57cec5SDimitry Andric typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; 7080b57cec5SDimitry Andric 7090b57cec5SDimitry Andricprivate: 7100b57cec5SDimitry Andric 7110b57cec5SDimitry Andric#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 7120b57cec5SDimitry Andric 7130b57cec5SDimitry Andric struct __long 7140b57cec5SDimitry Andric { 7150b57cec5SDimitry Andric pointer __data_; 7160b57cec5SDimitry Andric size_type __size_; 7170b57cec5SDimitry Andric size_type __cap_; 7180b57cec5SDimitry Andric }; 7190b57cec5SDimitry Andric 7200b57cec5SDimitry Andric#ifdef _LIBCPP_BIG_ENDIAN 7210b57cec5SDimitry Andric static const size_type __short_mask = 0x01; 7220b57cec5SDimitry Andric static const size_type __long_mask = 0x1ul; 7230b57cec5SDimitry Andric#else // _LIBCPP_BIG_ENDIAN 7240b57cec5SDimitry Andric static const size_type __short_mask = 0x80; 7250b57cec5SDimitry Andric static const size_type __long_mask = ~(size_type(~0) >> 1); 7260b57cec5SDimitry Andric#endif // _LIBCPP_BIG_ENDIAN 7270b57cec5SDimitry Andric 7280b57cec5SDimitry Andric enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ? 7290b57cec5SDimitry Andric (sizeof(__long) - 1)/sizeof(value_type) : 2}; 7300b57cec5SDimitry Andric 7310b57cec5SDimitry Andric struct __short 7320b57cec5SDimitry Andric { 7330b57cec5SDimitry Andric value_type __data_[__min_cap]; 7340b57cec5SDimitry Andric struct 7350b57cec5SDimitry Andric : __padding<value_type> 7360b57cec5SDimitry Andric { 7370b57cec5SDimitry Andric unsigned char __size_; 7380b57cec5SDimitry Andric }; 7390b57cec5SDimitry Andric }; 7400b57cec5SDimitry Andric 7410b57cec5SDimitry Andric#else 7420b57cec5SDimitry Andric 7430b57cec5SDimitry Andric struct __long 7440b57cec5SDimitry Andric { 7450b57cec5SDimitry Andric size_type __cap_; 7460b57cec5SDimitry Andric size_type __size_; 7470b57cec5SDimitry Andric pointer __data_; 7480b57cec5SDimitry Andric }; 7490b57cec5SDimitry Andric 7500b57cec5SDimitry Andric#ifdef _LIBCPP_BIG_ENDIAN 7510b57cec5SDimitry Andric static const size_type __short_mask = 0x80; 7520b57cec5SDimitry Andric static const size_type __long_mask = ~(size_type(~0) >> 1); 7530b57cec5SDimitry Andric#else // _LIBCPP_BIG_ENDIAN 7540b57cec5SDimitry Andric static const size_type __short_mask = 0x01; 7550b57cec5SDimitry Andric static const size_type __long_mask = 0x1ul; 7560b57cec5SDimitry Andric#endif // _LIBCPP_BIG_ENDIAN 7570b57cec5SDimitry Andric 7580b57cec5SDimitry Andric enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ? 7590b57cec5SDimitry Andric (sizeof(__long) - 1)/sizeof(value_type) : 2}; 7600b57cec5SDimitry Andric 7610b57cec5SDimitry Andric struct __short 7620b57cec5SDimitry Andric { 7630b57cec5SDimitry Andric union 7640b57cec5SDimitry Andric { 7650b57cec5SDimitry Andric unsigned char __size_; 7660b57cec5SDimitry Andric value_type __lx; 7670b57cec5SDimitry Andric }; 7680b57cec5SDimitry Andric value_type __data_[__min_cap]; 7690b57cec5SDimitry Andric }; 7700b57cec5SDimitry Andric 7710b57cec5SDimitry Andric#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 7720b57cec5SDimitry Andric 7730b57cec5SDimitry Andric union __ulx{__long __lx; __short __lxx;}; 7740b57cec5SDimitry Andric 7750b57cec5SDimitry Andric enum {__n_words = sizeof(__ulx) / sizeof(size_type)}; 7760b57cec5SDimitry Andric 7770b57cec5SDimitry Andric struct __raw 7780b57cec5SDimitry Andric { 7790b57cec5SDimitry Andric size_type __words[__n_words]; 7800b57cec5SDimitry Andric }; 7810b57cec5SDimitry Andric 7820b57cec5SDimitry Andric struct __rep 7830b57cec5SDimitry Andric { 7840b57cec5SDimitry Andric union 7850b57cec5SDimitry Andric { 7860b57cec5SDimitry Andric __long __l; 7870b57cec5SDimitry Andric __short __s; 7880b57cec5SDimitry Andric __raw __r; 7890b57cec5SDimitry Andric }; 7900b57cec5SDimitry Andric }; 7910b57cec5SDimitry Andric 7920b57cec5SDimitry Andric __compressed_pair<__rep, allocator_type> __r_; 7930b57cec5SDimitry Andric 7940b57cec5SDimitry Andricpublic: 795fe6060f1SDimitry Andric _LIBCPP_TEMPLATE_DATA_VIS 7960b57cec5SDimitry Andric static const size_type npos = -1; 7970b57cec5SDimitry Andric 7980b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY basic_string() 7990b57cec5SDimitry Andric _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value); 8000b57cec5SDimitry Andric 8010b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a) 8020b57cec5SDimitry Andric#if _LIBCPP_STD_VER <= 14 8030b57cec5SDimitry Andric _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value); 8040b57cec5SDimitry Andric#else 8050b57cec5SDimitry Andric _NOEXCEPT; 8060b57cec5SDimitry Andric#endif 8070b57cec5SDimitry Andric 8080b57cec5SDimitry Andric basic_string(const basic_string& __str); 8090b57cec5SDimitry Andric basic_string(const basic_string& __str, const allocator_type& __a); 8100b57cec5SDimitry Andric 8110b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 8120b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8130b57cec5SDimitry Andric basic_string(basic_string&& __str) 8140b57cec5SDimitry Andric#if _LIBCPP_STD_VER <= 14 8150b57cec5SDimitry Andric _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); 8160b57cec5SDimitry Andric#else 8170b57cec5SDimitry Andric _NOEXCEPT; 8180b57cec5SDimitry Andric#endif 8190b57cec5SDimitry Andric 8200b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8210b57cec5SDimitry Andric basic_string(basic_string&& __str, const allocator_type& __a); 8220b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 8230b57cec5SDimitry Andric 824349cc55cSDimitry Andric template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> > 8250b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 826480093f4SDimitry Andric basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) { 8270b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr"); 8280b57cec5SDimitry Andric __init(__s, traits_type::length(__s)); 829e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 830*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 8310b57cec5SDimitry Andric __get_db()->__insert_c(this); 8320b57cec5SDimitry Andric#endif 8330b57cec5SDimitry Andric } 8340b57cec5SDimitry Andric 835349cc55cSDimitry Andric template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> > 8360b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8370b57cec5SDimitry Andric basic_string(const _CharT* __s, const _Allocator& __a); 8380b57cec5SDimitry Andric 839fe6060f1SDimitry Andric#if _LIBCPP_STD_VER > 20 840fe6060f1SDimitry Andric basic_string(nullptr_t) = delete; 841fe6060f1SDimitry Andric#endif 842fe6060f1SDimitry Andric 8430b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8440b57cec5SDimitry Andric basic_string(const _CharT* __s, size_type __n); 8450b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8460b57cec5SDimitry Andric basic_string(const _CharT* __s, size_type __n, const _Allocator& __a); 8470b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8480b57cec5SDimitry Andric basic_string(size_type __n, _CharT __c); 8490b57cec5SDimitry Andric 850349cc55cSDimitry Andric template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> > 8510b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8520b57cec5SDimitry Andric basic_string(size_type __n, _CharT __c, const _Allocator& __a); 8530b57cec5SDimitry Andric 8540b57cec5SDimitry Andric basic_string(const basic_string& __str, size_type __pos, size_type __n, 8550b57cec5SDimitry Andric const _Allocator& __a = _Allocator()); 8560b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8570b57cec5SDimitry Andric basic_string(const basic_string& __str, size_type __pos, 8580b57cec5SDimitry Andric const _Allocator& __a = _Allocator()); 8590b57cec5SDimitry Andric 860349cc55cSDimitry Andric template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> > 8610b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 8620b57cec5SDimitry Andric basic_string(const _Tp& __t, size_type __pos, size_type __n, 8630b57cec5SDimitry Andric const allocator_type& __a = allocator_type()); 8640b57cec5SDimitry Andric 865349cc55cSDimitry Andric template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && 8665ffd83dbSDimitry Andric !__is_same_uncvref<_Tp, basic_string>::value> > 8670b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 8680b57cec5SDimitry Andric explicit basic_string(const _Tp& __t); 8690b57cec5SDimitry Andric 870349cc55cSDimitry Andric template<class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> > 8710b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 8720b57cec5SDimitry Andric explicit basic_string(const _Tp& __t, const allocator_type& __a); 8730b57cec5SDimitry Andric 874349cc55cSDimitry Andric template<class _InputIterator, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value> > 8750b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8760b57cec5SDimitry Andric basic_string(_InputIterator __first, _InputIterator __last); 877349cc55cSDimitry Andric template<class _InputIterator, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value> > 8780b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8790b57cec5SDimitry Andric basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a); 8800b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 8810b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8820b57cec5SDimitry Andric basic_string(initializer_list<_CharT> __il); 8830b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8840b57cec5SDimitry Andric basic_string(initializer_list<_CharT> __il, const _Allocator& __a); 8850b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 8860b57cec5SDimitry Andric 8870b57cec5SDimitry Andric inline ~basic_string(); 8880b57cec5SDimitry Andric 8890b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 8900b57cec5SDimitry Andric operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); } 8910b57cec5SDimitry Andric 8920b57cec5SDimitry Andric basic_string& operator=(const basic_string& __str); 8930b57cec5SDimitry Andric 894349cc55cSDimitry Andric template <class _Tp, class = __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> > 8950b57cec5SDimitry Andric basic_string& operator=(const _Tp& __t) 8960b57cec5SDimitry Andric {__self_view __sv = __t; return assign(__sv);} 8970b57cec5SDimitry Andric 8980b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 8990b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9000b57cec5SDimitry Andric basic_string& operator=(basic_string&& __str) 9010b57cec5SDimitry Andric _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)); 9020b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9030b57cec5SDimitry Andric basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());} 9040b57cec5SDimitry Andric#endif 9050b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);} 906fe6060f1SDimitry Andric#if _LIBCPP_STD_VER > 20 907fe6060f1SDimitry Andric basic_string& operator=(nullptr_t) = delete; 908fe6060f1SDimitry Andric#endif 9090b57cec5SDimitry Andric basic_string& operator=(value_type __c); 9100b57cec5SDimitry Andric 911e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 9120b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9130b57cec5SDimitry Andric iterator begin() _NOEXCEPT 9140b57cec5SDimitry Andric {return iterator(this, __get_pointer());} 9150b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9160b57cec5SDimitry Andric const_iterator begin() const _NOEXCEPT 9170b57cec5SDimitry Andric {return const_iterator(this, __get_pointer());} 9180b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9190b57cec5SDimitry Andric iterator end() _NOEXCEPT 9200b57cec5SDimitry Andric {return iterator(this, __get_pointer() + size());} 9210b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9220b57cec5SDimitry Andric const_iterator end() const _NOEXCEPT 9230b57cec5SDimitry Andric {return const_iterator(this, __get_pointer() + size());} 9240b57cec5SDimitry Andric#else 9250b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9260b57cec5SDimitry Andric iterator begin() _NOEXCEPT 9270b57cec5SDimitry Andric {return iterator(__get_pointer());} 9280b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9290b57cec5SDimitry Andric const_iterator begin() const _NOEXCEPT 9300b57cec5SDimitry Andric {return const_iterator(__get_pointer());} 9310b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9320b57cec5SDimitry Andric iterator end() _NOEXCEPT 9330b57cec5SDimitry Andric {return iterator(__get_pointer() + size());} 9340b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9350b57cec5SDimitry Andric const_iterator end() const _NOEXCEPT 9360b57cec5SDimitry Andric {return const_iterator(__get_pointer() + size());} 937e8d8bef9SDimitry Andric#endif // _LIBCPP_DEBUG_LEVEL == 2 9380b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9390b57cec5SDimitry Andric reverse_iterator rbegin() _NOEXCEPT 9400b57cec5SDimitry Andric {return reverse_iterator(end());} 9410b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9420b57cec5SDimitry Andric const_reverse_iterator rbegin() const _NOEXCEPT 9430b57cec5SDimitry Andric {return const_reverse_iterator(end());} 9440b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9450b57cec5SDimitry Andric reverse_iterator rend() _NOEXCEPT 9460b57cec5SDimitry Andric {return reverse_iterator(begin());} 9470b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9480b57cec5SDimitry Andric const_reverse_iterator rend() const _NOEXCEPT 9490b57cec5SDimitry Andric {return const_reverse_iterator(begin());} 9500b57cec5SDimitry Andric 9510b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9520b57cec5SDimitry Andric const_iterator cbegin() const _NOEXCEPT 9530b57cec5SDimitry Andric {return begin();} 9540b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9550b57cec5SDimitry Andric const_iterator cend() const _NOEXCEPT 9560b57cec5SDimitry Andric {return end();} 9570b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9580b57cec5SDimitry Andric const_reverse_iterator crbegin() const _NOEXCEPT 9590b57cec5SDimitry Andric {return rbegin();} 9600b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9610b57cec5SDimitry Andric const_reverse_iterator crend() const _NOEXCEPT 9620b57cec5SDimitry Andric {return rend();} 9630b57cec5SDimitry Andric 9640b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT 9650b57cec5SDimitry Andric {return __is_long() ? __get_long_size() : __get_short_size();} 9660b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY size_type length() const _NOEXCEPT {return size();} 9670b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT; 9680b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY size_type capacity() const _NOEXCEPT 9690b57cec5SDimitry Andric {return (__is_long() ? __get_long_cap() 9700b57cec5SDimitry Andric : static_cast<size_type>(__min_cap)) - 1;} 9710b57cec5SDimitry Andric 9720b57cec5SDimitry Andric void resize(size_type __n, value_type __c); 9730b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());} 9740b57cec5SDimitry Andric 975e8d8bef9SDimitry Andric void reserve(size_type __requested_capacity); 9760b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY void __resize_default_init(size_type __n); 9770b57cec5SDimitry Andric 978e8d8bef9SDimitry Andric _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY 979e8d8bef9SDimitry Andric void reserve() _NOEXCEPT {shrink_to_fit();} 9800b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 981e8d8bef9SDimitry Andric void shrink_to_fit() _NOEXCEPT; 9820b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 9830b57cec5SDimitry Andric void clear() _NOEXCEPT; 9840b57cec5SDimitry Andric _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 9850b57cec5SDimitry Andric bool empty() const _NOEXCEPT {return size() == 0;} 9860b57cec5SDimitry Andric 9870b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __pos) const _NOEXCEPT; 9880b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __pos) _NOEXCEPT; 9890b57cec5SDimitry Andric 9900b57cec5SDimitry Andric const_reference at(size_type __n) const; 9910b57cec5SDimitry Andric reference at(size_type __n); 9920b57cec5SDimitry Andric 9930b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const basic_string& __str) {return append(__str);} 9940b57cec5SDimitry Andric 9950b57cec5SDimitry Andric template <class _Tp> 9960b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 997349cc55cSDimitry Andric __enable_if_t 9980b57cec5SDimitry Andric < 9995ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value 10005ffd83dbSDimitry Andric && !__is_same_uncvref<_Tp, basic_string >::value, 10010b57cec5SDimitry Andric basic_string& 10025ffd83dbSDimitry Andric > 10030b57cec5SDimitry Andric operator+=(const _Tp& __t) {__self_view __sv = __t; return append(__sv);} 10040b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const value_type* __s) {return append(__s);} 10050b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c) {push_back(__c); return *this;} 10060b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 10070b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);} 10080b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 10090b57cec5SDimitry Andric 10100b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 10110b57cec5SDimitry Andric basic_string& append(const basic_string& __str); 10120b57cec5SDimitry Andric 10130b57cec5SDimitry Andric template <class _Tp> 10140b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1015349cc55cSDimitry Andric __enable_if_t< 10165ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value 10175ffd83dbSDimitry Andric && !__is_same_uncvref<_Tp, basic_string>::value, 10180b57cec5SDimitry Andric basic_string& 10195ffd83dbSDimitry Andric > 10200b57cec5SDimitry Andric append(const _Tp& __t) { __self_view __sv = __t; return append(__sv.data(), __sv.size()); } 10210b57cec5SDimitry Andric basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos); 10220b57cec5SDimitry Andric 10230b57cec5SDimitry Andric template <class _Tp> 10240b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1025349cc55cSDimitry Andric __enable_if_t 10260b57cec5SDimitry Andric < 10275ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value 10285ffd83dbSDimitry Andric && !__is_same_uncvref<_Tp, basic_string>::value, 10290b57cec5SDimitry Andric basic_string& 10305ffd83dbSDimitry Andric > 10310b57cec5SDimitry Andric append(const _Tp& __t, size_type __pos, size_type __n=npos); 10320b57cec5SDimitry Andric basic_string& append(const value_type* __s, size_type __n); 10330b57cec5SDimitry Andric basic_string& append(const value_type* __s); 10340b57cec5SDimitry Andric basic_string& append(size_type __n, value_type __c); 10350b57cec5SDimitry Andric 10360b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 10370b57cec5SDimitry Andric void __append_default_init(size_type __n); 10380b57cec5SDimitry Andric 10390b57cec5SDimitry Andric template<class _InputIterator> 10400b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1041349cc55cSDimitry Andric __enable_if_t 10420b57cec5SDimitry Andric < 1043fe6060f1SDimitry Andric __is_exactly_cpp17_input_iterator<_InputIterator>::value, 10440b57cec5SDimitry Andric basic_string& 10455ffd83dbSDimitry Andric > 10460b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 10470b57cec5SDimitry Andric append(_InputIterator __first, _InputIterator __last) { 10480b57cec5SDimitry Andric const basic_string __temp(__first, __last, __alloc()); 10490b57cec5SDimitry Andric append(__temp.data(), __temp.size()); 10500b57cec5SDimitry Andric return *this; 10510b57cec5SDimitry Andric } 10520b57cec5SDimitry Andric template<class _ForwardIterator> 10530b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1054349cc55cSDimitry Andric __enable_if_t 10550b57cec5SDimitry Andric < 1056fe6060f1SDimitry Andric __is_cpp17_forward_iterator<_ForwardIterator>::value, 10570b57cec5SDimitry Andric basic_string& 10585ffd83dbSDimitry Andric > 10590b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 1060fe6060f1SDimitry Andric append(_ForwardIterator __first, _ForwardIterator __last); 10610b57cec5SDimitry Andric 10620b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 10630b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 10640b57cec5SDimitry Andric basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());} 10650b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 10660b57cec5SDimitry Andric 10670b57cec5SDimitry Andric void push_back(value_type __c); 10680b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 10690b57cec5SDimitry Andric void pop_back(); 10700b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY reference front() _NOEXCEPT; 10710b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY const_reference front() const _NOEXCEPT; 10720b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY reference back() _NOEXCEPT; 10730b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY const_reference back() const _NOEXCEPT; 10740b57cec5SDimitry Andric 10750b57cec5SDimitry Andric template <class _Tp> 10760b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1077349cc55cSDimitry Andric __enable_if_t 10780b57cec5SDimitry Andric < 10790b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 10800b57cec5SDimitry Andric basic_string& 10815ffd83dbSDimitry Andric > 10820b57cec5SDimitry Andric assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); } 10830b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 10840b57cec5SDimitry Andric basic_string& assign(const basic_string& __str) { return *this = __str; } 10850b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 10860b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 10870b57cec5SDimitry Andric basic_string& assign(basic_string&& __str) 10880b57cec5SDimitry Andric _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) 10890b57cec5SDimitry Andric {*this = _VSTD::move(__str); return *this;} 10900b57cec5SDimitry Andric#endif 10910b57cec5SDimitry Andric basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos); 10920b57cec5SDimitry Andric template <class _Tp> 10930b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1094349cc55cSDimitry Andric __enable_if_t 10950b57cec5SDimitry Andric < 10965ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value 10975ffd83dbSDimitry Andric && !__is_same_uncvref<_Tp, basic_string>::value, 10980b57cec5SDimitry Andric basic_string& 10995ffd83dbSDimitry Andric > 11000b57cec5SDimitry Andric assign(const _Tp & __t, size_type __pos, size_type __n=npos); 11010b57cec5SDimitry Andric basic_string& assign(const value_type* __s, size_type __n); 11020b57cec5SDimitry Andric basic_string& assign(const value_type* __s); 11030b57cec5SDimitry Andric basic_string& assign(size_type __n, value_type __c); 11040b57cec5SDimitry Andric template<class _InputIterator> 11050b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1106349cc55cSDimitry Andric __enable_if_t 11070b57cec5SDimitry Andric < 1108fe6060f1SDimitry Andric __is_exactly_cpp17_input_iterator<_InputIterator>::value, 11090b57cec5SDimitry Andric basic_string& 11105ffd83dbSDimitry Andric > 11110b57cec5SDimitry Andric assign(_InputIterator __first, _InputIterator __last); 11120b57cec5SDimitry Andric template<class _ForwardIterator> 11130b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1114349cc55cSDimitry Andric __enable_if_t 11150b57cec5SDimitry Andric < 1116fe6060f1SDimitry Andric __is_cpp17_forward_iterator<_ForwardIterator>::value, 11170b57cec5SDimitry Andric basic_string& 11185ffd83dbSDimitry Andric > 11190b57cec5SDimitry Andric assign(_ForwardIterator __first, _ForwardIterator __last); 11200b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 11210b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11220b57cec5SDimitry Andric basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());} 11230b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 11240b57cec5SDimitry Andric 11250b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11260b57cec5SDimitry Andric basic_string& insert(size_type __pos1, const basic_string& __str); 11270b57cec5SDimitry Andric 11280b57cec5SDimitry Andric template <class _Tp> 11290b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1130349cc55cSDimitry Andric __enable_if_t 11310b57cec5SDimitry Andric < 11320b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 11330b57cec5SDimitry Andric basic_string& 11345ffd83dbSDimitry Andric > 11350b57cec5SDimitry Andric insert(size_type __pos1, const _Tp& __t) 11360b57cec5SDimitry Andric { __self_view __sv = __t; return insert(__pos1, __sv.data(), __sv.size()); } 11370b57cec5SDimitry Andric 11380b57cec5SDimitry Andric template <class _Tp> 11390b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1140349cc55cSDimitry Andric __enable_if_t 11410b57cec5SDimitry Andric < 11425ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value, 11430b57cec5SDimitry Andric basic_string& 11445ffd83dbSDimitry Andric > 11450b57cec5SDimitry Andric insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos); 11460b57cec5SDimitry Andric basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos); 11470b57cec5SDimitry Andric basic_string& insert(size_type __pos, const value_type* __s, size_type __n); 11480b57cec5SDimitry Andric basic_string& insert(size_type __pos, const value_type* __s); 11490b57cec5SDimitry Andric basic_string& insert(size_type __pos, size_type __n, value_type __c); 11500b57cec5SDimitry Andric iterator insert(const_iterator __pos, value_type __c); 11510b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11520b57cec5SDimitry Andric iterator insert(const_iterator __pos, size_type __n, value_type __c); 11530b57cec5SDimitry Andric template<class _InputIterator> 11540b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1155349cc55cSDimitry Andric __enable_if_t 11560b57cec5SDimitry Andric < 1157fe6060f1SDimitry Andric __is_exactly_cpp17_input_iterator<_InputIterator>::value, 11580b57cec5SDimitry Andric iterator 11595ffd83dbSDimitry Andric > 11600b57cec5SDimitry Andric insert(const_iterator __pos, _InputIterator __first, _InputIterator __last); 11610b57cec5SDimitry Andric template<class _ForwardIterator> 11620b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1163349cc55cSDimitry Andric __enable_if_t 11640b57cec5SDimitry Andric < 1165fe6060f1SDimitry Andric __is_cpp17_forward_iterator<_ForwardIterator>::value, 11660b57cec5SDimitry Andric iterator 11675ffd83dbSDimitry Andric > 11680b57cec5SDimitry Andric insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last); 11690b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 11700b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11710b57cec5SDimitry Andric iterator insert(const_iterator __pos, initializer_list<value_type> __il) 11720b57cec5SDimitry Andric {return insert(__pos, __il.begin(), __il.end());} 11730b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 11740b57cec5SDimitry Andric 11750b57cec5SDimitry Andric basic_string& erase(size_type __pos = 0, size_type __n = npos); 11760b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11770b57cec5SDimitry Andric iterator erase(const_iterator __pos); 11780b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11790b57cec5SDimitry Andric iterator erase(const_iterator __first, const_iterator __last); 11800b57cec5SDimitry Andric 11810b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 11820b57cec5SDimitry Andric basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str); 11830b57cec5SDimitry Andric 11840b57cec5SDimitry Andric template <class _Tp> 11850b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1186349cc55cSDimitry Andric __enable_if_t 11870b57cec5SDimitry Andric < 11880b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 11890b57cec5SDimitry Andric basic_string& 11905ffd83dbSDimitry Andric > 11910b57cec5SDimitry Andric replace(size_type __pos1, size_type __n1, const _Tp& __t) { __self_view __sv = __t; return replace(__pos1, __n1, __sv.data(), __sv.size()); } 11920b57cec5SDimitry Andric basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos); 11930b57cec5SDimitry Andric template <class _Tp> 11940b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1195349cc55cSDimitry Andric __enable_if_t 11960b57cec5SDimitry Andric < 11975ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value, 11980b57cec5SDimitry Andric basic_string& 11995ffd83dbSDimitry Andric > 12000b57cec5SDimitry Andric replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos); 12010b57cec5SDimitry Andric basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2); 12020b57cec5SDimitry Andric basic_string& replace(size_type __pos, size_type __n1, const value_type* __s); 12030b57cec5SDimitry Andric basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c); 12040b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12050b57cec5SDimitry Andric basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str); 12060b57cec5SDimitry Andric 12070b57cec5SDimitry Andric template <class _Tp> 12080b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1209349cc55cSDimitry Andric __enable_if_t 12100b57cec5SDimitry Andric < 12110b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 12120b57cec5SDimitry Andric basic_string& 12135ffd83dbSDimitry Andric > 12140b57cec5SDimitry Andric replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); } 12150b57cec5SDimitry Andric 12160b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12170b57cec5SDimitry Andric basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n); 12180b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12190b57cec5SDimitry Andric basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s); 12200b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12210b57cec5SDimitry Andric basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c); 12220b57cec5SDimitry Andric template<class _InputIterator> 12230b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1224349cc55cSDimitry Andric __enable_if_t 12250b57cec5SDimitry Andric < 1226480093f4SDimitry Andric __is_cpp17_input_iterator<_InputIterator>::value, 12270b57cec5SDimitry Andric basic_string& 12285ffd83dbSDimitry Andric > 12290b57cec5SDimitry Andric replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2); 12300b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 12310b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12320b57cec5SDimitry Andric basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il) 12330b57cec5SDimitry Andric {return replace(__i1, __i2, __il.begin(), __il.end());} 12340b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 12350b57cec5SDimitry Andric 12360b57cec5SDimitry Andric size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const; 12370b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12380b57cec5SDimitry Andric basic_string substr(size_type __pos = 0, size_type __n = npos) const; 12390b57cec5SDimitry Andric 12400b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12410b57cec5SDimitry Andric void swap(basic_string& __str) 12420b57cec5SDimitry Andric#if _LIBCPP_STD_VER >= 14 12430b57cec5SDimitry Andric _NOEXCEPT; 12440b57cec5SDimitry Andric#else 12450b57cec5SDimitry Andric _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || 12460b57cec5SDimitry Andric __is_nothrow_swappable<allocator_type>::value); 12470b57cec5SDimitry Andric#endif 12480b57cec5SDimitry Andric 12490b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12500b57cec5SDimitry Andric const value_type* c_str() const _NOEXCEPT {return data();} 12510b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 1252480093f4SDimitry Andric const value_type* data() const _NOEXCEPT {return _VSTD::__to_address(__get_pointer());} 12530b57cec5SDimitry Andric#if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY) 12540b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 1255480093f4SDimitry Andric value_type* data() _NOEXCEPT {return _VSTD::__to_address(__get_pointer());} 12560b57cec5SDimitry Andric#endif 12570b57cec5SDimitry Andric 12580b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12590b57cec5SDimitry Andric allocator_type get_allocator() const _NOEXCEPT {return __alloc();} 12600b57cec5SDimitry Andric 12610b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12620b57cec5SDimitry Andric size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; 12630b57cec5SDimitry Andric 12640b57cec5SDimitry Andric template <class _Tp> 12650b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1266349cc55cSDimitry Andric __enable_if_t 12670b57cec5SDimitry Andric < 12680b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 12690b57cec5SDimitry Andric size_type 12705ffd83dbSDimitry Andric > 1271fe6060f1SDimitry Andric find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT; 12720b57cec5SDimitry Andric size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 12730b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12740b57cec5SDimitry Andric size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; 12750b57cec5SDimitry Andric size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT; 12760b57cec5SDimitry Andric 12770b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12780b57cec5SDimitry Andric size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; 12790b57cec5SDimitry Andric 12800b57cec5SDimitry Andric template <class _Tp> 12810b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1282349cc55cSDimitry Andric __enable_if_t 12830b57cec5SDimitry Andric < 12840b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 12850b57cec5SDimitry Andric size_type 12865ffd83dbSDimitry Andric > 1287fe6060f1SDimitry Andric rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT; 12880b57cec5SDimitry Andric size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 12890b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12900b57cec5SDimitry Andric size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; 12910b57cec5SDimitry Andric size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT; 12920b57cec5SDimitry Andric 12930b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 12940b57cec5SDimitry Andric size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; 12950b57cec5SDimitry Andric 12960b57cec5SDimitry Andric template <class _Tp> 12970b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1298349cc55cSDimitry Andric __enable_if_t 12990b57cec5SDimitry Andric < 13000b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 13010b57cec5SDimitry Andric size_type 13025ffd83dbSDimitry Andric > 1303fe6060f1SDimitry Andric find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT; 13040b57cec5SDimitry Andric size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 13050b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13060b57cec5SDimitry Andric size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; 13070b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13080b57cec5SDimitry Andric size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT; 13090b57cec5SDimitry Andric 13100b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13110b57cec5SDimitry Andric size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; 13120b57cec5SDimitry Andric 13130b57cec5SDimitry Andric template <class _Tp> 13140b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1315349cc55cSDimitry Andric __enable_if_t 13160b57cec5SDimitry Andric < 13170b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 13180b57cec5SDimitry Andric size_type 13195ffd83dbSDimitry Andric > 1320fe6060f1SDimitry Andric find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT; 13210b57cec5SDimitry Andric size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 13220b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13230b57cec5SDimitry Andric size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; 13240b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13250b57cec5SDimitry Andric size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT; 13260b57cec5SDimitry Andric 13270b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13280b57cec5SDimitry Andric size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT; 13290b57cec5SDimitry Andric 13300b57cec5SDimitry Andric template <class _Tp> 13310b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1332349cc55cSDimitry Andric __enable_if_t 13330b57cec5SDimitry Andric < 13340b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 13350b57cec5SDimitry Andric size_type 13365ffd83dbSDimitry Andric > 1337fe6060f1SDimitry Andric find_first_not_of(const _Tp &__t, size_type __pos = 0) const _NOEXCEPT; 13380b57cec5SDimitry Andric size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 13390b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13400b57cec5SDimitry Andric size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT; 13410b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13420b57cec5SDimitry Andric size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT; 13430b57cec5SDimitry Andric 13440b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13450b57cec5SDimitry Andric size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT; 13460b57cec5SDimitry Andric 13470b57cec5SDimitry Andric template <class _Tp> 13480b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1349349cc55cSDimitry Andric __enable_if_t 13500b57cec5SDimitry Andric < 13510b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 13520b57cec5SDimitry Andric size_type 13535ffd83dbSDimitry Andric > 1354fe6060f1SDimitry Andric find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT; 13550b57cec5SDimitry Andric size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT; 13560b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13570b57cec5SDimitry Andric size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT; 13580b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13590b57cec5SDimitry Andric size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT; 13600b57cec5SDimitry Andric 13610b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13620b57cec5SDimitry Andric int compare(const basic_string& __str) const _NOEXCEPT; 13630b57cec5SDimitry Andric 13640b57cec5SDimitry Andric template <class _Tp> 13650b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1366349cc55cSDimitry Andric __enable_if_t 13670b57cec5SDimitry Andric < 13680b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 13690b57cec5SDimitry Andric int 13705ffd83dbSDimitry Andric > 1371fe6060f1SDimitry Andric compare(const _Tp &__t) const _NOEXCEPT; 13720b57cec5SDimitry Andric 13730b57cec5SDimitry Andric template <class _Tp> 13740b57cec5SDimitry Andric _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS 1375349cc55cSDimitry Andric __enable_if_t 13760b57cec5SDimitry Andric < 13770b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 13780b57cec5SDimitry Andric int 13795ffd83dbSDimitry Andric > 13800b57cec5SDimitry Andric compare(size_type __pos1, size_type __n1, const _Tp& __t) const; 13810b57cec5SDimitry Andric 13820b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 13830b57cec5SDimitry Andric int compare(size_type __pos1, size_type __n1, const basic_string& __str) const; 13840b57cec5SDimitry Andric int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos) const; 13850b57cec5SDimitry Andric 13860b57cec5SDimitry Andric template <class _Tp> 13870b57cec5SDimitry Andric inline _LIBCPP_INLINE_VISIBILITY 1388349cc55cSDimitry Andric __enable_if_t 13890b57cec5SDimitry Andric < 13905ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value, 13910b57cec5SDimitry Andric int 13925ffd83dbSDimitry Andric > 13930b57cec5SDimitry Andric compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const; 13940b57cec5SDimitry Andric int compare(const value_type* __s) const _NOEXCEPT; 13950b57cec5SDimitry Andric int compare(size_type __pos1, size_type __n1, const value_type* __s) const; 13960b57cec5SDimitry Andric int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const; 13970b57cec5SDimitry Andric 13980b57cec5SDimitry Andric#if _LIBCPP_STD_VER > 17 1399349cc55cSDimitry Andric constexpr _LIBCPP_INLINE_VISIBILITY 1400349cc55cSDimitry Andric bool starts_with(__self_view __sv) const noexcept 14010b57cec5SDimitry Andric { return __self_view(data(), size()).starts_with(__sv); } 14020b57cec5SDimitry Andric 1403349cc55cSDimitry Andric constexpr _LIBCPP_INLINE_VISIBILITY 1404349cc55cSDimitry Andric bool starts_with(value_type __c) const noexcept 14050b57cec5SDimitry Andric { return !empty() && _Traits::eq(front(), __c); } 14060b57cec5SDimitry Andric 1407349cc55cSDimitry Andric constexpr _LIBCPP_INLINE_VISIBILITY 1408349cc55cSDimitry Andric bool starts_with(const value_type* __s) const noexcept 14090b57cec5SDimitry Andric { return starts_with(__self_view(__s)); } 14100b57cec5SDimitry Andric 1411349cc55cSDimitry Andric constexpr _LIBCPP_INLINE_VISIBILITY 1412349cc55cSDimitry Andric bool ends_with(__self_view __sv) const noexcept 14130b57cec5SDimitry Andric { return __self_view(data(), size()).ends_with( __sv); } 14140b57cec5SDimitry Andric 1415349cc55cSDimitry Andric constexpr _LIBCPP_INLINE_VISIBILITY 1416349cc55cSDimitry Andric bool ends_with(value_type __c) const noexcept 14170b57cec5SDimitry Andric { return !empty() && _Traits::eq(back(), __c); } 14180b57cec5SDimitry Andric 1419349cc55cSDimitry Andric constexpr _LIBCPP_INLINE_VISIBILITY 1420349cc55cSDimitry Andric bool ends_with(const value_type* __s) const noexcept 14210b57cec5SDimitry Andric { return ends_with(__self_view(__s)); } 14220b57cec5SDimitry Andric#endif 14230b57cec5SDimitry Andric 1424e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER > 20 1425e8d8bef9SDimitry Andric constexpr _LIBCPP_INLINE_VISIBILITY 1426e8d8bef9SDimitry Andric bool contains(__self_view __sv) const noexcept 1427e8d8bef9SDimitry Andric { return __self_view(data(), size()).contains(__sv); } 1428e8d8bef9SDimitry Andric 1429e8d8bef9SDimitry Andric constexpr _LIBCPP_INLINE_VISIBILITY 1430e8d8bef9SDimitry Andric bool contains(value_type __c) const noexcept 1431e8d8bef9SDimitry Andric { return __self_view(data(), size()).contains(__c); } 1432e8d8bef9SDimitry Andric 1433e8d8bef9SDimitry Andric constexpr _LIBCPP_INLINE_VISIBILITY 1434e8d8bef9SDimitry Andric bool contains(const value_type* __s) const 1435e8d8bef9SDimitry Andric { return __self_view(data(), size()).contains(__s); } 1436e8d8bef9SDimitry Andric#endif 1437e8d8bef9SDimitry Andric 14380b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY bool __invariants() const; 14390b57cec5SDimitry Andric 14400b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT; 14410b57cec5SDimitry Andric 1442e8d8bef9SDimitry Andric _LIBCPP_INLINE_VISIBILITY void __shrink_or_extend(size_type __target_capacity); 1443e8d8bef9SDimitry Andric 14440b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 14450b57cec5SDimitry Andric bool __is_long() const _NOEXCEPT 14460b57cec5SDimitry Andric {return bool(__r_.first().__s.__size_ & __short_mask);} 14470b57cec5SDimitry Andric 1448e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 14490b57cec5SDimitry Andric 14500b57cec5SDimitry Andric bool __dereferenceable(const const_iterator* __i) const; 14510b57cec5SDimitry Andric bool __decrementable(const const_iterator* __i) const; 14520b57cec5SDimitry Andric bool __addable(const const_iterator* __i, ptrdiff_t __n) const; 14530b57cec5SDimitry Andric bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const; 14540b57cec5SDimitry Andric 1455e8d8bef9SDimitry Andric#endif // _LIBCPP_DEBUG_LEVEL == 2 14560b57cec5SDimitry Andric 14570b57cec5SDimitry Andricprivate: 14580b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 14590b57cec5SDimitry Andric allocator_type& __alloc() _NOEXCEPT 14600b57cec5SDimitry Andric {return __r_.second();} 14610b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 14620b57cec5SDimitry Andric const allocator_type& __alloc() const _NOEXCEPT 14630b57cec5SDimitry Andric {return __r_.second();} 14640b57cec5SDimitry Andric 14650b57cec5SDimitry Andric#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 14660b57cec5SDimitry Andric 14670b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 14680b57cec5SDimitry Andric void __set_short_size(size_type __s) _NOEXCEPT 14690b57cec5SDimitry Andric# ifdef _LIBCPP_BIG_ENDIAN 14700b57cec5SDimitry Andric {__r_.first().__s.__size_ = (unsigned char)(__s << 1);} 14710b57cec5SDimitry Andric# else 14720b57cec5SDimitry Andric {__r_.first().__s.__size_ = (unsigned char)(__s);} 14730b57cec5SDimitry Andric# endif 14740b57cec5SDimitry Andric 14750b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 14760b57cec5SDimitry Andric size_type __get_short_size() const _NOEXCEPT 14770b57cec5SDimitry Andric# ifdef _LIBCPP_BIG_ENDIAN 14780b57cec5SDimitry Andric {return __r_.first().__s.__size_ >> 1;} 14790b57cec5SDimitry Andric# else 14800b57cec5SDimitry Andric {return __r_.first().__s.__size_;} 14810b57cec5SDimitry Andric# endif 14820b57cec5SDimitry Andric 14830b57cec5SDimitry Andric#else // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 14840b57cec5SDimitry Andric 14850b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 14860b57cec5SDimitry Andric void __set_short_size(size_type __s) _NOEXCEPT 14870b57cec5SDimitry Andric# ifdef _LIBCPP_BIG_ENDIAN 14880b57cec5SDimitry Andric {__r_.first().__s.__size_ = (unsigned char)(__s);} 14890b57cec5SDimitry Andric# else 14900b57cec5SDimitry Andric {__r_.first().__s.__size_ = (unsigned char)(__s << 1);} 14910b57cec5SDimitry Andric# endif 14920b57cec5SDimitry Andric 14930b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 14940b57cec5SDimitry Andric size_type __get_short_size() const _NOEXCEPT 14950b57cec5SDimitry Andric# ifdef _LIBCPP_BIG_ENDIAN 14960b57cec5SDimitry Andric {return __r_.first().__s.__size_;} 14970b57cec5SDimitry Andric# else 14980b57cec5SDimitry Andric {return __r_.first().__s.__size_ >> 1;} 14990b57cec5SDimitry Andric# endif 15000b57cec5SDimitry Andric 15010b57cec5SDimitry Andric#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT 15020b57cec5SDimitry Andric 15030b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15040b57cec5SDimitry Andric void __set_long_size(size_type __s) _NOEXCEPT 15050b57cec5SDimitry Andric {__r_.first().__l.__size_ = __s;} 15060b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15070b57cec5SDimitry Andric size_type __get_long_size() const _NOEXCEPT 15080b57cec5SDimitry Andric {return __r_.first().__l.__size_;} 15090b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15100b57cec5SDimitry Andric void __set_size(size_type __s) _NOEXCEPT 15110b57cec5SDimitry Andric {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);} 15120b57cec5SDimitry Andric 15130b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15140b57cec5SDimitry Andric void __set_long_cap(size_type __s) _NOEXCEPT 15150b57cec5SDimitry Andric {__r_.first().__l.__cap_ = __long_mask | __s;} 15160b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15170b57cec5SDimitry Andric size_type __get_long_cap() const _NOEXCEPT 15180b57cec5SDimitry Andric {return __r_.first().__l.__cap_ & size_type(~__long_mask);} 15190b57cec5SDimitry Andric 15200b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15210b57cec5SDimitry Andric void __set_long_pointer(pointer __p) _NOEXCEPT 15220b57cec5SDimitry Andric {__r_.first().__l.__data_ = __p;} 15230b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15240b57cec5SDimitry Andric pointer __get_long_pointer() _NOEXCEPT 15250b57cec5SDimitry Andric {return __r_.first().__l.__data_;} 15260b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15270b57cec5SDimitry Andric const_pointer __get_long_pointer() const _NOEXCEPT 15280b57cec5SDimitry Andric {return __r_.first().__l.__data_;} 15290b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15300b57cec5SDimitry Andric pointer __get_short_pointer() _NOEXCEPT 15310b57cec5SDimitry Andric {return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);} 15320b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15330b57cec5SDimitry Andric const_pointer __get_short_pointer() const _NOEXCEPT 15340b57cec5SDimitry Andric {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);} 15350b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15360b57cec5SDimitry Andric pointer __get_pointer() _NOEXCEPT 15370b57cec5SDimitry Andric {return __is_long() ? __get_long_pointer() : __get_short_pointer();} 15380b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15390b57cec5SDimitry Andric const_pointer __get_pointer() const _NOEXCEPT 15400b57cec5SDimitry Andric {return __is_long() ? __get_long_pointer() : __get_short_pointer();} 15410b57cec5SDimitry Andric 15420b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15430b57cec5SDimitry Andric void __zero() _NOEXCEPT 15440b57cec5SDimitry Andric { 15450b57cec5SDimitry Andric size_type (&__a)[__n_words] = __r_.first().__r.__words; 15460b57cec5SDimitry Andric for (unsigned __i = 0; __i < __n_words; ++__i) 15470b57cec5SDimitry Andric __a[__i] = 0; 15480b57cec5SDimitry Andric } 15490b57cec5SDimitry Andric 15500b57cec5SDimitry Andric template <size_type __a> static 15510b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 15520b57cec5SDimitry Andric size_type __align_it(size_type __s) _NOEXCEPT 15530b57cec5SDimitry Andric {return (__s + (__a-1)) & ~(__a-1);} 15540b57cec5SDimitry Andric enum {__alignment = 16}; 15550b57cec5SDimitry Andric static _LIBCPP_INLINE_VISIBILITY 15560b57cec5SDimitry Andric size_type __recommend(size_type __s) _NOEXCEPT 15570b57cec5SDimitry Andric { 15580b57cec5SDimitry Andric if (__s < __min_cap) return static_cast<size_type>(__min_cap) - 1; 15590b57cec5SDimitry Andric size_type __guess = __align_it<sizeof(value_type) < __alignment ? 15600b57cec5SDimitry Andric __alignment/sizeof(value_type) : 1 > (__s+1) - 1; 15610b57cec5SDimitry Andric if (__guess == __min_cap) ++__guess; 15620b57cec5SDimitry Andric return __guess; 15630b57cec5SDimitry Andric } 15640b57cec5SDimitry Andric 15650b57cec5SDimitry Andric inline 15660b57cec5SDimitry Andric void __init(const value_type* __s, size_type __sz, size_type __reserve); 15670b57cec5SDimitry Andric inline 15680b57cec5SDimitry Andric void __init(const value_type* __s, size_type __sz); 15690b57cec5SDimitry Andric inline 15700b57cec5SDimitry Andric void __init(size_type __n, value_type __c); 15710b57cec5SDimitry Andric 15725ffd83dbSDimitry Andric // Slow path for the (inlined) copy constructor for 'long' strings. 15735ffd83dbSDimitry Andric // Always externally instantiated and not inlined. 15745ffd83dbSDimitry Andric // Requires that __s is zero terminated. 15755ffd83dbSDimitry Andric // The main reason for this function to exist is because for unstable, we 15765ffd83dbSDimitry Andric // want to allow inlining of the copy constructor. However, we don't want 15775ffd83dbSDimitry Andric // to call the __init() functions as those are marked as inline which may 15785ffd83dbSDimitry Andric // result in over-aggressive inlining by the compiler, where our aim is 15795ffd83dbSDimitry Andric // to only inline the fast path code directly in the ctor. 15805ffd83dbSDimitry Andric void __init_copy_ctor_external(const value_type* __s, size_type __sz); 15815ffd83dbSDimitry Andric 15820b57cec5SDimitry Andric template <class _InputIterator> 15830b57cec5SDimitry Andric inline 1584349cc55cSDimitry Andric __enable_if_t 15850b57cec5SDimitry Andric < 15865ffd83dbSDimitry Andric __is_exactly_cpp17_input_iterator<_InputIterator>::value 15875ffd83dbSDimitry Andric > 15880b57cec5SDimitry Andric __init(_InputIterator __first, _InputIterator __last); 15890b57cec5SDimitry Andric 15900b57cec5SDimitry Andric template <class _ForwardIterator> 15910b57cec5SDimitry Andric inline 1592349cc55cSDimitry Andric __enable_if_t 15930b57cec5SDimitry Andric < 15945ffd83dbSDimitry Andric __is_cpp17_forward_iterator<_ForwardIterator>::value 15955ffd83dbSDimitry Andric > 15960b57cec5SDimitry Andric __init(_ForwardIterator __first, _ForwardIterator __last); 15970b57cec5SDimitry Andric 15980b57cec5SDimitry Andric void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz, 15990b57cec5SDimitry Andric size_type __n_copy, size_type __n_del, size_type __n_add = 0); 16000b57cec5SDimitry Andric void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz, 16010b57cec5SDimitry Andric size_type __n_copy, size_type __n_del, 16020b57cec5SDimitry Andric size_type __n_add, const value_type* __p_new_stuff); 16030b57cec5SDimitry Andric 16045ffd83dbSDimitry Andric // __assign_no_alias is invoked for assignment operations where we 16055ffd83dbSDimitry Andric // have proof that the input does not alias the current instance. 16065ffd83dbSDimitry Andric // For example, operator=(basic_string) performs a 'self' check. 16075ffd83dbSDimitry Andric template <bool __is_short> 16085ffd83dbSDimitry Andric basic_string& __assign_no_alias(const value_type* __s, size_type __n); 16095ffd83dbSDimitry Andric 16100b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16110b57cec5SDimitry Andric void __erase_to_end(size_type __pos); 16120b57cec5SDimitry Andric 16135ffd83dbSDimitry Andric // __erase_external_with_move is invoked for erase() invocations where 16145ffd83dbSDimitry Andric // `n ~= npos`, likely requiring memory moves on the string data. 16155ffd83dbSDimitry Andric void __erase_external_with_move(size_type __pos, size_type __n); 16165ffd83dbSDimitry Andric 16170b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16180b57cec5SDimitry Andric void __copy_assign_alloc(const basic_string& __str) 16190b57cec5SDimitry Andric {__copy_assign_alloc(__str, integral_constant<bool, 16200b57cec5SDimitry Andric __alloc_traits::propagate_on_container_copy_assignment::value>());} 16210b57cec5SDimitry Andric 16220b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16230b57cec5SDimitry Andric void __copy_assign_alloc(const basic_string& __str, true_type) 16240b57cec5SDimitry Andric { 16250b57cec5SDimitry Andric if (__alloc() == __str.__alloc()) 16260b57cec5SDimitry Andric __alloc() = __str.__alloc(); 16270b57cec5SDimitry Andric else 16280b57cec5SDimitry Andric { 16290b57cec5SDimitry Andric if (!__str.__is_long()) 16300b57cec5SDimitry Andric { 16310b57cec5SDimitry Andric __clear_and_shrink(); 16320b57cec5SDimitry Andric __alloc() = __str.__alloc(); 16330b57cec5SDimitry Andric } 16340b57cec5SDimitry Andric else 16350b57cec5SDimitry Andric { 16360b57cec5SDimitry Andric allocator_type __a = __str.__alloc(); 16370b57cec5SDimitry Andric pointer __p = __alloc_traits::allocate(__a, __str.__get_long_cap()); 16380b57cec5SDimitry Andric __clear_and_shrink(); 16390b57cec5SDimitry Andric __alloc() = _VSTD::move(__a); 16400b57cec5SDimitry Andric __set_long_pointer(__p); 16410b57cec5SDimitry Andric __set_long_cap(__str.__get_long_cap()); 16420b57cec5SDimitry Andric __set_long_size(__str.size()); 16430b57cec5SDimitry Andric } 16440b57cec5SDimitry Andric } 16450b57cec5SDimitry Andric } 16460b57cec5SDimitry Andric 16470b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16480b57cec5SDimitry Andric void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT 16490b57cec5SDimitry Andric {} 16500b57cec5SDimitry Andric 16510b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 16520b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16530b57cec5SDimitry Andric void __move_assign(basic_string& __str, false_type) 16540b57cec5SDimitry Andric _NOEXCEPT_(__alloc_traits::is_always_equal::value); 16550b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16560b57cec5SDimitry Andric void __move_assign(basic_string& __str, true_type) 16570b57cec5SDimitry Andric#if _LIBCPP_STD_VER > 14 16580b57cec5SDimitry Andric _NOEXCEPT; 16590b57cec5SDimitry Andric#else 16600b57cec5SDimitry Andric _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value); 16610b57cec5SDimitry Andric#endif 16620b57cec5SDimitry Andric#endif 16630b57cec5SDimitry Andric 16640b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16650b57cec5SDimitry Andric void 16660b57cec5SDimitry Andric __move_assign_alloc(basic_string& __str) 16670b57cec5SDimitry Andric _NOEXCEPT_( 16680b57cec5SDimitry Andric !__alloc_traits::propagate_on_container_move_assignment::value || 16690b57cec5SDimitry Andric is_nothrow_move_assignable<allocator_type>::value) 16700b57cec5SDimitry Andric {__move_assign_alloc(__str, integral_constant<bool, 16710b57cec5SDimitry Andric __alloc_traits::propagate_on_container_move_assignment::value>());} 16720b57cec5SDimitry Andric 16730b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16740b57cec5SDimitry Andric void __move_assign_alloc(basic_string& __c, true_type) 16750b57cec5SDimitry Andric _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) 16760b57cec5SDimitry Andric { 16770b57cec5SDimitry Andric __alloc() = _VSTD::move(__c.__alloc()); 16780b57cec5SDimitry Andric } 16790b57cec5SDimitry Andric 16800b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 16810b57cec5SDimitry Andric void __move_assign_alloc(basic_string&, false_type) 16820b57cec5SDimitry Andric _NOEXCEPT 16830b57cec5SDimitry Andric {} 16840b57cec5SDimitry Andric 16855ffd83dbSDimitry Andric basic_string& __assign_external(const value_type* __s); 16865ffd83dbSDimitry Andric basic_string& __assign_external(const value_type* __s, size_type __n); 16875ffd83dbSDimitry Andric 16885ffd83dbSDimitry Andric // Assigns the value in __s, guaranteed to be __n < __min_cap in length. 16895ffd83dbSDimitry Andric inline basic_string& __assign_short(const value_type* __s, size_type __n) { 16905ffd83dbSDimitry Andric pointer __p = __is_long() 16915ffd83dbSDimitry Andric ? (__set_long_size(__n), __get_long_pointer()) 16925ffd83dbSDimitry Andric : (__set_short_size(__n), __get_short_pointer()); 16935ffd83dbSDimitry Andric traits_type::move(_VSTD::__to_address(__p), __s, __n); 16945ffd83dbSDimitry Andric traits_type::assign(__p[__n], value_type()); 16955ffd83dbSDimitry Andric return *this; 16965ffd83dbSDimitry Andric } 16975ffd83dbSDimitry Andric 1698*0eae32dcSDimitry Andric _LIBCPP_HIDE_FROM_ABI basic_string& __null_terminate_at(value_type* __p, size_type __newsz) { 1699*0eae32dcSDimitry Andric __set_size(__newsz); 1700*0eae32dcSDimitry Andric __invalidate_iterators_past(__newsz); 1701*0eae32dcSDimitry Andric traits_type::assign(__p[__newsz], value_type()); 1702*0eae32dcSDimitry Andric return *this; 1703*0eae32dcSDimitry Andric } 1704*0eae32dcSDimitry Andric 17050b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators(); 17060b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type); 17070b57cec5SDimitry Andric 1708fe6060f1SDimitry Andric template<class _Tp> 1709fe6060f1SDimitry Andric _LIBCPP_INLINE_VISIBILITY 1710fe6060f1SDimitry Andric bool __addr_in_range(_Tp&& __t) const { 1711fe6060f1SDimitry Andric const volatile void *__p = _VSTD::addressof(__t); 1712fe6060f1SDimitry Andric return data() <= __p && __p <= data() + size(); 1713fe6060f1SDimitry Andric } 1714fe6060f1SDimitry Andric 171569ade1e0SDimitry Andric _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI 171669ade1e0SDimitry Andric void __throw_length_error() const { 171769ade1e0SDimitry Andric#ifndef _LIBCPP_NO_EXCEPTIONS 171869ade1e0SDimitry Andric __basic_string_common<true>::__throw_length_error(); 171969ade1e0SDimitry Andric#else 172069ade1e0SDimitry Andric _VSTD::abort(); 172169ade1e0SDimitry Andric#endif 172269ade1e0SDimitry Andric } 172369ade1e0SDimitry Andric 172469ade1e0SDimitry Andric _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI 172569ade1e0SDimitry Andric void __throw_out_of_range() const { 172669ade1e0SDimitry Andric#ifndef _LIBCPP_NO_EXCEPTIONS 172769ade1e0SDimitry Andric __basic_string_common<true>::__throw_out_of_range(); 172869ade1e0SDimitry Andric#else 172969ade1e0SDimitry Andric _VSTD::abort(); 173069ade1e0SDimitry Andric#endif 173169ade1e0SDimitry Andric } 173269ade1e0SDimitry Andric 17330b57cec5SDimitry Andric friend basic_string operator+<>(const basic_string&, const basic_string&); 17340b57cec5SDimitry Andric friend basic_string operator+<>(const value_type*, const basic_string&); 17350b57cec5SDimitry Andric friend basic_string operator+<>(value_type, const basic_string&); 17360b57cec5SDimitry Andric friend basic_string operator+<>(const basic_string&, const value_type*); 17370b57cec5SDimitry Andric friend basic_string operator+<>(const basic_string&, value_type); 17380b57cec5SDimitry Andric}; 17390b57cec5SDimitry Andric 17405ffd83dbSDimitry Andric// These declarations must appear before any functions are implicitly used 17415ffd83dbSDimitry Andric// so that they have the correct visibility specifier. 17425ffd83dbSDimitry Andric#ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION 17435ffd83dbSDimitry Andric _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char) 1744349cc55cSDimitry Andric# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 17455ffd83dbSDimitry Andric _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t) 1746349cc55cSDimitry Andric# endif 17475ffd83dbSDimitry Andric#else 17485ffd83dbSDimitry Andric _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char) 1749349cc55cSDimitry Andric# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 17505ffd83dbSDimitry Andric _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t) 17515ffd83dbSDimitry Andric# endif 1752349cc55cSDimitry Andric#endif 17535ffd83dbSDimitry Andric 17545ffd83dbSDimitry Andric 1755349cc55cSDimitry Andric#if _LIBCPP_STD_VER >= 17 17560b57cec5SDimitry Andrictemplate<class _InputIterator, 1757fe6060f1SDimitry Andric class _CharT = __iter_value_type<_InputIterator>, 17580b57cec5SDimitry Andric class _Allocator = allocator<_CharT>, 1759349cc55cSDimitry Andric class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>, 1760349cc55cSDimitry Andric class = enable_if_t<__is_allocator<_Allocator>::value> 17610b57cec5SDimitry Andric > 17620b57cec5SDimitry Andricbasic_string(_InputIterator, _InputIterator, _Allocator = _Allocator()) 17630b57cec5SDimitry Andric -> basic_string<_CharT, char_traits<_CharT>, _Allocator>; 17640b57cec5SDimitry Andric 17650b57cec5SDimitry Andrictemplate<class _CharT, 17660b57cec5SDimitry Andric class _Traits, 17670b57cec5SDimitry Andric class _Allocator = allocator<_CharT>, 1768349cc55cSDimitry Andric class = enable_if_t<__is_allocator<_Allocator>::value> 17690b57cec5SDimitry Andric > 17700b57cec5SDimitry Andricexplicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator()) 17710b57cec5SDimitry Andric -> basic_string<_CharT, _Traits, _Allocator>; 17720b57cec5SDimitry Andric 17730b57cec5SDimitry Andrictemplate<class _CharT, 17740b57cec5SDimitry Andric class _Traits, 17750b57cec5SDimitry Andric class _Allocator = allocator<_CharT>, 1776349cc55cSDimitry Andric class = enable_if_t<__is_allocator<_Allocator>::value>, 17770b57cec5SDimitry Andric class _Sz = typename allocator_traits<_Allocator>::size_type 17780b57cec5SDimitry Andric > 17790b57cec5SDimitry Andricbasic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator()) 17800b57cec5SDimitry Andric -> basic_string<_CharT, _Traits, _Allocator>; 17810b57cec5SDimitry Andric#endif 17820b57cec5SDimitry Andric 17830b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 17840b57cec5SDimitry Andricinline 17850b57cec5SDimitry Andricvoid 17860b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators() 17870b57cec5SDimitry Andric{ 1788e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 1789*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 17900b57cec5SDimitry Andric __get_db()->__invalidate_all(this); 1791e8d8bef9SDimitry Andric#endif 17920b57cec5SDimitry Andric} 17930b57cec5SDimitry Andric 17940b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 17950b57cec5SDimitry Andricinline 17960b57cec5SDimitry Andricvoid 1797fe6060f1SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type __pos) 17980b57cec5SDimitry Andric{ 1799e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 1800*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) { 18010b57cec5SDimitry Andric __c_node* __c = __get_db()->__find_c_and_lock(this); 18020b57cec5SDimitry Andric if (__c) 18030b57cec5SDimitry Andric { 18040b57cec5SDimitry Andric const_pointer __new_last = __get_pointer() + __pos; 18050b57cec5SDimitry Andric for (__i_node** __p = __c->end_; __p != __c->beg_; ) 18060b57cec5SDimitry Andric { 18070b57cec5SDimitry Andric --__p; 18080b57cec5SDimitry Andric const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_); 18090b57cec5SDimitry Andric if (__i->base() > __new_last) 18100b57cec5SDimitry Andric { 18110b57cec5SDimitry Andric (*__p)->__c_ = nullptr; 18120b57cec5SDimitry Andric if (--__c->end_ != __p) 1813e8d8bef9SDimitry Andric _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*)); 18140b57cec5SDimitry Andric } 18150b57cec5SDimitry Andric } 18160b57cec5SDimitry Andric __get_db()->unlock(); 18170b57cec5SDimitry Andric } 1818*0eae32dcSDimitry Andric } 1819fe6060f1SDimitry Andric#else 1820fe6060f1SDimitry Andric (void)__pos; 1821e8d8bef9SDimitry Andric#endif // _LIBCPP_DEBUG_LEVEL == 2 18220b57cec5SDimitry Andric} 18230b57cec5SDimitry Andric 18240b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 18250b57cec5SDimitry Andricinline 18260b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string() 18270b57cec5SDimitry Andric _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) 1828480093f4SDimitry Andric : __r_(__default_init_tag(), __default_init_tag()) 18290b57cec5SDimitry Andric{ 1830e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 1831*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 18320b57cec5SDimitry Andric __get_db()->__insert_c(this); 18330b57cec5SDimitry Andric#endif 18340b57cec5SDimitry Andric __zero(); 18350b57cec5SDimitry Andric} 18360b57cec5SDimitry Andric 18370b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 18380b57cec5SDimitry Andricinline 18390b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a) 18400b57cec5SDimitry Andric#if _LIBCPP_STD_VER <= 14 18410b57cec5SDimitry Andric _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value) 18420b57cec5SDimitry Andric#else 18430b57cec5SDimitry Andric _NOEXCEPT 18440b57cec5SDimitry Andric#endif 1845480093f4SDimitry Andric: __r_(__default_init_tag(), __a) 18460b57cec5SDimitry Andric{ 1847e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 1848*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 18490b57cec5SDimitry Andric __get_db()->__insert_c(this); 18500b57cec5SDimitry Andric#endif 18510b57cec5SDimitry Andric __zero(); 18520b57cec5SDimitry Andric} 18530b57cec5SDimitry Andric 18540b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 18550b57cec5SDimitry Andricvoid basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, 18560b57cec5SDimitry Andric size_type __sz, 18570b57cec5SDimitry Andric size_type __reserve) 18580b57cec5SDimitry Andric{ 18590b57cec5SDimitry Andric if (__reserve > max_size()) 18600b57cec5SDimitry Andric this->__throw_length_error(); 18610b57cec5SDimitry Andric pointer __p; 18620b57cec5SDimitry Andric if (__reserve < __min_cap) 18630b57cec5SDimitry Andric { 18640b57cec5SDimitry Andric __set_short_size(__sz); 18650b57cec5SDimitry Andric __p = __get_short_pointer(); 18660b57cec5SDimitry Andric } 18670b57cec5SDimitry Andric else 18680b57cec5SDimitry Andric { 18690b57cec5SDimitry Andric size_type __cap = __recommend(__reserve); 18700b57cec5SDimitry Andric __p = __alloc_traits::allocate(__alloc(), __cap+1); 18710b57cec5SDimitry Andric __set_long_pointer(__p); 18720b57cec5SDimitry Andric __set_long_cap(__cap+1); 18730b57cec5SDimitry Andric __set_long_size(__sz); 18740b57cec5SDimitry Andric } 1875480093f4SDimitry Andric traits_type::copy(_VSTD::__to_address(__p), __s, __sz); 18760b57cec5SDimitry Andric traits_type::assign(__p[__sz], value_type()); 18770b57cec5SDimitry Andric} 18780b57cec5SDimitry Andric 18790b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 18800b57cec5SDimitry Andricvoid 18810b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz) 18820b57cec5SDimitry Andric{ 18830b57cec5SDimitry Andric if (__sz > max_size()) 18840b57cec5SDimitry Andric this->__throw_length_error(); 18850b57cec5SDimitry Andric pointer __p; 18860b57cec5SDimitry Andric if (__sz < __min_cap) 18870b57cec5SDimitry Andric { 18880b57cec5SDimitry Andric __set_short_size(__sz); 18890b57cec5SDimitry Andric __p = __get_short_pointer(); 18900b57cec5SDimitry Andric } 18910b57cec5SDimitry Andric else 18920b57cec5SDimitry Andric { 18930b57cec5SDimitry Andric size_type __cap = __recommend(__sz); 18940b57cec5SDimitry Andric __p = __alloc_traits::allocate(__alloc(), __cap+1); 18950b57cec5SDimitry Andric __set_long_pointer(__p); 18960b57cec5SDimitry Andric __set_long_cap(__cap+1); 18970b57cec5SDimitry Andric __set_long_size(__sz); 18980b57cec5SDimitry Andric } 1899480093f4SDimitry Andric traits_type::copy(_VSTD::__to_address(__p), __s, __sz); 19000b57cec5SDimitry Andric traits_type::assign(__p[__sz], value_type()); 19010b57cec5SDimitry Andric} 19020b57cec5SDimitry Andric 19030b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 19040b57cec5SDimitry Andrictemplate <class> 19050b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a) 1906480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 19070b57cec5SDimitry Andric{ 19080b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr"); 19090b57cec5SDimitry Andric __init(__s, traits_type::length(__s)); 1910e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 1911*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 19120b57cec5SDimitry Andric __get_db()->__insert_c(this); 19130b57cec5SDimitry Andric#endif 19140b57cec5SDimitry Andric} 19150b57cec5SDimitry Andric 19160b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 19170b57cec5SDimitry Andricinline 19180b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n) 1919480093f4SDimitry Andric : __r_(__default_init_tag(), __default_init_tag()) 19200b57cec5SDimitry Andric{ 19210b57cec5SDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr"); 19220b57cec5SDimitry Andric __init(__s, __n); 1923e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 1924*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 19250b57cec5SDimitry Andric __get_db()->__insert_c(this); 19260b57cec5SDimitry Andric#endif 19270b57cec5SDimitry Andric} 19280b57cec5SDimitry Andric 19290b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 19300b57cec5SDimitry Andricinline 19310b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a) 1932480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 19330b57cec5SDimitry Andric{ 19340b57cec5SDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr"); 19350b57cec5SDimitry Andric __init(__s, __n); 1936e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 1937*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 19380b57cec5SDimitry Andric __get_db()->__insert_c(this); 19390b57cec5SDimitry Andric#endif 19400b57cec5SDimitry Andric} 19410b57cec5SDimitry Andric 19420b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 19430b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str) 1944480093f4SDimitry Andric : __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc())) 19450b57cec5SDimitry Andric{ 19460b57cec5SDimitry Andric if (!__str.__is_long()) 19470b57cec5SDimitry Andric __r_.first().__r = __str.__r_.first().__r; 19480b57cec5SDimitry Andric else 19495ffd83dbSDimitry Andric __init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()), 19505ffd83dbSDimitry Andric __str.__get_long_size()); 19515ffd83dbSDimitry Andric 1952e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 1953*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 19540b57cec5SDimitry Andric __get_db()->__insert_c(this); 19550b57cec5SDimitry Andric#endif 19560b57cec5SDimitry Andric} 19570b57cec5SDimitry Andric 19580b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 19590b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string( 19600b57cec5SDimitry Andric const basic_string& __str, const allocator_type& __a) 1961480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 19620b57cec5SDimitry Andric{ 19630b57cec5SDimitry Andric if (!__str.__is_long()) 19640b57cec5SDimitry Andric __r_.first().__r = __str.__r_.first().__r; 19650b57cec5SDimitry Andric else 19665ffd83dbSDimitry Andric __init_copy_ctor_external(_VSTD::__to_address(__str.__get_long_pointer()), 19675ffd83dbSDimitry Andric __str.__get_long_size()); 1968e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 1969*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 19700b57cec5SDimitry Andric __get_db()->__insert_c(this); 19710b57cec5SDimitry Andric#endif 19720b57cec5SDimitry Andric} 19730b57cec5SDimitry Andric 19745ffd83dbSDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 19755ffd83dbSDimitry Andricvoid basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external( 19765ffd83dbSDimitry Andric const value_type* __s, size_type __sz) { 19775ffd83dbSDimitry Andric pointer __p; 19785ffd83dbSDimitry Andric if (__sz < __min_cap) { 19795ffd83dbSDimitry Andric __p = __get_short_pointer(); 19805ffd83dbSDimitry Andric __set_short_size(__sz); 19815ffd83dbSDimitry Andric } else { 19825ffd83dbSDimitry Andric if (__sz > max_size()) 19835ffd83dbSDimitry Andric this->__throw_length_error(); 19845ffd83dbSDimitry Andric size_t __cap = __recommend(__sz); 19855ffd83dbSDimitry Andric __p = __alloc_traits::allocate(__alloc(), __cap + 1); 19865ffd83dbSDimitry Andric __set_long_pointer(__p); 19875ffd83dbSDimitry Andric __set_long_cap(__cap + 1); 19885ffd83dbSDimitry Andric __set_long_size(__sz); 19895ffd83dbSDimitry Andric } 19905ffd83dbSDimitry Andric traits_type::copy(_VSTD::__to_address(__p), __s, __sz + 1); 19915ffd83dbSDimitry Andric} 19925ffd83dbSDimitry Andric 19930b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 19940b57cec5SDimitry Andric 19950b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 19960b57cec5SDimitry Andricinline 19970b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str) 19980b57cec5SDimitry Andric#if _LIBCPP_STD_VER <= 14 19990b57cec5SDimitry Andric _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) 20000b57cec5SDimitry Andric#else 20010b57cec5SDimitry Andric _NOEXCEPT 20020b57cec5SDimitry Andric#endif 20030b57cec5SDimitry Andric : __r_(_VSTD::move(__str.__r_)) 20040b57cec5SDimitry Andric{ 20050b57cec5SDimitry Andric __str.__zero(); 2006e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2007*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) { 20080b57cec5SDimitry Andric __get_db()->__insert_c(this); 20090b57cec5SDimitry Andric if (__is_long()) 20100b57cec5SDimitry Andric __get_db()->swap(this, &__str); 2011*0eae32dcSDimitry Andric } 20120b57cec5SDimitry Andric#endif 20130b57cec5SDimitry Andric} 20140b57cec5SDimitry Andric 20150b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 20160b57cec5SDimitry Andricinline 20170b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a) 2018480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 20190b57cec5SDimitry Andric{ 20200b57cec5SDimitry Andric if (__str.__is_long() && __a != __str.__alloc()) // copy, not move 2021480093f4SDimitry Andric __init(_VSTD::__to_address(__str.__get_long_pointer()), __str.__get_long_size()); 20220b57cec5SDimitry Andric else 20230b57cec5SDimitry Andric { 20240b57cec5SDimitry Andric __r_.first().__r = __str.__r_.first().__r; 20250b57cec5SDimitry Andric __str.__zero(); 20260b57cec5SDimitry Andric } 2027e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2028*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) { 20290b57cec5SDimitry Andric __get_db()->__insert_c(this); 20300b57cec5SDimitry Andric if (__is_long()) 20310b57cec5SDimitry Andric __get_db()->swap(this, &__str); 2032*0eae32dcSDimitry Andric } 20330b57cec5SDimitry Andric#endif 20340b57cec5SDimitry Andric} 20350b57cec5SDimitry Andric 20360b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 20370b57cec5SDimitry Andric 20380b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 20390b57cec5SDimitry Andricvoid 20400b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c) 20410b57cec5SDimitry Andric{ 20420b57cec5SDimitry Andric if (__n > max_size()) 20430b57cec5SDimitry Andric this->__throw_length_error(); 20440b57cec5SDimitry Andric pointer __p; 20450b57cec5SDimitry Andric if (__n < __min_cap) 20460b57cec5SDimitry Andric { 20470b57cec5SDimitry Andric __set_short_size(__n); 20480b57cec5SDimitry Andric __p = __get_short_pointer(); 20490b57cec5SDimitry Andric } 20500b57cec5SDimitry Andric else 20510b57cec5SDimitry Andric { 20520b57cec5SDimitry Andric size_type __cap = __recommend(__n); 20530b57cec5SDimitry Andric __p = __alloc_traits::allocate(__alloc(), __cap+1); 20540b57cec5SDimitry Andric __set_long_pointer(__p); 20550b57cec5SDimitry Andric __set_long_cap(__cap+1); 20560b57cec5SDimitry Andric __set_long_size(__n); 20570b57cec5SDimitry Andric } 2058480093f4SDimitry Andric traits_type::assign(_VSTD::__to_address(__p), __n, __c); 20590b57cec5SDimitry Andric traits_type::assign(__p[__n], value_type()); 20600b57cec5SDimitry Andric} 20610b57cec5SDimitry Andric 20620b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 20630b57cec5SDimitry Andricinline 20640b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c) 2065480093f4SDimitry Andric : __r_(__default_init_tag(), __default_init_tag()) 20660b57cec5SDimitry Andric{ 20670b57cec5SDimitry Andric __init(__n, __c); 2068e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2069*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 20700b57cec5SDimitry Andric __get_db()->__insert_c(this); 20710b57cec5SDimitry Andric#endif 20720b57cec5SDimitry Andric} 20730b57cec5SDimitry Andric 20740b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 20750b57cec5SDimitry Andrictemplate <class> 20760b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a) 2077480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 20780b57cec5SDimitry Andric{ 20790b57cec5SDimitry Andric __init(__n, __c); 2080e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2081*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 20820b57cec5SDimitry Andric __get_db()->__insert_c(this); 20830b57cec5SDimitry Andric#endif 20840b57cec5SDimitry Andric} 20850b57cec5SDimitry Andric 20860b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 20870b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, 20880b57cec5SDimitry Andric size_type __pos, size_type __n, 20890b57cec5SDimitry Andric const _Allocator& __a) 2090480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 20910b57cec5SDimitry Andric{ 20920b57cec5SDimitry Andric size_type __str_sz = __str.size(); 20930b57cec5SDimitry Andric if (__pos > __str_sz) 20940b57cec5SDimitry Andric this->__throw_out_of_range(); 20950b57cec5SDimitry Andric __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos)); 2096e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2097*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 20980b57cec5SDimitry Andric __get_db()->__insert_c(this); 20990b57cec5SDimitry Andric#endif 21000b57cec5SDimitry Andric} 21010b57cec5SDimitry Andric 21020b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 21030b57cec5SDimitry Andricinline 21040b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos, 21050b57cec5SDimitry Andric const _Allocator& __a) 2106480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 21070b57cec5SDimitry Andric{ 21080b57cec5SDimitry Andric size_type __str_sz = __str.size(); 21090b57cec5SDimitry Andric if (__pos > __str_sz) 21100b57cec5SDimitry Andric this->__throw_out_of_range(); 21110b57cec5SDimitry Andric __init(__str.data() + __pos, __str_sz - __pos); 2112e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2113*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 21140b57cec5SDimitry Andric __get_db()->__insert_c(this); 21150b57cec5SDimitry Andric#endif 21160b57cec5SDimitry Andric} 21170b57cec5SDimitry Andric 21180b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 21190b57cec5SDimitry Andrictemplate <class _Tp, class> 21200b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string( 21210b57cec5SDimitry Andric const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a) 2122480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 21230b57cec5SDimitry Andric{ 21240b57cec5SDimitry Andric __self_view __sv0 = __t; 21250b57cec5SDimitry Andric __self_view __sv = __sv0.substr(__pos, __n); 21260b57cec5SDimitry Andric __init(__sv.data(), __sv.size()); 2127e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2128*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 21290b57cec5SDimitry Andric __get_db()->__insert_c(this); 21300b57cec5SDimitry Andric#endif 21310b57cec5SDimitry Andric} 21320b57cec5SDimitry Andric 21330b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 21340b57cec5SDimitry Andrictemplate <class _Tp, class> 21350b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t) 2136480093f4SDimitry Andric : __r_(__default_init_tag(), __default_init_tag()) 21370b57cec5SDimitry Andric{ 21380b57cec5SDimitry Andric __self_view __sv = __t; 21390b57cec5SDimitry Andric __init(__sv.data(), __sv.size()); 2140e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2141*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 21420b57cec5SDimitry Andric __get_db()->__insert_c(this); 21430b57cec5SDimitry Andric#endif 21440b57cec5SDimitry Andric} 21450b57cec5SDimitry Andric 21460b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 21470b57cec5SDimitry Andrictemplate <class _Tp, class> 21480b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a) 2149480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 21500b57cec5SDimitry Andric{ 21510b57cec5SDimitry Andric __self_view __sv = __t; 21520b57cec5SDimitry Andric __init(__sv.data(), __sv.size()); 2153e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2154*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 21550b57cec5SDimitry Andric __get_db()->__insert_c(this); 21560b57cec5SDimitry Andric#endif 21570b57cec5SDimitry Andric} 21580b57cec5SDimitry Andric 21590b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 21600b57cec5SDimitry Andrictemplate <class _InputIterator> 2161349cc55cSDimitry Andric__enable_if_t 21620b57cec5SDimitry Andric< 21635ffd83dbSDimitry Andric __is_exactly_cpp17_input_iterator<_InputIterator>::value 21645ffd83dbSDimitry Andric> 21650b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last) 21660b57cec5SDimitry Andric{ 21670b57cec5SDimitry Andric __zero(); 21680b57cec5SDimitry Andric#ifndef _LIBCPP_NO_EXCEPTIONS 21690b57cec5SDimitry Andric try 21700b57cec5SDimitry Andric { 21710b57cec5SDimitry Andric#endif // _LIBCPP_NO_EXCEPTIONS 21720b57cec5SDimitry Andric for (; __first != __last; ++__first) 21730b57cec5SDimitry Andric push_back(*__first); 21740b57cec5SDimitry Andric#ifndef _LIBCPP_NO_EXCEPTIONS 21750b57cec5SDimitry Andric } 21760b57cec5SDimitry Andric catch (...) 21770b57cec5SDimitry Andric { 21780b57cec5SDimitry Andric if (__is_long()) 21790b57cec5SDimitry Andric __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); 21800b57cec5SDimitry Andric throw; 21810b57cec5SDimitry Andric } 21820b57cec5SDimitry Andric#endif // _LIBCPP_NO_EXCEPTIONS 21830b57cec5SDimitry Andric} 21840b57cec5SDimitry Andric 21850b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 21860b57cec5SDimitry Andrictemplate <class _ForwardIterator> 2187349cc55cSDimitry Andric__enable_if_t 21880b57cec5SDimitry Andric< 21895ffd83dbSDimitry Andric __is_cpp17_forward_iterator<_ForwardIterator>::value 21905ffd83dbSDimitry Andric> 21910b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last) 21920b57cec5SDimitry Andric{ 21930b57cec5SDimitry Andric size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last)); 21940b57cec5SDimitry Andric if (__sz > max_size()) 21950b57cec5SDimitry Andric this->__throw_length_error(); 21960b57cec5SDimitry Andric pointer __p; 21970b57cec5SDimitry Andric if (__sz < __min_cap) 21980b57cec5SDimitry Andric { 21990b57cec5SDimitry Andric __set_short_size(__sz); 22000b57cec5SDimitry Andric __p = __get_short_pointer(); 22010b57cec5SDimitry Andric } 22020b57cec5SDimitry Andric else 22030b57cec5SDimitry Andric { 22040b57cec5SDimitry Andric size_type __cap = __recommend(__sz); 22050b57cec5SDimitry Andric __p = __alloc_traits::allocate(__alloc(), __cap+1); 22060b57cec5SDimitry Andric __set_long_pointer(__p); 22070b57cec5SDimitry Andric __set_long_cap(__cap+1); 22080b57cec5SDimitry Andric __set_long_size(__sz); 22090b57cec5SDimitry Andric } 2210fe6060f1SDimitry Andric 2211fe6060f1SDimitry Andric#ifndef _LIBCPP_NO_EXCEPTIONS 2212fe6060f1SDimitry Andric try 2213fe6060f1SDimitry Andric { 2214fe6060f1SDimitry Andric#endif // _LIBCPP_NO_EXCEPTIONS 22150b57cec5SDimitry Andric for (; __first != __last; ++__first, (void) ++__p) 22160b57cec5SDimitry Andric traits_type::assign(*__p, *__first); 22170b57cec5SDimitry Andric traits_type::assign(*__p, value_type()); 2218fe6060f1SDimitry Andric#ifndef _LIBCPP_NO_EXCEPTIONS 2219fe6060f1SDimitry Andric } 2220fe6060f1SDimitry Andric catch (...) 2221fe6060f1SDimitry Andric { 2222fe6060f1SDimitry Andric if (__is_long()) 2223fe6060f1SDimitry Andric __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); 2224fe6060f1SDimitry Andric throw; 2225fe6060f1SDimitry Andric } 2226fe6060f1SDimitry Andric#endif // _LIBCPP_NO_EXCEPTIONS 22270b57cec5SDimitry Andric} 22280b57cec5SDimitry Andric 22290b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 22300b57cec5SDimitry Andrictemplate<class _InputIterator, class> 22310b57cec5SDimitry Andricinline 22320b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last) 2233480093f4SDimitry Andric : __r_(__default_init_tag(), __default_init_tag()) 22340b57cec5SDimitry Andric{ 22350b57cec5SDimitry Andric __init(__first, __last); 2236e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2237*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 22380b57cec5SDimitry Andric __get_db()->__insert_c(this); 22390b57cec5SDimitry Andric#endif 22400b57cec5SDimitry Andric} 22410b57cec5SDimitry Andric 22420b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 22430b57cec5SDimitry Andrictemplate<class _InputIterator, class> 22440b57cec5SDimitry Andricinline 22450b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last, 22460b57cec5SDimitry Andric const allocator_type& __a) 2247480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 22480b57cec5SDimitry Andric{ 22490b57cec5SDimitry Andric __init(__first, __last); 2250e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2251*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 22520b57cec5SDimitry Andric __get_db()->__insert_c(this); 22530b57cec5SDimitry Andric#endif 22540b57cec5SDimitry Andric} 22550b57cec5SDimitry Andric 22560b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 22570b57cec5SDimitry Andric 22580b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 22590b57cec5SDimitry Andricinline 22600b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string( 22610b57cec5SDimitry Andric initializer_list<_CharT> __il) 2262480093f4SDimitry Andric : __r_(__default_init_tag(), __default_init_tag()) 22630b57cec5SDimitry Andric{ 22640b57cec5SDimitry Andric __init(__il.begin(), __il.end()); 2265e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2266*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 22670b57cec5SDimitry Andric __get_db()->__insert_c(this); 22680b57cec5SDimitry Andric#endif 22690b57cec5SDimitry Andric} 22700b57cec5SDimitry Andric 22710b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 22720b57cec5SDimitry Andricinline 22730b57cec5SDimitry Andric 22740b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::basic_string( 22750b57cec5SDimitry Andric initializer_list<_CharT> __il, const _Allocator& __a) 2276480093f4SDimitry Andric : __r_(__default_init_tag(), __a) 22770b57cec5SDimitry Andric{ 22780b57cec5SDimitry Andric __init(__il.begin(), __il.end()); 2279e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2280*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 22810b57cec5SDimitry Andric __get_db()->__insert_c(this); 22820b57cec5SDimitry Andric#endif 22830b57cec5SDimitry Andric} 22840b57cec5SDimitry Andric 22850b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 22860b57cec5SDimitry Andric 22870b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 22880b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::~basic_string() 22890b57cec5SDimitry Andric{ 2290e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 2291*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) 22920b57cec5SDimitry Andric __get_db()->__erase_c(this); 22930b57cec5SDimitry Andric#endif 22940b57cec5SDimitry Andric if (__is_long()) 22950b57cec5SDimitry Andric __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); 22960b57cec5SDimitry Andric} 22970b57cec5SDimitry Andric 22980b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 22990b57cec5SDimitry Andricvoid 23000b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace 23010b57cec5SDimitry Andric (size_type __old_cap, size_type __delta_cap, size_type __old_sz, 23020b57cec5SDimitry Andric size_type __n_copy, size_type __n_del, size_type __n_add, const value_type* __p_new_stuff) 23030b57cec5SDimitry Andric{ 23040b57cec5SDimitry Andric size_type __ms = max_size(); 23050b57cec5SDimitry Andric if (__delta_cap > __ms - __old_cap - 1) 23060b57cec5SDimitry Andric this->__throw_length_error(); 23070b57cec5SDimitry Andric pointer __old_p = __get_pointer(); 23080b57cec5SDimitry Andric size_type __cap = __old_cap < __ms / 2 - __alignment ? 23090b57cec5SDimitry Andric __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) : 23100b57cec5SDimitry Andric __ms - 1; 23110b57cec5SDimitry Andric pointer __p = __alloc_traits::allocate(__alloc(), __cap+1); 23120b57cec5SDimitry Andric __invalidate_all_iterators(); 23130b57cec5SDimitry Andric if (__n_copy != 0) 2314480093f4SDimitry Andric traits_type::copy(_VSTD::__to_address(__p), 2315480093f4SDimitry Andric _VSTD::__to_address(__old_p), __n_copy); 23160b57cec5SDimitry Andric if (__n_add != 0) 2317480093f4SDimitry Andric traits_type::copy(_VSTD::__to_address(__p) + __n_copy, __p_new_stuff, __n_add); 23180b57cec5SDimitry Andric size_type __sec_cp_sz = __old_sz - __n_del - __n_copy; 23190b57cec5SDimitry Andric if (__sec_cp_sz != 0) 2320480093f4SDimitry Andric traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add, 2321480093f4SDimitry Andric _VSTD::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz); 23220b57cec5SDimitry Andric if (__old_cap+1 != __min_cap) 23230b57cec5SDimitry Andric __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1); 23240b57cec5SDimitry Andric __set_long_pointer(__p); 23250b57cec5SDimitry Andric __set_long_cap(__cap+1); 23260b57cec5SDimitry Andric __old_sz = __n_copy + __n_add + __sec_cp_sz; 23270b57cec5SDimitry Andric __set_long_size(__old_sz); 23280b57cec5SDimitry Andric traits_type::assign(__p[__old_sz], value_type()); 23290b57cec5SDimitry Andric} 23300b57cec5SDimitry Andric 23310b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 23320b57cec5SDimitry Andricvoid 23330b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz, 23340b57cec5SDimitry Andric size_type __n_copy, size_type __n_del, size_type __n_add) 23350b57cec5SDimitry Andric{ 23360b57cec5SDimitry Andric size_type __ms = max_size(); 23370b57cec5SDimitry Andric if (__delta_cap > __ms - __old_cap) 23380b57cec5SDimitry Andric this->__throw_length_error(); 23390b57cec5SDimitry Andric pointer __old_p = __get_pointer(); 23400b57cec5SDimitry Andric size_type __cap = __old_cap < __ms / 2 - __alignment ? 23410b57cec5SDimitry Andric __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) : 23420b57cec5SDimitry Andric __ms - 1; 23430b57cec5SDimitry Andric pointer __p = __alloc_traits::allocate(__alloc(), __cap+1); 23440b57cec5SDimitry Andric __invalidate_all_iterators(); 23450b57cec5SDimitry Andric if (__n_copy != 0) 2346480093f4SDimitry Andric traits_type::copy(_VSTD::__to_address(__p), 2347480093f4SDimitry Andric _VSTD::__to_address(__old_p), __n_copy); 23480b57cec5SDimitry Andric size_type __sec_cp_sz = __old_sz - __n_del - __n_copy; 23490b57cec5SDimitry Andric if (__sec_cp_sz != 0) 2350480093f4SDimitry Andric traits_type::copy(_VSTD::__to_address(__p) + __n_copy + __n_add, 2351480093f4SDimitry Andric _VSTD::__to_address(__old_p) + __n_copy + __n_del, 23520b57cec5SDimitry Andric __sec_cp_sz); 23530b57cec5SDimitry Andric if (__old_cap+1 != __min_cap) 23540b57cec5SDimitry Andric __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1); 23550b57cec5SDimitry Andric __set_long_pointer(__p); 23560b57cec5SDimitry Andric __set_long_cap(__cap+1); 23570b57cec5SDimitry Andric} 23580b57cec5SDimitry Andric 23590b57cec5SDimitry Andric// assign 23600b57cec5SDimitry Andric 23610b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 23625ffd83dbSDimitry Andrictemplate <bool __is_short> 23630b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 23645ffd83dbSDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__assign_no_alias( 23655ffd83dbSDimitry Andric const value_type* __s, size_type __n) { 23665ffd83dbSDimitry Andric size_type __cap = __is_short ? __min_cap : __get_long_cap(); 23675ffd83dbSDimitry Andric if (__n < __cap) { 23685ffd83dbSDimitry Andric pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer(); 23695ffd83dbSDimitry Andric __is_short ? __set_short_size(__n) : __set_long_size(__n); 23705ffd83dbSDimitry Andric traits_type::copy(_VSTD::__to_address(__p), __s, __n); 23715ffd83dbSDimitry Andric traits_type::assign(__p[__n], value_type()); 23725ffd83dbSDimitry Andric __invalidate_iterators_past(__n); 23735ffd83dbSDimitry Andric } else { 23745ffd83dbSDimitry Andric size_type __sz = __is_short ? __get_short_size() : __get_long_size(); 23755ffd83dbSDimitry Andric __grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __s); 23765ffd83dbSDimitry Andric } 23775ffd83dbSDimitry Andric return *this; 23785ffd83dbSDimitry Andric} 23795ffd83dbSDimitry Andric 23805ffd83dbSDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 23815ffd83dbSDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 23825ffd83dbSDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__assign_external( 23835ffd83dbSDimitry Andric const value_type* __s, size_type __n) { 23840b57cec5SDimitry Andric size_type __cap = capacity(); 23855ffd83dbSDimitry Andric if (__cap >= __n) { 2386480093f4SDimitry Andric value_type* __p = _VSTD::__to_address(__get_pointer()); 23870b57cec5SDimitry Andric traits_type::move(__p, __s, __n); 2388*0eae32dcSDimitry Andric return __null_terminate_at(__p, __n); 23895ffd83dbSDimitry Andric } else { 23900b57cec5SDimitry Andric size_type __sz = size(); 23910b57cec5SDimitry Andric __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s); 23920b57cec5SDimitry Andric return *this; 23930b57cec5SDimitry Andric } 2394*0eae32dcSDimitry Andric} 23950b57cec5SDimitry Andric 23960b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 23970b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 23985ffd83dbSDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n) 23995ffd83dbSDimitry Andric{ 24005ffd83dbSDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr"); 2401349cc55cSDimitry Andric return (__builtin_constant_p(__n) && __n < __min_cap) 24025ffd83dbSDimitry Andric ? __assign_short(__s, __n) 24035ffd83dbSDimitry Andric : __assign_external(__s, __n); 24045ffd83dbSDimitry Andric} 24055ffd83dbSDimitry Andric 24065ffd83dbSDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 24075ffd83dbSDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 24080b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c) 24090b57cec5SDimitry Andric{ 24100b57cec5SDimitry Andric size_type __cap = capacity(); 24110b57cec5SDimitry Andric if (__cap < __n) 24120b57cec5SDimitry Andric { 24130b57cec5SDimitry Andric size_type __sz = size(); 24140b57cec5SDimitry Andric __grow_by(__cap, __n - __cap, __sz, 0, __sz); 24150b57cec5SDimitry Andric } 2416480093f4SDimitry Andric value_type* __p = _VSTD::__to_address(__get_pointer()); 24170b57cec5SDimitry Andric traits_type::assign(__p, __n, __c); 2418*0eae32dcSDimitry Andric return __null_terminate_at(__p, __n); 24190b57cec5SDimitry Andric} 24200b57cec5SDimitry Andric 24210b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 24220b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 24230b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c) 24240b57cec5SDimitry Andric{ 24250b57cec5SDimitry Andric pointer __p; 24260b57cec5SDimitry Andric if (__is_long()) 24270b57cec5SDimitry Andric { 24280b57cec5SDimitry Andric __p = __get_long_pointer(); 24290b57cec5SDimitry Andric __set_long_size(1); 24300b57cec5SDimitry Andric } 24310b57cec5SDimitry Andric else 24320b57cec5SDimitry Andric { 24330b57cec5SDimitry Andric __p = __get_short_pointer(); 24340b57cec5SDimitry Andric __set_short_size(1); 24350b57cec5SDimitry Andric } 24360b57cec5SDimitry Andric traits_type::assign(*__p, __c); 24370b57cec5SDimitry Andric traits_type::assign(*++__p, value_type()); 24380b57cec5SDimitry Andric __invalidate_iterators_past(1); 24390b57cec5SDimitry Andric return *this; 24400b57cec5SDimitry Andric} 24410b57cec5SDimitry Andric 24420b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 24430b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 24440b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str) 24450b57cec5SDimitry Andric{ 24465ffd83dbSDimitry Andric if (this != &__str) { 24470b57cec5SDimitry Andric __copy_assign_alloc(__str); 24485ffd83dbSDimitry Andric if (!__is_long()) { 24495ffd83dbSDimitry Andric if (!__str.__is_long()) { 24505ffd83dbSDimitry Andric __r_.first().__r = __str.__r_.first().__r; 24515ffd83dbSDimitry Andric } else { 24525ffd83dbSDimitry Andric return __assign_no_alias<true>(__str.data(), __str.size()); 24535ffd83dbSDimitry Andric } 24545ffd83dbSDimitry Andric } else { 24555ffd83dbSDimitry Andric return __assign_no_alias<false>(__str.data(), __str.size()); 24565ffd83dbSDimitry Andric } 24570b57cec5SDimitry Andric } 24580b57cec5SDimitry Andric return *this; 24590b57cec5SDimitry Andric} 24600b57cec5SDimitry Andric 24610b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 24620b57cec5SDimitry Andric 24630b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 24640b57cec5SDimitry Andricinline 24650b57cec5SDimitry Andricvoid 24660b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type) 24670b57cec5SDimitry Andric _NOEXCEPT_(__alloc_traits::is_always_equal::value) 24680b57cec5SDimitry Andric{ 24690b57cec5SDimitry Andric if (__alloc() != __str.__alloc()) 24700b57cec5SDimitry Andric assign(__str); 24710b57cec5SDimitry Andric else 24720b57cec5SDimitry Andric __move_assign(__str, true_type()); 24730b57cec5SDimitry Andric} 24740b57cec5SDimitry Andric 24750b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 24760b57cec5SDimitry Andricinline 24770b57cec5SDimitry Andricvoid 24780b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type) 24790b57cec5SDimitry Andric#if _LIBCPP_STD_VER > 14 24800b57cec5SDimitry Andric _NOEXCEPT 24810b57cec5SDimitry Andric#else 24820b57cec5SDimitry Andric _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) 24830b57cec5SDimitry Andric#endif 24840b57cec5SDimitry Andric{ 2485480093f4SDimitry Andric if (__is_long()) { 2486480093f4SDimitry Andric __alloc_traits::deallocate(__alloc(), __get_long_pointer(), 2487480093f4SDimitry Andric __get_long_cap()); 2488480093f4SDimitry Andric#if _LIBCPP_STD_VER <= 14 2489480093f4SDimitry Andric if (!is_nothrow_move_assignable<allocator_type>::value) { 2490480093f4SDimitry Andric __set_short_size(0); 2491480093f4SDimitry Andric traits_type::assign(__get_short_pointer()[0], value_type()); 2492480093f4SDimitry Andric } 2493480093f4SDimitry Andric#endif 2494480093f4SDimitry Andric } 24950b57cec5SDimitry Andric __move_assign_alloc(__str); 2496480093f4SDimitry Andric __r_.first() = __str.__r_.first(); 2497480093f4SDimitry Andric __str.__set_short_size(0); 2498480093f4SDimitry Andric traits_type::assign(__str.__get_short_pointer()[0], value_type()); 24990b57cec5SDimitry Andric} 25000b57cec5SDimitry Andric 25010b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 25020b57cec5SDimitry Andricinline 25030b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 25040b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str) 25050b57cec5SDimitry Andric _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) 25060b57cec5SDimitry Andric{ 25070b57cec5SDimitry Andric __move_assign(__str, integral_constant<bool, 25080b57cec5SDimitry Andric __alloc_traits::propagate_on_container_move_assignment::value>()); 25090b57cec5SDimitry Andric return *this; 25100b57cec5SDimitry Andric} 25110b57cec5SDimitry Andric 25120b57cec5SDimitry Andric#endif 25130b57cec5SDimitry Andric 25140b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 25150b57cec5SDimitry Andrictemplate<class _InputIterator> 2516349cc55cSDimitry Andric__enable_if_t 25170b57cec5SDimitry Andric< 2518fe6060f1SDimitry Andric __is_exactly_cpp17_input_iterator<_InputIterator>::value, 25190b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& 25205ffd83dbSDimitry Andric> 25210b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last) 25220b57cec5SDimitry Andric{ 25230b57cec5SDimitry Andric const basic_string __temp(__first, __last, __alloc()); 25240b57cec5SDimitry Andric assign(__temp.data(), __temp.size()); 25250b57cec5SDimitry Andric return *this; 25260b57cec5SDimitry Andric} 25270b57cec5SDimitry Andric 25280b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 25290b57cec5SDimitry Andrictemplate<class _ForwardIterator> 2530349cc55cSDimitry Andric__enable_if_t 25310b57cec5SDimitry Andric< 2532fe6060f1SDimitry Andric __is_cpp17_forward_iterator<_ForwardIterator>::value, 25330b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& 25345ffd83dbSDimitry Andric> 25350b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) 25360b57cec5SDimitry Andric{ 25370b57cec5SDimitry Andric size_type __cap = capacity(); 2538fe6060f1SDimitry Andric size_type __n = __string_is_trivial_iterator<_ForwardIterator>::value ? 2539fe6060f1SDimitry Andric static_cast<size_type>(_VSTD::distance(__first, __last)) : 0; 2540fe6060f1SDimitry Andric 2541fe6060f1SDimitry Andric if (__string_is_trivial_iterator<_ForwardIterator>::value && 2542fe6060f1SDimitry Andric (__cap >= __n || !__addr_in_range(*__first))) 2543fe6060f1SDimitry Andric { 25440b57cec5SDimitry Andric if (__cap < __n) 25450b57cec5SDimitry Andric { 25460b57cec5SDimitry Andric size_type __sz = size(); 25470b57cec5SDimitry Andric __grow_by(__cap, __n - __cap, __sz, 0, __sz); 25480b57cec5SDimitry Andric } 25490b57cec5SDimitry Andric pointer __p = __get_pointer(); 2550349cc55cSDimitry Andric for (; __first != __last; ++__p, (void) ++__first) 25510b57cec5SDimitry Andric traits_type::assign(*__p, *__first); 25520b57cec5SDimitry Andric traits_type::assign(*__p, value_type()); 25530b57cec5SDimitry Andric __set_size(__n); 2554fe6060f1SDimitry Andric __invalidate_iterators_past(__n); 2555fe6060f1SDimitry Andric } 2556fe6060f1SDimitry Andric else 2557fe6060f1SDimitry Andric { 2558fe6060f1SDimitry Andric const basic_string __temp(__first, __last, __alloc()); 2559fe6060f1SDimitry Andric assign(__temp.data(), __temp.size()); 2560fe6060f1SDimitry Andric } 25610b57cec5SDimitry Andric return *this; 25620b57cec5SDimitry Andric} 25630b57cec5SDimitry Andric 25640b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 25650b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 25660b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n) 25670b57cec5SDimitry Andric{ 25680b57cec5SDimitry Andric size_type __sz = __str.size(); 25690b57cec5SDimitry Andric if (__pos > __sz) 25700b57cec5SDimitry Andric this->__throw_out_of_range(); 25710b57cec5SDimitry Andric return assign(__str.data() + __pos, _VSTD::min(__n, __sz - __pos)); 25720b57cec5SDimitry Andric} 25730b57cec5SDimitry Andric 25740b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 25750b57cec5SDimitry Andrictemplate <class _Tp> 2576349cc55cSDimitry Andric__enable_if_t 25770b57cec5SDimitry Andric< 25785ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value 25795ffd83dbSDimitry Andric && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, 25800b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& 25815ffd83dbSDimitry Andric> 25820b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n) 25830b57cec5SDimitry Andric{ 25840b57cec5SDimitry Andric __self_view __sv = __t; 25850b57cec5SDimitry Andric size_type __sz = __sv.size(); 25860b57cec5SDimitry Andric if (__pos > __sz) 25870b57cec5SDimitry Andric this->__throw_out_of_range(); 25880b57cec5SDimitry Andric return assign(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos)); 25890b57cec5SDimitry Andric} 25900b57cec5SDimitry Andric 25910b57cec5SDimitry Andric 25920b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 25930b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 25945ffd83dbSDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __s) { 25955ffd83dbSDimitry Andric return __assign_external(__s, traits_type::length(__s)); 25965ffd83dbSDimitry Andric} 25975ffd83dbSDimitry Andric 25985ffd83dbSDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 25995ffd83dbSDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 26000b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s) 26010b57cec5SDimitry Andric{ 26020b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr"); 2603349cc55cSDimitry Andric return __builtin_constant_p(*__s) 26045ffd83dbSDimitry Andric ? (traits_type::length(__s) < __min_cap 26055ffd83dbSDimitry Andric ? __assign_short(__s, traits_type::length(__s)) 26065ffd83dbSDimitry Andric : __assign_external(__s, traits_type::length(__s))) 26075ffd83dbSDimitry Andric : __assign_external(__s); 26080b57cec5SDimitry Andric} 26090b57cec5SDimitry Andric// append 26100b57cec5SDimitry Andric 26110b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 26120b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 26130b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n) 26140b57cec5SDimitry Andric{ 26150b57cec5SDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr"); 26160b57cec5SDimitry Andric size_type __cap = capacity(); 26170b57cec5SDimitry Andric size_type __sz = size(); 26180b57cec5SDimitry Andric if (__cap - __sz >= __n) 26190b57cec5SDimitry Andric { 26200b57cec5SDimitry Andric if (__n) 26210b57cec5SDimitry Andric { 2622480093f4SDimitry Andric value_type* __p = _VSTD::__to_address(__get_pointer()); 26230b57cec5SDimitry Andric traits_type::copy(__p + __sz, __s, __n); 26240b57cec5SDimitry Andric __sz += __n; 26250b57cec5SDimitry Andric __set_size(__sz); 26260b57cec5SDimitry Andric traits_type::assign(__p[__sz], value_type()); 26270b57cec5SDimitry Andric } 26280b57cec5SDimitry Andric } 26290b57cec5SDimitry Andric else 26300b57cec5SDimitry Andric __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s); 26310b57cec5SDimitry Andric return *this; 26320b57cec5SDimitry Andric} 26330b57cec5SDimitry Andric 26340b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 26350b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 26360b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c) 26370b57cec5SDimitry Andric{ 26380b57cec5SDimitry Andric if (__n) 26390b57cec5SDimitry Andric { 26400b57cec5SDimitry Andric size_type __cap = capacity(); 26410b57cec5SDimitry Andric size_type __sz = size(); 26420b57cec5SDimitry Andric if (__cap - __sz < __n) 26430b57cec5SDimitry Andric __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); 26440b57cec5SDimitry Andric pointer __p = __get_pointer(); 2645480093f4SDimitry Andric traits_type::assign(_VSTD::__to_address(__p) + __sz, __n, __c); 26460b57cec5SDimitry Andric __sz += __n; 26470b57cec5SDimitry Andric __set_size(__sz); 26480b57cec5SDimitry Andric traits_type::assign(__p[__sz], value_type()); 26490b57cec5SDimitry Andric } 26500b57cec5SDimitry Andric return *this; 26510b57cec5SDimitry Andric} 26520b57cec5SDimitry Andric 26530b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 26540b57cec5SDimitry Andricinline void 26550b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n) 26560b57cec5SDimitry Andric{ 26570b57cec5SDimitry Andric if (__n) 26580b57cec5SDimitry Andric { 26590b57cec5SDimitry Andric size_type __cap = capacity(); 26600b57cec5SDimitry Andric size_type __sz = size(); 26610b57cec5SDimitry Andric if (__cap - __sz < __n) 26620b57cec5SDimitry Andric __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); 26630b57cec5SDimitry Andric pointer __p = __get_pointer(); 26640b57cec5SDimitry Andric __sz += __n; 26650b57cec5SDimitry Andric __set_size(__sz); 26660b57cec5SDimitry Andric traits_type::assign(__p[__sz], value_type()); 26670b57cec5SDimitry Andric } 26680b57cec5SDimitry Andric} 26690b57cec5SDimitry Andric 26700b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 26710b57cec5SDimitry Andricvoid 26720b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c) 26730b57cec5SDimitry Andric{ 26740b57cec5SDimitry Andric bool __is_short = !__is_long(); 26750b57cec5SDimitry Andric size_type __cap; 26760b57cec5SDimitry Andric size_type __sz; 26770b57cec5SDimitry Andric if (__is_short) 26780b57cec5SDimitry Andric { 26790b57cec5SDimitry Andric __cap = __min_cap - 1; 26800b57cec5SDimitry Andric __sz = __get_short_size(); 26810b57cec5SDimitry Andric } 26820b57cec5SDimitry Andric else 26830b57cec5SDimitry Andric { 26840b57cec5SDimitry Andric __cap = __get_long_cap() - 1; 26850b57cec5SDimitry Andric __sz = __get_long_size(); 26860b57cec5SDimitry Andric } 26870b57cec5SDimitry Andric if (__sz == __cap) 26880b57cec5SDimitry Andric { 26890b57cec5SDimitry Andric __grow_by(__cap, 1, __sz, __sz, 0); 2690349cc55cSDimitry Andric __is_short = false; // the string is always long after __grow_by 26910b57cec5SDimitry Andric } 26920b57cec5SDimitry Andric pointer __p; 26930b57cec5SDimitry Andric if (__is_short) 26940b57cec5SDimitry Andric { 26950b57cec5SDimitry Andric __p = __get_short_pointer() + __sz; 26960b57cec5SDimitry Andric __set_short_size(__sz+1); 26970b57cec5SDimitry Andric } 26980b57cec5SDimitry Andric else 26990b57cec5SDimitry Andric { 27000b57cec5SDimitry Andric __p = __get_long_pointer() + __sz; 27010b57cec5SDimitry Andric __set_long_size(__sz+1); 27020b57cec5SDimitry Andric } 27030b57cec5SDimitry Andric traits_type::assign(*__p, __c); 27040b57cec5SDimitry Andric traits_type::assign(*++__p, value_type()); 27050b57cec5SDimitry Andric} 27060b57cec5SDimitry Andric 27070b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 27080b57cec5SDimitry Andrictemplate<class _ForwardIterator> 2709349cc55cSDimitry Andric__enable_if_t 2710fe6060f1SDimitry Andric< 2711fe6060f1SDimitry Andric __is_cpp17_forward_iterator<_ForwardIterator>::value, 27120b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& 2713fe6060f1SDimitry Andric> 2714fe6060f1SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::append( 27150b57cec5SDimitry Andric _ForwardIterator __first, _ForwardIterator __last) 27160b57cec5SDimitry Andric{ 27170b57cec5SDimitry Andric size_type __sz = size(); 27180b57cec5SDimitry Andric size_type __cap = capacity(); 27190b57cec5SDimitry Andric size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); 27200b57cec5SDimitry Andric if (__n) 27210b57cec5SDimitry Andric { 2722fe6060f1SDimitry Andric if (__string_is_trivial_iterator<_ForwardIterator>::value && 2723fe6060f1SDimitry Andric !__addr_in_range(*__first)) 27240b57cec5SDimitry Andric { 27250b57cec5SDimitry Andric if (__cap - __sz < __n) 27260b57cec5SDimitry Andric __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); 27270b57cec5SDimitry Andric pointer __p = __get_pointer() + __sz; 2728349cc55cSDimitry Andric for (; __first != __last; ++__p, (void) ++__first) 27290b57cec5SDimitry Andric traits_type::assign(*__p, *__first); 27300b57cec5SDimitry Andric traits_type::assign(*__p, value_type()); 27310b57cec5SDimitry Andric __set_size(__sz + __n); 27320b57cec5SDimitry Andric } 2733fe6060f1SDimitry Andric else 2734fe6060f1SDimitry Andric { 2735fe6060f1SDimitry Andric const basic_string __temp(__first, __last, __alloc()); 2736fe6060f1SDimitry Andric append(__temp.data(), __temp.size()); 2737fe6060f1SDimitry Andric } 27380b57cec5SDimitry Andric } 27390b57cec5SDimitry Andric return *this; 27400b57cec5SDimitry Andric} 27410b57cec5SDimitry Andric 27420b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 27430b57cec5SDimitry Andricinline 27440b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 27450b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str) 27460b57cec5SDimitry Andric{ 27470b57cec5SDimitry Andric return append(__str.data(), __str.size()); 27480b57cec5SDimitry Andric} 27490b57cec5SDimitry Andric 27500b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 27510b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 27520b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n) 27530b57cec5SDimitry Andric{ 27540b57cec5SDimitry Andric size_type __sz = __str.size(); 27550b57cec5SDimitry Andric if (__pos > __sz) 27560b57cec5SDimitry Andric this->__throw_out_of_range(); 27570b57cec5SDimitry Andric return append(__str.data() + __pos, _VSTD::min(__n, __sz - __pos)); 27580b57cec5SDimitry Andric} 27590b57cec5SDimitry Andric 27600b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 27610b57cec5SDimitry Andrictemplate <class _Tp> 2762349cc55cSDimitry Andric __enable_if_t 27630b57cec5SDimitry Andric < 27645ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, 27650b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& 27665ffd83dbSDimitry Andric > 27670b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n) 27680b57cec5SDimitry Andric{ 27690b57cec5SDimitry Andric __self_view __sv = __t; 27700b57cec5SDimitry Andric size_type __sz = __sv.size(); 27710b57cec5SDimitry Andric if (__pos > __sz) 27720b57cec5SDimitry Andric this->__throw_out_of_range(); 27730b57cec5SDimitry Andric return append(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos)); 27740b57cec5SDimitry Andric} 27750b57cec5SDimitry Andric 27760b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 27770b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 27780b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s) 27790b57cec5SDimitry Andric{ 27800b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr"); 27810b57cec5SDimitry Andric return append(__s, traits_type::length(__s)); 27820b57cec5SDimitry Andric} 27830b57cec5SDimitry Andric 27840b57cec5SDimitry Andric// insert 27850b57cec5SDimitry Andric 27860b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 27870b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 27880b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n) 27890b57cec5SDimitry Andric{ 27900b57cec5SDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr"); 27910b57cec5SDimitry Andric size_type __sz = size(); 27920b57cec5SDimitry Andric if (__pos > __sz) 27930b57cec5SDimitry Andric this->__throw_out_of_range(); 27940b57cec5SDimitry Andric size_type __cap = capacity(); 27950b57cec5SDimitry Andric if (__cap - __sz >= __n) 27960b57cec5SDimitry Andric { 27970b57cec5SDimitry Andric if (__n) 27980b57cec5SDimitry Andric { 2799480093f4SDimitry Andric value_type* __p = _VSTD::__to_address(__get_pointer()); 28000b57cec5SDimitry Andric size_type __n_move = __sz - __pos; 28010b57cec5SDimitry Andric if (__n_move != 0) 28020b57cec5SDimitry Andric { 28030b57cec5SDimitry Andric if (__p + __pos <= __s && __s < __p + __sz) 28040b57cec5SDimitry Andric __s += __n; 28050b57cec5SDimitry Andric traits_type::move(__p + __pos + __n, __p + __pos, __n_move); 28060b57cec5SDimitry Andric } 28070b57cec5SDimitry Andric traits_type::move(__p + __pos, __s, __n); 28080b57cec5SDimitry Andric __sz += __n; 28090b57cec5SDimitry Andric __set_size(__sz); 28100b57cec5SDimitry Andric traits_type::assign(__p[__sz], value_type()); 28110b57cec5SDimitry Andric } 28120b57cec5SDimitry Andric } 28130b57cec5SDimitry Andric else 28140b57cec5SDimitry Andric __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s); 28150b57cec5SDimitry Andric return *this; 28160b57cec5SDimitry Andric} 28170b57cec5SDimitry Andric 28180b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 28190b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 28200b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c) 28210b57cec5SDimitry Andric{ 28220b57cec5SDimitry Andric size_type __sz = size(); 28230b57cec5SDimitry Andric if (__pos > __sz) 28240b57cec5SDimitry Andric this->__throw_out_of_range(); 28250b57cec5SDimitry Andric if (__n) 28260b57cec5SDimitry Andric { 28270b57cec5SDimitry Andric size_type __cap = capacity(); 28280b57cec5SDimitry Andric value_type* __p; 28290b57cec5SDimitry Andric if (__cap - __sz >= __n) 28300b57cec5SDimitry Andric { 2831480093f4SDimitry Andric __p = _VSTD::__to_address(__get_pointer()); 28320b57cec5SDimitry Andric size_type __n_move = __sz - __pos; 28330b57cec5SDimitry Andric if (__n_move != 0) 28340b57cec5SDimitry Andric traits_type::move(__p + __pos + __n, __p + __pos, __n_move); 28350b57cec5SDimitry Andric } 28360b57cec5SDimitry Andric else 28370b57cec5SDimitry Andric { 28380b57cec5SDimitry Andric __grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n); 2839480093f4SDimitry Andric __p = _VSTD::__to_address(__get_long_pointer()); 28400b57cec5SDimitry Andric } 28410b57cec5SDimitry Andric traits_type::assign(__p + __pos, __n, __c); 28420b57cec5SDimitry Andric __sz += __n; 28430b57cec5SDimitry Andric __set_size(__sz); 28440b57cec5SDimitry Andric traits_type::assign(__p[__sz], value_type()); 28450b57cec5SDimitry Andric } 28460b57cec5SDimitry Andric return *this; 28470b57cec5SDimitry Andric} 28480b57cec5SDimitry Andric 28490b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 28500b57cec5SDimitry Andrictemplate<class _InputIterator> 2851349cc55cSDimitry Andric__enable_if_t 28520b57cec5SDimitry Andric< 2853fe6060f1SDimitry Andric __is_exactly_cpp17_input_iterator<_InputIterator>::value, 28540b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::iterator 28555ffd83dbSDimitry Andric> 28560b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last) 28570b57cec5SDimitry Andric{ 2858*0eae32dcSDimitry Andric _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, 28590b57cec5SDimitry Andric "string::insert(iterator, range) called with an iterator not" 28600b57cec5SDimitry Andric " referring to this string"); 28610b57cec5SDimitry Andric const basic_string __temp(__first, __last, __alloc()); 28620b57cec5SDimitry Andric return insert(__pos, __temp.data(), __temp.data() + __temp.size()); 28630b57cec5SDimitry Andric} 28640b57cec5SDimitry Andric 28650b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 28660b57cec5SDimitry Andrictemplate<class _ForwardIterator> 2867349cc55cSDimitry Andric__enable_if_t 28680b57cec5SDimitry Andric< 2869fe6060f1SDimitry Andric __is_cpp17_forward_iterator<_ForwardIterator>::value, 28700b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::iterator 28715ffd83dbSDimitry Andric> 28720b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last) 28730b57cec5SDimitry Andric{ 2874*0eae32dcSDimitry Andric _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, 28750b57cec5SDimitry Andric "string::insert(iterator, range) called with an iterator not" 28760b57cec5SDimitry Andric " referring to this string"); 2877*0eae32dcSDimitry Andric 28780b57cec5SDimitry Andric size_type __ip = static_cast<size_type>(__pos - begin()); 28790b57cec5SDimitry Andric size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); 28800b57cec5SDimitry Andric if (__n) 28810b57cec5SDimitry Andric { 2882fe6060f1SDimitry Andric if (__string_is_trivial_iterator<_ForwardIterator>::value && 2883fe6060f1SDimitry Andric !__addr_in_range(*__first)) 28840b57cec5SDimitry Andric { 28850b57cec5SDimitry Andric size_type __sz = size(); 28860b57cec5SDimitry Andric size_type __cap = capacity(); 28870b57cec5SDimitry Andric value_type* __p; 28880b57cec5SDimitry Andric if (__cap - __sz >= __n) 28890b57cec5SDimitry Andric { 2890480093f4SDimitry Andric __p = _VSTD::__to_address(__get_pointer()); 28910b57cec5SDimitry Andric size_type __n_move = __sz - __ip; 28920b57cec5SDimitry Andric if (__n_move != 0) 28930b57cec5SDimitry Andric traits_type::move(__p + __ip + __n, __p + __ip, __n_move); 28940b57cec5SDimitry Andric } 28950b57cec5SDimitry Andric else 28960b57cec5SDimitry Andric { 28970b57cec5SDimitry Andric __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n); 2898480093f4SDimitry Andric __p = _VSTD::__to_address(__get_long_pointer()); 28990b57cec5SDimitry Andric } 29000b57cec5SDimitry Andric __sz += __n; 29010b57cec5SDimitry Andric __set_size(__sz); 29020b57cec5SDimitry Andric traits_type::assign(__p[__sz], value_type()); 2903349cc55cSDimitry Andric for (__p += __ip; __first != __last; ++__p, (void) ++__first) 29040b57cec5SDimitry Andric traits_type::assign(*__p, *__first); 29050b57cec5SDimitry Andric } 2906fe6060f1SDimitry Andric else 2907fe6060f1SDimitry Andric { 2908fe6060f1SDimitry Andric const basic_string __temp(__first, __last, __alloc()); 2909fe6060f1SDimitry Andric return insert(__pos, __temp.data(), __temp.data() + __temp.size()); 2910fe6060f1SDimitry Andric } 2911fe6060f1SDimitry Andric } 29120b57cec5SDimitry Andric return begin() + __ip; 29130b57cec5SDimitry Andric} 29140b57cec5SDimitry Andric 29150b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 29160b57cec5SDimitry Andricinline 29170b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 29180b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str) 29190b57cec5SDimitry Andric{ 29200b57cec5SDimitry Andric return insert(__pos1, __str.data(), __str.size()); 29210b57cec5SDimitry Andric} 29220b57cec5SDimitry Andric 29230b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 29240b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 29250b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str, 29260b57cec5SDimitry Andric size_type __pos2, size_type __n) 29270b57cec5SDimitry Andric{ 29280b57cec5SDimitry Andric size_type __str_sz = __str.size(); 29290b57cec5SDimitry Andric if (__pos2 > __str_sz) 29300b57cec5SDimitry Andric this->__throw_out_of_range(); 29310b57cec5SDimitry Andric return insert(__pos1, __str.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2)); 29320b57cec5SDimitry Andric} 29330b57cec5SDimitry Andric 29340b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 29350b57cec5SDimitry Andrictemplate <class _Tp> 2936349cc55cSDimitry Andric__enable_if_t 29370b57cec5SDimitry Andric< 29385ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, 29390b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& 29405ffd83dbSDimitry Andric> 29410b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t, 29420b57cec5SDimitry Andric size_type __pos2, size_type __n) 29430b57cec5SDimitry Andric{ 29440b57cec5SDimitry Andric __self_view __sv = __t; 29450b57cec5SDimitry Andric size_type __str_sz = __sv.size(); 29460b57cec5SDimitry Andric if (__pos2 > __str_sz) 29470b57cec5SDimitry Andric this->__throw_out_of_range(); 29480b57cec5SDimitry Andric return insert(__pos1, __sv.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2)); 29490b57cec5SDimitry Andric} 29500b57cec5SDimitry Andric 29510b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 29520b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 29530b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s) 29540b57cec5SDimitry Andric{ 29550b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr"); 29560b57cec5SDimitry Andric return insert(__pos, __s, traits_type::length(__s)); 29570b57cec5SDimitry Andric} 29580b57cec5SDimitry Andric 29590b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 29600b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::iterator 29610b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c) 29620b57cec5SDimitry Andric{ 29630b57cec5SDimitry Andric size_type __ip = static_cast<size_type>(__pos - begin()); 29640b57cec5SDimitry Andric size_type __sz = size(); 29650b57cec5SDimitry Andric size_type __cap = capacity(); 29660b57cec5SDimitry Andric value_type* __p; 29670b57cec5SDimitry Andric if (__cap == __sz) 29680b57cec5SDimitry Andric { 29690b57cec5SDimitry Andric __grow_by(__cap, 1, __sz, __ip, 0, 1); 2970480093f4SDimitry Andric __p = _VSTD::__to_address(__get_long_pointer()); 29710b57cec5SDimitry Andric } 29720b57cec5SDimitry Andric else 29730b57cec5SDimitry Andric { 2974480093f4SDimitry Andric __p = _VSTD::__to_address(__get_pointer()); 29750b57cec5SDimitry Andric size_type __n_move = __sz - __ip; 29760b57cec5SDimitry Andric if (__n_move != 0) 29770b57cec5SDimitry Andric traits_type::move(__p + __ip + 1, __p + __ip, __n_move); 29780b57cec5SDimitry Andric } 29790b57cec5SDimitry Andric traits_type::assign(__p[__ip], __c); 29800b57cec5SDimitry Andric traits_type::assign(__p[++__sz], value_type()); 29810b57cec5SDimitry Andric __set_size(__sz); 29820b57cec5SDimitry Andric return begin() + static_cast<difference_type>(__ip); 29830b57cec5SDimitry Andric} 29840b57cec5SDimitry Andric 29850b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 29860b57cec5SDimitry Andricinline 29870b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::iterator 29880b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c) 29890b57cec5SDimitry Andric{ 2990*0eae32dcSDimitry Andric _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, 29910b57cec5SDimitry Andric "string::insert(iterator, n, value) called with an iterator not" 29920b57cec5SDimitry Andric " referring to this string"); 29930b57cec5SDimitry Andric difference_type __p = __pos - begin(); 29940b57cec5SDimitry Andric insert(static_cast<size_type>(__p), __n, __c); 29950b57cec5SDimitry Andric return begin() + __p; 29960b57cec5SDimitry Andric} 29970b57cec5SDimitry Andric 29980b57cec5SDimitry Andric// replace 29990b57cec5SDimitry Andric 30000b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 30010b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 30020b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2) 30030b57cec5SDimitry Andric _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK 30040b57cec5SDimitry Andric{ 30050b57cec5SDimitry Andric _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr"); 30060b57cec5SDimitry Andric size_type __sz = size(); 30070b57cec5SDimitry Andric if (__pos > __sz) 30080b57cec5SDimitry Andric this->__throw_out_of_range(); 30090b57cec5SDimitry Andric __n1 = _VSTD::min(__n1, __sz - __pos); 30100b57cec5SDimitry Andric size_type __cap = capacity(); 30110b57cec5SDimitry Andric if (__cap - __sz + __n1 >= __n2) 30120b57cec5SDimitry Andric { 3013480093f4SDimitry Andric value_type* __p = _VSTD::__to_address(__get_pointer()); 30140b57cec5SDimitry Andric if (__n1 != __n2) 30150b57cec5SDimitry Andric { 30160b57cec5SDimitry Andric size_type __n_move = __sz - __pos - __n1; 30170b57cec5SDimitry Andric if (__n_move != 0) 30180b57cec5SDimitry Andric { 30190b57cec5SDimitry Andric if (__n1 > __n2) 30200b57cec5SDimitry Andric { 30210b57cec5SDimitry Andric traits_type::move(__p + __pos, __s, __n2); 30220b57cec5SDimitry Andric traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move); 3023*0eae32dcSDimitry Andric return __null_terminate_at(__p, __sz + (__n2 - __n1)); 30240b57cec5SDimitry Andric } 30250b57cec5SDimitry Andric if (__p + __pos < __s && __s < __p + __sz) 30260b57cec5SDimitry Andric { 30270b57cec5SDimitry Andric if (__p + __pos + __n1 <= __s) 30280b57cec5SDimitry Andric __s += __n2 - __n1; 30290b57cec5SDimitry Andric else // __p + __pos < __s < __p + __pos + __n1 30300b57cec5SDimitry Andric { 30310b57cec5SDimitry Andric traits_type::move(__p + __pos, __s, __n1); 30320b57cec5SDimitry Andric __pos += __n1; 30330b57cec5SDimitry Andric __s += __n2; 30340b57cec5SDimitry Andric __n2 -= __n1; 30350b57cec5SDimitry Andric __n1 = 0; 30360b57cec5SDimitry Andric } 30370b57cec5SDimitry Andric } 30380b57cec5SDimitry Andric traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move); 30390b57cec5SDimitry Andric } 30400b57cec5SDimitry Andric } 30410b57cec5SDimitry Andric traits_type::move(__p + __pos, __s, __n2); 3042*0eae32dcSDimitry Andric return __null_terminate_at(__p, __sz + (__n2 - __n1)); 30430b57cec5SDimitry Andric } 30440b57cec5SDimitry Andric else 30450b57cec5SDimitry Andric __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s); 30460b57cec5SDimitry Andric return *this; 30470b57cec5SDimitry Andric} 30480b57cec5SDimitry Andric 30490b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 30500b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 30510b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c) 30520b57cec5SDimitry Andric{ 30530b57cec5SDimitry Andric size_type __sz = size(); 30540b57cec5SDimitry Andric if (__pos > __sz) 30550b57cec5SDimitry Andric this->__throw_out_of_range(); 30560b57cec5SDimitry Andric __n1 = _VSTD::min(__n1, __sz - __pos); 30570b57cec5SDimitry Andric size_type __cap = capacity(); 30580b57cec5SDimitry Andric value_type* __p; 30590b57cec5SDimitry Andric if (__cap - __sz + __n1 >= __n2) 30600b57cec5SDimitry Andric { 3061480093f4SDimitry Andric __p = _VSTD::__to_address(__get_pointer()); 30620b57cec5SDimitry Andric if (__n1 != __n2) 30630b57cec5SDimitry Andric { 30640b57cec5SDimitry Andric size_type __n_move = __sz - __pos - __n1; 30650b57cec5SDimitry Andric if (__n_move != 0) 30660b57cec5SDimitry Andric traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move); 30670b57cec5SDimitry Andric } 30680b57cec5SDimitry Andric } 30690b57cec5SDimitry Andric else 30700b57cec5SDimitry Andric { 30710b57cec5SDimitry Andric __grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2); 3072480093f4SDimitry Andric __p = _VSTD::__to_address(__get_long_pointer()); 30730b57cec5SDimitry Andric } 30740b57cec5SDimitry Andric traits_type::assign(__p + __pos, __n2, __c); 3075*0eae32dcSDimitry Andric return __null_terminate_at(__p, __sz - (__n1 - __n2)); 30760b57cec5SDimitry Andric} 30770b57cec5SDimitry Andric 30780b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 30790b57cec5SDimitry Andrictemplate<class _InputIterator> 3080349cc55cSDimitry Andric__enable_if_t 30810b57cec5SDimitry Andric< 3082480093f4SDimitry Andric __is_cpp17_input_iterator<_InputIterator>::value, 30830b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& 30845ffd83dbSDimitry Andric> 30850b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, 30860b57cec5SDimitry Andric _InputIterator __j1, _InputIterator __j2) 30870b57cec5SDimitry Andric{ 30880b57cec5SDimitry Andric const basic_string __temp(__j1, __j2, __alloc()); 30890b57cec5SDimitry Andric return this->replace(__i1, __i2, __temp); 30900b57cec5SDimitry Andric} 30910b57cec5SDimitry Andric 30920b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 30930b57cec5SDimitry Andricinline 30940b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 30950b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str) 30960b57cec5SDimitry Andric{ 30970b57cec5SDimitry Andric return replace(__pos1, __n1, __str.data(), __str.size()); 30980b57cec5SDimitry Andric} 30990b57cec5SDimitry Andric 31000b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 31010b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 31020b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str, 31030b57cec5SDimitry Andric size_type __pos2, size_type __n2) 31040b57cec5SDimitry Andric{ 31050b57cec5SDimitry Andric size_type __str_sz = __str.size(); 31060b57cec5SDimitry Andric if (__pos2 > __str_sz) 31070b57cec5SDimitry Andric this->__throw_out_of_range(); 31080b57cec5SDimitry Andric return replace(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2)); 31090b57cec5SDimitry Andric} 31100b57cec5SDimitry Andric 31110b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 31120b57cec5SDimitry Andrictemplate <class _Tp> 3113349cc55cSDimitry Andric__enable_if_t 31140b57cec5SDimitry Andric< 31155ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, 31160b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& 31175ffd83dbSDimitry Andric> 31180b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t, 31190b57cec5SDimitry Andric size_type __pos2, size_type __n2) 31200b57cec5SDimitry Andric{ 31210b57cec5SDimitry Andric __self_view __sv = __t; 31220b57cec5SDimitry Andric size_type __str_sz = __sv.size(); 31230b57cec5SDimitry Andric if (__pos2 > __str_sz) 31240b57cec5SDimitry Andric this->__throw_out_of_range(); 31250b57cec5SDimitry Andric return replace(__pos1, __n1, __sv.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2)); 31260b57cec5SDimitry Andric} 31270b57cec5SDimitry Andric 31280b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 31290b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 31300b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s) 31310b57cec5SDimitry Andric{ 31320b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr"); 31330b57cec5SDimitry Andric return replace(__pos, __n1, __s, traits_type::length(__s)); 31340b57cec5SDimitry Andric} 31350b57cec5SDimitry Andric 31360b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 31370b57cec5SDimitry Andricinline 31380b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 31390b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str) 31400b57cec5SDimitry Andric{ 31410b57cec5SDimitry Andric return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), 31420b57cec5SDimitry Andric __str.data(), __str.size()); 31430b57cec5SDimitry Andric} 31440b57cec5SDimitry Andric 31450b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 31460b57cec5SDimitry Andricinline 31470b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 31480b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n) 31490b57cec5SDimitry Andric{ 31500b57cec5SDimitry Andric return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n); 31510b57cec5SDimitry Andric} 31520b57cec5SDimitry Andric 31530b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 31540b57cec5SDimitry Andricinline 31550b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 31560b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s) 31570b57cec5SDimitry Andric{ 31580b57cec5SDimitry Andric return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s); 31590b57cec5SDimitry Andric} 31600b57cec5SDimitry Andric 31610b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 31620b57cec5SDimitry Andricinline 31630b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 31640b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c) 31650b57cec5SDimitry Andric{ 31660b57cec5SDimitry Andric return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c); 31670b57cec5SDimitry Andric} 31680b57cec5SDimitry Andric 31690b57cec5SDimitry Andric// erase 31700b57cec5SDimitry Andric 31715ffd83dbSDimitry Andric// 'externally instantiated' erase() implementation, called when __n != npos. 31725ffd83dbSDimitry Andric// Does not check __pos against size() 31730b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 31745ffd83dbSDimitry Andricvoid 31755ffd83dbSDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move( 31765ffd83dbSDimitry Andric size_type __pos, size_type __n) 31770b57cec5SDimitry Andric{ 31780b57cec5SDimitry Andric if (__n) 31790b57cec5SDimitry Andric { 31805ffd83dbSDimitry Andric size_type __sz = size(); 3181480093f4SDimitry Andric value_type* __p = _VSTD::__to_address(__get_pointer()); 31820b57cec5SDimitry Andric __n = _VSTD::min(__n, __sz - __pos); 31830b57cec5SDimitry Andric size_type __n_move = __sz - __pos - __n; 31840b57cec5SDimitry Andric if (__n_move != 0) 31850b57cec5SDimitry Andric traits_type::move(__p + __pos, __p + __pos + __n, __n_move); 3186*0eae32dcSDimitry Andric __null_terminate_at(__p, __sz - __n); 31870b57cec5SDimitry Andric } 31885ffd83dbSDimitry Andric} 31895ffd83dbSDimitry Andric 31905ffd83dbSDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 31915ffd83dbSDimitry Andricbasic_string<_CharT, _Traits, _Allocator>& 31925ffd83dbSDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, 31935ffd83dbSDimitry Andric size_type __n) { 31945ffd83dbSDimitry Andric if (__pos > size()) this->__throw_out_of_range(); 31955ffd83dbSDimitry Andric if (__n == npos) { 31965ffd83dbSDimitry Andric __erase_to_end(__pos); 31975ffd83dbSDimitry Andric } else { 31985ffd83dbSDimitry Andric __erase_external_with_move(__pos, __n); 31995ffd83dbSDimitry Andric } 32000b57cec5SDimitry Andric return *this; 32010b57cec5SDimitry Andric} 32020b57cec5SDimitry Andric 32030b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 32040b57cec5SDimitry Andricinline 32050b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::iterator 32060b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos) 32070b57cec5SDimitry Andric{ 3208*0eae32dcSDimitry Andric _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this, 32090b57cec5SDimitry Andric "string::erase(iterator) called with an iterator not" 32100b57cec5SDimitry Andric " referring to this string"); 3211*0eae32dcSDimitry Andric 3212*0eae32dcSDimitry Andric _LIBCPP_ASSERT(__pos != end(), "string::erase(iterator) called with a non-dereferenceable iterator"); 32130b57cec5SDimitry Andric iterator __b = begin(); 32140b57cec5SDimitry Andric size_type __r = static_cast<size_type>(__pos - __b); 32150b57cec5SDimitry Andric erase(__r, 1); 32160b57cec5SDimitry Andric return __b + static_cast<difference_type>(__r); 32170b57cec5SDimitry Andric} 32180b57cec5SDimitry Andric 32190b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 32200b57cec5SDimitry Andricinline 32210b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::iterator 32220b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last) 32230b57cec5SDimitry Andric{ 3224*0eae32dcSDimitry Andric _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this, 32250b57cec5SDimitry Andric "string::erase(iterator, iterator) called with an iterator not" 32260b57cec5SDimitry Andric " referring to this string"); 3227*0eae32dcSDimitry Andric 32280b57cec5SDimitry Andric _LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range"); 32290b57cec5SDimitry Andric iterator __b = begin(); 32300b57cec5SDimitry Andric size_type __r = static_cast<size_type>(__first - __b); 32310b57cec5SDimitry Andric erase(__r, static_cast<size_type>(__last - __first)); 32320b57cec5SDimitry Andric return __b + static_cast<difference_type>(__r); 32330b57cec5SDimitry Andric} 32340b57cec5SDimitry Andric 32350b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 32360b57cec5SDimitry Andricinline 32370b57cec5SDimitry Andricvoid 32380b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::pop_back() 32390b57cec5SDimitry Andric{ 32400b57cec5SDimitry Andric _LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty"); 3241*0eae32dcSDimitry Andric __erase_to_end(size() - 1); 32420b57cec5SDimitry Andric} 32430b57cec5SDimitry Andric 32440b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 32450b57cec5SDimitry Andricinline 32460b57cec5SDimitry Andricvoid 32470b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT 32480b57cec5SDimitry Andric{ 32490b57cec5SDimitry Andric __invalidate_all_iterators(); 32500b57cec5SDimitry Andric if (__is_long()) 32510b57cec5SDimitry Andric { 32520b57cec5SDimitry Andric traits_type::assign(*__get_long_pointer(), value_type()); 32530b57cec5SDimitry Andric __set_long_size(0); 32540b57cec5SDimitry Andric } 32550b57cec5SDimitry Andric else 32560b57cec5SDimitry Andric { 32570b57cec5SDimitry Andric traits_type::assign(*__get_short_pointer(), value_type()); 32580b57cec5SDimitry Andric __set_short_size(0); 32590b57cec5SDimitry Andric } 32600b57cec5SDimitry Andric} 32610b57cec5SDimitry Andric 32620b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 32630b57cec5SDimitry Andricinline 32640b57cec5SDimitry Andricvoid 32650b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos) 32660b57cec5SDimitry Andric{ 3267*0eae32dcSDimitry Andric __null_terminate_at(_VSTD::__to_address(__get_pointer()), __pos); 32680b57cec5SDimitry Andric} 32690b57cec5SDimitry Andric 32700b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 32710b57cec5SDimitry Andricvoid 32720b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c) 32730b57cec5SDimitry Andric{ 32740b57cec5SDimitry Andric size_type __sz = size(); 32750b57cec5SDimitry Andric if (__n > __sz) 32760b57cec5SDimitry Andric append(__n - __sz, __c); 32770b57cec5SDimitry Andric else 32780b57cec5SDimitry Andric __erase_to_end(__n); 32790b57cec5SDimitry Andric} 32800b57cec5SDimitry Andric 32810b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 32820b57cec5SDimitry Andricinline void 32830b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n) 32840b57cec5SDimitry Andric{ 32850b57cec5SDimitry Andric size_type __sz = size(); 32860b57cec5SDimitry Andric if (__n > __sz) { 32870b57cec5SDimitry Andric __append_default_init(__n - __sz); 32880b57cec5SDimitry Andric } else 32890b57cec5SDimitry Andric __erase_to_end(__n); 32900b57cec5SDimitry Andric} 32910b57cec5SDimitry Andric 32920b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 32930b57cec5SDimitry Andricinline 32940b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 32950b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT 32960b57cec5SDimitry Andric{ 32970b57cec5SDimitry Andric size_type __m = __alloc_traits::max_size(__alloc()); 32980b57cec5SDimitry Andric#ifdef _LIBCPP_BIG_ENDIAN 32990b57cec5SDimitry Andric return (__m <= ~__long_mask ? __m : __m/2) - __alignment; 33000b57cec5SDimitry Andric#else 33010b57cec5SDimitry Andric return __m - __alignment; 33020b57cec5SDimitry Andric#endif 33030b57cec5SDimitry Andric} 33040b57cec5SDimitry Andric 33050b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 33060b57cec5SDimitry Andricvoid 3307e8d8bef9SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity) 33080b57cec5SDimitry Andric{ 3309e8d8bef9SDimitry Andric if (__requested_capacity > max_size()) 33100b57cec5SDimitry Andric this->__throw_length_error(); 3311e8d8bef9SDimitry Andric 3312e8d8bef9SDimitry Andric#if _LIBCPP_STD_VER > 17 3313e8d8bef9SDimitry Andric // Reserve never shrinks as of C++20. 3314e8d8bef9SDimitry Andric if (__requested_capacity <= capacity()) return; 3315e8d8bef9SDimitry Andric#endif 3316e8d8bef9SDimitry Andric 3317e8d8bef9SDimitry Andric size_type __target_capacity = _VSTD::max(__requested_capacity, size()); 3318e8d8bef9SDimitry Andric __target_capacity = __recommend(__target_capacity); 3319e8d8bef9SDimitry Andric if (__target_capacity == capacity()) return; 3320e8d8bef9SDimitry Andric 3321e8d8bef9SDimitry Andric __shrink_or_extend(__target_capacity); 3322e8d8bef9SDimitry Andric} 3323e8d8bef9SDimitry Andric 3324e8d8bef9SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 3325*0eae32dcSDimitry Andricinline 3326e8d8bef9SDimitry Andricvoid 3327e8d8bef9SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT 3328e8d8bef9SDimitry Andric{ 3329e8d8bef9SDimitry Andric size_type __target_capacity = __recommend(size()); 3330e8d8bef9SDimitry Andric if (__target_capacity == capacity()) return; 3331e8d8bef9SDimitry Andric 3332e8d8bef9SDimitry Andric __shrink_or_extend(__target_capacity); 3333e8d8bef9SDimitry Andric} 3334e8d8bef9SDimitry Andric 3335e8d8bef9SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 3336*0eae32dcSDimitry Andricinline 3337e8d8bef9SDimitry Andricvoid 3338e8d8bef9SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity) 3339e8d8bef9SDimitry Andric{ 33400b57cec5SDimitry Andric size_type __cap = capacity(); 33410b57cec5SDimitry Andric size_type __sz = size(); 3342e8d8bef9SDimitry Andric 33430b57cec5SDimitry Andric pointer __new_data, __p; 33440b57cec5SDimitry Andric bool __was_long, __now_long; 3345e8d8bef9SDimitry Andric if (__target_capacity == __min_cap - 1) 33460b57cec5SDimitry Andric { 33470b57cec5SDimitry Andric __was_long = true; 33480b57cec5SDimitry Andric __now_long = false; 33490b57cec5SDimitry Andric __new_data = __get_short_pointer(); 33500b57cec5SDimitry Andric __p = __get_long_pointer(); 33510b57cec5SDimitry Andric } 33520b57cec5SDimitry Andric else 33530b57cec5SDimitry Andric { 3354e8d8bef9SDimitry Andric if (__target_capacity > __cap) 3355e8d8bef9SDimitry Andric __new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1); 33560b57cec5SDimitry Andric else 33570b57cec5SDimitry Andric { 33580b57cec5SDimitry Andric #ifndef _LIBCPP_NO_EXCEPTIONS 33590b57cec5SDimitry Andric try 33600b57cec5SDimitry Andric { 33610b57cec5SDimitry Andric #endif // _LIBCPP_NO_EXCEPTIONS 3362e8d8bef9SDimitry Andric __new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1); 33630b57cec5SDimitry Andric #ifndef _LIBCPP_NO_EXCEPTIONS 33640b57cec5SDimitry Andric } 33650b57cec5SDimitry Andric catch (...) 33660b57cec5SDimitry Andric { 33670b57cec5SDimitry Andric return; 33680b57cec5SDimitry Andric } 33690b57cec5SDimitry Andric #else // _LIBCPP_NO_EXCEPTIONS 33700b57cec5SDimitry Andric if (__new_data == nullptr) 33710b57cec5SDimitry Andric return; 33720b57cec5SDimitry Andric #endif // _LIBCPP_NO_EXCEPTIONS 33730b57cec5SDimitry Andric } 33740b57cec5SDimitry Andric __now_long = true; 33750b57cec5SDimitry Andric __was_long = __is_long(); 33760b57cec5SDimitry Andric __p = __get_pointer(); 33770b57cec5SDimitry Andric } 3378480093f4SDimitry Andric traits_type::copy(_VSTD::__to_address(__new_data), 3379480093f4SDimitry Andric _VSTD::__to_address(__p), size()+1); 33800b57cec5SDimitry Andric if (__was_long) 33810b57cec5SDimitry Andric __alloc_traits::deallocate(__alloc(), __p, __cap+1); 33820b57cec5SDimitry Andric if (__now_long) 33830b57cec5SDimitry Andric { 3384e8d8bef9SDimitry Andric __set_long_cap(__target_capacity+1); 33850b57cec5SDimitry Andric __set_long_size(__sz); 33860b57cec5SDimitry Andric __set_long_pointer(__new_data); 33870b57cec5SDimitry Andric } 33880b57cec5SDimitry Andric else 33890b57cec5SDimitry Andric __set_short_size(__sz); 33900b57cec5SDimitry Andric __invalidate_all_iterators(); 33910b57cec5SDimitry Andric} 33920b57cec5SDimitry Andric 33930b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 33940b57cec5SDimitry Andricinline 33950b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::const_reference 33960b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const _NOEXCEPT 33970b57cec5SDimitry Andric{ 33980b57cec5SDimitry Andric _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds"); 33990b57cec5SDimitry Andric return *(data() + __pos); 34000b57cec5SDimitry Andric} 34010b57cec5SDimitry Andric 34020b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 34030b57cec5SDimitry Andricinline 34040b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::reference 34050b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) _NOEXCEPT 34060b57cec5SDimitry Andric{ 34070b57cec5SDimitry Andric _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds"); 34080b57cec5SDimitry Andric return *(__get_pointer() + __pos); 34090b57cec5SDimitry Andric} 34100b57cec5SDimitry Andric 34110b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 34120b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::const_reference 34130b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const 34140b57cec5SDimitry Andric{ 34150b57cec5SDimitry Andric if (__n >= size()) 34160b57cec5SDimitry Andric this->__throw_out_of_range(); 34170b57cec5SDimitry Andric return (*this)[__n]; 34180b57cec5SDimitry Andric} 34190b57cec5SDimitry Andric 34200b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 34210b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::reference 34220b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::at(size_type __n) 34230b57cec5SDimitry Andric{ 34240b57cec5SDimitry Andric if (__n >= size()) 34250b57cec5SDimitry Andric this->__throw_out_of_range(); 34260b57cec5SDimitry Andric return (*this)[__n]; 34270b57cec5SDimitry Andric} 34280b57cec5SDimitry Andric 34290b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 34300b57cec5SDimitry Andricinline 34310b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::reference 34320b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::front() _NOEXCEPT 34330b57cec5SDimitry Andric{ 34340b57cec5SDimitry Andric _LIBCPP_ASSERT(!empty(), "string::front(): string is empty"); 34350b57cec5SDimitry Andric return *__get_pointer(); 34360b57cec5SDimitry Andric} 34370b57cec5SDimitry Andric 34380b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 34390b57cec5SDimitry Andricinline 34400b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::const_reference 34410b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::front() const _NOEXCEPT 34420b57cec5SDimitry Andric{ 34430b57cec5SDimitry Andric _LIBCPP_ASSERT(!empty(), "string::front(): string is empty"); 34440b57cec5SDimitry Andric return *data(); 34450b57cec5SDimitry Andric} 34460b57cec5SDimitry Andric 34470b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 34480b57cec5SDimitry Andricinline 34490b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::reference 34500b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::back() _NOEXCEPT 34510b57cec5SDimitry Andric{ 34520b57cec5SDimitry Andric _LIBCPP_ASSERT(!empty(), "string::back(): string is empty"); 34530b57cec5SDimitry Andric return *(__get_pointer() + size() - 1); 34540b57cec5SDimitry Andric} 34550b57cec5SDimitry Andric 34560b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 34570b57cec5SDimitry Andricinline 34580b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::const_reference 34590b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::back() const _NOEXCEPT 34600b57cec5SDimitry Andric{ 34610b57cec5SDimitry Andric _LIBCPP_ASSERT(!empty(), "string::back(): string is empty"); 34620b57cec5SDimitry Andric return *(data() + size() - 1); 34630b57cec5SDimitry Andric} 34640b57cec5SDimitry Andric 34650b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 34660b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 34670b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const 34680b57cec5SDimitry Andric{ 34690b57cec5SDimitry Andric size_type __sz = size(); 34700b57cec5SDimitry Andric if (__pos > __sz) 34710b57cec5SDimitry Andric this->__throw_out_of_range(); 34720b57cec5SDimitry Andric size_type __rlen = _VSTD::min(__n, __sz - __pos); 34730b57cec5SDimitry Andric traits_type::copy(__s, data() + __pos, __rlen); 34740b57cec5SDimitry Andric return __rlen; 34750b57cec5SDimitry Andric} 34760b57cec5SDimitry Andric 34770b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 34780b57cec5SDimitry Andricinline 34790b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 34800b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const 34810b57cec5SDimitry Andric{ 34820b57cec5SDimitry Andric return basic_string(*this, __pos, __n, __alloc()); 34830b57cec5SDimitry Andric} 34840b57cec5SDimitry Andric 34850b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 34860b57cec5SDimitry Andricinline 34870b57cec5SDimitry Andricvoid 34880b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str) 34890b57cec5SDimitry Andric#if _LIBCPP_STD_VER >= 14 34900b57cec5SDimitry Andric _NOEXCEPT 34910b57cec5SDimitry Andric#else 34920b57cec5SDimitry Andric _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || 34930b57cec5SDimitry Andric __is_nothrow_swappable<allocator_type>::value) 34940b57cec5SDimitry Andric#endif 34950b57cec5SDimitry Andric{ 3496e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 3497*0eae32dcSDimitry Andric if (!__libcpp_is_constant_evaluated()) { 34980b57cec5SDimitry Andric if (!__is_long()) 34990b57cec5SDimitry Andric __get_db()->__invalidate_all(this); 35000b57cec5SDimitry Andric if (!__str.__is_long()) 35010b57cec5SDimitry Andric __get_db()->__invalidate_all(&__str); 35020b57cec5SDimitry Andric __get_db()->swap(this, &__str); 3503*0eae32dcSDimitry Andric } 35040b57cec5SDimitry Andric#endif 35050b57cec5SDimitry Andric _LIBCPP_ASSERT( 35060b57cec5SDimitry Andric __alloc_traits::propagate_on_container_swap::value || 35070b57cec5SDimitry Andric __alloc_traits::is_always_equal::value || 35080b57cec5SDimitry Andric __alloc() == __str.__alloc(), "swapping non-equal allocators"); 35090b57cec5SDimitry Andric _VSTD::swap(__r_.first(), __str.__r_.first()); 3510e8d8bef9SDimitry Andric _VSTD::__swap_allocator(__alloc(), __str.__alloc()); 35110b57cec5SDimitry Andric} 35120b57cec5SDimitry Andric 35130b57cec5SDimitry Andric// find 35140b57cec5SDimitry Andric 35150b57cec5SDimitry Andrictemplate <class _Traits> 35160b57cec5SDimitry Andricstruct _LIBCPP_HIDDEN __traits_eq 35170b57cec5SDimitry Andric{ 35180b57cec5SDimitry Andric typedef typename _Traits::char_type char_type; 35190b57cec5SDimitry Andric _LIBCPP_INLINE_VISIBILITY 35200b57cec5SDimitry Andric bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT 35210b57cec5SDimitry Andric {return _Traits::eq(__x, __y);} 35220b57cec5SDimitry Andric}; 35230b57cec5SDimitry Andric 35240b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 35250b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 35260b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s, 35270b57cec5SDimitry Andric size_type __pos, 35280b57cec5SDimitry Andric size_type __n) const _NOEXCEPT 35290b57cec5SDimitry Andric{ 35300b57cec5SDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr"); 35310b57cec5SDimitry Andric return __str_find<value_type, size_type, traits_type, npos> 35320b57cec5SDimitry Andric (data(), size(), __s, __pos, __n); 35330b57cec5SDimitry Andric} 35340b57cec5SDimitry Andric 35350b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 35360b57cec5SDimitry Andricinline 35370b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 35380b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str, 35390b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 35400b57cec5SDimitry Andric{ 35410b57cec5SDimitry Andric return __str_find<value_type, size_type, traits_type, npos> 35420b57cec5SDimitry Andric (data(), size(), __str.data(), __pos, __str.size()); 35430b57cec5SDimitry Andric} 35440b57cec5SDimitry Andric 35450b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 35460b57cec5SDimitry Andrictemplate <class _Tp> 3547349cc55cSDimitry Andric__enable_if_t 35480b57cec5SDimitry Andric< 35490b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 35500b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type 35515ffd83dbSDimitry Andric> 35520b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t, 3553fe6060f1SDimitry Andric size_type __pos) const _NOEXCEPT 35540b57cec5SDimitry Andric{ 35550b57cec5SDimitry Andric __self_view __sv = __t; 35560b57cec5SDimitry Andric return __str_find<value_type, size_type, traits_type, npos> 35570b57cec5SDimitry Andric (data(), size(), __sv.data(), __pos, __sv.size()); 35580b57cec5SDimitry Andric} 35590b57cec5SDimitry Andric 35600b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 35610b57cec5SDimitry Andricinline 35620b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 35630b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s, 35640b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 35650b57cec5SDimitry Andric{ 35660b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr"); 35670b57cec5SDimitry Andric return __str_find<value_type, size_type, traits_type, npos> 35680b57cec5SDimitry Andric (data(), size(), __s, __pos, traits_type::length(__s)); 35690b57cec5SDimitry Andric} 35700b57cec5SDimitry Andric 35710b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 35720b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 35730b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find(value_type __c, 35740b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 35750b57cec5SDimitry Andric{ 35760b57cec5SDimitry Andric return __str_find<value_type, size_type, traits_type, npos> 35770b57cec5SDimitry Andric (data(), size(), __c, __pos); 35780b57cec5SDimitry Andric} 35790b57cec5SDimitry Andric 35800b57cec5SDimitry Andric// rfind 35810b57cec5SDimitry Andric 35820b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 35830b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 35840b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s, 35850b57cec5SDimitry Andric size_type __pos, 35860b57cec5SDimitry Andric size_type __n) const _NOEXCEPT 35870b57cec5SDimitry Andric{ 35880b57cec5SDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr"); 35890b57cec5SDimitry Andric return __str_rfind<value_type, size_type, traits_type, npos> 35900b57cec5SDimitry Andric (data(), size(), __s, __pos, __n); 35910b57cec5SDimitry Andric} 35920b57cec5SDimitry Andric 35930b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 35940b57cec5SDimitry Andricinline 35950b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 35960b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str, 35970b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 35980b57cec5SDimitry Andric{ 35990b57cec5SDimitry Andric return __str_rfind<value_type, size_type, traits_type, npos> 36000b57cec5SDimitry Andric (data(), size(), __str.data(), __pos, __str.size()); 36010b57cec5SDimitry Andric} 36020b57cec5SDimitry Andric 36030b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 36040b57cec5SDimitry Andrictemplate <class _Tp> 3605349cc55cSDimitry Andric__enable_if_t 36060b57cec5SDimitry Andric< 36070b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 36080b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type 36095ffd83dbSDimitry Andric> 36100b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t, 3611fe6060f1SDimitry Andric size_type __pos) const _NOEXCEPT 36120b57cec5SDimitry Andric{ 36130b57cec5SDimitry Andric __self_view __sv = __t; 36140b57cec5SDimitry Andric return __str_rfind<value_type, size_type, traits_type, npos> 36150b57cec5SDimitry Andric (data(), size(), __sv.data(), __pos, __sv.size()); 36160b57cec5SDimitry Andric} 36170b57cec5SDimitry Andric 36180b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 36190b57cec5SDimitry Andricinline 36200b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 36210b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s, 36220b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 36230b57cec5SDimitry Andric{ 36240b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr"); 36250b57cec5SDimitry Andric return __str_rfind<value_type, size_type, traits_type, npos> 36260b57cec5SDimitry Andric (data(), size(), __s, __pos, traits_type::length(__s)); 36270b57cec5SDimitry Andric} 36280b57cec5SDimitry Andric 36290b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 36300b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 36310b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c, 36320b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 36330b57cec5SDimitry Andric{ 36340b57cec5SDimitry Andric return __str_rfind<value_type, size_type, traits_type, npos> 36350b57cec5SDimitry Andric (data(), size(), __c, __pos); 36360b57cec5SDimitry Andric} 36370b57cec5SDimitry Andric 36380b57cec5SDimitry Andric// find_first_of 36390b57cec5SDimitry Andric 36400b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 36410b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 36420b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s, 36430b57cec5SDimitry Andric size_type __pos, 36440b57cec5SDimitry Andric size_type __n) const _NOEXCEPT 36450b57cec5SDimitry Andric{ 36460b57cec5SDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr"); 36470b57cec5SDimitry Andric return __str_find_first_of<value_type, size_type, traits_type, npos> 36480b57cec5SDimitry Andric (data(), size(), __s, __pos, __n); 36490b57cec5SDimitry Andric} 36500b57cec5SDimitry Andric 36510b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 36520b57cec5SDimitry Andricinline 36530b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 36540b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str, 36550b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 36560b57cec5SDimitry Andric{ 36570b57cec5SDimitry Andric return __str_find_first_of<value_type, size_type, traits_type, npos> 36580b57cec5SDimitry Andric (data(), size(), __str.data(), __pos, __str.size()); 36590b57cec5SDimitry Andric} 36600b57cec5SDimitry Andric 36610b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 36620b57cec5SDimitry Andrictemplate <class _Tp> 3663349cc55cSDimitry Andric__enable_if_t 36640b57cec5SDimitry Andric< 36650b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 36660b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type 36675ffd83dbSDimitry Andric> 36680b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t, 3669fe6060f1SDimitry Andric size_type __pos) const _NOEXCEPT 36700b57cec5SDimitry Andric{ 36710b57cec5SDimitry Andric __self_view __sv = __t; 36720b57cec5SDimitry Andric return __str_find_first_of<value_type, size_type, traits_type, npos> 36730b57cec5SDimitry Andric (data(), size(), __sv.data(), __pos, __sv.size()); 36740b57cec5SDimitry Andric} 36750b57cec5SDimitry Andric 36760b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 36770b57cec5SDimitry Andricinline 36780b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 36790b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s, 36800b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 36810b57cec5SDimitry Andric{ 36820b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr"); 36830b57cec5SDimitry Andric return __str_find_first_of<value_type, size_type, traits_type, npos> 36840b57cec5SDimitry Andric (data(), size(), __s, __pos, traits_type::length(__s)); 36850b57cec5SDimitry Andric} 36860b57cec5SDimitry Andric 36870b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 36880b57cec5SDimitry Andricinline 36890b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 36900b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c, 36910b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 36920b57cec5SDimitry Andric{ 36930b57cec5SDimitry Andric return find(__c, __pos); 36940b57cec5SDimitry Andric} 36950b57cec5SDimitry Andric 36960b57cec5SDimitry Andric// find_last_of 36970b57cec5SDimitry Andric 36980b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 36990b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 37000b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s, 37010b57cec5SDimitry Andric size_type __pos, 37020b57cec5SDimitry Andric size_type __n) const _NOEXCEPT 37030b57cec5SDimitry Andric{ 37040b57cec5SDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr"); 37050b57cec5SDimitry Andric return __str_find_last_of<value_type, size_type, traits_type, npos> 37060b57cec5SDimitry Andric (data(), size(), __s, __pos, __n); 37070b57cec5SDimitry Andric} 37080b57cec5SDimitry Andric 37090b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 37100b57cec5SDimitry Andricinline 37110b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 37120b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str, 37130b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 37140b57cec5SDimitry Andric{ 37150b57cec5SDimitry Andric return __str_find_last_of<value_type, size_type, traits_type, npos> 37160b57cec5SDimitry Andric (data(), size(), __str.data(), __pos, __str.size()); 37170b57cec5SDimitry Andric} 37180b57cec5SDimitry Andric 37190b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 37200b57cec5SDimitry Andrictemplate <class _Tp> 3721349cc55cSDimitry Andric__enable_if_t 37220b57cec5SDimitry Andric< 37230b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 37240b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type 37255ffd83dbSDimitry Andric> 37260b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t, 3727fe6060f1SDimitry Andric size_type __pos) const _NOEXCEPT 37280b57cec5SDimitry Andric{ 37290b57cec5SDimitry Andric __self_view __sv = __t; 37300b57cec5SDimitry Andric return __str_find_last_of<value_type, size_type, traits_type, npos> 37310b57cec5SDimitry Andric (data(), size(), __sv.data(), __pos, __sv.size()); 37320b57cec5SDimitry Andric} 37330b57cec5SDimitry Andric 37340b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 37350b57cec5SDimitry Andricinline 37360b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 37370b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s, 37380b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 37390b57cec5SDimitry Andric{ 37400b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr"); 37410b57cec5SDimitry Andric return __str_find_last_of<value_type, size_type, traits_type, npos> 37420b57cec5SDimitry Andric (data(), size(), __s, __pos, traits_type::length(__s)); 37430b57cec5SDimitry Andric} 37440b57cec5SDimitry Andric 37450b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 37460b57cec5SDimitry Andricinline 37470b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 37480b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c, 37490b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 37500b57cec5SDimitry Andric{ 37510b57cec5SDimitry Andric return rfind(__c, __pos); 37520b57cec5SDimitry Andric} 37530b57cec5SDimitry Andric 37540b57cec5SDimitry Andric// find_first_not_of 37550b57cec5SDimitry Andric 37560b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 37570b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 37580b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s, 37590b57cec5SDimitry Andric size_type __pos, 37600b57cec5SDimitry Andric size_type __n) const _NOEXCEPT 37610b57cec5SDimitry Andric{ 37620b57cec5SDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr"); 37630b57cec5SDimitry Andric return __str_find_first_not_of<value_type, size_type, traits_type, npos> 37640b57cec5SDimitry Andric (data(), size(), __s, __pos, __n); 37650b57cec5SDimitry Andric} 37660b57cec5SDimitry Andric 37670b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 37680b57cec5SDimitry Andricinline 37690b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 37700b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str, 37710b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 37720b57cec5SDimitry Andric{ 37730b57cec5SDimitry Andric return __str_find_first_not_of<value_type, size_type, traits_type, npos> 37740b57cec5SDimitry Andric (data(), size(), __str.data(), __pos, __str.size()); 37750b57cec5SDimitry Andric} 37760b57cec5SDimitry Andric 37770b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 37780b57cec5SDimitry Andrictemplate <class _Tp> 3779349cc55cSDimitry Andric__enable_if_t 37800b57cec5SDimitry Andric< 37810b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 37820b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type 37835ffd83dbSDimitry Andric> 37840b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t, 3785fe6060f1SDimitry Andric size_type __pos) const _NOEXCEPT 37860b57cec5SDimitry Andric{ 37870b57cec5SDimitry Andric __self_view __sv = __t; 37880b57cec5SDimitry Andric return __str_find_first_not_of<value_type, size_type, traits_type, npos> 37890b57cec5SDimitry Andric (data(), size(), __sv.data(), __pos, __sv.size()); 37900b57cec5SDimitry Andric} 37910b57cec5SDimitry Andric 37920b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 37930b57cec5SDimitry Andricinline 37940b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 37950b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s, 37960b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 37970b57cec5SDimitry Andric{ 37980b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr"); 37990b57cec5SDimitry Andric return __str_find_first_not_of<value_type, size_type, traits_type, npos> 38000b57cec5SDimitry Andric (data(), size(), __s, __pos, traits_type::length(__s)); 38010b57cec5SDimitry Andric} 38020b57cec5SDimitry Andric 38030b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 38040b57cec5SDimitry Andricinline 38050b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 38060b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c, 38070b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 38080b57cec5SDimitry Andric{ 38090b57cec5SDimitry Andric return __str_find_first_not_of<value_type, size_type, traits_type, npos> 38100b57cec5SDimitry Andric (data(), size(), __c, __pos); 38110b57cec5SDimitry Andric} 38120b57cec5SDimitry Andric 38130b57cec5SDimitry Andric// find_last_not_of 38140b57cec5SDimitry Andric 38150b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 38160b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 38170b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s, 38180b57cec5SDimitry Andric size_type __pos, 38190b57cec5SDimitry Andric size_type __n) const _NOEXCEPT 38200b57cec5SDimitry Andric{ 38210b57cec5SDimitry Andric _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr"); 38220b57cec5SDimitry Andric return __str_find_last_not_of<value_type, size_type, traits_type, npos> 38230b57cec5SDimitry Andric (data(), size(), __s, __pos, __n); 38240b57cec5SDimitry Andric} 38250b57cec5SDimitry Andric 38260b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 38270b57cec5SDimitry Andricinline 38280b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 38290b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str, 38300b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 38310b57cec5SDimitry Andric{ 38320b57cec5SDimitry Andric return __str_find_last_not_of<value_type, size_type, traits_type, npos> 38330b57cec5SDimitry Andric (data(), size(), __str.data(), __pos, __str.size()); 38340b57cec5SDimitry Andric} 38350b57cec5SDimitry Andric 38360b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 38370b57cec5SDimitry Andrictemplate <class _Tp> 3838349cc55cSDimitry Andric__enable_if_t 38390b57cec5SDimitry Andric< 38400b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 38410b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type 38425ffd83dbSDimitry Andric> 38430b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t, 3844fe6060f1SDimitry Andric size_type __pos) const _NOEXCEPT 38450b57cec5SDimitry Andric{ 38460b57cec5SDimitry Andric __self_view __sv = __t; 38470b57cec5SDimitry Andric return __str_find_last_not_of<value_type, size_type, traits_type, npos> 38480b57cec5SDimitry Andric (data(), size(), __sv.data(), __pos, __sv.size()); 38490b57cec5SDimitry Andric} 38500b57cec5SDimitry Andric 38510b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 38520b57cec5SDimitry Andricinline 38530b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 38540b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s, 38550b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 38560b57cec5SDimitry Andric{ 38570b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr"); 38580b57cec5SDimitry Andric return __str_find_last_not_of<value_type, size_type, traits_type, npos> 38590b57cec5SDimitry Andric (data(), size(), __s, __pos, traits_type::length(__s)); 38600b57cec5SDimitry Andric} 38610b57cec5SDimitry Andric 38620b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 38630b57cec5SDimitry Andricinline 38640b57cec5SDimitry Andrictypename basic_string<_CharT, _Traits, _Allocator>::size_type 38650b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c, 38660b57cec5SDimitry Andric size_type __pos) const _NOEXCEPT 38670b57cec5SDimitry Andric{ 38680b57cec5SDimitry Andric return __str_find_last_not_of<value_type, size_type, traits_type, npos> 38690b57cec5SDimitry Andric (data(), size(), __c, __pos); 38700b57cec5SDimitry Andric} 38710b57cec5SDimitry Andric 38720b57cec5SDimitry Andric// compare 38730b57cec5SDimitry Andric 38740b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 38750b57cec5SDimitry Andrictemplate <class _Tp> 3876349cc55cSDimitry Andric__enable_if_t 38770b57cec5SDimitry Andric< 38780b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 38790b57cec5SDimitry Andric int 38805ffd83dbSDimitry Andric> 3881fe6060f1SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const _NOEXCEPT 38820b57cec5SDimitry Andric{ 38830b57cec5SDimitry Andric __self_view __sv = __t; 38840b57cec5SDimitry Andric size_t __lhs_sz = size(); 38850b57cec5SDimitry Andric size_t __rhs_sz = __sv.size(); 38860b57cec5SDimitry Andric int __result = traits_type::compare(data(), __sv.data(), 38870b57cec5SDimitry Andric _VSTD::min(__lhs_sz, __rhs_sz)); 38880b57cec5SDimitry Andric if (__result != 0) 38890b57cec5SDimitry Andric return __result; 38900b57cec5SDimitry Andric if (__lhs_sz < __rhs_sz) 38910b57cec5SDimitry Andric return -1; 38920b57cec5SDimitry Andric if (__lhs_sz > __rhs_sz) 38930b57cec5SDimitry Andric return 1; 38940b57cec5SDimitry Andric return 0; 38950b57cec5SDimitry Andric} 38960b57cec5SDimitry Andric 38970b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 38980b57cec5SDimitry Andricinline 38990b57cec5SDimitry Andricint 39000b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT 39010b57cec5SDimitry Andric{ 39020b57cec5SDimitry Andric return compare(__self_view(__str)); 39030b57cec5SDimitry Andric} 39040b57cec5SDimitry Andric 39050b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 39060b57cec5SDimitry Andricint 39070b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 39080b57cec5SDimitry Andric size_type __n1, 39090b57cec5SDimitry Andric const value_type* __s, 39100b57cec5SDimitry Andric size_type __n2) const 39110b57cec5SDimitry Andric{ 39120b57cec5SDimitry Andric _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr"); 39130b57cec5SDimitry Andric size_type __sz = size(); 39140b57cec5SDimitry Andric if (__pos1 > __sz || __n2 == npos) 39150b57cec5SDimitry Andric this->__throw_out_of_range(); 39160b57cec5SDimitry Andric size_type __rlen = _VSTD::min(__n1, __sz - __pos1); 39170b57cec5SDimitry Andric int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2)); 39180b57cec5SDimitry Andric if (__r == 0) 39190b57cec5SDimitry Andric { 39200b57cec5SDimitry Andric if (__rlen < __n2) 39210b57cec5SDimitry Andric __r = -1; 39220b57cec5SDimitry Andric else if (__rlen > __n2) 39230b57cec5SDimitry Andric __r = 1; 39240b57cec5SDimitry Andric } 39250b57cec5SDimitry Andric return __r; 39260b57cec5SDimitry Andric} 39270b57cec5SDimitry Andric 39280b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 39290b57cec5SDimitry Andrictemplate <class _Tp> 3930349cc55cSDimitry Andric__enable_if_t 39310b57cec5SDimitry Andric< 39320b57cec5SDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, 39330b57cec5SDimitry Andric int 39345ffd83dbSDimitry Andric> 39350b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 39360b57cec5SDimitry Andric size_type __n1, 39370b57cec5SDimitry Andric const _Tp& __t) const 39380b57cec5SDimitry Andric{ 39390b57cec5SDimitry Andric __self_view __sv = __t; 39400b57cec5SDimitry Andric return compare(__pos1, __n1, __sv.data(), __sv.size()); 39410b57cec5SDimitry Andric} 39420b57cec5SDimitry Andric 39430b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 39440b57cec5SDimitry Andricinline 39450b57cec5SDimitry Andricint 39460b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 39470b57cec5SDimitry Andric size_type __n1, 39480b57cec5SDimitry Andric const basic_string& __str) const 39490b57cec5SDimitry Andric{ 39500b57cec5SDimitry Andric return compare(__pos1, __n1, __str.data(), __str.size()); 39510b57cec5SDimitry Andric} 39520b57cec5SDimitry Andric 39530b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 39540b57cec5SDimitry Andrictemplate <class _Tp> 3955349cc55cSDimitry Andric__enable_if_t 39560b57cec5SDimitry Andric< 39575ffd83dbSDimitry Andric __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value 39585ffd83dbSDimitry Andric && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, 39590b57cec5SDimitry Andric int 39605ffd83dbSDimitry Andric> 39610b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 39620b57cec5SDimitry Andric size_type __n1, 39630b57cec5SDimitry Andric const _Tp& __t, 39640b57cec5SDimitry Andric size_type __pos2, 39650b57cec5SDimitry Andric size_type __n2) const 39660b57cec5SDimitry Andric{ 39670b57cec5SDimitry Andric __self_view __sv = __t; 39680b57cec5SDimitry Andric return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2)); 39690b57cec5SDimitry Andric} 39700b57cec5SDimitry Andric 39710b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 39720b57cec5SDimitry Andricint 39730b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 39740b57cec5SDimitry Andric size_type __n1, 39750b57cec5SDimitry Andric const basic_string& __str, 39760b57cec5SDimitry Andric size_type __pos2, 39770b57cec5SDimitry Andric size_type __n2) const 39780b57cec5SDimitry Andric{ 39790b57cec5SDimitry Andric return compare(__pos1, __n1, __self_view(__str), __pos2, __n2); 39800b57cec5SDimitry Andric} 39810b57cec5SDimitry Andric 39820b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 39830b57cec5SDimitry Andricint 39840b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT 39850b57cec5SDimitry Andric{ 39860b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr"); 39870b57cec5SDimitry Andric return compare(0, npos, __s, traits_type::length(__s)); 39880b57cec5SDimitry Andric} 39890b57cec5SDimitry Andric 39900b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator> 39910b57cec5SDimitry Andricint 39920b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, 39930b57cec5SDimitry Andric size_type __n1, 39940b57cec5SDimitry Andric const value_type* __s) const 39950b57cec5SDimitry Andric{ 39960b57cec5SDimitry Andric _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr"); 39970b57cec5SDimitry Andric return compare(__pos1, __n1, __s, traits_type::length(__s)); 39980b57cec5SDimitry Andric} 39990b57cec5SDimitry Andric 40000b57cec5SDimitry Andric// __invariants 40010b57cec5SDimitry Andric 40020b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 40030b57cec5SDimitry Andricinline 40040b57cec5SDimitry Andricbool 40050b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__invariants() const 40060b57cec5SDimitry Andric{ 40070b57cec5SDimitry Andric if (size() > capacity()) 40080b57cec5SDimitry Andric return false; 40090b57cec5SDimitry Andric if (capacity() < __min_cap - 1) 40100b57cec5SDimitry Andric return false; 4011e8d8bef9SDimitry Andric if (data() == nullptr) 40120b57cec5SDimitry Andric return false; 4013e8d8bef9SDimitry Andric if (data()[size()] != value_type()) 40140b57cec5SDimitry Andric return false; 40150b57cec5SDimitry Andric return true; 40160b57cec5SDimitry Andric} 40170b57cec5SDimitry Andric 40180b57cec5SDimitry Andric// __clear_and_shrink 40190b57cec5SDimitry Andric 40200b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 40210b57cec5SDimitry Andricinline 40220b57cec5SDimitry Andricvoid 40230b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT 40240b57cec5SDimitry Andric{ 40250b57cec5SDimitry Andric clear(); 40260b57cec5SDimitry Andric if(__is_long()) 40270b57cec5SDimitry Andric { 40280b57cec5SDimitry Andric __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1); 40290b57cec5SDimitry Andric __set_long_cap(0); 40300b57cec5SDimitry Andric __set_short_size(0); 4031e8d8bef9SDimitry Andric traits_type::assign(*__get_short_pointer(), value_type()); 40320b57cec5SDimitry Andric } 40330b57cec5SDimitry Andric} 40340b57cec5SDimitry Andric 40350b57cec5SDimitry Andric// operator== 40360b57cec5SDimitry Andric 40370b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 40380b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 40390b57cec5SDimitry Andricbool 40400b57cec5SDimitry Andricoperator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 40410b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 40420b57cec5SDimitry Andric{ 40430b57cec5SDimitry Andric size_t __lhs_sz = __lhs.size(); 40440b57cec5SDimitry Andric return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(), 40450b57cec5SDimitry Andric __rhs.data(), 40460b57cec5SDimitry Andric __lhs_sz) == 0; 40470b57cec5SDimitry Andric} 40480b57cec5SDimitry Andric 40490b57cec5SDimitry Andrictemplate<class _Allocator> 40500b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 40510b57cec5SDimitry Andricbool 40520b57cec5SDimitry Andricoperator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs, 40530b57cec5SDimitry Andric const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT 40540b57cec5SDimitry Andric{ 40550b57cec5SDimitry Andric size_t __lhs_sz = __lhs.size(); 40560b57cec5SDimitry Andric if (__lhs_sz != __rhs.size()) 40570b57cec5SDimitry Andric return false; 40580b57cec5SDimitry Andric const char* __lp = __lhs.data(); 40590b57cec5SDimitry Andric const char* __rp = __rhs.data(); 40600b57cec5SDimitry Andric if (__lhs.__is_long()) 40610b57cec5SDimitry Andric return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0; 40620b57cec5SDimitry Andric for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp) 40630b57cec5SDimitry Andric if (*__lp != *__rp) 40640b57cec5SDimitry Andric return false; 40650b57cec5SDimitry Andric return true; 40660b57cec5SDimitry Andric} 40670b57cec5SDimitry Andric 40680b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 40690b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 40700b57cec5SDimitry Andricbool 40710b57cec5SDimitry Andricoperator==(const _CharT* __lhs, 40720b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 40730b57cec5SDimitry Andric{ 40740b57cec5SDimitry Andric typedef basic_string<_CharT, _Traits, _Allocator> _String; 40750b57cec5SDimitry Andric _LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr"); 40760b57cec5SDimitry Andric size_t __lhs_len = _Traits::length(__lhs); 40770b57cec5SDimitry Andric if (__lhs_len != __rhs.size()) return false; 40780b57cec5SDimitry Andric return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0; 40790b57cec5SDimitry Andric} 40800b57cec5SDimitry Andric 40810b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 40820b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 40830b57cec5SDimitry Andricbool 40840b57cec5SDimitry Andricoperator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs, 40850b57cec5SDimitry Andric const _CharT* __rhs) _NOEXCEPT 40860b57cec5SDimitry Andric{ 40870b57cec5SDimitry Andric typedef basic_string<_CharT, _Traits, _Allocator> _String; 40880b57cec5SDimitry Andric _LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr"); 40890b57cec5SDimitry Andric size_t __rhs_len = _Traits::length(__rhs); 40900b57cec5SDimitry Andric if (__rhs_len != __lhs.size()) return false; 40910b57cec5SDimitry Andric return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0; 40920b57cec5SDimitry Andric} 40930b57cec5SDimitry Andric 40940b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 40950b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 40960b57cec5SDimitry Andricbool 40970b57cec5SDimitry Andricoperator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, 40980b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 40990b57cec5SDimitry Andric{ 41000b57cec5SDimitry Andric return !(__lhs == __rhs); 41010b57cec5SDimitry Andric} 41020b57cec5SDimitry Andric 41030b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 41040b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 41050b57cec5SDimitry Andricbool 41060b57cec5SDimitry Andricoperator!=(const _CharT* __lhs, 41070b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 41080b57cec5SDimitry Andric{ 41090b57cec5SDimitry Andric return !(__lhs == __rhs); 41100b57cec5SDimitry Andric} 41110b57cec5SDimitry Andric 41120b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 41130b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 41140b57cec5SDimitry Andricbool 41150b57cec5SDimitry Andricoperator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 41160b57cec5SDimitry Andric const _CharT* __rhs) _NOEXCEPT 41170b57cec5SDimitry Andric{ 41180b57cec5SDimitry Andric return !(__lhs == __rhs); 41190b57cec5SDimitry Andric} 41200b57cec5SDimitry Andric 41210b57cec5SDimitry Andric// operator< 41220b57cec5SDimitry Andric 41230b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 41240b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 41250b57cec5SDimitry Andricbool 41260b57cec5SDimitry Andricoperator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 41270b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 41280b57cec5SDimitry Andric{ 41290b57cec5SDimitry Andric return __lhs.compare(__rhs) < 0; 41300b57cec5SDimitry Andric} 41310b57cec5SDimitry Andric 41320b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 41330b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 41340b57cec5SDimitry Andricbool 41350b57cec5SDimitry Andricoperator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 41360b57cec5SDimitry Andric const _CharT* __rhs) _NOEXCEPT 41370b57cec5SDimitry Andric{ 41380b57cec5SDimitry Andric return __lhs.compare(__rhs) < 0; 41390b57cec5SDimitry Andric} 41400b57cec5SDimitry Andric 41410b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 41420b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 41430b57cec5SDimitry Andricbool 41440b57cec5SDimitry Andricoperator< (const _CharT* __lhs, 41450b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 41460b57cec5SDimitry Andric{ 41470b57cec5SDimitry Andric return __rhs.compare(__lhs) > 0; 41480b57cec5SDimitry Andric} 41490b57cec5SDimitry Andric 41500b57cec5SDimitry Andric// operator> 41510b57cec5SDimitry Andric 41520b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 41530b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 41540b57cec5SDimitry Andricbool 41550b57cec5SDimitry Andricoperator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 41560b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 41570b57cec5SDimitry Andric{ 41580b57cec5SDimitry Andric return __rhs < __lhs; 41590b57cec5SDimitry Andric} 41600b57cec5SDimitry Andric 41610b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 41620b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 41630b57cec5SDimitry Andricbool 41640b57cec5SDimitry Andricoperator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs, 41650b57cec5SDimitry Andric const _CharT* __rhs) _NOEXCEPT 41660b57cec5SDimitry Andric{ 41670b57cec5SDimitry Andric return __rhs < __lhs; 41680b57cec5SDimitry Andric} 41690b57cec5SDimitry Andric 41700b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 41710b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 41720b57cec5SDimitry Andricbool 41730b57cec5SDimitry Andricoperator> (const _CharT* __lhs, 41740b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 41750b57cec5SDimitry Andric{ 41760b57cec5SDimitry Andric return __rhs < __lhs; 41770b57cec5SDimitry Andric} 41780b57cec5SDimitry Andric 41790b57cec5SDimitry Andric// operator<= 41800b57cec5SDimitry Andric 41810b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 41820b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 41830b57cec5SDimitry Andricbool 41840b57cec5SDimitry Andricoperator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 41850b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 41860b57cec5SDimitry Andric{ 41870b57cec5SDimitry Andric return !(__rhs < __lhs); 41880b57cec5SDimitry Andric} 41890b57cec5SDimitry Andric 41900b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 41910b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 41920b57cec5SDimitry Andricbool 41930b57cec5SDimitry Andricoperator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 41940b57cec5SDimitry Andric const _CharT* __rhs) _NOEXCEPT 41950b57cec5SDimitry Andric{ 41960b57cec5SDimitry Andric return !(__rhs < __lhs); 41970b57cec5SDimitry Andric} 41980b57cec5SDimitry Andric 41990b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 42000b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 42010b57cec5SDimitry Andricbool 42020b57cec5SDimitry Andricoperator<=(const _CharT* __lhs, 42030b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 42040b57cec5SDimitry Andric{ 42050b57cec5SDimitry Andric return !(__rhs < __lhs); 42060b57cec5SDimitry Andric} 42070b57cec5SDimitry Andric 42080b57cec5SDimitry Andric// operator>= 42090b57cec5SDimitry Andric 42100b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 42110b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 42120b57cec5SDimitry Andricbool 42130b57cec5SDimitry Andricoperator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 42140b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 42150b57cec5SDimitry Andric{ 42160b57cec5SDimitry Andric return !(__lhs < __rhs); 42170b57cec5SDimitry Andric} 42180b57cec5SDimitry Andric 42190b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 42200b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 42210b57cec5SDimitry Andricbool 42220b57cec5SDimitry Andricoperator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 42230b57cec5SDimitry Andric const _CharT* __rhs) _NOEXCEPT 42240b57cec5SDimitry Andric{ 42250b57cec5SDimitry Andric return !(__lhs < __rhs); 42260b57cec5SDimitry Andric} 42270b57cec5SDimitry Andric 42280b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 42290b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 42300b57cec5SDimitry Andricbool 42310b57cec5SDimitry Andricoperator>=(const _CharT* __lhs, 42320b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT 42330b57cec5SDimitry Andric{ 42340b57cec5SDimitry Andric return !(__lhs < __rhs); 42350b57cec5SDimitry Andric} 42360b57cec5SDimitry Andric 42370b57cec5SDimitry Andric// operator + 42380b57cec5SDimitry Andric 42390b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 42400b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 42410b57cec5SDimitry Andricoperator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, 42420b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __rhs) 42430b57cec5SDimitry Andric{ 42440b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator()); 42450b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size(); 42460b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size(); 42470b57cec5SDimitry Andric __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz); 42480b57cec5SDimitry Andric __r.append(__rhs.data(), __rhs_sz); 42490b57cec5SDimitry Andric return __r; 42500b57cec5SDimitry Andric} 42510b57cec5SDimitry Andric 42520b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 42530b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 42540b57cec5SDimitry Andricoperator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs) 42550b57cec5SDimitry Andric{ 42560b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator()); 42570b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = _Traits::length(__lhs); 42580b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size(); 42590b57cec5SDimitry Andric __r.__init(__lhs, __lhs_sz, __lhs_sz + __rhs_sz); 42600b57cec5SDimitry Andric __r.append(__rhs.data(), __rhs_sz); 42610b57cec5SDimitry Andric return __r; 42620b57cec5SDimitry Andric} 42630b57cec5SDimitry Andric 42640b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 42650b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 42660b57cec5SDimitry Andricoperator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs) 42670b57cec5SDimitry Andric{ 42680b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator()); 42690b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size(); 42700b57cec5SDimitry Andric __r.__init(&__lhs, 1, 1 + __rhs_sz); 42710b57cec5SDimitry Andric __r.append(__rhs.data(), __rhs_sz); 42720b57cec5SDimitry Andric return __r; 42730b57cec5SDimitry Andric} 42740b57cec5SDimitry Andric 42750b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 42760b57cec5SDimitry Andricinline 42770b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 42780b57cec5SDimitry Andricoperator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) 42790b57cec5SDimitry Andric{ 42800b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator()); 42810b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size(); 42820b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = _Traits::length(__rhs); 42830b57cec5SDimitry Andric __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz); 42840b57cec5SDimitry Andric __r.append(__rhs, __rhs_sz); 42850b57cec5SDimitry Andric return __r; 42860b57cec5SDimitry Andric} 42870b57cec5SDimitry Andric 42880b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 42890b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 42900b57cec5SDimitry Andricoperator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs) 42910b57cec5SDimitry Andric{ 42920b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator()); 42930b57cec5SDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size(); 42940b57cec5SDimitry Andric __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + 1); 42950b57cec5SDimitry Andric __r.push_back(__rhs); 42960b57cec5SDimitry Andric return __r; 42970b57cec5SDimitry Andric} 42980b57cec5SDimitry Andric 42990b57cec5SDimitry Andric#ifndef _LIBCPP_CXX03_LANG 43000b57cec5SDimitry Andric 43010b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 43020b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 43030b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 43040b57cec5SDimitry Andricoperator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) 43050b57cec5SDimitry Andric{ 43060b57cec5SDimitry Andric return _VSTD::move(__lhs.append(__rhs)); 43070b57cec5SDimitry Andric} 43080b57cec5SDimitry Andric 43090b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 43100b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 43110b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 43120b57cec5SDimitry Andricoperator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) 43130b57cec5SDimitry Andric{ 43140b57cec5SDimitry Andric return _VSTD::move(__rhs.insert(0, __lhs)); 43150b57cec5SDimitry Andric} 43160b57cec5SDimitry Andric 43170b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 43180b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 43190b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 43200b57cec5SDimitry Andricoperator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) 43210b57cec5SDimitry Andric{ 43220b57cec5SDimitry Andric return _VSTD::move(__lhs.append(__rhs)); 43230b57cec5SDimitry Andric} 43240b57cec5SDimitry Andric 43250b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 43260b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 43270b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 43280b57cec5SDimitry Andricoperator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs) 43290b57cec5SDimitry Andric{ 43300b57cec5SDimitry Andric return _VSTD::move(__rhs.insert(0, __lhs)); 43310b57cec5SDimitry Andric} 43320b57cec5SDimitry Andric 43330b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 43340b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 43350b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 43360b57cec5SDimitry Andricoperator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs) 43370b57cec5SDimitry Andric{ 43380b57cec5SDimitry Andric __rhs.insert(__rhs.begin(), __lhs); 43390b57cec5SDimitry Andric return _VSTD::move(__rhs); 43400b57cec5SDimitry Andric} 43410b57cec5SDimitry Andric 43420b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 43430b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 43440b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 43450b57cec5SDimitry Andricoperator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs) 43460b57cec5SDimitry Andric{ 43470b57cec5SDimitry Andric return _VSTD::move(__lhs.append(__rhs)); 43480b57cec5SDimitry Andric} 43490b57cec5SDimitry Andric 43500b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 43510b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 43520b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator> 43530b57cec5SDimitry Andricoperator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs) 43540b57cec5SDimitry Andric{ 43550b57cec5SDimitry Andric __lhs.push_back(__rhs); 43560b57cec5SDimitry Andric return _VSTD::move(__lhs); 43570b57cec5SDimitry Andric} 43580b57cec5SDimitry Andric 43590b57cec5SDimitry Andric#endif // _LIBCPP_CXX03_LANG 43600b57cec5SDimitry Andric 43610b57cec5SDimitry Andric// swap 43620b57cec5SDimitry Andric 43630b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 43640b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 43650b57cec5SDimitry Andricvoid 43660b57cec5SDimitry Andricswap(basic_string<_CharT, _Traits, _Allocator>& __lhs, 43670b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& __rhs) 43680b57cec5SDimitry Andric _NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs))) 43690b57cec5SDimitry Andric{ 43700b57cec5SDimitry Andric __lhs.swap(__rhs); 43710b57cec5SDimitry Andric} 43720b57cec5SDimitry Andric 4373e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS int stoi (const string& __str, size_t* __idx = nullptr, int __base = 10); 4374e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS long stol (const string& __str, size_t* __idx = nullptr, int __base = 10); 4375e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS unsigned long stoul (const string& __str, size_t* __idx = nullptr, int __base = 10); 4376e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS long long stoll (const string& __str, size_t* __idx = nullptr, int __base = 10); 4377e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS unsigned long long stoull(const string& __str, size_t* __idx = nullptr, int __base = 10); 43780b57cec5SDimitry Andric 4379e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS float stof (const string& __str, size_t* __idx = nullptr); 4380e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS double stod (const string& __str, size_t* __idx = nullptr); 4381e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS long double stold(const string& __str, size_t* __idx = nullptr); 43820b57cec5SDimitry Andric 43830b57cec5SDimitry Andric_LIBCPP_FUNC_VIS string to_string(int __val); 43840b57cec5SDimitry Andric_LIBCPP_FUNC_VIS string to_string(unsigned __val); 43850b57cec5SDimitry Andric_LIBCPP_FUNC_VIS string to_string(long __val); 43860b57cec5SDimitry Andric_LIBCPP_FUNC_VIS string to_string(unsigned long __val); 43870b57cec5SDimitry Andric_LIBCPP_FUNC_VIS string to_string(long long __val); 43880b57cec5SDimitry Andric_LIBCPP_FUNC_VIS string to_string(unsigned long long __val); 43890b57cec5SDimitry Andric_LIBCPP_FUNC_VIS string to_string(float __val); 43900b57cec5SDimitry Andric_LIBCPP_FUNC_VIS string to_string(double __val); 43910b57cec5SDimitry Andric_LIBCPP_FUNC_VIS string to_string(long double __val); 43920b57cec5SDimitry Andric 4393349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 4394e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS int stoi (const wstring& __str, size_t* __idx = nullptr, int __base = 10); 4395e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS long stol (const wstring& __str, size_t* __idx = nullptr, int __base = 10); 4396e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS unsigned long stoul (const wstring& __str, size_t* __idx = nullptr, int __base = 10); 4397e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS long long stoll (const wstring& __str, size_t* __idx = nullptr, int __base = 10); 4398e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS unsigned long long stoull(const wstring& __str, size_t* __idx = nullptr, int __base = 10); 43990b57cec5SDimitry Andric 4400e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS float stof (const wstring& __str, size_t* __idx = nullptr); 4401e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS double stod (const wstring& __str, size_t* __idx = nullptr); 4402e8d8bef9SDimitry Andric_LIBCPP_FUNC_VIS long double stold(const wstring& __str, size_t* __idx = nullptr); 44030b57cec5SDimitry Andric 44040b57cec5SDimitry Andric_LIBCPP_FUNC_VIS wstring to_wstring(int __val); 44050b57cec5SDimitry Andric_LIBCPP_FUNC_VIS wstring to_wstring(unsigned __val); 44060b57cec5SDimitry Andric_LIBCPP_FUNC_VIS wstring to_wstring(long __val); 44070b57cec5SDimitry Andric_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long __val); 44080b57cec5SDimitry Andric_LIBCPP_FUNC_VIS wstring to_wstring(long long __val); 44090b57cec5SDimitry Andric_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long long __val); 44100b57cec5SDimitry Andric_LIBCPP_FUNC_VIS wstring to_wstring(float __val); 44110b57cec5SDimitry Andric_LIBCPP_FUNC_VIS wstring to_wstring(double __val); 44120b57cec5SDimitry Andric_LIBCPP_FUNC_VIS wstring to_wstring(long double __val); 4413349cc55cSDimitry Andric#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS 44140b57cec5SDimitry Andric 44150b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 4416fe6060f1SDimitry Andric_LIBCPP_TEMPLATE_DATA_VIS 44170b57cec5SDimitry Andricconst typename basic_string<_CharT, _Traits, _Allocator>::size_type 44180b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>::npos; 44190b57cec5SDimitry Andric 44200b57cec5SDimitry Andrictemplate <class _CharT, class _Allocator> 44210b57cec5SDimitry Andricstruct _LIBCPP_TEMPLATE_VIS 44220b57cec5SDimitry Andric hash<basic_string<_CharT, char_traits<_CharT>, _Allocator> > 44230b57cec5SDimitry Andric : public unary_function< 44240b57cec5SDimitry Andric basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t> 44250b57cec5SDimitry Andric{ 44260b57cec5SDimitry Andric size_t 44270b57cec5SDimitry Andric operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT 44280b57cec5SDimitry Andric { return __do_string_hash(__val.data(), __val.data() + __val.size()); } 44290b57cec5SDimitry Andric}; 44300b57cec5SDimitry Andric 44310b57cec5SDimitry Andric 44320b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 44330b57cec5SDimitry Andricbasic_ostream<_CharT, _Traits>& 44340b57cec5SDimitry Andricoperator<<(basic_ostream<_CharT, _Traits>& __os, 44350b57cec5SDimitry Andric const basic_string<_CharT, _Traits, _Allocator>& __str); 44360b57cec5SDimitry Andric 44370b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 44380b57cec5SDimitry Andricbasic_istream<_CharT, _Traits>& 44390b57cec5SDimitry Andricoperator>>(basic_istream<_CharT, _Traits>& __is, 44400b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& __str); 44410b57cec5SDimitry Andric 44420b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 44430b57cec5SDimitry Andricbasic_istream<_CharT, _Traits>& 44440b57cec5SDimitry Andricgetline(basic_istream<_CharT, _Traits>& __is, 44450b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm); 44460b57cec5SDimitry Andric 44470b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 44480b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 44490b57cec5SDimitry Andricbasic_istream<_CharT, _Traits>& 44500b57cec5SDimitry Andricgetline(basic_istream<_CharT, _Traits>& __is, 44510b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& __str); 44520b57cec5SDimitry Andric 44530b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 44540b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 44550b57cec5SDimitry Andricbasic_istream<_CharT, _Traits>& 44560b57cec5SDimitry Andricgetline(basic_istream<_CharT, _Traits>&& __is, 44570b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm); 44580b57cec5SDimitry Andric 44590b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 44600b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 44610b57cec5SDimitry Andricbasic_istream<_CharT, _Traits>& 44620b57cec5SDimitry Andricgetline(basic_istream<_CharT, _Traits>&& __is, 44630b57cec5SDimitry Andric basic_string<_CharT, _Traits, _Allocator>& __str); 44640b57cec5SDimitry Andric 44650b57cec5SDimitry Andric#if _LIBCPP_STD_VER > 17 44660b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator, class _Up> 44670b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 44685ffd83dbSDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type 44695ffd83dbSDimitry Andric erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) { 44705ffd83dbSDimitry Andric auto __old_size = __str.size(); 44715ffd83dbSDimitry Andric __str.erase(_VSTD::remove(__str.begin(), __str.end(), __v), __str.end()); 44725ffd83dbSDimitry Andric return __old_size - __str.size(); 44735ffd83dbSDimitry Andric} 44740b57cec5SDimitry Andric 44750b57cec5SDimitry Andrictemplate <class _CharT, class _Traits, class _Allocator, class _Predicate> 44760b57cec5SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY 44775ffd83dbSDimitry Andric typename basic_string<_CharT, _Traits, _Allocator>::size_type 44785ffd83dbSDimitry Andric erase_if(basic_string<_CharT, _Traits, _Allocator>& __str, 44795ffd83dbSDimitry Andric _Predicate __pred) { 44805ffd83dbSDimitry Andric auto __old_size = __str.size(); 44815ffd83dbSDimitry Andric __str.erase(_VSTD::remove_if(__str.begin(), __str.end(), __pred), 44825ffd83dbSDimitry Andric __str.end()); 44835ffd83dbSDimitry Andric return __old_size - __str.size(); 44845ffd83dbSDimitry Andric} 44850b57cec5SDimitry Andric#endif 44860b57cec5SDimitry Andric 4487e8d8bef9SDimitry Andric#if _LIBCPP_DEBUG_LEVEL == 2 44880b57cec5SDimitry Andric 44890b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 44900b57cec5SDimitry Andricbool 44910b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const 44920b57cec5SDimitry Andric{ 4493480093f4SDimitry Andric return this->data() <= _VSTD::__to_address(__i->base()) && 4494480093f4SDimitry Andric _VSTD::__to_address(__i->base()) < this->data() + this->size(); 44950b57cec5SDimitry Andric} 44960b57cec5SDimitry Andric 44970b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 44980b57cec5SDimitry Andricbool 44990b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const 45000b57cec5SDimitry Andric{ 4501480093f4SDimitry Andric return this->data() < _VSTD::__to_address(__i->base()) && 4502480093f4SDimitry Andric _VSTD::__to_address(__i->base()) <= this->data() + this->size(); 45030b57cec5SDimitry Andric} 45040b57cec5SDimitry Andric 45050b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 45060b57cec5SDimitry Andricbool 45070b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const 45080b57cec5SDimitry Andric{ 4509480093f4SDimitry Andric const value_type* __p = _VSTD::__to_address(__i->base()) + __n; 45100b57cec5SDimitry Andric return this->data() <= __p && __p <= this->data() + this->size(); 45110b57cec5SDimitry Andric} 45120b57cec5SDimitry Andric 45130b57cec5SDimitry Andrictemplate<class _CharT, class _Traits, class _Allocator> 45140b57cec5SDimitry Andricbool 45150b57cec5SDimitry Andricbasic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const 45160b57cec5SDimitry Andric{ 4517480093f4SDimitry Andric const value_type* __p = _VSTD::__to_address(__i->base()) + __n; 45180b57cec5SDimitry Andric return this->data() <= __p && __p < this->data() + this->size(); 45190b57cec5SDimitry Andric} 45200b57cec5SDimitry Andric 4521e8d8bef9SDimitry Andric#endif // _LIBCPP_DEBUG_LEVEL == 2 45220b57cec5SDimitry Andric 45230b57cec5SDimitry Andric#if _LIBCPP_STD_VER > 11 45240b57cec5SDimitry Andric// Literal suffixes for basic_string [basic.string.literals] 45250b57cec5SDimitry Andricinline namespace literals 45260b57cec5SDimitry Andric{ 45270b57cec5SDimitry Andric inline namespace string_literals 45280b57cec5SDimitry Andric { 45290b57cec5SDimitry Andric inline _LIBCPP_INLINE_VISIBILITY 45300b57cec5SDimitry Andric basic_string<char> operator "" s( const char *__str, size_t __len ) 45310b57cec5SDimitry Andric { 45320b57cec5SDimitry Andric return basic_string<char> (__str, __len); 45330b57cec5SDimitry Andric } 45340b57cec5SDimitry Andric 4535349cc55cSDimitry Andric#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 45360b57cec5SDimitry Andric inline _LIBCPP_INLINE_VISIBILITY 45370b57cec5SDimitry Andric basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len ) 45380b57cec5SDimitry Andric { 45390b57cec5SDimitry Andric return basic_string<wchar_t> (__str, __len); 45400b57cec5SDimitry Andric } 4541349cc55cSDimitry Andric#endif 45420b57cec5SDimitry Andric 4543fe6060f1SDimitry Andric#ifndef _LIBCPP_HAS_NO_CHAR8_T 45440b57cec5SDimitry Andric inline _LIBCPP_INLINE_VISIBILITY 45450b57cec5SDimitry Andric basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len) _NOEXCEPT 45460b57cec5SDimitry Andric { 45470b57cec5SDimitry Andric return basic_string<char8_t> (__str, __len); 45480b57cec5SDimitry Andric } 45490b57cec5SDimitry Andric#endif 45500b57cec5SDimitry Andric 45510b57cec5SDimitry Andric inline _LIBCPP_INLINE_VISIBILITY 45520b57cec5SDimitry Andric basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len ) 45530b57cec5SDimitry Andric { 45540b57cec5SDimitry Andric return basic_string<char16_t> (__str, __len); 45550b57cec5SDimitry Andric } 45560b57cec5SDimitry Andric 45570b57cec5SDimitry Andric inline _LIBCPP_INLINE_VISIBILITY 45580b57cec5SDimitry Andric basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len ) 45590b57cec5SDimitry Andric { 45600b57cec5SDimitry Andric return basic_string<char32_t> (__str, __len); 45610b57cec5SDimitry Andric } 4562*0eae32dcSDimitry Andric } // namespace string_literals 4563*0eae32dcSDimitry Andric} // namespace literals 45640b57cec5SDimitry Andric#endif 45650b57cec5SDimitry Andric 45660b57cec5SDimitry Andric_LIBCPP_END_NAMESPACE_STD 45670b57cec5SDimitry Andric 45680b57cec5SDimitry Andric_LIBCPP_POP_MACROS 45690b57cec5SDimitry Andric 45700b57cec5SDimitry Andric#endif // _LIBCPP_STRING 4571