LTP GCOV extension - code coverage report
Current view: | directory - usr/include/c++/4.3 - sstream
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 43
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,
           4                 : // 2006, 2008 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
          18                 : // along with this library; see the file COPYING.  If not, write to
          19                 : // the Free Software Foundation, 51 Franklin Street, Fifth Floor,
          20                 : // Boston, MA 02110-1301, 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                 : /** @file sstream
          32                 :  *  This is a Standard C++ Library header.
          33                 :  */
          34                 :
          35                 : //
          36                 : // ISO C++ 14882: 27.7  String-based streams
          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                 : _GLIBCXX_BEGIN_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                 :       /// Place to stash in || out || in | out settings for current stringbuf.
          81                 :       ios_base::openmode        _M_mode;
          82                 :
          83                 :       // Data Members:
          84                 :       __string_type             _M_string;
          85                 :
          86                 :     public:
          87                 :       // Constructors:
          88                 :       /**
          89                 :        *  @brief  Starts with an empty string buffer.
          90                 :        *  @param  mode  Whether the buffer can read, or write, or both.
          91                 :        *
          92                 :        *  The default constructor initializes the parent class using its
          93                 :        *  own default ctor.
          94                 :       */
          95                 :       explicit
          96               0 :       basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
          97               0 :       : __streambuf_type(), _M_mode(__mode), _M_string()
          98               0 :       { }
          99                 :
         100                 :       /**
         101                 :        *  @brief  Starts with an existing string buffer.
         102                 :        *  @param  str  A string to copy as a starting buffer.
         103                 :        *  @param  mode  Whether the buffer can read, or write, or both.
         104                 :        *
         105                 :        *  This constructor initializes the parent class using its
         106                 :        *  own default ctor.
         107                 :       */
         108                 :       explicit
         109                 :       basic_stringbuf(const __string_type& __str,
         110               0 :                       ios_base::openmode __mode = ios_base::in | ios_base::out)
         111               0 :       : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
         112               0 :       { _M_stringbuf_init(__mode); }
         113                 :
         114                 :       // Get and set:
         115                 :       /**
         116                 :        *  @brief  Copying out the string buffer.
         117                 :        *  @return  A copy of one of the underlying sequences.
         118                 :        *
         119                 :        *  "If the buffer is only created in input mode, the underlying
         120                 :        *  character sequence is equal to the input sequence; otherwise, it
         121                 :        *  is equal to the output sequence." [27.7.1.2]/1
         122                 :       */
         123                 :       __string_type
         124               0 :       str() const
         125                 :       {
         126               0 :         __string_type __ret;
         127               0 :         if (this->pptr())
         128                 :           {
         129                 :             // The current egptr() may not be the actual string end.
         130               0 :             if (this->pptr() > this->egptr())
         131               0 :               __ret = __string_type(this->pbase(), this->pptr());
         132                 :             else
         133               0 :               __ret = __string_type(this->pbase(), this->egptr());
         134                 :           }
         135                 :         else
         136               0 :           __ret = _M_string;
         137               0 :         return __ret;
         138                 :       }
         139                 :
         140                 :       /**
         141                 :        *  @brief  Setting a new buffer.
         142                 :        *  @param  s  The string to use as a new sequence.
         143                 :        *
         144                 :        *  Deallocates any previous stored sequence, then copies @a s to
         145                 :        *  use as a new one.
         146                 :       */
         147                 :       void
         148                 :       str(const __string_type& __s)
         149                 :       {
         150                 :         // Cannot use _M_string = __s, since v3 strings are COW.
         151                 :         _M_string.assign(__s.data(), __s.size());
         152                 :         _M_stringbuf_init(_M_mode);
         153                 :       }
         154                 :
         155                 :     protected:
         156                 :       // Common initialization code goes here.
         157                 :       void
         158               0 :       _M_stringbuf_init(ios_base::openmode __mode)
         159                 :       {
         160               0 :         _M_mode = __mode;
         161               0 :         __size_type __len = 0;
         162               0 :         if (_M_mode & (ios_base::ate | ios_base::app))
         163               0 :           __len = _M_string.size();
         164               0 :         _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
         165               0 :       }
         166                 :
         167                 :       virtual streamsize
         168                 :       showmanyc()
         169                 :       {
         170                 :         streamsize __ret = -1;
         171                 :         if (_M_mode & ios_base::in)
         172                 :           {
         173                 :             _M_update_egptr();
         174                 :             __ret = this->egptr() - this->gptr();
         175                 :           }
         176                 :         return __ret;
         177                 :       }
         178                 :
         179                 :       virtual int_type
         180                 :       underflow();
         181                 :
         182                 :       virtual int_type
         183                 :       pbackfail(int_type __c = traits_type::eof());
         184                 :
         185                 :       virtual int_type
         186                 :       overflow(int_type __c = traits_type::eof());
         187                 :
         188                 :       /**
         189                 :        *  @brief  Manipulates the buffer.
         190                 :        *  @param  s  Pointer to a buffer area.
         191                 :        *  @param  n  Size of @a s.
         192                 :        *  @return  @c this
         193                 :        *
         194                 :        *  If no buffer has already been created, and both @a s and @a n are
         195                 :        *  non-zero, then @c s is used as a buffer; see
         196                 :        *  http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2
         197                 :        *  for more.
         198                 :       */
         199                 :       virtual __streambuf_type*
         200                 :       setbuf(char_type* __s, streamsize __n)
         201                 :       {
         202                 :         if (__s && __n >= 0)
         203                 :           {
         204                 :             // This is implementation-defined behavior, and assumes
         205                 :             // that an external char_type array of length __n exists
         206                 :             // and has been pre-allocated. If this is not the case,
         207                 :             // things will quickly blow up.
         208                 :
         209                 :             // Step 1: Destroy the current internal array.
         210                 :             _M_string.clear();
         211                 :
         212                 :             // Step 2: Use the external array.
         213                 :             _M_sync(__s, __n, 0);
         214                 :           }
         215                 :         return this;
         216                 :       }
         217                 :
         218                 :       virtual pos_type
         219                 :       seekoff(off_type __off, ios_base::seekdir __way,
         220                 :               ios_base::openmode __mode = ios_base::in | ios_base::out);
         221                 :
         222                 :       virtual pos_type
         223                 :       seekpos(pos_type __sp,
         224                 :               ios_base::openmode __mode = ios_base::in | ios_base::out);
         225                 :
         226                 :       // Internal function for correctly updating the internal buffer
         227                 :       // for a particular _M_string, due to initialization or re-sizing
         228                 :       // of an existing _M_string.
         229                 :       void
         230                 :       _M_sync(char_type* __base, __size_type __i, __size_type __o);
         231                 :
         232                 :       // Internal function for correctly updating egptr() to the actual
         233                 :       // string end.
         234                 :       void
         235                 :       _M_update_egptr()
         236                 :       {
         237                 :         const bool __testin = _M_mode & ios_base::in;
         238                 :         if (this->pptr() && this->pptr() > this->egptr())
         239                 :           if (__testin)
         240                 :             this->setg(this->eback(), this->gptr(), this->pptr());
         241                 :           else
         242                 :             this->setg(this->pptr(), this->pptr(), this->pptr());
         243                 :       }
         244                 :     };
         245                 :
         246                 :
         247                 :   // [27.7.2] Template class basic_istringstream
         248                 :   /**
         249                 :    *  @brief  Controlling input for std::string.
         250                 :    *
         251                 :    *  This class supports reading from objects of type std::basic_string,
         252                 :    *  using the inherited functions from std::basic_istream.  To control
         253                 :    *  the associated sequence, an instance of std::basic_stringbuf is used,
         254                 :    *  which this page refers to as @c sb.
         255                 :   */
         256                 :   template<typename _CharT, typename _Traits, typename _Alloc>
         257                 :     class basic_istringstream : public basic_istream<_CharT, _Traits>
         258                 :     {
         259                 :     public:
         260                 :       // Types:
         261                 :       typedef _CharT                                    char_type;
         262                 :       typedef _Traits                                   traits_type;
         263                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
         264                 :       // 251. basic_stringbuf missing allocator_type
         265                 :       typedef _Alloc                                    allocator_type;
         266                 :       typedef typename traits_type::int_type            int_type;
         267                 :       typedef typename traits_type::pos_type            pos_type;
         268                 :       typedef typename traits_type::off_type            off_type;
         269                 :
         270                 :       // Non-standard types:
         271                 :       typedef basic_string<_CharT, _Traits, _Alloc>       __string_type;
         272                 :       typedef basic_stringbuf<_CharT, _Traits, _Alloc>    __stringbuf_type;
         273                 :       typedef basic_istream<char_type, traits_type>       __istream_type;
         274                 :
         275                 :     private:
         276                 :       __stringbuf_type  _M_stringbuf;
         277                 :
         278                 :     public:
         279                 :       // Constructors:
         280                 :       /**
         281                 :        *  @brief  Default constructor starts with an empty string buffer.
         282                 :        *  @param  mode  Whether the buffer can read, or write, or both.
         283                 :        *
         284                 :        *  @c ios_base::in is automatically included in @a mode.
         285                 :        *
         286                 :        *  Initializes @c sb using @c mode|in, and passes @c &sb to the base
         287                 :        *  class initializer.  Does not allocate any buffer.
         288                 :        *
         289                 :        *  That's a lie.  We initialize the base class with NULL, because the
         290                 :        *  string class does its own memory management.
         291                 :       */
         292                 :       explicit
         293                 :       basic_istringstream(ios_base::openmode __mode = ios_base::in)
         294                 :       : __istream_type(), _M_stringbuf(__mode | ios_base::in)
         295                 :       { this->init(&_M_stringbuf); }
         296                 :
         297                 :       /**
         298                 :        *  @brief  Starts with an existing string buffer.
         299                 :        *  @param  str  A string to copy as a starting buffer.
         300                 :        *  @param  mode  Whether the buffer can read, or write, or both.
         301                 :        *
         302                 :        *  @c ios_base::in is automatically included in @a mode.
         303                 :        *
         304                 :        *  Initializes @c sb using @a str and @c mode|in, and passes @c &sb
         305                 :        *  to the base class initializer.
         306                 :        *
         307                 :        *  That's a lie.  We initialize the base class with NULL, because the
         308                 :        *  string class does its own memory management.
         309                 :       */
         310                 :       explicit
         311                 :       basic_istringstream(const __string_type& __str,
         312               0 :                           ios_base::openmode __mode = ios_base::in)
         313               0 :       : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
         314               0 :       { this->init(&_M_stringbuf); }
         315                 :
         316                 :       /**
         317                 :        *  @brief  The destructor does nothing.
         318                 :        *
         319                 :        *  The buffer is deallocated by the stringbuf object, not the
         320                 :        *  formatting stream.
         321                 :       */
         322               0 :       ~basic_istringstream()
         323               0 :       { }
         324                 :
         325                 :       // Members:
         326                 :       /**
         327                 :        *  @brief  Accessing the underlying buffer.
         328                 :        *  @return  The current basic_stringbuf buffer.
         329                 :        *
         330                 :        *  This hides both signatures of std::basic_ios::rdbuf().
         331                 :       */
         332                 :       __stringbuf_type*
         333                 :       rdbuf() const
         334                 :       { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
         335                 :
         336                 :       /**
         337                 :        *  @brief  Copying out the string buffer.
         338                 :        *  @return  @c rdbuf()->str()
         339                 :       */
         340                 :       __string_type
         341                 :       str() const
         342                 :       { return _M_stringbuf.str(); }
         343                 :
         344                 :       /**
         345                 :        *  @brief  Setting a new buffer.
         346                 :        *  @param  s  The string to use as a new sequence.
         347                 :        *
         348                 :        *  Calls @c rdbuf()->str(s).
         349                 :       */
         350                 :       void
         351                 :       str(const __string_type& __s)
         352                 :       { _M_stringbuf.str(__s); }
         353                 :     };
         354                 :
         355                 :
         356                 :   // [27.7.3] Template class basic_ostringstream
         357                 :   /**
         358                 :    *  @brief  Controlling output for std::string.
         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                 :       str(const __string_type& __s)
         461                 :       { _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                 :    *
         469                 :    *  This class supports reading from and writing to objects of type
         470                 :    *  std::basic_string, using the inherited functions from
         471                 :    *  std::basic_iostream.  To control the associated sequence, an instance
         472                 :    *  of std::basic_stringbuf is used, which this page refers to as @c sb.
         473                 :   */
         474                 :   template <typename _CharT, typename _Traits, typename _Alloc>
         475                 :     class basic_stringstream : public basic_iostream<_CharT, _Traits>
         476                 :     {
         477                 :     public:
         478                 :       // Types:
         479                 :       typedef _CharT                                    char_type;
         480                 :       typedef _Traits                                   traits_type;
         481                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
         482                 :       // 251. basic_stringbuf missing allocator_type
         483                 :       typedef _Alloc                                    allocator_type;
         484                 :       typedef typename traits_type::int_type            int_type;
         485                 :       typedef typename traits_type::pos_type            pos_type;
         486                 :       typedef typename traits_type::off_type            off_type;
         487                 :
         488                 :       // Non-standard Types:
         489                 :       typedef basic_string<_CharT, _Traits, _Alloc>       __string_type;
         490                 :       typedef basic_stringbuf<_CharT, _Traits, _Alloc>    __stringbuf_type;
         491                 :       typedef basic_iostream<char_type, traits_type>      __iostream_type;
         492                 :
         493                 :     private:
         494                 :       __stringbuf_type  _M_stringbuf;
         495                 :
         496                 :     public:
         497                 :       // Constructors/destructors
         498                 :       /**
         499                 :        *  @brief  Default constructor starts with an empty string buffer.
         500                 :        *  @param  mode  Whether the buffer can read, or write, or both.
         501                 :        *
         502                 :        *  Initializes @c sb using @c mode, and passes @c &sb to the base
         503                 :        *  class initializer.  Does not allocate any buffer.
         504                 :        *
         505                 :        *  That's a lie.  We initialize the base class with NULL, because the
         506                 :        *  string class does its own memory management.
         507                 :       */
         508                 :       explicit
         509               0 :       basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
         510               0 :       : __iostream_type(), _M_stringbuf(__m)
         511               0 :       { this->init(&_M_stringbuf); }
         512                 :
         513                 :       /**
         514                 :        *  @brief  Starts with an existing string buffer.
         515                 :        *  @param  str  A string to copy as a starting buffer.
         516                 :        *  @param  mode  Whether the buffer can read, or write, or both.
         517                 :        *
         518                 :        *  Initializes @c sb using @a str and @c mode, and passes @c &sb
         519                 :        *  to the base class initializer.
         520                 :        *
         521                 :        *  That's a lie.  We initialize the base class with NULL, because the
         522                 :        *  string class does its own memory management.
         523                 :       */
         524                 :       explicit
         525                 :       basic_stringstream(const __string_type& __str,
         526               0 :                          ios_base::openmode __m = ios_base::out | ios_base::in)
         527               0 :       : __iostream_type(), _M_stringbuf(__str, __m)
         528               0 :       { this->init(&_M_stringbuf); }
         529                 :
         530                 :       /**
         531                 :        *  @brief  The destructor does nothing.
         532                 :        *
         533                 :        *  The buffer is deallocated by the stringbuf object, not the
         534                 :        *  formatting stream.
         535                 :       */
         536               0 :       ~basic_stringstream()
         537               0 :       { }
         538                 :
         539                 :       // Members:
         540                 :       /**
         541                 :        *  @brief  Accessing the underlying buffer.
         542                 :        *  @return  The current basic_stringbuf buffer.
         543                 :        *
         544                 :        *  This hides both signatures of std::basic_ios::rdbuf().
         545                 :       */
         546                 :       __stringbuf_type*
         547                 :       rdbuf() const
         548                 :       { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
         549                 :
         550                 :       /**
         551                 :        *  @brief  Copying out the string buffer.
         552                 :        *  @return  @c rdbuf()->str()
         553                 :       */
         554                 :       __string_type
         555               0 :       str() const
         556               0 :       { return _M_stringbuf.str(); }
         557                 :
         558                 :       /**
         559                 :        *  @brief  Setting a new buffer.
         560                 :        *  @param  s  The string to use as a new sequence.
         561                 :        *
         562                 :        *  Calls @c rdbuf()->str(s).
         563                 :       */
         564                 :       void
         565                 :       str(const __string_type& __s)
         566                 :       { _M_stringbuf.str(__s); }
         567                 :     };
         568                 :
         569                 : _GLIBCXX_END_NAMESPACE
         570                 :
         571                 : #ifndef _GLIBCXX_EXPORT_TEMPLATE
         572                 : # include <bits/sstream.tcc>
         573                 : #endif
         574                 :
         575                 : #endif /* _GLIBCXX_SSTREAM */

Generated by: LTP GCOV extension version 1.6