1 /* 2 * Copyright (c) 1997-1999 3 * Silicon Graphics Computer Systems, Inc. 4 * 5 * Copyright (c) 1999 6 * Boris Fomitchev 7 * 8 * This material is provided "as is", with absolutely no warranty expressed 9 * or implied. Any use is at your own risk. 10 * 11 * Permission to use or copy this software for any purpose is hereby granted 12 * without fee, provided the above notices are retained on all copies. 13 * Permission to modify the code and to distribute modified code is granted, 14 * provided the above notices are retained, and a notice that the code was 15 * modified is included with the above copyright notice. 16 * 17 */ 18 19 #ifndef _STLP_INTERNAL_STRING_H 20 #define _STLP_INTERNAL_STRING_H 21 22 #ifndef _STLP_INTERNAL_ALLOC_H 23 # include <stl/_alloc.h> 24 #endif 25 26 #ifndef _STLP_STRING_FWD_H 27 # include <stl/_string_fwd.h> 28 #endif 29 30 #ifndef _STLP_INTERNAL_FUNCTION_BASE_H 31 # include <stl/_function_base.h> 32 #endif 33 34 #ifndef _STLP_INTERNAL_ALGOBASE_H 35 # include <stl/_algobase.h> 36 #endif 37 38 #ifndef _STLP_INTERNAL_ITERATOR_H 39 # include <stl/_iterator.h> 40 #endif 41 42 #ifndef _STLP_INTERNAL_UNINITIALIZED_H 43 # include <stl/_uninitialized.h> 44 #endif 45 46 #if defined (_STLP_USE_TEMPLATE_EXPRESSION) 47 # include <stl/_string_sum.h> 48 #endif /* _STLP_USE_TEMPLATE_EXPRESSION */ 49 50 #if defined (__MWERKS__) && ! defined (_STLP_USE_OWN_NAMESPACE) 51 52 // MSL implementation classes expect to see the definition of streampos 53 // when this header is included. We expect this to be fixed in later MSL 54 // implementations 55 # if !defined( __MSL_CPP__ ) || __MSL_CPP__ < 0x4105 56 # include <stl/msl_string.h> 57 # endif 58 #endif // __MWERKS__ 59 60 /* 61 * Standard C++ string class. This class has performance 62 * characteristics very much like vector<>, meaning, for example, that 63 * it does not perform reference-count or copy-on-write, and that 64 * concatenation of two strings is an O(N) operation. 65 66 * There are three reasons why basic_string is not identical to 67 * vector. 68 * First, basic_string always stores a null character at the end; 69 * this makes it possible for c_str to be a fast operation. 70 * Second, the C++ standard requires basic_string to copy elements 71 * using char_traits<>::assign, char_traits<>::copy, and 72 * char_traits<>::move. This means that all of vector<>'s low-level 73 * operations must be rewritten. Third, basic_string<> has a lot of 74 * extra functions in its interface that are convenient but, strictly 75 * speaking, redundant. 76 */ 77 78 #include <stl/_string_base.h> 79 80 _STLP_BEGIN_NAMESPACE 81 82 // ------------------------------------------------------------ 83 // Class basic_string. 84 85 // Class invariants: 86 // (1) [start, finish) is a valid range. 87 // (2) Each iterator in [start, finish) points to a valid object 88 // of type value_type. 89 // (3) *finish is a valid object of type value_type; when 90 // value_type is not a POD it is value_type(). 91 // (4) [finish + 1, end_of_storage) is a valid range. 92 // (5) Each iterator in [finish + 1, end_of_storage) points to 93 // unininitialized memory. 94 95 // Note one important consequence: a string of length n must manage 96 // a block of memory whose size is at least n + 1. 97 98 _STLP_MOVE_TO_PRIV_NAMESPACE 99 struct _String_reserve_t {}; 100 _STLP_MOVE_TO_STD_NAMESPACE 101 102 #if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 103 # define basic_string _STLP_NO_MEM_T_NAME(str) 104 #elif defined (_STLP_DEBUG) 105 # define basic_string _STLP_NON_DBG_NAME(str) 106 #endif 107 108 #if defined (basic_string) 109 _STLP_MOVE_TO_PRIV_NAMESPACE 110 #endif 111 112 #if defined (__DMC__) 113 # define _STLP_PRIVATE public 114 #elif defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 115 # define _STLP_PRIVATE protected 116 #else 117 # define _STLP_PRIVATE private 118 #endif 119 120 template <class _CharT, class _Traits, class _Alloc> 121 class basic_string : _STLP_PRIVATE _STLP_PRIV _String_base<_CharT,_Alloc> 122 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (basic_string) 123 , public __stlport_class<basic_string<_CharT, _Traits, _Alloc> > 124 #endif 125 { 126 _STLP_PRIVATE: // Private members inherited from base. 127 typedef _STLP_PRIV _String_base<_CharT,_Alloc> _Base; 128 typedef basic_string<_CharT, _Traits, _Alloc> _Self; 129 130 public: 131 typedef _CharT value_type; 132 typedef _Traits traits_type; 133 134 typedef value_type* pointer; 135 typedef const value_type* const_pointer; 136 typedef value_type& reference; 137 typedef const value_type& const_reference; 138 typedef typename _Base::size_type size_type; 139 typedef ptrdiff_t difference_type; 140 typedef random_access_iterator_tag _Iterator_category; 141 142 typedef const value_type* const_iterator; 143 typedef value_type* iterator; 144 145 _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS; 146 147 #include <stl/_string_npos.h> 148 149 typedef _STLP_PRIV _String_reserve_t _Reserve_t; 150 151 public: // Constructor, destructor, assignment. 152 typedef typename _Base::allocator_type allocator_type; 153 154 allocator_type get_allocator() const 155 { return _STLP_CONVERT_ALLOCATOR((const allocator_type&)this->_M_start_of_storage, _CharT); } 156 157 #if !defined (_STLP_DONT_SUP_DFLT_PARAM) 158 explicit basic_string(const allocator_type& __a = allocator_type()) 159 #else 160 basic_string() 161 : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), _Base::_DEFAULT_SIZE) 162 { _M_terminate_string(); } 163 explicit basic_string(const allocator_type& __a) 164 #endif 165 : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, _Base::_DEFAULT_SIZE) 166 { _M_terminate_string(); } 167 168 #if !defined (_STLP_DONT_SUP_DFLT_PARAM) 169 basic_string(_Reserve_t, size_t __n, 170 const allocator_type& __a = allocator_type()) 171 #else 172 basic_string(_Reserve_t, size_t __n) 173 : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), __n + 1) 174 { _M_terminate_string(); } 175 basic_string(_Reserve_t, size_t __n, const allocator_type& __a) 176 #endif 177 : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, __n + 1) 178 { _M_terminate_string(); } 179 180 basic_string(const _Self&); 181 182 #if !defined (_STLP_DONT_SUP_DFLT_PARAM) 183 basic_string(const _Self& __s, size_type __pos, size_type __n = npos, 184 const allocator_type& __a = allocator_type()) 185 #else 186 basic_string(const _Self& __s, size_type __pos) 187 : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) { 188 if (__pos > __s.size()) 189 this->_M_throw_out_of_range(); 190 else 191 _M_range_initialize(__s._M_Start() + __pos, __s._M_Finish()); 192 } 193 basic_string(const _Self& __s, size_type __pos, size_type __n) 194 : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) { 195 if (__pos > __s.size()) 196 this->_M_throw_out_of_range(); 197 else 198 _M_range_initialize(__s._M_Start() + __pos, 199 __s._M_Start() + __pos + (min) (__n, __s.size() - __pos)); 200 } 201 basic_string(const _Self& __s, size_type __pos, size_type __n, 202 const allocator_type& __a) 203 #endif 204 : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) { 205 if (__pos > __s.size()) 206 this->_M_throw_out_of_range(); 207 else 208 _M_range_initialize(__s._M_Start() + __pos, 209 __s._M_Start() + __pos + (min) (__n, __s.size() - __pos)); 210 } 211 212 #if !defined (_STLP_DONT_SUP_DFLT_PARAM) 213 basic_string(const _CharT* __s, size_type __n, 214 const allocator_type& __a = allocator_type()) 215 #else 216 basic_string(const _CharT* __s, size_type __n) 217 : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) { 218 _STLP_FIX_LITERAL_BUG(__s) 219 _M_range_initialize(__s, __s + __n); 220 } 221 basic_string(const _CharT* __s, size_type __n, const allocator_type& __a) 222 #endif 223 : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) { 224 _STLP_FIX_LITERAL_BUG(__s) 225 _M_range_initialize(__s, __s + __n); 226 } 227 228 #if !defined (_STLP_DONT_SUP_DFLT_PARAM) 229 basic_string(const _CharT* __s, 230 const allocator_type& __a = allocator_type()); 231 #else 232 basic_string(const _CharT* __s); 233 basic_string(const _CharT* __s, const allocator_type& __a); 234 #endif 235 236 #if !defined (_STLP_DONT_SUP_DFLT_PARAM) 237 basic_string(size_type __n, _CharT __c, 238 const allocator_type& __a = allocator_type()) 239 #else 240 basic_string(size_type __n, _CharT __c) 241 : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), __n + 1) { 242 this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c); 243 _M_terminate_string(); 244 } 245 basic_string(size_type __n, _CharT __c, const allocator_type& __a) 246 #endif 247 : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, __n + 1) { 248 this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c); 249 _M_terminate_string(); 250 } 251 252 #if !defined (_STLP_NO_MOVE_SEMANTIC) 253 basic_string(__move_source<_Self> src) 254 : _STLP_PRIV _String_base<_CharT,_Alloc>(__move_source<_Base>(src.get())) {} 255 #endif 256 257 // Check to see if _InputIterator is an integer type. If so, then 258 // it can't be an iterator. 259 #if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 260 template <class _InputIterator> 261 basic_string(_InputIterator __f, _InputIterator __l, 262 const allocator_type & __a _STLP_ALLOCATOR_TYPE_DFL) 263 : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) { 264 typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; 265 _M_initialize_dispatch(__f, __l, _Integral()); 266 } 267 # if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) 268 template <class _InputIterator> 269 basic_string(_InputIterator __f, _InputIterator __l) 270 : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) { 271 typedef typename _IsIntegral<_InputIterator>::_Ret _Integral; 272 _M_initialize_dispatch(__f, __l, _Integral()); 273 } 274 # endif 275 #else 276 # if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 277 basic_string(const _CharT* __f, const _CharT* __l, 278 const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL) 279 : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) { 280 _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) 281 _M_range_initialize(__f, __l); 282 } 283 # if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) 284 basic_string(const _CharT* __f, const _CharT* __l) 285 : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) { 286 _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) 287 _M_range_initialize(__f, __l); 288 } 289 # endif 290 # endif 291 # if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 292 /* We need an additionnal constructor to build an empty string without 293 * any allocation or termination char*/ 294 protected: 295 struct _CalledFromWorkaround_t {}; 296 basic_string(_CalledFromWorkaround_t, const allocator_type &__a) 297 : _String_base<_CharT,_Alloc>(__a) {} 298 # endif 299 #endif 300 301 _STLP_PRIVATE: 302 size_type _M_compute_next_size(size_type __n) { 303 const size_type __size = size(); 304 if (__n > max_size() - __size) 305 this->_M_throw_length_error(); 306 size_type __len = __size + (max)(__n, __size) + 1; 307 if (__len > max_size() || __len < __size) 308 __len = max_size(); // overflow 309 return __len; 310 } 311 312 template <class _InputIter> 313 void _M_range_initialize(_InputIter __f, _InputIter __l, 314 const input_iterator_tag &__tag) { 315 this->_M_allocate_block(); 316 _M_construct_null(this->_M_Finish()); 317 _M_appendT(__f, __l, __tag); 318 } 319 320 template <class _ForwardIter> 321 void _M_range_initialize(_ForwardIter __f, _ForwardIter __l, 322 const forward_iterator_tag &) { 323 difference_type __n = _STLP_STD::distance(__f, __l); 324 this->_M_allocate_block(__n + 1); 325 this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start()); 326 this->_M_terminate_string(); 327 } 328 329 template <class _InputIter> 330 void _M_range_initializeT(_InputIter __f, _InputIter __l) { 331 _M_range_initialize(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); 332 } 333 334 template <class _Integer> 335 void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/) { 336 this->_M_allocate_block(__n + 1); 337 this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __x); 338 this->_M_terminate_string(); 339 } 340 341 template <class _InputIter> 342 void _M_initialize_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) { 343 _M_range_initializeT(__f, __l); 344 } 345 346 public: 347 _Self& operator=(const _Self& __s) { 348 if (&__s != this) 349 _M_assign(__s._M_Start(), __s._M_Finish()); 350 return *this; 351 } 352 353 _Self& operator=(const _CharT* __s) { 354 _STLP_FIX_LITERAL_BUG(__s) 355 return _M_assign(__s, __s + traits_type::length(__s)); 356 } 357 358 _Self& operator=(_CharT __c) 359 { return assign(__STATIC_CAST(size_type,1), __c); } 360 361 private: 362 static _CharT _STLP_CALL _M_null() 363 { return _STLP_DEFAULT_CONSTRUCTED(_CharT); } 364 365 _STLP_PRIVATE: // Helper functions used by constructors 366 // and elsewhere. 367 void _M_construct_null(_CharT* __p) const 368 { _STLP_STD::_Construct(__p); } 369 void _M_terminate_string() 370 { _M_construct_null(this->_M_Finish()); } 371 bool _M_inside(const _CharT* __s) const { 372 _STLP_FIX_LITERAL_BUG(__s) 373 return (__s >= this->_M_Start()) && (__s < this->_M_Finish()); 374 } 375 376 void _M_range_initialize(const _CharT* __f, const _CharT* __l) { 377 _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) 378 ptrdiff_t __n = __l - __f; 379 this->_M_allocate_block(__n + 1); 380 this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start()); 381 _M_terminate_string(); 382 } 383 384 public: // Iterators. 385 iterator begin() { return this->_M_Start(); } 386 iterator end() { return this->_M_Finish(); } 387 const_iterator begin() const { return this->_M_Start(); } 388 const_iterator end() const { return this->_M_Finish(); } 389 390 reverse_iterator rbegin() 391 { return reverse_iterator(this->_M_Finish()); } 392 reverse_iterator rend() 393 { return reverse_iterator(this->_M_Start()); } 394 const_reverse_iterator rbegin() const 395 { return const_reverse_iterator(this->_M_Finish()); } 396 const_reverse_iterator rend() const 397 { return const_reverse_iterator(this->_M_Start()); } 398 399 public: // Size, capacity, etc. 400 size_type size() const { return this->_M_Finish() - this->_M_Start(); } 401 size_type length() const { return size(); } 402 size_type max_size() const { return _Base::max_size(); } 403 404 void resize(size_type __n, _CharT __c) { 405 if (__n <= size()) 406 erase(begin() + __n, end()); 407 else 408 append(__n - size(), __c); 409 } 410 411 void resize(size_type __n) { resize(__n, _M_null()); } 412 413 private: 414 void _M_reserve(size_type); 415 public: 416 void reserve(size_type = 0); 417 418 size_type capacity() const 419 { return this->_M_capacity() - 1; } 420 421 void clear() { 422 if (!empty()) { 423 _Traits::assign(*(this->_M_Start()), _M_null()); 424 this->_M_finish = this->_M_Start(); 425 } 426 } 427 428 bool empty() const { return this->_M_Start() == this->_M_Finish(); } 429 430 public: // Element access. 431 432 const_reference operator[](size_type __n) const 433 { return *(this->_M_Start() + __n); } 434 reference operator[](size_type __n) 435 { return *(this->_M_Start() + __n); } 436 437 const_reference at(size_type __n) const { 438 if (__n >= size()) 439 this->_M_throw_out_of_range(); 440 return *(this->_M_Start() + __n); 441 } 442 443 reference at(size_type __n) { 444 if (__n >= size()) 445 this->_M_throw_out_of_range(); 446 return *(this->_M_Start() + __n); 447 } 448 449 public: // Append, operator+=, push_back. 450 451 _Self& operator+=(const _Self& __s) { return append(__s); } 452 _Self& operator+=(const _CharT* __s) { _STLP_FIX_LITERAL_BUG(__s) return append(__s); } 453 _Self& operator+=(_CharT __c) { push_back(__c); return *this; } 454 455 private: 456 _Self& _M_append(const _CharT* __first, const _CharT* __last); 457 458 #if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 459 template <class _InputIter> 460 _Self& _M_appendT(_InputIter __first, _InputIter __last, 461 const input_iterator_tag &) { 462 for ( ; __first != __last ; ++__first) 463 push_back(*__first); 464 return *this; 465 } 466 467 template <class _ForwardIter> 468 _Self& _M_appendT(_ForwardIter __first, _ForwardIter __last, 469 const forward_iterator_tag &) { 470 if (__first != __last) { 471 size_type __n = __STATIC_CAST(size_type, _STLP_STD::distance(__first, __last)); 472 if (__n >= this->_M_rest()) { 473 size_type __len = _M_compute_next_size(__n); 474 pointer __new_start = this->_M_start_of_storage.allocate(__len, __len); 475 pointer __new_finish = uninitialized_copy(this->_M_Start(), this->_M_Finish(), __new_start); 476 __new_finish = uninitialized_copy(__first, __last, __new_finish); 477 _M_construct_null(__new_finish); 478 this->_M_deallocate_block(); 479 this->_M_reset(__new_start, __new_finish, __new_start + __len); 480 } 481 else { 482 _Traits::assign(*this->_M_finish, *__first++); 483 uninitialized_copy(__first, __last, this->_M_Finish() + 1); 484 _M_construct_null(this->_M_Finish() + __n); 485 this->_M_finish += __n; 486 } 487 } 488 return *this; 489 } 490 491 template <class _Integer> 492 _Self& _M_append_dispatch(_Integer __n, _Integer __x, const __true_type& /*Integral*/) 493 { return append((size_type) __n, (_CharT) __x); } 494 495 template <class _InputIter> 496 _Self& _M_append_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*Integral*/) 497 { return _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); } 498 499 public: 500 // Check to see if _InputIterator is an integer type. If so, then 501 // it can't be an iterator. 502 template <class _InputIter> 503 _Self& append(_InputIter __first, _InputIter __last) { 504 typedef typename _IsIntegral<_InputIter>::_Ret _Integral; 505 return _M_append_dispatch(__first, __last, _Integral()); 506 } 507 #else 508 public: 509 _Self& append(const _CharT* __first, const _CharT* __last) { 510 _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) 511 return _M_append(__first, __last); 512 } 513 #endif 514 515 public: 516 _Self& append(const _Self& __s) 517 { return _M_append(__s._M_Start(), __s._M_Finish()); } 518 519 _Self& append(const _Self& __s, 520 size_type __pos, size_type __n) { 521 if (__pos > __s.size()) 522 this->_M_throw_out_of_range(); 523 return _M_append(__s._M_Start() + __pos, 524 __s._M_Start() + __pos + (min) (__n, __s.size() - __pos)); 525 } 526 527 _Self& append(const _CharT* __s, size_type __n) 528 { _STLP_FIX_LITERAL_BUG(__s) return _M_append(__s, __s+__n); } 529 _Self& append(const _CharT* __s) 530 { _STLP_FIX_LITERAL_BUG(__s) return _M_append(__s, __s + traits_type::length(__s)); } 531 _Self& append(size_type __n, _CharT __c); 532 533 public: 534 void push_back(_CharT __c) { 535 if (this->_M_rest() == 1 ) 536 _M_reserve(_M_compute_next_size(1)); 537 _M_construct_null(this->_M_Finish() + 1); 538 _Traits::assign(*(this->_M_Finish()), __c); 539 ++this->_M_finish; 540 } 541 542 void pop_back() { 543 _Traits::assign(*(this->_M_Finish() - 1), _M_null()); 544 --this->_M_finish; 545 } 546 547 public: // Assign 548 _Self& assign(const _Self& __s) 549 { return _M_assign(__s._M_Start(), __s._M_Finish()); } 550 551 _Self& assign(const _Self& __s, 552 size_type __pos, size_type __n) { 553 if (__pos > __s.size()) 554 this->_M_throw_out_of_range(); 555 return _M_assign(__s._M_Start() + __pos, 556 __s._M_Start() + __pos + (min) (__n, __s.size() - __pos)); 557 } 558 559 _Self& assign(const _CharT* __s, size_type __n) 560 { _STLP_FIX_LITERAL_BUG(__s) return _M_assign(__s, __s + __n); } 561 562 _Self& assign(const _CharT* __s) 563 { _STLP_FIX_LITERAL_BUG(__s) return _M_assign(__s, __s + _Traits::length(__s)); } 564 565 _Self& assign(size_type __n, _CharT __c); 566 567 private: 568 _Self& _M_assign(const _CharT* __f, const _CharT* __l); 569 570 #if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 571 // Helper functions for assign. 572 template <class _Integer> 573 _Self& _M_assign_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/) 574 { return assign((size_type) __n, (_CharT) __x); } 575 576 template <class _InputIter> 577 _Self& _M_assign_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) { 578 pointer __cur = this->_M_Start(); 579 while (__f != __l && __cur != this->_M_Finish()) { 580 _Traits::assign(*__cur, *__f); 581 ++__f; 582 ++__cur; 583 } 584 if (__f == __l) 585 erase(__cur, this->end()); 586 else 587 _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); 588 return *this; 589 } 590 591 public: 592 // Check to see if _InputIterator is an integer type. If so, then 593 // it can't be an iterator. 594 template <class _InputIter> 595 _Self& assign(_InputIter __first, _InputIter __last) { 596 typedef typename _IsIntegral<_InputIter>::_Ret _Integral; 597 return _M_assign_dispatch(__first, __last, _Integral()); 598 } 599 #else 600 public: 601 _Self& assign(const _CharT* __f, const _CharT* __l) { 602 _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) 603 return _M_assign(__f, __l); 604 } 605 #endif 606 607 public: // Insert 608 _Self& insert(size_type __pos, const _Self& __s) { 609 if (__pos > size()) 610 this->_M_throw_out_of_range(); 611 if (__s.size() > max_size() - size()) 612 this->_M_throw_length_error(); 613 _M_insert(begin() + __pos, __s._M_Start(), __s._M_Finish(), &__s == this); 614 return *this; 615 } 616 617 _Self& insert(size_type __pos, const _Self& __s, 618 size_type __beg, size_type __n) { 619 if (__pos > size() || __beg > __s.size()) 620 this->_M_throw_out_of_range(); 621 size_type __len = (min) (__n, __s.size() - __beg); 622 if (__len > max_size() - size()) 623 this->_M_throw_length_error(); 624 _M_insert(begin() + __pos, 625 __s._M_Start() + __beg, __s._M_Start() + __beg + __len, &__s == this); 626 return *this; 627 } 628 _Self& insert(size_type __pos, const _CharT* __s, size_type __n) { 629 _STLP_FIX_LITERAL_BUG(__s) 630 if (__pos > size()) 631 this->_M_throw_out_of_range(); 632 if (__n > max_size() - size()) 633 this->_M_throw_length_error(); 634 _M_insert(begin() + __pos, __s, __s + __n, _M_inside(__s)); 635 return *this; 636 } 637 638 _Self& insert(size_type __pos, const _CharT* __s) { 639 _STLP_FIX_LITERAL_BUG(__s) 640 if (__pos > size()) 641 this->_M_throw_out_of_range(); 642 size_type __len = _Traits::length(__s); 643 if (__len > max_size() - size()) 644 this->_M_throw_length_error(); 645 _M_insert(this->_M_Start() + __pos, __s, __s + __len, _M_inside(__s)); 646 return *this; 647 } 648 649 _Self& insert(size_type __pos, size_type __n, _CharT __c) { 650 if (__pos > size()) 651 this->_M_throw_out_of_range(); 652 if (__n > max_size() - size()) 653 this->_M_throw_length_error(); 654 insert(begin() + __pos, __n, __c); 655 return *this; 656 } 657 658 iterator insert(iterator __p, _CharT __c) { 659 _STLP_FIX_LITERAL_BUG(__p) 660 if (__p == end()) { 661 push_back(__c); 662 return this->_M_Finish() - 1; 663 } 664 else 665 return _M_insert_aux(__p, __c); 666 } 667 668 void insert(iterator __p, size_t __n, _CharT __c); 669 670 _STLP_PRIVATE: // Helper functions for insert. 671 void _M_insert(iterator __p, const _CharT* __first, const _CharT* __last, bool __self_ref); 672 673 pointer _M_insert_aux(pointer, _CharT); 674 675 void _M_copy(const _CharT* __f, const _CharT* __l, _CharT* __res) { 676 _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) 677 _STLP_FIX_LITERAL_BUG(__res) 678 _Traits::copy(__res, __f, __l - __f); 679 } 680 681 void _M_move(const _CharT* __f, const _CharT* __l, _CharT* __res) { 682 _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) 683 _Traits::move(__res, __f, __l - __f); 684 } 685 686 #if defined (_STLP_MEMBER_TEMPLATES) 687 # if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 688 template <class _ForwardIter> 689 void _M_insert_overflow(iterator __pos, _ForwardIter __first, _ForwardIter __last, 690 size_type __n) { 691 size_type __len = _M_compute_next_size(__n); 692 pointer __new_start = this->_M_start_of_storage.allocate(__len, __len); 693 pointer __new_finish = uninitialized_copy(this->_M_Start(), __pos, __new_start); 694 __new_finish = uninitialized_copy(__first, __last, __new_finish); 695 __new_finish = uninitialized_copy(__pos, this->_M_Finish(), __new_finish); 696 _M_construct_null(__new_finish); 697 this->_M_deallocate_block(); 698 this->_M_reset(__new_start, __new_finish, __new_start + __len); 699 } 700 701 template <class _InputIter> 702 void _M_insertT(iterator __p, _InputIter __first, _InputIter __last, 703 const input_iterator_tag &) { 704 for ( ; __first != __last; ++__first) { 705 __p = insert(__p, *__first); 706 ++__p; 707 } 708 } 709 710 template <class _ForwardIter> 711 void _M_insertT(iterator __pos, _ForwardIter __first, _ForwardIter __last, 712 const forward_iterator_tag &) { 713 if (__first != __last) { 714 size_type __n = _STLP_STD::distance(__first, __last); 715 if (__n < this->_M_rest()) { 716 const size_type __elems_after = this->_M_finish - __pos; 717 if (__elems_after >= __n) { 718 uninitialized_copy((this->_M_Finish() - __n) + 1, this->_M_Finish() + 1, this->_M_Finish() + 1); 719 this->_M_finish += __n; 720 _Traits::move(__pos + __n, __pos, (__elems_after - __n) + 1); 721 _M_copyT(__first, __last, __pos); 722 } 723 else { 724 pointer __old_finish = this->_M_Finish(); 725 _ForwardIter __mid = __first; 726 _STLP_STD::advance(__mid, __elems_after + 1); 727 _STLP_STD::uninitialized_copy(__mid, __last, this->_M_Finish() + 1); 728 this->_M_finish += __n - __elems_after; 729 uninitialized_copy(__pos, __old_finish + 1, this->_M_Finish()); 730 this->_M_finish += __elems_after; 731 _M_copyT(__first, __mid, __pos); 732 } 733 } 734 else { 735 _M_insert_overflow(__pos, __first, __last, __n); 736 } 737 } 738 } 739 740 template <class _Integer> 741 void _M_insert_dispatch(iterator __p, _Integer __n, _Integer __x, 742 const __true_type& /*Integral*/) 743 { insert(__p, (size_type) __n, (_CharT) __x); } 744 745 template <class _InputIter> 746 void _M_insert_dispatch(iterator __p, _InputIter __first, _InputIter __last, 747 const __false_type& /*Integral*/) { 748 _STLP_FIX_LITERAL_BUG(__p) 749 /* We are forced to do a temporary string to avoid the self referencing issue. */ 750 const _Self __self(__first, __last, get_allocator()); 751 _M_insertT(__p, __self.begin(), __self.end(), forward_iterator_tag()); 752 } 753 754 template <class _InputIterator> 755 void _M_copyT(_InputIterator __first, _InputIterator __last, pointer __result) { 756 _STLP_FIX_LITERAL_BUG(__result) 757 for ( ; __first != __last; ++__first, ++__result) 758 _Traits::assign(*__result, *__first); 759 } 760 761 # if !defined (_STLP_NO_METHOD_SPECIALIZATION) 762 void _M_copyT(const _CharT* __f, const _CharT* __l, _CharT* __res) { 763 _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) 764 _STLP_FIX_LITERAL_BUG(__res) 765 _Traits::copy(__res, __f, __l - __f); 766 } 767 # endif 768 public: 769 // Check to see if _InputIterator is an integer type. If so, then 770 // it can't be an iterator. 771 template <class _InputIter> 772 void insert(iterator __p, _InputIter __first, _InputIter __last) { 773 typedef typename _IsIntegral<_InputIter>::_Ret _Integral; 774 _M_insert_dispatch(__p, __first, __last, _Integral()); 775 } 776 # endif 777 #endif 778 779 #if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION) 780 public: 781 void insert(iterator __p, const _CharT* __f, const _CharT* __l) { 782 _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) 783 _M_insert(__p, __f, __l, _M_inside(__f)); 784 } 785 #endif 786 787 public: // Erase. 788 _Self& erase(size_type __pos = 0, size_type __n = npos) { 789 if (__pos > size()) 790 this->_M_throw_out_of_range(); 791 erase(begin() + __pos, begin() + __pos + (min) (__n, size() - __pos)); 792 return *this; 793 } 794 795 iterator erase(iterator __pos) { 796 // The move includes the terminating _CharT(). 797 _Traits::move(__pos, __pos + 1, this->_M_Finish() - __pos); 798 --this->_M_finish; 799 return __pos; 800 } 801 802 iterator erase(iterator __first, iterator __last) { 803 if (__first != __last) { 804 // The move includes the terminating _CharT(). 805 traits_type::move(__first, __last, (this->_M_Finish() - __last) + 1); 806 this->_M_finish = this->_M_Finish() - (__last - __first); 807 } 808 return __first; 809 } 810 811 public: // Replace. (Conceptually equivalent 812 // to erase followed by insert.) 813 _Self& replace(size_type __pos, size_type __n, const _Self& __s) { 814 const size_type __size = size(); 815 if (__pos > __size) 816 this->_M_throw_out_of_range(); 817 const size_type __len = (min) (__n, __size - __pos); 818 if (__s.size() > max_size() - (__size - __len)) 819 this->_M_throw_length_error(); 820 return _M_replace(begin() + __pos, begin() + __pos + __len, 821 __s._M_Start(), __s._M_Finish(), &__s == this); 822 } 823 824 _Self& replace(size_type __pos1, size_type __n1, const _Self& __s, 825 size_type __pos2, size_type __n2) { 826 const size_type __size1 = size(); 827 const size_type __size2 = __s.size(); 828 if (__pos1 > __size1 || __pos2 > __size2) 829 this->_M_throw_out_of_range(); 830 const size_type __len1 = (min) (__n1, __size1 - __pos1); 831 const size_type __len2 = (min) (__n2, __size2 - __pos2); 832 if (__len2 > max_size() - (__size1 - __len1)) 833 this->_M_throw_length_error(); 834 return _M_replace(begin() + __pos1, begin() + __pos1 + __len1, 835 __s._M_Start() + __pos2, __s._M_Start() + __pos2 + __len2, &__s == this); 836 } 837 838 _Self& replace(size_type __pos, size_type __n1, 839 const _CharT* __s, size_type __n2) { 840 _STLP_FIX_LITERAL_BUG(__s) 841 const size_type __size = size(); 842 if (__pos > __size) 843 this->_M_throw_out_of_range(); 844 const size_type __len = (min) (__n1, __size - __pos); 845 if (__n2 > max_size() - (__size - __len)) 846 this->_M_throw_length_error(); 847 return _M_replace(begin() + __pos, begin() + __pos + __len, 848 __s, __s + __n2, _M_inside(__s)); 849 } 850 851 _Self& replace(size_type __pos, size_type __n1, const _CharT* __s) { 852 _STLP_FIX_LITERAL_BUG(__s) 853 return replace(__pos, __n1, __s, _Traits::length(__s)); 854 } 855 856 _Self& replace(size_type __pos, size_type __n1, 857 size_type __n2, _CharT __c) { 858 const size_type __size = size(); 859 if (__pos > __size) 860 this->_M_throw_out_of_range(); 861 const size_type __len = (min) (__n1, __size - __pos); 862 if (__n2 > max_size() - (__size - __len)) 863 this->_M_throw_length_error(); 864 return replace(begin() + __pos, begin() + __pos + __len, __n2, __c); 865 } 866 867 _Self& replace(iterator __first, iterator __last, const _Self& __s) { 868 _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) 869 return _M_replace(__first, __last, __s._M_Start(), __s._M_Finish(), &__s == this); 870 } 871 872 _Self& replace(iterator __first, iterator __last, 873 const _CharT* __s, size_type __n) { 874 _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) 875 _STLP_FIX_LITERAL_BUG(__s) 876 return _M_replace(__first, __last, __s, __s + __n, _M_inside(__s)); 877 } 878 879 _Self& replace(iterator __first, iterator __last, 880 const _CharT* __s) { 881 _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) 882 _STLP_FIX_LITERAL_BUG(__s) 883 return _M_replace(__first, __last, __s, __s + _Traits::length(__s), _M_inside(__s)); 884 } 885 886 _Self& replace(iterator __first, iterator __last, size_type __n, _CharT __c); 887 888 _STLP_PRIVATE: // Helper functions for replace. 889 _Self& _M_replace(iterator __first, iterator __last, 890 const _CharT* __f, const _CharT* __l, bool __self_ref); 891 892 #if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 893 template <class _Integer> 894 _Self& _M_replace_dispatch(iterator __first, iterator __last, 895 _Integer __n, _Integer __x, const __true_type& /*IsIntegral*/) { 896 _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last) 897 return replace(__first, __last, (size_type) __n, (_CharT) __x); 898 } 899 900 template <class _InputIter> 901 _Self& _M_replace_dispatch(iterator __first, iterator __last, 902 _InputIter __f, _InputIter __l, const __false_type& /*IsIntegral*/) { 903 _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last) 904 /* We are forced to do a temporary string to avoid the self referencing issue. */ 905 const _Self __self(__f, __l, get_allocator()); 906 return _M_replace(__first, __last, __self._M_Start(), __self._M_Finish(), false); 907 } 908 909 public: 910 // Check to see if _InputIter is an integer type. If so, then 911 // it can't be an iterator. 912 template <class _InputIter> 913 _Self& replace(iterator __first, iterator __last, 914 _InputIter __f, _InputIter __l) { 915 _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) 916 typedef typename _IsIntegral<_InputIter>::_Ret _Integral; 917 return _M_replace_dispatch(__first, __last, __f, __l, _Integral()); 918 } 919 #endif 920 921 #if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION) 922 public: 923 _Self& replace(iterator __first, iterator __last, 924 const _CharT* __f, const _CharT* __l) { 925 _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last) 926 _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) 927 return _M_replace(__first, __last, __f, __l, _M_inside(__f)); 928 } 929 #endif 930 931 public: // Other modifier member functions. 932 933 size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const { 934 _STLP_FIX_LITERAL_BUG(__s) 935 if (__pos > size()) 936 this->_M_throw_out_of_range(); 937 const size_type __len = (min) (__n, size() - __pos); 938 _Traits::copy(__s, this->_M_Start() + __pos, __len); 939 return __len; 940 } 941 942 void swap(_Self& __s) { this->_M_swap(__s); } 943 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) 944 void _M_swap_workaround(_Self& __x) { swap(__x); } 945 #endif 946 947 public: // Conversion to C string. 948 949 const _CharT* c_str() const { return this->_M_Start(); } 950 const _CharT* data() const { return this->_M_Start(); } 951 952 public: // find. 953 size_type find(const _Self& __s, size_type __pos = 0) const 954 { return find(__s._M_Start(), __pos, __s.size()); } 955 956 size_type find(const _CharT* __s, size_type __pos = 0) const 957 { _STLP_FIX_LITERAL_BUG(__s) return find(__s, __pos, _Traits::length(__s)); } 958 959 size_type find(const _CharT* __s, size_type __pos, size_type __n) const; 960 961 // WIE: Versant schema compiler 5.2.2 ICE workaround 962 size_type find(_CharT __c) const { return find(__c, 0); } 963 size_type find(_CharT __c, size_type __pos /* = 0 */) const; 964 965 public: // rfind. 966 size_type rfind(const _Self& __s, size_type __pos = npos) const 967 { return rfind(__s._M_Start(), __pos, __s.size()); } 968 969 size_type rfind(const _CharT* __s, size_type __pos = npos) const 970 { _STLP_FIX_LITERAL_BUG(__s) return rfind(__s, __pos, _Traits::length(__s)); } 971 972 size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const; 973 size_type rfind(_CharT __c, size_type __pos = npos) const; 974 975 public: // find_first_of 976 size_type find_first_of(const _Self& __s, size_type __pos = 0) const 977 { return find_first_of(__s._M_Start(), __pos, __s.size()); } 978 979 size_type find_first_of(const _CharT* __s, size_type __pos = 0) const 980 { _STLP_FIX_LITERAL_BUG(__s) return find_first_of(__s, __pos, _Traits::length(__s)); } 981 982 size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const; 983 984 size_type find_first_of(_CharT __c, size_type __pos = 0) const 985 { return find(__c, __pos); } 986 987 public: // find_last_of 988 size_type find_last_of(const _Self& __s, size_type __pos = npos) const 989 { return find_last_of(__s._M_Start(), __pos, __s.size()); } 990 991 size_type find_last_of(const _CharT* __s, size_type __pos = npos) const 992 { _STLP_FIX_LITERAL_BUG(__s) return find_last_of(__s, __pos, _Traits::length(__s)); } 993 994 size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const; 995 996 size_type find_last_of(_CharT __c, size_type __pos = npos) const 997 { return rfind(__c, __pos); } 998 999 public: // find_first_not_of 1000 size_type find_first_not_of(const _Self& __s, size_type __pos = 0) const 1001 { return find_first_not_of(__s._M_Start(), __pos, __s.size()); } 1002 1003 size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const 1004 { _STLP_FIX_LITERAL_BUG(__s) return find_first_not_of(__s, __pos, _Traits::length(__s)); } 1005 1006 size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const; 1007 1008 size_type find_first_not_of(_CharT __c, size_type __pos = 0) const; 1009 1010 public: // find_last_not_of 1011 size_type find_last_not_of(const _Self& __s, size_type __pos = npos) const 1012 { return find_last_not_of(__s._M_Start(), __pos, __s.size()); } 1013 1014 size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const 1015 { _STLP_FIX_LITERAL_BUG(__s) return find_last_not_of(__s, __pos, _Traits::length(__s)); } 1016 1017 size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const; 1018 1019 size_type find_last_not_of(_CharT __c, size_type __pos = npos) const; 1020 1021 public: // Substring. 1022 _Self substr(size_type __pos = 0, size_type __n = npos) const 1023 { return _Self(*this, __pos, __n, get_allocator()); } 1024 1025 public: // Compare 1026 int compare(const _Self& __s) const 1027 { return _M_compare(this->_M_Start(), this->_M_Finish(), __s._M_Start(), __s._M_Finish()); } 1028 1029 int compare(size_type __pos1, size_type __n1, const _Self& __s) const { 1030 if (__pos1 > size()) 1031 this->_M_throw_out_of_range(); 1032 return _M_compare(this->_M_Start() + __pos1, 1033 this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1), 1034 __s._M_Start(), __s._M_Finish()); 1035 } 1036 1037 int compare(size_type __pos1, size_type __n1, const _Self& __s, 1038 size_type __pos2, size_type __n2) const { 1039 if (__pos1 > size() || __pos2 > __s.size()) 1040 this->_M_throw_out_of_range(); 1041 return _M_compare(this->_M_Start() + __pos1, 1042 this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1), 1043 __s._M_Start() + __pos2, 1044 __s._M_Start() + __pos2 + (min) (__n2, __s.size() - __pos2)); 1045 } 1046 1047 int compare(const _CharT* __s) const { 1048 _STLP_FIX_LITERAL_BUG(__s) 1049 return _M_compare(this->_M_Start(), this->_M_Finish(), __s, __s + _Traits::length(__s)); 1050 } 1051 1052 int compare(size_type __pos1, size_type __n1, const _CharT* __s) const { 1053 _STLP_FIX_LITERAL_BUG(__s) 1054 if (__pos1 > size()) 1055 this->_M_throw_out_of_range(); 1056 return _M_compare(this->_M_Start() + __pos1, 1057 this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1), 1058 __s, __s + _Traits::length(__s)); 1059 } 1060 1061 int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const { 1062 _STLP_FIX_LITERAL_BUG(__s) 1063 if (__pos1 > size()) 1064 this->_M_throw_out_of_range(); 1065 return _M_compare(this->_M_Start() + __pos1, 1066 this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1), 1067 __s, __s + __n2); 1068 } 1069 1070 public: // Helper functions for compare. 1071 static int _STLP_CALL _M_compare(const _CharT* __f1, const _CharT* __l1, 1072 const _CharT* __f2, const _CharT* __l2) { 1073 const ptrdiff_t __n1 = __l1 - __f1; 1074 const ptrdiff_t __n2 = __l2 - __f2; 1075 const int cmp = _Traits::compare(__f1, __f2, (min) (__n1, __n2)); 1076 return cmp != 0 ? cmp : (__n1 < __n2 ? -1 : (__n1 > __n2 ? 1 : 0)); 1077 } 1078 #if defined (_STLP_USE_TEMPLATE_EXPRESSION) && !defined (_STLP_DEBUG) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 1079 # define _STLP_STRING_SUM_BASE(__reserve, __size, __alloc) _STLP_PRIV _String_base<_CharT,_Alloc>(__alloc, __size + 1) 1080 # include <stl/_string_sum_methods.h> 1081 # undef _STLP_STRING_SUM_BASE 1082 #endif 1083 }; 1084 1085 #undef _STLP_PRIVATE 1086 1087 #if defined (__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 96) 1088 template <class _CharT, class _Traits, class _Alloc> 1089 const size_t basic_string<_CharT, _Traits, _Alloc>::npos = ~(size_t) 0; 1090 #endif 1091 1092 #if defined (_STLP_USE_TEMPLATE_EXPORT) 1093 _STLP_EXPORT_TEMPLATE_CLASS basic_string<char, char_traits<char>, allocator<char> >; 1094 # if defined (_STLP_HAS_WCHAR_T) 1095 _STLP_EXPORT_TEMPLATE_CLASS basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >; 1096 # endif 1097 #endif /* _STLP_USE_TEMPLATE_EXPORT */ 1098 1099 #if defined (basic_string) 1100 _STLP_MOVE_TO_STD_NAMESPACE 1101 # undef basic_string 1102 #endif 1103 1104 _STLP_END_NAMESPACE 1105 1106 #if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 1107 # include <stl/_string_workaround.h> 1108 #endif 1109 1110 #if defined (_STLP_DEBUG) 1111 # include <stl/debug/_string.h> 1112 #endif 1113 1114 _STLP_BEGIN_NAMESPACE 1115 1116 // ------------------------------------------------------------ 1117 // Non-member functions. 1118 // Swap. 1119 #if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) 1120 template <class _CharT, class _Traits, class _Alloc> 1121 inline void _STLP_CALL 1122 swap(basic_string<_CharT,_Traits,_Alloc>& __x, 1123 basic_string<_CharT,_Traits,_Alloc>& __y) 1124 { __x.swap(__y); } 1125 #else 1126 inline void _STLP_CALL swap(string& __x, string& __y) 1127 { __x.swap(__y); } 1128 # if defined (_STLP_HAS_WCHAR_T) 1129 inline void _STLP_CALL swap(wstring& __x, wstring& __y) 1130 { __x.swap(__y); } 1131 # endif 1132 #endif 1133 1134 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC) 1135 template <class _CharT, class _Traits, class _Alloc> 1136 struct __move_traits<basic_string<_CharT, _Traits, _Alloc> > { 1137 typedef __true_type implemented; 1138 //Completness depends on the allocator: 1139 typedef typename __move_traits<_Alloc>::complete complete; 1140 }; 1141 /*#else 1142 * There is no need to specialize for string and wstring in this case 1143 * as the default __move_traits will already tell that string is movable 1144 * but not complete. We cannot define it as complete as nothing guaranty 1145 * that the STLport user hasn't specialized std::allocator for char or 1146 * wchar_t. 1147 */ 1148 #endif 1149 1150 _STLP_MOVE_TO_PRIV_NAMESPACE 1151 1152 template <class _CharT, class _Traits, class _Alloc> 1153 void _STLP_CALL _S_string_copy(const basic_string<_CharT,_Traits,_Alloc>& __s, 1154 _CharT* __buf, size_t __n); 1155 1156 #if defined(_STLP_USE_WIDE_INTERFACE) 1157 // A couple of functions to transfer between ASCII/Unicode 1158 wstring __ASCIIToWide(const char *ascii); 1159 string __WideToASCII(const wchar_t *wide); 1160 #endif 1161 1162 inline const char* _STLP_CALL 1163 __get_c_string(const string& __str) { return __str.c_str(); } 1164 1165 _STLP_MOVE_TO_STD_NAMESPACE 1166 1167 _STLP_END_NAMESPACE 1168 1169 #include <stl/_string_operators.h> 1170 1171 #if defined(_STLP_USE_NO_IOSTREAMS) || \ 1172 (defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)) 1173 # include <stl/_string.c> 1174 #endif 1175 1176 #endif /* _STLP_INTERNAL_STRING_H */ 1177 1178 /* 1179 * Local Variables: 1180 * mode:C++ 1181 * End: 1182 */ 1183
