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 #ifndef _GLIBCXX_DEBUG_STRING
00032 #define _GLIBCXX_DEBUG_STRING 1
00033
00034 #include <string>
00035 #include <debug/safe_sequence.h>
00036 #include <debug/safe_iterator.h>
00037
00038 namespace __gnu_debug
00039 {
00040 template<typename _CharT, typename _Traits, typename _Allocator>
00041 class basic_string
00042 : public std::basic_string<_CharT, _Traits, _Allocator>,
00043 public __gnu_debug::_Safe_sequence<basic_string<_CharT, _Traits,
00044 _Allocator> >
00045 {
00046 typedef std::basic_string<_CharT, _Traits, _Allocator> _Base;
00047 typedef __gnu_debug::_Safe_sequence<basic_string> _Safe_base;
00048
00049 public:
00050
00051 typedef _Traits traits_type;
00052 typedef typename _Traits::char_type value_type;
00053 typedef _Allocator allocator_type;
00054 typedef typename _Allocator::size_type size_type;
00055 typedef typename _Allocator::difference_type difference_type;
00056 typedef typename _Allocator::reference reference;
00057 typedef typename _Allocator::const_reference const_reference;
00058 typedef typename _Allocator::pointer pointer;
00059 typedef typename _Allocator::const_pointer const_pointer;
00060
00061 typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, basic_string>
00062 iterator;
00063 typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
00064 basic_string> const_iterator;
00065
00066 typedef std::reverse_iterator<iterator> reverse_iterator;
00067 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00068
00069 using _Base::npos;
00070
00071
00072 explicit basic_string(const _Allocator& __a = _Allocator())
00073 : _Base(__a)
00074 { }
00075
00076
00077 basic_string(const _Base& __base) : _Base(__base), _Safe_base() { }
00078
00079
00080
00081 basic_string(const basic_string& __str)
00082 : _Base(__str, 0, _Base::npos, __str.get_allocator()), _Safe_base()
00083 { }
00084
00085
00086
00087 basic_string(const basic_string& __str, size_type __pos,
00088 size_type __n = _Base::npos,
00089 const _Allocator& __a = _Allocator())
00090 : _Base(__str, __pos, __n, __a)
00091 { }
00092
00093 basic_string(const _CharT* __s, size_type __n,
00094 const _Allocator& __a = _Allocator())
00095 : _Base(__gnu_debug::__check_string(__s, __n), __n, __a)
00096 { }
00097
00098 basic_string(const _CharT* __s, const _Allocator& __a = _Allocator())
00099 : _Base(__gnu_debug::__check_string(__s), __a)
00100 { this->assign(__s); }
00101
00102 basic_string(size_type __n, _CharT __c,
00103 const _Allocator& __a = _Allocator())
00104 : _Base(__n, __c, __a)
00105 { }
00106
00107 template<typename _InputIterator>
00108 basic_string(_InputIterator __begin, _InputIterator __end,
00109 const _Allocator& __a = _Allocator())
00110 : _Base(__gnu_debug::__check_valid_range(__begin, __end), __end, __a)
00111 { }
00112
00113 ~basic_string() { }
00114
00115 basic_string&
00116 operator=(const basic_string& __str)
00117 {
00118 *static_cast<_Base*>(this) = __str;
00119 this->_M_invalidate_all();
00120 return *this;
00121 }
00122
00123 basic_string&
00124 operator=(const _CharT* __s)
00125 {
00126 __glibcxx_check_string(__s);
00127 *static_cast<_Base*>(this) = __s;
00128 this->_M_invalidate_all();
00129 return *this;
00130 }
00131
00132 basic_string&
00133 operator=(_CharT __c)
00134 {
00135 *static_cast<_Base*>(this) = __c;
00136 this->_M_invalidate_all();
00137 return *this;
00138 }
00139
00140
00141 iterator
00142 begin()
00143 { return iterator(_Base::begin(), this); }
00144
00145 const_iterator
00146 begin() const
00147 { return const_iterator(_Base::begin(), this); }
00148
00149 iterator
00150 end()
00151 { return iterator(_Base::end(), this); }
00152
00153 const_iterator
00154 end() const
00155 { return const_iterator(_Base::end(), this); }
00156
00157 reverse_iterator
00158 rbegin()
00159 { return reverse_iterator(end()); }
00160
00161 const_reverse_iterator
00162 rbegin() const
00163 { return const_reverse_iterator(end()); }
00164
00165 reverse_iterator
00166 rend()
00167 { return reverse_iterator(begin()); }
00168
00169 const_reverse_iterator
00170 rend() const
00171 { return const_reverse_iterator(begin()); }
00172
00173
00174 using _Base::size;
00175 using _Base::length;
00176 using _Base::max_size;
00177
00178 void
00179 resize(size_type __n, _CharT __c)
00180 {
00181 _Base::resize(__n, __c);
00182 this->_M_invalidate_all();
00183 }
00184
00185 void
00186 resize(size_type __n)
00187 { this->resize(__n, _CharT()); }
00188
00189 using _Base::capacity;
00190 using _Base::reserve;
00191
00192 void
00193 clear()
00194 {
00195 _Base::clear();
00196 this->_M_invalidate_all();
00197 }
00198
00199 using _Base::empty;
00200
00201
00202 const_reference
00203 operator[](size_type __pos) const
00204 {
00205 _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
00206 _M_message(::__gnu_debug::__msg_subscript_oob)
00207 ._M_sequence(*this, "this")
00208 ._M_integer(__pos, "__pos")
00209 ._M_integer(this->size(), "size"));
00210 return _M_base()[__pos];
00211 }
00212
00213 reference
00214 operator[](size_type __pos)
00215 {
00216 __glibcxx_check_subscript(__pos);
00217 return _M_base()[__pos];
00218 }
00219
00220 using _Base::at;
00221
00222
00223 basic_string&
00224 operator+=(const basic_string& __str)
00225 {
00226 _M_base() += __str;
00227 this->_M_invalidate_all();
00228 return *this;
00229 }
00230
00231 basic_string&
00232 operator+=(const _CharT* __s)
00233 {
00234 __glibcxx_check_string(__s);
00235 _M_base() += __s;
00236 this->_M_invalidate_all();
00237 return *this;
00238 }
00239
00240 basic_string&
00241 operator+=(_CharT __c)
00242 {
00243 _M_base() += __c;
00244 this->_M_invalidate_all();
00245 return *this;
00246 }
00247
00248 basic_string&
00249 append(const basic_string& __str)
00250 {
00251 _Base::append(__str);
00252 this->_M_invalidate_all();
00253 return *this;
00254 }
00255
00256 basic_string&
00257 append(const basic_string& __str, size_type __pos, size_type __n)
00258 {
00259 _Base::append(__str, __pos, __n);
00260 this->_M_invalidate_all();
00261 return *this;
00262 }
00263
00264 basic_string&
00265 append(const _CharT* __s, size_type __n)
00266 {
00267 __glibcxx_check_string_len(__s, __n);
00268 _Base::append(__s, __n);
00269 this->_M_invalidate_all();
00270 return *this;
00271 }
00272
00273 basic_string&
00274 append(const _CharT* __s)
00275 {
00276 __glibcxx_check_string(__s);
00277 _Base::append(__s);
00278 this->_M_invalidate_all();
00279 return *this;
00280 }
00281
00282 basic_string&
00283 append(size_type __n, _CharT __c)
00284 {
00285 _Base::append(__n, __c);
00286 this->_M_invalidate_all();
00287 return *this;
00288 }
00289
00290 template<typename _InputIterator>
00291 basic_string&
00292 append(_InputIterator __first, _InputIterator __last)
00293 {
00294 __glibcxx_check_valid_range(__first, __last);
00295 _Base::append(__first, __last);
00296 this->_M_invalidate_all();
00297 return *this;
00298 }
00299
00300
00301
00302 void
00303 push_back(_CharT __c)
00304 {
00305 _Base::push_back(__c);
00306 this->_M_invalidate_all();
00307 }
00308
00309 basic_string&
00310 assign(const basic_string& __x)
00311 {
00312 _Base::assign(__x);
00313 this->_M_invalidate_all();
00314 return *this;
00315 }
00316
00317 basic_string&
00318 assign(const basic_string& __str, size_type __pos, size_type __n)
00319 {
00320 _Base::assign(__str, __pos, __n);
00321 this->_M_invalidate_all();
00322 return *this;
00323 }
00324
00325 basic_string&
00326 assign(const _CharT* __s, size_type __n)
00327 {
00328 __glibcxx_check_string_len(__s, __n);
00329 _Base::assign(__s, __n);
00330 this->_M_invalidate_all();
00331 return *this;
00332 }
00333
00334 basic_string&
00335 assign(const _CharT* __s)
00336 {
00337 __glibcxx_check_string(__s);
00338 _Base::assign(__s);
00339 this->_M_invalidate_all();
00340 return *this;
00341 }
00342
00343 basic_string&
00344 assign(size_type __n, _CharT __c)
00345 {
00346 _Base::assign(__n, __c);
00347 this->_M_invalidate_all();
00348 return *this;
00349 }
00350
00351 template<typename _InputIterator>
00352 basic_string&
00353 assign(_InputIterator __first, _InputIterator __last)
00354 {
00355 __glibcxx_check_valid_range(__first, __last);
00356 _Base::assign(__first, __last);
00357 this->_M_invalidate_all();
00358 return *this;
00359 }
00360
00361 basic_string&
00362 insert(size_type __pos1, const basic_string& __str)
00363 {
00364 _Base::insert(__pos1, __str);
00365 this->_M_invalidate_all();
00366 return *this;
00367 }
00368
00369 basic_string&
00370 insert(size_type __pos1, const basic_string& __str,
00371 size_type __pos2, size_type __n)
00372 {
00373 _Base::insert(__pos1, __str, __pos2, __n);
00374 this->_M_invalidate_all();
00375 return *this;
00376 }
00377
00378 basic_string&
00379 insert(size_type __pos, const _CharT* __s, size_type __n)
00380 {
00381 __glibcxx_check_string(__s);
00382 _Base::insert(__pos, __s, __n);
00383 this->_M_invalidate_all();
00384 return *this;
00385 }
00386
00387 basic_string&
00388 insert(size_type __pos, const _CharT* __s)
00389 {
00390 __glibcxx_check_string(__s);
00391 _Base::insert(__pos, __s);
00392 this->_M_invalidate_all();
00393 return *this;
00394 }
00395
00396 basic_string&
00397 insert(size_type __pos, size_type __n, _CharT __c)
00398 {
00399 _Base::insert(__pos, __n, __c);
00400 this->_M_invalidate_all();
00401 return *this;
00402 }
00403
00404 iterator
00405 insert(iterator __p, _CharT __c)
00406 {
00407 __glibcxx_check_insert(__p);
00408 typename _Base::iterator __res = _Base::insert(__p.base(), __c);
00409 this->_M_invalidate_all();
00410 return iterator(__res, this);
00411 }
00412
00413 void
00414 insert(iterator __p, size_type __n, _CharT __c)
00415 {
00416 __glibcxx_check_insert(__p);
00417 _Base::insert(__p.base(), __n, __c);
00418 this->_M_invalidate_all();
00419 }
00420
00421 template<typename _InputIterator>
00422 void
00423 insert(iterator __p, _InputIterator __first, _InputIterator __last)
00424 {
00425 __glibcxx_check_insert_range(__p, __first, __last);
00426 _Base::insert(__p.base(), __first, __last);
00427 this->_M_invalidate_all();
00428 }
00429
00430 basic_string&
00431 erase(size_type __pos = 0, size_type __n = _Base::npos)
00432 {
00433 _Base::erase(__pos, __n);
00434 this->_M_invalidate_all();
00435 return *this;
00436 }
00437
00438 iterator
00439 erase(iterator __position)
00440 {
00441 __glibcxx_check_erase(__position);
00442 typename _Base::iterator __res = _Base::erase(__position.base());
00443 this->_M_invalidate_all();
00444 return iterator(__res, this);
00445 }
00446
00447 iterator
00448 erase(iterator __first, iterator __last)
00449 {
00450
00451
00452 __glibcxx_check_erase_range(__first, __last);
00453 typename _Base::iterator __res = _Base::erase(__first.base(),
00454 __last.base());
00455 this->_M_invalidate_all();
00456 return iterator(__res, this);
00457 }
00458
00459 basic_string&
00460 replace(size_type __pos1, size_type __n1, const basic_string& __str)
00461 {
00462 _Base::replace(__pos1, __n1, __str);
00463 this->_M_invalidate_all();
00464 return *this;
00465 }
00466
00467 basic_string&
00468 replace(size_type __pos1, size_type __n1, const basic_string& __str,
00469 size_type __pos2, size_type __n2)
00470 {
00471 _Base::replace(__pos1, __n1, __str, __pos2, __n2);
00472 this->_M_invalidate_all();
00473 return *this;
00474 }
00475
00476 basic_string&
00477 replace(size_type __pos, size_type __n1, const _CharT* __s,
00478 size_type __n2)
00479 {
00480 __glibcxx_check_string_len(__s, __n2);
00481 _Base::replace(__pos, __n1, __s, __n2);
00482 this->_M_invalidate_all();
00483 return *this;
00484 }
00485
00486 basic_string&
00487 replace(size_type __pos, size_type __n1, const _CharT* __s)
00488 {
00489 __glibcxx_check_string(__s);
00490 _Base::replace(__pos, __n1, __s);
00491 this->_M_invalidate_all();
00492 return *this;
00493 }
00494
00495 basic_string&
00496 replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
00497 {
00498 _Base::replace(__pos, __n1, __n2, __c);
00499 this->_M_invalidate_all();
00500 return *this;
00501 }
00502
00503 basic_string&
00504 replace(iterator __i1, iterator __i2, const basic_string& __str)
00505 {
00506 __glibcxx_check_erase_range(__i1, __i2);
00507 _Base::replace(__i1.base(), __i2.base(), __str);
00508 this->_M_invalidate_all();
00509 return *this;
00510 }
00511
00512 basic_string&
00513 replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
00514 {
00515 __glibcxx_check_erase_range(__i1, __i2);
00516 __glibcxx_check_string_len(__s, __n);
00517 _Base::replace(__i1.base(), __i2.base(), __s, __n);
00518 this->_M_invalidate_all();
00519 return *this;
00520 }
00521
00522 basic_string&
00523 replace(iterator __i1, iterator __i2, const _CharT* __s)
00524 {
00525 __glibcxx_check_erase_range(__i1, __i2);
00526 __glibcxx_check_string(__s);
00527 _Base::replace(__i1.base(), __i2.base(), __s);
00528 this->_M_invalidate_all();
00529 return *this;
00530 }
00531
00532 basic_string&
00533 replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
00534 {
00535 __glibcxx_check_erase_range(__i1, __i2);
00536 _Base::replace(__i1.base(), __i2.base(), __n, __c);
00537 this->_M_invalidate_all();
00538 return *this;
00539 }
00540
00541 template<typename _InputIterator>
00542 basic_string&
00543 replace(iterator __i1, iterator __i2,
00544 _InputIterator __j1, _InputIterator __j2)
00545 {
00546 __glibcxx_check_erase_range(__i1, __i2);
00547 __glibcxx_check_valid_range(__j1, __j2);
00548 _Base::replace(__i1.base(), __i2.base(), __j1, __j2);
00549 this->_M_invalidate_all();
00550 return *this;
00551 }
00552
00553 size_type
00554 copy(_CharT* __s, size_type __n, size_type __pos = 0) const
00555 {
00556 __glibcxx_check_string_len(__s, __n);
00557 return _Base::copy(__s, __n, __pos);
00558 }
00559
00560 void
00561 swap(basic_string<_CharT,_Traits,_Allocator>& __x)
00562 {
00563 _Base::swap(__x);
00564 this->_M_swap(__x);
00565 this->_M_invalidate_all();
00566 __x._M_invalidate_all();
00567 }
00568
00569
00570 const _CharT*
00571 c_str() const
00572 {
00573 const _CharT* __res = _Base::c_str();
00574 this->_M_invalidate_all();
00575 return __res;
00576 }
00577
00578 const _CharT*
00579 data() const
00580 {
00581 const _CharT* __res = _Base::data();
00582 this->_M_invalidate_all();
00583 return __res;
00584 }
00585
00586 using _Base::get_allocator;
00587
00588 size_type
00589 find(const basic_string& __str, size_type __pos = 0) const
00590 { return _Base::find(__str, __pos); }
00591
00592 size_type
00593 find(const _CharT* __s, size_type __pos, size_type __n) const
00594 {
00595 __glibcxx_check_string(__s);
00596 return _Base::find(__s, __pos, __n);
00597 }
00598
00599 size_type
00600 find(const _CharT* __s, size_type __pos = 0) const
00601 {
00602 __glibcxx_check_string(__s);
00603 return _Base::find(__s, __pos);
00604 }
00605
00606 size_type
00607 find(_CharT __c, size_type __pos = 0) const
00608 { return _Base::find(__c, __pos); }
00609
00610 size_type
00611 rfind(const basic_string& __str, size_type __pos = _Base::npos) const
00612 { return _Base::rfind(__str, __pos); }
00613
00614 size_type
00615 rfind(const _CharT* __s, size_type __pos, size_type __n) const
00616 {
00617 __glibcxx_check_string_len(__s, __n);
00618 return _Base::rfind(__s, __pos, __n);
00619 }
00620
00621 size_type
00622 rfind(const _CharT* __s, size_type __pos = _Base::npos) const
00623 {
00624 __glibcxx_check_string(__s);
00625 return _Base::rfind(__s, __pos);
00626 }
00627
00628 size_type
00629 rfind(_CharT __c, size_type __pos = _Base::npos) const
00630 { return _Base::rfind(__c, __pos); }
00631
00632 size_type
00633 find_first_of(const basic_string& __str, size_type __pos = 0) const
00634 { return _Base::find_first_of(__str, __pos); }
00635
00636 size_type
00637 find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
00638 {
00639 __glibcxx_check_string(__s);
00640 return _Base::find_first_of(__s, __pos, __n);
00641 }
00642
00643 size_type
00644 find_first_of(const _CharT* __s, size_type __pos = 0) const
00645 {
00646 __glibcxx_check_string(__s);
00647 return _Base::find_first_of(__s, __pos);
00648 }
00649
00650 size_type
00651 find_first_of(_CharT __c, size_type __pos = 0) const
00652 { return _Base::find_first_of(__c, __pos); }
00653
00654 size_type
00655 find_last_of(const basic_string& __str, size_type __pos = _Base::npos) const
00656 { return _Base::find_last_of(__str, __pos); }
00657
00658 size_type
00659 find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
00660 {
00661 __glibcxx_check_string(__s);
00662 return _Base::find_last_of(__s, __pos, __n);
00663 }
00664
00665 size_type
00666 find_last_of(const _CharT* __s, size_type __pos = _Base::npos) const
00667 {
00668 __glibcxx_check_string(__s);
00669 return _Base::find_last_of(__s, __pos);
00670 }
00671
00672 size_type
00673 find_last_of(_CharT __c, size_type __pos = _Base::npos) const
00674 { return _Base::find_last_of(__c, __pos); }
00675
00676 size_type
00677 find_first_not_of(const basic_string& __str, size_type __pos = 0) const
00678 { return _Base::find_first_not_of(__str, __pos); }
00679
00680 size_type
00681 find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
00682 {
00683 __glibcxx_check_string_len(__s, __n);
00684 return _Base::find_first_not_of(__s, __pos, __n);
00685 }
00686
00687 size_type
00688 find_first_not_of(const _CharT* __s, size_type __pos = 0) const
00689 {
00690 __glibcxx_check_string(__s);
00691 return _Base::find_first_not_of(__s, __pos);
00692 }
00693
00694 size_type
00695 find_first_not_of(_CharT __c, size_type __pos = 0) const
00696 { return _Base::find_first_not_of(__c, __pos); }
00697
00698 size_type
00699 find_last_not_of(const basic_string& __str,
00700 size_type __pos = _Base::npos) const
00701 { return _Base::find_last_not_of(__str, __pos); }
00702
00703 size_type
00704 find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
00705 {
00706 __glibcxx_check_string(__s);
00707 return _Base::find_last_not_of(__s, __pos, __n);
00708 }
00709
00710 size_type
00711 find_last_not_of(const _CharT* __s, size_type __pos = _Base::npos) const
00712 {
00713 __glibcxx_check_string(__s);
00714 return _Base::find_last_not_of(__s, __pos);
00715 }
00716
00717 size_type
00718 find_last_not_of(_CharT __c, size_type __pos = _Base::npos) const
00719 { return _Base::find_last_not_of(__c, __pos); }
00720
00721 basic_string
00722 substr(size_type __pos = 0, size_type __n = _Base::npos) const
00723 { return basic_string(_Base::substr(__pos, __n)); }
00724
00725 int
00726 compare(const basic_string& __str) const
00727 { return _Base::compare(__str); }
00728
00729 int
00730 compare(size_type __pos1, size_type __n1,
00731 const basic_string& __str) const
00732 { return _Base::compare(__pos1, __n1, __str); }
00733
00734 int
00735 compare(size_type __pos1, size_type __n1, const basic_string& __str,
00736 size_type __pos2, size_type __n2) const
00737 { return _Base::compare(__pos1, __n1, __str, __pos2, __n2); }
00738
00739 int
00740 compare(const _CharT* __s) const
00741 {
00742 __glibcxx_check_string(__s);
00743 return _Base::compare(__s);
00744 }
00745
00746
00747
00748 int
00749 compare(size_type __pos1, size_type __n1, const _CharT* __s) const
00750 {
00751 __glibcxx_check_string(__s);
00752 return _Base::compare(__pos1, __n1, __s);
00753 }
00754
00755
00756
00757 int
00758 compare(size_type __pos1, size_type __n1,const _CharT* __s,
00759 size_type __n2) const
00760 {
00761 __glibcxx_check_string_len(__s, __n2);
00762 return _Base::compare(__pos1, __n1, __s, __n2);
00763 }
00764
00765 _Base&
00766 _M_base() { return *this; }
00767
00768 const _Base&
00769 _M_base() const { return *this; }
00770
00771 using _Safe_base::_M_invalidate_all;
00772 };
00773
00774 template<typename _CharT, typename _Traits, typename _Allocator>
00775 inline basic_string<_CharT,_Traits,_Allocator>
00776 operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00777 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00778 { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
00779
00780 template<typename _CharT, typename _Traits, typename _Allocator>
00781 inline basic_string<_CharT,_Traits,_Allocator>
00782 operator+(const _CharT* __lhs,
00783 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00784 {
00785 __glibcxx_check_string(__lhs);
00786 return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
00787 }
00788
00789 template<typename _CharT, typename _Traits, typename _Allocator>
00790 inline basic_string<_CharT,_Traits,_Allocator>
00791 operator+(_CharT __lhs,
00792 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00793 { return basic_string<_CharT,_Traits,_Allocator>(1, __lhs) += __rhs; }
00794
00795 template<typename _CharT, typename _Traits, typename _Allocator>
00796 inline basic_string<_CharT,_Traits,_Allocator>
00797 operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00798 const _CharT* __rhs)
00799 {
00800 __glibcxx_check_string(__rhs);
00801 return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
00802 }
00803
00804 template<typename _CharT, typename _Traits, typename _Allocator>
00805 inline basic_string<_CharT,_Traits,_Allocator>
00806 operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00807 _CharT __rhs)
00808 { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
00809
00810 template<typename _CharT, typename _Traits, typename _Allocator>
00811 inline bool
00812 operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00813 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00814 { return __lhs._M_base() == __rhs._M_base(); }
00815
00816 template<typename _CharT, typename _Traits, typename _Allocator>
00817 inline bool
00818 operator==(const _CharT* __lhs,
00819 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00820 {
00821 __glibcxx_check_string(__lhs);
00822 return __lhs == __rhs._M_base();
00823 }
00824
00825 template<typename _CharT, typename _Traits, typename _Allocator>
00826 inline bool
00827 operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00828 const _CharT* __rhs)
00829 {
00830 __glibcxx_check_string(__rhs);
00831 return __lhs._M_base() == __rhs;
00832 }
00833
00834 template<typename _CharT, typename _Traits, typename _Allocator>
00835 inline bool
00836 operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00837 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00838 { return __lhs._M_base() != __rhs._M_base(); }
00839
00840 template<typename _CharT, typename _Traits, typename _Allocator>
00841 inline bool
00842 operator!=(const _CharT* __lhs,
00843 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00844 {
00845 __glibcxx_check_string(__lhs);
00846 return __lhs != __rhs._M_base();
00847 }
00848
00849 template<typename _CharT, typename _Traits, typename _Allocator>
00850 inline bool
00851 operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00852 const _CharT* __rhs)
00853 {
00854 __glibcxx_check_string(__rhs);
00855 return __lhs._M_base() != __rhs;
00856 }
00857
00858 template<typename _CharT, typename _Traits, typename _Allocator>
00859 inline bool
00860 operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00861 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00862 { return __lhs._M_base() < __rhs._M_base(); }
00863
00864 template<typename _CharT, typename _Traits, typename _Allocator>
00865 inline bool
00866 operator<(const _CharT* __lhs,
00867 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00868 {
00869 __glibcxx_check_string(__lhs);
00870 return __lhs < __rhs._M_base();
00871 }
00872
00873 template<typename _CharT, typename _Traits, typename _Allocator>
00874 inline bool
00875 operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00876 const _CharT* __rhs)
00877 {
00878 __glibcxx_check_string(__rhs);
00879 return __lhs._M_base() < __rhs;
00880 }
00881
00882 template<typename _CharT, typename _Traits, typename _Allocator>
00883 inline bool
00884 operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00885 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00886 { return __lhs._M_base() <= __rhs._M_base(); }
00887
00888 template<typename _CharT, typename _Traits, typename _Allocator>
00889 inline bool
00890 operator<=(const _CharT* __lhs,
00891 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00892 {
00893 __glibcxx_check_string(__lhs);
00894 return __lhs <= __rhs._M_base();
00895 }
00896
00897 template<typename _CharT, typename _Traits, typename _Allocator>
00898 inline bool
00899 operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00900 const _CharT* __rhs)
00901 {
00902 __glibcxx_check_string(__rhs);
00903 return __lhs._M_base() <= __rhs;
00904 }
00905
00906 template<typename _CharT, typename _Traits, typename _Allocator>
00907 inline bool
00908 operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00909 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00910 { return __lhs._M_base() >= __rhs._M_base(); }
00911
00912 template<typename _CharT, typename _Traits, typename _Allocator>
00913 inline bool
00914 operator>=(const _CharT* __lhs,
00915 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00916 {
00917 __glibcxx_check_string(__lhs);
00918 return __lhs >= __rhs._M_base();
00919 }
00920
00921 template<typename _CharT, typename _Traits, typename _Allocator>
00922 inline bool
00923 operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00924 const _CharT* __rhs)
00925 {
00926 __glibcxx_check_string(__rhs);
00927 return __lhs._M_base() >= __rhs;
00928 }
00929
00930 template<typename _CharT, typename _Traits, typename _Allocator>
00931 inline bool
00932 operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00933 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00934 { return __lhs._M_base() > __rhs._M_base(); }
00935
00936 template<typename _CharT, typename _Traits, typename _Allocator>
00937 inline bool
00938 operator>(const _CharT* __lhs,
00939 const basic_string<_CharT,_Traits,_Allocator>& __rhs)
00940 {
00941 __glibcxx_check_string(__lhs);
00942 return __lhs > __rhs._M_base();
00943 }
00944
00945 template<typename _CharT, typename _Traits, typename _Allocator>
00946 inline bool
00947 operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
00948 const _CharT* __rhs)
00949 {
00950 __glibcxx_check_string(__rhs);
00951 return __lhs._M_base() > __rhs;
00952 }
00953
00954
00955 template<typename _CharT, typename _Traits, typename _Allocator>
00956 inline void
00957 swap(basic_string<_CharT,_Traits,_Allocator>& __lhs,
00958 basic_string<_CharT,_Traits,_Allocator>& __rhs)
00959 { __lhs.swap(__rhs); }
00960
00961 template<typename _CharT, typename _Traits, typename _Allocator>
00962 std::basic_ostream<_CharT, _Traits>&
00963 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
00964 const basic_string<_CharT, _Traits, _Allocator>& __str)
00965 { return __os << __str._M_base(); }
00966
00967 template<typename _CharT, typename _Traits, typename _Allocator>
00968 std::basic_istream<_CharT,_Traits>&
00969 operator>>(std::basic_istream<_CharT,_Traits>& __is,
00970 basic_string<_CharT,_Traits,_Allocator>& __str)
00971 {
00972 std::basic_istream<_CharT,_Traits>& __res = __is >> __str._M_base();
00973 __str._M_invalidate_all();
00974 return __res;
00975 }
00976
00977 template<typename _CharT, typename _Traits, typename _Allocator>
00978 std::basic_istream<_CharT,_Traits>&
00979 getline(std::basic_istream<_CharT,_Traits>& __is,
00980 basic_string<_CharT,_Traits,_Allocator>& __str, _CharT __delim)
00981 {
00982 std::basic_istream<_CharT,_Traits>& __res = getline(__is,
00983 __str._M_base(),
00984 __delim);
00985 __str._M_invalidate_all();
00986 return __res;
00987 }
00988
00989 template<typename _CharT, typename _Traits, typename _Allocator>
00990 std::basic_istream<_CharT,_Traits>&
00991 getline(std::basic_istream<_CharT,_Traits>& __is,
00992 basic_string<_CharT,_Traits,_Allocator>& __str)
00993 {
00994 std::basic_istream<_CharT,_Traits>& __res = getline(__is,
00995 __str._M_base());
00996 __str._M_invalidate_all();
00997 return __res;
00998 }
00999 }
01000
01001 #endif