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 _VSTRING_H
00031 #define _VSTRING_H 1
00032
00033 #pragma GCC system_header
00034
00035 #include <initializer_list>
00036 #include <ext/vstring_util.h>
00037 #include <ext/rc_string_base.h>
00038 #include <ext/sso_string_base.h>
00039
00040 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
00041
00042
00043
00044
00045
00046
00047
00048 template<typename _CharT, typename _Traits, typename _Alloc,
00049 template <typename, typename, typename> class _Base>
00050 class __versa_string
00051 : private _Base<_CharT, _Traits, _Alloc>
00052 {
00053 typedef _Base<_CharT, _Traits, _Alloc> __vstring_base;
00054 typedef typename __vstring_base::_CharT_alloc_type _CharT_alloc_type;
00055
00056
00057 public:
00058 typedef _Traits traits_type;
00059 typedef typename _Traits::char_type value_type;
00060 typedef _Alloc allocator_type;
00061 typedef typename _CharT_alloc_type::size_type size_type;
00062 typedef typename _CharT_alloc_type::difference_type difference_type;
00063 typedef typename _CharT_alloc_type::reference reference;
00064 typedef typename _CharT_alloc_type::const_reference const_reference;
00065 typedef typename _CharT_alloc_type::pointer pointer;
00066 typedef typename _CharT_alloc_type::const_pointer const_pointer;
00067 typedef __gnu_cxx::__normal_iterator<pointer, __versa_string> iterator;
00068 typedef __gnu_cxx::__normal_iterator<const_pointer, __versa_string>
00069 const_iterator;
00070 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00071 typedef std::reverse_iterator<iterator> reverse_iterator;
00072
00073
00074
00075 static const size_type npos = static_cast<size_type>(-1);
00076
00077 private:
00078 size_type
00079 _M_check(size_type __pos, const char* __s) const
00080 {
00081 if (__pos > this->size())
00082 std::__throw_out_of_range(__N(__s));
00083 return __pos;
00084 }
00085
00086 void
00087 _M_check_length(size_type __n1, size_type __n2, const char* __s) const
00088 {
00089 if (this->max_size() - (this->size() - __n1) < __n2)
00090 std::__throw_length_error(__N(__s));
00091 }
00092
00093
00094 size_type
00095 _M_limit(size_type __pos, size_type __off) const
00096 {
00097 const bool __testoff = __off < this->size() - __pos;
00098 return __testoff ? __off : this->size() - __pos;
00099 }
00100
00101
00102 bool
00103 _M_disjunct(const _CharT* __s) const
00104 {
00105 return (std::less<const _CharT*>()(__s, this->_M_data())
00106 || std::less<const _CharT*>()(this->_M_data()
00107 + this->size(), __s));
00108 }
00109
00110
00111
00112 iterator
00113 _M_ibegin() const
00114 { return iterator(this->_M_data()); }
00115
00116 iterator
00117 _M_iend() const
00118 { return iterator(this->_M_data() + this->_M_length()); }
00119
00120 public:
00121
00122
00123
00124
00125
00126
00127
00128 __versa_string()
00129 : __vstring_base() { }
00130
00131
00132
00133
00134 explicit
00135 __versa_string(const _Alloc& __a)
00136 : __vstring_base(__a) { }
00137
00138
00139
00140
00141
00142
00143 __versa_string(const __versa_string& __str)
00144 : __vstring_base(__str) { }
00145
00146 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00147
00148
00149
00150
00151
00152
00153
00154
00155 __versa_string(__versa_string&& __str)
00156 : __vstring_base(std::forward<__vstring_base>(__str)) { }
00157
00158
00159
00160
00161
00162
00163 __versa_string(std::initializer_list<_CharT> __l,
00164 const _Alloc& __a = _Alloc())
00165 : __vstring_base(__l.begin(), __l.end(), __a) { }
00166 #endif
00167
00168
00169
00170
00171
00172
00173
00174 __versa_string(const __versa_string& __str, size_type __pos,
00175 size_type __n = npos)
00176 : __vstring_base(__str._M_data()
00177 + __str._M_check(__pos,
00178 "__versa_string::__versa_string"),
00179 __str._M_data() + __str._M_limit(__pos, __n)
00180 + __pos, _Alloc()) { }
00181
00182
00183
00184
00185
00186
00187
00188
00189 __versa_string(const __versa_string& __str, size_type __pos,
00190 size_type __n, const _Alloc& __a)
00191 : __vstring_base(__str._M_data()
00192 + __str._M_check(__pos,
00193 "__versa_string::__versa_string"),
00194 __str._M_data() + __str._M_limit(__pos, __n)
00195 + __pos, __a) { }
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206 __versa_string(const _CharT* __s, size_type __n,
00207 const _Alloc& __a = _Alloc())
00208 : __vstring_base(__s, __s + __n, __a) { }
00209
00210
00211
00212
00213
00214
00215 __versa_string(const _CharT* __s, const _Alloc& __a = _Alloc())
00216 : __vstring_base(__s, __s ? __s + traits_type::length(__s) :
00217 __s + npos, __a) { }
00218
00219
00220
00221
00222
00223
00224
00225 __versa_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
00226 : __vstring_base(__n, __c, __a) { }
00227
00228
00229
00230
00231
00232
00233
00234 template<class _InputIterator>
00235 __versa_string(_InputIterator __beg, _InputIterator __end,
00236 const _Alloc& __a = _Alloc())
00237 : __vstring_base(__beg, __end, __a) { }
00238
00239
00240
00241
00242 ~__versa_string() { }
00243
00244
00245
00246
00247
00248 __versa_string&
00249 operator=(const __versa_string& __str)
00250 { return this->assign(__str); }
00251
00252 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00253
00254
00255
00256
00257
00258
00259
00260 __versa_string&
00261 operator=(__versa_string&& __str)
00262 {
00263
00264 this->swap(__str);
00265 return *this;
00266 }
00267
00268
00269
00270
00271
00272 __versa_string&
00273 operator=(std::initializer_list<_CharT> __l)
00274 {
00275 this->assign(__l.begin(), __l.end());
00276 return *this;
00277 }
00278 #endif
00279
00280
00281
00282
00283
00284 __versa_string&
00285 operator=(const _CharT* __s)
00286 { return this->assign(__s); }
00287
00288
00289
00290
00291
00292
00293
00294
00295 __versa_string&
00296 operator=(_CharT __c)
00297 {
00298 this->assign(1, __c);
00299 return *this;
00300 }
00301
00302
00303
00304
00305
00306
00307 iterator
00308 begin()
00309 {
00310 this->_M_leak();
00311 return iterator(this->_M_data());
00312 }
00313
00314
00315
00316
00317
00318 const_iterator
00319 begin() const
00320 { return const_iterator(this->_M_data()); }
00321
00322
00323
00324
00325
00326 iterator
00327 end()
00328 {
00329 this->_M_leak();
00330 return iterator(this->_M_data() + this->size());
00331 }
00332
00333
00334
00335
00336
00337 const_iterator
00338 end() const
00339 { return const_iterator(this->_M_data() + this->size()); }
00340
00341
00342
00343
00344
00345
00346 reverse_iterator
00347 rbegin()
00348 { return reverse_iterator(this->end()); }
00349
00350
00351
00352
00353
00354
00355 const_reverse_iterator
00356 rbegin() const
00357 { return const_reverse_iterator(this->end()); }
00358
00359
00360
00361
00362
00363
00364 reverse_iterator
00365 rend()
00366 { return reverse_iterator(this->begin()); }
00367
00368
00369
00370
00371
00372
00373 const_reverse_iterator
00374 rend() const
00375 { return const_reverse_iterator(this->begin()); }
00376
00377 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00378
00379
00380
00381
00382 const_iterator
00383 cbegin() const
00384 { return const_iterator(this->_M_data()); }
00385
00386
00387
00388
00389
00390 const_iterator
00391 cend() const
00392 { return const_iterator(this->_M_data() + this->size()); }
00393
00394
00395
00396
00397
00398
00399 const_reverse_iterator
00400 crbegin() const
00401 { return const_reverse_iterator(this->end()); }
00402
00403
00404
00405
00406
00407
00408 const_reverse_iterator
00409 crend() const
00410 { return const_reverse_iterator(this->begin()); }
00411 #endif
00412
00413 public:
00414
00415
00416
00417 size_type
00418 size() const
00419 { return this->_M_length(); }
00420
00421
00422
00423 size_type
00424 length() const
00425 { return this->_M_length(); }
00426
00427
00428 size_type
00429 max_size() const
00430 { return this->_M_max_size(); }
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442 void
00443 resize(size_type __n, _CharT __c);
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455 void
00456 resize(size_type __n)
00457 { this->resize(__n, _CharT()); }
00458
00459 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00460
00461 void
00462 shrink_to_fit()
00463 {
00464 try
00465 { this->reserve(0); }
00466 catch(...)
00467 { }
00468 }
00469 #endif
00470
00471
00472
00473
00474
00475 size_type
00476 capacity() const
00477 { return this->_M_capacity(); }
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496 void
00497 reserve(size_type __res_arg = 0)
00498 { this->_M_reserve(__res_arg); }
00499
00500
00501
00502
00503 void
00504 clear()
00505 { this->_M_clear(); }
00506
00507
00508
00509
00510 bool
00511 empty() const
00512 { return this->size() == 0; }
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525 const_reference
00526 operator[] (size_type __pos) const
00527 {
00528 _GLIBCXX_DEBUG_ASSERT(__pos <= this->size());
00529 return this->_M_data()[__pos];
00530 }
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542 reference
00543 operator[](size_type __pos)
00544 {
00545
00546 _GLIBCXX_DEBUG_ASSERT(__pos <= this->size());
00547
00548 _GLIBCXX_DEBUG_PEDASSERT(__pos < this->size());
00549 this->_M_leak();
00550 return this->_M_data()[__pos];
00551 }
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563 const_reference
00564 at(size_type __n) const
00565 {
00566 if (__n >= this->size())
00567 std::__throw_out_of_range(__N("__versa_string::at"));
00568 return this->_M_data()[__n];
00569 }
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582 reference
00583 at(size_type __n)
00584 {
00585 if (__n >= this->size())
00586 std::__throw_out_of_range(__N("__versa_string::at"));
00587 this->_M_leak();
00588 return this->_M_data()[__n];
00589 }
00590
00591 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00592
00593
00594
00595
00596 reference
00597 front()
00598 { return *begin(); }
00599
00600
00601
00602
00603
00604 const_reference
00605 front() const
00606 { return *begin(); }
00607
00608
00609
00610
00611
00612 reference
00613 back()
00614 { return *(end() - 1); }
00615
00616
00617
00618
00619
00620 const_reference
00621 back() const
00622 { return *(end() - 1); }
00623 #endif
00624
00625
00626
00627
00628
00629
00630
00631 __versa_string&
00632 operator+=(const __versa_string& __str)
00633 { return this->append(__str); }
00634
00635
00636
00637
00638
00639
00640 __versa_string&
00641 operator+=(const _CharT* __s)
00642 { return this->append(__s); }
00643
00644
00645
00646
00647
00648
00649 __versa_string&
00650 operator+=(_CharT __c)
00651 {
00652 this->push_back(__c);
00653 return *this;
00654 }
00655
00656 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00657
00658
00659
00660
00661
00662 __versa_string&
00663 operator+=(std::initializer_list<_CharT> __l)
00664 { return this->append(__l.begin(), __l.end()); }
00665 #endif // __GXX_EXPERIMENTAL_CXX0X__
00666
00667
00668
00669
00670
00671
00672 __versa_string&
00673 append(const __versa_string& __str)
00674 { return _M_append(__str._M_data(), __str.size()); }
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689 __versa_string&
00690 append(const __versa_string& __str, size_type __pos, size_type __n)
00691 { return _M_append(__str._M_data()
00692 + __str._M_check(__pos, "__versa_string::append"),
00693 __str._M_limit(__pos, __n)); }
00694
00695
00696
00697
00698
00699
00700
00701 __versa_string&
00702 append(const _CharT* __s, size_type __n)
00703 {
00704 __glibcxx_requires_string_len(__s, __n);
00705 _M_check_length(size_type(0), __n, "__versa_string::append");
00706 return _M_append(__s, __n);
00707 }
00708
00709
00710
00711
00712
00713
00714 __versa_string&
00715 append(const _CharT* __s)
00716 {
00717 __glibcxx_requires_string(__s);
00718 const size_type __n = traits_type::length(__s);
00719 _M_check_length(size_type(0), __n, "__versa_string::append");
00720 return _M_append(__s, __n);
00721 }
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731 __versa_string&
00732 append(size_type __n, _CharT __c)
00733 { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
00734
00735 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00736
00737
00738
00739
00740
00741 __versa_string&
00742 append(std::initializer_list<_CharT> __l)
00743 { return this->append(__l.begin(), __l.end()); }
00744 #endif // __GXX_EXPERIMENTAL_CXX0X__
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754 template<class _InputIterator>
00755 __versa_string&
00756 append(_InputIterator __first, _InputIterator __last)
00757 { return this->replace(_M_iend(), _M_iend(), __first, __last); }
00758
00759
00760
00761
00762
00763 void
00764 push_back(_CharT __c)
00765 {
00766 const size_type __size = this->size();
00767 if (__size + 1 > this->capacity() || this->_M_is_shared())
00768 this->_M_mutate(__size, size_type(0), 0, size_type(1));
00769 traits_type::assign(this->_M_data()[__size], __c);
00770 this->_M_set_length(__size + 1);
00771 }
00772
00773
00774
00775
00776
00777
00778 __versa_string&
00779 assign(const __versa_string& __str)
00780 {
00781 this->_M_assign(__str);
00782 return *this;
00783 }
00784
00785 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00786
00787
00788
00789
00790
00791
00792
00793
00794 __versa_string&
00795 assign(__versa_string&& __str)
00796 {
00797 this->swap(__str);
00798 return *this;
00799 }
00800 #endif // __GXX_EXPERIMENTAL_CXX0X__
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815 __versa_string&
00816 assign(const __versa_string& __str, size_type __pos, size_type __n)
00817 { return _M_replace(size_type(0), this->size(), __str._M_data()
00818 + __str._M_check(__pos, "__versa_string::assign"),
00819 __str._M_limit(__pos, __n)); }
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832 __versa_string&
00833 assign(const _CharT* __s, size_type __n)
00834 {
00835 __glibcxx_requires_string_len(__s, __n);
00836 return _M_replace(size_type(0), this->size(), __s, __n);
00837 }
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848 __versa_string&
00849 assign(const _CharT* __s)
00850 {
00851 __glibcxx_requires_string(__s);
00852 return _M_replace(size_type(0), this->size(), __s,
00853 traits_type::length(__s));
00854 }
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865 __versa_string&
00866 assign(size_type __n, _CharT __c)
00867 { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878 template<class _InputIterator>
00879 __versa_string&
00880 assign(_InputIterator __first, _InputIterator __last)
00881 { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
00882
00883 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00884
00885
00886
00887
00888
00889 __versa_string&
00890 assign(std::initializer_list<_CharT> __l)
00891 { return this->assign(__l.begin(), __l.end()); }
00892 #endif // __GXX_EXPERIMENTAL_CXX0X__
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907 void
00908 insert(iterator __p, size_type __n, _CharT __c)
00909 { this->replace(__p, __p, __n, __c); }
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923 template<class _InputIterator>
00924 void
00925 insert(iterator __p, _InputIterator __beg, _InputIterator __end)
00926 { this->replace(__p, __p, __beg, __end); }
00927
00928 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00929
00930
00931
00932
00933
00934
00935 void
00936 insert(iterator __p, std::initializer_list<_CharT> __l)
00937 { this->insert(__p, __l.begin(), __l.end()); }
00938 #endif // __GXX_EXPERIMENTAL_CXX0X__
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952 __versa_string&
00953 insert(size_type __pos1, const __versa_string& __str)
00954 { return this->replace(__pos1, size_type(0),
00955 __str._M_data(), __str.size()); }
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975 __versa_string&
00976 insert(size_type __pos1, const __versa_string& __str,
00977 size_type __pos2, size_type __n)
00978 { return this->replace(__pos1, size_type(0), __str._M_data()
00979 + __str._M_check(__pos2, "__versa_string::insert"),
00980 __str._M_limit(__pos2, __n)); }
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998 __versa_string&
00999 insert(size_type __pos, const _CharT* __s, size_type __n)
01000 { return this->replace(__pos, size_type(0), __s, __n); }
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017 __versa_string&
01018 insert(size_type __pos, const _CharT* __s)
01019 {
01020 __glibcxx_requires_string(__s);
01021 return this->replace(__pos, size_type(0), __s,
01022 traits_type::length(__s));
01023 }
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041 __versa_string&
01042 insert(size_type __pos, size_type __n, _CharT __c)
01043 { return _M_replace_aux(_M_check(__pos, "__versa_string::insert"),
01044 size_type(0), __n, __c); }
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059 iterator
01060 insert(iterator __p, _CharT __c)
01061 {
01062 _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend());
01063 const size_type __pos = __p - _M_ibegin();
01064 _M_replace_aux(__pos, size_type(0), size_type(1), __c);
01065 this->_M_set_leaked();
01066 return iterator(this->_M_data() + __pos);
01067 }
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077
01078
01079
01080
01081
01082
01083
01084 __versa_string&
01085 erase(size_type __pos = 0, size_type __n = npos)
01086 {
01087 this->_M_erase(_M_check(__pos, "__versa_string::erase"),
01088 _M_limit(__pos, __n));
01089 return *this;
01090 }
01091
01092
01093
01094
01095
01096
01097
01098
01099
01100 iterator
01101 erase(iterator __position)
01102 {
01103 _GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin()
01104 && __position < _M_iend());
01105 const size_type __pos = __position - _M_ibegin();
01106 this->_M_erase(__pos, size_type(1));
01107 this->_M_set_leaked();
01108 return iterator(this->_M_data() + __pos);
01109 }
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121 iterator
01122 erase(iterator __first, iterator __last)
01123 {
01124 _GLIBCXX_DEBUG_PEDASSERT(__first >= _M_ibegin() && __first <= __last
01125 && __last <= _M_iend());
01126 const size_type __pos = __first - _M_ibegin();
01127 this->_M_erase(__pos, __last - __first);
01128 this->_M_set_leaked();
01129 return iterator(this->_M_data() + __pos);
01130 }
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149 __versa_string&
01150 replace(size_type __pos, size_type __n, const __versa_string& __str)
01151 { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
01152
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172 __versa_string&
01173 replace(size_type __pos1, size_type __n1, const __versa_string& __str,
01174 size_type __pos2, size_type __n2)
01175 {
01176 return this->replace(__pos1, __n1, __str._M_data()
01177 + __str._M_check(__pos2,
01178 "__versa_string::replace"),
01179 __str._M_limit(__pos2, __n2));
01180 }
01181
01182
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200 __versa_string&
01201 replace(size_type __pos, size_type __n1, const _CharT* __s,
01202 size_type __n2)
01203 {
01204 __glibcxx_requires_string_len(__s, __n2);
01205 return _M_replace(_M_check(__pos, "__versa_string::replace"),
01206 _M_limit(__pos, __n1), __s, __n2);
01207 }
01208
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225 __versa_string&
01226 replace(size_type __pos, size_type __n1, const _CharT* __s)
01227 {
01228 __glibcxx_requires_string(__s);
01229 return this->replace(__pos, __n1, __s, traits_type::length(__s));
01230 }
01231
01232
01233
01234
01235
01236
01237
01238
01239
01240
01241
01242
01243
01244
01245
01246
01247
01248
01249 __versa_string&
01250 replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
01251 { return _M_replace_aux(_M_check(__pos, "__versa_string::replace"),
01252 _M_limit(__pos, __n1), __n2, __c); }
01253
01254
01255
01256
01257
01258
01259
01260
01261
01262
01263
01264
01265
01266
01267 __versa_string&
01268 replace(iterator __i1, iterator __i2, const __versa_string& __str)
01269 { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279
01280
01281
01282
01283
01284
01285 __versa_string&
01286 replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
01287 {
01288 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01289 && __i2 <= _M_iend());
01290 return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
01291 }
01292
01293
01294
01295
01296
01297
01298
01299
01300
01301
01302
01303
01304
01305
01306 __versa_string&
01307 replace(iterator __i1, iterator __i2, const _CharT* __s)
01308 {
01309 __glibcxx_requires_string(__s);
01310 return this->replace(__i1, __i2, __s, traits_type::length(__s));
01311 }
01312
01313
01314
01315
01316
01317
01318
01319
01320
01321
01322
01323
01324
01325
01326
01327 __versa_string&
01328 replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
01329 {
01330 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01331 && __i2 <= _M_iend());
01332 return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
01333 }
01334
01335
01336
01337
01338
01339
01340
01341
01342
01343
01344
01345
01346
01347
01348
01349 template<class _InputIterator>
01350 __versa_string&
01351 replace(iterator __i1, iterator __i2,
01352 _InputIterator __k1, _InputIterator __k2)
01353 {
01354 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01355 && __i2 <= _M_iend());
01356 __glibcxx_requires_valid_range(__k1, __k2);
01357 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
01358 return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
01359 }
01360
01361
01362
01363 __versa_string&
01364 replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
01365 {
01366 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01367 && __i2 <= _M_iend());
01368 __glibcxx_requires_valid_range(__k1, __k2);
01369 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
01370 __k1, __k2 - __k1);
01371 }
01372
01373 __versa_string&
01374 replace(iterator __i1, iterator __i2,
01375 const _CharT* __k1, const _CharT* __k2)
01376 {
01377 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01378 && __i2 <= _M_iend());
01379 __glibcxx_requires_valid_range(__k1, __k2);
01380 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
01381 __k1, __k2 - __k1);
01382 }
01383
01384 __versa_string&
01385 replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
01386 {
01387 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01388 && __i2 <= _M_iend());
01389 __glibcxx_requires_valid_range(__k1, __k2);
01390 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
01391 __k1.base(), __k2 - __k1);
01392 }
01393
01394 __versa_string&
01395 replace(iterator __i1, iterator __i2,
01396 const_iterator __k1, const_iterator __k2)
01397 {
01398 _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2
01399 && __i2 <= _M_iend());
01400 __glibcxx_requires_valid_range(__k1, __k2);
01401 return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
01402 __k1.base(), __k2 - __k1);
01403 }
01404
01405 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415
01416
01417
01418
01419 __versa_string& replace(iterator __i1, iterator __i2,
01420 std::initializer_list<_CharT> __l)
01421 { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
01422 #endif // __GXX_EXPERIMENTAL_CXX0X__
01423
01424 private:
01425 template<class _Integer>
01426 __versa_string&
01427 _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
01428 _Integer __val, std::__true_type)
01429 { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
01430
01431 template<class _InputIterator>
01432 __versa_string&
01433 _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
01434 _InputIterator __k2, std::__false_type);
01435
01436 __versa_string&
01437 _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
01438 _CharT __c);
01439
01440 __versa_string&
01441 _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
01442 const size_type __len2);
01443
01444 __versa_string&
01445 _M_append(const _CharT* __s, size_type __n);
01446
01447 public:
01448
01449
01450
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460
01461 size_type
01462 copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
01463
01464
01465
01466
01467
01468
01469
01470
01471 void
01472 swap(__versa_string& __s)
01473 { this->_M_swap(__s); }
01474
01475
01476
01477
01478
01479
01480
01481
01482 const _CharT*
01483 c_str() const
01484 { return this->_M_data(); }
01485
01486
01487
01488
01489
01490
01491
01492 const _CharT*
01493 data() const
01494 { return this->_M_data(); }
01495
01496
01497
01498
01499 allocator_type
01500 get_allocator() const
01501 { return allocator_type(this->_M_get_allocator()); }
01502
01503
01504
01505
01506
01507
01508
01509
01510
01511
01512
01513
01514
01515 size_type
01516 find(const _CharT* __s, size_type __pos, size_type __n) const;
01517
01518
01519
01520
01521
01522
01523
01524
01525
01526
01527
01528 size_type
01529 find(const __versa_string& __str, size_type __pos = 0) const
01530 { return this->find(__str.data(), __pos, __str.size()); }
01531
01532
01533
01534
01535
01536
01537
01538
01539
01540
01541
01542 size_type
01543 find(const _CharT* __s, size_type __pos = 0) const
01544 {
01545 __glibcxx_requires_string(__s);
01546 return this->find(__s, __pos, traits_type::length(__s));
01547 }
01548
01549
01550
01551
01552
01553
01554
01555
01556
01557
01558
01559 size_type
01560 find(_CharT __c, size_type __pos = 0) const;
01561
01562
01563
01564
01565
01566
01567
01568
01569
01570
01571
01572 size_type
01573 rfind(const __versa_string& __str, size_type __pos = npos) const
01574 { return this->rfind(__str.data(), __pos, __str.size()); }
01575
01576
01577
01578
01579
01580
01581
01582
01583
01584
01585
01586
01587
01588 size_type
01589 rfind(const _CharT* __s, size_type __pos, size_type __n) const;
01590
01591
01592
01593
01594
01595
01596
01597
01598
01599
01600
01601 size_type
01602 rfind(const _CharT* __s, size_type __pos = npos) const
01603 {
01604 __glibcxx_requires_string(__s);
01605 return this->rfind(__s, __pos, traits_type::length(__s));
01606 }
01607
01608
01609
01610
01611
01612
01613
01614
01615
01616
01617
01618 size_type
01619 rfind(_CharT __c, size_type __pos = npos) const;
01620
01621
01622
01623
01624
01625
01626
01627
01628
01629
01630
01631 size_type
01632 find_first_of(const __versa_string& __str, size_type __pos = 0) const
01633 { return this->find_first_of(__str.data(), __pos, __str.size()); }
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646
01647 size_type
01648 find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
01649
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659
01660 size_type
01661 find_first_of(const _CharT* __s, size_type __pos = 0) const
01662 {
01663 __glibcxx_requires_string(__s);
01664 return this->find_first_of(__s, __pos, traits_type::length(__s));
01665 }
01666
01667
01668
01669
01670
01671
01672
01673
01674
01675
01676
01677
01678
01679 size_type
01680 find_first_of(_CharT __c, size_type __pos = 0) const
01681 { return this->find(__c, __pos); }
01682
01683
01684
01685
01686
01687
01688
01689
01690
01691
01692
01693
01694 size_type
01695 find_last_of(const __versa_string& __str, size_type __pos = npos) const
01696 { return this->find_last_of(__str.data(), __pos, __str.size()); }
01697
01698
01699
01700
01701
01702
01703
01704
01705
01706
01707
01708
01709
01710 size_type
01711 find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
01712
01713
01714
01715
01716
01717
01718
01719
01720
01721
01722
01723 size_type
01724 find_last_of(const _CharT* __s, size_type __pos = npos) const
01725 {
01726 __glibcxx_requires_string(__s);
01727 return this->find_last_of(__s, __pos, traits_type::length(__s));
01728 }
01729
01730
01731
01732
01733
01734
01735
01736
01737
01738
01739
01740
01741
01742 size_type
01743 find_last_of(_CharT __c, size_type __pos = npos) const
01744 { return this->rfind(__c, __pos); }
01745
01746
01747
01748
01749
01750
01751
01752
01753
01754
01755
01756 size_type
01757 find_first_not_of(const __versa_string& __str, size_type __pos = 0) const
01758 { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
01759
01760
01761
01762
01763
01764
01765
01766
01767
01768
01769
01770
01771
01772 size_type
01773 find_first_not_of(const _CharT* __s, size_type __pos,
01774 size_type __n) const;
01775
01776
01777
01778
01779
01780
01781
01782
01783
01784
01785
01786 size_type
01787 find_first_not_of(const _CharT* __s, size_type __pos = 0) const
01788 {
01789 __glibcxx_requires_string(__s);
01790 return this->find_first_not_of(__s, __pos, traits_type::length(__s));
01791 }
01792
01793
01794
01795
01796
01797
01798
01799
01800
01801
01802
01803 size_type
01804 find_first_not_of(_CharT __c, size_type __pos = 0) const;
01805
01806
01807
01808
01809
01810
01811
01812
01813
01814
01815
01816
01817 size_type
01818 find_last_not_of(const __versa_string& __str,
01819 size_type __pos = npos) const
01820 { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
01821
01822
01823
01824
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834 size_type
01835 find_last_not_of(const _CharT* __s, size_type __pos,
01836 size_type __n) const;
01837
01838
01839
01840
01841
01842
01843
01844
01845
01846
01847
01848 size_type
01849 find_last_not_of(const _CharT* __s, size_type __pos = npos) const
01850 {
01851 __glibcxx_requires_string(__s);
01852 return this->find_last_not_of(__s, __pos, traits_type::length(__s));
01853 }
01854
01855
01856
01857
01858
01859
01860
01861
01862
01863
01864
01865 size_type
01866 find_last_not_of(_CharT __c, size_type __pos = npos) const;
01867
01868
01869
01870
01871
01872
01873
01874
01875
01876
01877
01878
01879
01880 __versa_string
01881 substr(size_type __pos = 0, size_type __n = npos) const
01882 {
01883 return __versa_string(*this, _M_check(__pos, "__versa_string::substr"),
01884 __n);
01885 }
01886
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898
01899
01900
01901 int
01902 compare(const __versa_string& __str) const
01903 {
01904 if (this->_M_compare(__str))
01905 return 0;
01906
01907 const size_type __size = this->size();
01908 const size_type __osize = __str.size();
01909 const size_type __len = std::min(__size, __osize);
01910
01911 int __r = traits_type::compare(this->_M_data(), __str.data(), __len);
01912 if (!__r)
01913 __r = _S_compare(__size, __osize);
01914 return __r;
01915 }
01916
01917
01918
01919
01920
01921
01922
01923
01924
01925
01926
01927
01928
01929
01930
01931
01932
01933
01934
01935
01936 int
01937 compare(size_type __pos, size_type __n,
01938 const __versa_string& __str) const;
01939
01940
01941
01942
01943
01944
01945
01946
01947
01948
01949
01950
01951
01952
01953
01954
01955
01956
01957
01958
01959
01960
01961
01962
01963 int
01964 compare(size_type __pos1, size_type __n1, const __versa_string& __str,
01965 size_type __pos2, size_type __n2) const;
01966
01967
01968
01969
01970
01971
01972
01973
01974
01975
01976
01977
01978
01979
01980
01981
01982 int
01983 compare(const _CharT* __s) const;
01984
01985
01986
01987
01988
01989
01990
01991
01992
01993
01994
01995
01996
01997
01998
01999
02000
02001
02002
02003
02004
02005
02006 int
02007 compare(size_type __pos, size_type __n1, const _CharT* __s) const;
02008
02009
02010
02011
02012
02013
02014
02015
02016
02017
02018
02019
02020
02021
02022
02023
02024
02025
02026
02027
02028
02029
02030
02031
02032
02033 int
02034 compare(size_type __pos, size_type __n1, const _CharT* __s,
02035 size_type __n2) const;
02036 };
02037
02038
02039
02040
02041
02042
02043
02044
02045 template<typename _CharT, typename _Traits, typename _Alloc,
02046 template <typename, typename, typename> class _Base>
02047 __versa_string<_CharT, _Traits, _Alloc, _Base>
02048 operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02049 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs);
02050
02051
02052
02053
02054
02055
02056
02057 template<typename _CharT, typename _Traits, typename _Alloc,
02058 template <typename, typename, typename> class _Base>
02059 __versa_string<_CharT, _Traits, _Alloc, _Base>
02060 operator+(const _CharT* __lhs,
02061 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs);
02062
02063
02064
02065
02066
02067
02068
02069 template<typename _CharT, typename _Traits, typename _Alloc,
02070 template <typename, typename, typename> class _Base>
02071 __versa_string<_CharT, _Traits, _Alloc, _Base>
02072 operator+(_CharT __lhs,
02073 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs);
02074
02075
02076
02077
02078
02079
02080
02081 template<typename _CharT, typename _Traits, typename _Alloc,
02082 template <typename, typename, typename> class _Base>
02083 __versa_string<_CharT, _Traits, _Alloc, _Base>
02084 operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02085 const _CharT* __rhs);
02086
02087
02088
02089
02090
02091
02092
02093 template<typename _CharT, typename _Traits, typename _Alloc,
02094 template <typename, typename, typename> class _Base>
02095 __versa_string<_CharT, _Traits, _Alloc, _Base>
02096 operator+(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02097 _CharT __rhs);
02098
02099
02100
02101
02102
02103
02104
02105
02106 template<typename _CharT, typename _Traits, typename _Alloc,
02107 template <typename, typename, typename> class _Base>
02108 inline bool
02109 operator==(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02110 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02111 { return __lhs.compare(__rhs) == 0; }
02112
02113 template<typename _CharT,
02114 template <typename, typename, typename> class _Base>
02115 inline typename __enable_if<std::__is_char<_CharT>::__value, bool>::__type
02116 operator==(const __versa_string<_CharT, std::char_traits<_CharT>,
02117 std::allocator<_CharT>, _Base>& __lhs,
02118 const __versa_string<_CharT, std::char_traits<_CharT>,
02119 std::allocator<_CharT>, _Base>& __rhs)
02120 { return (__lhs.size() == __rhs.size()
02121 && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
02122 __lhs.size())); }
02123
02124
02125
02126
02127
02128
02129
02130 template<typename _CharT, typename _Traits, typename _Alloc,
02131 template <typename, typename, typename> class _Base>
02132 inline bool
02133 operator==(const _CharT* __lhs,
02134 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02135 { return __rhs.compare(__lhs) == 0; }
02136
02137
02138
02139
02140
02141
02142
02143 template<typename _CharT, typename _Traits, typename _Alloc,
02144 template <typename, typename, typename> class _Base>
02145 inline bool
02146 operator==(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02147 const _CharT* __rhs)
02148 { return __lhs.compare(__rhs) == 0; }
02149
02150
02151
02152
02153
02154
02155
02156
02157 template<typename _CharT, typename _Traits, typename _Alloc,
02158 template <typename, typename, typename> class _Base>
02159 inline bool
02160 operator!=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02161 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02162 { return !(__lhs == __rhs); }
02163
02164
02165
02166
02167
02168
02169
02170 template<typename _CharT, typename _Traits, typename _Alloc,
02171 template <typename, typename, typename> class _Base>
02172 inline bool
02173 operator!=(const _CharT* __lhs,
02174 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02175 { return !(__lhs == __rhs); }
02176
02177
02178
02179
02180
02181
02182
02183 template<typename _CharT, typename _Traits, typename _Alloc,
02184 template <typename, typename, typename> class _Base>
02185 inline bool
02186 operator!=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02187 const _CharT* __rhs)
02188 { return !(__lhs == __rhs); }
02189
02190
02191
02192
02193
02194
02195
02196
02197 template<typename _CharT, typename _Traits, typename _Alloc,
02198 template <typename, typename, typename> class _Base>
02199 inline bool
02200 operator<(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02201 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02202 { return __lhs.compare(__rhs) < 0; }
02203
02204
02205
02206
02207
02208
02209
02210 template<typename _CharT, typename _Traits, typename _Alloc,
02211 template <typename, typename, typename> class _Base>
02212 inline bool
02213 operator<(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02214 const _CharT* __rhs)
02215 { return __lhs.compare(__rhs) < 0; }
02216
02217
02218
02219
02220
02221
02222
02223 template<typename _CharT, typename _Traits, typename _Alloc,
02224 template <typename, typename, typename> class _Base>
02225 inline bool
02226 operator<(const _CharT* __lhs,
02227 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02228 { return __rhs.compare(__lhs) > 0; }
02229
02230
02231
02232
02233
02234
02235
02236
02237 template<typename _CharT, typename _Traits, typename _Alloc,
02238 template <typename, typename, typename> class _Base>
02239 inline bool
02240 operator>(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02241 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02242 { return __lhs.compare(__rhs) > 0; }
02243
02244
02245
02246
02247
02248
02249
02250 template<typename _CharT, typename _Traits, typename _Alloc,
02251 template <typename, typename, typename> class _Base>
02252 inline bool
02253 operator>(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02254 const _CharT* __rhs)
02255 { return __lhs.compare(__rhs) > 0; }
02256
02257
02258
02259
02260
02261
02262
02263 template<typename _CharT, typename _Traits, typename _Alloc,
02264 template <typename, typename, typename> class _Base>
02265 inline bool
02266 operator>(const _CharT* __lhs,
02267 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02268 { return __rhs.compare(__lhs) < 0; }
02269
02270
02271
02272
02273
02274
02275
02276
02277 template<typename _CharT, typename _Traits, typename _Alloc,
02278 template <typename, typename, typename> class _Base>
02279 inline bool
02280 operator<=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02281 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02282 { return __lhs.compare(__rhs) <= 0; }
02283
02284
02285
02286
02287
02288
02289
02290 template<typename _CharT, typename _Traits, typename _Alloc,
02291 template <typename, typename, typename> class _Base>
02292 inline bool
02293 operator<=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02294 const _CharT* __rhs)
02295 { return __lhs.compare(__rhs) <= 0; }
02296
02297
02298
02299
02300
02301
02302
02303 template<typename _CharT, typename _Traits, typename _Alloc,
02304 template <typename, typename, typename> class _Base>
02305 inline bool
02306 operator<=(const _CharT* __lhs,
02307 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02308 { return __rhs.compare(__lhs) >= 0; }
02309
02310
02311
02312
02313
02314
02315
02316
02317 template<typename _CharT, typename _Traits, typename _Alloc,
02318 template <typename, typename, typename> class _Base>
02319 inline bool
02320 operator>=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02321 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02322 { return __lhs.compare(__rhs) >= 0; }
02323
02324
02325
02326
02327
02328
02329
02330 template<typename _CharT, typename _Traits, typename _Alloc,
02331 template <typename, typename, typename> class _Base>
02332 inline bool
02333 operator>=(const __versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02334 const _CharT* __rhs)
02335 { return __lhs.compare(__rhs) >= 0; }
02336
02337
02338
02339
02340
02341
02342
02343 template<typename _CharT, typename _Traits, typename _Alloc,
02344 template <typename, typename, typename> class _Base>
02345 inline bool
02346 operator>=(const _CharT* __lhs,
02347 const __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02348 { return __rhs.compare(__lhs) <= 0; }
02349
02350
02351
02352
02353
02354
02355
02356
02357 template<typename _CharT, typename _Traits, typename _Alloc,
02358 template <typename, typename, typename> class _Base>
02359 inline void
02360 swap(__versa_string<_CharT, _Traits, _Alloc, _Base>& __lhs,
02361 __versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
02362 { __lhs.swap(__rhs); }
02363
02364 _GLIBCXX_END_NAMESPACE
02365
02366 _GLIBCXX_BEGIN_NAMESPACE(std)
02367
02368
02369
02370
02371
02372
02373
02374
02375
02376
02377
02378
02379
02380 template<typename _CharT, typename _Traits, typename _Alloc,
02381 template <typename, typename, typename> class _Base>
02382 basic_istream<_CharT, _Traits>&
02383 operator>>(basic_istream<_CharT, _Traits>& __is,
02384 __gnu_cxx::__versa_string<_CharT, _Traits,
02385 _Alloc, _Base>& __str);
02386
02387
02388
02389
02390
02391
02392
02393
02394
02395
02396 template<typename _CharT, typename _Traits, typename _Alloc,
02397 template <typename, typename, typename> class _Base>
02398 inline basic_ostream<_CharT, _Traits>&
02399 operator<<(basic_ostream<_CharT, _Traits>& __os,
02400 const __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc,
02401 _Base>& __str)
02402 {
02403
02404
02405 return __ostream_insert(__os, __str.data(), __str.size());
02406 }
02407
02408
02409
02410
02411
02412
02413
02414
02415
02416
02417
02418
02419
02420
02421
02422 template<typename _CharT, typename _Traits, typename _Alloc,
02423 template <typename, typename, typename> class _Base>
02424 basic_istream<_CharT, _Traits>&
02425 getline(basic_istream<_CharT, _Traits>& __is,
02426 __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str,
02427 _CharT __delim);
02428
02429
02430
02431
02432
02433
02434
02435
02436
02437
02438
02439
02440
02441
02442 template<typename _CharT, typename _Traits, typename _Alloc,
02443 template <typename, typename, typename> class _Base>
02444 inline basic_istream<_CharT, _Traits>&
02445 getline(basic_istream<_CharT, _Traits>& __is,
02446 __gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str)
02447 { return getline(__is, __str, __is.widen('\n')); }
02448
02449 _GLIBCXX_END_NAMESPACE
02450
02451 #if (defined(__GXX_EXPERIMENTAL_CXX0X__) && defined(_GLIBCXX_USE_C99))
02452
02453 #include <ext/string_conversions.h>
02454
02455 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
02456
02457
02458 inline int
02459 stoi(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
02460 { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
02461 __idx, __base); }
02462
02463 inline long
02464 stol(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
02465 { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
02466 __idx, __base); }
02467
02468 inline unsigned long
02469 stoul(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
02470 { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
02471 __idx, __base); }
02472
02473 inline long long
02474 stoll(const __vstring& __str, std::size_t* __idx = 0, int __base = 10)
02475 { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
02476 __idx, __base); }
02477
02478 inline unsigned long long
02479 stoull(const __vstring& __str, std::size_t* __idx, int __base = 10)
02480 { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
02481 __idx, __base); }
02482
02483
02484 inline float
02485 stof(const __vstring& __str, std::size_t* __idx = 0)
02486 { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
02487
02488 inline double
02489 stod(const __vstring& __str, std::size_t* __idx = 0)
02490 { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
02491
02492 inline long double
02493 stold(const __vstring& __str, std::size_t* __idx = 0)
02494 { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
02495
02496
02497
02498
02499 inline __vstring
02500 to_string(int __val)
02501 { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, 4 * sizeof(int),
02502 "%d", __val); }
02503
02504 inline __vstring
02505 to_string(unsigned __val)
02506 { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
02507 4 * sizeof(unsigned),
02508 "%u", __val); }
02509
02510 inline __vstring
02511 to_string(long __val)
02512 { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
02513 4 * sizeof(long),
02514 "%ld", __val); }
02515
02516 inline __vstring
02517 to_string(unsigned long __val)
02518 { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
02519 4 * sizeof(unsigned long),
02520 "%lu", __val); }
02521
02522
02523 inline __vstring
02524 to_string(long long __val)
02525 { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
02526 4 * sizeof(long long),
02527 "%lld", __val); }
02528
02529 inline __vstring
02530 to_string(unsigned long long __val)
02531 { return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf,
02532 4 * sizeof(unsigned long long),
02533 "%llu", __val); }
02534
02535 inline __vstring
02536 to_string(float __val)
02537 {
02538 const int __n = __numeric_traits<float>::__max_exponent10 + 20;
02539 return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, __n,
02540 "%f", __val);
02541 }
02542
02543 inline __vstring
02544 to_string(double __val)
02545 {
02546 const int __n = __numeric_traits<double>::__max_exponent10 + 20;
02547 return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, __n,
02548 "%f", __val);
02549 }
02550
02551 inline __vstring
02552 to_string(long double __val)
02553 {
02554 const int __n = __numeric_traits<long double>::__max_exponent10 + 20;
02555 return __gnu_cxx::__to_xstring<__vstring>(&std::vsnprintf, __n,
02556 "%Lf", __val);
02557 }
02558
02559 #ifdef _GLIBCXX_USE_WCHAR_T
02560 inline int
02561 stoi(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
02562 { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
02563 __idx, __base); }
02564
02565 inline long
02566 stol(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
02567 { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
02568 __idx, __base); }
02569
02570 inline unsigned long
02571 stoul(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
02572 { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
02573 __idx, __base); }
02574
02575 inline long long
02576 stoll(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
02577 { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
02578 __idx, __base); }
02579
02580 inline unsigned long long
02581 stoull(const __wvstring& __str, std::size_t* __idx = 0, int __base = 10)
02582 { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
02583 __idx, __base); }
02584
02585
02586 inline float
02587 stof(const __wvstring& __str, std::size_t* __idx = 0)
02588 { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
02589
02590 inline double
02591 stod(const __wvstring& __str, std::size_t* __idx = 0)
02592 { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
02593
02594 inline long double
02595 stold(const __wvstring& __str, std::size_t* __idx = 0)
02596 { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
02597
02598 #ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF
02599
02600 inline __wvstring
02601 to_wstring(int __val)
02602 { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02603 4 * sizeof(int),
02604 L"%d", __val); }
02605
02606 inline __wvstring
02607 to_wstring(unsigned __val)
02608 { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02609 4 * sizeof(unsigned),
02610 L"%u", __val); }
02611
02612 inline __wvstring
02613 to_wstring(long __val)
02614 { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02615 4 * sizeof(long),
02616 L"%ld", __val); }
02617
02618 inline __wvstring
02619 to_wstring(unsigned long __val)
02620 { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02621 4 * sizeof(unsigned long),
02622 L"%lu", __val); }
02623
02624 inline __wvstring
02625 to_wstring(long long __val)
02626 { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02627 4 * sizeof(long long),
02628 L"%lld", __val); }
02629
02630 inline __wvstring
02631 to_wstring(unsigned long long __val)
02632 { return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf,
02633 4 * sizeof(unsigned long long),
02634 L"%llu", __val); }
02635
02636 inline __wvstring
02637 to_wstring(float __val)
02638 {
02639 const int __n = __numeric_traits<float>::__max_exponent10 + 20;
02640 return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf, __n,
02641 L"%f", __val);
02642 }
02643
02644 inline __wvstring
02645 to_wstring(double __val)
02646 {
02647 const int __n = __numeric_traits<double>::__max_exponent10 + 20;
02648 return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf, __n,
02649 L"%f", __val);
02650 }
02651
02652 inline __wvstring
02653 to_wstring(long double __val)
02654 {
02655 const int __n = __numeric_traits<long double>::__max_exponent10 + 20;
02656 return __gnu_cxx::__to_xstring<__wvstring>(&std::vswprintf, __n,
02657 L"%Lf", __val);
02658 }
02659 #endif
02660 #endif
02661
02662 _GLIBCXX_END_NAMESPACE
02663
02664 #endif
02665
02666 #ifndef _GLIBCXX_EXPORT_TEMPLATE
02667 # include "vstring.tcc"
02668 #endif
02669
02670 #endif