LCOV - app.info - /tools/gcc-4.5/include/c++/4.5.2/bits/basic_ios.h

LCOV - code coverage report
| Current view: | directory - tools/gcc-4.5/include/c++/4.5.2/bits - basic_ios.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 34 | 0 | 0.0 %
| Date: | 2012-04-07 | Functions: | 14 | 0 | 0.0 %

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

Generated by: LCOV version 1.7