libstdc++
debug/string
Go to the documentation of this file.
1 // Debugging string implementation -*- C++ -*-
2 
3 // Copyright (C) 2003, 2005, 2006, 2009
4 // Free Software Foundation, Inc.
5 //
6 // This file is part of the GNU ISO C++ Library. This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 3, or (at your option)
10 // any later version.
11 
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 
17 // Under Section 7 of GPL version 3, you are granted additional
18 // permissions described in the GCC Runtime Library Exception, version
19 // 3.1, as published by the Free Software Foundation.
20 
21 // You should have received a copy of the GNU General Public License and
22 // a copy of the GCC Runtime Library Exception along with this program;
23 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 // <http://www.gnu.org/licenses/>.
25 
26 /** @file debug/string
27  * This file is a GNU debug extension to the Standard C++ Library.
28  */
29 
30 #ifndef _GLIBCXX_DEBUG_STRING
31 #define _GLIBCXX_DEBUG_STRING 1
32 
33 #include <string>
34 #include <debug/safe_sequence.h>
35 #include <debug/safe_iterator.h>
36 
37 namespace __gnu_debug
38 {
39  template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
40  typename _Allocator = std::allocator<_CharT> >
41  class basic_string
42  : public std::basic_string<_CharT, _Traits, _Allocator>,
43  public __gnu_debug::_Safe_sequence<basic_string<_CharT, _Traits,
44  _Allocator> >
45  {
48 
49  public:
50  // types:
51  typedef _Traits traits_type;
52  typedef typename _Traits::char_type value_type;
53  typedef _Allocator allocator_type;
54  typedef typename _Base::size_type size_type;
55  typedef typename _Base::difference_type difference_type;
56  typedef typename _Base::reference reference;
57  typedef typename _Base::const_reference const_reference;
58  typedef typename _Base::pointer pointer;
59  typedef typename _Base::const_pointer const_pointer;
60 
62  iterator;
63  typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
64  basic_string> const_iterator;
65 
66  typedef std::reverse_iterator<iterator> reverse_iterator;
67  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
68 
69  using _Base::npos;
70 
71  // 21.3.1 construct/copy/destroy:
72  explicit basic_string(const _Allocator& __a = _Allocator())
73  : _Base(__a)
74  { }
75 
76  // Provides conversion from a release-mode string to a debug-mode string
77  basic_string(const _Base& __base) : _Base(__base), _Safe_base() { }
78 
79  // _GLIBCXX_RESOLVE_LIB_DEFECTS
80  // 42. string ctors specify wrong default allocator
81  basic_string(const basic_string& __str)
82  : _Base(__str, 0, _Base::npos, __str.get_allocator()), _Safe_base()
83  { }
84 
85  // _GLIBCXX_RESOLVE_LIB_DEFECTS
86  // 42. string ctors specify wrong default allocator
87  basic_string(const basic_string& __str, size_type __pos,
88  size_type __n = _Base::npos,
89  const _Allocator& __a = _Allocator())
90  : _Base(__str, __pos, __n, __a)
91  { }
92 
93  basic_string(const _CharT* __s, size_type __n,
94  const _Allocator& __a = _Allocator())
95  : _Base(__gnu_debug::__check_string(__s, __n), __n, __a)
96  { }
97 
98  basic_string(const _CharT* __s, const _Allocator& __a = _Allocator())
99  : _Base(__gnu_debug::__check_string(__s), __a)
100  { this->assign(__s); }
101 
102  basic_string(size_type __n, _CharT __c,
103  const _Allocator& __a = _Allocator())
104  : _Base(__n, __c, __a)
105  { }
106 
107  template<typename _InputIterator>
108  basic_string(_InputIterator __begin, _InputIterator __end,
109  const _Allocator& __a = _Allocator())
110  : _Base(__gnu_debug::__check_valid_range(__begin, __end), __end, __a)
111  { }
112 
113 #ifdef __GXX_EXPERIMENTAL_CXX0X__
114  basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
115  : _Base(__l, __a)
116  { }
117 #endif // __GXX_EXPERIMENTAL_CXX0X__
118 
119  ~basic_string() { }
120 
121  basic_string&
122  operator=(const basic_string& __str)
123  {
124  *static_cast<_Base*>(this) = __str;
125  this->_M_invalidate_all();
126  return *this;
127  }
128 
129  basic_string&
130  operator=(const _CharT* __s)
131  {
132  __glibcxx_check_string(__s);
133  *static_cast<_Base*>(this) = __s;
134  this->_M_invalidate_all();
135  return *this;
136  }
137 
138  basic_string&
139  operator=(_CharT __c)
140  {
141  *static_cast<_Base*>(this) = __c;
142  this->_M_invalidate_all();
143  return *this;
144  }
145 
146 #ifdef __GXX_EXPERIMENTAL_CXX0X__
147  basic_string&
148  operator=(initializer_list<_CharT> __l)
149  {
150  *static_cast<_Base*>(this) = __l;
151  this->_M_invalidate_all();
152  return *this;
153  }
154 #endif // __GXX_EXPERIMENTAL_CXX0X__
155 
156  // 21.3.2 iterators:
157  iterator
158  begin()
159  { return iterator(_Base::begin(), this); }
160 
161  const_iterator
162  begin() const
163  { return const_iterator(_Base::begin(), this); }
164 
165  iterator
166  end()
167  { return iterator(_Base::end(), this); }
168 
169  const_iterator
170  end() const
171  { return const_iterator(_Base::end(), this); }
172 
173  reverse_iterator
174  rbegin()
175  { return reverse_iterator(end()); }
176 
177  const_reverse_iterator
178  rbegin() const
179  { return const_reverse_iterator(end()); }
180 
181  reverse_iterator
182  rend()
183  { return reverse_iterator(begin()); }
184 
185  const_reverse_iterator
186  rend() const
187  { return const_reverse_iterator(begin()); }
188 
189  // 21.3.3 capacity:
190  using _Base::size;
191  using _Base::length;
192  using _Base::max_size;
193 
194  void
195  resize(size_type __n, _CharT __c)
196  {
197  _Base::resize(__n, __c);
198  this->_M_invalidate_all();
199  }
200 
201  void
202  resize(size_type __n)
203  { this->resize(__n, _CharT()); }
204 
205  using _Base::capacity;
206  using _Base::reserve;
207 
208  void
209  clear()
210  {
211  _Base::clear();
212  this->_M_invalidate_all();
213  }
214 
215  using _Base::empty;
216 
217  // 21.3.4 element access:
218  const_reference
219  operator[](size_type __pos) const
220  {
221  _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
222  _M_message(__gnu_debug::__msg_subscript_oob)
223  ._M_sequence(*this, "this")
224  ._M_integer(__pos, "__pos")
225  ._M_integer(this->size(), "size"));
226  return _M_base()[__pos];
227  }
228 
229  reference
230  operator[](size_type __pos)
231  {
232 #ifdef _GLIBCXX_DEBUG_PEDANTIC
233  __glibcxx_check_subscript(__pos);
234 #else
235  // as an extension v3 allows s[s.size()] when s is non-const.
236  _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
237  _M_message(__gnu_debug::__msg_subscript_oob)
238  ._M_sequence(*this, "this")
239  ._M_integer(__pos, "__pos")
240  ._M_integer(this->size(), "size"));
241 #endif
242  return _M_base()[__pos];
243  }
244 
245  using _Base::at;
246 
247  // 21.3.5 modifiers:
248  basic_string&
249  operator+=(const basic_string& __str)
250  {
251  _M_base() += __str;
252  this->_M_invalidate_all();
253  return *this;
254  }
255 
256  basic_string&
257  operator+=(const _CharT* __s)
258  {
259  __glibcxx_check_string(__s);
260  _M_base() += __s;
261  this->_M_invalidate_all();
262  return *this;
263  }
264 
265  basic_string&
266  operator+=(_CharT __c)
267  {
268  _M_base() += __c;
269  this->_M_invalidate_all();
270  return *this;
271  }
272 
273 #ifdef __GXX_EXPERIMENTAL_CXX0X__
274  basic_string&
275  operator+=(initializer_list<_CharT> __l)
276  {
277  _M_base() += __l;
278  this->_M_invalidate_all();
279  return *this;
280  }
281 #endif // __GXX_EXPERIMENTAL_CXX0X__
282 
283  basic_string&
284  append(const basic_string& __str)
285  {
286  _Base::append(__str);
287  this->_M_invalidate_all();
288  return *this;
289  }
290 
291  basic_string&
292  append(const basic_string& __str, size_type __pos, size_type __n)
293  {
294  _Base::append(__str, __pos, __n);
295  this->_M_invalidate_all();
296  return *this;
297  }
298 
299  basic_string&
300  append(const _CharT* __s, size_type __n)
301  {
302  __glibcxx_check_string_len(__s, __n);
303  _Base::append(__s, __n);
304  this->_M_invalidate_all();
305  return *this;
306  }
307 
308  basic_string&
309  append(const _CharT* __s)
310  {
311  __glibcxx_check_string(__s);
312  _Base::append(__s);
313  this->_M_invalidate_all();
314  return *this;
315  }
316 
317  basic_string&
318  append(size_type __n, _CharT __c)
319  {
320  _Base::append(__n, __c);
321  this->_M_invalidate_all();
322  return *this;
323  }
324 
325  template<typename _InputIterator>
326  basic_string&
327  append(_InputIterator __first, _InputIterator __last)
328  {
329  __glibcxx_check_valid_range(__first, __last);
330  _Base::append(__first, __last);
331  this->_M_invalidate_all();
332  return *this;
333  }
334 
335  // _GLIBCXX_RESOLVE_LIB_DEFECTS
336  // 7. string clause minor problems
337  void
338  push_back(_CharT __c)
339  {
340  _Base::push_back(__c);
341  this->_M_invalidate_all();
342  }
343 
344  basic_string&
345  assign(const basic_string& __x)
346  {
347  _Base::assign(__x);
348  this->_M_invalidate_all();
349  return *this;
350  }
351 
352  basic_string&
353  assign(const basic_string& __str, size_type __pos, size_type __n)
354  {
355  _Base::assign(__str, __pos, __n);
356  this->_M_invalidate_all();
357  return *this;
358  }
359 
360  basic_string&
361  assign(const _CharT* __s, size_type __n)
362  {
363  __glibcxx_check_string_len(__s, __n);
364  _Base::assign(__s, __n);
365  this->_M_invalidate_all();
366  return *this;
367  }
368 
369  basic_string&
370  assign(const _CharT* __s)
371  {
372  __glibcxx_check_string(__s);
373  _Base::assign(__s);
374  this->_M_invalidate_all();
375  return *this;
376  }
377 
378  basic_string&
379  assign(size_type __n, _CharT __c)
380  {
381  _Base::assign(__n, __c);
382  this->_M_invalidate_all();
383  return *this;
384  }
385 
386  template<typename _InputIterator>
387  basic_string&
388  assign(_InputIterator __first, _InputIterator __last)
389  {
390  __glibcxx_check_valid_range(__first, __last);
391  _Base::assign(__first, __last);
392  this->_M_invalidate_all();
393  return *this;
394  }
395 
396 #ifdef __GXX_EXPERIMENTAL_CXX0X__
397  basic_string&
398  assign(initializer_list<_CharT> __l)
399  {
400  _Base::assign(__l);
401  this->_M_invalidate_all();
402  return *this;
403  }
404 #endif // __GXX_EXPERIMENTAL_CXX0X__
405 
406  basic_string&
407  insert(size_type __pos1, const basic_string& __str)
408  {
409  _Base::insert(__pos1, __str);
410  this->_M_invalidate_all();
411  return *this;
412  }
413 
414  basic_string&
415  insert(size_type __pos1, const basic_string& __str,
416  size_type __pos2, size_type __n)
417  {
418  _Base::insert(__pos1, __str, __pos2, __n);
419  this->_M_invalidate_all();
420  return *this;
421  }
422 
423  basic_string&
424  insert(size_type __pos, const _CharT* __s, size_type __n)
425  {
426  __glibcxx_check_string(__s);
427  _Base::insert(__pos, __s, __n);
428  this->_M_invalidate_all();
429  return *this;
430  }
431 
432  basic_string&
433  insert(size_type __pos, const _CharT* __s)
434  {
435  __glibcxx_check_string(__s);
436  _Base::insert(__pos, __s);
437  this->_M_invalidate_all();
438  return *this;
439  }
440 
441  basic_string&
442  insert(size_type __pos, size_type __n, _CharT __c)
443  {
444  _Base::insert(__pos, __n, __c);
445  this->_M_invalidate_all();
446  return *this;
447  }
448 
449  iterator
450  insert(iterator __p, _CharT __c)
451  {
453  typename _Base::iterator __res = _Base::insert(__p.base(), __c);
454  this->_M_invalidate_all();
455  return iterator(__res, this);
456  }
457 
458  void
459  insert(iterator __p, size_type __n, _CharT __c)
460  {
462  _Base::insert(__p.base(), __n, __c);
463  this->_M_invalidate_all();
464  }
465 
466  template<typename _InputIterator>
467  void
468  insert(iterator __p, _InputIterator __first, _InputIterator __last)
469  {
470  __glibcxx_check_insert_range(__p, __first, __last);
471  _Base::insert(__p.base(), __first, __last);
472  this->_M_invalidate_all();
473  }
474 
475 #ifdef __GXX_EXPERIMENTAL_CXX0X__
476  void
477  insert(iterator __p, initializer_list<_CharT> __l)
478  {
479  _Base::insert(__p, __l);
480  this->_M_invalidate_all();
481  }
482 #endif // __GXX_EXPERIMENTAL_CXX0X__
483 
484  basic_string&
485  erase(size_type __pos = 0, size_type __n = _Base::npos)
486  {
487  _Base::erase(__pos, __n);
488  this->_M_invalidate_all();
489  return *this;
490  }
491 
492  iterator
493  erase(iterator __position)
494  {
495  __glibcxx_check_erase(__position);
496  typename _Base::iterator __res = _Base::erase(__position.base());
497  this->_M_invalidate_all();
498  return iterator(__res, this);
499  }
500 
501  iterator
502  erase(iterator __first, iterator __last)
503  {
504  // _GLIBCXX_RESOLVE_LIB_DEFECTS
505  // 151. can't currently clear() empty container
506  __glibcxx_check_erase_range(__first, __last);
507  typename _Base::iterator __res = _Base::erase(__first.base(),
508  __last.base());
509  this->_M_invalidate_all();
510  return iterator(__res, this);
511  }
512 
513  basic_string&
514  replace(size_type __pos1, size_type __n1, const basic_string& __str)
515  {
516  _Base::replace(__pos1, __n1, __str);
517  this->_M_invalidate_all();
518  return *this;
519  }
520 
521  basic_string&
522  replace(size_type __pos1, size_type __n1, const basic_string& __str,
523  size_type __pos2, size_type __n2)
524  {
525  _Base::replace(__pos1, __n1, __str, __pos2, __n2);
526  this->_M_invalidate_all();
527  return *this;
528  }
529 
530  basic_string&
531  replace(size_type __pos, size_type __n1, const _CharT* __s,
532  size_type __n2)
533  {
534  __glibcxx_check_string_len(__s, __n2);
535  _Base::replace(__pos, __n1, __s, __n2);
536  this->_M_invalidate_all();
537  return *this;
538  }
539 
540  basic_string&
541  replace(size_type __pos, size_type __n1, const _CharT* __s)
542  {
543  __glibcxx_check_string(__s);
544  _Base::replace(__pos, __n1, __s);
545  this->_M_invalidate_all();
546  return *this;
547  }
548 
549  basic_string&
550  replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
551  {
552  _Base::replace(__pos, __n1, __n2, __c);
553  this->_M_invalidate_all();
554  return *this;
555  }
556 
557  basic_string&
558  replace(iterator __i1, iterator __i2, const basic_string& __str)
559  {
560  __glibcxx_check_erase_range(__i1, __i2);
561  _Base::replace(__i1.base(), __i2.base(), __str);
562  this->_M_invalidate_all();
563  return *this;
564  }
565 
566  basic_string&
567  replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
568  {
569  __glibcxx_check_erase_range(__i1, __i2);
570  __glibcxx_check_string_len(__s, __n);
571  _Base::replace(__i1.base(), __i2.base(), __s, __n);
572  this->_M_invalidate_all();
573  return *this;
574  }
575 
576  basic_string&
577  replace(iterator __i1, iterator __i2, const _CharT* __s)
578  {
579  __glibcxx_check_erase_range(__i1, __i2);
580  __glibcxx_check_string(__s);
581  _Base::replace(__i1.base(), __i2.base(), __s);
582  this->_M_invalidate_all();
583  return *this;
584  }
585 
586  basic_string&
587  replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
588  {
589  __glibcxx_check_erase_range(__i1, __i2);
590  _Base::replace(__i1.base(), __i2.base(), __n, __c);
591  this->_M_invalidate_all();
592  return *this;
593  }
594 
595  template<typename _InputIterator>
596  basic_string&
597  replace(iterator __i1, iterator __i2,
598  _InputIterator __j1, _InputIterator __j2)
599  {
600  __glibcxx_check_erase_range(__i1, __i2);
601  __glibcxx_check_valid_range(__j1, __j2);
602  _Base::replace(__i1.base(), __i2.base(), __j1, __j2);
603  this->_M_invalidate_all();
604  return *this;
605  }
606 
607 #ifdef __GXX_EXPERIMENTAL_CXX0X__
608  basic_string& replace(iterator __i1, iterator __i2,
609  initializer_list<_CharT> __l)
610  {
611  __glibcxx_check_erase_range(__i1, __i2);
612  _Base::replace(__i1.base(), __i2.base(), __l);
613  this->_M_invalidate_all();
614  return *this;
615  }
616 #endif // __GXX_EXPERIMENTAL_CXX0X__
617 
618  size_type
619  copy(_CharT* __s, size_type __n, size_type __pos = 0) const
620  {
621  __glibcxx_check_string_len(__s, __n);
622  return _Base::copy(__s, __n, __pos);
623  }
624 
625  void
626  swap(basic_string<_CharT,_Traits,_Allocator>& __x)
627  {
628  _Base::swap(__x);
629  this->_M_swap(__x);
630  this->_M_invalidate_all();
631  __x._M_invalidate_all();
632  }
633 
634  // 21.3.6 string operations:
635  const _CharT*
636  c_str() const
637  {
638  const _CharT* __res = _Base::c_str();
639  this->_M_invalidate_all();
640  return __res;
641  }
642 
643  const _CharT*
644  data() const
645  {
646  const _CharT* __res = _Base::data();
647  this->_M_invalidate_all();
648  return __res;
649  }
650 
651  using _Base::get_allocator;
652 
653  size_type
654  find(const basic_string& __str, size_type __pos = 0) const
655  { return _Base::find(__str, __pos); }
656 
657  size_type
658  find(const _CharT* __s, size_type __pos, size_type __n) const
659  {
660  __glibcxx_check_string(__s);
661  return _Base::find(__s, __pos, __n);
662  }
663 
664  size_type
665  find(const _CharT* __s, size_type __pos = 0) const
666  {
667  __glibcxx_check_string(__s);
668  return _Base::find(__s, __pos);
669  }
670 
671  size_type
672  find(_CharT __c, size_type __pos = 0) const
673  { return _Base::find(__c, __pos); }
674 
675  size_type
676  rfind(const basic_string& __str, size_type __pos = _Base::npos) const
677  { return _Base::rfind(__str, __pos); }
678 
679  size_type
680  rfind(const _CharT* __s, size_type __pos, size_type __n) const
681  {
682  __glibcxx_check_string_len(__s, __n);
683  return _Base::rfind(__s, __pos, __n);
684  }
685 
686  size_type
687  rfind(const _CharT* __s, size_type __pos = _Base::npos) const
688  {
689  __glibcxx_check_string(__s);
690  return _Base::rfind(__s, __pos);
691  }
692 
693  size_type
694  rfind(_CharT __c, size_type __pos = _Base::npos) const
695  { return _Base::rfind(__c, __pos); }
696 
697  size_type
698  find_first_of(const basic_string& __str, size_type __pos = 0) const
699  { return _Base::find_first_of(__str, __pos); }
700 
701  size_type
702  find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
703  {
704  __glibcxx_check_string(__s);
705  return _Base::find_first_of(__s, __pos, __n);
706  }
707 
708  size_type
709  find_first_of(const _CharT* __s, size_type __pos = 0) const
710  {
711  __glibcxx_check_string(__s);
712  return _Base::find_first_of(__s, __pos);
713  }
714 
715  size_type
716  find_first_of(_CharT __c, size_type __pos = 0) const
717  { return _Base::find_first_of(__c, __pos); }
718 
719  size_type
720  find_last_of(const basic_string& __str,
721  size_type __pos = _Base::npos) const
722  { return _Base::find_last_of(__str, __pos); }
723 
724  size_type
725  find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
726  {
727  __glibcxx_check_string(__s);
728  return _Base::find_last_of(__s, __pos, __n);
729  }
730 
731  size_type
732  find_last_of(const _CharT* __s, size_type __pos = _Base::npos) const
733  {
734  __glibcxx_check_string(__s);
735  return _Base::find_last_of(__s, __pos);
736  }
737 
738  size_type
739  find_last_of(_CharT __c, size_type __pos = _Base::npos) const
740  { return _Base::find_last_of(__c, __pos); }
741 
742  size_type
743  find_first_not_of(const basic_string& __str, size_type __pos = 0) const
744  { return _Base::find_first_not_of(__str, __pos); }
745 
746  size_type
747  find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
748  {
749  __glibcxx_check_string_len(__s, __n);
750  return _Base::find_first_not_of(__s, __pos, __n);
751  }
752 
753  size_type
754  find_first_not_of(const _CharT* __s, size_type __pos = 0) const
755  {
756  __glibcxx_check_string(__s);
757  return _Base::find_first_not_of(__s, __pos);
758  }
759 
760  size_type
761  find_first_not_of(_CharT __c, size_type __pos = 0) const
762  { return _Base::find_first_not_of(__c, __pos); }
763 
764  size_type
765  find_last_not_of(const basic_string& __str,
766  size_type __pos = _Base::npos) const
767  { return _Base::find_last_not_of(__str, __pos); }
768 
769  size_type
770  find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
771  {
772  __glibcxx_check_string(__s);
773  return _Base::find_last_not_of(__s, __pos, __n);
774  }
775 
776  size_type
777  find_last_not_of(const _CharT* __s, size_type __pos = _Base::npos) const
778  {
779  __glibcxx_check_string(__s);
780  return _Base::find_last_not_of(__s, __pos);
781  }
782 
783  size_type
784  find_last_not_of(_CharT __c, size_type __pos = _Base::npos) const
785  { return _Base::find_last_not_of(__c, __pos); }
786 
787  basic_string
788  substr(size_type __pos = 0, size_type __n = _Base::npos) const
789  { return basic_string(_Base::substr(__pos, __n)); }
790 
791  int
792  compare(const basic_string& __str) const
793  { return _Base::compare(__str); }
794 
795  int
796  compare(size_type __pos1, size_type __n1,
797  const basic_string& __str) const
798  { return _Base::compare(__pos1, __n1, __str); }
799 
800  int
801  compare(size_type __pos1, size_type __n1, const basic_string& __str,
802  size_type __pos2, size_type __n2) const
803  { return _Base::compare(__pos1, __n1, __str, __pos2, __n2); }
804 
805  int
806  compare(const _CharT* __s) const
807  {
808  __glibcxx_check_string(__s);
809  return _Base::compare(__s);
810  }
811 
812  // _GLIBCXX_RESOLVE_LIB_DEFECTS
813  // 5. string::compare specification questionable
814  int
815  compare(size_type __pos1, size_type __n1, const _CharT* __s) const
816  {
817  __glibcxx_check_string(__s);
818  return _Base::compare(__pos1, __n1, __s);
819  }
820 
821  // _GLIBCXX_RESOLVE_LIB_DEFECTS
822  // 5. string::compare specification questionable
823  int
824  compare(size_type __pos1, size_type __n1,const _CharT* __s,
825  size_type __n2) const
826  {
827  __glibcxx_check_string_len(__s, __n2);
828  return _Base::compare(__pos1, __n1, __s, __n2);
829  }
830 
831  _Base&
832  _M_base() { return *this; }
833 
834  const _Base&
835  _M_base() const { return *this; }
836 
838  };
839 
840  template<typename _CharT, typename _Traits, typename _Allocator>
841  inline basic_string<_CharT,_Traits,_Allocator>
842  operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
843  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
844  { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
845 
846  template<typename _CharT, typename _Traits, typename _Allocator>
847  inline basic_string<_CharT,_Traits,_Allocator>
848  operator+(const _CharT* __lhs,
849  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
850  {
851  __glibcxx_check_string(__lhs);
852  return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
853  }
854 
855  template<typename _CharT, typename _Traits, typename _Allocator>
856  inline basic_string<_CharT,_Traits,_Allocator>
857  operator+(_CharT __lhs,
858  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
859  { return basic_string<_CharT,_Traits,_Allocator>(1, __lhs) += __rhs; }
860 
861  template<typename _CharT, typename _Traits, typename _Allocator>
862  inline basic_string<_CharT,_Traits,_Allocator>
863  operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
864  const _CharT* __rhs)
865  {
866  __glibcxx_check_string(__rhs);
867  return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
868  }
869 
870  template<typename _CharT, typename _Traits, typename _Allocator>
871  inline basic_string<_CharT,_Traits,_Allocator>
872  operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
873  _CharT __rhs)
874  { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
875 
876  template<typename _CharT, typename _Traits, typename _Allocator>
877  inline bool
878  operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
879  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
880  { return __lhs._M_base() == __rhs._M_base(); }
881 
882  template<typename _CharT, typename _Traits, typename _Allocator>
883  inline bool
884  operator==(const _CharT* __lhs,
885  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
886  {
887  __glibcxx_check_string(__lhs);
888  return __lhs == __rhs._M_base();
889  }
890 
891  template<typename _CharT, typename _Traits, typename _Allocator>
892  inline bool
893  operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
894  const _CharT* __rhs)
895  {
896  __glibcxx_check_string(__rhs);
897  return __lhs._M_base() == __rhs;
898  }
899 
900  template<typename _CharT, typename _Traits, typename _Allocator>
901  inline bool
902  operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
903  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
904  { return __lhs._M_base() != __rhs._M_base(); }
905 
906  template<typename _CharT, typename _Traits, typename _Allocator>
907  inline bool
908  operator!=(const _CharT* __lhs,
909  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
910  {
911  __glibcxx_check_string(__lhs);
912  return __lhs != __rhs._M_base();
913  }
914 
915  template<typename _CharT, typename _Traits, typename _Allocator>
916  inline bool
917  operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
918  const _CharT* __rhs)
919  {
920  __glibcxx_check_string(__rhs);
921  return __lhs._M_base() != __rhs;
922  }
923 
924  template<typename _CharT, typename _Traits, typename _Allocator>
925  inline bool
926  operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
927  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
928  { return __lhs._M_base() < __rhs._M_base(); }
929 
930  template<typename _CharT, typename _Traits, typename _Allocator>
931  inline bool
932  operator<(const _CharT* __lhs,
933  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
934  {
935  __glibcxx_check_string(__lhs);
936  return __lhs < __rhs._M_base();
937  }
938 
939  template<typename _CharT, typename _Traits, typename _Allocator>
940  inline bool
941  operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
942  const _CharT* __rhs)
943  {
944  __glibcxx_check_string(__rhs);
945  return __lhs._M_base() < __rhs;
946  }
947 
948  template<typename _CharT, typename _Traits, typename _Allocator>
949  inline bool
950  operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
951  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
952  { return __lhs._M_base() <= __rhs._M_base(); }
953 
954  template<typename _CharT, typename _Traits, typename _Allocator>
955  inline bool
956  operator<=(const _CharT* __lhs,
957  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
958  {
959  __glibcxx_check_string(__lhs);
960  return __lhs <= __rhs._M_base();
961  }
962 
963  template<typename _CharT, typename _Traits, typename _Allocator>
964  inline bool
965  operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
966  const _CharT* __rhs)
967  {
968  __glibcxx_check_string(__rhs);
969  return __lhs._M_base() <= __rhs;
970  }
971 
972  template<typename _CharT, typename _Traits, typename _Allocator>
973  inline bool
974  operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
975  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
976  { return __lhs._M_base() >= __rhs._M_base(); }
977 
978  template<typename _CharT, typename _Traits, typename _Allocator>
979  inline bool
980  operator>=(const _CharT* __lhs,
981  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
982  {
983  __glibcxx_check_string(__lhs);
984  return __lhs >= __rhs._M_base();
985  }
986 
987  template<typename _CharT, typename _Traits, typename _Allocator>
988  inline bool
989  operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
990  const _CharT* __rhs)
991  {
992  __glibcxx_check_string(__rhs);
993  return __lhs._M_base() >= __rhs;
994  }
995 
996  template<typename _CharT, typename _Traits, typename _Allocator>
997  inline bool
998  operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
999  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1000  { return __lhs._M_base() > __rhs._M_base(); }
1001 
1002  template<typename _CharT, typename _Traits, typename _Allocator>
1003  inline bool
1004  operator>(const _CharT* __lhs,
1005  const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1006  {
1007  __glibcxx_check_string(__lhs);
1008  return __lhs > __rhs._M_base();
1009  }
1010 
1011  template<typename _CharT, typename _Traits, typename _Allocator>
1012  inline bool
1013  operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1014  const _CharT* __rhs)
1015  {
1016  __glibcxx_check_string(__rhs);
1017  return __lhs._M_base() > __rhs;
1018  }
1019 
1020  // 21.3.7.8:
1021  template<typename _CharT, typename _Traits, typename _Allocator>
1022  inline void
1023  swap(basic_string<_CharT,_Traits,_Allocator>& __lhs,
1024  basic_string<_CharT,_Traits,_Allocator>& __rhs)
1025  { __lhs.swap(__rhs); }
1026 
1027  template<typename _CharT, typename _Traits, typename _Allocator>
1029  operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1030  const basic_string<_CharT, _Traits, _Allocator>& __str)
1031  { return __os << __str._M_base(); }
1032 
1033  template<typename _CharT, typename _Traits, typename _Allocator>
1035  operator>>(std::basic_istream<_CharT,_Traits>& __is,
1036  basic_string<_CharT,_Traits,_Allocator>& __str)
1037  {
1038  std::basic_istream<_CharT,_Traits>& __res = __is >> __str._M_base();
1039  __str._M_invalidate_all();
1040  return __res;
1041  }
1042 
1043  template<typename _CharT, typename _Traits, typename _Allocator>
1045  getline(std::basic_istream<_CharT,_Traits>& __is,
1046  basic_string<_CharT,_Traits,_Allocator>& __str, _CharT __delim)
1047  {
1048  std::basic_istream<_CharT,_Traits>& __res = getline(__is,
1049  __str._M_base(),
1050  __delim);
1051  __str._M_invalidate_all();
1052  return __res;
1053  }
1054 
1055  template<typename _CharT, typename _Traits, typename _Allocator>
1057  getline(std::basic_istream<_CharT,_Traits>& __is,
1058  basic_string<_CharT,_Traits,_Allocator>& __str)
1059  {
1060  std::basic_istream<_CharT,_Traits>& __res = getline(__is,
1061  __str._M_base());
1062  __str._M_invalidate_all();
1063  return __res;
1064  }
1065 
1066  typedef basic_string<char> string;
1067 
1068 #ifdef _GLIBCXX_USE_WCHAR_T
1069  typedef basic_string<wchar_t> wstring;
1070 #endif
1071 
1072 } // namespace __gnu_debug
1073 
1074 #endif
basic_string & assign(const basic_string &__str)
Set value to contents of another string.
size_type find_last_not_of(const basic_string &__str, size_type __pos=npos) const
Find last position of a character not in string.
#define __glibcxx_check_insert_range(_Position, _First, _Last)
Definition: macros.h:87
#define __glibcxx_check_erase(_Position)
Definition: macros.h:102
void reserve(size_type __res_arg=0)
Attempt to preallocate enough memory for specified number of characters.
allocator_type get_allocator() const
Return copy of allocator used to construct this string.
#define _GLIBCXX_DEBUG_VERIFY(_Condition, _ErrorMessage)
Definition: macros.h:42
const _CharT * c_str() const
Return const pointer to null-terminated contents.
void insert(iterator __p, size_type __n, _CharT __c)
Insert multiple characters.
size_type length() const
Returns the number of characters in the string, not including any null-termination.
Definition: basic_string.h:634
size_type find_last_of(const basic_string &__str, size_type __pos=npos) const
Find last position of a character of string.
size_type find_first_of(const basic_string &__str, size_type __pos=0) const
Find position of a character of string.
size_type find(const _CharT *__s, size_type __pos, size_type __n) const
Find position of a C substring.
const _CharT * data() const
Return const pointer to contents.
Base class for constructing a "safe" sequence type that tracks iterators that reference it...
Definition: formatter.h:60
void resize(size_type __n, _CharT __c)
Resizes the string to the specified number of characters.
size_type max_size() const
Returns the size() of the largest possible string.
Definition: basic_string.h:639
size_type size() const
Returns the number of characters in the string, not including any null-termination.
Definition: basic_string.h:628
void swap(basic_string &__s)
Swap contents with another string.
Controlling output.This is the base class for all output streams. It provides text formatting of all ...
Definition: iosfwd:56
const _CharT * __check_string(const _CharT *__s, const _Integer &__n __attribute__((__unused__)))
Definition: functions.h:164
void push_back(_CharT __c)
Append a single character.
Definition: basic_string.h:914
#define __glibcxx_check_erase_range(_First, _Last)
Definition: macros.h:116
basic_string & replace(size_type __pos, size_type __n, const basic_string &__str)
Replace characters with value from another string.
basic_string substr(size_type __pos=0, size_type __n=npos) const
Get a substring.
const_reference at(size_type __n) const
Provides access to the data contained in the string.
Definition: basic_string.h:761
size_type rfind(const basic_string &__str, size_type __pos=npos) const
Find last position of a string.
static const size_type npos
Value returned by various member functions when they fail.
Definition: basic_string.h:270
size_type find_first_not_of(const basic_string &__str, size_type __pos=0) const
Find position of a character not in string.
size_type copy(_CharT *__s, size_type __n, size_type __pos=0) const
Copy substring into C string.
#define __glibcxx_check_insert(_Position)
Definition: macros.h:64
basic_string & erase(size_type __pos=0, size_type __n=npos)
Remove characters.
basic_string & append(const basic_string &__str)
Append a string to this string.
Controlling input.This is the base class for all input streams. It provides text formatting of all bu...
Definition: iosfwd:53
Safe iterator wrapper.
Definition: formatter.h:57
Managing sequences of characters and character-like objects.
Definition: basic_string.h:104
int compare(const basic_string &__str) const
Compare to a string.