1// String based streams -*- C++ -*- 2 3// Copyright (C) 1997-2013 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 <istream> 39#include <ostream> 40 41namespace std _GLIBCXX_VISIBILITY(default) 42{ 43_GLIBCXX_BEGIN_NAMESPACE_VERSION 44 45 // [27.7.1] template class basic_stringbuf 46 /** 47 * @brief The actual work of input and output (for std::string). 48 * @ingroup io 49 * 50 * @tparam _CharT Type of character stream. 51 * @tparam _Traits Traits for character type, defaults to 52 * char_traits<_CharT>. 53 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. 54 * 55 * This class associates either or both of its input and output sequences 56 * with a sequence of characters, which can be initialized from, or made 57 * available as, a @c std::basic_string. (Paraphrased from [27.7.1]/1.) 58 * 59 * For this class, open modes (of type @c ios_base::openmode) have 60 * @c in set if the input sequence can be read, and @c out set if the 61 * output sequence can be written. 62 */ 63 template<typename _CharT, typename _Traits, typename _Alloc> 64 class basic_stringbuf : public basic_streambuf<_CharT, _Traits> 65 { 66 public: 67 // Types: 68 typedef _CharT char_type; 69 typedef _Traits traits_type; 70 // _GLIBCXX_RESOLVE_LIB_DEFECTS 71 // 251. basic_stringbuf missing allocator_type 72 typedef _Alloc allocator_type; 73 typedef typename traits_type::int_type int_type; 74 typedef typename traits_type::pos_type pos_type; 75 typedef typename traits_type::off_type off_type; 76 77 typedef basic_streambuf<char_type, traits_type> __streambuf_type; 78 typedef basic_string<char_type, _Traits, _Alloc> __string_type; 79 typedef typename __string_type::size_type __size_type; 80 81 protected: 82 /// Place to stash in || out || in | out settings for current stringbuf. 83 ios_base::openmode _M_mode; 84 85 // Data Members: 86 __string_type _M_string; 87 88 public: 89 // Constructors: 90 /** 91 * @brief Starts with an empty string buffer. 92 * @param __mode Whether the buffer can read, or write, or both. 93 * 94 * The default constructor initializes the parent class using its 95 * own default ctor. 96 */ 97 explicit 98 basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out) 99 : __streambuf_type(), _M_mode(__mode), _M_string() 100 { } 101 102 /** 103 * @brief Starts with an existing string buffer. 104 * @param __str A string to copy as a starting buffer. 105 * @param __mode Whether the buffer can read, or write, or both. 106 * 107 * This constructor initializes the parent class using its 108 * own default ctor. 109 */ 110 explicit 111 basic_stringbuf(const __string_type& __str, 112 ios_base::openmode __mode = ios_base::in | ios_base::out) 113 : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size()) 114 { _M_stringbuf_init(__mode); } 115 116 // Get and set: 117 /** 118 * @brief Copying out the string buffer. 119 * @return A copy of one of the underlying sequences. 120 * 121 * <em>If the buffer is only created in input mode, the underlying 122 * character sequence is equal to the input sequence; otherwise, it 123 * is equal to the output sequence.</em> [27.7.1.2]/1 124 */ 125 __string_type 126 str() const 127 { 128 __string_type __ret; 129 if (this->pptr()) 130 { 131 // The current egptr() may not be the actual string end. 132 if (this->pptr() > this->egptr()) 133 __ret = __string_type(this->pbase(), this->pptr()); 134 else 135 __ret = __string_type(this->pbase(), this->egptr()); 136 } 137 else 138 __ret = _M_string; 139 return __ret; 140 } 141 142 /** 143 * @brief Setting a new buffer. 144 * @param __s The string to use as a new sequence. 145 * 146 * Deallocates any previous stored sequence, then copies @a s to 147 * use as a new one. 148 */ 149 void 150 str(const __string_type& __s) 151 { 152 // Cannot use _M_string = __s, since v3 strings are COW. 153 _M_string.assign(__s.data(), __s.size()); 154 _M_stringbuf_init(_M_mode); 155 } 156 157 protected: 158 // Common initialization code goes here. 159 void 160 _M_stringbuf_init(ios_base::openmode __mode) 161 { 162 _M_mode = __mode; 163 __size_type __len = 0; 164 if (_M_mode & (ios_base::ate | ios_base::app)) 165 __len = _M_string.size(); 166 _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len); 167 } 168 169 virtual streamsize 170 showmanyc() 171 { 172 streamsize __ret = -1; 173 if (_M_mode & ios_base::in) 174 { 175 _M_update_egptr(); 176 __ret = this->egptr() - this->gptr(); 177 } 178 return __ret; 179 } 180 181 virtual int_type 182 underflow(); 183 184 virtual int_type 185 pbackfail(int_type __c = traits_type::eof()); 186 187 virtual int_type 188 overflow(int_type __c = traits_type::eof()); 189 190 /** 191 * @brief Manipulates the buffer. 192 * @param __s Pointer to a buffer area. 193 * @param __n Size of @a __s. 194 * @return @c this 195 * 196 * If no buffer has already been created, and both @a __s and @a __n are 197 * non-zero, then @c __s is used as a buffer; see 198 * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html 199 * for more. 200 */ 201 virtual __streambuf_type* 202 setbuf(char_type* __s, streamsize __n) 203 { 204 if (__s && __n >= 0) 205 { 206 // This is implementation-defined behavior, and assumes 207 // that an external char_type array of length __n exists 208 // and has been pre-allocated. If this is not the case, 209 // things will quickly blow up. 210 211 // Step 1: Destroy the current internal array. 212 _M_string.clear(); 213 214 // Step 2: Use the external array. 215 _M_sync(__s, __n, 0); 216 } 217 return this; 218 } 219 220 virtual pos_type 221 seekoff(off_type __off, ios_base::seekdir __way, 222 ios_base::openmode __mode = ios_base::in | ios_base::out); 223 224 virtual pos_type 225 seekpos(pos_type __sp, 226 ios_base::openmode __mode = ios_base::in | ios_base::out); 227 228 // Internal function for correctly updating the internal buffer 229 // for a particular _M_string, due to initialization or re-sizing 230 // of an existing _M_string. 231 void 232 _M_sync(char_type* __base, __size_type __i, __size_type __o); 233 234 // Internal function for correctly updating egptr() to the actual 235 // string end. 236 void 237 _M_update_egptr() 238 { 239 const bool __testin = _M_mode & ios_base::in; 240 if (this->pptr() && this->pptr() > this->egptr()) 241 { 242 if (__testin) 243 this->setg(this->eback(), this->gptr(), this->pptr()); 244 else 245 this->setg(this->pptr(), this->pptr(), this->pptr()); 246 } 247 } 248 249 // Works around the issue with pbump, part of the protected 250 // interface of basic_streambuf, taking just an int. 251 void 252 _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off); 253 }; 254 255 256 // [27.7.2] Template class basic_istringstream 257 /** 258 * @brief Controlling input for std::string. 259 * @ingroup io 260 * 261 * @tparam _CharT Type of character stream. 262 * @tparam _Traits Traits for character type, defaults to 263 * char_traits<_CharT>. 264 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. 265 * 266 * This class supports reading from objects of type std::basic_string, 267 * using the inherited functions from std::basic_istream. To control 268 * the associated sequence, an instance of std::basic_stringbuf is used, 269 * which this page refers to as @c sb. 270 */ 271 template<typename _CharT, typename _Traits, typename _Alloc> 272 class basic_istringstream : public basic_istream<_CharT, _Traits> 273 { 274 public: 275 // Types: 276 typedef _CharT char_type; 277 typedef _Traits traits_type; 278 // _GLIBCXX_RESOLVE_LIB_DEFECTS 279 // 251. basic_stringbuf missing allocator_type 280 typedef _Alloc allocator_type; 281 typedef typename traits_type::int_type int_type; 282 typedef typename traits_type::pos_type pos_type; 283 typedef typename traits_type::off_type off_type; 284 285 // Non-standard types: 286 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 287 typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; 288 typedef basic_istream<char_type, traits_type> __istream_type; 289 290 private: 291 __stringbuf_type _M_stringbuf; 292 293 public: 294 // Constructors: 295 /** 296 * @brief Default constructor starts with an empty string buffer. 297 * @param __mode Whether the buffer can read, or write, or both. 298 * 299 * @c ios_base::in is automatically included in @a __mode. 300 * 301 * Initializes @c sb using @c __mode|in, and passes @c &sb to the base 302 * class initializer. Does not allocate any buffer. 303 * 304 * That's a lie. We initialize the base class with NULL, because the 305 * string class does its own memory management. 306 */ 307 explicit 308 basic_istringstream(ios_base::openmode __mode = ios_base::in) 309 : __istream_type(), _M_stringbuf(__mode | ios_base::in) 310 { this->init(&_M_stringbuf); } 311 312 /** 313 * @brief Starts with an existing string buffer. 314 * @param __str A string to copy as a starting buffer. 315 * @param __mode Whether the buffer can read, or write, or both. 316 * 317 * @c ios_base::in is automatically included in @a mode. 318 * 319 * Initializes @c sb using @a str and @c mode|in, and passes @c &sb 320 * to the base class initializer. 321 * 322 * That's a lie. We initialize the base class with NULL, because the 323 * string class does its own memory management. 324 */ 325 explicit 326 basic_istringstream(const __string_type& __str, 327 ios_base::openmode __mode = ios_base::in) 328 : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in) 329 { this->init(&_M_stringbuf); } 330 331 /** 332 * @brief The destructor does nothing. 333 * 334 * The buffer is deallocated by the stringbuf object, not the 335 * formatting stream. 336 */ 337 ~basic_istringstream() 338 { } 339 340 // Members: 341 /** 342 * @brief Accessing the underlying buffer. 343 * @return The current basic_stringbuf buffer. 344 * 345 * This hides both signatures of std::basic_ios::rdbuf(). 346 */ 347 __stringbuf_type* 348 rdbuf() const 349 { return const_cast<__stringbuf_type*>(&_M_stringbuf); } 350 351 /** 352 * @brief Copying out the string buffer. 353 * @return @c rdbuf()->str() 354 */ 355 __string_type 356 str() const 357 { return _M_stringbuf.str(); } 358 359 /** 360 * @brief Setting a new buffer. 361 * @param __s The string to use as a new sequence. 362 * 363 * Calls @c rdbuf()->str(s). 364 */ 365 void 366 str(const __string_type& __s) 367 { _M_stringbuf.str(__s); } 368 }; 369 370 371 // [27.7.3] Template class basic_ostringstream 372 /** 373 * @brief Controlling output for std::string. 374 * @ingroup io 375 * 376 * @tparam _CharT Type of character stream. 377 * @tparam _Traits Traits for character type, defaults to 378 * char_traits<_CharT>. 379 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. 380 * 381 * This class supports writing to objects of type std::basic_string, 382 * using the inherited functions from std::basic_ostream. To control 383 * the associated sequence, an instance of std::basic_stringbuf is used, 384 * which this page refers to as @c sb. 385 */ 386 template <typename _CharT, typename _Traits, typename _Alloc> 387 class basic_ostringstream : public basic_ostream<_CharT, _Traits> 388 { 389 public: 390 // Types: 391 typedef _CharT char_type; 392 typedef _Traits traits_type; 393 // _GLIBCXX_RESOLVE_LIB_DEFECTS 394 // 251. basic_stringbuf missing allocator_type 395 typedef _Alloc allocator_type; 396 typedef typename traits_type::int_type int_type; 397 typedef typename traits_type::pos_type pos_type; 398 typedef typename traits_type::off_type off_type; 399 400 // Non-standard types: 401 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 402 typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; 403 typedef basic_ostream<char_type, traits_type> __ostream_type; 404 405 private: 406 __stringbuf_type _M_stringbuf; 407 408 public: 409 // Constructors/destructor: 410 /** 411 * @brief Default constructor starts with an empty string buffer. 412 * @param __mode Whether the buffer can read, or write, or both. 413 * 414 * @c ios_base::out is automatically included in @a mode. 415 * 416 * Initializes @c sb using @c mode|out, and passes @c &sb to the base 417 * class initializer. Does not allocate any buffer. 418 * 419 * That's a lie. We initialize the base class with NULL, because the 420 * string class does its own memory management. 421 */ 422 explicit 423 basic_ostringstream(ios_base::openmode __mode = ios_base::out) 424 : __ostream_type(), _M_stringbuf(__mode | ios_base::out) 425 { this->init(&_M_stringbuf); } 426 427 /** 428 * @brief Starts with an existing string buffer. 429 * @param __str A string to copy as a starting buffer. 430 * @param __mode Whether the buffer can read, or write, or both. 431 * 432 * @c ios_base::out is automatically included in @a mode. 433 * 434 * Initializes @c sb using @a str and @c mode|out, and passes @c &sb 435 * to the base class initializer. 436 * 437 * That's a lie. We initialize the base class with NULL, because the 438 * string class does its own memory management. 439 */ 440 explicit 441 basic_ostringstream(const __string_type& __str, 442 ios_base::openmode __mode = ios_base::out) 443 : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out) 444 { this->init(&_M_stringbuf); } 445 446 /** 447 * @brief The destructor does nothing. 448 * 449 * The buffer is deallocated by the stringbuf object, not the 450 * formatting stream. 451 */ 452 ~basic_ostringstream() 453 { } 454 455 // Members: 456 /** 457 * @brief Accessing the underlying buffer. 458 * @return The current basic_stringbuf buffer. 459 * 460 * This hides both signatures of std::basic_ios::rdbuf(). 461 */ 462 __stringbuf_type* 463 rdbuf() const 464 { return const_cast<__stringbuf_type*>(&_M_stringbuf); } 465 466 /** 467 * @brief Copying out the string buffer. 468 * @return @c rdbuf()->str() 469 */ 470 __string_type 471 str() const 472 { return _M_stringbuf.str(); } 473 474 /** 475 * @brief Setting a new buffer. 476 * @param __s The string to use as a new sequence. 477 * 478 * Calls @c rdbuf()->str(s). 479 */ 480 void 481 str(const __string_type& __s) 482 { _M_stringbuf.str(__s); } 483 }; 484 485 486 // [27.7.4] Template class basic_stringstream 487 /** 488 * @brief Controlling input and output for std::string. 489 * @ingroup io 490 * 491 * @tparam _CharT Type of character stream. 492 * @tparam _Traits Traits for character type, defaults to 493 * char_traits<_CharT>. 494 * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. 495 * 496 * This class supports reading from and writing to objects of type 497 * std::basic_string, using the inherited functions from 498 * std::basic_iostream. To control the associated sequence, an instance 499 * of std::basic_stringbuf is used, which this page refers to as @c sb. 500 */ 501 template <typename _CharT, typename _Traits, typename _Alloc> 502 class basic_stringstream : public basic_iostream<_CharT, _Traits> 503 { 504 public: 505 // Types: 506 typedef _CharT char_type; 507 typedef _Traits traits_type; 508 // _GLIBCXX_RESOLVE_LIB_DEFECTS 509 // 251. basic_stringbuf missing allocator_type 510 typedef _Alloc allocator_type; 511 typedef typename traits_type::int_type int_type; 512 typedef typename traits_type::pos_type pos_type; 513 typedef typename traits_type::off_type off_type; 514 515 // Non-standard Types: 516 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 517 typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; 518 typedef basic_iostream<char_type, traits_type> __iostream_type; 519 520 private: 521 __stringbuf_type _M_stringbuf; 522 523 public: 524 // Constructors/destructors 525 /** 526 * @brief Default constructor starts with an empty string buffer. 527 * @param __m Whether the buffer can read, or write, or both. 528 * 529 * Initializes @c sb using the mode from @c __m, and passes @c 530 * &sb to the base class initializer. Does not allocate any 531 * buffer. 532 * 533 * That's a lie. We initialize the base class with NULL, because the 534 * string class does its own memory management. 535 */ 536 explicit 537 basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in) 538 : __iostream_type(), _M_stringbuf(__m) 539 { this->init(&_M_stringbuf); } 540 541 /** 542 * @brief Starts with an existing string buffer. 543 * @param __str A string to copy as a starting buffer. 544 * @param __m Whether the buffer can read, or write, or both. 545 * 546 * Initializes @c sb using @a __str and @c __m, and passes @c &sb 547 * to the base class initializer. 548 * 549 * That's a lie. We initialize the base class with NULL, because the 550 * string class does its own memory management. 551 */ 552 explicit 553 basic_stringstream(const __string_type& __str, 554 ios_base::openmode __m = ios_base::out | ios_base::in) 555 : __iostream_type(), _M_stringbuf(__str, __m) 556 { this->init(&_M_stringbuf); } 557 558 /** 559 * @brief The destructor does nothing. 560 * 561 * The buffer is deallocated by the stringbuf object, not the 562 * formatting stream. 563 */ 564 ~basic_stringstream() 565 { } 566 567 // Members: 568 /** 569 * @brief Accessing the underlying buffer. 570 * @return The current basic_stringbuf buffer. 571 * 572 * This hides both signatures of std::basic_ios::rdbuf(). 573 */ 574 __stringbuf_type* 575 rdbuf() const 576 { return const_cast<__stringbuf_type*>(&_M_stringbuf); } 577 578 /** 579 * @brief Copying out the string buffer. 580 * @return @c rdbuf()->str() 581 */ 582 __string_type 583 str() const 584 { return _M_stringbuf.str(); } 585 586 /** 587 * @brief Setting a new buffer. 588 * @param __s The string to use as a new sequence. 589 * 590 * Calls @c rdbuf()->str(s). 591 */ 592 void 593 str(const __string_type& __s) 594 { _M_stringbuf.str(__s); } 595 }; 596 597_GLIBCXX_END_NAMESPACE_VERSION 598} // namespace 599 600#include <bits/sstream.tcc> 601 602#endif /* _GLIBCXX_SSTREAM */ 603