diff options
Diffstat (limited to 'rep/usr/include/c++/4.3/bits/basic_string.h.gcov.html')
| -rw-r--r-- | rep/usr/include/c++/4.3/bits/basic_string.h.gcov.html | 2545 |
1 files changed, 2545 insertions, 0 deletions
diff --git a/rep/usr/include/c++/4.3/bits/basic_string.h.gcov.html b/rep/usr/include/c++/4.3/bits/basic_string.h.gcov.html new file mode 100644 index 0000000..909cd58 --- /dev/null +++ b/rep/usr/include/c++/4.3/bits/basic_string.h.gcov.html @@ -0,0 +1,2545 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> + +<html lang="en"> + +<head> + <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>LCOV - lcov.info - /usr/include/c++/4.3/bits/basic_string.h</title> + <link rel="stylesheet" type="text/css" href="../../../../../gcov.css"> +</head> + +<body> + + <table width="100%" border=0 cellspacing=0 cellpadding=0> + <tr><td class="title">LTP GCOV extension - code coverage report</td></tr> + <tr><td class="ruler"><img src="../../../../../glass.png" width=3 height=3 alt=""></td></tr> + + <tr> + <td width="100%"> + <table cellpadding=1 border=0 width="100%"> + <tr> + <td class="headerItem" width="20%">Current view:</td> + <td class="headerValue" width="80%" colspan=4><a href="../../../../../index.html">directory</a> - <a href="index.html">usr/include/c++/4.3/bits</a> - basic_string.h</td> + </tr> + <tr> + <td class="headerItem" width="20%">Test:</td> + <td class="headerValue" width="80%" colspan=4>lcov.info</td> + </tr> + <tr> + <td class="headerItem" width="20%">Date:</td> + <td class="headerValue" width="20%">2008-08-14</td> + <td width="20%"></td> + <td class="headerItem" width="20%">Instrumented lines:</td> + <td class="headerValue" width="20%">178</td> + </tr> + <tr> + <td class="headerItem" width="20%">Code covered:</td> + <td class="headerValue" width="20%">17.4 %</td> + <td width="20%"></td> + <td class="headerItem" width="20%">Executed lines:</td> + <td class="headerValue" width="20%">31</td> + </tr> + </table> + </td> + </tr> + <tr><td class="ruler"><img src="../../../../../glass.png" width=3 height=3 alt=""></td></tr> + </table> + + <table cellpadding=0 cellspacing=0 border=0> + <tr> + <td><br></td> + </tr> + <tr> + <td><pre class="source"> +<span class="lineNum"> 1 </span> : // Components for manipulating sequences of characters -*- C++ -*- +<span class="lineNum"> 2 </span> : +<span class="lineNum"> 3 </span> : // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, +<span class="lineNum"> 4 </span> : // 2006, 2007, 2008 +<span class="lineNum"> 5 </span> : // Free Software Foundation, Inc. +<span class="lineNum"> 6 </span> : // +<span class="lineNum"> 7 </span> : // This file is part of the GNU ISO C++ Library. This library is free +<span class="lineNum"> 8 </span> : // software; you can redistribute it and/or modify it under the +<span class="lineNum"> 9 </span> : // terms of the GNU General Public License as published by the +<span class="lineNum"> 10 </span> : // Free Software Foundation; either version 2, or (at your option) +<span class="lineNum"> 11 </span> : // any later version. +<span class="lineNum"> 12 </span> : +<span class="lineNum"> 13 </span> : // This library is distributed in the hope that it will be useful, +<span class="lineNum"> 14 </span> : // but WITHOUT ANY WARRANTY; without even the implied warranty of +<span class="lineNum"> 15 </span> : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +<span class="lineNum"> 16 </span> : // GNU General Public License for more details. +<span class="lineNum"> 17 </span> : +<span class="lineNum"> 18 </span> : // You should have received a copy of the GNU General Public License along +<span class="lineNum"> 19 </span> : // with this library; see the file COPYING. If not, write to the Free +<span class="lineNum"> 20 </span> : // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +<span class="lineNum"> 21 </span> : // USA. +<span class="lineNum"> 22 </span> : +<span class="lineNum"> 23 </span> : // As a special exception, you may use this file as part of a free software +<span class="lineNum"> 24 </span> : // library without restriction. Specifically, if other files instantiate +<span class="lineNum"> 25 </span> : // templates or use macros or inline functions from this file, or you compile +<span class="lineNum"> 26 </span> : // this file and link it with other files to produce an executable, this +<span class="lineNum"> 27 </span> : // file does not by itself cause the resulting executable to be covered by +<span class="lineNum"> 28 </span> : // the GNU General Public License. This exception does not however +<span class="lineNum"> 29 </span> : // invalidate any other reasons why the executable file might be covered by +<span class="lineNum"> 30 </span> : // the GNU General Public License. +<span class="lineNum"> 31 </span> : +<span class="lineNum"> 32 </span> : /** @file basic_string.h +<span class="lineNum"> 33 </span> : * This is an internal header file, included by other library headers. +<span class="lineNum"> 34 </span> : * You should not attempt to use it directly. +<span class="lineNum"> 35 </span> : */ +<span class="lineNum"> 36 </span> : +<span class="lineNum"> 37 </span> : // +<span class="lineNum"> 38 </span> : // ISO C++ 14882: 21 Strings library +<span class="lineNum"> 39 </span> : // +<span class="lineNum"> 40 </span> : +<span class="lineNum"> 41 </span> : #ifndef _BASIC_STRING_H +<span class="lineNum"> 42 </span> : #define _BASIC_STRING_H 1 +<span class="lineNum"> 43 </span> : +<span class="lineNum"> 44 </span> : #pragma GCC system_header +<span class="lineNum"> 45 </span> : +<span class="lineNum"> 46 </span> : #include <ext/atomicity.h> +<span class="lineNum"> 47 </span> : #include <debug/debug.h> +<span class="lineNum"> 48 </span> : +<span class="lineNum"> 49 </span> : _GLIBCXX_BEGIN_NAMESPACE(std) +<span class="lineNum"> 50 </span> : +<span class="lineNum"> 51 </span> : /** +<span class="lineNum"> 52 </span> : * @class basic_string basic_string.h <string> +<span class="lineNum"> 53 </span> : * @brief Managing sequences of characters and character-like objects. +<span class="lineNum"> 54 </span> : * +<span class="lineNum"> 55 </span> : * @ingroup Containers +<span class="lineNum"> 56 </span> : * @ingroup Sequences +<span class="lineNum"> 57 </span> : * +<span class="lineNum"> 58 </span> : * Meets the requirements of a <a href="tables.html#65">container</a>, a +<span class="lineNum"> 59 </span> : * <a href="tables.html#66">reversible container</a>, and a +<span class="lineNum"> 60 </span> : * <a href="tables.html#67">sequence</a>. Of the +<span class="lineNum"> 61 </span> : * <a href="tables.html#68">optional sequence requirements</a>, only +<span class="lineNum"> 62 </span> : * @c push_back, @c at, and array access are supported. +<span class="lineNum"> 63 </span> : * +<span class="lineNum"> 64 </span> : * @doctodo +<span class="lineNum"> 65 </span> : * +<span class="lineNum"> 66 </span> : * +<span class="lineNum"> 67 </span> : * Documentation? What's that? +<span class="lineNum"> 68 </span> : * Nathan Myers <ncm@cantrip.org>. +<span class="lineNum"> 69 </span> : * +<span class="lineNum"> 70 </span> : * A string looks like this: +<span class="lineNum"> 71 </span> : * +<span class="lineNum"> 72 </span> : * @code +<span class="lineNum"> 73 </span> : * [_Rep] +<span class="lineNum"> 74 </span> : * _M_length +<span class="lineNum"> 75 </span> : * [basic_string<char_type>] _M_capacity +<span class="lineNum"> 76 </span> : * _M_dataplus _M_refcount +<span class="lineNum"> 77 </span> : * _M_p ----------------> unnamed array of char_type +<span class="lineNum"> 78 </span> : * @endcode +<span class="lineNum"> 79 </span> : * +<span class="lineNum"> 80 </span> : * Where the _M_p points to the first character in the string, and +<span class="lineNum"> 81 </span> : * you cast it to a pointer-to-_Rep and subtract 1 to get a +<span class="lineNum"> 82 </span> : * pointer to the header. +<span class="lineNum"> 83 </span> : * +<span class="lineNum"> 84 </span> : * This approach has the enormous advantage that a string object +<span class="lineNum"> 85 </span> : * requires only one allocation. All the ugliness is confined +<span class="lineNum"> 86 </span> : * within a single pair of inline functions, which each compile to +<span class="lineNum"> 87 </span> : * a single "add" instruction: _Rep::_M_data(), and +<span class="lineNum"> 88 </span> : * string::_M_rep(); and the allocation function which gets a +<span class="lineNum"> 89 </span> : * block of raw bytes and with room enough and constructs a _Rep +<span class="lineNum"> 90 </span> : * object at the front. +<span class="lineNum"> 91 </span> : * +<span class="lineNum"> 92 </span> : * The reason you want _M_data pointing to the character array and +<span class="lineNum"> 93 </span> : * not the _Rep is so that the debugger can see the string +<span class="lineNum"> 94 </span> : * contents. (Probably we should add a non-inline member to get +<span class="lineNum"> 95 </span> : * the _Rep for the debugger to use, so users can check the actual +<span class="lineNum"> 96 </span> : * string length.) +<span class="lineNum"> 97 </span> : * +<span class="lineNum"> 98 </span> : * Note that the _Rep object is a POD so that you can have a +<span class="lineNum"> 99 </span> : * static "empty string" _Rep object already "constructed" before +<span class="lineNum"> 100 </span> : * static constructors have run. The reference-count encoding is +<span class="lineNum"> 101 </span> : * chosen so that a 0 indicates one reference, so you never try to +<span class="lineNum"> 102 </span> : * destroy the empty-string _Rep object. +<span class="lineNum"> 103 </span> : * +<span class="lineNum"> 104 </span> : * All but the last paragraph is considered pretty conventional +<span class="lineNum"> 105 </span> : * for a C++ string implementation. +<span class="lineNum"> 106 </span> : */ +<span class="lineNum"> 107 </span> : // 21.3 Template class basic_string +<span class="lineNum"> 108 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 109 </span> : class basic_string +<span class="lineNum"> 110 </span> : { +<span class="lineNum"> 111 </span> : typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type; +<span class="lineNum"> 112 </span> : +<span class="lineNum"> 113 </span> : // Types: +<span class="lineNum"> 114 </span> : public: +<span class="lineNum"> 115 </span> : typedef _Traits traits_type; +<span class="lineNum"> 116 </span> : typedef typename _Traits::char_type value_type; +<span class="lineNum"> 117 </span> : typedef _Alloc allocator_type; +<span class="lineNum"> 118 </span> : typedef typename _CharT_alloc_type::size_type size_type; +<span class="lineNum"> 119 </span> : typedef typename _CharT_alloc_type::difference_type difference_type; +<span class="lineNum"> 120 </span> : typedef typename _CharT_alloc_type::reference reference; +<span class="lineNum"> 121 </span> : typedef typename _CharT_alloc_type::const_reference const_reference; +<span class="lineNum"> 122 </span> : typedef typename _CharT_alloc_type::pointer pointer; +<span class="lineNum"> 123 </span> : typedef typename _CharT_alloc_type::const_pointer const_pointer; +<span class="lineNum"> 124 </span> : typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator; +<span class="lineNum"> 125 </span> : typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string> +<span class="lineNum"> 126 </span> : const_iterator; +<span class="lineNum"> 127 </span> : typedef std::reverse_iterator<const_iterator> const_reverse_iterator; +<span class="lineNum"> 128 </span> : typedef std::reverse_iterator<iterator> reverse_iterator; +<span class="lineNum"> 129 </span> : +<span class="lineNum"> 130 </span> : private: +<span class="lineNum"> 131 </span> : // _Rep: string representation +<span class="lineNum"> 132 </span> : // Invariants: +<span class="lineNum"> 133 </span> : // 1. String really contains _M_length + 1 characters: due to 21.3.4 +<span class="lineNum"> 134 </span> : // must be kept null-terminated. +<span class="lineNum"> 135 </span> : // 2. _M_capacity >= _M_length +<span class="lineNum"> 136 </span> : // Allocated memory is always (_M_capacity + 1) * sizeof(_CharT). +<span class="lineNum"> 137 </span> : // 3. _M_refcount has three states: +<span class="lineNum"> 138 </span> : // -1: leaked, one reference, no ref-copies allowed, non-const. +<span class="lineNum"> 139 </span> : // 0: one reference, non-const. +<span class="lineNum"> 140 </span> : // n>0: n + 1 references, operations require a lock, const. +<span class="lineNum"> 141 </span> : // 4. All fields==0 is an empty string, given the extra storage +<span class="lineNum"> 142 </span> : // beyond-the-end for a null terminator; thus, the shared +<span class="lineNum"> 143 </span> : // empty string representation needs no constructor. +<span class="lineNum"> 144 </span> : +<span class="lineNum"> 145 </span> : struct _Rep_base +<span class="lineNum"> 146 </span> : { +<span class="lineNum"> 147 </span> : size_type _M_length; +<span class="lineNum"> 148 </span> : size_type _M_capacity; +<span class="lineNum"> 149 </span> : _Atomic_word _M_refcount; +<span class="lineNum"> 150 </span> : }; +<span class="lineNum"> 151 </span> : +<span class="lineNum"> 152 </span> : struct _Rep : _Rep_base +<span class="lineNum"> 153 </span> : { +<span class="lineNum"> 154 </span> : // Types: +<span class="lineNum"> 155 </span> : typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc; +<span class="lineNum"> 156 </span> : +<span class="lineNum"> 157 </span> : // (Public) Data members: +<span class="lineNum"> 158 </span> : +<span class="lineNum"> 159 </span> : // The maximum number of individual char_type elements of an +<span class="lineNum"> 160 </span> : // individual string is determined by _S_max_size. This is the +<span class="lineNum"> 161 </span> : // value that will be returned by max_size(). (Whereas npos +<span class="lineNum"> 162 </span> : // is the maximum number of bytes the allocator can allocate.) +<span class="lineNum"> 163 </span> : // If one was to divvy up the theoretical largest size string, +<span class="lineNum"> 164 </span> : // with a terminating character and m _CharT elements, it'd +<span class="lineNum"> 165 </span> : // look like this: +<span class="lineNum"> 166 </span> : // npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT) +<span class="lineNum"> 167 </span> : // Solving for m: +<span class="lineNum"> 168 </span> : // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1 +<span class="lineNum"> 169 </span> : // In addition, this implementation quarters this amount. +<span class="lineNum"> 170 </span> : static const size_type _S_max_size; +<span class="lineNum"> 171 </span> : static const _CharT _S_terminal; +<span class="lineNum"> 172 </span> : +<span class="lineNum"> 173 </span> : // The following storage is init'd to 0 by the linker, resulting +<span class="lineNum"> 174 </span> : // (carefully) in an empty string with one reference. +<span class="lineNum"> 175 </span> : static size_type _S_empty_rep_storage[]; +<span class="lineNum"> 176 </span> : +<span class="lineNum"> 177 </span> : static _Rep& +<span class="lineNum"> 178 </span><span class="lineNoCov"> 0 : _S_empty_rep()</span> +<span class="lineNum"> 179 </span> : { +<span class="lineNum"> 180 </span> : // NB: Mild hack to avoid strict-aliasing warnings. Note that +<span class="lineNum"> 181 </span> : // _S_empty_rep_storage is never modified and the punning should +<span class="lineNum"> 182 </span> : // be reasonably safe in this case. +<span class="lineNum"> 183 </span><span class="lineNoCov"> 0 : void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);</span> +<span class="lineNum"> 184 </span><span class="lineNoCov"> 0 : return *reinterpret_cast<_Rep*>(__p);</span> +<span class="lineNum"> 185 </span> : } +<span class="lineNum"> 186 </span> : +<span class="lineNum"> 187 </span> : bool +<span class="lineNum"> 188 </span><span class="lineNoCov"> 0 : _M_is_leaked() const</span> +<span class="lineNum"> 189 </span><span class="lineNoCov"> 0 : { return this->_M_refcount < 0; }</span> +<span class="lineNum"> 190 </span> : +<span class="lineNum"> 191 </span> : bool +<span class="lineNum"> 192 </span><span class="lineNoCov"> 0 : _M_is_shared() const</span> +<span class="lineNum"> 193 </span><span class="lineNoCov"> 0 : { return this->_M_refcount > 0; }</span> +<span class="lineNum"> 194 </span> : +<span class="lineNum"> 195 </span> : void +<span class="lineNum"> 196 </span><span class="lineNoCov"> 0 : _M_set_leaked()</span> +<span class="lineNum"> 197 </span><span class="lineNoCov"> 0 : { this->_M_refcount = -1; }</span> +<span class="lineNum"> 198 </span> : +<span class="lineNum"> 199 </span> : void +<span class="lineNum"> 200 </span><span class="lineNoCov"> 0 : _M_set_sharable()</span> +<span class="lineNum"> 201 </span><span class="lineNoCov"> 0 : { this->_M_refcount = 0; }</span> +<span class="lineNum"> 202 </span> : +<span class="lineNum"> 203 </span> : void +<span class="lineNum"> 204 </span><span class="lineNoCov"> 0 : _M_set_length_and_sharable(size_type __n)</span> +<span class="lineNum"> 205 </span> : { +<span class="lineNum"> 206 </span><span class="lineNoCov"> 0 : this->_M_set_sharable(); // One reference.</span> +<span class="lineNum"> 207 </span><span class="lineNoCov"> 0 : this->_M_length = __n;</span> +<span class="lineNum"> 208 </span><span class="lineNoCov"> 0 : traits_type::assign(this->_M_refdata()[__n], _S_terminal);</span> +<span class="lineNum"> 209 </span> : // grrr. (per 21.3.4) +<span class="lineNum"> 210 </span> : // You cannot leave those LWG people alone for a second. +<span class="lineNum"> 211 </span><span class="lineNoCov"> 0 : }</span> +<span class="lineNum"> 212 </span> : +<span class="lineNum"> 213 </span> : _CharT* +<span class="lineNum"> 214 </span><span class="lineNoCov"> 0 : _M_refdata() throw()</span> +<span class="lineNum"> 215 </span><span class="lineNoCov"> 0 : { return reinterpret_cast<_CharT*>(this + 1); }</span> +<span class="lineNum"> 216 </span> : +<span class="lineNum"> 217 </span> : _CharT* +<span class="lineNum"> 218 </span> : _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2) +<span class="lineNum"> 219 </span> : { +<span class="lineNum"> 220 </span> : return (!_M_is_leaked() && __alloc1 == __alloc2) +<span class="lineNum"> 221 </span> : ? _M_refcopy() : _M_clone(__alloc1); +<span class="lineNum"> 222 </span> : } +<span class="lineNum"> 223 </span> : +<span class="lineNum"> 224 </span> : // Create & Destroy +<span class="lineNum"> 225 </span> : static _Rep* +<span class="lineNum"> 226 </span> : _S_create(size_type, size_type, const _Alloc&); +<span class="lineNum"> 227 </span> : +<span class="lineNum"> 228 </span> : void +<span class="lineNum"> 229 </span><span class="lineNoCov"> 0 : _M_dispose(const _Alloc& __a)</span> +<span class="lineNum"> 230 </span> : { +<span class="lineNum"> 231 </span> : #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING +<span class="lineNum"> 232 </span><span class="lineNoCov"> 0 : if (__builtin_expect(this != &_S_empty_rep(), false))</span> +<span class="lineNum"> 233 </span> : #endif +<span class="lineNum"> 234 </span><span class="lineNoCov"> 0 : if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,</span> +<span class="lineNum"> 235 </span> : -1) <= 0) +<span class="lineNum"> 236 </span><span class="lineNoCov"> 0 : _M_destroy(__a);</span> +<span class="lineNum"> 237 </span><span class="lineNoCov"> 0 : } // XXX MT</span> +<span class="lineNum"> 238 </span> : +<span class="lineNum"> 239 </span> : void +<span class="lineNum"> 240 </span> : _M_destroy(const _Alloc&) throw(); +<span class="lineNum"> 241 </span> : +<span class="lineNum"> 242 </span> : _CharT* +<span class="lineNum"> 243 </span> : _M_refcopy() throw() +<span class="lineNum"> 244 </span> : { +<span class="lineNum"> 245 </span> : #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING +<span class="lineNum"> 246 </span> : if (__builtin_expect(this != &_S_empty_rep(), false)) +<span class="lineNum"> 247 </span> : #endif +<span class="lineNum"> 248 </span> : __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1); +<span class="lineNum"> 249 </span> : return _M_refdata(); +<span class="lineNum"> 250 </span> : } // XXX MT +<span class="lineNum"> 251 </span> : +<span class="lineNum"> 252 </span> : _CharT* +<span class="lineNum"> 253 </span> : _M_clone(const _Alloc&, size_type __res = 0); +<span class="lineNum"> 254 </span> : }; +<span class="lineNum"> 255 </span> : +<span class="lineNum"> 256 </span> : // Use empty-base optimization: http://www.cantrip.org/emptyopt.html +<span class="lineNum"> 257 </span> : struct _Alloc_hider : _Alloc +<span class="lineNum"> 258 </span><span class="lineNoCov"> 0 : {</span> +<span class="lineNum"> 259 </span><span class="lineNoCov"> 0 : _Alloc_hider(_CharT* __dat, const _Alloc& __a)</span> +<span class="lineNum"> 260 </span><span class="lineNoCov"> 0 : : _Alloc(__a), _M_p(__dat) { }</span> +<span class="lineNum"> 261 </span> : +<span class="lineNum"> 262 </span> : _CharT* _M_p; // The actual data. +<span class="lineNum"> 263 </span> : }; +<span class="lineNum"> 264 </span> : +<span class="lineNum"> 265 </span> : public: +<span class="lineNum"> 266 </span> : // Data Members (public): +<span class="lineNum"> 267 </span> : // NB: This is an unsigned type, and thus represents the maximum +<span class="lineNum"> 268 </span> : // size that the allocator can hold. +<span class="lineNum"> 269 </span> : /// Value returned by various member functions when they fail. +<span class="lineNum"> 270 </span> : static const size_type npos = static_cast<size_type>(-1); +<span class="lineNum"> 271 </span> : +<span class="lineNum"> 272 </span> : private: +<span class="lineNum"> 273 </span> : // Data Members (private): +<span class="lineNum"> 274 </span> : mutable _Alloc_hider _M_dataplus; +<span class="lineNum"> 275 </span> : +<span class="lineNum"> 276 </span> : _CharT* +<span class="lineNum"> 277 </span><span class="lineNoCov"> 0 : _M_data() const</span> +<span class="lineNum"> 278 </span><span class="lineNoCov"> 0 : { return _M_dataplus._M_p; }</span> +<span class="lineNum"> 279 </span> : +<span class="lineNum"> 280 </span> : _CharT* +<span class="lineNum"> 281 </span> : _M_data(_CharT* __p) +<span class="lineNum"> 282 </span> : { return (_M_dataplus._M_p = __p); } +<span class="lineNum"> 283 </span> : +<span class="lineNum"> 284 </span> : _Rep* +<span class="lineNum"> 285 </span><span class="lineNoCov"> 0 : _M_rep() const</span> +<span class="lineNum"> 286 </span><span class="lineNoCov"> 0 : { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }</span> +<span class="lineNum"> 287 </span> : +<span class="lineNum"> 288 </span> : // For the internal use we have functions similar to `begin'/`end' +<span class="lineNum"> 289 </span> : // but they do not call _M_leak. +<span class="lineNum"> 290 </span> : iterator +<span class="lineNum"> 291 </span><span class="lineNoCov"> 0 : _M_ibegin() const</span> +<span class="lineNum"> 292 </span><span class="lineNoCov"> 0 : { return iterator(_M_data()); }</span> +<span class="lineNum"> 293 </span> : +<span class="lineNum"> 294 </span> : iterator +<span class="lineNum"> 295 </span> : _M_iend() const +<span class="lineNum"> 296 </span> : { return iterator(_M_data() + this->size()); } +<span class="lineNum"> 297 </span> : +<span class="lineNum"> 298 </span> : void +<span class="lineNum"> 299 </span><span class="lineNoCov"> 0 : _M_leak() // for use in begin() & non-const op[]</span> +<span class="lineNum"> 300 </span> : { +<span class="lineNum"> 301 </span><span class="lineNoCov"> 0 : if (!_M_rep()->_M_is_leaked())</span> +<span class="lineNum"> 302 </span><span class="lineNoCov"> 0 : _M_leak_hard();</span> +<span class="lineNum"> 303 </span><span class="lineNoCov"> 0 : }</span> +<span class="lineNum"> 304 </span> : +<span class="lineNum"> 305 </span> : size_type +<span class="lineNum"> 306 </span><span class="lineNoCov"> 0 : _M_check(size_type __pos, const char* __s) const</span> +<span class="lineNum"> 307 </span> : { +<span class="lineNum"> 308 </span><span class="lineNoCov"> 0 : if (__pos > this->size())</span> +<span class="lineNum"> 309 </span><span class="lineNoCov"> 0 : __throw_out_of_range(__N(__s));</span> +<span class="lineNum"> 310 </span><span class="lineNoCov"> 0 : return __pos;</span> +<span class="lineNum"> 311 </span> : } +<span class="lineNum"> 312 </span> : +<span class="lineNum"> 313 </span> : void +<span class="lineNum"> 314 </span> : _M_check_length(size_type __n1, size_type __n2, const char* __s) const +<span class="lineNum"> 315 </span> : { +<span class="lineNum"> 316 </span> : if (this->max_size() - (this->size() - __n1) < __n2) +<span class="lineNum"> 317 </span> : __throw_length_error(__N(__s)); +<span class="lineNum"> 318 </span> : } +<span class="lineNum"> 319 </span> : +<span class="lineNum"> 320 </span> : // NB: _M_limit doesn't check for a bad __pos value. +<span class="lineNum"> 321 </span> : size_type +<span class="lineNum"> 322 </span> : _M_limit(size_type __pos, size_type __off) const +<span class="lineNum"> 323 </span> : { +<span class="lineNum"> 324 </span> : const bool __testoff = __off < this->size() - __pos; +<span class="lineNum"> 325 </span> : return __testoff ? __off : this->size() - __pos; +<span class="lineNum"> 326 </span> : } +<span class="lineNum"> 327 </span> : +<span class="lineNum"> 328 </span> : // True if _Rep and source do not overlap. +<span class="lineNum"> 329 </span> : bool +<span class="lineNum"> 330 </span> : _M_disjunct(const _CharT* __s) const +<span class="lineNum"> 331 </span> : { +<span class="lineNum"> 332 </span> : return (less<const _CharT*>()(__s, _M_data()) +<span class="lineNum"> 333 </span> : || less<const _CharT*>()(_M_data() + this->size(), __s)); +<span class="lineNum"> 334 </span> : } +<span class="lineNum"> 335 </span> : +<span class="lineNum"> 336 </span> : // When __n = 1 way faster than the general multichar +<span class="lineNum"> 337 </span> : // traits_type::copy/move/assign. +<span class="lineNum"> 338 </span> : static void +<span class="lineNum"> 339 </span><span class="lineNoCov"> 0 : _M_copy(_CharT* __d, const _CharT* __s, size_type __n)</span> +<span class="lineNum"> 340 </span> : { +<span class="lineNum"> 341 </span><span class="lineNoCov"> 0 : if (__n == 1)</span> +<span class="lineNum"> 342 </span><span class="lineNoCov"> 0 : traits_type::assign(*__d, *__s);</span> +<span class="lineNum"> 343 </span> : else +<span class="lineNum"> 344 </span><span class="lineNoCov"> 0 : traits_type::copy(__d, __s, __n);</span> +<span class="lineNum"> 345 </span><span class="lineNoCov"> 0 : }</span> +<span class="lineNum"> 346 </span> : +<span class="lineNum"> 347 </span> : static void +<span class="lineNum"> 348 </span> : _M_move(_CharT* __d, const _CharT* __s, size_type __n) +<span class="lineNum"> 349 </span> : { +<span class="lineNum"> 350 </span> : if (__n == 1) +<span class="lineNum"> 351 </span> : traits_type::assign(*__d, *__s); +<span class="lineNum"> 352 </span> : else +<span class="lineNum"> 353 </span> : traits_type::move(__d, __s, __n); +<span class="lineNum"> 354 </span> : } +<span class="lineNum"> 355 </span> : +<span class="lineNum"> 356 </span> : static void +<span class="lineNum"> 357 </span> : _M_assign(_CharT* __d, size_type __n, _CharT __c) +<span class="lineNum"> 358 </span> : { +<span class="lineNum"> 359 </span> : if (__n == 1) +<span class="lineNum"> 360 </span> : traits_type::assign(*__d, __c); +<span class="lineNum"> 361 </span> : else +<span class="lineNum"> 362 </span> : traits_type::assign(__d, __n, __c); +<span class="lineNum"> 363 </span> : } +<span class="lineNum"> 364 </span> : +<span class="lineNum"> 365 </span> : // _S_copy_chars is a separate template to permit specialization +<span class="lineNum"> 366 </span> : // to optimize for the common case of pointers as iterators. +<span class="lineNum"> 367 </span> : template<class _Iterator> +<span class="lineNum"> 368 </span> : static void +<span class="lineNum"> 369 </span><span class="lineCov"> 1012 : _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)</span> +<span class="lineNum"> 370 </span> : { +<span class="lineNum"> 371 </span><span class="lineCov"> 11988 : for (; __k1 != __k2; ++__k1, ++__p)</span> +<span class="lineNum"> 372 </span><span class="lineCov"> 10976 : traits_type::assign(*__p, *__k1); // These types are off.</span> +<span class="lineNum"> 373 </span><span class="lineCov"> 1012 : }</span> +<span class="lineNum"> 374 </span> : +<span class="lineNum"> 375 </span> : static void +<span class="lineNum"> 376 </span><span class="lineNoCov"> 0 : _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)</span> +<span class="lineNum"> 377 </span><span class="lineNoCov"> 0 : { _S_copy_chars(__p, __k1.base(), __k2.base()); }</span> +<span class="lineNum"> 378 </span> : +<span class="lineNum"> 379 </span> : static void +<span class="lineNum"> 380 </span> : _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2) +<span class="lineNum"> 381 </span> : { _S_copy_chars(__p, __k1.base(), __k2.base()); } +<span class="lineNum"> 382 </span> : +<span class="lineNum"> 383 </span> : static void +<span class="lineNum"> 384 </span><span class="lineNoCov"> 0 : _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)</span> +<span class="lineNum"> 385 </span><span class="lineNoCov"> 0 : { _M_copy(__p, __k1, __k2 - __k1); }</span> +<span class="lineNum"> 386 </span> : +<span class="lineNum"> 387 </span> : static void +<span class="lineNum"> 388 </span> : _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) +<span class="lineNum"> 389 </span> : { _M_copy(__p, __k1, __k2 - __k1); } +<span class="lineNum"> 390 </span> : +<span class="lineNum"> 391 </span> : static int +<span class="lineNum"> 392 </span><span class="lineNoCov"> 0 : _S_compare(size_type __n1, size_type __n2)</span> +<span class="lineNum"> 393 </span> : { +<span class="lineNum"> 394 </span><span class="lineNoCov"> 0 : const difference_type __d = difference_type(__n1 - __n2);</span> +<span class="lineNum"> 395 </span> : +<span class="lineNum"> 396 </span> : if (__d > __gnu_cxx::__numeric_traits<int>::__max) +<span class="lineNum"> 397 </span> : return __gnu_cxx::__numeric_traits<int>::__max; +<span class="lineNum"> 398 </span> : else if (__d < __gnu_cxx::__numeric_traits<int>::__min) +<span class="lineNum"> 399 </span> : return __gnu_cxx::__numeric_traits<int>::__min; +<span class="lineNum"> 400 </span> : else +<span class="lineNum"> 401 </span><span class="lineNoCov"> 0 : return int(__d);</span> +<span class="lineNum"> 402 </span> : } +<span class="lineNum"> 403 </span> : +<span class="lineNum"> 404 </span> : void +<span class="lineNum"> 405 </span> : _M_mutate(size_type __pos, size_type __len1, size_type __len2); +<span class="lineNum"> 406 </span> : +<span class="lineNum"> 407 </span> : void +<span class="lineNum"> 408 </span> : _M_leak_hard(); +<span class="lineNum"> 409 </span> : +<span class="lineNum"> 410 </span> : static _Rep& +<span class="lineNum"> 411 </span><span class="lineNoCov"> 0 : _S_empty_rep()</span> +<span class="lineNum"> 412 </span><span class="lineNoCov"> 0 : { return _Rep::_S_empty_rep(); }</span> +<span class="lineNum"> 413 </span> : +<span class="lineNum"> 414 </span> : public: +<span class="lineNum"> 415 </span> : // Construct/copy/destroy: +<span class="lineNum"> 416 </span> : // NB: We overload ctors in some cases instead of using default +<span class="lineNum"> 417 </span> : // arguments, per 17.4.4.4 para. 2 item 2. +<span class="lineNum"> 418 </span> : +<span class="lineNum"> 419 </span> : /** +<span class="lineNum"> 420 </span> : * @brief Default constructor creates an empty string. +<span class="lineNum"> 421 </span> : */ +<span class="lineNum"> 422 </span> : inline +<span class="lineNum"> 423 </span> : basic_string(); +<span class="lineNum"> 424 </span> : +<span class="lineNum"> 425 </span> : /** +<span class="lineNum"> 426 </span> : * @brief Construct an empty string using allocator @a a. +<span class="lineNum"> 427 </span> : */ +<span class="lineNum"> 428 </span> : explicit +<span class="lineNum"> 429 </span> : basic_string(const _Alloc& __a); +<span class="lineNum"> 430 </span> : +<span class="lineNum"> 431 </span> : // NB: per LWG issue 42, semantics different from IS: +<span class="lineNum"> 432 </span> : /** +<span class="lineNum"> 433 </span> : * @brief Construct string with copy of value of @a str. +<span class="lineNum"> 434 </span> : * @param str Source string. +<span class="lineNum"> 435 </span> : */ +<span class="lineNum"> 436 </span> : basic_string(const basic_string& __str); +<span class="lineNum"> 437 </span> : /** +<span class="lineNum"> 438 </span> : * @brief Construct string as copy of a substring. +<span class="lineNum"> 439 </span> : * @param str Source string. +<span class="lineNum"> 440 </span> : * @param pos Index of first character to copy from. +<span class="lineNum"> 441 </span> : * @param n Number of characters to copy (default remainder). +<span class="lineNum"> 442 </span> : */ +<span class="lineNum"> 443 </span> : basic_string(const basic_string& __str, size_type __pos, +<span class="lineNum"> 444 </span> : size_type __n = npos); +<span class="lineNum"> 445 </span> : /** +<span class="lineNum"> 446 </span> : * @brief Construct string as copy of a substring. +<span class="lineNum"> 447 </span> : * @param str Source string. +<span class="lineNum"> 448 </span> : * @param pos Index of first character to copy from. +<span class="lineNum"> 449 </span> : * @param n Number of characters to copy. +<span class="lineNum"> 450 </span> : * @param a Allocator to use. +<span class="lineNum"> 451 </span> : */ +<span class="lineNum"> 452 </span> : basic_string(const basic_string& __str, size_type __pos, +<span class="lineNum"> 453 </span> : size_type __n, const _Alloc& __a); +<span class="lineNum"> 454 </span> : +<span class="lineNum"> 455 </span> : /** +<span class="lineNum"> 456 </span> : * @brief Construct string initialized by a character array. +<span class="lineNum"> 457 </span> : * @param s Source character array. +<span class="lineNum"> 458 </span> : * @param n Number of characters to copy. +<span class="lineNum"> 459 </span> : * @param a Allocator to use (default is default allocator). +<span class="lineNum"> 460 </span> : * +<span class="lineNum"> 461 </span> : * NB: @a s must have at least @a n characters, '\0' has no special +<span class="lineNum"> 462 </span> : * meaning. +<span class="lineNum"> 463 </span> : */ +<span class="lineNum"> 464 </span> : basic_string(const _CharT* __s, size_type __n, +<span class="lineNum"> 465 </span> : const _Alloc& __a = _Alloc()); +<span class="lineNum"> 466 </span> : /** +<span class="lineNum"> 467 </span> : * @brief Construct string as copy of a C string. +<span class="lineNum"> 468 </span> : * @param s Source C string. +<span class="lineNum"> 469 </span> : * @param a Allocator to use (default is default allocator). +<span class="lineNum"> 470 </span> : */ +<span class="lineNum"> 471 </span> : basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()); +<span class="lineNum"> 472 </span> : /** +<span class="lineNum"> 473 </span> : * @brief Construct string as multiple characters. +<span class="lineNum"> 474 </span> : * @param n Number of characters. +<span class="lineNum"> 475 </span> : * @param c Character to use. +<span class="lineNum"> 476 </span> : * @param a Allocator to use (default is default allocator). +<span class="lineNum"> 477 </span> : */ +<span class="lineNum"> 478 </span> : basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()); +<span class="lineNum"> 479 </span> : +<span class="lineNum"> 480 </span> : /** +<span class="lineNum"> 481 </span> : * @brief Construct string as copy of a range. +<span class="lineNum"> 482 </span> : * @param beg Start of range. +<span class="lineNum"> 483 </span> : * @param end End of range. +<span class="lineNum"> 484 </span> : * @param a Allocator to use (default is default allocator). +<span class="lineNum"> 485 </span> : */ +<span class="lineNum"> 486 </span> : template<class _InputIterator> +<span class="lineNum"> 487 </span> : basic_string(_InputIterator __beg, _InputIterator __end, +<span class="lineNum"> 488 </span> : const _Alloc& __a = _Alloc()); +<span class="lineNum"> 489 </span> : +<span class="lineNum"> 490 </span> : /** +<span class="lineNum"> 491 </span> : * @brief Destroy the string instance. +<span class="lineNum"> 492 </span> : */ +<span class="lineNum"> 493 </span><span class="lineNoCov"> 0 : ~basic_string()</span> +<span class="lineNum"> 494 </span><span class="lineNoCov"> 0 : { _M_rep()->_M_dispose(this->get_allocator()); }</span> +<span class="lineNum"> 495 </span> : +<span class="lineNum"> 496 </span> : /** +<span class="lineNum"> 497 </span> : * @brief Assign the value of @a str to this string. +<span class="lineNum"> 498 </span> : * @param str Source string. +<span class="lineNum"> 499 </span> : */ +<span class="lineNum"> 500 </span> : basic_string& +<span class="lineNum"> 501 </span><span class="lineNoCov"> 0 : operator=(const basic_string& __str) </span> +<span class="lineNum"> 502 </span><span class="lineNoCov"> 0 : { return this->assign(__str); }</span> +<span class="lineNum"> 503 </span> : +<span class="lineNum"> 504 </span> : /** +<span class="lineNum"> 505 </span> : * @brief Copy contents of @a s into this string. +<span class="lineNum"> 506 </span> : * @param s Source null-terminated string. +<span class="lineNum"> 507 </span> : */ +<span class="lineNum"> 508 </span> : basic_string& +<span class="lineNum"> 509 </span><span class="lineNoCov"> 0 : operator=(const _CharT* __s) </span> +<span class="lineNum"> 510 </span><span class="lineNoCov"> 0 : { return this->assign(__s); }</span> +<span class="lineNum"> 511 </span> : +<span class="lineNum"> 512 </span> : /** +<span class="lineNum"> 513 </span> : * @brief Set value to string of length 1. +<span class="lineNum"> 514 </span> : * @param c Source character. +<span class="lineNum"> 515 </span> : * +<span class="lineNum"> 516 </span> : * Assigning to a character makes this string length 1 and +<span class="lineNum"> 517 </span> : * (*this)[0] == @a c. +<span class="lineNum"> 518 </span> : */ +<span class="lineNum"> 519 </span> : basic_string& +<span class="lineNum"> 520 </span> : operator=(_CharT __c) +<span class="lineNum"> 521 </span> : { +<span class="lineNum"> 522 </span> : this->assign(1, __c); +<span class="lineNum"> 523 </span> : return *this; +<span class="lineNum"> 524 </span> : } +<span class="lineNum"> 525 </span> : +<span class="lineNum"> 526 </span> : // Iterators: +<span class="lineNum"> 527 </span> : /** +<span class="lineNum"> 528 </span> : * Returns a read/write iterator that points to the first character in +<span class="lineNum"> 529 </span> : * the %string. Unshares the string. +<span class="lineNum"> 530 </span> : */ +<span class="lineNum"> 531 </span> : iterator +<span class="lineNum"> 532 </span><span class="lineNoCov"> 0 : begin()</span> +<span class="lineNum"> 533 </span> : { +<span class="lineNum"> 534 </span><span class="lineNoCov"> 0 : _M_leak();</span> +<span class="lineNum"> 535 </span><span class="lineNoCov"> 0 : return iterator(_M_data());</span> +<span class="lineNum"> 536 </span> : } +<span class="lineNum"> 537 </span> : +<span class="lineNum"> 538 </span> : /** +<span class="lineNum"> 539 </span> : * Returns a read-only (constant) iterator that points to the first +<span class="lineNum"> 540 </span> : * character in the %string. +<span class="lineNum"> 541 </span> : */ +<span class="lineNum"> 542 </span> : const_iterator +<span class="lineNum"> 543 </span><span class="lineNoCov"> 0 : begin() const</span> +<span class="lineNum"> 544 </span><span class="lineNoCov"> 0 : { return const_iterator(_M_data()); }</span> +<span class="lineNum"> 545 </span> : +<span class="lineNum"> 546 </span> : /** +<span class="lineNum"> 547 </span> : * Returns a read/write iterator that points one past the last +<span class="lineNum"> 548 </span> : * character in the %string. Unshares the string. +<span class="lineNum"> 549 </span> : */ +<span class="lineNum"> 550 </span> : iterator +<span class="lineNum"> 551 </span><span class="lineNoCov"> 0 : end()</span> +<span class="lineNum"> 552 </span> : { +<span class="lineNum"> 553 </span><span class="lineNoCov"> 0 : _M_leak();</span> +<span class="lineNum"> 554 </span><span class="lineNoCov"> 0 : return iterator(_M_data() + this->size());</span> +<span class="lineNum"> 555 </span> : } +<span class="lineNum"> 556 </span> : +<span class="lineNum"> 557 </span> : /** +<span class="lineNum"> 558 </span> : * Returns a read-only (constant) iterator that points one past the +<span class="lineNum"> 559 </span> : * last character in the %string. +<span class="lineNum"> 560 </span> : */ +<span class="lineNum"> 561 </span> : const_iterator +<span class="lineNum"> 562 </span><span class="lineNoCov"> 0 : end() const</span> +<span class="lineNum"> 563 </span><span class="lineNoCov"> 0 : { return const_iterator(_M_data() + this->size()); }</span> +<span class="lineNum"> 564 </span> : +<span class="lineNum"> 565 </span> : /** +<span class="lineNum"> 566 </span> : * Returns a read/write reverse iterator that points to the last +<span class="lineNum"> 567 </span> : * character in the %string. Iteration is done in reverse element +<span class="lineNum"> 568 </span> : * order. Unshares the string. +<span class="lineNum"> 569 </span> : */ +<span class="lineNum"> 570 </span> : reverse_iterator +<span class="lineNum"> 571 </span> : rbegin() +<span class="lineNum"> 572 </span> : { return reverse_iterator(this->end()); } +<span class="lineNum"> 573 </span> : +<span class="lineNum"> 574 </span> : /** +<span class="lineNum"> 575 </span> : * Returns a read-only (constant) reverse iterator that points +<span class="lineNum"> 576 </span> : * to the last character in the %string. Iteration is done in +<span class="lineNum"> 577 </span> : * reverse element order. +<span class="lineNum"> 578 </span> : */ +<span class="lineNum"> 579 </span> : const_reverse_iterator +<span class="lineNum"> 580 </span> : rbegin() const +<span class="lineNum"> 581 </span> : { return const_reverse_iterator(this->end()); } +<span class="lineNum"> 582 </span> : +<span class="lineNum"> 583 </span> : /** +<span class="lineNum"> 584 </span> : * Returns a read/write reverse iterator that points to one before the +<span class="lineNum"> 585 </span> : * first character in the %string. Iteration is done in reverse +<span class="lineNum"> 586 </span> : * element order. Unshares the string. +<span class="lineNum"> 587 </span> : */ +<span class="lineNum"> 588 </span> : reverse_iterator +<span class="lineNum"> 589 </span> : rend() +<span class="lineNum"> 590 </span> : { return reverse_iterator(this->begin()); } +<span class="lineNum"> 591 </span> : +<span class="lineNum"> 592 </span> : /** +<span class="lineNum"> 593 </span> : * Returns a read-only (constant) reverse iterator that points +<span class="lineNum"> 594 </span> : * to one before the first character in the %string. Iteration +<span class="lineNum"> 595 </span> : * is done in reverse element order. +<span class="lineNum"> 596 </span> : */ +<span class="lineNum"> 597 </span> : const_reverse_iterator +<span class="lineNum"> 598 </span> : rend() const +<span class="lineNum"> 599 </span> : { return const_reverse_iterator(this->begin()); } +<span class="lineNum"> 600 </span> : +<span class="lineNum"> 601 </span> : public: +<span class="lineNum"> 602 </span> : // Capacity: +<span class="lineNum"> 603 </span> : /// Returns the number of characters in the string, not including any +<span class="lineNum"> 604 </span> : /// null-termination. +<span class="lineNum"> 605 </span> : size_type +<span class="lineNum"> 606 </span><span class="lineNoCov"> 0 : size() const</span> +<span class="lineNum"> 607 </span><span class="lineNoCov"> 0 : { return _M_rep()->_M_length; }</span> +<span class="lineNum"> 608 </span> : +<span class="lineNum"> 609 </span> : /// Returns the number of characters in the string, not including any +<span class="lineNum"> 610 </span> : /// null-termination. +<span class="lineNum"> 611 </span> : size_type +<span class="lineNum"> 612 </span><span class="lineNoCov"> 0 : length() const</span> +<span class="lineNum"> 613 </span><span class="lineNoCov"> 0 : { return _M_rep()->_M_length; }</span> +<span class="lineNum"> 614 </span> : +<span class="lineNum"> 615 </span> : /// Returns the size() of the largest possible %string. +<span class="lineNum"> 616 </span> : size_type +<span class="lineNum"> 617 </span> : max_size() const +<span class="lineNum"> 618 </span> : { return _Rep::_S_max_size; } +<span class="lineNum"> 619 </span> : +<span class="lineNum"> 620 </span> : /** +<span class="lineNum"> 621 </span> : * @brief Resizes the %string to the specified number of characters. +<span class="lineNum"> 622 </span> : * @param n Number of characters the %string should contain. +<span class="lineNum"> 623 </span> : * @param c Character to fill any new elements. +<span class="lineNum"> 624 </span> : * +<span class="lineNum"> 625 </span> : * This function will %resize the %string to the specified +<span class="lineNum"> 626 </span> : * number of characters. If the number is smaller than the +<span class="lineNum"> 627 </span> : * %string's current size the %string is truncated, otherwise +<span class="lineNum"> 628 </span> : * the %string is extended and new elements are set to @a c. +<span class="lineNum"> 629 </span> : */ +<span class="lineNum"> 630 </span> : void +<span class="lineNum"> 631 </span> : resize(size_type __n, _CharT __c); +<span class="lineNum"> 632 </span> : +<span class="lineNum"> 633 </span> : /** +<span class="lineNum"> 634 </span> : * @brief Resizes the %string to the specified number of characters. +<span class="lineNum"> 635 </span> : * @param n Number of characters the %string should contain. +<span class="lineNum"> 636 </span> : * +<span class="lineNum"> 637 </span> : * This function will resize the %string to the specified length. If +<span class="lineNum"> 638 </span> : * the new size is smaller than the %string's current size the %string +<span class="lineNum"> 639 </span> : * is truncated, otherwise the %string is extended and new characters +<span class="lineNum"> 640 </span> : * are default-constructed. For basic types such as char, this means +<span class="lineNum"> 641 </span> : * setting them to 0. +<span class="lineNum"> 642 </span> : */ +<span class="lineNum"> 643 </span> : void +<span class="lineNum"> 644 </span><span class="lineNoCov"> 0 : resize(size_type __n)</span> +<span class="lineNum"> 645 </span><span class="lineNoCov"> 0 : { this->resize(__n, _CharT()); }</span> +<span class="lineNum"> 646 </span> : +<span class="lineNum"> 647 </span> : /** +<span class="lineNum"> 648 </span> : * Returns the total number of characters that the %string can hold +<span class="lineNum"> 649 </span> : * before needing to allocate more memory. +<span class="lineNum"> 650 </span> : */ +<span class="lineNum"> 651 </span> : size_type +<span class="lineNum"> 652 </span><span class="lineNoCov"> 0 : capacity() const</span> +<span class="lineNum"> 653 </span><span class="lineNoCov"> 0 : { return _M_rep()->_M_capacity; }</span> +<span class="lineNum"> 654 </span> : +<span class="lineNum"> 655 </span> : /** +<span class="lineNum"> 656 </span> : * @brief Attempt to preallocate enough memory for specified number of +<span class="lineNum"> 657 </span> : * characters. +<span class="lineNum"> 658 </span> : * @param res_arg Number of characters required. +<span class="lineNum"> 659 </span> : * @throw std::length_error If @a res_arg exceeds @c max_size(). +<span class="lineNum"> 660 </span> : * +<span class="lineNum"> 661 </span> : * This function attempts to reserve enough memory for the +<span class="lineNum"> 662 </span> : * %string to hold the specified number of characters. If the +<span class="lineNum"> 663 </span> : * number requested is more than max_size(), length_error is +<span class="lineNum"> 664 </span> : * thrown. +<span class="lineNum"> 665 </span> : * +<span class="lineNum"> 666 </span> : * The advantage of this function is that if optimal code is a +<span class="lineNum"> 667 </span> : * necessity and the user can determine the string length that will be +<span class="lineNum"> 668 </span> : * required, the user can reserve the memory in %advance, and thus +<span class="lineNum"> 669 </span> : * prevent a possible reallocation of memory and copying of %string +<span class="lineNum"> 670 </span> : * data. +<span class="lineNum"> 671 </span> : */ +<span class="lineNum"> 672 </span> : void +<span class="lineNum"> 673 </span> : reserve(size_type __res_arg = 0); +<span class="lineNum"> 674 </span> : +<span class="lineNum"> 675 </span> : /** +<span class="lineNum"> 676 </span> : * Erases the string, making it empty. +<span class="lineNum"> 677 </span> : */ +<span class="lineNum"> 678 </span> : void +<span class="lineNum"> 679 </span><span class="lineNoCov"> 0 : clear()</span> +<span class="lineNum"> 680 </span><span class="lineNoCov"> 0 : { _M_mutate(0, this->size(), 0); }</span> +<span class="lineNum"> 681 </span> : +<span class="lineNum"> 682 </span> : /** +<span class="lineNum"> 683 </span> : * Returns true if the %string is empty. Equivalent to *this == "". +<span class="lineNum"> 684 </span> : */ +<span class="lineNum"> 685 </span> : bool +<span class="lineNum"> 686 </span><span class="lineNoCov"> 0 : empty() const</span> +<span class="lineNum"> 687 </span><span class="lineNoCov"> 0 : { return this->size() == 0; }</span> +<span class="lineNum"> 688 </span> : +<span class="lineNum"> 689 </span> : // Element access: +<span class="lineNum"> 690 </span> : /** +<span class="lineNum"> 691 </span> : * @brief Subscript access to the data contained in the %string. +<span class="lineNum"> 692 </span> : * @param pos The index of the character to access. +<span class="lineNum"> 693 </span> : * @return Read-only (constant) reference to the character. +<span class="lineNum"> 694 </span> : * +<span class="lineNum"> 695 </span> : * This operator allows for easy, array-style, data access. +<span class="lineNum"> 696 </span> : * Note that data access with this operator is unchecked and +<span class="lineNum"> 697 </span> : * out_of_range lookups are not defined. (For checked lookups +<span class="lineNum"> 698 </span> : * see at().) +<span class="lineNum"> 699 </span> : */ +<span class="lineNum"> 700 </span> : const_reference +<span class="lineNum"> 701 </span><span class="lineNoCov"> 0 : operator[] (size_type __pos) const</span> +<span class="lineNum"> 702 </span> : { +<span class="lineNum"> 703 </span> : _GLIBCXX_DEBUG_ASSERT(__pos <= size()); +<span class="lineNum"> 704 </span><span class="lineNoCov"> 0 : return _M_data()[__pos];</span> +<span class="lineNum"> 705 </span> : } +<span class="lineNum"> 706 </span> : +<span class="lineNum"> 707 </span> : /** +<span class="lineNum"> 708 </span> : * @brief Subscript access to the data contained in the %string. +<span class="lineNum"> 709 </span> : * @param pos The index of the character to access. +<span class="lineNum"> 710 </span> : * @return Read/write reference to the character. +<span class="lineNum"> 711 </span> : * +<span class="lineNum"> 712 </span> : * This operator allows for easy, array-style, data access. +<span class="lineNum"> 713 </span> : * Note that data access with this operator is unchecked and +<span class="lineNum"> 714 </span> : * out_of_range lookups are not defined. (For checked lookups +<span class="lineNum"> 715 </span> : * see at().) Unshares the string. +<span class="lineNum"> 716 </span> : */ +<span class="lineNum"> 717 </span> : reference +<span class="lineNum"> 718 </span><span class="lineNoCov"> 0 : operator[](size_type __pos)</span> +<span class="lineNum"> 719 </span> : { +<span class="lineNum"> 720 </span> : // allow pos == size() as v3 extension: +<span class="lineNum"> 721 </span> : _GLIBCXX_DEBUG_ASSERT(__pos <= size()); +<span class="lineNum"> 722 </span> : // but be strict in pedantic mode: +<span class="lineNum"> 723 </span> : _GLIBCXX_DEBUG_PEDASSERT(__pos < size()); +<span class="lineNum"> 724 </span><span class="lineNoCov"> 0 : _M_leak();</span> +<span class="lineNum"> 725 </span><span class="lineNoCov"> 0 : return _M_data()[__pos];</span> +<span class="lineNum"> 726 </span> : } +<span class="lineNum"> 727 </span> : +<span class="lineNum"> 728 </span> : /** +<span class="lineNum"> 729 </span> : * @brief Provides access to the data contained in the %string. +<span class="lineNum"> 730 </span> : * @param n The index of the character to access. +<span class="lineNum"> 731 </span> : * @return Read-only (const) reference to the character. +<span class="lineNum"> 732 </span> : * @throw std::out_of_range If @a n is an invalid index. +<span class="lineNum"> 733 </span> : * +<span class="lineNum"> 734 </span> : * This function provides for safer data access. The parameter is +<span class="lineNum"> 735 </span> : * first checked that it is in the range of the string. The function +<span class="lineNum"> 736 </span> : * throws out_of_range if the check fails. +<span class="lineNum"> 737 </span> : */ +<span class="lineNum"> 738 </span> : const_reference +<span class="lineNum"> 739 </span> : at(size_type __n) const +<span class="lineNum"> 740 </span> : { +<span class="lineNum"> 741 </span> : if (__n >= this->size()) +<span class="lineNum"> 742 </span> : __throw_out_of_range(__N("basic_string::at")); +<span class="lineNum"> 743 </span> : return _M_data()[__n]; +<span class="lineNum"> 744 </span> : } +<span class="lineNum"> 745 </span> : +<span class="lineNum"> 746 </span> : /** +<span class="lineNum"> 747 </span> : * @brief Provides access to the data contained in the %string. +<span class="lineNum"> 748 </span> : * @param n The index of the character to access. +<span class="lineNum"> 749 </span> : * @return Read/write reference to the character. +<span class="lineNum"> 750 </span> : * @throw std::out_of_range If @a n is an invalid index. +<span class="lineNum"> 751 </span> : * +<span class="lineNum"> 752 </span> : * This function provides for safer data access. The parameter is +<span class="lineNum"> 753 </span> : * first checked that it is in the range of the string. The function +<span class="lineNum"> 754 </span> : * throws out_of_range if the check fails. Success results in +<span class="lineNum"> 755 </span> : * unsharing the string. +<span class="lineNum"> 756 </span> : */ +<span class="lineNum"> 757 </span> : reference +<span class="lineNum"> 758 </span> : at(size_type __n) +<span class="lineNum"> 759 </span> : { +<span class="lineNum"> 760 </span> : if (__n >= size()) +<span class="lineNum"> 761 </span> : __throw_out_of_range(__N("basic_string::at")); +<span class="lineNum"> 762 </span> : _M_leak(); +<span class="lineNum"> 763 </span> : return _M_data()[__n]; +<span class="lineNum"> 764 </span> : } +<span class="lineNum"> 765 </span> : +<span class="lineNum"> 766 </span> : // Modifiers: +<span class="lineNum"> 767 </span> : /** +<span class="lineNum"> 768 </span> : * @brief Append a string to this string. +<span class="lineNum"> 769 </span> : * @param str The string to append. +<span class="lineNum"> 770 </span> : * @return Reference to this string. +<span class="lineNum"> 771 </span> : */ +<span class="lineNum"> 772 </span> : basic_string& +<span class="lineNum"> 773 </span><span class="lineNoCov"> 0 : operator+=(const basic_string& __str)</span> +<span class="lineNum"> 774 </span><span class="lineNoCov"> 0 : { return this->append(__str); }</span> +<span class="lineNum"> 775 </span> : +<span class="lineNum"> 776 </span> : /** +<span class="lineNum"> 777 </span> : * @brief Append a C string. +<span class="lineNum"> 778 </span> : * @param s The C string to append. +<span class="lineNum"> 779 </span> : * @return Reference to this string. +<span class="lineNum"> 780 </span> : */ +<span class="lineNum"> 781 </span> : basic_string& +<span class="lineNum"> 782 </span><span class="lineNoCov"> 0 : operator+=(const _CharT* __s)</span> +<span class="lineNum"> 783 </span><span class="lineNoCov"> 0 : { return this->append(__s); }</span> +<span class="lineNum"> 784 </span> : +<span class="lineNum"> 785 </span> : /** +<span class="lineNum"> 786 </span> : * @brief Append a character. +<span class="lineNum"> 787 </span> : * @param c The character to append. +<span class="lineNum"> 788 </span> : * @return Reference to this string. +<span class="lineNum"> 789 </span> : */ +<span class="lineNum"> 790 </span> : basic_string& +<span class="lineNum"> 791 </span><span class="lineNoCov"> 0 : operator+=(_CharT __c)</span> +<span class="lineNum"> 792 </span> : { +<span class="lineNum"> 793 </span><span class="lineNoCov"> 0 : this->push_back(__c);</span> +<span class="lineNum"> 794 </span><span class="lineNoCov"> 0 : return *this;</span> +<span class="lineNum"> 795 </span> : } +<span class="lineNum"> 796 </span> : +<span class="lineNum"> 797 </span> : /** +<span class="lineNum"> 798 </span> : * @brief Append a string to this string. +<span class="lineNum"> 799 </span> : * @param str The string to append. +<span class="lineNum"> 800 </span> : * @return Reference to this string. +<span class="lineNum"> 801 </span> : */ +<span class="lineNum"> 802 </span> : basic_string& +<span class="lineNum"> 803 </span> : append(const basic_string& __str); +<span class="lineNum"> 804 </span> : +<span class="lineNum"> 805 </span> : /** +<span class="lineNum"> 806 </span> : * @brief Append a substring. +<span class="lineNum"> 807 </span> : * @param str The string to append. +<span class="lineNum"> 808 </span> : * @param pos Index of the first character of str to append. +<span class="lineNum"> 809 </span> : * @param n The number of characters to append. +<span class="lineNum"> 810 </span> : * @return Reference to this string. +<span class="lineNum"> 811 </span> : * @throw std::out_of_range if @a pos is not a valid index. +<span class="lineNum"> 812 </span> : * +<span class="lineNum"> 813 </span> : * This function appends @a n characters from @a str starting at @a pos +<span class="lineNum"> 814 </span> : * to this string. If @a n is is larger than the number of available +<span class="lineNum"> 815 </span> : * characters in @a str, the remainder of @a str is appended. +<span class="lineNum"> 816 </span> : */ +<span class="lineNum"> 817 </span> : basic_string& +<span class="lineNum"> 818 </span> : append(const basic_string& __str, size_type __pos, size_type __n); +<span class="lineNum"> 819 </span> : +<span class="lineNum"> 820 </span> : /** +<span class="lineNum"> 821 </span> : * @brief Append a C substring. +<span class="lineNum"> 822 </span> : * @param s The C string to append. +<span class="lineNum"> 823 </span> : * @param n The number of characters to append. +<span class="lineNum"> 824 </span> : * @return Reference to this string. +<span class="lineNum"> 825 </span> : */ +<span class="lineNum"> 826 </span> : basic_string& +<span class="lineNum"> 827 </span> : append(const _CharT* __s, size_type __n); +<span class="lineNum"> 828 </span> : +<span class="lineNum"> 829 </span> : /** +<span class="lineNum"> 830 </span> : * @brief Append a C string. +<span class="lineNum"> 831 </span> : * @param s The C string to append. +<span class="lineNum"> 832 </span> : * @return Reference to this string. +<span class="lineNum"> 833 </span> : */ +<span class="lineNum"> 834 </span> : basic_string& +<span class="lineNum"> 835 </span><span class="lineNoCov"> 0 : append(const _CharT* __s)</span> +<span class="lineNum"> 836 </span> : { +<span class="lineNum"> 837 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 838 </span><span class="lineNoCov"> 0 : return this->append(__s, traits_type::length(__s));</span> +<span class="lineNum"> 839 </span> : } +<span class="lineNum"> 840 </span> : +<span class="lineNum"> 841 </span> : /** +<span class="lineNum"> 842 </span> : * @brief Append multiple characters. +<span class="lineNum"> 843 </span> : * @param n The number of characters to append. +<span class="lineNum"> 844 </span> : * @param c The character to use. +<span class="lineNum"> 845 </span> : * @return Reference to this string. +<span class="lineNum"> 846 </span> : * +<span class="lineNum"> 847 </span> : * Appends n copies of c to this string. +<span class="lineNum"> 848 </span> : */ +<span class="lineNum"> 849 </span> : basic_string& +<span class="lineNum"> 850 </span> : append(size_type __n, _CharT __c); +<span class="lineNum"> 851 </span> : +<span class="lineNum"> 852 </span> : /** +<span class="lineNum"> 853 </span> : * @brief Append a range of characters. +<span class="lineNum"> 854 </span> : * @param first Iterator referencing the first character to append. +<span class="lineNum"> 855 </span> : * @param last Iterator marking the end of the range. +<span class="lineNum"> 856 </span> : * @return Reference to this string. +<span class="lineNum"> 857 </span> : * +<span class="lineNum"> 858 </span> : * Appends characters in the range [first,last) to this string. +<span class="lineNum"> 859 </span> : */ +<span class="lineNum"> 860 </span> : template<class _InputIterator> +<span class="lineNum"> 861 </span> : basic_string& +<span class="lineNum"> 862 </span> : append(_InputIterator __first, _InputIterator __last) +<span class="lineNum"> 863 </span> : { return this->replace(_M_iend(), _M_iend(), __first, __last); } +<span class="lineNum"> 864 </span> : +<span class="lineNum"> 865 </span> : /** +<span class="lineNum"> 866 </span> : * @brief Append a single character. +<span class="lineNum"> 867 </span> : * @param c Character to append. +<span class="lineNum"> 868 </span> : */ +<span class="lineNum"> 869 </span> : void +<span class="lineNum"> 870 </span><span class="lineNoCov"> 0 : push_back(_CharT __c)</span> +<span class="lineNum"> 871 </span> : { +<span class="lineNum"> 872 </span><span class="lineNoCov"> 0 : const size_type __len = 1 + this->size();</span> +<span class="lineNum"> 873 </span><span class="lineNoCov"> 0 : if (__len > this->capacity() || _M_rep()->_M_is_shared())</span> +<span class="lineNum"> 874 </span><span class="lineNoCov"> 0 : this->reserve(__len);</span> +<span class="lineNum"> 875 </span><span class="lineNoCov"> 0 : traits_type::assign(_M_data()[this->size()], __c);</span> +<span class="lineNum"> 876 </span><span class="lineNoCov"> 0 : _M_rep()->_M_set_length_and_sharable(__len);</span> +<span class="lineNum"> 877 </span><span class="lineNoCov"> 0 : }</span> +<span class="lineNum"> 878 </span> : +<span class="lineNum"> 879 </span> : /** +<span class="lineNum"> 880 </span> : * @brief Set value to contents of another string. +<span class="lineNum"> 881 </span> : * @param str Source string to use. +<span class="lineNum"> 882 </span> : * @return Reference to this string. +<span class="lineNum"> 883 </span> : */ +<span class="lineNum"> 884 </span> : basic_string& +<span class="lineNum"> 885 </span> : assign(const basic_string& __str); +<span class="lineNum"> 886 </span> : +<span class="lineNum"> 887 </span> : /** +<span class="lineNum"> 888 </span> : * @brief Set value to a substring of a string. +<span class="lineNum"> 889 </span> : * @param str The string to use. +<span class="lineNum"> 890 </span> : * @param pos Index of the first character of str. +<span class="lineNum"> 891 </span> : * @param n Number of characters to use. +<span class="lineNum"> 892 </span> : * @return Reference to this string. +<span class="lineNum"> 893 </span> : * @throw std::out_of_range if @a pos is not a valid index. +<span class="lineNum"> 894 </span> : * +<span class="lineNum"> 895 </span> : * This function sets this string to the substring of @a str consisting +<span class="lineNum"> 896 </span> : * of @a n characters at @a pos. If @a n is is larger than the number +<span class="lineNum"> 897 </span> : * of available characters in @a str, the remainder of @a str is used. +<span class="lineNum"> 898 </span> : */ +<span class="lineNum"> 899 </span> : basic_string& +<span class="lineNum"> 900 </span> : assign(const basic_string& __str, size_type __pos, size_type __n) +<span class="lineNum"> 901 </span> : { return this->assign(__str._M_data() +<span class="lineNum"> 902 </span> : + __str._M_check(__pos, "basic_string::assign"), +<span class="lineNum"> 903 </span> : __str._M_limit(__pos, __n)); } +<span class="lineNum"> 904 </span> : +<span class="lineNum"> 905 </span> : /** +<span class="lineNum"> 906 </span> : * @brief Set value to a C substring. +<span class="lineNum"> 907 </span> : * @param s The C string to use. +<span class="lineNum"> 908 </span> : * @param n Number of characters to use. +<span class="lineNum"> 909 </span> : * @return Reference to this string. +<span class="lineNum"> 910 </span> : * +<span class="lineNum"> 911 </span> : * This function sets the value of this string to the first @a n +<span class="lineNum"> 912 </span> : * characters of @a s. If @a n is is larger than the number of +<span class="lineNum"> 913 </span> : * available characters in @a s, the remainder of @a s is used. +<span class="lineNum"> 914 </span> : */ +<span class="lineNum"> 915 </span> : basic_string& +<span class="lineNum"> 916 </span> : assign(const _CharT* __s, size_type __n); +<span class="lineNum"> 917 </span> : +<span class="lineNum"> 918 </span> : /** +<span class="lineNum"> 919 </span> : * @brief Set value to contents of a C string. +<span class="lineNum"> 920 </span> : * @param s The C string to use. +<span class="lineNum"> 921 </span> : * @return Reference to this string. +<span class="lineNum"> 922 </span> : * +<span class="lineNum"> 923 </span> : * This function sets the value of this string to the value of @a s. +<span class="lineNum"> 924 </span> : * The data is copied, so there is no dependence on @a s once the +<span class="lineNum"> 925 </span> : * function returns. +<span class="lineNum"> 926 </span> : */ +<span class="lineNum"> 927 </span> : basic_string& +<span class="lineNum"> 928 </span><span class="lineNoCov"> 0 : assign(const _CharT* __s)</span> +<span class="lineNum"> 929 </span> : { +<span class="lineNum"> 930 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 931 </span><span class="lineNoCov"> 0 : return this->assign(__s, traits_type::length(__s));</span> +<span class="lineNum"> 932 </span> : } +<span class="lineNum"> 933 </span> : +<span class="lineNum"> 934 </span> : /** +<span class="lineNum"> 935 </span> : * @brief Set value to multiple characters. +<span class="lineNum"> 936 </span> : * @param n Length of the resulting string. +<span class="lineNum"> 937 </span> : * @param c The character to use. +<span class="lineNum"> 938 </span> : * @return Reference to this string. +<span class="lineNum"> 939 </span> : * +<span class="lineNum"> 940 </span> : * This function sets the value of this string to @a n copies of +<span class="lineNum"> 941 </span> : * character @a c. +<span class="lineNum"> 942 </span> : */ +<span class="lineNum"> 943 </span> : basic_string& +<span class="lineNum"> 944 </span> : assign(size_type __n, _CharT __c) +<span class="lineNum"> 945 </span> : { return _M_replace_aux(size_type(0), this->size(), __n, __c); } +<span class="lineNum"> 946 </span> : +<span class="lineNum"> 947 </span> : /** +<span class="lineNum"> 948 </span> : * @brief Set value to a range of characters. +<span class="lineNum"> 949 </span> : * @param first Iterator referencing the first character to append. +<span class="lineNum"> 950 </span> : * @param last Iterator marking the end of the range. +<span class="lineNum"> 951 </span> : * @return Reference to this string. +<span class="lineNum"> 952 </span> : * +<span class="lineNum"> 953 </span> : * Sets value of string to characters in the range [first,last). +<span class="lineNum"> 954 </span> : */ +<span class="lineNum"> 955 </span> : template<class _InputIterator> +<span class="lineNum"> 956 </span> : basic_string& +<span class="lineNum"> 957 </span> : assign(_InputIterator __first, _InputIterator __last) +<span class="lineNum"> 958 </span> : { return this->replace(_M_ibegin(), _M_iend(), __first, __last); } +<span class="lineNum"> 959 </span> : +<span class="lineNum"> 960 </span> : /** +<span class="lineNum"> 961 </span> : * @brief Insert multiple characters. +<span class="lineNum"> 962 </span> : * @param p Iterator referencing location in string to insert at. +<span class="lineNum"> 963 </span> : * @param n Number of characters to insert +<span class="lineNum"> 964 </span> : * @param c The character to insert. +<span class="lineNum"> 965 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 966 </span> : * +<span class="lineNum"> 967 </span> : * Inserts @a n copies of character @a c starting at the position +<span class="lineNum"> 968 </span> : * referenced by iterator @a p. If adding characters causes the length +<span class="lineNum"> 969 </span> : * to exceed max_size(), length_error is thrown. The value of the +<span class="lineNum"> 970 </span> : * string doesn't change if an error is thrown. +<span class="lineNum"> 971 </span> : */ +<span class="lineNum"> 972 </span> : void +<span class="lineNum"> 973 </span> : insert(iterator __p, size_type __n, _CharT __c) +<span class="lineNum"> 974 </span> : { this->replace(__p, __p, __n, __c); } +<span class="lineNum"> 975 </span> : +<span class="lineNum"> 976 </span> : /** +<span class="lineNum"> 977 </span> : * @brief Insert a range of characters. +<span class="lineNum"> 978 </span> : * @param p Iterator referencing location in string to insert at. +<span class="lineNum"> 979 </span> : * @param beg Start of range. +<span class="lineNum"> 980 </span> : * @param end End of range. +<span class="lineNum"> 981 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 982 </span> : * +<span class="lineNum"> 983 </span> : * Inserts characters in range [beg,end). If adding characters causes +<span class="lineNum"> 984 </span> : * the length to exceed max_size(), length_error is thrown. The value +<span class="lineNum"> 985 </span> : * of the string doesn't change if an error is thrown. +<span class="lineNum"> 986 </span> : */ +<span class="lineNum"> 987 </span> : template<class _InputIterator> +<span class="lineNum"> 988 </span> : void +<span class="lineNum"> 989 </span> : insert(iterator __p, _InputIterator __beg, _InputIterator __end) +<span class="lineNum"> 990 </span> : { this->replace(__p, __p, __beg, __end); } +<span class="lineNum"> 991 </span> : +<span class="lineNum"> 992 </span> : /** +<span class="lineNum"> 993 </span> : * @brief Insert value of a string. +<span class="lineNum"> 994 </span> : * @param pos1 Iterator referencing location in string to insert at. +<span class="lineNum"> 995 </span> : * @param str The string to insert. +<span class="lineNum"> 996 </span> : * @return Reference to this string. +<span class="lineNum"> 997 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 998 </span> : * +<span class="lineNum"> 999 </span> : * Inserts value of @a str starting at @a pos1. If adding characters +<span class="lineNum"> 1000 </span> : * causes the length to exceed max_size(), length_error is thrown. The +<span class="lineNum"> 1001 </span> : * value of the string doesn't change if an error is thrown. +<span class="lineNum"> 1002 </span> : */ +<span class="lineNum"> 1003 </span> : basic_string& +<span class="lineNum"> 1004 </span> : insert(size_type __pos1, const basic_string& __str) +<span class="lineNum"> 1005 </span> : { return this->insert(__pos1, __str, size_type(0), __str.size()); } +<span class="lineNum"> 1006 </span> : +<span class="lineNum"> 1007 </span> : /** +<span class="lineNum"> 1008 </span> : * @brief Insert a substring. +<span class="lineNum"> 1009 </span> : * @param pos1 Iterator referencing location in string to insert at. +<span class="lineNum"> 1010 </span> : * @param str The string to insert. +<span class="lineNum"> 1011 </span> : * @param pos2 Start of characters in str to insert. +<span class="lineNum"> 1012 </span> : * @param n Number of characters to insert. +<span class="lineNum"> 1013 </span> : * @return Reference to this string. +<span class="lineNum"> 1014 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1015 </span> : * @throw std::out_of_range If @a pos1 > size() or +<span class="lineNum"> 1016 </span> : * @a pos2 > @a str.size(). +<span class="lineNum"> 1017 </span> : * +<span class="lineNum"> 1018 </span> : * Starting at @a pos1, insert @a n character of @a str beginning with +<span class="lineNum"> 1019 </span> : * @a pos2. If adding characters causes the length to exceed +<span class="lineNum"> 1020 </span> : * max_size(), length_error is thrown. If @a pos1 is beyond the end of +<span class="lineNum"> 1021 </span> : * this string or @a pos2 is beyond the end of @a str, out_of_range is +<span class="lineNum"> 1022 </span> : * thrown. The value of the string doesn't change if an error is +<span class="lineNum"> 1023 </span> : * thrown. +<span class="lineNum"> 1024 </span> : */ +<span class="lineNum"> 1025 </span> : basic_string& +<span class="lineNum"> 1026 </span> : insert(size_type __pos1, const basic_string& __str, +<span class="lineNum"> 1027 </span> : size_type __pos2, size_type __n) +<span class="lineNum"> 1028 </span> : { return this->insert(__pos1, __str._M_data() +<span class="lineNum"> 1029 </span> : + __str._M_check(__pos2, "basic_string::insert"), +<span class="lineNum"> 1030 </span> : __str._M_limit(__pos2, __n)); } +<span class="lineNum"> 1031 </span> : +<span class="lineNum"> 1032 </span> : /** +<span class="lineNum"> 1033 </span> : * @brief Insert a C substring. +<span class="lineNum"> 1034 </span> : * @param pos Iterator referencing location in string to insert at. +<span class="lineNum"> 1035 </span> : * @param s The C string to insert. +<span class="lineNum"> 1036 </span> : * @param n The number of characters to insert. +<span class="lineNum"> 1037 </span> : * @return Reference to this string. +<span class="lineNum"> 1038 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1039 </span> : * @throw std::out_of_range If @a pos is beyond the end of this +<span class="lineNum"> 1040 </span> : * string. +<span class="lineNum"> 1041 </span> : * +<span class="lineNum"> 1042 </span> : * Inserts the first @a n characters of @a s starting at @a pos. If +<span class="lineNum"> 1043 </span> : * adding characters causes the length to exceed max_size(), +<span class="lineNum"> 1044 </span> : * length_error is thrown. If @a pos is beyond end(), out_of_range is +<span class="lineNum"> 1045 </span> : * thrown. The value of the string doesn't change if an error is +<span class="lineNum"> 1046 </span> : * thrown. +<span class="lineNum"> 1047 </span> : */ +<span class="lineNum"> 1048 </span> : basic_string& +<span class="lineNum"> 1049 </span> : insert(size_type __pos, const _CharT* __s, size_type __n); +<span class="lineNum"> 1050 </span> : +<span class="lineNum"> 1051 </span> : /** +<span class="lineNum"> 1052 </span> : * @brief Insert a C string. +<span class="lineNum"> 1053 </span> : * @param pos Iterator referencing location in string to insert at. +<span class="lineNum"> 1054 </span> : * @param s The C string to insert. +<span class="lineNum"> 1055 </span> : * @return Reference to this string. +<span class="lineNum"> 1056 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1057 </span> : * @throw std::out_of_range If @a pos is beyond the end of this +<span class="lineNum"> 1058 </span> : * string. +<span class="lineNum"> 1059 </span> : * +<span class="lineNum"> 1060 </span> : * Inserts the first @a n characters of @a s starting at @a pos. If +<span class="lineNum"> 1061 </span> : * adding characters causes the length to exceed max_size(), +<span class="lineNum"> 1062 </span> : * length_error is thrown. If @a pos is beyond end(), out_of_range is +<span class="lineNum"> 1063 </span> : * thrown. The value of the string doesn't change if an error is +<span class="lineNum"> 1064 </span> : * thrown. +<span class="lineNum"> 1065 </span> : */ +<span class="lineNum"> 1066 </span> : basic_string& +<span class="lineNum"> 1067 </span> : insert(size_type __pos, const _CharT* __s) +<span class="lineNum"> 1068 </span> : { +<span class="lineNum"> 1069 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 1070 </span> : return this->insert(__pos, __s, traits_type::length(__s)); +<span class="lineNum"> 1071 </span> : } +<span class="lineNum"> 1072 </span> : +<span class="lineNum"> 1073 </span> : /** +<span class="lineNum"> 1074 </span> : * @brief Insert multiple characters. +<span class="lineNum"> 1075 </span> : * @param pos Index in string to insert at. +<span class="lineNum"> 1076 </span> : * @param n Number of characters to insert +<span class="lineNum"> 1077 </span> : * @param c The character to insert. +<span class="lineNum"> 1078 </span> : * @return Reference to this string. +<span class="lineNum"> 1079 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1080 </span> : * @throw std::out_of_range If @a pos is beyond the end of this +<span class="lineNum"> 1081 </span> : * string. +<span class="lineNum"> 1082 </span> : * +<span class="lineNum"> 1083 </span> : * Inserts @a n copies of character @a c starting at index @a pos. If +<span class="lineNum"> 1084 </span> : * adding characters causes the length to exceed max_size(), +<span class="lineNum"> 1085 </span> : * length_error is thrown. If @a pos > length(), out_of_range is +<span class="lineNum"> 1086 </span> : * thrown. The value of the string doesn't change if an error is +<span class="lineNum"> 1087 </span> : * thrown. +<span class="lineNum"> 1088 </span> : */ +<span class="lineNum"> 1089 </span> : basic_string& +<span class="lineNum"> 1090 </span> : insert(size_type __pos, size_type __n, _CharT __c) +<span class="lineNum"> 1091 </span> : { return _M_replace_aux(_M_check(__pos, "basic_string::insert"), +<span class="lineNum"> 1092 </span> : size_type(0), __n, __c); } +<span class="lineNum"> 1093 </span> : +<span class="lineNum"> 1094 </span> : /** +<span class="lineNum"> 1095 </span> : * @brief Insert one character. +<span class="lineNum"> 1096 </span> : * @param p Iterator referencing position in string to insert at. +<span class="lineNum"> 1097 </span> : * @param c The character to insert. +<span class="lineNum"> 1098 </span> : * @return Iterator referencing newly inserted char. +<span class="lineNum"> 1099 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1100 </span> : * +<span class="lineNum"> 1101 </span> : * Inserts character @a c at position referenced by @a p. If adding +<span class="lineNum"> 1102 </span> : * character causes the length to exceed max_size(), length_error is +<span class="lineNum"> 1103 </span> : * thrown. If @a p is beyond end of string, out_of_range is thrown. +<span class="lineNum"> 1104 </span> : * The value of the string doesn't change if an error is thrown. +<span class="lineNum"> 1105 </span> : */ +<span class="lineNum"> 1106 </span> : iterator +<span class="lineNum"> 1107 </span> : insert(iterator __p, _CharT __c) +<span class="lineNum"> 1108 </span> : { +<span class="lineNum"> 1109 </span> : _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend()); +<span class="lineNum"> 1110 </span> : const size_type __pos = __p - _M_ibegin(); +<span class="lineNum"> 1111 </span> : _M_replace_aux(__pos, size_type(0), size_type(1), __c); +<span class="lineNum"> 1112 </span> : _M_rep()->_M_set_leaked(); +<span class="lineNum"> 1113 </span> : return iterator(_M_data() + __pos); +<span class="lineNum"> 1114 </span> : } +<span class="lineNum"> 1115 </span> : +<span class="lineNum"> 1116 </span> : /** +<span class="lineNum"> 1117 </span> : * @brief Remove characters. +<span class="lineNum"> 1118 </span> : * @param pos Index of first character to remove (default 0). +<span class="lineNum"> 1119 </span> : * @param n Number of characters to remove (default remainder). +<span class="lineNum"> 1120 </span> : * @return Reference to this string. +<span class="lineNum"> 1121 </span> : * @throw std::out_of_range If @a pos is beyond the end of this +<span class="lineNum"> 1122 </span> : * string. +<span class="lineNum"> 1123 </span> : * +<span class="lineNum"> 1124 </span> : * Removes @a n characters from this string starting at @a pos. The +<span class="lineNum"> 1125 </span> : * length of the string is reduced by @a n. If there are < @a n +<span class="lineNum"> 1126 </span> : * characters to remove, the remainder of the string is truncated. If +<span class="lineNum"> 1127 </span> : * @a p is beyond end of string, out_of_range is thrown. The value of +<span class="lineNum"> 1128 </span> : * the string doesn't change if an error is thrown. +<span class="lineNum"> 1129 </span> : */ +<span class="lineNum"> 1130 </span> : basic_string& +<span class="lineNum"> 1131 </span> : erase(size_type __pos = 0, size_type __n = npos) +<span class="lineNum"> 1132 </span> : { +<span class="lineNum"> 1133 </span> : _M_mutate(_M_check(__pos, "basic_string::erase"), +<span class="lineNum"> 1134 </span> : _M_limit(__pos, __n), size_type(0)); +<span class="lineNum"> 1135 </span> : return *this; +<span class="lineNum"> 1136 </span> : } +<span class="lineNum"> 1137 </span> : +<span class="lineNum"> 1138 </span> : /** +<span class="lineNum"> 1139 </span> : * @brief Remove one character. +<span class="lineNum"> 1140 </span> : * @param position Iterator referencing the character to remove. +<span class="lineNum"> 1141 </span> : * @return iterator referencing same location after removal. +<span class="lineNum"> 1142 </span> : * +<span class="lineNum"> 1143 </span> : * Removes the character at @a position from this string. The value +<span class="lineNum"> 1144 </span> : * of the string doesn't change if an error is thrown. +<span class="lineNum"> 1145 </span> : */ +<span class="lineNum"> 1146 </span> : iterator +<span class="lineNum"> 1147 </span><span class="lineNoCov"> 0 : erase(iterator __position)</span> +<span class="lineNum"> 1148 </span> : { +<span class="lineNum"> 1149 </span> : _GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin() +<span class="lineNum"> 1150 </span> : && __position < _M_iend()); +<span class="lineNum"> 1151 </span><span class="lineNoCov"> 0 : const size_type __pos = __position - _M_ibegin();</span> +<span class="lineNum"> 1152 </span><span class="lineNoCov"> 0 : _M_mutate(__pos, size_type(1), size_type(0));</span> +<span class="lineNum"> 1153 </span><span class="lineNoCov"> 0 : _M_rep()->_M_set_leaked();</span> +<span class="lineNum"> 1154 </span><span class="lineNoCov"> 0 : return iterator(_M_data() + __pos);</span> +<span class="lineNum"> 1155 </span> : } +<span class="lineNum"> 1156 </span> : +<span class="lineNum"> 1157 </span> : /** +<span class="lineNum"> 1158 </span> : * @brief Remove a range of characters. +<span class="lineNum"> 1159 </span> : * @param first Iterator referencing the first character to remove. +<span class="lineNum"> 1160 </span> : * @param last Iterator referencing the end of the range. +<span class="lineNum"> 1161 </span> : * @return Iterator referencing location of first after removal. +<span class="lineNum"> 1162 </span> : * +<span class="lineNum"> 1163 </span> : * Removes the characters in the range [first,last) from this string. +<span class="lineNum"> 1164 </span> : * The value of the string doesn't change if an error is thrown. +<span class="lineNum"> 1165 </span> : */ +<span class="lineNum"> 1166 </span> : iterator +<span class="lineNum"> 1167 </span> : erase(iterator __first, iterator __last) +<span class="lineNum"> 1168 </span> : { +<span class="lineNum"> 1169 </span> : _GLIBCXX_DEBUG_PEDASSERT(__first >= _M_ibegin() && __first <= __last +<span class="lineNum"> 1170 </span> : && __last <= _M_iend()); +<span class="lineNum"> 1171 </span> : const size_type __pos = __first - _M_ibegin(); +<span class="lineNum"> 1172 </span> : _M_mutate(__pos, __last - __first, size_type(0)); +<span class="lineNum"> 1173 </span> : _M_rep()->_M_set_leaked(); +<span class="lineNum"> 1174 </span> : return iterator(_M_data() + __pos); +<span class="lineNum"> 1175 </span> : } +<span class="lineNum"> 1176 </span> : +<span class="lineNum"> 1177 </span> : /** +<span class="lineNum"> 1178 </span> : * @brief Replace characters with value from another string. +<span class="lineNum"> 1179 </span> : * @param pos Index of first character to replace. +<span class="lineNum"> 1180 </span> : * @param n Number of characters to be replaced. +<span class="lineNum"> 1181 </span> : * @param str String to insert. +<span class="lineNum"> 1182 </span> : * @return Reference to this string. +<span class="lineNum"> 1183 </span> : * @throw std::out_of_range If @a pos is beyond the end of this +<span class="lineNum"> 1184 </span> : * string. +<span class="lineNum"> 1185 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1186 </span> : * +<span class="lineNum"> 1187 </span> : * Removes the characters in the range [pos,pos+n) from this string. +<span class="lineNum"> 1188 </span> : * In place, the value of @a str is inserted. If @a pos is beyond end +<span class="lineNum"> 1189 </span> : * of string, out_of_range is thrown. If the length of the result +<span class="lineNum"> 1190 </span> : * exceeds max_size(), length_error is thrown. The value of the string +<span class="lineNum"> 1191 </span> : * doesn't change if an error is thrown. +<span class="lineNum"> 1192 </span> : */ +<span class="lineNum"> 1193 </span> : basic_string& +<span class="lineNum"> 1194 </span> : replace(size_type __pos, size_type __n, const basic_string& __str) +<span class="lineNum"> 1195 </span> : { return this->replace(__pos, __n, __str._M_data(), __str.size()); } +<span class="lineNum"> 1196 </span> : +<span class="lineNum"> 1197 </span> : /** +<span class="lineNum"> 1198 </span> : * @brief Replace characters with value from another string. +<span class="lineNum"> 1199 </span> : * @param pos1 Index of first character to replace. +<span class="lineNum"> 1200 </span> : * @param n1 Number of characters to be replaced. +<span class="lineNum"> 1201 </span> : * @param str String to insert. +<span class="lineNum"> 1202 </span> : * @param pos2 Index of first character of str to use. +<span class="lineNum"> 1203 </span> : * @param n2 Number of characters from str to use. +<span class="lineNum"> 1204 </span> : * @return Reference to this string. +<span class="lineNum"> 1205 </span> : * @throw std::out_of_range If @a pos1 > size() or @a pos2 > +<span class="lineNum"> 1206 </span> : * str.size(). +<span class="lineNum"> 1207 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1208 </span> : * +<span class="lineNum"> 1209 </span> : * Removes the characters in the range [pos1,pos1 + n) from this +<span class="lineNum"> 1210 </span> : * string. In place, the value of @a str is inserted. If @a pos is +<span class="lineNum"> 1211 </span> : * beyond end of string, out_of_range is thrown. If the length of the +<span class="lineNum"> 1212 </span> : * result exceeds max_size(), length_error is thrown. The value of the +<span class="lineNum"> 1213 </span> : * string doesn't change if an error is thrown. +<span class="lineNum"> 1214 </span> : */ +<span class="lineNum"> 1215 </span> : basic_string& +<span class="lineNum"> 1216 </span> : replace(size_type __pos1, size_type __n1, const basic_string& __str, +<span class="lineNum"> 1217 </span> : size_type __pos2, size_type __n2) +<span class="lineNum"> 1218 </span> : { return this->replace(__pos1, __n1, __str._M_data() +<span class="lineNum"> 1219 </span> : + __str._M_check(__pos2, "basic_string::replace"), +<span class="lineNum"> 1220 </span> : __str._M_limit(__pos2, __n2)); } +<span class="lineNum"> 1221 </span> : +<span class="lineNum"> 1222 </span> : /** +<span class="lineNum"> 1223 </span> : * @brief Replace characters with value of a C substring. +<span class="lineNum"> 1224 </span> : * @param pos Index of first character to replace. +<span class="lineNum"> 1225 </span> : * @param n1 Number of characters to be replaced. +<span class="lineNum"> 1226 </span> : * @param s C string to insert. +<span class="lineNum"> 1227 </span> : * @param n2 Number of characters from @a s to use. +<span class="lineNum"> 1228 </span> : * @return Reference to this string. +<span class="lineNum"> 1229 </span> : * @throw std::out_of_range If @a pos1 > size(). +<span class="lineNum"> 1230 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1231 </span> : * +<span class="lineNum"> 1232 </span> : * Removes the characters in the range [pos,pos + n1) from this string. +<span class="lineNum"> 1233 </span> : * In place, the first @a n2 characters of @a s are inserted, or all +<span class="lineNum"> 1234 </span> : * of @a s if @a n2 is too large. If @a pos is beyond end of string, +<span class="lineNum"> 1235 </span> : * out_of_range is thrown. If the length of result exceeds max_size(), +<span class="lineNum"> 1236 </span> : * length_error is thrown. The value of the string doesn't change if +<span class="lineNum"> 1237 </span> : * an error is thrown. +<span class="lineNum"> 1238 </span> : */ +<span class="lineNum"> 1239 </span> : basic_string& +<span class="lineNum"> 1240 </span> : replace(size_type __pos, size_type __n1, const _CharT* __s, +<span class="lineNum"> 1241 </span> : size_type __n2); +<span class="lineNum"> 1242 </span> : +<span class="lineNum"> 1243 </span> : /** +<span class="lineNum"> 1244 </span> : * @brief Replace characters with value of a C string. +<span class="lineNum"> 1245 </span> : * @param pos Index of first character to replace. +<span class="lineNum"> 1246 </span> : * @param n1 Number of characters to be replaced. +<span class="lineNum"> 1247 </span> : * @param s C string to insert. +<span class="lineNum"> 1248 </span> : * @return Reference to this string. +<span class="lineNum"> 1249 </span> : * @throw std::out_of_range If @a pos > size(). +<span class="lineNum"> 1250 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1251 </span> : * +<span class="lineNum"> 1252 </span> : * Removes the characters in the range [pos,pos + n1) from this string. +<span class="lineNum"> 1253 </span> : * In place, the first @a n characters of @a s are inserted. If @a +<span class="lineNum"> 1254 </span> : * pos is beyond end of string, out_of_range is thrown. If the length +<span class="lineNum"> 1255 </span> : * of result exceeds max_size(), length_error is thrown. The value of +<span class="lineNum"> 1256 </span> : * the string doesn't change if an error is thrown. +<span class="lineNum"> 1257 </span> : */ +<span class="lineNum"> 1258 </span> : basic_string& +<span class="lineNum"> 1259 </span> : replace(size_type __pos, size_type __n1, const _CharT* __s) +<span class="lineNum"> 1260 </span> : { +<span class="lineNum"> 1261 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 1262 </span> : return this->replace(__pos, __n1, __s, traits_type::length(__s)); +<span class="lineNum"> 1263 </span> : } +<span class="lineNum"> 1264 </span> : +<span class="lineNum"> 1265 </span> : /** +<span class="lineNum"> 1266 </span> : * @brief Replace characters with multiple characters. +<span class="lineNum"> 1267 </span> : * @param pos Index of first character to replace. +<span class="lineNum"> 1268 </span> : * @param n1 Number of characters to be replaced. +<span class="lineNum"> 1269 </span> : * @param n2 Number of characters to insert. +<span class="lineNum"> 1270 </span> : * @param c Character to insert. +<span class="lineNum"> 1271 </span> : * @return Reference to this string. +<span class="lineNum"> 1272 </span> : * @throw std::out_of_range If @a pos > size(). +<span class="lineNum"> 1273 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1274 </span> : * +<span class="lineNum"> 1275 </span> : * Removes the characters in the range [pos,pos + n1) from this string. +<span class="lineNum"> 1276 </span> : * In place, @a n2 copies of @a c are inserted. If @a pos is beyond +<span class="lineNum"> 1277 </span> : * end of string, out_of_range is thrown. If the length of result +<span class="lineNum"> 1278 </span> : * exceeds max_size(), length_error is thrown. The value of the string +<span class="lineNum"> 1279 </span> : * doesn't change if an error is thrown. +<span class="lineNum"> 1280 </span> : */ +<span class="lineNum"> 1281 </span> : basic_string& +<span class="lineNum"> 1282 </span> : replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) +<span class="lineNum"> 1283 </span> : { return _M_replace_aux(_M_check(__pos, "basic_string::replace"), +<span class="lineNum"> 1284 </span> : _M_limit(__pos, __n1), __n2, __c); } +<span class="lineNum"> 1285 </span> : +<span class="lineNum"> 1286 </span> : /** +<span class="lineNum"> 1287 </span> : * @brief Replace range of characters with string. +<span class="lineNum"> 1288 </span> : * @param i1 Iterator referencing start of range to replace. +<span class="lineNum"> 1289 </span> : * @param i2 Iterator referencing end of range to replace. +<span class="lineNum"> 1290 </span> : * @param str String value to insert. +<span class="lineNum"> 1291 </span> : * @return Reference to this string. +<span class="lineNum"> 1292 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1293 </span> : * +<span class="lineNum"> 1294 </span> : * Removes the characters in the range [i1,i2). In place, the value of +<span class="lineNum"> 1295 </span> : * @a str is inserted. If the length of result exceeds max_size(), +<span class="lineNum"> 1296 </span> : * length_error is thrown. The value of the string doesn't change if +<span class="lineNum"> 1297 </span> : * an error is thrown. +<span class="lineNum"> 1298 </span> : */ +<span class="lineNum"> 1299 </span> : basic_string& +<span class="lineNum"> 1300 </span> : replace(iterator __i1, iterator __i2, const basic_string& __str) +<span class="lineNum"> 1301 </span> : { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } +<span class="lineNum"> 1302 </span> : +<span class="lineNum"> 1303 </span> : /** +<span class="lineNum"> 1304 </span> : * @brief Replace range of characters with C substring. +<span class="lineNum"> 1305 </span> : * @param i1 Iterator referencing start of range to replace. +<span class="lineNum"> 1306 </span> : * @param i2 Iterator referencing end of range to replace. +<span class="lineNum"> 1307 </span> : * @param s C string value to insert. +<span class="lineNum"> 1308 </span> : * @param n Number of characters from s to insert. +<span class="lineNum"> 1309 </span> : * @return Reference to this string. +<span class="lineNum"> 1310 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1311 </span> : * +<span class="lineNum"> 1312 </span> : * Removes the characters in the range [i1,i2). In place, the first @a +<span class="lineNum"> 1313 </span> : * n characters of @a s are inserted. If the length of result exceeds +<span class="lineNum"> 1314 </span> : * max_size(), length_error is thrown. The value of the string doesn't +<span class="lineNum"> 1315 </span> : * change if an error is thrown. +<span class="lineNum"> 1316 </span> : */ +<span class="lineNum"> 1317 </span> : basic_string& +<span class="lineNum"> 1318 </span> : replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n) +<span class="lineNum"> 1319 </span> : { +<span class="lineNum"> 1320 </span> : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 +<span class="lineNum"> 1321 </span> : && __i2 <= _M_iend()); +<span class="lineNum"> 1322 </span> : return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n); +<span class="lineNum"> 1323 </span> : } +<span class="lineNum"> 1324 </span> : +<span class="lineNum"> 1325 </span> : /** +<span class="lineNum"> 1326 </span> : * @brief Replace range of characters with C string. +<span class="lineNum"> 1327 </span> : * @param i1 Iterator referencing start of range to replace. +<span class="lineNum"> 1328 </span> : * @param i2 Iterator referencing end of range to replace. +<span class="lineNum"> 1329 </span> : * @param s C string value to insert. +<span class="lineNum"> 1330 </span> : * @return Reference to this string. +<span class="lineNum"> 1331 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1332 </span> : * +<span class="lineNum"> 1333 </span> : * Removes the characters in the range [i1,i2). In place, the +<span class="lineNum"> 1334 </span> : * characters of @a s are inserted. If the length of result exceeds +<span class="lineNum"> 1335 </span> : * max_size(), length_error is thrown. The value of the string doesn't +<span class="lineNum"> 1336 </span> : * change if an error is thrown. +<span class="lineNum"> 1337 </span> : */ +<span class="lineNum"> 1338 </span> : basic_string& +<span class="lineNum"> 1339 </span> : replace(iterator __i1, iterator __i2, const _CharT* __s) +<span class="lineNum"> 1340 </span> : { +<span class="lineNum"> 1341 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 1342 </span> : return this->replace(__i1, __i2, __s, traits_type::length(__s)); +<span class="lineNum"> 1343 </span> : } +<span class="lineNum"> 1344 </span> : +<span class="lineNum"> 1345 </span> : /** +<span class="lineNum"> 1346 </span> : * @brief Replace range of characters with multiple characters +<span class="lineNum"> 1347 </span> : * @param i1 Iterator referencing start of range to replace. +<span class="lineNum"> 1348 </span> : * @param i2 Iterator referencing end of range to replace. +<span class="lineNum"> 1349 </span> : * @param n Number of characters to insert. +<span class="lineNum"> 1350 </span> : * @param c Character to insert. +<span class="lineNum"> 1351 </span> : * @return Reference to this string. +<span class="lineNum"> 1352 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1353 </span> : * +<span class="lineNum"> 1354 </span> : * Removes the characters in the range [i1,i2). In place, @a n copies +<span class="lineNum"> 1355 </span> : * of @a c are inserted. If the length of result exceeds max_size(), +<span class="lineNum"> 1356 </span> : * length_error is thrown. The value of the string doesn't change if +<span class="lineNum"> 1357 </span> : * an error is thrown. +<span class="lineNum"> 1358 </span> : */ +<span class="lineNum"> 1359 </span> : basic_string& +<span class="lineNum"> 1360 </span> : replace(iterator __i1, iterator __i2, size_type __n, _CharT __c) +<span class="lineNum"> 1361 </span> : { +<span class="lineNum"> 1362 </span> : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 +<span class="lineNum"> 1363 </span> : && __i2 <= _M_iend()); +<span class="lineNum"> 1364 </span> : return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c); +<span class="lineNum"> 1365 </span> : } +<span class="lineNum"> 1366 </span> : +<span class="lineNum"> 1367 </span> : /** +<span class="lineNum"> 1368 </span> : * @brief Replace range of characters with range. +<span class="lineNum"> 1369 </span> : * @param i1 Iterator referencing start of range to replace. +<span class="lineNum"> 1370 </span> : * @param i2 Iterator referencing end of range to replace. +<span class="lineNum"> 1371 </span> : * @param k1 Iterator referencing start of range to insert. +<span class="lineNum"> 1372 </span> : * @param k2 Iterator referencing end of range to insert. +<span class="lineNum"> 1373 </span> : * @return Reference to this string. +<span class="lineNum"> 1374 </span> : * @throw std::length_error If new length exceeds @c max_size(). +<span class="lineNum"> 1375 </span> : * +<span class="lineNum"> 1376 </span> : * Removes the characters in the range [i1,i2). In place, characters +<span class="lineNum"> 1377 </span> : * in the range [k1,k2) are inserted. If the length of result exceeds +<span class="lineNum"> 1378 </span> : * max_size(), length_error is thrown. The value of the string doesn't +<span class="lineNum"> 1379 </span> : * change if an error is thrown. +<span class="lineNum"> 1380 </span> : */ +<span class="lineNum"> 1381 </span> : template<class _InputIterator> +<span class="lineNum"> 1382 </span> : basic_string& +<span class="lineNum"> 1383 </span> : replace(iterator __i1, iterator __i2, +<span class="lineNum"> 1384 </span> : _InputIterator __k1, _InputIterator __k2) +<span class="lineNum"> 1385 </span> : { +<span class="lineNum"> 1386 </span> : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 +<span class="lineNum"> 1387 </span> : && __i2 <= _M_iend()); +<span class="lineNum"> 1388 </span> : __glibcxx_requires_valid_range(__k1, __k2); +<span class="lineNum"> 1389 </span> : typedef typename std::__is_integer<_InputIterator>::__type _Integral; +<span class="lineNum"> 1390 </span> : return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral()); +<span class="lineNum"> 1391 </span> : } +<span class="lineNum"> 1392 </span> : +<span class="lineNum"> 1393 </span> : // Specializations for the common case of pointer and iterator: +<span class="lineNum"> 1394 </span> : // useful to avoid the overhead of temporary buffering in _M_replace. +<span class="lineNum"> 1395 </span> : basic_string& +<span class="lineNum"> 1396 </span> : replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2) +<span class="lineNum"> 1397 </span> : { +<span class="lineNum"> 1398 </span> : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 +<span class="lineNum"> 1399 </span> : && __i2 <= _M_iend()); +<span class="lineNum"> 1400 </span> : __glibcxx_requires_valid_range(__k1, __k2); +<span class="lineNum"> 1401 </span> : return this->replace(__i1 - _M_ibegin(), __i2 - __i1, +<span class="lineNum"> 1402 </span> : __k1, __k2 - __k1); +<span class="lineNum"> 1403 </span> : } +<span class="lineNum"> 1404 </span> : +<span class="lineNum"> 1405 </span> : basic_string& +<span class="lineNum"> 1406 </span> : replace(iterator __i1, iterator __i2, +<span class="lineNum"> 1407 </span> : const _CharT* __k1, const _CharT* __k2) +<span class="lineNum"> 1408 </span> : { +<span class="lineNum"> 1409 </span> : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 +<span class="lineNum"> 1410 </span> : && __i2 <= _M_iend()); +<span class="lineNum"> 1411 </span> : __glibcxx_requires_valid_range(__k1, __k2); +<span class="lineNum"> 1412 </span> : return this->replace(__i1 - _M_ibegin(), __i2 - __i1, +<span class="lineNum"> 1413 </span> : __k1, __k2 - __k1); +<span class="lineNum"> 1414 </span> : } +<span class="lineNum"> 1415 </span> : +<span class="lineNum"> 1416 </span> : basic_string& +<span class="lineNum"> 1417 </span> : replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2) +<span class="lineNum"> 1418 </span> : { +<span class="lineNum"> 1419 </span> : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 +<span class="lineNum"> 1420 </span> : && __i2 <= _M_iend()); +<span class="lineNum"> 1421 </span> : __glibcxx_requires_valid_range(__k1, __k2); +<span class="lineNum"> 1422 </span> : return this->replace(__i1 - _M_ibegin(), __i2 - __i1, +<span class="lineNum"> 1423 </span> : __k1.base(), __k2 - __k1); +<span class="lineNum"> 1424 </span> : } +<span class="lineNum"> 1425 </span> : +<span class="lineNum"> 1426 </span> : basic_string& +<span class="lineNum"> 1427 </span> : replace(iterator __i1, iterator __i2, +<span class="lineNum"> 1428 </span> : const_iterator __k1, const_iterator __k2) +<span class="lineNum"> 1429 </span> : { +<span class="lineNum"> 1430 </span> : _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 +<span class="lineNum"> 1431 </span> : && __i2 <= _M_iend()); +<span class="lineNum"> 1432 </span> : __glibcxx_requires_valid_range(__k1, __k2); +<span class="lineNum"> 1433 </span> : return this->replace(__i1 - _M_ibegin(), __i2 - __i1, +<span class="lineNum"> 1434 </span> : __k1.base(), __k2 - __k1); +<span class="lineNum"> 1435 </span> : } +<span class="lineNum"> 1436 </span> : +<span class="lineNum"> 1437 </span> : private: +<span class="lineNum"> 1438 </span> : template<class _Integer> +<span class="lineNum"> 1439 </span> : basic_string& +<span class="lineNum"> 1440 </span> : _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n, +<span class="lineNum"> 1441 </span> : _Integer __val, __true_type) +<span class="lineNum"> 1442 </span> : { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); } +<span class="lineNum"> 1443 </span> : +<span class="lineNum"> 1444 </span> : template<class _InputIterator> +<span class="lineNum"> 1445 </span> : basic_string& +<span class="lineNum"> 1446 </span> : _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1, +<span class="lineNum"> 1447 </span> : _InputIterator __k2, __false_type); +<span class="lineNum"> 1448 </span> : +<span class="lineNum"> 1449 </span> : basic_string& +<span class="lineNum"> 1450 </span> : _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, +<span class="lineNum"> 1451 </span> : _CharT __c); +<span class="lineNum"> 1452 </span> : +<span class="lineNum"> 1453 </span> : basic_string& +<span class="lineNum"> 1454 </span> : _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s, +<span class="lineNum"> 1455 </span> : size_type __n2); +<span class="lineNum"> 1456 </span> : +<span class="lineNum"> 1457 </span> : // _S_construct_aux is used to implement the 21.3.1 para 15 which +<span class="lineNum"> 1458 </span> : // requires special behaviour if _InIter is an integral type +<span class="lineNum"> 1459 </span> : template<class _InIterator> +<span class="lineNum"> 1460 </span> : static _CharT* +<span class="lineNum"> 1461 </span> : _S_construct_aux(_InIterator __beg, _InIterator __end, +<span class="lineNum"> 1462 </span><span class="lineCov"> 1287 : const _Alloc& __a, __false_type)</span> +<span class="lineNum"> 1463 </span> : { +<span class="lineNum"> 1464 </span> : typedef typename iterator_traits<_InIterator>::iterator_category _Tag; +<span class="lineNum"> 1465 </span><span class="lineCov"> 1287 : return _S_construct(__beg, __end, __a, _Tag());</span> +<span class="lineNum"> 1466 </span> : } +<span class="lineNum"> 1467 </span> : +<span class="lineNum"> 1468 </span> : // _GLIBCXX_RESOLVE_LIB_DEFECTS +<span class="lineNum"> 1469 </span> : // 438. Ambiguity in the "do the right thing" clause +<span class="lineNum"> 1470 </span> : template<class _Integer> +<span class="lineNum"> 1471 </span> : static _CharT* +<span class="lineNum"> 1472 </span> : _S_construct_aux(_Integer __beg, _Integer __end, +<span class="lineNum"> 1473 </span> : const _Alloc& __a, __true_type) +<span class="lineNum"> 1474 </span> : { return _S_construct(static_cast<size_type>(__beg), __end, __a); } +<span class="lineNum"> 1475 </span> : +<span class="lineNum"> 1476 </span> : template<class _InIterator> +<span class="lineNum"> 1477 </span> : static _CharT* +<span class="lineNum"> 1478 </span><span class="lineCov"> 1287 : _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)</span> +<span class="lineNum"> 1479 </span> : { +<span class="lineNum"> 1480 </span> : typedef typename std::__is_integer<_InIterator>::__type _Integral; +<span class="lineNum"> 1481 </span><span class="lineCov"> 1287 : return _S_construct_aux(__beg, __end, __a, _Integral());</span> +<span class="lineNum"> 1482 </span> : } +<span class="lineNum"> 1483 </span> : +<span class="lineNum"> 1484 </span> : // For Input Iterators, used in istreambuf_iterators, etc. +<span class="lineNum"> 1485 </span> : template<class _InIterator> +<span class="lineNum"> 1486 </span> : static _CharT* +<span class="lineNum"> 1487 </span> : _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, +<span class="lineNum"> 1488 </span> : input_iterator_tag); +<span class="lineNum"> 1489 </span> : +<span class="lineNum"> 1490 </span> : // For forward_iterators up to random_access_iterators, used for +<span class="lineNum"> 1491 </span> : // string::iterator, _CharT*, etc. +<span class="lineNum"> 1492 </span> : template<class _FwdIterator> +<span class="lineNum"> 1493 </span> : static _CharT* +<span class="lineNum"> 1494 </span> : _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a, +<span class="lineNum"> 1495 </span> : forward_iterator_tag); +<span class="lineNum"> 1496 </span> : +<span class="lineNum"> 1497 </span> : static _CharT* +<span class="lineNum"> 1498 </span> : _S_construct(size_type __req, _CharT __c, const _Alloc& __a); +<span class="lineNum"> 1499 </span> : +<span class="lineNum"> 1500 </span> : public: +<span class="lineNum"> 1501 </span> : +<span class="lineNum"> 1502 </span> : /** +<span class="lineNum"> 1503 </span> : * @brief Copy substring into C string. +<span class="lineNum"> 1504 </span> : * @param s C string to copy value into. +<span class="lineNum"> 1505 </span> : * @param n Number of characters to copy. +<span class="lineNum"> 1506 </span> : * @param pos Index of first character to copy. +<span class="lineNum"> 1507 </span> : * @return Number of characters actually copied +<span class="lineNum"> 1508 </span> : * @throw std::out_of_range If pos > size(). +<span class="lineNum"> 1509 </span> : * +<span class="lineNum"> 1510 </span> : * Copies up to @a n characters starting at @a pos into the C string @a +<span class="lineNum"> 1511 </span> : * s. If @a pos is greater than size(), out_of_range is thrown. +<span class="lineNum"> 1512 </span> : */ +<span class="lineNum"> 1513 </span> : size_type +<span class="lineNum"> 1514 </span> : copy(_CharT* __s, size_type __n, size_type __pos = 0) const; +<span class="lineNum"> 1515 </span> : +<span class="lineNum"> 1516 </span> : /** +<span class="lineNum"> 1517 </span> : * @brief Swap contents with another string. +<span class="lineNum"> 1518 </span> : * @param s String to swap with. +<span class="lineNum"> 1519 </span> : * +<span class="lineNum"> 1520 </span> : * Exchanges the contents of this string with that of @a s in constant +<span class="lineNum"> 1521 </span> : * time. +<span class="lineNum"> 1522 </span> : */ +<span class="lineNum"> 1523 </span> : void +<span class="lineNum"> 1524 </span> : swap(basic_string& __s); +<span class="lineNum"> 1525 </span> : +<span class="lineNum"> 1526 </span> : // String operations: +<span class="lineNum"> 1527 </span> : /** +<span class="lineNum"> 1528 </span> : * @brief Return const pointer to null-terminated contents. +<span class="lineNum"> 1529 </span> : * +<span class="lineNum"> 1530 </span> : * This is a handle to internal data. Do not modify or dire things may +<span class="lineNum"> 1531 </span> : * happen. +<span class="lineNum"> 1532 </span> : */ +<span class="lineNum"> 1533 </span> : const _CharT* +<span class="lineNum"> 1534 </span><span class="lineNoCov"> 0 : c_str() const</span> +<span class="lineNum"> 1535 </span><span class="lineNoCov"> 0 : { return _M_data(); }</span> +<span class="lineNum"> 1536 </span> : +<span class="lineNum"> 1537 </span> : /** +<span class="lineNum"> 1538 </span> : * @brief Return const pointer to contents. +<span class="lineNum"> 1539 </span> : * +<span class="lineNum"> 1540 </span> : * This is a handle to internal data. Do not modify or dire things may +<span class="lineNum"> 1541 </span> : * happen. +<span class="lineNum"> 1542 </span> : */ +<span class="lineNum"> 1543 </span> : const _CharT* +<span class="lineNum"> 1544 </span><span class="lineNoCov"> 0 : data() const</span> +<span class="lineNum"> 1545 </span><span class="lineNoCov"> 0 : { return _M_data(); }</span> +<span class="lineNum"> 1546 </span> : +<span class="lineNum"> 1547 </span> : /** +<span class="lineNum"> 1548 </span> : * @brief Return copy of allocator used to construct this string. +<span class="lineNum"> 1549 </span> : */ +<span class="lineNum"> 1550 </span> : allocator_type +<span class="lineNum"> 1551 </span><span class="lineNoCov"> 0 : get_allocator() const</span> +<span class="lineNum"> 1552 </span><span class="lineNoCov"> 0 : { return _M_dataplus; }</span> +<span class="lineNum"> 1553 </span> : +<span class="lineNum"> 1554 </span> : /** +<span class="lineNum"> 1555 </span> : * @brief Find position of a C substring. +<span class="lineNum"> 1556 </span> : * @param s C string to locate. +<span class="lineNum"> 1557 </span> : * @param pos Index of character to search from. +<span class="lineNum"> 1558 </span> : * @param n Number of characters from @a s to search for. +<span class="lineNum"> 1559 </span> : * @return Index of start of first occurrence. +<span class="lineNum"> 1560 </span> : * +<span class="lineNum"> 1561 </span> : * Starting from @a pos, searches forward for the first @a n characters +<span class="lineNum"> 1562 </span> : * in @a s within this string. If found, returns the index where it +<span class="lineNum"> 1563 </span> : * begins. If not found, returns npos. +<span class="lineNum"> 1564 </span> : */ +<span class="lineNum"> 1565 </span> : size_type +<span class="lineNum"> 1566 </span> : find(const _CharT* __s, size_type __pos, size_type __n) const; +<span class="lineNum"> 1567 </span> : +<span class="lineNum"> 1568 </span> : /** +<span class="lineNum"> 1569 </span> : * @brief Find position of a string. +<span class="lineNum"> 1570 </span> : * @param str String to locate. +<span class="lineNum"> 1571 </span> : * @param pos Index of character to search from (default 0). +<span class="lineNum"> 1572 </span> : * @return Index of start of first occurrence. +<span class="lineNum"> 1573 </span> : * +<span class="lineNum"> 1574 </span> : * Starting from @a pos, searches forward for value of @a str within +<span class="lineNum"> 1575 </span> : * this string. If found, returns the index where it begins. If not +<span class="lineNum"> 1576 </span> : * found, returns npos. +<span class="lineNum"> 1577 </span> : */ +<span class="lineNum"> 1578 </span> : size_type +<span class="lineNum"> 1579 </span><span class="lineNoCov"> 0 : find(const basic_string& __str, size_type __pos = 0) const</span> +<span class="lineNum"> 1580 </span><span class="lineNoCov"> 0 : { return this->find(__str.data(), __pos, __str.size()); }</span> +<span class="lineNum"> 1581 </span> : +<span class="lineNum"> 1582 </span> : /** +<span class="lineNum"> 1583 </span> : * @brief Find position of a C string. +<span class="lineNum"> 1584 </span> : * @param s C string to locate. +<span class="lineNum"> 1585 </span> : * @param pos Index of character to search from (default 0). +<span class="lineNum"> 1586 </span> : * @return Index of start of first occurrence. +<span class="lineNum"> 1587 </span> : * +<span class="lineNum"> 1588 </span> : * Starting from @a pos, searches forward for the value of @a s within +<span class="lineNum"> 1589 </span> : * this string. If found, returns the index where it begins. If not +<span class="lineNum"> 1590 </span> : * found, returns npos. +<span class="lineNum"> 1591 </span> : */ +<span class="lineNum"> 1592 </span> : size_type +<span class="lineNum"> 1593 </span><span class="lineNoCov"> 0 : find(const _CharT* __s, size_type __pos = 0) const</span> +<span class="lineNum"> 1594 </span> : { +<span class="lineNum"> 1595 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 1596 </span><span class="lineNoCov"> 0 : return this->find(__s, __pos, traits_type::length(__s));</span> +<span class="lineNum"> 1597 </span> : } +<span class="lineNum"> 1598 </span> : +<span class="lineNum"> 1599 </span> : /** +<span class="lineNum"> 1600 </span> : * @brief Find position of a character. +<span class="lineNum"> 1601 </span> : * @param c Character to locate. +<span class="lineNum"> 1602 </span> : * @param pos Index of character to search from (default 0). +<span class="lineNum"> 1603 </span> : * @return Index of first occurrence. +<span class="lineNum"> 1604 </span> : * +<span class="lineNum"> 1605 </span> : * Starting from @a pos, searches forward for @a c within this string. +<span class="lineNum"> 1606 </span> : * If found, returns the index where it was found. If not found, +<span class="lineNum"> 1607 </span> : * returns npos. +<span class="lineNum"> 1608 </span> : */ +<span class="lineNum"> 1609 </span> : size_type +<span class="lineNum"> 1610 </span> : find(_CharT __c, size_type __pos = 0) const; +<span class="lineNum"> 1611 </span> : +<span class="lineNum"> 1612 </span> : /** +<span class="lineNum"> 1613 </span> : * @brief Find last position of a string. +<span class="lineNum"> 1614 </span> : * @param str String to locate. +<span class="lineNum"> 1615 </span> : * @param pos Index of character to search back from (default end). +<span class="lineNum"> 1616 </span> : * @return Index of start of last occurrence. +<span class="lineNum"> 1617 </span> : * +<span class="lineNum"> 1618 </span> : * Starting from @a pos, searches backward for value of @a str within +<span class="lineNum"> 1619 </span> : * this string. If found, returns the index where it begins. If not +<span class="lineNum"> 1620 </span> : * found, returns npos. +<span class="lineNum"> 1621 </span> : */ +<span class="lineNum"> 1622 </span> : size_type +<span class="lineNum"> 1623 </span> : rfind(const basic_string& __str, size_type __pos = npos) const +<span class="lineNum"> 1624 </span> : { return this->rfind(__str.data(), __pos, __str.size()); } +<span class="lineNum"> 1625 </span> : +<span class="lineNum"> 1626 </span> : /** +<span class="lineNum"> 1627 </span> : * @brief Find last position of a C substring. +<span class="lineNum"> 1628 </span> : * @param s C string to locate. +<span class="lineNum"> 1629 </span> : * @param pos Index of character to search back from. +<span class="lineNum"> 1630 </span> : * @param n Number of characters from s to search for. +<span class="lineNum"> 1631 </span> : * @return Index of start of last occurrence. +<span class="lineNum"> 1632 </span> : * +<span class="lineNum"> 1633 </span> : * Starting from @a pos, searches backward for the first @a n +<span class="lineNum"> 1634 </span> : * characters in @a s within this string. If found, returns the index +<span class="lineNum"> 1635 </span> : * where it begins. If not found, returns npos. +<span class="lineNum"> 1636 </span> : */ +<span class="lineNum"> 1637 </span> : size_type +<span class="lineNum"> 1638 </span> : rfind(const _CharT* __s, size_type __pos, size_type __n) const; +<span class="lineNum"> 1639 </span> : +<span class="lineNum"> 1640 </span> : /** +<span class="lineNum"> 1641 </span> : * @brief Find last position of a C string. +<span class="lineNum"> 1642 </span> : * @param s C string to locate. +<span class="lineNum"> 1643 </span> : * @param pos Index of character to start search at (default end). +<span class="lineNum"> 1644 </span> : * @return Index of start of last occurrence. +<span class="lineNum"> 1645 </span> : * +<span class="lineNum"> 1646 </span> : * Starting from @a pos, searches backward for the value of @a s within +<span class="lineNum"> 1647 </span> : * this string. If found, returns the index where it begins. If not +<span class="lineNum"> 1648 </span> : * found, returns npos. +<span class="lineNum"> 1649 </span> : */ +<span class="lineNum"> 1650 </span> : size_type +<span class="lineNum"> 1651 </span><span class="lineNoCov"> 0 : rfind(const _CharT* __s, size_type __pos = npos) const</span> +<span class="lineNum"> 1652 </span> : { +<span class="lineNum"> 1653 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 1654 </span><span class="lineNoCov"> 0 : return this->rfind(__s, __pos, traits_type::length(__s));</span> +<span class="lineNum"> 1655 </span> : } +<span class="lineNum"> 1656 </span> : +<span class="lineNum"> 1657 </span> : /** +<span class="lineNum"> 1658 </span> : * @brief Find last position of a character. +<span class="lineNum"> 1659 </span> : * @param c Character to locate. +<span class="lineNum"> 1660 </span> : * @param pos Index of character to search back from (default end). +<span class="lineNum"> 1661 </span> : * @return Index of last occurrence. +<span class="lineNum"> 1662 </span> : * +<span class="lineNum"> 1663 </span> : * Starting from @a pos, searches backward for @a c within this string. +<span class="lineNum"> 1664 </span> : * If found, returns the index where it was found. If not found, +<span class="lineNum"> 1665 </span> : * returns npos. +<span class="lineNum"> 1666 </span> : */ +<span class="lineNum"> 1667 </span> : size_type +<span class="lineNum"> 1668 </span> : rfind(_CharT __c, size_type __pos = npos) const; +<span class="lineNum"> 1669 </span> : +<span class="lineNum"> 1670 </span> : /** +<span class="lineNum"> 1671 </span> : * @brief Find position of a character of string. +<span class="lineNum"> 1672 </span> : * @param str String containing characters to locate. +<span class="lineNum"> 1673 </span> : * @param pos Index of character to search from (default 0). +<span class="lineNum"> 1674 </span> : * @return Index of first occurrence. +<span class="lineNum"> 1675 </span> : * +<span class="lineNum"> 1676 </span> : * Starting from @a pos, searches forward for one of the characters of +<span class="lineNum"> 1677 </span> : * @a str within this string. If found, returns the index where it was +<span class="lineNum"> 1678 </span> : * found. If not found, returns npos. +<span class="lineNum"> 1679 </span> : */ +<span class="lineNum"> 1680 </span> : size_type +<span class="lineNum"> 1681 </span> : find_first_of(const basic_string& __str, size_type __pos = 0) const +<span class="lineNum"> 1682 </span> : { return this->find_first_of(__str.data(), __pos, __str.size()); } +<span class="lineNum"> 1683 </span> : +<span class="lineNum"> 1684 </span> : /** +<span class="lineNum"> 1685 </span> : * @brief Find position of a character of C substring. +<span class="lineNum"> 1686 </span> : * @param s String containing characters to locate. +<span class="lineNum"> 1687 </span> : * @param pos Index of character to search from. +<span class="lineNum"> 1688 </span> : * @param n Number of characters from s to search for. +<span class="lineNum"> 1689 </span> : * @return Index of first occurrence. +<span class="lineNum"> 1690 </span> : * +<span class="lineNum"> 1691 </span> : * Starting from @a pos, searches forward for one of the first @a n +<span class="lineNum"> 1692 </span> : * characters of @a s within this string. If found, returns the index +<span class="lineNum"> 1693 </span> : * where it was found. If not found, returns npos. +<span class="lineNum"> 1694 </span> : */ +<span class="lineNum"> 1695 </span> : size_type +<span class="lineNum"> 1696 </span> : find_first_of(const _CharT* __s, size_type __pos, size_type __n) const; +<span class="lineNum"> 1697 </span> : +<span class="lineNum"> 1698 </span> : /** +<span class="lineNum"> 1699 </span> : * @brief Find position of a character of C string. +<span class="lineNum"> 1700 </span> : * @param s String containing characters to locate. +<span class="lineNum"> 1701 </span> : * @param pos Index of character to search from (default 0). +<span class="lineNum"> 1702 </span> : * @return Index of first occurrence. +<span class="lineNum"> 1703 </span> : * +<span class="lineNum"> 1704 </span> : * Starting from @a pos, searches forward for one of the characters of +<span class="lineNum"> 1705 </span> : * @a s within this string. If found, returns the index where it was +<span class="lineNum"> 1706 </span> : * found. If not found, returns npos. +<span class="lineNum"> 1707 </span> : */ +<span class="lineNum"> 1708 </span> : size_type +<span class="lineNum"> 1709 </span> : find_first_of(const _CharT* __s, size_type __pos = 0) const +<span class="lineNum"> 1710 </span> : { +<span class="lineNum"> 1711 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 1712 </span> : return this->find_first_of(__s, __pos, traits_type::length(__s)); +<span class="lineNum"> 1713 </span> : } +<span class="lineNum"> 1714 </span> : +<span class="lineNum"> 1715 </span> : /** +<span class="lineNum"> 1716 </span> : * @brief Find position of a character. +<span class="lineNum"> 1717 </span> : * @param c Character to locate. +<span class="lineNum"> 1718 </span> : * @param pos Index of character to search from (default 0). +<span class="lineNum"> 1719 </span> : * @return Index of first occurrence. +<span class="lineNum"> 1720 </span> : * +<span class="lineNum"> 1721 </span> : * Starting from @a pos, searches forward for the character @a c within +<span class="lineNum"> 1722 </span> : * this string. If found, returns the index where it was found. If +<span class="lineNum"> 1723 </span> : * not found, returns npos. +<span class="lineNum"> 1724 </span> : * +<span class="lineNum"> 1725 </span> : * Note: equivalent to find(c, pos). +<span class="lineNum"> 1726 </span> : */ +<span class="lineNum"> 1727 </span> : size_type +<span class="lineNum"> 1728 </span> : find_first_of(_CharT __c, size_type __pos = 0) const +<span class="lineNum"> 1729 </span> : { return this->find(__c, __pos); } +<span class="lineNum"> 1730 </span> : +<span class="lineNum"> 1731 </span> : /** +<span class="lineNum"> 1732 </span> : * @brief Find last position of a character of string. +<span class="lineNum"> 1733 </span> : * @param str String containing characters to locate. +<span class="lineNum"> 1734 </span> : * @param pos Index of character to search back from (default end). +<span class="lineNum"> 1735 </span> : * @return Index of last occurrence. +<span class="lineNum"> 1736 </span> : * +<span class="lineNum"> 1737 </span> : * Starting from @a pos, searches backward for one of the characters of +<span class="lineNum"> 1738 </span> : * @a str within this string. If found, returns the index where it was +<span class="lineNum"> 1739 </span> : * found. If not found, returns npos. +<span class="lineNum"> 1740 </span> : */ +<span class="lineNum"> 1741 </span> : size_type +<span class="lineNum"> 1742 </span> : find_last_of(const basic_string& __str, size_type __pos = npos) const +<span class="lineNum"> 1743 </span> : { return this->find_last_of(__str.data(), __pos, __str.size()); } +<span class="lineNum"> 1744 </span> : +<span class="lineNum"> 1745 </span> : /** +<span class="lineNum"> 1746 </span> : * @brief Find last position of a character of C substring. +<span class="lineNum"> 1747 </span> : * @param s C string containing characters to locate. +<span class="lineNum"> 1748 </span> : * @param pos Index of character to search back from. +<span class="lineNum"> 1749 </span> : * @param n Number of characters from s to search for. +<span class="lineNum"> 1750 </span> : * @return Index of last occurrence. +<span class="lineNum"> 1751 </span> : * +<span class="lineNum"> 1752 </span> : * Starting from @a pos, searches backward for one of the first @a n +<span class="lineNum"> 1753 </span> : * characters of @a s within this string. If found, returns the index +<span class="lineNum"> 1754 </span> : * where it was found. If not found, returns npos. +<span class="lineNum"> 1755 </span> : */ +<span class="lineNum"> 1756 </span> : size_type +<span class="lineNum"> 1757 </span> : find_last_of(const _CharT* __s, size_type __pos, size_type __n) const; +<span class="lineNum"> 1758 </span> : +<span class="lineNum"> 1759 </span> : /** +<span class="lineNum"> 1760 </span> : * @brief Find last position of a character of C string. +<span class="lineNum"> 1761 </span> : * @param s C string containing characters to locate. +<span class="lineNum"> 1762 </span> : * @param pos Index of character to search back from (default end). +<span class="lineNum"> 1763 </span> : * @return Index of last occurrence. +<span class="lineNum"> 1764 </span> : * +<span class="lineNum"> 1765 </span> : * Starting from @a pos, searches backward for one of the characters of +<span class="lineNum"> 1766 </span> : * @a s within this string. If found, returns the index where it was +<span class="lineNum"> 1767 </span> : * found. If not found, returns npos. +<span class="lineNum"> 1768 </span> : */ +<span class="lineNum"> 1769 </span> : size_type +<span class="lineNum"> 1770 </span> : find_last_of(const _CharT* __s, size_type __pos = npos) const +<span class="lineNum"> 1771 </span> : { +<span class="lineNum"> 1772 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 1773 </span> : return this->find_last_of(__s, __pos, traits_type::length(__s)); +<span class="lineNum"> 1774 </span> : } +<span class="lineNum"> 1775 </span> : +<span class="lineNum"> 1776 </span> : /** +<span class="lineNum"> 1777 </span> : * @brief Find last position of a character. +<span class="lineNum"> 1778 </span> : * @param c Character to locate. +<span class="lineNum"> 1779 </span> : * @param pos Index of character to search back from (default end). +<span class="lineNum"> 1780 </span> : * @return Index of last occurrence. +<span class="lineNum"> 1781 </span> : * +<span class="lineNum"> 1782 </span> : * Starting from @a pos, searches backward for @a c within this string. +<span class="lineNum"> 1783 </span> : * If found, returns the index where it was found. If not found, +<span class="lineNum"> 1784 </span> : * returns npos. +<span class="lineNum"> 1785 </span> : * +<span class="lineNum"> 1786 </span> : * Note: equivalent to rfind(c, pos). +<span class="lineNum"> 1787 </span> : */ +<span class="lineNum"> 1788 </span> : size_type +<span class="lineNum"> 1789 </span> : find_last_of(_CharT __c, size_type __pos = npos) const +<span class="lineNum"> 1790 </span> : { return this->rfind(__c, __pos); } +<span class="lineNum"> 1791 </span> : +<span class="lineNum"> 1792 </span> : /** +<span class="lineNum"> 1793 </span> : * @brief Find position of a character not in string. +<span class="lineNum"> 1794 </span> : * @param str String containing characters to avoid. +<span class="lineNum"> 1795 </span> : * @param pos Index of character to search from (default 0). +<span class="lineNum"> 1796 </span> : * @return Index of first occurrence. +<span class="lineNum"> 1797 </span> : * +<span class="lineNum"> 1798 </span> : * Starting from @a pos, searches forward for a character not contained +<span class="lineNum"> 1799 </span> : * in @a str within this string. If found, returns the index where it +<span class="lineNum"> 1800 </span> : * was found. If not found, returns npos. +<span class="lineNum"> 1801 </span> : */ +<span class="lineNum"> 1802 </span> : size_type +<span class="lineNum"> 1803 </span> : find_first_not_of(const basic_string& __str, size_type __pos = 0) const +<span class="lineNum"> 1804 </span> : { return this->find_first_not_of(__str.data(), __pos, __str.size()); } +<span class="lineNum"> 1805 </span> : +<span class="lineNum"> 1806 </span> : /** +<span class="lineNum"> 1807 </span> : * @brief Find position of a character not in C substring. +<span class="lineNum"> 1808 </span> : * @param s C string containing characters to avoid. +<span class="lineNum"> 1809 </span> : * @param pos Index of character to search from. +<span class="lineNum"> 1810 </span> : * @param n Number of characters from s to consider. +<span class="lineNum"> 1811 </span> : * @return Index of first occurrence. +<span class="lineNum"> 1812 </span> : * +<span class="lineNum"> 1813 </span> : * Starting from @a pos, searches forward for a character not contained +<span class="lineNum"> 1814 </span> : * in the first @a n characters of @a s within this string. If found, +<span class="lineNum"> 1815 </span> : * returns the index where it was found. If not found, returns npos. +<span class="lineNum"> 1816 </span> : */ +<span class="lineNum"> 1817 </span> : size_type +<span class="lineNum"> 1818 </span> : find_first_not_of(const _CharT* __s, size_type __pos, +<span class="lineNum"> 1819 </span> : size_type __n) const; +<span class="lineNum"> 1820 </span> : +<span class="lineNum"> 1821 </span> : /** +<span class="lineNum"> 1822 </span> : * @brief Find position of a character not in C string. +<span class="lineNum"> 1823 </span> : * @param s C string containing characters to avoid. +<span class="lineNum"> 1824 </span> : * @param pos Index of character to search from (default 0). +<span class="lineNum"> 1825 </span> : * @return Index of first occurrence. +<span class="lineNum"> 1826 </span> : * +<span class="lineNum"> 1827 </span> : * Starting from @a pos, searches forward for a character not contained +<span class="lineNum"> 1828 </span> : * in @a s within this string. If found, returns the index where it +<span class="lineNum"> 1829 </span> : * was found. If not found, returns npos. +<span class="lineNum"> 1830 </span> : */ +<span class="lineNum"> 1831 </span> : size_type +<span class="lineNum"> 1832 </span> : find_first_not_of(const _CharT* __s, size_type __pos = 0) const +<span class="lineNum"> 1833 </span> : { +<span class="lineNum"> 1834 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 1835 </span> : return this->find_first_not_of(__s, __pos, traits_type::length(__s)); +<span class="lineNum"> 1836 </span> : } +<span class="lineNum"> 1837 </span> : +<span class="lineNum"> 1838 </span> : /** +<span class="lineNum"> 1839 </span> : * @brief Find position of a different character. +<span class="lineNum"> 1840 </span> : * @param c Character to avoid. +<span class="lineNum"> 1841 </span> : * @param pos Index of character to search from (default 0). +<span class="lineNum"> 1842 </span> : * @return Index of first occurrence. +<span class="lineNum"> 1843 </span> : * +<span class="lineNum"> 1844 </span> : * Starting from @a pos, searches forward for a character other than @a c +<span class="lineNum"> 1845 </span> : * within this string. If found, returns the index where it was found. +<span class="lineNum"> 1846 </span> : * If not found, returns npos. +<span class="lineNum"> 1847 </span> : */ +<span class="lineNum"> 1848 </span> : size_type +<span class="lineNum"> 1849 </span> : find_first_not_of(_CharT __c, size_type __pos = 0) const; +<span class="lineNum"> 1850 </span> : +<span class="lineNum"> 1851 </span> : /** +<span class="lineNum"> 1852 </span> : * @brief Find last position of a character not in string. +<span class="lineNum"> 1853 </span> : * @param str String containing characters to avoid. +<span class="lineNum"> 1854 </span> : * @param pos Index of character to search back from (default end). +<span class="lineNum"> 1855 </span> : * @return Index of last occurrence. +<span class="lineNum"> 1856 </span> : * +<span class="lineNum"> 1857 </span> : * Starting from @a pos, searches backward for a character not +<span class="lineNum"> 1858 </span> : * contained in @a str within this string. If found, returns the index +<span class="lineNum"> 1859 </span> : * where it was found. If not found, returns npos. +<span class="lineNum"> 1860 </span> : */ +<span class="lineNum"> 1861 </span> : size_type +<span class="lineNum"> 1862 </span> : find_last_not_of(const basic_string& __str, size_type __pos = npos) const +<span class="lineNum"> 1863 </span> : { return this->find_last_not_of(__str.data(), __pos, __str.size()); } +<span class="lineNum"> 1864 </span> : +<span class="lineNum"> 1865 </span> : /** +<span class="lineNum"> 1866 </span> : * @brief Find last position of a character not in C substring. +<span class="lineNum"> 1867 </span> : * @param s C string containing characters to avoid. +<span class="lineNum"> 1868 </span> : * @param pos Index of character to search back from. +<span class="lineNum"> 1869 </span> : * @param n Number of characters from s to consider. +<span class="lineNum"> 1870 </span> : * @return Index of last occurrence. +<span class="lineNum"> 1871 </span> : * +<span class="lineNum"> 1872 </span> : * Starting from @a pos, searches backward for a character not +<span class="lineNum"> 1873 </span> : * contained in the first @a n characters of @a s within this string. +<span class="lineNum"> 1874 </span> : * If found, returns the index where it was found. If not found, +<span class="lineNum"> 1875 </span> : * returns npos. +<span class="lineNum"> 1876 </span> : */ +<span class="lineNum"> 1877 </span> : size_type +<span class="lineNum"> 1878 </span> : find_last_not_of(const _CharT* __s, size_type __pos, +<span class="lineNum"> 1879 </span> : size_type __n) const; +<span class="lineNum"> 1880 </span> : /** +<span class="lineNum"> 1881 </span> : * @brief Find last position of a character not in C string. +<span class="lineNum"> 1882 </span> : * @param s C string containing characters to avoid. +<span class="lineNum"> 1883 </span> : * @param pos Index of character to search back from (default end). +<span class="lineNum"> 1884 </span> : * @return Index of last occurrence. +<span class="lineNum"> 1885 </span> : * +<span class="lineNum"> 1886 </span> : * Starting from @a pos, searches backward for a character not +<span class="lineNum"> 1887 </span> : * contained in @a s within this string. If found, returns the index +<span class="lineNum"> 1888 </span> : * where it was found. If not found, returns npos. +<span class="lineNum"> 1889 </span> : */ +<span class="lineNum"> 1890 </span> : size_type +<span class="lineNum"> 1891 </span><span class="lineNoCov"> 0 : find_last_not_of(const _CharT* __s, size_type __pos = npos) const</span> +<span class="lineNum"> 1892 </span> : { +<span class="lineNum"> 1893 </span> : __glibcxx_requires_string(__s); +<span class="lineNum"> 1894 </span><span class="lineNoCov"> 0 : return this->find_last_not_of(__s, __pos, traits_type::length(__s));</span> +<span class="lineNum"> 1895 </span> : } +<span class="lineNum"> 1896 </span> : +<span class="lineNum"> 1897 </span> : /** +<span class="lineNum"> 1898 </span> : * @brief Find last position of a different character. +<span class="lineNum"> 1899 </span> : * @param c Character to avoid. +<span class="lineNum"> 1900 </span> : * @param pos Index of character to search back from (default end). +<span class="lineNum"> 1901 </span> : * @return Index of last occurrence. +<span class="lineNum"> 1902 </span> : * +<span class="lineNum"> 1903 </span> : * Starting from @a pos, searches backward for a character other than +<span class="lineNum"> 1904 </span> : * @a c within this string. If found, returns the index where it was +<span class="lineNum"> 1905 </span> : * found. If not found, returns npos. +<span class="lineNum"> 1906 </span> : */ +<span class="lineNum"> 1907 </span> : size_type +<span class="lineNum"> 1908 </span> : find_last_not_of(_CharT __c, size_type __pos = npos) const; +<span class="lineNum"> 1909 </span> : +<span class="lineNum"> 1910 </span> : /** +<span class="lineNum"> 1911 </span> : * @brief Get a substring. +<span class="lineNum"> 1912 </span> : * @param pos Index of first character (default 0). +<span class="lineNum"> 1913 </span> : * @param n Number of characters in substring (default remainder). +<span class="lineNum"> 1914 </span> : * @return The new string. +<span class="lineNum"> 1915 </span> : * @throw std::out_of_range If pos > size(). +<span class="lineNum"> 1916 </span> : * +<span class="lineNum"> 1917 </span> : * Construct and return a new string using the @a n characters starting +<span class="lineNum"> 1918 </span> : * at @a pos. If the string is too short, use the remainder of the +<span class="lineNum"> 1919 </span> : * characters. If @a pos is beyond the end of the string, out_of_range +<span class="lineNum"> 1920 </span> : * is thrown. +<span class="lineNum"> 1921 </span> : */ +<span class="lineNum"> 1922 </span> : basic_string +<span class="lineNum"> 1923 </span><span class="lineNoCov"> 0 : substr(size_type __pos = 0, size_type __n = npos) const</span> +<span class="lineNum"> 1924 </span> : { return basic_string(*this, +<span class="lineNum"> 1925 </span><span class="lineNoCov"> 0 : _M_check(__pos, "basic_string::substr"), __n); }</span> +<span class="lineNum"> 1926 </span> : +<span class="lineNum"> 1927 </span> : /** +<span class="lineNum"> 1928 </span> : * @brief Compare to a string. +<span class="lineNum"> 1929 </span> : * @param str String to compare against. +<span class="lineNum"> 1930 </span> : * @return Integer < 0, 0, or > 0. +<span class="lineNum"> 1931 </span> : * +<span class="lineNum"> 1932 </span> : * Returns an integer < 0 if this string is ordered before @a str, 0 if +<span class="lineNum"> 1933 </span> : * their values are equivalent, or > 0 if this string is ordered after +<span class="lineNum"> 1934 </span> : * @a str. Determines the effective length rlen of the strings to +<span class="lineNum"> 1935 </span> : * compare as the smallest of size() and str.size(). The function +<span class="lineNum"> 1936 </span> : * then compares the two strings by calling traits::compare(data(), +<span class="lineNum"> 1937 </span> : * str.data(),rlen). If the result of the comparison is nonzero returns +<span class="lineNum"> 1938 </span> : * it, otherwise the shorter one is ordered first. +<span class="lineNum"> 1939 </span> : */ +<span class="lineNum"> 1940 </span> : int +<span class="lineNum"> 1941 </span><span class="lineNoCov"> 0 : compare(const basic_string& __str) const</span> +<span class="lineNum"> 1942 </span> : { +<span class="lineNum"> 1943 </span><span class="lineNoCov"> 0 : const size_type __size = this->size();</span> +<span class="lineNum"> 1944 </span><span class="lineNoCov"> 0 : const size_type __osize = __str.size();</span> +<span class="lineNum"> 1945 </span><span class="lineNoCov"> 0 : const size_type __len = std::min(__size, __osize);</span> +<span class="lineNum"> 1946 </span> : +<span class="lineNum"> 1947 </span><span class="lineNoCov"> 0 : int __r = traits_type::compare(_M_data(), __str.data(), __len);</span> +<span class="lineNum"> 1948 </span><span class="lineNoCov"> 0 : if (!__r)</span> +<span class="lineNum"> 1949 </span><span class="lineNoCov"> 0 : __r = _S_compare(__size, __osize);</span> +<span class="lineNum"> 1950 </span><span class="lineNoCov"> 0 : return __r;</span> +<span class="lineNum"> 1951 </span> : } +<span class="lineNum"> 1952 </span> : +<span class="lineNum"> 1953 </span> : /** +<span class="lineNum"> 1954 </span> : * @brief Compare substring to a string. +<span class="lineNum"> 1955 </span> : * @param pos Index of first character of substring. +<span class="lineNum"> 1956 </span> : * @param n Number of characters in substring. +<span class="lineNum"> 1957 </span> : * @param str String to compare against. +<span class="lineNum"> 1958 </span> : * @return Integer < 0, 0, or > 0. +<span class="lineNum"> 1959 </span> : * +<span class="lineNum"> 1960 </span> : * Form the substring of this string from the @a n characters starting +<span class="lineNum"> 1961 </span> : * at @a pos. Returns an integer < 0 if the substring is ordered +<span class="lineNum"> 1962 </span> : * before @a str, 0 if their values are equivalent, or > 0 if the +<span class="lineNum"> 1963 </span> : * substring is ordered after @a str. Determines the effective length +<span class="lineNum"> 1964 </span> : * rlen of the strings to compare as the smallest of the length of the +<span class="lineNum"> 1965 </span> : * substring and @a str.size(). The function then compares the two +<span class="lineNum"> 1966 </span> : * strings by calling traits::compare(substring.data(),str.data(),rlen). +<span class="lineNum"> 1967 </span> : * If the result of the comparison is nonzero returns it, otherwise the +<span class="lineNum"> 1968 </span> : * shorter one is ordered first. +<span class="lineNum"> 1969 </span> : */ +<span class="lineNum"> 1970 </span> : int +<span class="lineNum"> 1971 </span> : compare(size_type __pos, size_type __n, const basic_string& __str) const; +<span class="lineNum"> 1972 </span> : +<span class="lineNum"> 1973 </span> : /** +<span class="lineNum"> 1974 </span> : * @brief Compare substring to a substring. +<span class="lineNum"> 1975 </span> : * @param pos1 Index of first character of substring. +<span class="lineNum"> 1976 </span> : * @param n1 Number of characters in substring. +<span class="lineNum"> 1977 </span> : * @param str String to compare against. +<span class="lineNum"> 1978 </span> : * @param pos2 Index of first character of substring of str. +<span class="lineNum"> 1979 </span> : * @param n2 Number of characters in substring of str. +<span class="lineNum"> 1980 </span> : * @return Integer < 0, 0, or > 0. +<span class="lineNum"> 1981 </span> : * +<span class="lineNum"> 1982 </span> : * Form the substring of this string from the @a n1 characters starting +<span class="lineNum"> 1983 </span> : * at @a pos1. Form the substring of @a str from the @a n2 characters +<span class="lineNum"> 1984 </span> : * starting at @a pos2. Returns an integer < 0 if this substring is +<span class="lineNum"> 1985 </span> : * ordered before the substring of @a str, 0 if their values are +<span class="lineNum"> 1986 </span> : * equivalent, or > 0 if this substring is ordered after the substring +<span class="lineNum"> 1987 </span> : * of @a str. Determines the effective length rlen of the strings +<span class="lineNum"> 1988 </span> : * to compare as the smallest of the lengths of the substrings. The +<span class="lineNum"> 1989 </span> : * function then compares the two strings by calling +<span class="lineNum"> 1990 </span> : * traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen). +<span class="lineNum"> 1991 </span> : * If the result of the comparison is nonzero returns it, otherwise the +<span class="lineNum"> 1992 </span> : * shorter one is ordered first. +<span class="lineNum"> 1993 </span> : */ +<span class="lineNum"> 1994 </span> : int +<span class="lineNum"> 1995 </span> : compare(size_type __pos1, size_type __n1, const basic_string& __str, +<span class="lineNum"> 1996 </span> : size_type __pos2, size_type __n2) const; +<span class="lineNum"> 1997 </span> : +<span class="lineNum"> 1998 </span> : /** +<span class="lineNum"> 1999 </span> : * @brief Compare to a C string. +<span class="lineNum"> 2000 </span> : * @param s C string to compare against. +<span class="lineNum"> 2001 </span> : * @return Integer < 0, 0, or > 0. +<span class="lineNum"> 2002 </span> : * +<span class="lineNum"> 2003 </span> : * Returns an integer < 0 if this string is ordered before @a s, 0 if +<span class="lineNum"> 2004 </span> : * their values are equivalent, or > 0 if this string is ordered after +<span class="lineNum"> 2005 </span> : * @a s. Determines the effective length rlen of the strings to +<span class="lineNum"> 2006 </span> : * compare as the smallest of size() and the length of a string +<span class="lineNum"> 2007 </span> : * constructed from @a s. The function then compares the two strings +<span class="lineNum"> 2008 </span> : * by calling traits::compare(data(),s,rlen). If the result of the +<span class="lineNum"> 2009 </span> : * comparison is nonzero returns it, otherwise the shorter one is +<span class="lineNum"> 2010 </span> : * ordered first. +<span class="lineNum"> 2011 </span> : */ +<span class="lineNum"> 2012 </span> : int +<span class="lineNum"> 2013 </span> : compare(const _CharT* __s) const; +<span class="lineNum"> 2014 </span> : +<span class="lineNum"> 2015 </span> : // _GLIBCXX_RESOLVE_LIB_DEFECTS +<span class="lineNum"> 2016 </span> : // 5 String::compare specification questionable +<span class="lineNum"> 2017 </span> : /** +<span class="lineNum"> 2018 </span> : * @brief Compare substring to a C string. +<span class="lineNum"> 2019 </span> : * @param pos Index of first character of substring. +<span class="lineNum"> 2020 </span> : * @param n1 Number of characters in substring. +<span class="lineNum"> 2021 </span> : * @param s C string to compare against. +<span class="lineNum"> 2022 </span> : * @return Integer < 0, 0, or > 0. +<span class="lineNum"> 2023 </span> : * +<span class="lineNum"> 2024 </span> : * Form the substring of this string from the @a n1 characters starting +<span class="lineNum"> 2025 </span> : * at @a pos. Returns an integer < 0 if the substring is ordered +<span class="lineNum"> 2026 </span> : * before @a s, 0 if their values are equivalent, or > 0 if the +<span class="lineNum"> 2027 </span> : * substring is ordered after @a s. Determines the effective length +<span class="lineNum"> 2028 </span> : * rlen of the strings to compare as the smallest of the length of the +<span class="lineNum"> 2029 </span> : * substring and the length of a string constructed from @a s. The +<span class="lineNum"> 2030 </span> : * function then compares the two string by calling +<span class="lineNum"> 2031 </span> : * traits::compare(substring.data(),s,rlen). If the result of the +<span class="lineNum"> 2032 </span> : * comparison is nonzero returns it, otherwise the shorter one is +<span class="lineNum"> 2033 </span> : * ordered first. +<span class="lineNum"> 2034 </span> : */ +<span class="lineNum"> 2035 </span> : int +<span class="lineNum"> 2036 </span> : compare(size_type __pos, size_type __n1, const _CharT* __s) const; +<span class="lineNum"> 2037 </span> : +<span class="lineNum"> 2038 </span> : /** +<span class="lineNum"> 2039 </span> : * @brief Compare substring against a character array. +<span class="lineNum"> 2040 </span> : * @param pos1 Index of first character of substring. +<span class="lineNum"> 2041 </span> : * @param n1 Number of characters in substring. +<span class="lineNum"> 2042 </span> : * @param s character array to compare against. +<span class="lineNum"> 2043 </span> : * @param n2 Number of characters of s. +<span class="lineNum"> 2044 </span> : * @return Integer < 0, 0, or > 0. +<span class="lineNum"> 2045 </span> : * +<span class="lineNum"> 2046 </span> : * Form the substring of this string from the @a n1 characters starting +<span class="lineNum"> 2047 </span> : * at @a pos1. Form a string from the first @a n2 characters of @a s. +<span class="lineNum"> 2048 </span> : * Returns an integer < 0 if this substring is ordered before the string +<span class="lineNum"> 2049 </span> : * from @a s, 0 if their values are equivalent, or > 0 if this substring +<span class="lineNum"> 2050 </span> : * is ordered after the string from @a s. Determines the effective +<span class="lineNum"> 2051 </span> : * length rlen of the strings to compare as the smallest of the length +<span class="lineNum"> 2052 </span> : * of the substring and @a n2. The function then compares the two +<span class="lineNum"> 2053 </span> : * strings by calling traits::compare(substring.data(),s,rlen). If the +<span class="lineNum"> 2054 </span> : * result of the comparison is nonzero returns it, otherwise the shorter +<span class="lineNum"> 2055 </span> : * one is ordered first. +<span class="lineNum"> 2056 </span> : * +<span class="lineNum"> 2057 </span> : * NB: s must have at least n2 characters, '\0' has no special +<span class="lineNum"> 2058 </span> : * meaning. +<span class="lineNum"> 2059 </span> : */ +<span class="lineNum"> 2060 </span> : int +<span class="lineNum"> 2061 </span> : compare(size_type __pos, size_type __n1, const _CharT* __s, +<span class="lineNum"> 2062 </span> : size_type __n2) const; +<span class="lineNum"> 2063 </span> : }; +<span class="lineNum"> 2064 </span> : +<span class="lineNum"> 2065 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2066 </span> : inline basic_string<_CharT, _Traits, _Alloc>:: +<span class="lineNum"> 2067 </span><span class="lineNoCov"> 0 : basic_string()</span> +<span class="lineNum"> 2068 </span> : #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING +<span class="lineNum"> 2069 </span><span class="lineNoCov"> 0 : : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }</span> +<span class="lineNum"> 2070 </span> : #else +<span class="lineNum"> 2071 </span> : : _M_dataplus(_S_construct(size_type(), _CharT(), _Alloc()), _Alloc()) { } +<span class="lineNum"> 2072 </span> : #endif +<span class="lineNum"> 2073 </span> : +<span class="lineNum"> 2074 </span> : // operator+ +<span class="lineNum"> 2075 </span> : /** +<span class="lineNum"> 2076 </span> : * @brief Concatenate two strings. +<span class="lineNum"> 2077 </span> : * @param lhs First string. +<span class="lineNum"> 2078 </span> : * @param rhs Last string. +<span class="lineNum"> 2079 </span> : * @return New string with value of @a lhs followed by @a rhs. +<span class="lineNum"> 2080 </span> : */ +<span class="lineNum"> 2081 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2082 </span> : basic_string<_CharT, _Traits, _Alloc> +<span class="lineNum"> 2083 </span> : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2084 </span><span class="lineCov"> 715370 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)</span> +<span class="lineNum"> 2085 </span> : { +<span class="lineNum"> 2086 </span><span class="lineCov"> 715370 : basic_string<_CharT, _Traits, _Alloc> __str(__lhs);</span> +<span class="lineNum"> 2087 </span><span class="lineCov"> 715370 : __str.append(__rhs);</span> +<span class="lineNum"> 2088 </span><span class="lineNoCov"> 0 : return __str;</span> +<span class="lineNum"> 2089 </span> : } +<span class="lineNum"> 2090 </span> : +<span class="lineNum"> 2091 </span> : /** +<span class="lineNum"> 2092 </span> : * @brief Concatenate C string and string. +<span class="lineNum"> 2093 </span> : * @param lhs First string. +<span class="lineNum"> 2094 </span> : * @param rhs Last string. +<span class="lineNum"> 2095 </span> : * @return New string with value of @a lhs followed by @a rhs. +<span class="lineNum"> 2096 </span> : */ +<span class="lineNum"> 2097 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2098 </span> : basic_string<_CharT,_Traits,_Alloc> +<span class="lineNum"> 2099 </span> : operator+(const _CharT* __lhs, +<span class="lineNum"> 2100 </span> : const basic_string<_CharT,_Traits,_Alloc>& __rhs); +<span class="lineNum"> 2101 </span> : +<span class="lineNum"> 2102 </span> : /** +<span class="lineNum"> 2103 </span> : * @brief Concatenate character and string. +<span class="lineNum"> 2104 </span> : * @param lhs First string. +<span class="lineNum"> 2105 </span> : * @param rhs Last string. +<span class="lineNum"> 2106 </span> : * @return New string with @a lhs followed by @a rhs. +<span class="lineNum"> 2107 </span> : */ +<span class="lineNum"> 2108 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2109 </span> : basic_string<_CharT,_Traits,_Alloc> +<span class="lineNum"> 2110 </span> : operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); +<span class="lineNum"> 2111 </span> : +<span class="lineNum"> 2112 </span> : /** +<span class="lineNum"> 2113 </span> : * @brief Concatenate string and C string. +<span class="lineNum"> 2114 </span> : * @param lhs First string. +<span class="lineNum"> 2115 </span> : * @param rhs Last string. +<span class="lineNum"> 2116 </span> : * @return New string with @a lhs followed by @a rhs. +<span class="lineNum"> 2117 </span> : */ +<span class="lineNum"> 2118 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2119 </span> : inline basic_string<_CharT, _Traits, _Alloc> +<span class="lineNum"> 2120 </span> : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2121 </span><span class="lineCov"> 5962 : const _CharT* __rhs)</span> +<span class="lineNum"> 2122 </span> : { +<span class="lineNum"> 2123 </span><span class="lineCov"> 5962 : basic_string<_CharT, _Traits, _Alloc> __str(__lhs);</span> +<span class="lineNum"> 2124 </span><span class="lineCov"> 5962 : __str.append(__rhs);</span> +<span class="lineNum"> 2125 </span><span class="lineNoCov"> 0 : return __str;</span> +<span class="lineNum"> 2126 </span> : } +<span class="lineNum"> 2127 </span> : +<span class="lineNum"> 2128 </span> : /** +<span class="lineNum"> 2129 </span> : * @brief Concatenate string and character. +<span class="lineNum"> 2130 </span> : * @param lhs First string. +<span class="lineNum"> 2131 </span> : * @param rhs Last string. +<span class="lineNum"> 2132 </span> : * @return New string with @a lhs followed by @a rhs. +<span class="lineNum"> 2133 </span> : */ +<span class="lineNum"> 2134 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2135 </span> : inline basic_string<_CharT, _Traits, _Alloc> +<span class="lineNum"> 2136 </span><span class="lineCov"> 140 : operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)</span> +<span class="lineNum"> 2137 </span> : { +<span class="lineNum"> 2138 </span> : typedef basic_string<_CharT, _Traits, _Alloc> __string_type; +<span class="lineNum"> 2139 </span> : typedef typename __string_type::size_type __size_type; +<span class="lineNum"> 2140 </span><span class="lineCov"> 140 : __string_type __str(__lhs);</span> +<span class="lineNum"> 2141 </span><span class="lineCov"> 140 : __str.append(__size_type(1), __rhs);</span> +<span class="lineNum"> 2142 </span><span class="lineNoCov"> 0 : return __str;</span> +<span class="lineNum"> 2143 </span> : } +<span class="lineNum"> 2144 </span> : +<span class="lineNum"> 2145 </span> : // operator == +<span class="lineNum"> 2146 </span> : /** +<span class="lineNum"> 2147 </span> : * @brief Test equivalence of two strings. +<span class="lineNum"> 2148 </span> : * @param lhs First string. +<span class="lineNum"> 2149 </span> : * @param rhs Second string. +<span class="lineNum"> 2150 </span> : * @return True if @a lhs.compare(@a rhs) == 0. False otherwise. +<span class="lineNum"> 2151 </span> : */ +<span class="lineNum"> 2152 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2153 </span> : inline bool +<span class="lineNum"> 2154 </span> : operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2155 </span> : const basic_string<_CharT, _Traits, _Alloc>& __rhs) +<span class="lineNum"> 2156 </span> : { return __lhs.compare(__rhs) == 0; } +<span class="lineNum"> 2157 </span> : +<span class="lineNum"> 2158 </span> : template<typename _CharT> +<span class="lineNum"> 2159 </span> : inline +<span class="lineNum"> 2160 </span> : typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type +<span class="lineNum"> 2161 </span> : operator==(const basic_string<_CharT>& __lhs, +<span class="lineNum"> 2162 </span><span class="lineCov"> 134945 : const basic_string<_CharT>& __rhs)</span> +<span class="lineNum"> 2163 </span> : { return (__lhs.size() == __rhs.size() +<span class="lineNum"> 2164 </span> : && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(), +<span class="lineNum"> 2165 </span><span class="lineCov"> 134945 : __lhs.size())); }</span> +<span class="lineNum"> 2166 </span> : +<span class="lineNum"> 2167 </span> : /** +<span class="lineNum"> 2168 </span> : * @brief Test equivalence of C string and string. +<span class="lineNum"> 2169 </span> : * @param lhs C string. +<span class="lineNum"> 2170 </span> : * @param rhs String. +<span class="lineNum"> 2171 </span> : * @return True if @a rhs.compare(@a lhs) == 0. False otherwise. +<span class="lineNum"> 2172 </span> : */ +<span class="lineNum"> 2173 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2174 </span> : inline bool +<span class="lineNum"> 2175 </span> : operator==(const _CharT* __lhs, +<span class="lineNum"> 2176 </span><span class="lineNoCov"> 0 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)</span> +<span class="lineNum"> 2177 </span><span class="lineNoCov"> 0 : { return __rhs.compare(__lhs) == 0; }</span> +<span class="lineNum"> 2178 </span> : +<span class="lineNum"> 2179 </span> : /** +<span class="lineNum"> 2180 </span> : * @brief Test equivalence of string and C string. +<span class="lineNum"> 2181 </span> : * @param lhs String. +<span class="lineNum"> 2182 </span> : * @param rhs C string. +<span class="lineNum"> 2183 </span> : * @return True if @a lhs.compare(@a rhs) == 0. False otherwise. +<span class="lineNum"> 2184 </span> : */ +<span class="lineNum"> 2185 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2186 </span> : inline bool +<span class="lineNum"> 2187 </span> : operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2188 </span><span class="lineCov"> 156952 : const _CharT* __rhs)</span> +<span class="lineNum"> 2189 </span><span class="lineCov"> 156952 : { return __lhs.compare(__rhs) == 0; }</span> +<span class="lineNum"> 2190 </span> : +<span class="lineNum"> 2191 </span> : // operator != +<span class="lineNum"> 2192 </span> : /** +<span class="lineNum"> 2193 </span> : * @brief Test difference of two strings. +<span class="lineNum"> 2194 </span> : * @param lhs First string. +<span class="lineNum"> 2195 </span> : * @param rhs Second string. +<span class="lineNum"> 2196 </span> : * @return True if @a lhs.compare(@a rhs) != 0. False otherwise. +<span class="lineNum"> 2197 </span> : */ +<span class="lineNum"> 2198 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2199 </span> : inline bool +<span class="lineNum"> 2200 </span> : operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2201 </span><span class="lineCov"> 84867 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)</span> +<span class="lineNum"> 2202 </span><span class="lineCov"> 84867 : { return !(__lhs == __rhs); }</span> +<span class="lineNum"> 2203 </span> : +<span class="lineNum"> 2204 </span> : /** +<span class="lineNum"> 2205 </span> : * @brief Test difference of C string and string. +<span class="lineNum"> 2206 </span> : * @param lhs C string. +<span class="lineNum"> 2207 </span> : * @param rhs String. +<span class="lineNum"> 2208 </span> : * @return True if @a rhs.compare(@a lhs) != 0. False otherwise. +<span class="lineNum"> 2209 </span> : */ +<span class="lineNum"> 2210 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2211 </span> : inline bool +<span class="lineNum"> 2212 </span> : operator!=(const _CharT* __lhs, +<span class="lineNum"> 2213 </span> : const basic_string<_CharT, _Traits, _Alloc>& __rhs) +<span class="lineNum"> 2214 </span> : { return !(__lhs == __rhs); } +<span class="lineNum"> 2215 </span> : +<span class="lineNum"> 2216 </span> : /** +<span class="lineNum"> 2217 </span> : * @brief Test difference of string and C string. +<span class="lineNum"> 2218 </span> : * @param lhs String. +<span class="lineNum"> 2219 </span> : * @param rhs C string. +<span class="lineNum"> 2220 </span> : * @return True if @a lhs.compare(@a rhs) != 0. False otherwise. +<span class="lineNum"> 2221 </span> : */ +<span class="lineNum"> 2222 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2223 </span> : inline bool +<span class="lineNum"> 2224 </span> : operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2225 </span><span class="lineCov"> 74475 : const _CharT* __rhs)</span> +<span class="lineNum"> 2226 </span><span class="lineCov"> 74475 : { return !(__lhs == __rhs); }</span> +<span class="lineNum"> 2227 </span> : +<span class="lineNum"> 2228 </span> : // operator < +<span class="lineNum"> 2229 </span> : /** +<span class="lineNum"> 2230 </span> : * @brief Test if string precedes string. +<span class="lineNum"> 2231 </span> : * @param lhs First string. +<span class="lineNum"> 2232 </span> : * @param rhs Second string. +<span class="lineNum"> 2233 </span> : * @return True if @a lhs precedes @a rhs. False otherwise. +<span class="lineNum"> 2234 </span> : */ +<span class="lineNum"> 2235 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2236 </span> : inline bool +<span class="lineNum"> 2237 </span> : operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2238 </span><span class="lineCov"> 4885154 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)</span> +<span class="lineNum"> 2239 </span><span class="lineCov"> 4885154 : { return __lhs.compare(__rhs) < 0; }</span> +<span class="lineNum"> 2240 </span> : +<span class="lineNum"> 2241 </span> : /** +<span class="lineNum"> 2242 </span> : * @brief Test if string precedes C string. +<span class="lineNum"> 2243 </span> : * @param lhs String. +<span class="lineNum"> 2244 </span> : * @param rhs C string. +<span class="lineNum"> 2245 </span> : * @return True if @a lhs precedes @a rhs. False otherwise. +<span class="lineNum"> 2246 </span> : */ +<span class="lineNum"> 2247 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2248 </span> : inline bool +<span class="lineNum"> 2249 </span> : operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2250 </span> : const _CharT* __rhs) +<span class="lineNum"> 2251 </span> : { return __lhs.compare(__rhs) < 0; } +<span class="lineNum"> 2252 </span> : +<span class="lineNum"> 2253 </span> : /** +<span class="lineNum"> 2254 </span> : * @brief Test if C string precedes string. +<span class="lineNum"> 2255 </span> : * @param lhs C string. +<span class="lineNum"> 2256 </span> : * @param rhs String. +<span class="lineNum"> 2257 </span> : * @return True if @a lhs precedes @a rhs. False otherwise. +<span class="lineNum"> 2258 </span> : */ +<span class="lineNum"> 2259 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2260 </span> : inline bool +<span class="lineNum"> 2261 </span> : operator<(const _CharT* __lhs, +<span class="lineNum"> 2262 </span> : const basic_string<_CharT, _Traits, _Alloc>& __rhs) +<span class="lineNum"> 2263 </span> : { return __rhs.compare(__lhs) > 0; } +<span class="lineNum"> 2264 </span> : +<span class="lineNum"> 2265 </span> : // operator > +<span class="lineNum"> 2266 </span> : /** +<span class="lineNum"> 2267 </span> : * @brief Test if string follows string. +<span class="lineNum"> 2268 </span> : * @param lhs First string. +<span class="lineNum"> 2269 </span> : * @param rhs Second string. +<span class="lineNum"> 2270 </span> : * @return True if @a lhs follows @a rhs. False otherwise. +<span class="lineNum"> 2271 </span> : */ +<span class="lineNum"> 2272 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2273 </span> : inline bool +<span class="lineNum"> 2274 </span> : operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2275 </span><span class="lineCov"> 1024110 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)</span> +<span class="lineNum"> 2276 </span><span class="lineCov"> 1024110 : { return __lhs.compare(__rhs) > 0; }</span> +<span class="lineNum"> 2277 </span> : +<span class="lineNum"> 2278 </span> : /** +<span class="lineNum"> 2279 </span> : * @brief Test if string follows C string. +<span class="lineNum"> 2280 </span> : * @param lhs String. +<span class="lineNum"> 2281 </span> : * @param rhs C string. +<span class="lineNum"> 2282 </span> : * @return True if @a lhs follows @a rhs. False otherwise. +<span class="lineNum"> 2283 </span> : */ +<span class="lineNum"> 2284 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2285 </span> : inline bool +<span class="lineNum"> 2286 </span> : operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2287 </span> : const _CharT* __rhs) +<span class="lineNum"> 2288 </span> : { return __lhs.compare(__rhs) > 0; } +<span class="lineNum"> 2289 </span> : +<span class="lineNum"> 2290 </span> : /** +<span class="lineNum"> 2291 </span> : * @brief Test if C string follows string. +<span class="lineNum"> 2292 </span> : * @param lhs C string. +<span class="lineNum"> 2293 </span> : * @param rhs String. +<span class="lineNum"> 2294 </span> : * @return True if @a lhs follows @a rhs. False otherwise. +<span class="lineNum"> 2295 </span> : */ +<span class="lineNum"> 2296 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2297 </span> : inline bool +<span class="lineNum"> 2298 </span> : operator>(const _CharT* __lhs, +<span class="lineNum"> 2299 </span> : const basic_string<_CharT, _Traits, _Alloc>& __rhs) +<span class="lineNum"> 2300 </span> : { return __rhs.compare(__lhs) < 0; } +<span class="lineNum"> 2301 </span> : +<span class="lineNum"> 2302 </span> : // operator <= +<span class="lineNum"> 2303 </span> : /** +<span class="lineNum"> 2304 </span> : * @brief Test if string doesn't follow string. +<span class="lineNum"> 2305 </span> : * @param lhs First string. +<span class="lineNum"> 2306 </span> : * @param rhs Second string. +<span class="lineNum"> 2307 </span> : * @return True if @a lhs doesn't follow @a rhs. False otherwise. +<span class="lineNum"> 2308 </span> : */ +<span class="lineNum"> 2309 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2310 </span> : inline bool +<span class="lineNum"> 2311 </span> : operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2312 </span><span class="lineCov"> 58 : const basic_string<_CharT, _Traits, _Alloc>& __rhs)</span> +<span class="lineNum"> 2313 </span><span class="lineCov"> 58 : { return __lhs.compare(__rhs) <= 0; }</span> +<span class="lineNum"> 2314 </span> : +<span class="lineNum"> 2315 </span> : /** +<span class="lineNum"> 2316 </span> : * @brief Test if string doesn't follow C string. +<span class="lineNum"> 2317 </span> : * @param lhs String. +<span class="lineNum"> 2318 </span> : * @param rhs C string. +<span class="lineNum"> 2319 </span> : * @return True if @a lhs doesn't follow @a rhs. False otherwise. +<span class="lineNum"> 2320 </span> : */ +<span class="lineNum"> 2321 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2322 </span> : inline bool +<span class="lineNum"> 2323 </span> : operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2324 </span> : const _CharT* __rhs) +<span class="lineNum"> 2325 </span> : { return __lhs.compare(__rhs) <= 0; } +<span class="lineNum"> 2326 </span> : +<span class="lineNum"> 2327 </span> : /** +<span class="lineNum"> 2328 </span> : * @brief Test if C string doesn't follow string. +<span class="lineNum"> 2329 </span> : * @param lhs C string. +<span class="lineNum"> 2330 </span> : * @param rhs String. +<span class="lineNum"> 2331 </span> : * @return True if @a lhs doesn't follow @a rhs. False otherwise. +<span class="lineNum"> 2332 </span> : */ +<span class="lineNum"> 2333 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2334 </span> : inline bool +<span class="lineNum"> 2335 </span> : operator<=(const _CharT* __lhs, +<span class="lineNum"> 2336 </span> : const basic_string<_CharT, _Traits, _Alloc>& __rhs) +<span class="lineNum"> 2337 </span> : { return __rhs.compare(__lhs) >= 0; } +<span class="lineNum"> 2338 </span> : +<span class="lineNum"> 2339 </span> : // operator >= +<span class="lineNum"> 2340 </span> : /** +<span class="lineNum"> 2341 </span> : * @brief Test if string doesn't precede string. +<span class="lineNum"> 2342 </span> : * @param lhs First string. +<span class="lineNum"> 2343 </span> : * @param rhs Second string. +<span class="lineNum"> 2344 </span> : * @return True if @a lhs doesn't precede @a rhs. False otherwise. +<span class="lineNum"> 2345 </span> : */ +<span class="lineNum"> 2346 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2347 </span> : inline bool +<span class="lineNum"> 2348 </span> : operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2349 </span> : const basic_string<_CharT, _Traits, _Alloc>& __rhs) +<span class="lineNum"> 2350 </span> : { return __lhs.compare(__rhs) >= 0; } +<span class="lineNum"> 2351 </span> : +<span class="lineNum"> 2352 </span> : /** +<span class="lineNum"> 2353 </span> : * @brief Test if string doesn't precede C string. +<span class="lineNum"> 2354 </span> : * @param lhs String. +<span class="lineNum"> 2355 </span> : * @param rhs C string. +<span class="lineNum"> 2356 </span> : * @return True if @a lhs doesn't precede @a rhs. False otherwise. +<span class="lineNum"> 2357 </span> : */ +<span class="lineNum"> 2358 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2359 </span> : inline bool +<span class="lineNum"> 2360 </span> : operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2361 </span> : const _CharT* __rhs) +<span class="lineNum"> 2362 </span> : { return __lhs.compare(__rhs) >= 0; } +<span class="lineNum"> 2363 </span> : +<span class="lineNum"> 2364 </span> : /** +<span class="lineNum"> 2365 </span> : * @brief Test if C string doesn't precede string. +<span class="lineNum"> 2366 </span> : * @param lhs C string. +<span class="lineNum"> 2367 </span> : * @param rhs String. +<span class="lineNum"> 2368 </span> : * @return True if @a lhs doesn't precede @a rhs. False otherwise. +<span class="lineNum"> 2369 </span> : */ +<span class="lineNum"> 2370 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2371 </span> : inline bool +<span class="lineNum"> 2372 </span> : operator>=(const _CharT* __lhs, +<span class="lineNum"> 2373 </span> : const basic_string<_CharT, _Traits, _Alloc>& __rhs) +<span class="lineNum"> 2374 </span> : { return __rhs.compare(__lhs) <= 0; } +<span class="lineNum"> 2375 </span> : +<span class="lineNum"> 2376 </span> : /** +<span class="lineNum"> 2377 </span> : * @brief Swap contents of two strings. +<span class="lineNum"> 2378 </span> : * @param lhs First string. +<span class="lineNum"> 2379 </span> : * @param rhs Second string. +<span class="lineNum"> 2380 </span> : * +<span class="lineNum"> 2381 </span> : * Exchanges the contents of @a lhs and @a rhs in constant time. +<span class="lineNum"> 2382 </span> : */ +<span class="lineNum"> 2383 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2384 </span> : inline void +<span class="lineNum"> 2385 </span> : swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, +<span class="lineNum"> 2386 </span><span class="lineNoCov"> 0 : basic_string<_CharT, _Traits, _Alloc>& __rhs)</span> +<span class="lineNum"> 2387 </span><span class="lineNoCov"> 0 : { __lhs.swap(__rhs); }</span> +<span class="lineNum"> 2388 </span> : +<span class="lineNum"> 2389 </span> : /** +<span class="lineNum"> 2390 </span> : * @brief Read stream into a string. +<span class="lineNum"> 2391 </span> : * @param is Input stream. +<span class="lineNum"> 2392 </span> : * @param str Buffer to store into. +<span class="lineNum"> 2393 </span> : * @return Reference to the input stream. +<span class="lineNum"> 2394 </span> : * +<span class="lineNum"> 2395 </span> : * Stores characters from @a is into @a str until whitespace is found, the +<span class="lineNum"> 2396 </span> : * end of the stream is encountered, or str.max_size() is reached. If +<span class="lineNum"> 2397 </span> : * is.width() is non-zero, that is the limit on the number of characters +<span class="lineNum"> 2398 </span> : * stored into @a str. Any previous contents of @a str are erased. +<span class="lineNum"> 2399 </span> : */ +<span class="lineNum"> 2400 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2401 </span> : basic_istream<_CharT, _Traits>& +<span class="lineNum"> 2402 </span> : operator>>(basic_istream<_CharT, _Traits>& __is, +<span class="lineNum"> 2403 </span> : basic_string<_CharT, _Traits, _Alloc>& __str); +<span class="lineNum"> 2404 </span> : +<span class="lineNum"> 2405 </span> : template<> +<span class="lineNum"> 2406 </span> : basic_istream<char>& +<span class="lineNum"> 2407 </span> : operator>>(basic_istream<char>& __is, basic_string<char>& __str); +<span class="lineNum"> 2408 </span> : +<span class="lineNum"> 2409 </span> : /** +<span class="lineNum"> 2410 </span> : * @brief Write string to a stream. +<span class="lineNum"> 2411 </span> : * @param os Output stream. +<span class="lineNum"> 2412 </span> : * @param str String to write out. +<span class="lineNum"> 2413 </span> : * @return Reference to the output stream. +<span class="lineNum"> 2414 </span> : * +<span class="lineNum"> 2415 </span> : * Output characters of @a str into os following the same rules as for +<span class="lineNum"> 2416 </span> : * writing a C string. +<span class="lineNum"> 2417 </span> : */ +<span class="lineNum"> 2418 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2419 </span> : inline basic_ostream<_CharT, _Traits>& +<span class="lineNum"> 2420 </span> : operator<<(basic_ostream<_CharT, _Traits>& __os, +<span class="lineNum"> 2421 </span><span class="lineNoCov"> 0 : const basic_string<_CharT, _Traits, _Alloc>& __str)</span> +<span class="lineNum"> 2422 </span> : { +<span class="lineNum"> 2423 </span> : // _GLIBCXX_RESOLVE_LIB_DEFECTS +<span class="lineNum"> 2424 </span> : // 586. string inserter not a formatted function +<span class="lineNum"> 2425 </span><span class="lineNoCov"> 0 : return __ostream_insert(__os, __str.data(), __str.size());</span> +<span class="lineNum"> 2426 </span> : } +<span class="lineNum"> 2427 </span> : +<span class="lineNum"> 2428 </span> : /** +<span class="lineNum"> 2429 </span> : * @brief Read a line from stream into a string. +<span class="lineNum"> 2430 </span> : * @param is Input stream. +<span class="lineNum"> 2431 </span> : * @param str Buffer to store into. +<span class="lineNum"> 2432 </span> : * @param delim Character marking end of line. +<span class="lineNum"> 2433 </span> : * @return Reference to the input stream. +<span class="lineNum"> 2434 </span> : * +<span class="lineNum"> 2435 </span> : * Stores characters from @a is into @a str until @a delim is found, the +<span class="lineNum"> 2436 </span> : * end of the stream is encountered, or str.max_size() is reached. If +<span class="lineNum"> 2437 </span> : * is.width() is non-zero, that is the limit on the number of characters +<span class="lineNum"> 2438 </span> : * stored into @a str. Any previous contents of @a str are erased. If @a +<span class="lineNum"> 2439 </span> : * delim was encountered, it is extracted but not stored into @a str. +<span class="lineNum"> 2440 </span> : */ +<span class="lineNum"> 2441 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2442 </span> : basic_istream<_CharT, _Traits>& +<span class="lineNum"> 2443 </span> : getline(basic_istream<_CharT, _Traits>& __is, +<span class="lineNum"> 2444 </span> : basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); +<span class="lineNum"> 2445 </span> : +<span class="lineNum"> 2446 </span> : /** +<span class="lineNum"> 2447 </span> : * @brief Read a line from stream into a string. +<span class="lineNum"> 2448 </span> : * @param is Input stream. +<span class="lineNum"> 2449 </span> : * @param str Buffer to store into. +<span class="lineNum"> 2450 </span> : * @return Reference to the input stream. +<span class="lineNum"> 2451 </span> : * +<span class="lineNum"> 2452 </span> : * Stores characters from is into @a str until '\n' is found, the end of +<span class="lineNum"> 2453 </span> : * the stream is encountered, or str.max_size() is reached. If is.width() +<span class="lineNum"> 2454 </span> : * is non-zero, that is the limit on the number of characters stored into +<span class="lineNum"> 2455 </span> : * @a str. Any previous contents of @a str are erased. If end of line was +<span class="lineNum"> 2456 </span> : * encountered, it is extracted but not stored into @a str. +<span class="lineNum"> 2457 </span> : */ +<span class="lineNum"> 2458 </span> : template<typename _CharT, typename _Traits, typename _Alloc> +<span class="lineNum"> 2459 </span> : inline basic_istream<_CharT, _Traits>& +<span class="lineNum"> 2460 </span> : getline(basic_istream<_CharT, _Traits>& __is, +<span class="lineNum"> 2461 </span><span class="lineNoCov"> 0 : basic_string<_CharT, _Traits, _Alloc>& __str)</span> +<span class="lineNum"> 2462 </span><span class="lineNoCov"> 0 : { return getline(__is, __str, __is.widen('\n')); }</span> +<span class="lineNum"> 2463 </span> : +<span class="lineNum"> 2464 </span> : template<> +<span class="lineNum"> 2465 </span> : basic_istream<char>& +<span class="lineNum"> 2466 </span> : getline(basic_istream<char>& __in, basic_string<char>& __str, +<span class="lineNum"> 2467 </span> : char __delim); +<span class="lineNum"> 2468 </span> : +<span class="lineNum"> 2469 </span> : #ifdef _GLIBCXX_USE_WCHAR_T +<span class="lineNum"> 2470 </span> : template<> +<span class="lineNum"> 2471 </span> : basic_istream<wchar_t>& +<span class="lineNum"> 2472 </span> : getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str, +<span class="lineNum"> 2473 </span> : wchar_t __delim); +<span class="lineNum"> 2474 </span> : #endif +<span class="lineNum"> 2475 </span> : +<span class="lineNum"> 2476 </span> : _GLIBCXX_END_NAMESPACE +<span class="lineNum"> 2477 </span> : +<span class="lineNum"> 2478 </span> : #endif /* _BASIC_STRING_H */ +</pre> + </td> + </tr> + </table> + <br> + + <table width="100%" border=0 cellspacing=0 cellpadding=0> + <tr><td class="ruler"><img src="../../../../../glass.png" width=3 height=3 alt=""></td></tr> + <tr><td class="versionInfo">Generated by: <a href="http://ltp.sourceforge.net/coverage/lcov.php" target="_parent">LTP GCOV extension version 1.6</a></td></tr> + </table> + <br> + +</body> +</html> |