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