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