LCOV - code coverage report
Current view: directory - tools/gcc-4.5/include/c++/4.5.2 - sstream (source / functions) Found Hit Coverage
Test: app.info Lines: 64 0 0.0 %
Date: 2012-06-02 Functions: 25 0 0.0 %

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

Generated by: LCOV version 1.7