LTP GCOV extension - code coverage report
Current view: directory - usr/include/c++/4.1.2 - sstream
Test: stap.info
Date: 2008-03-12 Instrumented lines: 39
Code covered: 0.0 % Executed lines: 0

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

Generated by: LTP GCOV extension version 1.5