1 // String based streams -*- C++ -*- 2 3 // Copyright (C) 1997-2024 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file include/sstream 26 * This is a Standard C++ Library header. 27 */ 28 29 // 30 // ISO C++ 14882: 27.7 String-based streams 31 // 32 33 #ifndef _GLIBCXX_SSTREAM 34 #define _GLIBCXX_SSTREAM 1 35 36 #pragma GCC system_header 37 38 #include <bits/requires_hosted.h> // iostream 39 40 #include <istream> 41 #include <ostream> 42 #include <bits/alloc_traits.h> // allocator_traits, __allocator_like 43 44 #if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI 45 # define _GLIBCXX_LVAL_REF_QUAL & 46 # define _GLIBCXX_SSTREAM_ALWAYS_INLINE 47 #else 48 # define _GLIBCXX_LVAL_REF_QUAL 49 // For symbols that are not exported from libstdc++.so for the COW string ABI. 50 # define _GLIBCXX_SSTREAM_ALWAYS_INLINE [[__gnu__::__always_inline__]] 51 #endif 52 53 54 55 namespace std _GLIBCXX_VISIBILITY(default) 56 { 57 _GLIBCXX_BEGIN_NAMESPACE_VERSION 58 _GLIBCXX_BEGIN_NAMESPACE_CXX11 59 60 // [27.7.1] template class basic_stringbuf 61 /** 62 * @brief The actual work of input and output (for std::string). 63 * @ingroup io 64 * 65 * @tparam _CharT Type of character stream. 66 * @tparam _Traits Traits for character type, defaults to 67 * char_traits<_CharT>. 68 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. 69 * 70 * This class associates either or both of its input and output sequences 71 * with a sequence of characters, which can be initialized from, or made 72 * available as, a @c std::basic_string. (Paraphrased from [27.7.1]/1.) 73 * 74 * For this class, open modes (of type @c ios_base::openmode) have 75 * @c in set if the input sequence can be read, and @c out set if the 76 * output sequence can be written. 77 */ 78 template<typename _CharT, typename _Traits, typename _Alloc> 79 class basic_stringbuf : public basic_streambuf<_CharT, _Traits> 80 { 81 struct __xfer_bufptrs; 82 83 #if __cplusplus >= 201103L 84 using allocator_traits = std::allocator_traits<_Alloc>; 85 using _Noexcept_swap 86 = __or_<typename allocator_traits::propagate_on_container_swap, 87 typename allocator_traits::is_always_equal>; 88 #endif 89 90 public: 91 // Types: 92 typedef _CharT char_type; 93 typedef _Traits traits_type; 94 // _GLIBCXX_RESOLVE_LIB_DEFECTS 95 // 251. basic_stringbuf missing allocator_type 96 typedef _Alloc allocator_type; 97 typedef typename traits_type::int_type int_type; 98 typedef typename traits_type::pos_type pos_type; 99 typedef typename traits_type::off_type off_type; 100 101 typedef basic_streambuf<char_type, traits_type> __streambuf_type; 102 typedef basic_string<char_type, _Traits, _Alloc> __string_type; 103 typedef typename __string_type::size_type __size_type; 104 105 protected: 106 /// Place to stash in || out || in | out settings for current stringbuf. 107 ios_base::openmode _M_mode; 108 109 // Data Members: 110 __string_type _M_string; 111 112 public: 113 // Constructors: 114 115 /** 116 * @brief Starts with an empty string buffer. 117 * 118 * The default constructor initializes the parent class using its 119 * own default ctor. 120 */ 121 basic_stringbuf() 122 : __streambuf_type(), _M_mode(ios_base::in | ios_base::out), _M_string() 123 { } 124 125 /** 126 * @brief Starts with an empty string buffer. 127 * @param __mode Whether the buffer can read, or write, or both. 128 * 129 * The default constructor initializes the parent class using its 130 * own default ctor. 131 */ 132 explicit 133 basic_stringbuf(ios_base::openmode __mode) 134 : __streambuf_type(), _M_mode(__mode), _M_string() 135 { } 136 137 /** 138 * @brief Starts with an existing string buffer. 139 * @param __str A string to copy as a starting buffer. 140 * @param __mode Whether the buffer can read, or write, or both. 141 * 142 * This constructor initializes the parent class using its 143 * own default ctor. 144 */ 145 explicit 146 basic_stringbuf(const __string_type& __str, 147 ios_base::openmode __mode = ios_base::in | ios_base::out) 148 : __streambuf_type(), _M_mode(), 149 _M_string(__str.data(), __str.size(), __str.get_allocator()) 150 { _M_stringbuf_init(__mode); } 151 152 #if __cplusplus >= 201103L 153 basic_stringbuf(const basic_stringbuf&) = delete; 154 155 basic_stringbuf(basic_stringbuf&& __rhs) 156 : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this)) 157 { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); } 158 159 #if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI 160 explicit 161 basic_stringbuf(const allocator_type& __a) 162 : basic_stringbuf(ios_base::in | std::ios_base::out, __a) 163 { } 164 165 basic_stringbuf(ios_base::openmode __mode, 166 const allocator_type& __a) 167 : __streambuf_type(), _M_mode(__mode), _M_string(__a) 168 { } 169 170 explicit 171 basic_stringbuf(__string_type&& __s, 172 ios_base::openmode __mode = ios_base::in 173 | ios_base::out) 174 : __streambuf_type(), _M_mode(__mode), _M_string(std::move(__s)) 175 { _M_stringbuf_init(__mode); } 176 177 template<typename _SAlloc> 178 basic_stringbuf(const basic_string<_CharT, _Traits, _SAlloc>& __s, 179 const allocator_type& __a) 180 : basic_stringbuf(__s, ios_base::in | std::ios_base::out, __a) 181 { } 182 183 template<typename _SAlloc> 184 basic_stringbuf(const basic_string<_CharT, _Traits, _SAlloc>& __s, 185 ios_base::openmode __mode, 186 const allocator_type& __a) 187 : __streambuf_type(), _M_mode(__mode), 188 _M_string(__s.data(), __s.size(), __a) 189 { _M_stringbuf_init(__mode); } 190 191 template<typename _SAlloc> 192 explicit 193 basic_stringbuf(const basic_string<_CharT, _Traits, _SAlloc>& __s, 194 ios_base::openmode __mode = ios_base::in 195 | ios_base::out) 196 : basic_stringbuf(__s, __mode, allocator_type{}) 197 { } 198 199 basic_stringbuf(basic_stringbuf&& __rhs, const allocator_type& __a) 200 : basic_stringbuf(std::move(__rhs), __a, __xfer_bufptrs(__rhs, this)) 201 { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); } 202 203 allocator_type get_allocator() const noexcept 204 { return _M_string.get_allocator(); } 205 #endif // C++20 206 207 // 27.8.2.2 Assign and swap: 208 209 basic_stringbuf& 210 operator=(const basic_stringbuf&) = delete; 211 212 basic_stringbuf& 213 operator=(basic_stringbuf&& __rhs) 214 { 215 __xfer_bufptrs __st{__rhs, this}; 216 const __streambuf_type& __base = __rhs; 217 __streambuf_type::operator=(__base); 218 this->pubimbue(__rhs.getloc()); 219 _M_mode = __rhs._M_mode; 220 _M_string = std::move(__rhs._M_string); 221 __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); 222 return *this; 223 } 224 225 void 226 swap(basic_stringbuf& __rhs) noexcept(_Noexcept_swap::value) 227 { 228 __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)}; 229 __xfer_bufptrs __r_st{__rhs, this}; 230 __streambuf_type& __base = __rhs; 231 __streambuf_type::swap(__base); 232 __rhs.pubimbue(this->pubimbue(__rhs.getloc())); 233 std::swap(_M_mode, __rhs._M_mode); 234 std::swap(_M_string, __rhs._M_string); // XXX not exception safe 235 } 236 #endif // C++11 237 238 // Getters and setters: 239 240 /** 241 * @brief Copying out the string buffer. 242 * @return A copy of one of the underlying sequences. 243 * 244 * <em>If the buffer is only created in input mode, the underlying 245 * character sequence is equal to the input sequence; otherwise, it 246 * is equal to the output sequence.</em> [27.7.1.2]/1 247 */ 248 __string_type 249 str() const _GLIBCXX_LVAL_REF_QUAL 250 { 251 __string_type __ret(_M_string.get_allocator()); 252 if (char_type* __hi = _M_high_mark()) 253 __ret.assign(this->pbase(), __hi); 254 else 255 __ret = _M_string; 256 return __ret; 257 } 258 259 #if __cplusplus > 201703L 260 #if _GLIBCXX_USE_CXX11_ABI 261 #if __cpp_concepts 262 template<__allocator_like _SAlloc> 263 basic_string<_CharT, _Traits, _SAlloc> 264 str(const _SAlloc& __sa) const 265 { 266 auto __sv = view(); 267 return { __sv.data(), __sv.size(), __sa }; 268 } 269 #endif 270 271 __string_type 272 str() && 273 { 274 if (char_type* __hi = _M_high_mark()) 275 { 276 // Set length to end of character sequence and add null terminator. 277 _M_string._M_set_length(_M_high_mark() - this->pbase()); 278 } 279 auto __str = std::move(_M_string); 280 _M_string.clear(); 281 _M_sync(_M_string.data(), 0, 0); 282 return __str; 283 } 284 #endif // cxx11 ABI 285 286 _GLIBCXX_SSTREAM_ALWAYS_INLINE 287 basic_string_view<char_type, traits_type> 288 view() const noexcept 289 { 290 if (char_type* __hi = _M_high_mark()) 291 return { this->pbase(), __hi }; 292 else 293 return _M_string; 294 } 295 #endif // C++20 296 297 /** 298 * @brief Setting a new buffer. 299 * @param __s The string to use as a new sequence. 300 * 301 * Deallocates any previous stored sequence, then copies @a s to 302 * use as a new one. 303 */ 304 void 305 str(const __string_type& __s) 306 { 307 // Cannot use _M_string = __s, since v3 strings are COW 308 // (not always true now but assign() always works). 309 _M_string.assign(__s.data(), __s.size()); 310 _M_stringbuf_init(_M_mode); 311 } 312 313 #if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI 314 #if __cpp_concepts 315 template<__allocator_like _SAlloc> 316 requires (!is_same_v<_SAlloc, _Alloc>) 317 void 318 str(const basic_string<_CharT, _Traits, _SAlloc>& __s) 319 { 320 _M_string.assign(__s.data(), __s.size()); 321 _M_stringbuf_init(_M_mode); 322 } 323 #endif 324 325 void 326 str(__string_type&& __s) 327 { 328 _M_string = std::move(__s); 329 _M_stringbuf_init(_M_mode); 330 } 331 #endif 332 333 protected: 334 // Common initialization code goes here. 335 void 336 _M_stringbuf_init(ios_base::openmode __mode) 337 { 338 _M_mode = __mode; 339 __size_type __len = 0; 340 if (_M_mode & (ios_base::ate | ios_base::app)) 341 __len = _M_string.size(); 342 _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len); 343 } 344 345 virtual streamsize 346 showmanyc() 347 { 348 streamsize __ret = -1; 349 if (_M_mode & ios_base::in) 350 { 351 _M_update_egptr(); 352 __ret = this->egptr() - this->gptr(); 353 } 354 return __ret; 355 } 356 357 virtual int_type 358 underflow(); 359 360 virtual int_type 361 pbackfail(int_type __c = traits_type::eof()); 362 363 virtual int_type 364 overflow(int_type __c = traits_type::eof()); 365 366 /** 367 * @brief Manipulates the buffer. 368 * @param __s Pointer to a buffer area. 369 * @param __n Size of @a __s. 370 * @return @c this 371 * 372 * If no buffer has already been created, and both @a __s and @a __n are 373 * non-zero, then @c __s is used as a buffer; see 374 * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering 375 * for more. 376 */ 377 virtual __streambuf_type* 378 setbuf(char_type* __s, streamsize __n) 379 { 380 if (__s && __n >= 0) 381 { 382 // This is implementation-defined behavior, and assumes 383 // that an external char_type array of length __n exists 384 // and has been pre-allocated. If this is not the case, 385 // things will quickly blow up. 386 387 // Step 1: Destroy the current internal array. 388 _M_string.clear(); 389 390 // Step 2: Use the external array. 391 _M_sync(__s, __n, 0); 392 } 393 return this; 394 } 395 396 virtual pos_type 397 seekoff(off_type __off, ios_base::seekdir __way, 398 ios_base::openmode __mode = ios_base::in | ios_base::out); 399 400 virtual pos_type 401 seekpos(pos_type __sp, 402 ios_base::openmode __mode = ios_base::in | ios_base::out); 403 404 // Internal function for correctly updating the internal buffer 405 // for a particular _M_string, due to initialization or re-sizing 406 // of an existing _M_string. 407 void 408 _M_sync(char_type* __base, __size_type __i, __size_type __o); 409 410 // Internal function for correctly updating egptr() to the actual 411 // string end. 412 void 413 _M_update_egptr() 414 { 415 if (char_type* __pptr = this->pptr()) 416 { 417 char_type* __egptr = this->egptr(); 418 if (!__egptr || __pptr > __egptr) 419 { 420 if (_M_mode & ios_base::in) 421 this->setg(this->eback(), this->gptr(), __pptr); 422 else 423 this->setg(__pptr, __pptr, __pptr); 424 } 425 } 426 } 427 428 // Works around the issue with pbump, part of the protected 429 // interface of basic_streambuf, taking just an int. 430 void 431 _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off); 432 433 private: 434 // Return a pointer to the end of the underlying character sequence. 435 // This might not be the same character as _M_string.end() because 436 // basic_stringbuf::overflow might have written to unused capacity 437 // in _M_string without updating its length. 438 __attribute__((__always_inline__)) 439 char_type* 440 _M_high_mark() const _GLIBCXX_NOEXCEPT 441 { 442 if (char_type* __pptr = this->pptr()) 443 { 444 char_type* __egptr = this->egptr(); 445 if (!__egptr || __pptr > __egptr) 446 return __pptr; // Underlying sequence is [pbase, pptr). 447 else 448 return __egptr; // Underlying sequence is [pbase, egptr). 449 } 450 return 0; // Underlying character sequence is just _M_string. 451 } 452 453 #if __cplusplus >= 201103L 454 #if _GLIBCXX_USE_CXX11_ABI 455 // This type captures the state of the gptr / pptr pointers as offsets 456 // so they can be restored in another object after moving the string. 457 struct __xfer_bufptrs 458 { 459 __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to) 460 : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1} 461 { 462 const _CharT* const __str = __from._M_string.data(); 463 const _CharT* __end = nullptr; 464 if (__from.eback()) 465 { 466 _M_goff[0] = __from.eback() - __str; 467 _M_goff[1] = __from.gptr() - __str; 468 _M_goff[2] = __from.egptr() - __str; 469 __end = __from.egptr(); 470 } 471 if (__from.pbase()) 472 { 473 _M_poff[0] = __from.pbase() - __str; 474 _M_poff[1] = __from.pptr() - __from.pbase(); 475 _M_poff[2] = __from.epptr() - __str; 476 if (!__end || __from.pptr() > __end) 477 __end = __from.pptr(); 478 } 479 480 // Set _M_string length to the greater of the get and put areas. 481 if (__end) 482 { 483 // The const_cast avoids changing this constructor's signature, 484 // because it is exported from the dynamic library. 485 auto& __mut_from = const_cast<basic_stringbuf&>(__from); 486 __mut_from._M_string._M_length(__end - __str); 487 } 488 } 489 490 ~__xfer_bufptrs() 491 { 492 char_type* __str = const_cast<char_type*>(_M_to->_M_string.data()); 493 if (_M_goff[0] != -1) 494 _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]); 495 if (_M_poff[0] != -1) 496 _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]); 497 } 498 499 basic_stringbuf* _M_to; 500 off_type _M_goff[3]; 501 off_type _M_poff[3]; 502 }; 503 #else 504 // This type does nothing when using Copy-On-Write strings. 505 struct __xfer_bufptrs 506 { 507 __xfer_bufptrs(const basic_stringbuf&, basic_stringbuf*) { } 508 }; 509 #endif 510 511 // The move constructor initializes an __xfer_bufptrs temporary then 512 // delegates to this constructor to performs moves during its lifetime. 513 basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&) 514 : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)), 515 _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string)) 516 { } 517 518 #if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI 519 // The move constructor initializes an __xfer_bufptrs temporary then 520 // delegates to this constructor to performs moves during its lifetime. 521 basic_stringbuf(basic_stringbuf&& __rhs, const allocator_type& __a, 522 __xfer_bufptrs&&) 523 : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)), 524 _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string), __a) 525 { } 526 #endif 527 #endif // C++11 528 }; 529 530 531 // [27.7.2] Template class basic_istringstream 532 /** 533 * @brief Controlling input for std::string. 534 * @ingroup io 535 * 536 * @tparam _CharT Type of character stream. 537 * @tparam _Traits Traits for character type, defaults to 538 * char_traits<_CharT>. 539 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. 540 * 541 * This class supports reading from objects of type std::basic_string, 542 * using the inherited functions from std::basic_istream. To control 543 * the associated sequence, an instance of std::basic_stringbuf is used, 544 * which this page refers to as @c sb. 545 */ 546 template<typename _CharT, typename _Traits, typename _Alloc> 547 class basic_istringstream : public basic_istream<_CharT, _Traits> 548 { 549 public: 550 // Types: 551 typedef _CharT char_type; 552 typedef _Traits traits_type; 553 // _GLIBCXX_RESOLVE_LIB_DEFECTS 554 // 251. basic_stringbuf missing allocator_type 555 typedef _Alloc allocator_type; 556 typedef typename traits_type::int_type int_type; 557 typedef typename traits_type::pos_type pos_type; 558 typedef typename traits_type::off_type off_type; 559 560 // Non-standard types: 561 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 562 typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; 563 typedef basic_istream<char_type, traits_type> __istream_type; 564 565 private: 566 __stringbuf_type _M_stringbuf; 567 568 public: 569 // Constructors: 570 571 /** 572 * @brief Default constructor starts with an empty string buffer. 573 * 574 * Initializes @c sb using @c in, and passes @c &sb to the base 575 * class initializer. Does not allocate any buffer. 576 * 577 * That's a lie. We initialize the base class with NULL, because the 578 * string class does its own memory management. 579 */ 580 basic_istringstream() 581 : __istream_type(), _M_stringbuf(ios_base::in) 582 { this->init(&_M_stringbuf); } 583 584 /** 585 * @brief Starts with an empty string buffer. 586 * @param __mode Whether the buffer can read, or write, or both. 587 * 588 * @c ios_base::in is automatically included in @a __mode. 589 * 590 * Initializes @c sb using @c __mode|in, and passes @c &sb to the base 591 * class initializer. Does not allocate any buffer. 592 * 593 * That's a lie. We initialize the base class with NULL, because the 594 * string class does its own memory management. 595 */ 596 explicit 597 basic_istringstream(ios_base::openmode __mode) 598 : __istream_type(), _M_stringbuf(__mode | ios_base::in) 599 { this->init(&_M_stringbuf); } 600 601 /** 602 * @brief Starts with an existing string buffer. 603 * @param __str A string to copy as a starting buffer. 604 * @param __mode Whether the buffer can read, or write, or both. 605 * 606 * @c ios_base::in is automatically included in @a mode. 607 * 608 * Initializes @c sb using @a str and @c mode|in, and passes @c &sb 609 * to the base class initializer. 610 * 611 * That's a lie. We initialize the base class with NULL, because the 612 * string class does its own memory management. 613 */ 614 explicit 615 basic_istringstream(const __string_type& __str, 616 ios_base::openmode __mode = ios_base::in) 617 : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in) 618 { this->init(&_M_stringbuf); } 619 620 /** 621 * @brief The destructor does nothing. 622 * 623 * The buffer is deallocated by the stringbuf object, not the 624 * formatting stream. 625 */ 626 ~basic_istringstream() 627 { } 628 629 #if __cplusplus >= 201103L 630 basic_istringstream(const basic_istringstream&) = delete; 631 632 basic_istringstream(basic_istringstream&& __rhs) 633 : __istream_type(std::move(__rhs)), 634 _M_stringbuf(std::move(__rhs._M_stringbuf)) 635 { __istream_type::set_rdbuf(&_M_stringbuf); } 636 637 #if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI 638 basic_istringstream(ios_base::openmode __mode, const allocator_type& __a) 639 : __istream_type(), _M_stringbuf(__mode | ios_base::in, __a) 640 { this->init(std::__addressof(_M_stringbuf)); } 641 642 explicit 643 basic_istringstream(__string_type&& __str, 644 ios_base::openmode __mode = ios_base::in) 645 : __istream_type(), _M_stringbuf(std::move(__str), __mode | ios_base::in) 646 { this->init(std::__addressof(_M_stringbuf)); } 647 648 template<typename _SAlloc> 649 basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str, 650 const allocator_type& __a) 651 : basic_istringstream(__str, ios_base::in, __a) 652 { } 653 654 template<typename _SAlloc> 655 basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str, 656 ios_base::openmode __mode, 657 const allocator_type& __a) 658 : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in, __a) 659 { this->init(std::__addressof(_M_stringbuf)); } 660 661 template<typename _SAlloc> 662 explicit 663 basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str, 664 ios_base::openmode __mode = ios_base::in) 665 : basic_istringstream(__str, __mode, allocator_type()) 666 { } 667 #endif // C++20 668 669 // 27.8.3.2 Assign and swap: 670 671 basic_istringstream& 672 operator=(const basic_istringstream&) = delete; 673 674 basic_istringstream& 675 operator=(basic_istringstream&& __rhs) 676 { 677 __istream_type::operator=(std::move(__rhs)); 678 _M_stringbuf = std::move(__rhs._M_stringbuf); 679 return *this; 680 } 681 682 void 683 swap(basic_istringstream& __rhs) 684 { 685 __istream_type::swap(__rhs); 686 _M_stringbuf.swap(__rhs._M_stringbuf); 687 } 688 #endif // C++11 689 690 // Members: 691 /** 692 * @brief Accessing the underlying buffer. 693 * @return The current basic_stringbuf buffer. 694 * 695 * This hides both signatures of std::basic_ios::rdbuf(). 696 */ 697 __stringbuf_type* 698 rdbuf() const 699 { return const_cast<__stringbuf_type*>(&_M_stringbuf); } 700 701 /** 702 * @brief Copying out the string buffer. 703 * @return @c rdbuf()->str() 704 */ 705 __string_type 706 str() const _GLIBCXX_LVAL_REF_QUAL 707 { return _M_stringbuf.str(); } 708 709 #if __cplusplus > 201703L 710 #if _GLIBCXX_USE_CXX11_ABI 711 #if __cpp_concepts 712 template<__allocator_like _SAlloc> 713 basic_string<_CharT, _Traits, _SAlloc> 714 str(const _SAlloc& __sa) const 715 { return _M_stringbuf.str(__sa); } 716 #endif 717 718 __string_type 719 str() && 720 { return std::move(_M_stringbuf).str(); } 721 #endif // cxx11 ABI 722 723 _GLIBCXX_SSTREAM_ALWAYS_INLINE 724 basic_string_view<char_type, traits_type> 725 view() const noexcept 726 { return _M_stringbuf.view(); } 727 #endif // C++20 728 729 /** 730 * @brief Setting a new buffer. 731 * @param __s The string to use as a new sequence. 732 * 733 * Calls @c rdbuf()->str(s). 734 */ 735 void 736 str(const __string_type& __s) 737 { _M_stringbuf.str(__s); } 738 739 #if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI 740 #if __cpp_concepts 741 template<__allocator_like _SAlloc> 742 requires (!is_same_v<_SAlloc, _Alloc>) 743 void 744 str(const basic_string<_CharT, _Traits, _SAlloc>& __s) 745 { _M_stringbuf.str(__s); } 746 #endif 747 748 void 749 str(__string_type&& __s) 750 { _M_stringbuf.str(std::move(__s)); } 751 #endif 752 }; 753 754 755 // [27.7.3] Template class basic_ostringstream 756 /** 757 * @brief Controlling output for std::string. 758 * @ingroup io 759 * 760 * @tparam _CharT Type of character stream. 761 * @tparam _Traits Traits for character type, defaults to 762 * char_traits<_CharT>. 763 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. 764 * 765 * This class supports writing to objects of type std::basic_string, 766 * using the inherited functions from std::basic_ostream. To control 767 * the associated sequence, an instance of std::basic_stringbuf is used, 768 * which this page refers to as @c sb. 769 */ 770 template <typename _CharT, typename _Traits, typename _Alloc> 771 class basic_ostringstream : public basic_ostream<_CharT, _Traits> 772 { 773 public: 774 // Types: 775 typedef _CharT char_type; 776 typedef _Traits traits_type; 777 // _GLIBCXX_RESOLVE_LIB_DEFECTS 778 // 251. basic_stringbuf missing allocator_type 779 typedef _Alloc allocator_type; 780 typedef typename traits_type::int_type int_type; 781 typedef typename traits_type::pos_type pos_type; 782 typedef typename traits_type::off_type off_type; 783 784 // Non-standard types: 785 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 786 typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; 787 typedef basic_ostream<char_type, traits_type> __ostream_type; 788 789 private: 790 __stringbuf_type _M_stringbuf; 791 792 public: 793 // Constructors/destructor: 794 795 /** 796 * @brief Default constructor starts with an empty string buffer. 797 * 798 * Initializes @c sb using @c mode|out, and passes @c &sb to the base 799 * class initializer. Does not allocate any buffer. 800 * 801 * That's a lie. We initialize the base class with NULL, because the 802 * string class does its own memory management. 803 */ 804 basic_ostringstream() 805 : __ostream_type(), _M_stringbuf(ios_base::out) 806 { this->init(&_M_stringbuf); } 807 808 /** 809 * @brief Starts with an empty string buffer. 810 * @param __mode Whether the buffer can read, or write, or both. 811 * 812 * @c ios_base::out is automatically included in @a mode. 813 * 814 * Initializes @c sb using @c mode|out, and passes @c &sb to the base 815 * class initializer. Does not allocate any buffer. 816 * 817 * That's a lie. We initialize the base class with NULL, because the 818 * string class does its own memory management. 819 */ 820 explicit 821 basic_ostringstream(ios_base::openmode __mode) 822 : __ostream_type(), _M_stringbuf(__mode | ios_base::out) 823 { this->init(&_M_stringbuf); } 824 825 /** 826 * @brief Starts with an existing string buffer. 827 * @param __str A string to copy as a starting buffer. 828 * @param __mode Whether the buffer can read, or write, or both. 829 * 830 * @c ios_base::out is automatically included in @a mode. 831 * 832 * Initializes @c sb using @a str and @c mode|out, and passes @c &sb 833 * to the base class initializer. 834 * 835 * That's a lie. We initialize the base class with NULL, because the 836 * string class does its own memory management. 837 */ 838 explicit 839 basic_ostringstream(const __string_type& __str, 840 ios_base::openmode __mode = ios_base::out) 841 : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out) 842 { this->init(&_M_stringbuf); } 843 844 /** 845 * @brief The destructor does nothing. 846 * 847 * The buffer is deallocated by the stringbuf object, not the 848 * formatting stream. 849 */ 850 ~basic_ostringstream() 851 { } 852 853 #if __cplusplus >= 201103L 854 basic_ostringstream(const basic_ostringstream&) = delete; 855 856 basic_ostringstream(basic_ostringstream&& __rhs) 857 : __ostream_type(std::move(__rhs)), 858 _M_stringbuf(std::move(__rhs._M_stringbuf)) 859 { __ostream_type::set_rdbuf(&_M_stringbuf); } 860 861 #if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI 862 basic_ostringstream(ios_base::openmode __mode, const allocator_type& __a) 863 : __ostream_type(), _M_stringbuf(__mode | ios_base::out, __a) 864 { this->init(std::__addressof(_M_stringbuf)); } 865 866 explicit 867 basic_ostringstream(__string_type&& __str, 868 ios_base::openmode __mode = ios_base::out) 869 : __ostream_type(), _M_stringbuf(std::move(__str), __mode | ios_base::out) 870 { this->init(std::__addressof(_M_stringbuf)); } 871 872 template<typename _SAlloc> 873 basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str, 874 const allocator_type& __a) 875 : basic_ostringstream(__str, ios_base::out, __a) 876 { } 877 878 template<typename _SAlloc> 879 basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str, 880 ios_base::openmode __mode, 881 const allocator_type& __a) 882 : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out, __a) 883 { this->init(std::__addressof(_M_stringbuf)); } 884 885 template<typename _SAlloc> 886 explicit 887 basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str, 888 ios_base::openmode __mode = ios_base::out) 889 : basic_ostringstream(__str, __mode, allocator_type()) 890 { } 891 #endif // C++20 892 893 // 27.8.3.2 Assign and swap: 894 895 basic_ostringstream& 896 operator=(const basic_ostringstream&) = delete; 897 898 basic_ostringstream& 899 operator=(basic_ostringstream&& __rhs) 900 { 901 __ostream_type::operator=(std::move(__rhs)); 902 _M_stringbuf = std::move(__rhs._M_stringbuf); 903 return *this; 904 } 905 906 void 907 swap(basic_ostringstream& __rhs) 908 { 909 __ostream_type::swap(__rhs); 910 _M_stringbuf.swap(__rhs._M_stringbuf); 911 } 912 #endif // C++11 913 914 // Members: 915 /** 916 * @brief Accessing the underlying buffer. 917 * @return The current basic_stringbuf buffer. 918 * 919 * This hides both signatures of std::basic_ios::rdbuf(). 920 */ 921 __stringbuf_type* 922 rdbuf() const 923 { return const_cast<__stringbuf_type*>(&_M_stringbuf); } 924 925 /** 926 * @brief Copying out the string buffer. 927 * @return @c rdbuf()->str() 928 */ 929 __string_type 930 str() const _GLIBCXX_LVAL_REF_QUAL 931 { return _M_stringbuf.str(); } 932 933 #if __cplusplus > 201703L 934 #if _GLIBCXX_USE_CXX11_ABI 935 #if __cpp_concepts 936 template<__allocator_like _SAlloc> 937 basic_string<_CharT, _Traits, _SAlloc> 938 str(const _SAlloc& __sa) const 939 { return _M_stringbuf.str(__sa); } 940 #endif 941 942 __string_type 943 str() && 944 { return std::move(_M_stringbuf).str(); } 945 #endif // cxx11 ABI 946 947 _GLIBCXX_SSTREAM_ALWAYS_INLINE 948 basic_string_view<char_type, traits_type> 949 view() const noexcept 950 { return _M_stringbuf.view(); } 951 #endif // C++20 952 953 /** 954 * @brief Setting a new buffer. 955 * @param __s The string to use as a new sequence. 956 * 957 * Calls @c rdbuf()->str(s). 958 */ 959 void 960 str(const __string_type& __s) 961 { _M_stringbuf.str(__s); } 962 963 #if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI 964 #if __cpp_concepts 965 template<__allocator_like _SAlloc> 966 requires (!is_same_v<_SAlloc, _Alloc>) 967 void 968 str(const basic_string<_CharT, _Traits, _SAlloc>& __s) 969 { _M_stringbuf.str(__s); } 970 #endif 971 972 void 973 str(__string_type&& __s) 974 { _M_stringbuf.str(std::move(__s)); } 975 #endif 976 }; 977 978 979 // [27.7.4] Template class basic_stringstream 980 /** 981 * @brief Controlling input and output for std::string. 982 * @ingroup io 983 * 984 * @tparam _CharT Type of character stream. 985 * @tparam _Traits Traits for character type, defaults to 986 * char_traits<_CharT>. 987 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. 988 * 989 * This class supports reading from and writing to objects of type 990 * std::basic_string, using the inherited functions from 991 * std::basic_iostream. To control the associated sequence, an instance 992 * of std::basic_stringbuf is used, which this page refers to as @c sb. 993 */ 994 template <typename _CharT, typename _Traits, typename _Alloc> 995 class basic_stringstream : public basic_iostream<_CharT, _Traits> 996 { 997 public: 998 // Types: 999 typedef _CharT char_type; 1000 typedef _Traits traits_type; 1001 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1002 // 251. basic_stringbuf missing allocator_type 1003 typedef _Alloc allocator_type; 1004 typedef typename traits_type::int_type int_type; 1005 typedef typename traits_type::pos_type pos_type; 1006 typedef typename traits_type::off_type off_type; 1007 1008 // Non-standard Types: 1009 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 1010 typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; 1011 typedef basic_iostream<char_type, traits_type> __iostream_type; 1012 1013 private: 1014 __stringbuf_type _M_stringbuf; 1015 1016 public: 1017 // Constructors/destructors 1018 1019 /** 1020 * @brief Default constructor starts with an empty string buffer. 1021 * 1022 * Initializes @c sb using the mode @c in|out, and passes @c &sb 1023 * to the base class initializer. Does not allocate any buffer. 1024 * 1025 * That's a lie. We initialize the base class with NULL, because the 1026 * string class does its own memory management. 1027 */ 1028 basic_stringstream() 1029 : __iostream_type(), _M_stringbuf(ios_base::out | ios_base::in) 1030 { this->init(&_M_stringbuf); } 1031 1032 /** 1033 * @brief Starts with an empty string buffer. 1034 * @param __m Whether the buffer can read, or write, or both. 1035 * 1036 * Initializes @c sb using the mode from @c __m, and passes @c &sb 1037 * to the base class initializer. Does not allocate any buffer. 1038 * 1039 * That's a lie. We initialize the base class with NULL, because the 1040 * string class does its own memory management. 1041 */ 1042 explicit 1043 basic_stringstream(ios_base::openmode __m) 1044 : __iostream_type(), _M_stringbuf(__m) 1045 { this->init(&_M_stringbuf); } 1046 1047 /** 1048 * @brief Starts with an existing string buffer. 1049 * @param __str A string to copy as a starting buffer. 1050 * @param __m Whether the buffer can read, or write, or both. 1051 * 1052 * Initializes @c sb using @a __str and @c __m, and passes @c &sb 1053 * to the base class initializer. 1054 * 1055 * That's a lie. We initialize the base class with NULL, because the 1056 * string class does its own memory management. 1057 */ 1058 explicit 1059 basic_stringstream(const __string_type& __str, 1060 ios_base::openmode __m = ios_base::out | ios_base::in) 1061 : __iostream_type(), _M_stringbuf(__str, __m) 1062 { this->init(&_M_stringbuf); } 1063 1064 /** 1065 * @brief The destructor does nothing. 1066 * 1067 * The buffer is deallocated by the stringbuf object, not the 1068 * formatting stream. 1069 */ 1070 ~basic_stringstream() 1071 { } 1072 1073 #if __cplusplus >= 201103L 1074 basic_stringstream(const basic_stringstream&) = delete; 1075 1076 basic_stringstream(basic_stringstream&& __rhs) 1077 : __iostream_type(std::move(__rhs)), 1078 _M_stringbuf(std::move(__rhs._M_stringbuf)) 1079 { __iostream_type::set_rdbuf(&_M_stringbuf); } 1080 1081 #if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI 1082 basic_stringstream(ios_base::openmode __mode, const allocator_type& __a) 1083 : __iostream_type(), _M_stringbuf(__mode, __a) 1084 { this->init(&_M_stringbuf); } 1085 1086 explicit 1087 basic_stringstream(__string_type&& __str, 1088 ios_base::openmode __mode = ios_base::in 1089 | ios_base::out) 1090 : __iostream_type(), _M_stringbuf(std::move(__str), __mode) 1091 { this->init(std::__addressof(_M_stringbuf)); } 1092 1093 template<typename _SAlloc> 1094 basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str, 1095 const allocator_type& __a) 1096 : basic_stringstream(__str, ios_base::in | ios_base::out, __a) 1097 { } 1098 1099 template<typename _SAlloc> 1100 basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str, 1101 ios_base::openmode __mode, 1102 const allocator_type& __a) 1103 : __iostream_type(), _M_stringbuf(__str, __mode, __a) 1104 { this->init(std::__addressof(_M_stringbuf)); } 1105 1106 template<typename _SAlloc> 1107 explicit 1108 basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str, 1109 ios_base::openmode __mode = ios_base::in 1110 | ios_base::out) 1111 : basic_stringstream(__str, __mode, allocator_type()) 1112 { } 1113 #endif // C++20 1114 1115 // 27.8.3.2 Assign and swap: 1116 1117 basic_stringstream& 1118 operator=(const basic_stringstream&) = delete; 1119 1120 basic_stringstream& 1121 operator=(basic_stringstream&& __rhs) 1122 { 1123 __iostream_type::operator=(std::move(__rhs)); 1124 _M_stringbuf = std::move(__rhs._M_stringbuf); 1125 return *this; 1126 } 1127 1128 void 1129 swap(basic_stringstream& __rhs) 1130 { 1131 __iostream_type::swap(__rhs); 1132 _M_stringbuf.swap(__rhs._M_stringbuf); 1133 } 1134 #endif // C++11 1135 1136 // Members: 1137 /** 1138 * @brief Accessing the underlying buffer. 1139 * @return The current basic_stringbuf buffer. 1140 * 1141 * This hides both signatures of std::basic_ios::rdbuf(). 1142 */ 1143 __stringbuf_type* 1144 rdbuf() const 1145 { return const_cast<__stringbuf_type*>(&_M_stringbuf); } 1146 1147 /** 1148 * @brief Copying out the string buffer. 1149 * @return @c rdbuf()->str() 1150 */ 1151 __string_type 1152 str() const _GLIBCXX_LVAL_REF_QUAL 1153 { return _M_stringbuf.str(); } 1154 1155 #if __cplusplus > 201703L 1156 #if _GLIBCXX_USE_CXX11_ABI 1157 #if __cpp_concepts 1158 template<__allocator_like _SAlloc> 1159 basic_string<_CharT, _Traits, _SAlloc> 1160 str(const _SAlloc& __sa) const 1161 { return _M_stringbuf.str(__sa); } 1162 #endif 1163 1164 __string_type 1165 str() && 1166 { return std::move(_M_stringbuf).str(); } 1167 #endif // cxx11 ABI 1168 1169 _GLIBCXX_SSTREAM_ALWAYS_INLINE 1170 basic_string_view<char_type, traits_type> 1171 view() const noexcept 1172 { return _M_stringbuf.view(); } 1173 #endif // C++20 1174 1175 /** 1176 * @brief Setting a new buffer. 1177 * @param __s The string to use as a new sequence. 1178 * 1179 * Calls @c rdbuf()->str(s). 1180 */ 1181 void 1182 str(const __string_type& __s) 1183 { _M_stringbuf.str(__s); } 1184 1185 #if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI 1186 #if __cpp_concepts 1187 template<__allocator_like _SAlloc> 1188 requires (!is_same_v<_SAlloc, _Alloc>) 1189 void 1190 str(const basic_string<_CharT, _Traits, _SAlloc>& __s) 1191 { _M_stringbuf.str(__s); } 1192 #endif 1193 1194 void 1195 str(__string_type&& __s) 1196 { _M_stringbuf.str(std::move(__s)); } 1197 #endif 1198 }; 1199 1200 #if __cplusplus >= 201103L 1201 /// Swap specialization for stringbufs. 1202 template <class _CharT, class _Traits, class _Allocator> 1203 inline void 1204 swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x, 1205 basic_stringbuf<_CharT, _Traits, _Allocator>& __y) 1206 noexcept(noexcept(__x.swap(__y))) 1207 { __x.swap(__y); } 1208 1209 /// Swap specialization for istringstreams. 1210 template <class _CharT, class _Traits, class _Allocator> 1211 inline void 1212 swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x, 1213 basic_istringstream<_CharT, _Traits, _Allocator>& __y) 1214 { __x.swap(__y); } 1215 1216 /// Swap specialization for ostringstreams. 1217 template <class _CharT, class _Traits, class _Allocator> 1218 inline void 1219 swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x, 1220 basic_ostringstream<_CharT, _Traits, _Allocator>& __y) 1221 { __x.swap(__y); } 1222 1223 /// Swap specialization for stringstreams. 1224 template <class _CharT, class _Traits, class _Allocator> 1225 inline void 1226 swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x, 1227 basic_stringstream<_CharT, _Traits, _Allocator>& __y) 1228 { __x.swap(__y); } 1229 #endif // C++11 1230 1231 _GLIBCXX_END_NAMESPACE_CXX11 1232 _GLIBCXX_END_NAMESPACE_VERSION 1233 } // namespace 1234 1235 #undef _GLIBCXX_SSTREAM_ALWAYS_INLINE 1236 #undef _GLIBCXX_LVAL_REF_QUAL 1237 1238 #include <bits/sstream.tcc> 1239 1240 #endif /* _GLIBCXX_SSTREAM */ 1241
Indexes created Thu Apr 23 00:23:13 UTC 2026