← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to system/include/libcxx/string

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

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