00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00040 #ifndef _CPP_BITS_STRING_H
00041 #define _CPP_BITS_STRING_H 1
00042
00043 #pragma GCC system_header
00044
00045 #include <bits/atomicity.h>
00046
00047 namespace std
00048 {
00107
00108 template<typename _CharT, typename _Traits, typename _Alloc>
00109 class basic_string
00110 {
00111
00112 public:
00113 typedef _Traits traits_type;
00114 typedef typename _Traits::char_type value_type;
00115 typedef _Alloc allocator_type;
00116 typedef typename _Alloc::size_type size_type;
00117 typedef typename _Alloc::difference_type difference_type;
00118 typedef typename _Alloc::reference reference;
00119 typedef typename _Alloc::const_reference const_reference;
00120 typedef typename _Alloc::pointer pointer;
00121 typedef typename _Alloc::const_pointer const_pointer;
00122 typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
00123 typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
00124 const_iterator;
00125 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00126 typedef std::reverse_iterator<iterator> reverse_iterator;
00127
00128 private:
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143 struct _Rep
00144 {
00145
00146 typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161 static const size_type _S_max_size;
00162 static const _CharT _S_terminal;
00163
00164 size_type _M_length;
00165 size_type _M_capacity;
00166 _Atomic_word _M_references;
00167
00168 bool
00169 _M_is_leaked() const
00170 { return _M_references < 0; }
00171
00172 bool
00173 _M_is_shared() const
00174 { return _M_references > 0; }
00175
00176 void
00177 _M_set_leaked()
00178 { _M_references = -1; }
00179
00180 void
00181 _M_set_sharable()
00182 { _M_references = 0; }
00183
00184 _CharT*
00185 _M_refdata() throw()
00186 { return reinterpret_cast<_CharT*>(this + 1); }
00187
00188 _CharT&
00189 operator[](size_t __s) throw()
00190 { return _M_refdata() [__s]; }
00191
00192 _CharT*
00193 _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
00194 {
00195 return (!_M_is_leaked() && __alloc1 == __alloc2)
00196 ? _M_refcopy() : _M_clone(__alloc1);
00197 }
00198
00199
00200 static _Rep*
00201 _S_create(size_t, const _Alloc&);
00202
00203 void
00204 _M_dispose(const _Alloc& __a)
00205 {
00206 if (__exchange_and_add(&_M_references, -1) <= 0)
00207 _M_destroy(__a);
00208 }
00209
00210 void
00211 _M_destroy(const _Alloc&) throw();
00212
00213 _CharT*
00214 _M_refcopy() throw()
00215 {
00216 __atomic_add(&_M_references, 1);
00217 return _M_refdata();
00218 }
00219
00220 _CharT*
00221 _M_clone(const _Alloc&, size_type __res = 0);
00222 };
00223
00224
00225 struct _Alloc_hider : _Alloc
00226 {
00227 _Alloc_hider(_CharT* __dat, const _Alloc& __a)
00228 : _Alloc(__a), _M_p(__dat) { }
00229
00230 _CharT* _M_p;
00231 };
00232
00233 public:
00234
00235
00236
00237 static const size_type npos = static_cast<size_type>(-1);
00238
00239 private:
00240
00241 mutable _Alloc_hider _M_dataplus;
00242
00243
00244
00245 static size_type _S_empty_rep_storage[(sizeof(_Rep) + sizeof(_CharT) + sizeof(size_type) - 1)/sizeof(size_type)];
00246
00247 _CharT*
00248 _M_data() const
00249 { return _M_dataplus._M_p; }
00250
00251 _CharT*
00252 _M_data(_CharT* __p)
00253 { return (_M_dataplus._M_p = __p); }
00254
00255 _Rep*
00256 _M_rep() const
00257 { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
00258
00259
00260
00261 iterator
00262 _M_ibegin() const { return iterator(_M_data()); }
00263
00264 iterator
00265 _M_iend() const { return iterator(_M_data() + this->size()); }
00266
00267 void
00268 _M_leak()
00269 {
00270 if (!_M_rep()->_M_is_leaked())
00271 _M_leak_hard();
00272 }
00273
00274 iterator
00275 _M_check(size_type __pos) const
00276 {
00277 if (__pos > this->size())
00278 __throw_out_of_range("basic_string::_M_check");
00279 return _M_ibegin() + __pos;
00280 }
00281
00282
00283 iterator
00284 _M_fold(size_type __pos, size_type __off) const
00285 {
00286 bool __testoff = __off < this->size() - __pos;
00287 size_type __newoff = __testoff ? __off : this->size() - __pos;
00288 return (_M_ibegin() + __pos + __newoff);
00289 }
00290
00291
00292
00293 template<class _Iterator>
00294 static void
00295 _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
00296 {
00297 for (; __k1 != __k2; ++__k1, ++__p)
00298 traits_type::assign(*__p, *__k1);
00299 }
00300
00301 static void
00302 _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
00303 { _S_copy_chars(__p, __k1.base(), __k2.base()); }
00304
00305 static void
00306 _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
00307 { _S_copy_chars(__p, __k1.base(), __k2.base()); }
00308
00309 static void
00310 _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
00311 { traits_type::copy(__p, __k1, __k2 - __k1); }
00312
00313 static void
00314 _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
00315 { traits_type::copy(__p, __k1, __k2 - __k1); }
00316
00317 void
00318 _M_mutate(size_type __pos, size_type __len1, size_type __len2);
00319
00320 void
00321 _M_leak_hard();
00322
00323 static _Rep&
00324 _S_empty_rep()
00325 { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); }
00326
00327 public:
00328
00329
00330
00331
00332 inline
00333 basic_string();
00334
00335 explicit
00336 basic_string(const _Alloc& __a);
00337
00338
00339 basic_string(const basic_string& __str);
00340 basic_string(const basic_string& __str, size_type __pos,
00341 size_type __n = npos);
00342 basic_string(const basic_string& __str, size_type __pos,
00343 size_type __n, const _Alloc& __a);
00344
00345 basic_string(const _CharT* __s, size_type __n,
00346 const _Alloc& __a = _Alloc());
00347 basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
00348 basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
00349
00350 template<class _InputIterator>
00351 basic_string(_InputIterator __beg, _InputIterator __end,
00352 const _Alloc& __a = _Alloc());
00353
00354 ~basic_string()
00355 { _M_rep()->_M_dispose(this->get_allocator()); }
00356
00357 basic_string&
00358 operator=(const basic_string& __str) { return this->assign(__str); }
00359
00360 basic_string&
00361 operator=(const _CharT* __s) { return this->assign(__s); }
00362
00363 basic_string&
00364 operator=(_CharT __c) { return this->assign(1, __c); }
00365
00366
00367 iterator
00368 begin()
00369 {
00370 _M_leak();
00371 return iterator(_M_data());
00372 }
00373
00374 const_iterator
00375 begin() const
00376 { return const_iterator(_M_data()); }
00377
00378 iterator
00379 end()
00380 {
00381 _M_leak();
00382 return iterator(_M_data() + this->size());
00383 }
00384
00385 const_iterator
00386 end() const
00387 { return const_iterator(_M_data() + this->size()); }
00388
00389 reverse_iterator
00390 rbegin()
00391 { return reverse_iterator(this->end()); }
00392
00393 const_reverse_iterator
00394 rbegin() const
00395 { return const_reverse_iterator(this->end()); }
00396
00397 reverse_iterator
00398 rend()
00399 { return reverse_iterator(this->begin()); }
00400
00401 const_reverse_iterator
00402 rend() const
00403 { return const_reverse_iterator(this->begin()); }
00404
00405 public:
00406
00407 size_type
00408 size() const { return _M_rep()->_M_length; }
00409
00410 size_type
00411 length() const { return _M_rep()->_M_length; }
00412
00413 size_type
00414 max_size() const { return _Rep::_S_max_size; }
00415
00416 void
00417 resize(size_type __n, _CharT __c);
00418
00419 void
00420 resize(size_type __n) { this->resize(__n, _CharT()); }
00421
00422 size_type
00423 capacity() const { return _M_rep()->_M_capacity; }
00424
00425 void
00426 reserve(size_type __res_arg = 0);
00427
00428 void
00429 clear() { _M_mutate(0, this->size(), 0); }
00430
00431 bool
00432 empty() const { return this->size() == 0; }
00433
00434
00435 const_reference
00436 operator[] (size_type __pos) const
00437 { return _M_data()[__pos]; }
00438
00439 reference
00440 operator[](size_type __pos)
00441 {
00442 _M_leak();
00443 return _M_data()[__pos];
00444 }
00445
00446 const_reference
00447 at(size_type __n) const
00448 {
00449 if (__n >= this->size())
00450 __throw_out_of_range("basic_string::at");
00451 return _M_data()[__n];
00452 }
00453
00454 reference
00455 at(size_type __n)
00456 {
00457 if (__n >= size())
00458 __throw_out_of_range("basic_string::at");
00459 _M_leak();
00460 return _M_data()[__n];
00461 }
00462
00463
00464 basic_string&
00465 operator+=(const basic_string& __str) { return this->append(__str); }
00466
00467 basic_string&
00468 operator+=(const _CharT* __s) { return this->append(__s); }
00469
00470 basic_string&
00471 operator+=(_CharT __c) { return this->append(size_type(1), __c); }
00472
00473 basic_string&
00474 append(const basic_string& __str);
00475
00476 basic_string&
00477 append(const basic_string& __str, size_type __pos, size_type __n);
00478
00479 basic_string&
00480 append(const _CharT* __s, size_type __n);
00481
00482 basic_string&
00483 append(const _CharT* __s)
00484 { return this->append(__s, traits_type::length(__s)); }
00485
00486 basic_string&
00487 append(size_type __n, _CharT __c);
00488
00489 template<class _InputIterator>
00490 basic_string&
00491 append(_InputIterator __first, _InputIterator __last)
00492 { return this->replace(_M_iend(), _M_iend(), __first, __last); }
00493
00494 void
00495 push_back(_CharT __c)
00496 { this->replace(_M_iend(), _M_iend(), 1, __c); }
00497
00498 basic_string&
00499 assign(const basic_string& __str);
00500
00501 basic_string&
00502 assign(const basic_string& __str, size_type __pos, size_type __n);
00503
00504 basic_string&
00505 assign(const _CharT* __s, size_type __n);
00506
00507 basic_string&
00508 assign(const _CharT* __s)
00509 { return this->assign(__s, traits_type::length(__s)); }
00510
00511 basic_string&
00512 assign(size_type __n, _CharT __c)
00513 { return this->replace(_M_ibegin(), _M_iend(), __n, __c); }
00514
00515 template<class _InputIterator>
00516 basic_string&
00517 assign(_InputIterator __first, _InputIterator __last)
00518 { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
00519
00520 void
00521 insert(iterator __p, size_type __n, _CharT __c)
00522 { this->replace(__p, __p, __n, __c); }
00523
00524 template<class _InputIterator>
00525 void insert(iterator __p, _InputIterator __beg, _InputIterator __end)
00526 { this->replace(__p, __p, __beg, __end); }
00527
00528 basic_string&
00529 insert(size_type __pos1, const basic_string& __str)
00530 { return this->insert(__pos1, __str, 0, __str.size()); }
00531
00532 basic_string&
00533 insert(size_type __pos1, const basic_string& __str,
00534 size_type __pos2, size_type __n);
00535
00536 basic_string&
00537 insert(size_type __pos, const _CharT* __s, size_type __n);
00538
00539 basic_string&
00540 insert(size_type __pos, const _CharT* __s)
00541 { return this->insert(__pos, __s, traits_type::length(__s)); }
00542
00543 basic_string&
00544 insert(size_type __pos, size_type __n, _CharT __c)
00545 {
00546 this->insert(_M_check(__pos), __n, __c);
00547 return *this;
00548 }
00549
00550 iterator
00551 insert(iterator __p, _CharT __c = _CharT())
00552 {
00553 size_type __pos = __p - _M_ibegin();
00554 this->insert(_M_check(__pos), size_type(1), __c);
00555 _M_rep()->_M_set_leaked();
00556 return this->_M_ibegin() + __pos;
00557 }
00558
00559 basic_string&
00560 erase(size_type __pos = 0, size_type __n = npos)
00561 {
00562 return this->replace(_M_check(__pos), _M_fold(__pos, __n),
00563 _M_data(), _M_data());
00564 }
00565
00566 iterator
00567 erase(iterator __position)
00568 {
00569 size_type __i = __position - _M_ibegin();
00570 this->replace(__position, __position + 1, _M_data(), _M_data());
00571 _M_rep()->_M_set_leaked();
00572 return _M_ibegin() + __i;
00573 }
00574
00575 iterator
00576 erase(iterator __first, iterator __last)
00577 {
00578 size_type __i = __first - _M_ibegin();
00579 this->replace(__first, __last, _M_data(), _M_data());
00580 _M_rep()->_M_set_leaked();
00581 return _M_ibegin() + __i;
00582 }
00583
00584 basic_string&
00585 replace(size_type __pos, size_type __n, const basic_string& __str)
00586 { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
00587
00588 basic_string&
00589 replace(size_type __pos1, size_type __n1, const basic_string& __str,
00590 size_type __pos2, size_type __n2);
00591
00592 basic_string&
00593 replace(size_type __pos, size_type __n1, const _CharT* __s,
00594 size_type __n2);
00595
00596 basic_string&
00597 replace(size_type __pos, size_type __n1, const _CharT* __s)
00598 { return this->replace(__pos, __n1, __s, traits_type::length(__s)); }
00599
00600 basic_string&
00601 replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
00602 { return this->replace(_M_check(__pos), _M_fold(__pos, __n1), __n2, __c); }
00603
00604 basic_string&
00605 replace(iterator __i1, iterator __i2, const basic_string& __str)
00606 { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
00607
00608 basic_string&
00609 replace(iterator __i1, iterator __i2,
00610 const _CharT* __s, size_type __n)
00611 { return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n); }
00612
00613 basic_string&
00614 replace(iterator __i1, iterator __i2, const _CharT* __s)
00615 { return this->replace(__i1, __i2, __s, traits_type::length(__s)); }
00616
00617 basic_string&
00618 replace(iterator __i1, iterator __i2, size_type __n, _CharT __c);
00619
00620 template<class _InputIterator>
00621 basic_string&
00622 replace(iterator __i1, iterator __i2,
00623 _InputIterator __k1, _InputIterator __k2)
00624 { return _M_replace(__i1, __i2, __k1, __k2,
00625 typename iterator_traits<_InputIterator>::iterator_category()); }
00626
00627
00628
00629 basic_string&
00630 replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
00631 { return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
00632 __k1, __k2 - __k1); }
00633
00634 basic_string&
00635 replace(iterator __i1, iterator __i2, const _CharT* __k1, const _CharT* __k2)
00636 { return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
00637 __k1, __k2 - __k1); }
00638
00639 basic_string&
00640 replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
00641 { return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
00642 __k1.base(), __k2 - __k1);
00643 }
00644
00645 basic_string&
00646 replace(iterator __i1, iterator __i2, const_iterator __k1, const_iterator __k2)
00647 { return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
00648 __k1.base(), __k2 - __k1);
00649 }
00650
00651 private:
00652 template<class _InputIterator>
00653 basic_string&
00654 _M_replace(iterator __i1, iterator __i2, _InputIterator __k1,
00655 _InputIterator __k2, input_iterator_tag);
00656
00657 template<class _ForwardIterator>
00658 basic_string&
00659 _M_replace_safe(iterator __i1, iterator __i2, _ForwardIterator __k1,
00660 _ForwardIterator __k2);
00661
00662
00663
00664 template<class _InIter>
00665 static _CharT*
00666 _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a,
00667 __false_type)
00668 {
00669 typedef typename iterator_traits<_InIter>::iterator_category _Tag;
00670 return _S_construct(__beg, __end, __a, _Tag());
00671 }
00672
00673 template<class _InIter>
00674 static _CharT*
00675 _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a,
00676 __true_type)
00677 {
00678 return _S_construct(static_cast<size_type>(__beg),
00679 static_cast<value_type>(__end), __a);
00680 }
00681
00682 template<class _InIter>
00683 static _CharT*
00684 _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a)
00685 {
00686 typedef typename _Is_integer<_InIter>::_Integral _Integral;
00687 return _S_construct_aux(__beg, __end, __a, _Integral());
00688 }
00689
00690
00691 template<class _InIter>
00692 static _CharT*
00693 _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
00694 input_iterator_tag);
00695
00696
00697
00698 template<class _FwdIter>
00699 static _CharT*
00700 _S_construct(_FwdIter __beg, _FwdIter __end, const _Alloc& __a,
00701 forward_iterator_tag);
00702
00703 static _CharT*
00704 _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
00705
00706 public:
00707
00708 size_type
00709 copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
00710
00711 void
00712 swap(basic_string<_CharT, _Traits, _Alloc>& __s);
00713
00714
00715 const _CharT*
00716 c_str() const
00717 {
00718
00719 size_type __n = this->size();
00720 traits_type::assign(_M_data()[__n], _Rep::_S_terminal);
00721 return _M_data();
00722 }
00723
00724 const _CharT*
00725 data() const { return _M_data(); }
00726
00727 allocator_type
00728 get_allocator() const { return _M_dataplus; }
00729
00730 size_type
00731 find(const _CharT* __s, size_type __pos, size_type __n) const;
00732
00733 size_type
00734 find(const basic_string& __str, size_type __pos = 0) const
00735 { return this->find(__str.data(), __pos, __str.size()); }
00736
00737 size_type
00738 find(const _CharT* __s, size_type __pos = 0) const
00739 { return this->find(__s, __pos, traits_type::length(__s)); }
00740
00741 size_type
00742 find(_CharT __c, size_type __pos = 0) const;
00743
00744 size_type
00745 rfind(const basic_string& __str, size_type __pos = npos) const
00746 { return this->rfind(__str.data(), __pos, __str.size()); }
00747
00748 size_type
00749 rfind(const _CharT* __s, size_type __pos, size_type __n) const;
00750
00751 size_type
00752 rfind(const _CharT* __s, size_type __pos = npos) const
00753 { return this->rfind(__s, __pos, traits_type::length(__s)); }
00754
00755 size_type
00756 rfind(_CharT __c, size_type __pos = npos) const;
00757
00758 size_type
00759 find_first_of(const basic_string& __str, size_type __pos = 0) const
00760 { return this->find_first_of(__str.data(), __pos, __str.size()); }
00761
00762 size_type
00763 find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
00764
00765 size_type
00766 find_first_of(const _CharT* __s, size_type __pos = 0) const
00767 { return this->find_first_of(__s, __pos, traits_type::length(__s)); }
00768
00769 size_type
00770 find_first_of(_CharT __c, size_type __pos = 0) const
00771 { return this->find(__c, __pos); }
00772
00773 size_type
00774 find_last_of(const basic_string& __str, size_type __pos = npos) const
00775 { return this->find_last_of(__str.data(), __pos, __str.size()); }
00776
00777 size_type
00778 find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
00779
00780 size_type
00781 find_last_of(const _CharT* __s, size_type __pos = npos) const
00782 { return this->find_last_of(__s, __pos, traits_type::length(__s)); }
00783
00784 size_type
00785 find_last_of(_CharT __c, size_type __pos = npos) const
00786 { return this->rfind(__c, __pos); }
00787
00788 size_type
00789 find_first_not_of(const basic_string& __str, size_type __pos = 0) const
00790 { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
00791
00792 size_type
00793 find_first_not_of(const _CharT* __s, size_type __pos,
00794 size_type __n) const;
00795
00796 size_type
00797 find_first_not_of(const _CharT* __s, size_type __pos = 0) const
00798 { return this->find_first_not_of(__s, __pos, traits_type::length(__s)); }
00799
00800 size_type
00801 find_first_not_of(_CharT __c, size_type __pos = 0) const;
00802
00803 size_type
00804 find_last_not_of(const basic_string& __str, size_type __pos = npos) const
00805 { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
00806
00807 size_type
00808 find_last_not_of(const _CharT* __s, size_type __pos,
00809 size_type __n) const;
00810 size_type
00811 find_last_not_of(const _CharT* __s, size_type __pos = npos) const
00812 { return this->find_last_not_of(__s, __pos, traits_type::length(__s)); }
00813
00814 size_type
00815 find_last_not_of(_CharT __c, size_type __pos = npos) const;
00816
00817 basic_string
00818 substr(size_type __pos = 0, size_type __n = npos) const
00819 {
00820 if (__pos > this->size())
00821 __throw_out_of_range("basic_string::substr");
00822 return basic_string(*this, __pos, __n);
00823 }
00824
00825 int
00826 compare(const basic_string& __str) const
00827 {
00828 size_type __size = this->size();
00829 size_type __osize = __str.size();
00830 size_type __len = std::min(__size, __osize);
00831
00832 int __r = traits_type::compare(_M_data(), __str.data(), __len);
00833 if (!__r)
00834 __r = __size - __osize;
00835 return __r;
00836 }
00837
00838 int
00839 compare(size_type __pos, size_type __n, const basic_string& __str) const;
00840
00841 int
00842 compare(size_type __pos1, size_type __n1, const basic_string& __str,
00843 size_type __pos2, size_type __n2) const;
00844
00845 int
00846 compare(const _CharT* __s) const;
00847
00848
00849
00850 int
00851 compare(size_type __pos, size_type __n1, const _CharT* __s) const;
00852
00853 int
00854 compare(size_type __pos, size_type __n1, const _CharT* __s,
00855 size_type __n2) const;
00856 };
00857
00858
00859 template<typename _CharT, typename _Traits, typename _Alloc>
00860 inline basic_string<_CharT, _Traits, _Alloc>::
00861 basic_string()
00862 : _M_dataplus(_S_empty_rep()._M_refcopy(), _Alloc()) { }
00863
00864
00865 template<typename _CharT, typename _Traits, typename _Alloc>
00866 basic_string<_CharT, _Traits, _Alloc>
00867 operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00868 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00869 {
00870 basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
00871 __str.append(__rhs);
00872 return __str;
00873 }
00874
00875 template<typename _CharT, typename _Traits, typename _Alloc>
00876 basic_string<_CharT,_Traits,_Alloc>
00877 operator+(const _CharT* __lhs,
00878 const basic_string<_CharT,_Traits,_Alloc>& __rhs);
00879
00880 template<typename _CharT, typename _Traits, typename _Alloc>
00881 basic_string<_CharT,_Traits,_Alloc>
00882 operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
00883
00884 template<typename _CharT, typename _Traits, typename _Alloc>
00885 inline basic_string<_CharT, _Traits, _Alloc>
00886 operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00887 const _CharT* __rhs)
00888 {
00889 basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
00890 __str.append(__rhs);
00891 return __str;
00892 }
00893
00894 template<typename _CharT, typename _Traits, typename _Alloc>
00895 inline basic_string<_CharT, _Traits, _Alloc>
00896 operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
00897 {
00898 typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
00899 typedef typename __string_type::size_type __size_type;
00900 __string_type __str(__lhs);
00901 __str.append(__size_type(1), __rhs);
00902 return __str;
00903 }
00904
00905
00906 template<typename _CharT, typename _Traits, typename _Alloc>
00907 inline bool
00908 operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00909 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00910 { return __lhs.compare(__rhs) == 0; }
00911
00912 template<typename _CharT, typename _Traits, typename _Alloc>
00913 inline bool
00914 operator==(const _CharT* __lhs,
00915 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00916 { return __rhs.compare(__lhs) == 0; }
00917
00918 template<typename _CharT, typename _Traits, typename _Alloc>
00919 inline bool
00920 operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00921 const _CharT* __rhs)
00922 { return __lhs.compare(__rhs) == 0; }
00923
00924
00925 template<typename _CharT, typename _Traits, typename _Alloc>
00926 inline bool
00927 operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00928 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00929 { return __rhs.compare(__lhs) != 0; }
00930
00931 template<typename _CharT, typename _Traits, typename _Alloc>
00932 inline bool
00933 operator!=(const _CharT* __lhs,
00934 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00935 { return __rhs.compare(__lhs) != 0; }
00936
00937 template<typename _CharT, typename _Traits, typename _Alloc>
00938 inline bool
00939 operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00940 const _CharT* __rhs)
00941 { return __lhs.compare(__rhs) != 0; }
00942
00943
00944 template<typename _CharT, typename _Traits, typename _Alloc>
00945 inline bool
00946 operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00947 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00948 { return __lhs.compare(__rhs) < 0; }
00949
00950 template<typename _CharT, typename _Traits, typename _Alloc>
00951 inline bool
00952 operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00953 const _CharT* __rhs)
00954 { return __lhs.compare(__rhs) < 0; }
00955
00956 template<typename _CharT, typename _Traits, typename _Alloc>
00957 inline bool
00958 operator<(const _CharT* __lhs,
00959 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00960 { return __rhs.compare(__lhs) > 0; }
00961
00962
00963 template<typename _CharT, typename _Traits, typename _Alloc>
00964 inline bool
00965 operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00966 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00967 { return __lhs.compare(__rhs) > 0; }
00968
00969 template<typename _CharT, typename _Traits, typename _Alloc>
00970 inline bool
00971 operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00972 const _CharT* __rhs)
00973 { return __lhs.compare(__rhs) > 0; }
00974
00975 template<typename _CharT, typename _Traits, typename _Alloc>
00976 inline bool
00977 operator>(const _CharT* __lhs,
00978 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00979 { return __rhs.compare(__lhs) < 0; }
00980
00981
00982 template<typename _CharT, typename _Traits, typename _Alloc>
00983 inline bool
00984 operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00985 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00986 { return __lhs.compare(__rhs) <= 0; }
00987
00988 template<typename _CharT, typename _Traits, typename _Alloc>
00989 inline bool
00990 operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
00991 const _CharT* __rhs)
00992 { return __lhs.compare(__rhs) <= 0; }
00993
00994 template<typename _CharT, typename _Traits, typename _Alloc>
00995 inline bool
00996 operator<=(const _CharT* __lhs,
00997 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
00998 { return __rhs.compare(__lhs) >= 0; }
00999
01000
01001 template<typename _CharT, typename _Traits, typename _Alloc>
01002 inline bool
01003 operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
01004 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
01005 { return __lhs.compare(__rhs) >= 0; }
01006
01007 template<typename _CharT, typename _Traits, typename _Alloc>
01008 inline bool
01009 operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
01010 const _CharT* __rhs)
01011 { return __lhs.compare(__rhs) >= 0; }
01012
01013 template<typename _CharT, typename _Traits, typename _Alloc>
01014 inline bool
01015 operator>=(const _CharT* __lhs,
01016 const basic_string<_CharT, _Traits, _Alloc>& __rhs)
01017 { return __rhs.compare(__lhs) <= 0; }
01018
01019
01020 template<typename _CharT, typename _Traits, typename _Alloc>
01021 inline void
01022 swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
01023 basic_string<_CharT, _Traits, _Alloc>& __rhs)
01024 { __lhs.swap(__rhs); }
01025
01026 template<typename _CharT, typename _Traits, typename _Alloc>
01027 basic_istream<_CharT, _Traits>&
01028 operator>>(basic_istream<_CharT, _Traits>& __is,
01029 basic_string<_CharT, _Traits, _Alloc>& __str);
01030
01031 template<typename _CharT, typename _Traits, typename _Alloc>
01032 basic_ostream<_CharT, _Traits>&
01033 operator<<(basic_ostream<_CharT, _Traits>& __os,
01034 const basic_string<_CharT, _Traits, _Alloc>& __str);
01035
01036 template<typename _CharT, typename _Traits, typename _Alloc>
01037 basic_istream<_CharT,_Traits>&
01038 getline(basic_istream<_CharT, _Traits>& __is,
01039 basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
01040
01041 template<typename _CharT, typename _Traits, typename _Alloc>
01042 inline basic_istream<_CharT,_Traits>&
01043 getline(basic_istream<_CharT, _Traits>& __is,
01044 basic_string<_CharT, _Traits, _Alloc>& __str);
01045 }
01046
01047 #endif