contrib/gcc-4.0/libstdc++-v3/include/std/std_fstream.h

   1 // File based streams -*- C++ -*-
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   4 // Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 2, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // You should have received a copy of the GNU General Public License along
  18 // with this library; see the file COPYING.  If not, write to the Free
  19 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20 // USA.
  21
  22 // As a special exception, you may use this file as part of a free software
  23 // library without restriction.  Specifically, if other files instantiate
  24 // templates or use macros or inline functions from this file, or you compile
  25 // this file and link it with other files to produce an executable, this
  26 // file does not by itself cause the resulting executable to be covered by
  27 // the GNU General Public License.  This exception does not however
  28 // invalidate any other reasons why the executable file might be covered by
  29 // the GNU General Public License.
  30
  31 //
  32 // ISO C++ 14882: 27.8  File-based streams
  33 //
  34
  35 /** @file fstream
  36  *  This is a Standard C++ Library header.
  37  */
  38
  39 #ifndef _GLIBCXX_FSTREAM
  40 #define _GLIBCXX_FSTREAM 1
  41
  42 #pragma GCC system_header
  43
  44 #include <istream>
  45 #include <ostream>
  46 #include <locale>       // For codecvt
  47 #include <cstdio>       // For SEEK_SET, SEEK_CUR, SEEK_END, BUFSIZ
  48 #include <bits/basic_file.h>
  49 #include <bits/gthr.h>
  50
  51 namespace std
  52 {
  53   // [27.8.1.1] template class basic_filebuf
  54   /**
  55    *  @brief  The actual work of input and output (for files).
  56    *
  57    *  This class associates both its input and output sequence with an
  58    *  external disk file, and maintains a joint file position for both
  59    *  sequences.  Many of its sematics are described in terms of similar
  60    *  behavior in the Standard C Library's @c FILE streams.
  61   */
  62   // Requirements on traits_type, specific to this class:
  63   // traits_type::pos_type must be fpos<traits_type::state_type>
  64   // traits_type::off_type must be streamoff
  65   // traits_type::state_type must be Assignable and DefaultConstructable,
  66   // and traits_type::state_type() must be the initial state for codecvt.
  67   template<typename _CharT, typename _Traits>
  68     class basic_filebuf : public basic_streambuf<_CharT, _Traits>
  69     {
  70     public:
  71       // Types:
  72       typedef _CharT                                    char_type;
  73       typedef _Traits                                   traits_type;
  74       typedef typename traits_type::int_type            int_type;
  75       typedef typename traits_type::pos_type            pos_type;
  76       typedef typename traits_type::off_type            off_type;
  77
  78       typedef basic_streambuf<char_type, traits_type>   __streambuf_type;
  79       typedef basic_filebuf<char_type, traits_type>     __filebuf_type;
  80       typedef __basic_file<char>                        __file_type;
  81       typedef typename traits_type::state_type          __state_type;
  82       typedef codecvt<char_type, char, __state_type>    __codecvt_type;
  83
  84       friend class ios_base; // For sync_with_stdio.
  85
  86     protected:
  87       // Data Members:
  88       // MT lock inherited from libio or other low-level io library.
  89       __c_lock                  _M_lock;
  90
  91       // External buffer.
  92       __file_type               _M_file;
  93
  94       /**
  95        *  @if maint
  96        *  Place to stash in || out || in | out settings for current filebuf.
  97        *  @endif
  98       */
  99       ios_base::openmode        _M_mode;
 100
 101       // Beginning state type for codecvt.
 102       __state_type              _M_state_beg;
 103
 104       // During output, the state that corresponds to pptr(),
 105       // during input, the state that corresponds to egptr() and
 106       // _M_ext_next.
 107       __state_type              _M_state_cur;
 108
 109       // Not used for output. During input, the state that corresponds
 110       // to eback() and _M_ext_buf.
 111       __state_type              _M_state_last;
 112
 113       /**
 114        *  @if maint
 115        *  Pointer to the beginning of internal buffer.
 116        *  @endif
 117       */
 118       char_type*                _M_buf;
 119
 120       /**
 121        *  @if maint
 122        *  Actual size of internal buffer. This number is equal to the size
 123        *  of the put area + 1 position, reserved for the overflow char of
 124        *  a full area.
 125        *  @endif
 126       */
 127       size_t                    _M_buf_size;
 128
 129       // Set iff _M_buf is allocated memory from _M_allocate_internal_buffer.
 130       bool                      _M_buf_allocated;
 131
 132       /**
 133        *  @if maint
 134        *  _M_reading == false && _M_writing == false for 'uncommitted' mode;
 135        *  _M_reading == true for 'read' mode;
 136        *  _M_writing == true for 'write' mode;
 137        *
 138        *  NB: _M_reading == true && _M_writing == true is unused.
 139        *  @endif
 140       */
 141       bool                      _M_reading;
 142       bool                      _M_writing;
 143
 144       //@{
 145       /**
 146        *  @if maint
 147        *  Necessary bits for putback buffer management.
 148        *
 149        *  @note pbacks of over one character are not currently supported.
 150        *  @endif
 151       */
 152       char_type                 _M_pback;
 153       char_type*                _M_pback_cur_save;
 154       char_type*                _M_pback_end_save;
 155       bool                      _M_pback_init;
 156       //@}
 157
 158       // Cached codecvt facet.
 159       const __codecvt_type*     _M_codecvt;
 160
 161       /**
 162        *  @if maint
 163        *  Buffer for external characters. Used for input when
 164        *  codecvt::always_noconv() == false. When valid, this corresponds
 165        *  to eback().
 166        *  @endif
 167       */
 168       char*                     _M_ext_buf;
 169
 170       /**
 171        *  @if maint
 172        *  Size of buffer held by _M_ext_buf.
 173        *  @endif
 174       */
 175       streamsize                _M_ext_buf_size;
 176
 177       /**
 178        *  @if maint
 179        *  Pointers into the buffer held by _M_ext_buf that delimit a
 180        *  subsequence of bytes that have been read but not yet converted.
 181        *  When valid, _M_ext_next corresponds to egptr().
 182        *  @endif
 183       */
 184       const char*               _M_ext_next;
 185       char*                     _M_ext_end;
 186
 187       /**
 188        *  @if maint
 189        *  Initializes pback buffers, and moves normal buffers to safety.
 190        *  Assumptions:
 191        *  _M_in_cur has already been moved back
 192        *  @endif
 193       */
 194       void
 195       _M_create_pback()
 196       {
 197         if (!_M_pback_init)
 198           {
 199             _M_pback_cur_save = this->gptr();
 200             _M_pback_end_save = this->egptr();
 201             this->setg(&_M_pback, &_M_pback, &_M_pback + 1);
 202             _M_pback_init = true;
 203           }
 204       }
 205
 206       /**
 207        *  @if maint
 208        *  Deactivates pback buffer contents, and restores normal buffer.
 209        *  Assumptions:
 210        *  The pback buffer has only moved forward.
 211        *  @endif
 212       */
 213       void
 214       _M_destroy_pback() throw()
 215       {
 216         if (_M_pback_init)
 217           {
 218             // Length _M_in_cur moved in the pback buffer.
 219             _M_pback_cur_save += this->gptr() != this->eback();
 220             this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save);
 221             _M_pback_init = false;
 222           }
 223       }
 224
 225     public:
 226       // Constructors/destructor:
 227       /**
 228        *  @brief  Does not open any files.
 229        *
 230        *  The default constructor initializes the parent class using its
 231        *  own default ctor.
 232       */
 233       basic_filebuf();
 234
 235       /**
 236        *  @brief  The destructor closes the file first.
 237       */
 238       virtual
 239       ~basic_filebuf()
 240       { this->close(); }
 241
 242       // Members:
 243       /**
 244        *  @brief  Returns true if the external file is open.
 245       */
 246       bool
 247       is_open() const throw()
 248       { return _M_file.is_open(); }
 249
 250       /**
 251        *  @brief  Opens an external file.
 252        *  @param  s  The name of the file.
 253        *  @param  mode  The open mode flags.
 254        *  @return  @c this on success, NULL on failure
 255        *
 256        *  If a file is already open, this function immediately fails.
 257        *  Otherwise it tries to open the file named @a s using the flags
 258        *  given in @a mode.
 259        *
 260        *  [Table 92 gives the relation between openmode combinations and the
 261        *  equivalent fopen() flags, but the table has not been copied yet.]
 262       */
 263       __filebuf_type*
 264       open(const char* __s, ios_base::openmode __mode);
 265
 266       /**
 267        *  @brief  Closes the currently associated file.
 268        *  @return  @c this on success, NULL on failure
 269        *
 270        *  If no file is currently open, this function immediately fails.
 271        *
 272        *  If a "put buffer area" exists, @c overflow(eof) is called to flush
 273        *  all the characters.  The file is then closed.
 274        *
 275        *  If any operations fail, this function also fails.
 276       */
 277       __filebuf_type*
 278       close() throw();
 279
 280     protected:
 281       void
 282       _M_allocate_internal_buffer();
 283
 284       void
 285       _M_destroy_internal_buffer() throw();
 286
 287       // [27.8.1.4] overridden virtual functions
 288       virtual streamsize
 289       showmanyc();
 290
 291       // Stroustrup, 1998, p. 628
 292       // underflow() and uflow() functions are called to get the next
 293       // charater from the real input source when the buffer is empty.
 294       // Buffered input uses underflow()
 295
 296       virtual int_type
 297       underflow();
 298
 299       virtual int_type
 300       pbackfail(int_type __c = _Traits::eof());
 301
 302       // Stroustrup, 1998, p 648
 303       // The overflow() function is called to transfer characters to the
 304       // real output destination when the buffer is full. A call to
 305       // overflow(c) outputs the contents of the buffer plus the
 306       // character c.
 307       // 27.5.2.4.5
 308       // Consume some sequence of the characters in the pending sequence.
 309       virtual int_type
 310       overflow(int_type __c = _Traits::eof());
 311
 312       // Convert internal byte sequence to external, char-based
 313       // sequence via codecvt.
 314       bool
 315       _M_convert_to_external(char_type*, streamsize);
 316
 317       /**
 318        *  @brief  Manipulates the buffer.
 319        *  @param  s  Pointer to a buffer area.
 320        *  @param  n  Size of @a s.
 321        *  @return  @c this
 322        *
 323        *  If no file has been opened, and both @a s and @a n are zero, then
 324        *  the stream becomes unbuffered.  Otherwise, @c s is used as a
 325        *  buffer; see
 326        *  http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2
 327        *  for more.
 328       */
 329       virtual __streambuf_type*
 330       setbuf(char_type* __s, streamsize __n);
 331
 332       virtual pos_type
 333       seekoff(off_type __off, ios_base::seekdir __way,
 334               ios_base::openmode __mode = ios_base::in | ios_base::out);
 335
 336       virtual pos_type
 337       seekpos(pos_type __pos,
 338               ios_base::openmode __mode = ios_base::in | ios_base::out);
 339
 340       // Common code for seekoff and seekpos
 341       pos_type
 342       _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);
 343
 344       virtual int
 345       sync();
 346
 347       virtual void
 348       imbue(const locale& __loc);
 349
 350       virtual streamsize
 351       xsgetn(char_type* __s, streamsize __n);
 352
 353       virtual streamsize
 354       xsputn(const char_type* __s, streamsize __n);
 355
 356       // Flushes output buffer, then writes unshift sequence.
 357       bool
 358       _M_terminate_output();
 359
 360       /**
 361        *  @if maint
 362        *  This function sets the pointers of the internal buffer, both get
 363        *  and put areas. Typically:
 364        *
 365        *   __off == egptr() - eback() upon underflow/uflow ('read' mode);
 366        *   __off == 0 upon overflow ('write' mode);
 367        *   __off == -1 upon open, setbuf, seekoff/pos ('uncommitted' mode).
 368        *
 369        *  NB: epptr() - pbase() == _M_buf_size - 1, since _M_buf_size
 370        *  reflects the actual allocated memory and the last cell is reserved
 371        *  for the overflow char of a full put area.
 372        *  @endif
 373       */
 374       void
 375       _M_set_buffer(streamsize __off)
 376       {
 377         const bool __testin = _M_mode & ios_base::in;
 378         const bool __testout = _M_mode & ios_base::out;
 379
 380         if (__testin && __off > 0)
 381           this->setg(_M_buf, _M_buf, _M_buf + __off);
 382         else
 383           this->setg(_M_buf, _M_buf, _M_buf);
 384
 385         if (__testout && __off == 0 && _M_buf_size > 1 )
 386           this->setp(_M_buf, _M_buf + _M_buf_size - 1);
 387         else
 388           this->setp(NULL, NULL);
 389       }
 390     };
 391
 392   // [27.8.1.5] Template class basic_ifstream
 393   /**
 394    *  @brief  Controlling input for files.
 395    *
 396    *  This class supports reading from named files, using the inherited
 397    *  functions from std::basic_istream.  To control the associated
 398    *  sequence, an instance of std::basic_filebuf is used, which this page
 399    *  refers to as @c sb.
 400   */
 401   template<typename _CharT, typename _Traits>
 402     class basic_ifstream : public basic_istream<_CharT, _Traits>
 403     {
 404     public:
 405       // Types:
 406       typedef _CharT                                    char_type;
 407       typedef _Traits                                   traits_type;
 408       typedef typename traits_type::int_type            int_type;
 409       typedef typename traits_type::pos_type            pos_type;
 410       typedef typename traits_type::off_type            off_type;
 411
 412       // Non-standard types:
 413       typedef basic_filebuf<char_type, traits_type>     __filebuf_type;
 414       typedef basic_istream<char_type, traits_type>     __istream_type;
 415
 416     private:
 417       __filebuf_type    _M_filebuf;
 418
 419     public:
 420       // Constructors/Destructors:
 421       /**
 422        *  @brief  Default constructor.
 423        *
 424        *  Initializes @c sb using its default constructor, and passes
 425        *  @c &sb to the base class initializer.  Does not open any files
 426        *  (you haven't given it a filename to open).
 427       */
 428       basic_ifstream() : __istream_type(), _M_filebuf()
 429       { this->init(&_M_filebuf); }
 430
 431       /**
 432        *  @brief  Create an input file stream.
 433        *  @param  s  Null terminated string specifying the filename.
 434        *  @param  mode  Open file in specified mode (see std::ios_base).
 435        *
 436        *  @c ios_base::in is automatically included in @a mode.
 437        *
 438        *  Tip:  When using std::string to hold the filename, you must use
 439        *  .c_str() before passing it to this constructor.
 440       */
 441       explicit
 442       basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
 443       : __istream_type(), _M_filebuf()
 444       {
 445         this->init(&_M_filebuf);
 446         this->open(__s, __mode);
 447       }
 448
 449       /**
 450        *  @brief  The destructor does nothing.
 451        *
 452        *  The file is closed by the filebuf object, not the formatting
 453        *  stream.
 454       */
 455       ~basic_ifstream()
 456       { }
 457
 458       // Members:
 459       /**
 460        *  @brief  Accessing the underlying buffer.
 461        *  @return  The current basic_filebuf buffer.
 462        *
 463        *  This hides both signatures of std::basic_ios::rdbuf().
 464       */
 465       __filebuf_type*
 466       rdbuf() const
 467       { return const_cast<__filebuf_type*>(&_M_filebuf); }
 468
 469       /**
 470        *  @brief  Wrapper to test for an open file.
 471        *  @return  @c rdbuf()->is_open()
 472       */
 473       bool
 474       is_open()
 475       { return _M_filebuf.is_open(); }
 476
 477       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 478       // 365. Lack of const-qualification in clause 27
 479       bool
 480       is_open() const
 481       { return _M_filebuf.is_open(); }
 482
 483       /**
 484        *  @brief  Opens an external file.
 485        *  @param  s  The name of the file.
 486        *  @param  mode  The open mode flags.
 487        *
 488        *  Calls @c std::basic_filebuf::open(s,mode|in).  If that function
 489        *  fails, @c failbit is set in the stream's error state.
 490        *
 491        *  Tip:  When using std::string to hold the filename, you must use
 492        *  .c_str() before passing it to this constructor.
 493       */
 494       void
 495       open(const char* __s, ios_base::openmode __mode = ios_base::in)
 496       {
 497         if (!_M_filebuf.open(__s, __mode | ios_base::in))
 498           this->setstate(ios_base::failbit);
 499         else
 500           // _GLIBCXX_RESOLVE_LIB_DEFECTS
 501           // 409. Closing an fstream should clear error state
 502           this->clear();
 503       }
 504
 505       /**
 506        *  @brief  Close the file.
 507        *
 508        *  Calls @c std::basic_filebuf::close().  If that function
 509        *  fails, @c failbit is set in the stream's error state.
 510       */
 511       void
 512       close()
 513       {
 514         if (!_M_filebuf.close())
 515           this->setstate(ios_base::failbit);
 516       }
 517     };
 518
 519
 520   // [27.8.1.8] Template class basic_ofstream
 521   /**
 522    *  @brief  Controlling output for files.
 523    *
 524    *  This class supports reading from named files, using the inherited
 525    *  functions from std::basic_ostream.  To control the associated
 526    *  sequence, an instance of std::basic_filebuf is used, which this page
 527    *  refers to as @c sb.
 528   */
 529   template<typename _CharT, typename _Traits>
 530     class basic_ofstream : public basic_ostream<_CharT,_Traits>
 531     {
 532     public:
 533       // Types:
 534       typedef _CharT                                    char_type;
 535       typedef _Traits                                   traits_type;
 536       typedef typename traits_type::int_type            int_type;
 537       typedef typename traits_type::pos_type            pos_type;
 538       typedef typename traits_type::off_type            off_type;
 539
 540       // Non-standard types:
 541       typedef basic_filebuf<char_type, traits_type>     __filebuf_type;
 542       typedef basic_ostream<char_type, traits_type>     __ostream_type;
 543
 544     private:
 545       __filebuf_type    _M_filebuf;
 546
 547     public:
 548       // Constructors:
 549       /**
 550        *  @brief  Default constructor.
 551        *
 552        *  Initializes @c sb using its default constructor, and passes
 553        *  @c &sb to the base class initializer.  Does not open any files
 554        *  (you haven't given it a filename to open).
 555       */
 556       basic_ofstream(): __ostream_type(), _M_filebuf()
 557       { this->init(&_M_filebuf); }
 558
 559       /**
 560        *  @brief  Create an output file stream.
 561        *  @param  s  Null terminated string specifying the filename.
 562        *  @param  mode  Open file in specified mode (see std::ios_base).
 563        *
 564        *  @c ios_base::out|ios_base::trunc is automatically included in
 565        *  @a mode.
 566        *
 567        *  Tip:  When using std::string to hold the filename, you must use
 568        *  .c_str() before passing it to this constructor.
 569       */
 570       explicit
 571       basic_ofstream(const char* __s,
 572                      ios_base::openmode __mode = ios_base::out|ios_base::trunc)
 573       : __ostream_type(), _M_filebuf()
 574       {
 575         this->init(&_M_filebuf);
 576         this->open(__s, __mode);
 577       }
 578
 579       /**
 580        *  @brief  The destructor does nothing.
 581        *
 582        *  The file is closed by the filebuf object, not the formatting
 583        *  stream.
 584       */
 585       ~basic_ofstream()
 586       { }
 587
 588       // Members:
 589       /**
 590        *  @brief  Accessing the underlying buffer.
 591        *  @return  The current basic_filebuf buffer.
 592        *
 593        *  This hides both signatures of std::basic_ios::rdbuf().
 594       */
 595       __filebuf_type*
 596       rdbuf() const
 597       { return const_cast<__filebuf_type*>(&_M_filebuf); }
 598
 599       /**
 600        *  @brief  Wrapper to test for an open file.
 601        *  @return  @c rdbuf()->is_open()
 602       */
 603       bool
 604       is_open()
 605       { return _M_filebuf.is_open(); }
 606
 607       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 608       // 365. Lack of const-qualification in clause 27
 609       bool
 610       is_open() const
 611       { return _M_filebuf.is_open(); }
 612
 613       /**
 614        *  @brief  Opens an external file.
 615        *  @param  s  The name of the file.
 616        *  @param  mode  The open mode flags.
 617        *
 618        *  Calls @c std::basic_filebuf::open(s,mode|out|trunc).  If that
 619        *  function fails, @c failbit is set in the stream's error state.
 620        *
 621        *  Tip:  When using std::string to hold the filename, you must use
 622        *  .c_str() before passing it to this constructor.
 623       */
 624       void
 625       open(const char* __s,
 626            ios_base::openmode __mode = ios_base::out | ios_base::trunc)
 627       {
 628         if (!_M_filebuf.open(__s, __mode | ios_base::out))
 629           this->setstate(ios_base::failbit);
 630         else
 631           // _GLIBCXX_RESOLVE_LIB_DEFECTS
 632           // 409. Closing an fstream should clear error state
 633           this->clear();
 634       }
 635
 636       /**
 637        *  @brief  Close the file.
 638        *
 639        *  Calls @c std::basic_filebuf::close().  If that function
 640        *  fails, @c failbit is set in the stream's error state.
 641       */
 642       void
 643       close()
 644       {
 645         if (!_M_filebuf.close())
 646           this->setstate(ios_base::failbit);
 647       }
 648     };
 649
 650
 651   // [27.8.1.11] Template class basic_fstream
 652   /**
 653    *  @brief  Controlling intput and output for files.
 654    *
 655    *  This class supports reading from and writing to named files, using
 656    *  the inherited functions from std::basic_iostream.  To control the
 657    *  associated sequence, an instance of std::basic_filebuf is used, which
 658    *  this page refers to as @c sb.
 659   */
 660   template<typename _CharT, typename _Traits>
 661     class basic_fstream : public basic_iostream<_CharT, _Traits>
 662     {
 663     public:
 664       // Types:
 665       typedef _CharT                                    char_type;
 666       typedef _Traits                                   traits_type;
 667       typedef typename traits_type::int_type            int_type;
 668       typedef typename traits_type::pos_type            pos_type;
 669       typedef typename traits_type::off_type            off_type;
 670
 671       // Non-standard types:
 672       typedef basic_filebuf<char_type, traits_type>     __filebuf_type;
 673       typedef basic_ios<char_type, traits_type>         __ios_type;
 674       typedef basic_iostream<char_type, traits_type>    __iostream_type;
 675
 676     private:
 677       __filebuf_type    _M_filebuf;
 678
 679     public:
 680       // Constructors/destructor:
 681       /**
 682        *  @brief  Default constructor.
 683        *
 684        *  Initializes @c sb using its default constructor, and passes
 685        *  @c &sb to the base class initializer.  Does not open any files
 686        *  (you haven't given it a filename to open).
 687       */
 688       basic_fstream()
 689       : __iostream_type(), _M_filebuf()
 690       { this->init(&_M_filebuf); }
 691
 692       /**
 693        *  @brief  Create an input/output file stream.
 694        *  @param  s  Null terminated string specifying the filename.
 695        *  @param  mode  Open file in specified mode (see std::ios_base).
 696        *
 697        *  Tip:  When using std::string to hold the filename, you must use
 698        *  .c_str() before passing it to this constructor.
 699       */
 700       explicit
 701       basic_fstream(const char* __s,
 702                     ios_base::openmode __mode = ios_base::in | ios_base::out)
 703       : __iostream_type(NULL), _M_filebuf()
 704       {
 705         this->init(&_M_filebuf);
 706         this->open(__s, __mode);
 707       }
 708
 709       /**
 710        *  @brief  The destructor does nothing.
 711        *
 712        *  The file is closed by the filebuf object, not the formatting
 713        *  stream.
 714       */
 715       ~basic_fstream()
 716       { }
 717
 718       // Members:
 719       /**
 720        *  @brief  Accessing the underlying buffer.
 721        *  @return  The current basic_filebuf buffer.
 722        *
 723        *  This hides both signatures of std::basic_ios::rdbuf().
 724       */
 725       __filebuf_type*
 726       rdbuf() const
 727       { return const_cast<__filebuf_type*>(&_M_filebuf); }
 728
 729       /**
 730        *  @brief  Wrapper to test for an open file.
 731        *  @return  @c rdbuf()->is_open()
 732       */
 733       bool
 734       is_open()
 735       { return _M_filebuf.is_open(); }
 736
 737       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 738       // 365. Lack of const-qualification in clause 27
 739       bool
 740       is_open() const
 741       { return _M_filebuf.is_open(); }
 742
 743       /**
 744        *  @brief  Opens an external file.
 745        *  @param  s  The name of the file.
 746        *  @param  mode  The open mode flags.
 747        *
 748        *  Calls @c std::basic_filebuf::open(s,mode).  If that
 749        *  function fails, @c failbit is set in the stream's error state.
 750        *
 751        *  Tip:  When using std::string to hold the filename, you must use
 752        *  .c_str() before passing it to this constructor.
 753       */
 754       void
 755       open(const char* __s,
 756            ios_base::openmode __mode = ios_base::in | ios_base::out)
 757       {
 758         if (!_M_filebuf.open(__s, __mode))
 759           this->setstate(ios_base::failbit);
 760         else
 761           // _GLIBCXX_RESOLVE_LIB_DEFECTS
 762           // 409. Closing an fstream should clear error state
 763           this->clear();
 764       }
 765
 766       /**
 767        *  @brief  Close the file.
 768        *
 769        *  Calls @c std::basic_filebuf::close().  If that function
 770        *  fails, @c failbit is set in the stream's error state.
 771       */
 772       void
 773       close()
 774       {
 775         if (!_M_filebuf.close())
 776           this->setstate(ios_base::failbit);
 777       }
 778     };
 779 } // namespace std
 780
 781 #ifndef _GLIBCXX_EXPORT_TEMPLATE
 782 # include <bits/fstream.tcc>
 783 #endif
 784
 785 #endif /* _GLIBCXX_FSTREAM */