ios_base.h

Go to the documentation of this file.
00001 // Iostreams base classes -*- C++ -*-
00002 
00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
00004 // 2006, 2007, 2008, 2009
00005 // Free Software Foundation, Inc.
00006 //
00007 // This file is part of the GNU ISO C++ Library.  This library is free
00008 // software; you can redistribute it and/or modify it under the
00009 // terms of the GNU General Public License as published by the
00010 // Free Software Foundation; either version 3, or (at your option)
00011 // any later version.
00012 
00013 // This library is distributed in the hope that it will be useful,
00014 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016 // GNU General Public License for more details.
00017 
00018 // Under Section 7 of GPL version 3, you are granted additional
00019 // permissions described in the GCC Runtime Library Exception, version
00020 // 3.1, as published by the Free Software Foundation.
00021 
00022 // You should have received a copy of the GNU General Public License and
00023 // a copy of the GCC Runtime Library Exception along with this program;
00024 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00025 // <http://www.gnu.org/licenses/>.
00026 
00027 /** @file ios_base.h
00028  *  This is an internal header file, included by other library headers.
00029  *  You should not attempt to use it directly.
00030  */
00031 
00032 //
00033 // ISO C++ 14882: 27.4  Iostreams base classes
00034 //
00035 
00036 #ifndef _IOS_BASE_H
00037 #define _IOS_BASE_H 1
00038 
00039 #pragma GCC system_header
00040 
00041 #include <ext/atomicity.h>
00042 #include <bits/localefwd.h>
00043 #include <bits/locale_classes.h>
00044 
00045 #ifndef _GLIBCXX_STDIO_MACROS
00046 # include <cstdio>   // For SEEK_CUR, SEEK_END
00047 # define _IOS_BASE_SEEK_CUR SEEK_CUR
00048 # define _IOS_BASE_SEEK_END SEEK_END
00049 #else
00050 # define _IOS_BASE_SEEK_CUR 1
00051 # define _IOS_BASE_SEEK_END 2
00052 #endif
00053 
00054 _GLIBCXX_BEGIN_NAMESPACE(std)
00055 
00056   // The following definitions of bitmask types are enums, not ints,
00057   // as permitted (but not required) in the standard, in order to provide
00058   // better type safety in iostream calls.  A side effect is that
00059   // expressions involving them are no longer compile-time constants.
00060   enum _Ios_Fmtflags 
00061     { 
00062       _S_boolalpha  = 1L << 0,
00063       _S_dec        = 1L << 1,
00064       _S_fixed      = 1L << 2,
00065       _S_hex        = 1L << 3,
00066       _S_internal   = 1L << 4,
00067       _S_left       = 1L << 5,
00068       _S_oct        = 1L << 6,
00069       _S_right      = 1L << 7,
00070       _S_scientific     = 1L << 8,
00071       _S_showbase   = 1L << 9,
00072       _S_showpoint  = 1L << 10,
00073       _S_showpos    = 1L << 11,
00074       _S_skipws     = 1L << 12,
00075       _S_unitbuf    = 1L << 13,
00076       _S_uppercase  = 1L << 14,
00077       _S_adjustfield    = _S_left | _S_right | _S_internal,
00078       _S_basefield  = _S_dec | _S_oct | _S_hex,
00079       _S_floatfield     = _S_scientific | _S_fixed,
00080       _S_ios_fmtflags_end = 1L << 16 
00081     };
00082 
00083   inline _Ios_Fmtflags
00084   operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
00085   { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
00086 
00087   inline _Ios_Fmtflags
00088   operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
00089   { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
00090 
00091   inline _Ios_Fmtflags
00092   operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
00093   { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
00094 
00095   inline _Ios_Fmtflags&
00096   operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
00097   { return __a = __a | __b; }
00098 
00099   inline _Ios_Fmtflags&
00100   operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
00101   { return __a = __a & __b; }
00102 
00103   inline _Ios_Fmtflags&
00104   operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
00105   { return __a = __a ^ __b; }
00106 
00107   inline _Ios_Fmtflags
00108   operator~(_Ios_Fmtflags __a)
00109   { return _Ios_Fmtflags(~static_cast<int>(__a)); }
00110 
00111 
00112   enum _Ios_Openmode 
00113     { 
00114       _S_app        = 1L << 0,
00115       _S_ate        = 1L << 1,
00116       _S_bin        = 1L << 2,
00117       _S_in         = 1L << 3,
00118       _S_out        = 1L << 4,
00119       _S_trunc      = 1L << 5,
00120       _S_ios_openmode_end = 1L << 16 
00121     };
00122 
00123   inline _Ios_Openmode
00124   operator&(_Ios_Openmode __a, _Ios_Openmode __b)
00125   { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
00126 
00127   inline _Ios_Openmode
00128   operator|(_Ios_Openmode __a, _Ios_Openmode __b)
00129   { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
00130 
00131   inline _Ios_Openmode
00132   operator^(_Ios_Openmode __a, _Ios_Openmode __b)
00133   { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
00134 
00135   inline _Ios_Openmode&
00136   operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
00137   { return __a = __a | __b; }
00138 
00139   inline _Ios_Openmode&
00140   operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
00141   { return __a = __a & __b; }
00142 
00143   inline _Ios_Openmode&
00144   operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
00145   { return __a = __a ^ __b; }
00146 
00147   inline _Ios_Openmode
00148   operator~(_Ios_Openmode __a)
00149   { return _Ios_Openmode(~static_cast<int>(__a)); }
00150 
00151 
00152   enum _Ios_Iostate
00153     { 
00154       _S_goodbit        = 0,
00155       _S_badbit         = 1L << 0,
00156       _S_eofbit         = 1L << 1,
00157       _S_failbit        = 1L << 2,
00158       _S_ios_iostate_end = 1L << 16 
00159     };
00160 
00161   inline _Ios_Iostate
00162   operator&(_Ios_Iostate __a, _Ios_Iostate __b)
00163   { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
00164 
00165   inline _Ios_Iostate
00166   operator|(_Ios_Iostate __a, _Ios_Iostate __b)
00167   { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
00168 
00169   inline _Ios_Iostate
00170   operator^(_Ios_Iostate __a, _Ios_Iostate __b)
00171   { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
00172 
00173   inline _Ios_Iostate&
00174   operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
00175   { return __a = __a | __b; }
00176 
00177   inline _Ios_Iostate&
00178   operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
00179   { return __a = __a & __b; }
00180 
00181   inline _Ios_Iostate&
00182   operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
00183   { return __a = __a ^ __b; }
00184 
00185   inline _Ios_Iostate
00186   operator~(_Ios_Iostate __a)
00187   { return _Ios_Iostate(~static_cast<int>(__a)); }
00188 
00189   enum _Ios_Seekdir 
00190     { 
00191       _S_beg = 0,
00192       _S_cur = _IOS_BASE_SEEK_CUR,
00193       _S_end = _IOS_BASE_SEEK_END,
00194       _S_ios_seekdir_end = 1L << 16 
00195     };
00196 
00197   // 27.4.2  Class ios_base
00198   /**
00199    *  @brief  The base of the I/O class hierarchy.
00200    *  @ingroup io
00201    *
00202    *  This class defines everything that can be defined about I/O that does
00203    *  not depend on the type of characters being input or output.  Most
00204    *  people will only see @c ios_base when they need to specify the full
00205    *  name of the various I/O flags (e.g., the openmodes).
00206   */
00207   class ios_base
00208   {
00209   public:
00210 
00211     /** 
00212      *  @brief These are thrown to indicate problems with io.
00213      *  @ingroup exceptions
00214      *
00215      *  27.4.2.1.1  Class ios_base::failure
00216      */
00217     class failure : public exception
00218     {
00219     public:
00220       // _GLIBCXX_RESOLVE_LIB_DEFECTS
00221       // 48.  Use of non-existent exception constructor
00222       explicit
00223       failure(const string& __str) throw();
00224 
00225       // This declaration is not useless:
00226       // http://gcc.gnu.org/onlinedocs/gcc-4.3.2/gcc/Vague-Linkage.html
00227       virtual
00228       ~failure() throw();
00229 
00230       virtual const char*
00231       what() const throw();
00232 
00233     private:
00234       string _M_msg;
00235     };
00236 
00237     // 27.4.2.1.2  Type ios_base::fmtflags
00238     /**
00239      *  @brief This is a bitmask type.
00240      *
00241      *  @c "_Ios_Fmtflags" is implementation-defined, but it is valid to
00242      *  perform bitwise operations on these values and expect the Right
00243      *  Thing to happen.  Defined objects of type fmtflags are:
00244      *  - boolalpha
00245      *  - dec
00246      *  - fixed
00247      *  - hex
00248      *  - internal
00249      *  - left
00250      *  - oct
00251      *  - right
00252      *  - scientific
00253      *  - showbase
00254      *  - showpoint
00255      *  - showpos
00256      *  - skipws
00257      *  - unitbuf
00258      *  - uppercase
00259      *  - adjustfield
00260      *  - basefield
00261      *  - floatfield
00262     */
00263     typedef _Ios_Fmtflags fmtflags;
00264 
00265     /// Insert/extract @c bool in alphabetic rather than numeric format.
00266     static const fmtflags boolalpha =   _S_boolalpha;
00267 
00268     /// Converts integer input or generates integer output in decimal base.
00269     static const fmtflags dec =         _S_dec;
00270 
00271     /// Generate floating-point output in fixed-point notation.
00272     static const fmtflags fixed =       _S_fixed;
00273 
00274     /// Converts integer input or generates integer output in hexadecimal base.
00275     static const fmtflags hex =         _S_hex;
00276 
00277     /// Adds fill characters at a designated internal point in certain
00278     /// generated output, or identical to @c right if no such point is
00279     /// designated.
00280     static const fmtflags internal =    _S_internal;
00281 
00282     /// Adds fill characters on the right (final positions) of certain
00283     /// generated output.  (I.e., the thing you print is flush left.)
00284     static const fmtflags left =        _S_left;
00285 
00286     /// Converts integer input or generates integer output in octal base.
00287     static const fmtflags oct =         _S_oct;
00288 
00289     /// Adds fill characters on the left (initial positions) of certain
00290     /// generated output.  (I.e., the thing you print is flush right.)
00291     static const fmtflags right =       _S_right;
00292 
00293     /// Generates floating-point output in scientific notation.
00294     static const fmtflags scientific =  _S_scientific;
00295 
00296     /// Generates a prefix indicating the numeric base of generated integer
00297     /// output.
00298     static const fmtflags showbase =    _S_showbase;
00299 
00300     /// Generates a decimal-point character unconditionally in generated
00301     /// floating-point output.
00302     static const fmtflags showpoint =   _S_showpoint;
00303 
00304     /// Generates a + sign in non-negative generated numeric output.
00305     static const fmtflags showpos =     _S_showpos;
00306 
00307     /// Skips leading white space before certain input operations.
00308     static const fmtflags skipws =      _S_skipws;
00309 
00310     /// Flushes output after each output operation.
00311     static const fmtflags unitbuf =     _S_unitbuf;
00312 
00313     /// Replaces certain lowercase letters with their uppercase equivalents
00314     /// in generated output.
00315     static const fmtflags uppercase =   _S_uppercase;
00316 
00317     /// A mask of left|right|internal.  Useful for the 2-arg form of @c setf.
00318     static const fmtflags adjustfield = _S_adjustfield;
00319 
00320     /// A mask of dec|oct|hex.  Useful for the 2-arg form of @c setf.
00321     static const fmtflags basefield =   _S_basefield;
00322 
00323     /// A mask of scientific|fixed.  Useful for the 2-arg form of @c setf.
00324     static const fmtflags floatfield =  _S_floatfield;
00325 
00326     // 27.4.2.1.3  Type ios_base::iostate
00327     /**
00328      *  @brief This is a bitmask type.
00329      *
00330      *  @c "_Ios_Iostate" is implementation-defined, but it is valid to
00331      *  perform bitwise operations on these values and expect the Right
00332      *  Thing to happen.  Defined objects of type iostate are:
00333      *  - badbit
00334      *  - eofbit
00335      *  - failbit
00336      *  - goodbit
00337     */
00338     typedef _Ios_Iostate iostate;
00339 
00340     /// Indicates a loss of integrity in an input or output sequence (such
00341     /// as an irrecoverable read error from a file).
00342     static const iostate badbit =   _S_badbit;
00343 
00344     /// Indicates that an input operation reached the end of an input sequence.
00345     static const iostate eofbit =   _S_eofbit;
00346 
00347     /// Indicates that an input operation failed to read the expected
00348     /// characters, or that an output operation failed to generate the
00349     /// desired characters.
00350     static const iostate failbit =  _S_failbit;
00351 
00352     /// Indicates all is well.
00353     static const iostate goodbit =  _S_goodbit;
00354 
00355     // 27.4.2.1.4  Type ios_base::openmode
00356     /**
00357      *  @brief This is a bitmask type.
00358      *
00359      *  @c "_Ios_Openmode" is implementation-defined, but it is valid to
00360      *  perform bitwise operations on these values and expect the Right
00361      *  Thing to happen.  Defined objects of type openmode are:
00362      *  - app
00363      *  - ate
00364      *  - binary
00365      *  - in
00366      *  - out
00367      *  - trunc
00368     */
00369     typedef _Ios_Openmode openmode;
00370 
00371     /// Seek to end before each write.
00372     static const openmode app =     _S_app;
00373 
00374     /// Open and seek to end immediately after opening.
00375     static const openmode ate =     _S_ate;
00376 
00377     /// Perform input and output in binary mode (as opposed to text mode).
00378     /// This is probably not what you think it is; see
00379     /// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch27s02.html
00380     static const openmode binary =  _S_bin;
00381 
00382     /// Open for input.  Default for @c ifstream and fstream.
00383     static const openmode in =      _S_in;
00384 
00385     /// Open for output.  Default for @c ofstream and fstream.
00386     static const openmode out =     _S_out;
00387 
00388     /// Open for input.  Default for @c ofstream.
00389     static const openmode trunc =   _S_trunc;
00390 
00391     // 27.4.2.1.5  Type ios_base::seekdir
00392     /**
00393      *  @brief This is an enumerated type.
00394      *
00395      *  @c "_Ios_Seekdir" is implementation-defined.  Defined values
00396      *  of type seekdir are:
00397      *  - beg
00398      *  - cur, equivalent to @c SEEK_CUR in the C standard library.
00399      *  - end, equivalent to @c SEEK_END in the C standard library.
00400     */
00401     typedef _Ios_Seekdir seekdir;
00402 
00403     /// Request a seek relative to the beginning of the stream.
00404     static const seekdir beg =      _S_beg;
00405 
00406     /// Request a seek relative to the current position within the sequence.
00407     static const seekdir cur =      _S_cur;
00408 
00409     /// Request a seek relative to the current end of the sequence.
00410     static const seekdir end =      _S_end;
00411 
00412     // Annex D.6
00413     typedef int io_state;
00414     typedef int open_mode;
00415     typedef int seek_dir;
00416 
00417     typedef std::streampos streampos;
00418     typedef std::streamoff streamoff;
00419 
00420     // Callbacks;
00421     /**
00422      *  @brief  The set of events that may be passed to an event callback.
00423      *
00424      *  erase_event is used during ~ios() and copyfmt().  imbue_event is used
00425      *  during imbue().  copyfmt_event is used during copyfmt().
00426     */
00427     enum event
00428     {
00429       erase_event,
00430       imbue_event,
00431       copyfmt_event
00432     };
00433 
00434     /**
00435      *  @brief  The type of an event callback function.
00436      *  @param  event  One of the members of the event enum.
00437      *  @param  ios_base  Reference to the ios_base object.
00438      *  @param  int  The integer provided when the callback was registered.
00439      *
00440      *  Event callbacks are user defined functions that get called during
00441      *  several ios_base and basic_ios functions, specifically imbue(),
00442      *  copyfmt(), and ~ios().
00443     */
00444     typedef void (*event_callback) (event, ios_base&, int);
00445 
00446     /**
00447      *  @brief  Add the callback __fn with parameter __index.
00448      *  @param  __fn  The function to add.
00449      *  @param  __index  The integer to pass to the function when invoked.
00450      *
00451      *  Registers a function as an event callback with an integer parameter to
00452      *  be passed to the function when invoked.  Multiple copies of the
00453      *  function are allowed.  If there are multiple callbacks, they are
00454      *  invoked in the order they were registered.
00455     */
00456     void
00457     register_callback(event_callback __fn, int __index);
00458 
00459   protected:
00460     //@{
00461     /**
00462      *  ios_base data members (doc me)
00463     */
00464     streamsize      _M_precision;
00465     streamsize      _M_width;
00466     fmtflags        _M_flags;
00467     iostate     _M_exception;
00468     iostate     _M_streambuf_state;
00469     //@}
00470 
00471     // 27.4.2.6  Members for callbacks
00472     // 27.4.2.6  ios_base callbacks
00473     struct _Callback_list
00474     {
00475       // Data Members
00476       _Callback_list*       _M_next;
00477       ios_base::event_callback  _M_fn;
00478       int           _M_index;
00479       _Atomic_word      _M_refcount;  // 0 means one reference.
00480 
00481       _Callback_list(ios_base::event_callback __fn, int __index,
00482              _Callback_list* __cb)
00483       : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
00484 
00485       void
00486       _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
00487 
00488       // 0 => OK to delete.
00489       int
00490       _M_remove_reference() 
00491       { return __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1); }
00492     };
00493 
00494      _Callback_list*    _M_callbacks;
00495 
00496     void
00497     _M_call_callbacks(event __ev) throw();
00498 
00499     void
00500     _M_dispose_callbacks(void);
00501 
00502     // 27.4.2.5  Members for iword/pword storage
00503     struct _Words
00504     {
00505       void* _M_pword;
00506       long  _M_iword;
00507       _Words() : _M_pword(0), _M_iword(0) { }
00508     };
00509 
00510     // Only for failed iword/pword calls.
00511     _Words      _M_word_zero;
00512 
00513     // Guaranteed storage.
00514     // The first 5 iword and pword slots are reserved for internal use.
00515     enum { _S_local_word_size = 8 };
00516     _Words      _M_local_word[_S_local_word_size];
00517 
00518     // Allocated storage.
00519     int         _M_word_size;
00520     _Words*     _M_word;
00521 
00522     _Words&
00523     _M_grow_words(int __index, bool __iword);
00524 
00525     // Members for locale and locale caching.
00526     locale      _M_ios_locale;
00527 
00528     void
00529     _M_init();
00530 
00531   public:
00532 
00533     // 27.4.2.1.6  Class ios_base::Init
00534     // Used to initialize standard streams. In theory, g++ could use
00535     // -finit-priority to order this stuff correctly without going
00536     // through these machinations.
00537     class Init
00538     {
00539       friend class ios_base;
00540     public:
00541       Init();
00542       ~Init();
00543 
00544     private:
00545       static _Atomic_word   _S_refcount;
00546       static bool       _S_synced_with_stdio;
00547     };
00548 
00549     // [27.4.2.2] fmtflags state functions
00550     /**
00551      *  @brief  Access to format flags.
00552      *  @return  The format control flags for both input and output.
00553     */
00554     fmtflags
00555     flags() const
00556     { return _M_flags; }
00557 
00558     /**
00559      *  @brief  Setting new format flags all at once.
00560      *  @param  fmtfl  The new flags to set.
00561      *  @return  The previous format control flags.
00562      *
00563      *  This function overwrites all the format flags with @a fmtfl.
00564     */
00565     fmtflags
00566     flags(fmtflags __fmtfl)
00567     {
00568       fmtflags __old = _M_flags;
00569       _M_flags = __fmtfl;
00570       return __old;
00571     }
00572 
00573     /**
00574      *  @brief  Setting new format flags.
00575      *  @param  fmtfl  Additional flags to set.
00576      *  @return  The previous format control flags.
00577      *
00578      *  This function sets additional flags in format control.  Flags that
00579      *  were previously set remain set.
00580     */
00581     fmtflags
00582     setf(fmtflags __fmtfl)
00583     {
00584       fmtflags __old = _M_flags;
00585       _M_flags |= __fmtfl;
00586       return __old;
00587     }
00588 
00589     /**
00590      *  @brief  Setting new format flags.
00591      *  @param  fmtfl  Additional flags to set.
00592      *  @param  mask  The flags mask for @a fmtfl.
00593      *  @return  The previous format control flags.
00594      *
00595      *  This function clears @a mask in the format flags, then sets
00596      *  @a fmtfl @c & @a mask.  An example mask is @c ios_base::adjustfield.
00597     */
00598     fmtflags
00599     setf(fmtflags __fmtfl, fmtflags __mask)
00600     {
00601       fmtflags __old = _M_flags;
00602       _M_flags &= ~__mask;
00603       _M_flags |= (__fmtfl & __mask);
00604       return __old;
00605     }
00606 
00607     /**
00608      *  @brief  Clearing format flags.
00609      *  @param  mask  The flags to unset.
00610      *
00611      *  This function clears @a mask in the format flags.
00612     */
00613     void
00614     unsetf(fmtflags __mask)
00615     { _M_flags &= ~__mask; }
00616 
00617     /**
00618      *  @brief  Flags access.
00619      *  @return  The precision to generate on certain output operations.
00620      *
00621      *  Be careful if you try to give a definition of "precision" here; see
00622      *  DR 189.
00623     */
00624     streamsize
00625     precision() const
00626     { return _M_precision; }
00627 
00628     /**
00629      *  @brief  Changing flags.
00630      *  @param  prec  The new precision value.
00631      *  @return  The previous value of precision().
00632     */
00633     streamsize
00634     precision(streamsize __prec)
00635     {
00636       streamsize __old = _M_precision;
00637       _M_precision = __prec;
00638       return __old;
00639     }
00640 
00641     /**
00642      *  @brief  Flags access.
00643      *  @return  The minimum field width to generate on output operations.
00644      *
00645      *  "Minimum field width" refers to the number of characters.
00646     */
00647     streamsize
00648     width() const
00649     { return _M_width; }
00650 
00651     /**
00652      *  @brief  Changing flags.
00653      *  @param  wide  The new width value.
00654      *  @return  The previous value of width().
00655     */
00656     streamsize
00657     width(streamsize __wide)
00658     {
00659       streamsize __old = _M_width;
00660       _M_width = __wide;
00661       return __old;
00662     }
00663 
00664     // [27.4.2.4] ios_base static members
00665     /**
00666      *  @brief  Interaction with the standard C I/O objects.
00667      *  @param  sync  Whether to synchronize or not.
00668      *  @return  True if the standard streams were previously synchronized.
00669      *
00670      *  The synchronization referred to is @e only that between the standard
00671      *  C facilities (e.g., stdout) and the standard C++ objects (e.g.,
00672      *  cout).  User-declared streams are unaffected.  See
00673      *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch28s02.html
00674     */
00675     static bool
00676     sync_with_stdio(bool __sync = true);
00677 
00678     // [27.4.2.3] ios_base locale functions
00679     /**
00680      *  @brief  Setting a new locale.
00681      *  @param  loc  The new locale.
00682      *  @return  The previous locale.
00683      *
00684      *  Sets the new locale for this stream, and then invokes each callback
00685      *  with imbue_event.
00686     */
00687     locale
00688     imbue(const locale& __loc);
00689 
00690     /**
00691      *  @brief  Locale access
00692      *  @return  A copy of the current locale.
00693      *
00694      *  If @c imbue(loc) has previously been called, then this function
00695      *  returns @c loc.  Otherwise, it returns a copy of @c std::locale(),
00696      *  the global C++ locale.
00697     */
00698     locale
00699     getloc() const
00700     { return _M_ios_locale; }
00701 
00702     /**
00703      *  @brief  Locale access
00704      *  @return  A reference to the current locale.
00705      *
00706      *  Like getloc above, but returns a reference instead of
00707      *  generating a copy.
00708     */
00709     const locale&
00710     _M_getloc() const
00711     { return _M_ios_locale; }
00712 
00713     // [27.4.2.5] ios_base storage functions
00714     /**
00715      *  @brief  Access to unique indices.
00716      *  @return  An integer different from all previous calls.
00717      *
00718      *  This function returns a unique integer every time it is called.  It
00719      *  can be used for any purpose, but is primarily intended to be a unique
00720      *  index for the iword and pword functions.  The expectation is that an
00721      *  application calls xalloc in order to obtain an index in the iword and
00722      *  pword arrays that can be used without fear of conflict.
00723      *
00724      *  The implementation maintains a static variable that is incremented and
00725      *  returned on each invocation.  xalloc is guaranteed to return an index
00726      *  that is safe to use in the iword and pword arrays.
00727     */
00728     static int
00729     xalloc() throw();
00730 
00731     /**
00732      *  @brief  Access to integer array.
00733      *  @param  __ix  Index into the array.
00734      *  @return  A reference to an integer associated with the index.
00735      *
00736      *  The iword function provides access to an array of integers that can be
00737      *  used for any purpose.  The array grows as required to hold the
00738      *  supplied index.  All integers in the array are initialized to 0.
00739      *
00740      *  The implementation reserves several indices.  You should use xalloc to
00741      *  obtain an index that is safe to use.  Also note that since the array
00742      *  can grow dynamically, it is not safe to hold onto the reference.
00743     */
00744     long&
00745     iword(int __ix)
00746     {
00747       _Words& __word = (__ix < _M_word_size)
00748             ? _M_word[__ix] : _M_grow_words(__ix, true);
00749       return __word._M_iword;
00750     }
00751 
00752     /**
00753      *  @brief  Access to void pointer array.
00754      *  @param  __ix  Index into the array.
00755      *  @return  A reference to a void* associated with the index.
00756      *
00757      *  The pword function provides access to an array of pointers that can be
00758      *  used for any purpose.  The array grows as required to hold the
00759      *  supplied index.  All pointers in the array are initialized to 0.
00760      *
00761      *  The implementation reserves several indices.  You should use xalloc to
00762      *  obtain an index that is safe to use.  Also note that since the array
00763      *  can grow dynamically, it is not safe to hold onto the reference.
00764     */
00765     void*&
00766     pword(int __ix)
00767     {
00768       _Words& __word = (__ix < _M_word_size)
00769             ? _M_word[__ix] : _M_grow_words(__ix, false);
00770       return __word._M_pword;
00771     }
00772 
00773     // Destructor
00774     /**
00775      *  Invokes each callback with erase_event.  Destroys local storage.
00776      *
00777      *  Note that the ios_base object for the standard streams never gets
00778      *  destroyed.  As a result, any callbacks registered with the standard
00779      *  streams will not get invoked with erase_event (unless copyfmt is
00780      *  used).
00781     */
00782     virtual ~ios_base();
00783 
00784   protected:
00785     ios_base();
00786 
00787   // _GLIBCXX_RESOLVE_LIB_DEFECTS
00788   // 50.  Copy constructor and assignment operator of ios_base
00789   private:
00790     ios_base(const ios_base&);
00791 
00792     ios_base&
00793     operator=(const ios_base&);
00794   };
00795 
00796   // [27.4.5.1] fmtflags manipulators
00797   /// Calls base.setf(ios_base::boolalpha).
00798   inline ios_base&
00799   boolalpha(ios_base& __base)
00800   {
00801     __base.setf(ios_base::boolalpha);
00802     return __base;
00803   }
00804 
00805   /// Calls base.unsetf(ios_base::boolalpha).
00806   inline ios_base&
00807   noboolalpha(ios_base& __base)
00808   {
00809     __base.unsetf(ios_base::boolalpha);
00810     return __base;
00811   }
00812 
00813   /// Calls base.setf(ios_base::showbase).
00814   inline ios_base&
00815   showbase(ios_base& __base)
00816   {
00817     __base.setf(ios_base::showbase);
00818     return __base;
00819   }
00820 
00821   /// Calls base.unsetf(ios_base::showbase).
00822   inline ios_base&
00823   noshowbase(ios_base& __base)
00824   {
00825     __base.unsetf(ios_base::showbase);
00826     return __base;
00827   }
00828 
00829   /// Calls base.setf(ios_base::showpoint).
00830   inline ios_base&
00831   showpoint(ios_base& __base)
00832   {
00833     __base.setf(ios_base::showpoint);
00834     return __base;
00835   }
00836 
00837   /// Calls base.unsetf(ios_base::showpoint).
00838   inline ios_base&
00839   noshowpoint(ios_base& __base)
00840   {
00841     __base.unsetf(ios_base::showpoint);
00842     return __base;
00843   }
00844 
00845   /// Calls base.setf(ios_base::showpos).
00846   inline ios_base&
00847   showpos(ios_base& __base)
00848   {
00849     __base.setf(ios_base::showpos);
00850     return __base;
00851   }
00852 
00853   /// Calls base.unsetf(ios_base::showpos).
00854   inline ios_base&
00855   noshowpos(ios_base& __base)
00856   {
00857     __base.unsetf(ios_base::showpos);
00858     return __base;
00859   }
00860 
00861   /// Calls base.setf(ios_base::skipws).
00862   inline ios_base&
00863   skipws(ios_base& __base)
00864   {
00865     __base.setf(ios_base::skipws);
00866     return __base;
00867   }
00868 
00869   /// Calls base.unsetf(ios_base::skipws).
00870   inline ios_base&
00871   noskipws(ios_base& __base)
00872   {
00873     __base.unsetf(ios_base::skipws);
00874     return __base;
00875   }
00876 
00877   /// Calls base.setf(ios_base::uppercase).
00878   inline ios_base&
00879   uppercase(ios_base& __base)
00880   {
00881     __base.setf(ios_base::uppercase);
00882     return __base;
00883   }
00884 
00885   /// Calls base.unsetf(ios_base::uppercase).
00886   inline ios_base&
00887   nouppercase(ios_base& __base)
00888   {
00889     __base.unsetf(ios_base::uppercase);
00890     return __base;
00891   }
00892 
00893   /// Calls base.setf(ios_base::unitbuf).
00894   inline ios_base&
00895   unitbuf(ios_base& __base)
00896   {
00897      __base.setf(ios_base::unitbuf);
00898      return __base;
00899   }
00900 
00901   /// Calls base.unsetf(ios_base::unitbuf).
00902   inline ios_base&
00903   nounitbuf(ios_base& __base)
00904   {
00905      __base.unsetf(ios_base::unitbuf);
00906      return __base;
00907   }
00908 
00909   // [27.4.5.2] adjustfield manipulators
00910   /// Calls base.setf(ios_base::internal, ios_base::adjustfield).
00911   inline ios_base&
00912   internal(ios_base& __base)
00913   {
00914      __base.setf(ios_base::internal, ios_base::adjustfield);
00915      return __base;
00916   }
00917 
00918   /// Calls base.setf(ios_base::left, ios_base::adjustfield).
00919   inline ios_base&
00920   left(ios_base& __base)
00921   {
00922     __base.setf(ios_base::left, ios_base::adjustfield);
00923     return __base;
00924   }
00925 
00926   /// Calls base.setf(ios_base::right, ios_base::adjustfield).
00927   inline ios_base&
00928   right(ios_base& __base)
00929   {
00930     __base.setf(ios_base::right, ios_base::adjustfield);
00931     return __base;
00932   }
00933 
00934   // [27.4.5.3] basefield manipulators
00935   /// Calls base.setf(ios_base::dec, ios_base::basefield).
00936   inline ios_base&
00937   dec(ios_base& __base)
00938   {
00939     __base.setf(ios_base::dec, ios_base::basefield);
00940     return __base;
00941   }
00942 
00943   /// Calls base.setf(ios_base::hex, ios_base::basefield).
00944   inline ios_base&
00945   hex(ios_base& __base)
00946   {
00947     __base.setf(ios_base::hex, ios_base::basefield);
00948     return __base;
00949   }
00950 
00951   /// Calls base.setf(ios_base::oct, ios_base::basefield).
00952   inline ios_base&
00953   oct(ios_base& __base)
00954   {
00955     __base.setf(ios_base::oct, ios_base::basefield);
00956     return __base;
00957   }
00958 
00959   // [27.4.5.4] floatfield manipulators
00960   /// Calls base.setf(ios_base::fixed, ios_base::floatfield).
00961   inline ios_base&
00962   fixed(ios_base& __base)
00963   {
00964     __base.setf(ios_base::fixed, ios_base::floatfield);
00965     return __base;
00966   }
00967 
00968   /// Calls base.setf(ios_base::scientific, ios_base::floatfield).
00969   inline ios_base&
00970   scientific(ios_base& __base)
00971   {
00972     __base.setf(ios_base::scientific, ios_base::floatfield);
00973     return __base;
00974   }
00975 
00976 _GLIBCXX_END_NAMESPACE
00977 
00978 #undef _IOS_BASE_SEEK_CUR
00979 #undef _IOS_BASE_SEEK_END
00980 
00981 #endif /* _IOS_BASE_H */
00982 

Generated on Thu Jul 23 21:16:09 2009 for libstdc++ by  doxygen 1.5.8