home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 April / PCWorld_2008-04_cd.bin / temacd / devc++ / devcpp-4.9.9.2_setup.exe / fstream < prev    next >
Text File  |  2005-01-29  |  25KB  |  844 lines
  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 */
  844.