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