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