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

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