From fb21a4dfe2c81640379f64855509fb7613530887 Mon Sep 17 00:00:00 2001 From: Enrico Zini Date: Wed, 9 Sep 2015 22:43:35 +0200 Subject: Removed wrongly added coverage report --- rep/usr/include/c++/4.3/sstream.gcov.html | 642 ------------------------------ 1 file changed, 642 deletions(-) delete mode 100644 rep/usr/include/c++/4.3/sstream.gcov.html (limited to 'rep/usr/include/c++/4.3/sstream.gcov.html') diff --git a/rep/usr/include/c++/4.3/sstream.gcov.html b/rep/usr/include/c++/4.3/sstream.gcov.html deleted file mode 100644 index 0254a8d..0000000 --- a/rep/usr/include/c++/4.3/sstream.gcov.html +++ /dev/null @@ -1,642 +0,0 @@ - - - - - - - LCOV - lcov.info - /usr/include/c++/4.3/sstream - - - - - - - - - - - - - -
LTP GCOV extension - code coverage report
- - - - - - - - - - - - - - - - - - - - - - - -
Current view:directory - usr/include/c++/4.3 - sstream
Test:lcov.info
Date:2008-08-14Instrumented 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
-
- - - -- cgit v1.2.3