LTP GCOV extension - code coverage report
Current view: directory - usr/include/c++/4.3/bits - basic_ios.h
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 35
Code covered: 0.0 % Executed lines: 0

       1                 : // Iostreams base classes -*- C++ -*-
       2                 : 
       3                 : // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
       4                 : // 2006, 2007, 2008
       5                 : // Free Software Foundation, Inc.
       6                 : //
       7                 : // This file is part of the GNU ISO C++ Library.  This library is free
       8                 : // software; you can redistribute it and/or modify it under the
       9                 : // terms of the GNU General Public License as published by the
      10                 : // Free Software Foundation; either version 2, or (at your option)
      11                 : // any later version.
      12                 : 
      13                 : // This library is distributed in the hope that it will be useful,
      14                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 : // GNU General Public License for more details.
      17                 : 
      18                 : // You should have received a copy of the GNU General Public License along
      19                 : // with this library; see the file COPYING.  If not, write to the Free
      20                 : // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
      21                 : // USA.
      22                 : 
      23                 : // As a special exception, you may use this file as part of a free software
      24                 : // library without restriction.  Specifically, if other files instantiate
      25                 : // templates or use macros or inline functions from this file, or you compile
      26                 : // this file and link it with other files to produce an executable, this
      27                 : // file does not by itself cause the resulting executable to be covered by
      28                 : // the GNU General Public License.  This exception does not however
      29                 : // invalidate any other reasons why the executable file might be covered by
      30                 : // the GNU General Public License.
      31                 : 
      32                 : /** @file basic_ios.h
      33                 :  *  This is an internal header file, included by other library headers.
      34                 :  *  You should not attempt to use it directly.
      35                 :  */
      36                 : 
      37                 : #ifndef _BASIC_IOS_H
      38                 : #define _BASIC_IOS_H 1
      39                 : 
      40                 : #pragma GCC system_header
      41                 : 
      42                 : #include <bits/localefwd.h>
      43                 : #include <bits/locale_classes.h>
      44                 : #include <bits/locale_facets.h>
      45                 : #include <bits/streambuf_iterator.h>
      46                 : 
      47                 : _GLIBCXX_BEGIN_NAMESPACE(std)
      48                 : 
      49                 :   template<typename _Facet>
      50                 :     inline const _Facet&
      51               0 :     __check_facet(const _Facet* __f)
      52                 :     {
      53               0 :       if (!__f)
      54               0 :         __throw_bad_cast();
      55               0 :       return *__f;
      56                 :     }
      57                 : 
      58                 :   // 27.4.5  Template class basic_ios
      59                 :   /**
      60                 :    *  @brief  Virtual base class for all stream classes.
      61                 :    *
      62                 :    *  Most of the member functions called dispatched on stream objects
      63                 :    *  (e.g., @c std::cout.foo(bar);) are consolidated in this class.
      64                 :   */
      65                 :   template<typename _CharT, typename _Traits>
      66                 :     class basic_ios : public ios_base
      67                 :     {
      68                 :     public:
      69                 :       //@{
      70                 :       /**
      71                 :        *  These are standard types.  They permit a standardized way of
      72                 :        *  referring to names of (or names dependant on) the template
      73                 :        *  parameters, which are specific to the implementation.
      74                 :       */
      75                 :       typedef _CharT                                 char_type;
      76                 :       typedef typename _Traits::int_type             int_type;
      77                 :       typedef typename _Traits::pos_type             pos_type;
      78                 :       typedef typename _Traits::off_type             off_type;
      79                 :       typedef _Traits                                traits_type;
      80                 :       //@}
      81                 : 
      82                 :       //@{
      83                 :       /**
      84                 :        *  These are non-standard types.
      85                 :       */
      86                 :       typedef ctype<_CharT>                          __ctype_type;
      87                 :       typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
      88                 :                                                      __num_put_type;
      89                 :       typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
      90                 :                                                      __num_get_type;
      91                 :       //@}
      92                 : 
      93                 :       // Data members:
      94                 :     protected:
      95                 :       basic_ostream<_CharT, _Traits>*                _M_tie;
      96                 :       mutable char_type                              _M_fill;
      97                 :       mutable bool                                   _M_fill_init;
      98                 :       basic_streambuf<_CharT, _Traits>*              _M_streambuf;
      99                 : 
     100                 :       // Cached use_facet<ctype>, which is based on the current locale info.
     101                 :       const __ctype_type*                            _M_ctype;
     102                 :       // For ostream.
     103                 :       const __num_put_type*                          _M_num_put;
     104                 :       // For istream.
     105                 :       const __num_get_type*                          _M_num_get;
     106                 : 
     107                 :     public:
     108                 :       //@{
     109                 :       /**
     110                 :        *  @brief  The quick-and-easy status check.
     111                 :        *
     112                 :        *  This allows you to write constructs such as
     113                 :        *  "if (!a_stream) ..." and "while (a_stream) ..."
     114                 :       */
     115               0 :       operator void*() const
     116               0 :       { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
     117                 : 
     118                 :       bool
     119               0 :       operator!() const
     120               0 :       { return this->fail(); }
     121                 :       //@}
     122                 : 
     123                 :       /**
     124                 :        *  @brief  Returns the error state of the stream buffer.
     125                 :        *  @return  A bit pattern (well, isn't everything?)
     126                 :        *
     127                 :        *  See std::ios_base::iostate for the possible bit values.  Most
     128                 :        *  users will call one of the interpreting wrappers, e.g., good().
     129                 :       */
     130                 :       iostate
     131               0 :       rdstate() const
     132               0 :       { return _M_streambuf_state; }
     133                 : 
     134                 :       /**
     135                 :        *  @brief  [Re]sets the error state.
     136                 :        *  @param  state  The new state flag(s) to set.
     137                 :        *
     138                 :        *  See std::ios_base::iostate for the possible bit values.  Most
     139                 :        *  users will not need to pass an argument.
     140                 :       */
     141                 :       void
     142                 :       clear(iostate __state = goodbit);
     143                 : 
     144                 :       /**
     145                 :        *  @brief  Sets additional flags in the error state.
     146                 :        *  @param  state  The additional state flag(s) to set.
     147                 :        *
     148                 :        *  See std::ios_base::iostate for the possible bit values.
     149                 :       */
     150                 :       void
     151               0 :       setstate(iostate __state)
     152               0 :       { this->clear(this->rdstate() | __state); }
     153                 : 
     154                 :       // Flip the internal state on for the proper state bits, then re
     155                 :       // throws the propagated exception if bit also set in
     156                 :       // exceptions().
     157                 :       void
     158                 :       _M_setstate(iostate __state)
     159                 :       {
     160                 :         // 27.6.1.2.1 Common requirements.
     161                 :         // Turn this on without causing an ios::failure to be thrown.
     162                 :         _M_streambuf_state |= __state;
     163                 :         if (this->exceptions() & __state)
     164                 :           __throw_exception_again;
     165                 :       }
     166                 : 
     167                 :       /**
     168                 :        *  @brief  Fast error checking.
     169                 :        *  @return  True if no error flags are set.
     170                 :        *
     171                 :        *  A wrapper around rdstate.
     172                 :       */
     173                 :       bool
     174               0 :       good() const
     175               0 :       { return this->rdstate() == 0; }
     176                 : 
     177                 :       /**
     178                 :        *  @brief  Fast error checking.
     179                 :        *  @return  True if the eofbit is set.
     180                 :        *
     181                 :        *  Note that other iostate flags may also be set.
     182                 :       */
     183                 :       bool
     184               0 :       eof() const
     185               0 :       { return (this->rdstate() & eofbit) != 0; }
     186                 : 
     187                 :       /**
     188                 :        *  @brief  Fast error checking.
     189                 :        *  @return  True if either the badbit or the failbit is set.
     190                 :        *
     191                 :        *  Checking the badbit in fail() is historical practice.
     192                 :        *  Note that other iostate flags may also be set.
     193                 :       */
     194                 :       bool
     195               0 :       fail() const
     196               0 :       { return (this->rdstate() & (badbit | failbit)) != 0; }
     197                 : 
     198                 :       /**
     199                 :        *  @brief  Fast error checking.
     200                 :        *  @return  True if the badbit is set.
     201                 :        *
     202                 :        *  Note that other iostate flags may also be set.
     203                 :       */
     204                 :       bool
     205                 :       bad() const
     206                 :       { return (this->rdstate() & badbit) != 0; }
     207                 : 
     208                 :       /**
     209                 :        *  @brief  Throwing exceptions on errors.
     210                 :        *  @return  The current exceptions mask.
     211                 :        *
     212                 :        *  This changes nothing in the stream.  See the one-argument version
     213                 :        *  of exceptions(iostate) for the meaning of the return value.
     214                 :       */
     215                 :       iostate
     216                 :       exceptions() const
     217                 :       { return _M_exception; }
     218                 : 
     219                 :       /**
     220                 :        *  @brief  Throwing exceptions on errors.
     221                 :        *  @param  except  The new exceptions mask.
     222                 :        *
     223                 :        *  By default, error flags are set silently.  You can set an
     224                 :        *  exceptions mask for each stream; if a bit in the mask becomes set
     225                 :        *  in the error flags, then an exception of type
     226                 :        *  std::ios_base::failure is thrown.
     227                 :        *
     228                 :        *  If the error flag is already set when the exceptions mask is
     229                 :        *  added, the exception is immediately thrown.  Try running the
     230                 :        *  following under GCC 3.1 or later:
     231                 :        *  @code
     232                 :        *  #include <iostream>
     233                 :        *  #include <fstream>
     234                 :        *  #include <exception>
     235                 :        *
     236                 :        *  int main()
     237                 :        *  {
     238                 :        *      std::set_terminate (__gnu_cxx::__verbose_terminate_handler);
     239                 :        *
     240                 :        *      std::ifstream f ("/etc/motd");
     241                 :        *
     242                 :        *      std::cerr << "Setting badbit\n";
     243                 :        *      f.setstate (std::ios_base::badbit);
     244                 :        *
     245                 :        *      std::cerr << "Setting exception mask\n";
     246                 :        *      f.exceptions (std::ios_base::badbit);
     247                 :        *  }
     248                 :        *  @endcode
     249                 :       */
     250                 :       void
     251                 :       exceptions(iostate __except)
     252                 :       {
     253                 :         _M_exception = __except;
     254                 :         this->clear(_M_streambuf_state);
     255                 :       }
     256                 : 
     257                 :       // Constructor/destructor:
     258                 :       /**
     259                 :        *  @brief  Constructor performs initialization.
     260                 :        *
     261                 :        *  The parameter is passed by derived streams.
     262                 :       */
     263                 :       explicit
     264                 :       basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
     265                 :       : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
     266                 :         _M_ctype(0), _M_num_put(0), _M_num_get(0)
     267                 :       { this->init(__sb); }
     268                 : 
     269                 :       /**
     270                 :        *  @brief  Empty.
     271                 :        *
     272                 :        *  The destructor does nothing.  More specifically, it does not
     273                 :        *  destroy the streambuf held by rdbuf().
     274                 :       */
     275                 :       virtual
     276               0 :       ~basic_ios() { }
     277                 : 
     278                 :       // Members:
     279                 :       /**
     280                 :        *  @brief  Fetches the current @e tied stream.
     281                 :        *  @return  A pointer to the tied stream, or NULL if the stream is
     282                 :        *           not tied.
     283                 :        *
     284                 :        *  A stream may be @e tied (or synchronized) to a second output
     285                 :        *  stream.  When this stream performs any I/O, the tied stream is
     286                 :        *  first flushed.  For example, @c std::cin is tied to @c std::cout.
     287                 :       */
     288                 :       basic_ostream<_CharT, _Traits>*
     289                 :       tie() const
     290                 :       { return _M_tie; }
     291                 : 
     292                 :       /**
     293                 :        *  @brief  Ties this stream to an output stream.
     294                 :        *  @param  tiestr  The output stream.
     295                 :        *  @return  The previously tied output stream, or NULL if the stream
     296                 :        *           was not tied.
     297                 :        *
     298                 :        *  This sets up a new tie; see tie() for more.
     299                 :       */
     300                 :       basic_ostream<_CharT, _Traits>*
     301                 :       tie(basic_ostream<_CharT, _Traits>* __tiestr)
     302                 :       {
     303                 :         basic_ostream<_CharT, _Traits>* __old = _M_tie;
     304                 :         _M_tie = __tiestr;
     305                 :         return __old;
     306                 :       }
     307                 : 
     308                 :       /**
     309                 :        *  @brief  Accessing the underlying buffer.
     310                 :        *  @return  The current stream buffer.
     311                 :        *
     312                 :        *  This does not change the state of the stream.
     313                 :       */
     314                 :       basic_streambuf<_CharT, _Traits>*
     315               0 :       rdbuf() const
     316               0 :       { return _M_streambuf; }
     317                 : 
     318                 :       /**
     319                 :        *  @brief  Changing the underlying buffer.
     320                 :        *  @param  sb  The new stream buffer.
     321                 :        *  @return  The previous stream buffer.
     322                 :        *
     323                 :        *  Associates a new buffer with the current stream, and clears the
     324                 :        *  error state.
     325                 :        *
     326                 :        *  Due to historical accidents which the LWG refuses to correct, the
     327                 :        *  I/O library suffers from a design error:  this function is hidden
     328                 :        *  in derived classes by overrides of the zero-argument @c rdbuf(),
     329                 :        *  which is non-virtual for hysterical raisins.  As a result, you
     330                 :        *  must use explicit qualifications to access this function via any
     331                 :        *  derived class.  For example:
     332                 :        *
     333                 :        *  @code
     334                 :        *  std::fstream     foo;         // or some other derived type
     335                 :        *  std::streambuf*  p = .....;
     336                 :        *
     337                 :        *  foo.ios::rdbuf(p);            // ios == basic_ios<char>
     338                 :        *  @endcode
     339                 :       */
     340                 :       basic_streambuf<_CharT, _Traits>*
     341                 :       rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
     342                 : 
     343                 :       /**
     344                 :        *  @brief  Copies fields of __rhs into this.
     345                 :        *  @param  __rhs  The source values for the copies.
     346                 :        *  @return  Reference to this object.
     347                 :        *
     348                 :        *  All fields of __rhs are copied into this object except that rdbuf()
     349                 :        *  and rdstate() remain unchanged.  All values in the pword and iword
     350                 :        *  arrays are copied.  Before copying, each callback is invoked with
     351                 :        *  erase_event.  After copying, each (new) callback is invoked with
     352                 :        *  copyfmt_event.  The final step is to copy exceptions().
     353                 :       */
     354                 :       basic_ios&
     355                 :       copyfmt(const basic_ios& __rhs);
     356                 : 
     357                 :       /**
     358                 :        *  @brief  Retrieves the "empty" character.
     359                 :        *  @return  The current fill character.
     360                 :        *
     361                 :        *  It defaults to a space (' ') in the current locale.
     362                 :       */
     363                 :       char_type
     364               0 :       fill() const
     365                 :       {
     366               0 :         if (!_M_fill_init)
     367                 :           {
     368               0 :             _M_fill = this->widen(' ');
     369               0 :             _M_fill_init = true;
     370                 :           }
     371               0 :         return _M_fill;
     372                 :       }
     373                 : 
     374                 :       /**
     375                 :        *  @brief  Sets a new "empty" character.
     376                 :        *  @param  ch  The new character.
     377                 :        *  @return  The previous fill character.
     378                 :        *
     379                 :        *  The fill character is used to fill out space when P+ characters
     380                 :        *  have been requested (e.g., via setw), Q characters are actually
     381                 :        *  used, and Q<P.  It defaults to a space (' ') in the current locale.
     382                 :       */
     383                 :       char_type
     384               0 :       fill(char_type __ch)
     385                 :       {
     386               0 :         char_type __old = this->fill();
     387               0 :         _M_fill = __ch;
     388               0 :         return __old;
     389                 :       }
     390                 : 
     391                 :       // Locales:
     392                 :       /**
     393                 :        *  @brief  Moves to a new locale.
     394                 :        *  @param  loc  The new locale.
     395                 :        *  @return  The previous locale.
     396                 :        *
     397                 :        *  Calls @c ios_base::imbue(loc), and if a stream buffer is associated
     398                 :        *  with this stream, calls that buffer's @c pubimbue(loc).
     399                 :        *
     400                 :        *  Additional l10n notes are at
     401                 :        *  http://gcc.gnu.org/onlinedocs/libstdc++/22_locale/howto.html
     402                 :       */
     403                 :       locale
     404                 :       imbue(const locale& __loc);
     405                 : 
     406                 :       /**
     407                 :        *  @brief  Squeezes characters.
     408                 :        *  @param  c  The character to narrow.
     409                 :        *  @param  dfault  The character to narrow.
     410                 :        *  @return  The narrowed character.
     411                 :        *
     412                 :        *  Maps a character of @c char_type to a character of @c char,
     413                 :        *  if possible.
     414                 :        *
     415                 :        *  Returns the result of
     416                 :        *  @code
     417                 :        *    std::use_facet<ctype<char_type> >(getloc()).narrow(c,dfault)
     418                 :        *  @endcode
     419                 :        *
     420                 :        *  Additional l10n notes are at
     421                 :        *  http://gcc.gnu.org/onlinedocs/libstdc++/22_locale/howto.html
     422                 :       */
     423                 :       char
     424                 :       narrow(char_type __c, char __dfault) const
     425                 :       { return __check_facet(_M_ctype).narrow(__c, __dfault); }
     426                 : 
     427                 :       /**
     428                 :        *  @brief  Widens characters.
     429                 :        *  @param  c  The character to widen.
     430                 :        *  @return  The widened character.
     431                 :        *
     432                 :        *  Maps a character of @c char to a character of @c char_type.
     433                 :        *
     434                 :        *  Returns the result of
     435                 :        *  @code
     436                 :        *    std::use_facet<ctype<char_type> >(getloc()).widen(c)
     437                 :        *  @endcode
     438                 :        *
     439                 :        *  Additional l10n notes are at
     440                 :        *  http://gcc.gnu.org/onlinedocs/libstdc++/22_locale/howto.html
     441                 :       */
     442                 :       char_type
     443               0 :       widen(char __c) const
     444               0 :       { return __check_facet(_M_ctype).widen(__c); }
     445                 : 
     446                 :     protected:
     447                 :       // 27.4.5.1  basic_ios constructors
     448                 :       /**
     449                 :        *  @brief  Empty.
     450                 :        *
     451                 :        *  The default constructor does nothing and is not normally
     452                 :        *  accessible to users.
     453                 :       */
     454               0 :       basic_ios()
     455                 :       : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false), 
     456               0 :         _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
     457               0 :       { }
     458                 : 
     459                 :       /**
     460                 :        *  @brief  All setup is performed here.
     461                 :        *
     462                 :        *  This is called from the public constructor.  It is not virtual and
     463                 :        *  cannot be redefined.
     464                 :       */
     465                 :       void
     466                 :       init(basic_streambuf<_CharT, _Traits>* __sb);
     467                 : 
     468                 :       void
     469                 :       _M_cache_locale(const locale& __loc);
     470                 :     };
     471                 : 
     472                 : _GLIBCXX_END_NAMESPACE
     473                 : 
     474                 : #ifndef _GLIBCXX_EXPORT_TEMPLATE
     475                 : #include <bits/basic_ios.tcc>
     476                 : #endif
     477                 : 
     478                 : #endif /* _BASIC_IOS_H */

Generated by: LTP GCOV extension version 1.6