wpkg test coverage results

Coverage test results of the Windows Packager by Made to Order Software Corporation.

LCOV - code coverage report
Current view: top level - usr/include/c++/4.8 - sstream (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 1 0.0 %
Date: 2014-07-27 Functions: 0 2 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.9

The wpkg tool is an open source tool created by Made to Order Software Corporation.