libstdc++-v3/include/std/sstream

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