Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // File based streams -*- C++ -*-
  2.  
  3. // Copyright (C) 1997-2015 Free Software Foundation, Inc.
  4. //
  5. // This file is part of the GNU ISO C++ Library.  This library is free
  6. // software; you can redistribute it and/or modify it under the
  7. // terms of the GNU General Public License as published by the
  8. // Free Software Foundation; either version 3, or (at your option)
  9. // any later version.
  10.  
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. // GNU General Public License for more details.
  15.  
  16. // Under Section 7 of GPL version 3, you are granted additional
  17. // permissions described in the GCC Runtime Library Exception, version
  18. // 3.1, as published by the Free Software Foundation.
  19.  
  20. // You should have received a copy of the GNU General Public License and
  21. // a copy of the GCC Runtime Library Exception along with this program;
  22. // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23. // <http://www.gnu.org/licenses/>.
  24.  
  25. /** @file include/fstream
  26.  *  This is a Standard C++ Library header.
  27.  */
  28.  
  29. //
  30. // ISO C++ 14882: 27.8  File-based streams
  31. //
  32.  
  33. #ifndef _GLIBCXX_FSTREAM
  34. #define _GLIBCXX_FSTREAM 1
  35.  
  36. #pragma GCC system_header
  37.  
  38. #include <istream>
  39. #include <ostream>
  40. #include <bits/codecvt.h>
  41. #include <cstdio>             // For BUFSIZ
  42. #include <bits/basic_file.h>  // For __basic_file, __c_lock
  43. #if __cplusplus >= 201103L
  44. #include <string>             // For std::string overloads.
  45. #endif
  46.  
  47. namespace std _GLIBCXX_VISIBILITY(default)
  48. {
  49. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  50.  
  51.   // [27.8.1.1] template class basic_filebuf
  52.   /**
  53.    *  @brief  The actual work of input and output (for files).
  54.    *  @ingroup io
  55.    *
  56.    *  @tparam _CharT  Type of character stream.
  57.    *  @tparam _Traits  Traits for character type, defaults to
  58.    *                   char_traits<_CharT>.
  59.    *
  60.    *  This class associates both its input and output sequence with an
  61.    *  external disk file, and maintains a joint file position for both
  62.    *  sequences.  Many of its semantics are described in terms of similar
  63.    *  behavior in the Standard C Library's @c FILE streams.
  64.    *
  65.    *  Requirements on traits_type, specific to this class:
  66.    *  - traits_type::pos_type must be fpos<traits_type::state_type>
  67.    *  - traits_type::off_type must be streamoff
  68.    *  - traits_type::state_type must be Assignable and DefaultConstructible,
  69.    *  - traits_type::state_type() must be the initial state for codecvt.
  70.    */
  71.   template<typename _CharT, typename _Traits>
  72.     class basic_filebuf : public basic_streambuf<_CharT, _Traits>
  73.     {
  74. #if __cplusplus >= 201103L
  75.       template<typename _Tp>
  76.         using __chk_state = __and_<is_copy_assignable<_Tp>,
  77.                                    is_copy_constructible<_Tp>,
  78.                                    is_default_constructible<_Tp>>;
  79.  
  80.       static_assert(__chk_state<typename _Traits::state_type>::value,
  81.                     "state_type must be CopyAssignable, CopyConstructible"
  82.                     " and DefaultConstructible");
  83.  
  84.       static_assert(is_same<typename _Traits::pos_type,
  85.                             fpos<typename _Traits::state_type>>::value,
  86.                     "pos_type must be fpos<state_type>");
  87. #endif
  88.     public:
  89.       // Types:
  90.       typedef _CharT                                    char_type;
  91.       typedef _Traits                                   traits_type;
  92.       typedef typename traits_type::int_type            int_type;
  93.       typedef typename traits_type::pos_type            pos_type;
  94.       typedef typename traits_type::off_type            off_type;
  95.  
  96.       typedef basic_streambuf<char_type, traits_type>   __streambuf_type;
  97.       typedef basic_filebuf<char_type, traits_type>     __filebuf_type;
  98.       typedef __basic_file<char>                        __file_type;
  99.       typedef typename traits_type::state_type          __state_type;
  100.       typedef codecvt<char_type, char, __state_type>    __codecvt_type;
  101.  
  102.       friend class ios_base; // For sync_with_stdio.
  103.  
  104.     protected:
  105.       // Data Members:
  106.       // MT lock inherited from libio or other low-level io library.
  107.       __c_lock                  _M_lock;
  108.  
  109.       // External buffer.
  110.       __file_type               _M_file;
  111.  
  112.       /// Place to stash in || out || in | out settings for current filebuf.
  113.       ios_base::openmode        _M_mode;
  114.  
  115.       // Beginning state type for codecvt.
  116.       __state_type              _M_state_beg;
  117.  
  118.       // During output, the state that corresponds to pptr(),
  119.       // during input, the state that corresponds to egptr() and
  120.       // _M_ext_next.
  121.       __state_type              _M_state_cur;
  122.  
  123.       // Not used for output. During input, the state that corresponds
  124.       // to eback() and _M_ext_buf.
  125.       __state_type              _M_state_last;
  126.  
  127.       /// Pointer to the beginning of internal buffer.
  128.       char_type*                _M_buf;
  129.  
  130.       /**
  131.        *  Actual size of internal buffer. This number is equal to the size
  132.        *  of the put area + 1 position, reserved for the overflow char of
  133.        *  a full area.
  134.        */
  135.       size_t                    _M_buf_size;
  136.  
  137.       // Set iff _M_buf is allocated memory from _M_allocate_internal_buffer.
  138.       bool                      _M_buf_allocated;
  139.  
  140.       /**
  141.        *  _M_reading == false && _M_writing == false for @b uncommitted mode;
  142.        *  _M_reading == true for @b read mode;
  143.        *  _M_writing == true for @b write mode;
  144.        *
  145.        *  NB: _M_reading == true && _M_writing == true is unused.
  146.        */
  147.       bool                      _M_reading;
  148.       bool                      _M_writing;
  149.  
  150.       //@{
  151.       /**
  152.        *  Necessary bits for putback buffer management.
  153.        *
  154.        *  @note pbacks of over one character are not currently supported.
  155.        */
  156.       char_type                 _M_pback;
  157.       char_type*                _M_pback_cur_save;
  158.       char_type*                _M_pback_end_save;
  159.       bool                      _M_pback_init;
  160.       //@}
  161.  
  162.       // Cached codecvt facet.
  163.       const __codecvt_type*     _M_codecvt;
  164.  
  165.       /**
  166.        *  Buffer for external characters. Used for input when
  167.        *  codecvt::always_noconv() == false. When valid, this corresponds
  168.        *  to eback().
  169.        */
  170.       char*                     _M_ext_buf;
  171.  
  172.       /**
  173.        *  Size of buffer held by _M_ext_buf.
  174.        */
  175.       streamsize                _M_ext_buf_size;
  176.  
  177.       /**
  178.        *  Pointers into the buffer held by _M_ext_buf that delimit a
  179.        *  subsequence of bytes that have been read but not yet converted.
  180.        *  When valid, _M_ext_next corresponds to egptr().
  181.        */
  182.       const char*               _M_ext_next;
  183.       char*                     _M_ext_end;
  184.  
  185.       /**
  186.        *  Initializes pback buffers, and moves normal buffers to safety.
  187.        *  Assumptions:
  188.        *  _M_in_cur has already been moved back
  189.        */
  190.       void
  191.       _M_create_pback()
  192.       {
  193.         if (!_M_pback_init)
  194.           {
  195.             _M_pback_cur_save = this->gptr();
  196.             _M_pback_end_save = this->egptr();
  197.             this->setg(&_M_pback, &_M_pback, &_M_pback + 1);
  198.             _M_pback_init = true;
  199.           }
  200.       }
  201.  
  202.       /**
  203.        *  Deactivates pback buffer contents, and restores normal buffer.
  204.        *  Assumptions:
  205.        *  The pback buffer has only moved forward.
  206.        */
  207.       void
  208.       _M_destroy_pback() throw()
  209.       {
  210.         if (_M_pback_init)
  211.           {
  212.             // Length _M_in_cur moved in the pback buffer.
  213.             _M_pback_cur_save += this->gptr() != this->eback();
  214.             this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save);
  215.             _M_pback_init = false;
  216.           }
  217.       }
  218.  
  219.     public:
  220.       // Constructors/destructor:
  221.       /**
  222.        *  @brief  Does not open any files.
  223.        *
  224.        *  The default constructor initializes the parent class using its
  225.        *  own default ctor.
  226.        */
  227.       basic_filebuf();
  228.  
  229. #if __cplusplus >= 201103L
  230.       basic_filebuf(const basic_filebuf&) = delete;
  231.       basic_filebuf(basic_filebuf&&);
  232. #endif
  233.  
  234.       /**
  235.        *  @brief  The destructor closes the file first.
  236.        */
  237.       virtual
  238.       ~basic_filebuf()
  239.       { this->close(); }
  240.  
  241. #if __cplusplus >= 201103L
  242.       basic_filebuf& operator=(const basic_filebuf&) = delete;
  243.       basic_filebuf& operator=(basic_filebuf&&);
  244.       void swap(basic_filebuf&);
  245. #endif
  246.  
  247.       // Members:
  248.       /**
  249.        *  @brief  Returns true if the external file is open.
  250.        */
  251.       bool
  252.       is_open() const throw()
  253.       { return _M_file.is_open(); }
  254.  
  255.       /**
  256.        *  @brief  Opens an external file.
  257.        *  @param  __s  The name of the file.
  258.        *  @param  __mode  The open mode flags.
  259.        *  @return  @c this on success, NULL on failure
  260.        *
  261.        *  If a file is already open, this function immediately fails.
  262.        *  Otherwise it tries to open the file named @a __s using the flags
  263.        *  given in @a __mode.
  264.        *
  265.        *  Table 92, adapted here, gives the relation between openmode
  266.        *  combinations and the equivalent @c fopen() flags.
  267.        *  (NB: lines app, in|out|app, in|app, binary|app, binary|in|out|app,
  268.        *  and binary|in|app per DR 596)
  269.        *  <pre>
  270.        *  +---------------------------------------------------------+
  271.        *  | ios_base Flag combination            stdio equivalent   |
  272.        *  |binary  in  out  trunc  app                              |
  273.        *  +---------------------------------------------------------+
  274.        *  |             +                        w                  |
  275.        *  |             +           +            a                  |
  276.        *  |                         +            a                  |
  277.        *  |             +     +                  w                  |
  278.        *  |         +                            r                  |
  279.        *  |         +   +                        r+                 |
  280.        *  |         +   +     +                  w+                 |
  281.        *  |         +   +           +            a+                 |
  282.        *  |         +               +            a+                 |
  283.        *  +---------------------------------------------------------+
  284.        *  |   +         +                        wb                 |
  285.        *  |   +         +           +            ab                 |
  286.        *  |   +                     +            ab                 |
  287.        *  |   +         +     +                  wb                 |
  288.        *  |   +     +                            rb                 |
  289.        *  |   +     +   +                        r+b                |
  290.        *  |   +     +   +     +                  w+b                |
  291.        *  |   +     +   +           +            a+b                |
  292.        *  |   +     +               +            a+b                |
  293.        *  +---------------------------------------------------------+
  294.        *  </pre>
  295.        */
  296.       __filebuf_type*
  297.       open(const char* __s, ios_base::openmode __mode);
  298.  
  299. #if __cplusplus >= 201103L
  300.       /**
  301.        *  @brief  Opens an external file.
  302.        *  @param  __s  The name of the file.
  303.        *  @param  __mode  The open mode flags.
  304.        *  @return  @c this on success, NULL on failure
  305.        */
  306.       __filebuf_type*
  307.       open(const std::string& __s, ios_base::openmode __mode)
  308.       { return open(__s.c_str(), __mode); }
  309. #endif
  310.  
  311.       /**
  312.        *  @brief  Closes the currently associated file.
  313.        *  @return  @c this on success, NULL on failure
  314.        *
  315.        *  If no file is currently open, this function immediately fails.
  316.        *
  317.        *  If a <em>put buffer area</em> exists, @c overflow(eof) is
  318.        *  called to flush all the characters.  The file is then
  319.        *  closed.
  320.        *
  321.        *  If any operations fail, this function also fails.
  322.        */
  323.       __filebuf_type*
  324.       close();
  325.  
  326.     protected:
  327.       void
  328.       _M_allocate_internal_buffer();
  329.  
  330.       void
  331.       _M_destroy_internal_buffer() throw();
  332.  
  333.       // [27.8.1.4] overridden virtual functions
  334.       virtual streamsize
  335.       showmanyc();
  336.  
  337.       // Stroustrup, 1998, p. 628
  338.       // underflow() and uflow() functions are called to get the next
  339.       // character from the real input source when the buffer is empty.
  340.       // Buffered input uses underflow()
  341.  
  342.       virtual int_type
  343.       underflow();
  344.  
  345.       virtual int_type
  346.       pbackfail(int_type __c = _Traits::eof());
  347.  
  348.       // Stroustrup, 1998, p 648
  349.       // The overflow() function is called to transfer characters to the
  350.       // real output destination when the buffer is full. A call to
  351.       // overflow(c) outputs the contents of the buffer plus the
  352.       // character c.
  353.       // 27.5.2.4.5
  354.       // Consume some sequence of the characters in the pending sequence.
  355.       virtual int_type
  356.       overflow(int_type __c = _Traits::eof());
  357.  
  358.       // Convert internal byte sequence to external, char-based
  359.       // sequence via codecvt.
  360.       bool
  361.       _M_convert_to_external(char_type*, streamsize);
  362.  
  363.       /**
  364.        *  @brief  Manipulates the buffer.
  365.        *  @param  __s  Pointer to a buffer area.
  366.        *  @param  __n  Size of @a __s.
  367.        *  @return  @c this
  368.        *
  369.        *  If no file has been opened, and both @a __s and @a __n are zero, then
  370.        *  the stream becomes unbuffered.  Otherwise, @c __s is used as a
  371.        *  buffer; see
  372.        *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering
  373.        *  for more.
  374.        */
  375.       virtual __streambuf_type*
  376.       setbuf(char_type* __s, streamsize __n);
  377.  
  378.       virtual pos_type
  379.       seekoff(off_type __off, ios_base::seekdir __way,
  380.               ios_base::openmode __mode = ios_base::in | ios_base::out);
  381.  
  382.       virtual pos_type
  383.       seekpos(pos_type __pos,
  384.               ios_base::openmode __mode = ios_base::in | ios_base::out);
  385.  
  386.       // Common code for seekoff, seekpos, and overflow
  387.       pos_type
  388.       _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);
  389.      
  390.       int
  391.       _M_get_ext_pos(__state_type &__state);
  392.  
  393.       virtual int
  394.       sync();
  395.  
  396.       virtual void
  397.       imbue(const locale& __loc);
  398.  
  399.       virtual streamsize
  400.       xsgetn(char_type* __s, streamsize __n);
  401.  
  402.       virtual streamsize
  403.       xsputn(const char_type* __s, streamsize __n);
  404.  
  405.       // Flushes output buffer, then writes unshift sequence.
  406.       bool
  407.       _M_terminate_output();
  408.  
  409.       /**
  410.        *  This function sets the pointers of the internal buffer, both get
  411.        *  and put areas. Typically:
  412.        *
  413.        *   __off == egptr() - eback() upon underflow/uflow (@b read mode);
  414.        *   __off == 0 upon overflow (@b write mode);
  415.        *   __off == -1 upon open, setbuf, seekoff/pos (@b uncommitted mode).
  416.        *
  417.        *  NB: epptr() - pbase() == _M_buf_size - 1, since _M_buf_size
  418.        *  reflects the actual allocated memory and the last cell is reserved
  419.        *  for the overflow char of a full put area.
  420.        */
  421.       void
  422.       _M_set_buffer(streamsize __off)
  423.       {
  424.         const bool __testin = _M_mode & ios_base::in;
  425.         const bool __testout = (_M_mode & ios_base::out
  426.                                 || _M_mode & ios_base::app);
  427.  
  428.         if (__testin && __off > 0)
  429.           this->setg(_M_buf, _M_buf, _M_buf + __off);
  430.         else
  431.           this->setg(_M_buf, _M_buf, _M_buf);
  432.  
  433.         if (__testout && __off == 0 && _M_buf_size > 1 )
  434.           this->setp(_M_buf, _M_buf + _M_buf_size - 1);
  435.         else
  436.           this->setp(0, 0);
  437.       }
  438.     };
  439.  
  440.   // [27.8.1.5] Template class basic_ifstream
  441.   /**
  442.    *  @brief  Controlling input for files.
  443.    *  @ingroup io
  444.    *
  445.    *  @tparam _CharT  Type of character stream.
  446.    *  @tparam _Traits  Traits for character type, defaults to
  447.    *                   char_traits<_CharT>.
  448.    *
  449.    *  This class supports reading from named files, using the inherited
  450.    *  functions from std::basic_istream.  To control the associated
  451.    *  sequence, an instance of std::basic_filebuf is used, which this page
  452.    *  refers to as @c sb.
  453.    */
  454.   template<typename _CharT, typename _Traits>
  455.     class basic_ifstream : public basic_istream<_CharT, _Traits>
  456.     {
  457.     public:
  458.       // Types:
  459.       typedef _CharT                                    char_type;
  460.       typedef _Traits                                   traits_type;
  461.       typedef typename traits_type::int_type            int_type;
  462.       typedef typename traits_type::pos_type            pos_type;
  463.       typedef typename traits_type::off_type            off_type;
  464.  
  465.       // Non-standard types:
  466.       typedef basic_filebuf<char_type, traits_type>     __filebuf_type;
  467.       typedef basic_istream<char_type, traits_type>     __istream_type;
  468.  
  469.     private:
  470.       __filebuf_type    _M_filebuf;
  471.  
  472.     public:
  473.       // Constructors/Destructors:
  474.       /**
  475.        *  @brief  Default constructor.
  476.        *
  477.        *  Initializes @c sb using its default constructor, and passes
  478.        *  @c &sb to the base class initializer.  Does not open any files
  479.        *  (you haven't given it a filename to open).
  480.        */
  481.       basic_ifstream() : __istream_type(), _M_filebuf()
  482.       { this->init(&_M_filebuf); }
  483.  
  484.       /**
  485.        *  @brief  Create an input file stream.
  486.        *  @param  __s  Null terminated string specifying the filename.
  487.        *  @param  __mode  Open file in specified mode (see std::ios_base).
  488.        *
  489.        *  @c ios_base::in is automatically included in @a __mode.
  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.       explicit
  495.       basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
  496.       : __istream_type(), _M_filebuf()
  497.       {
  498.         this->init(&_M_filebuf);
  499.         this->open(__s, __mode);
  500.       }
  501.  
  502. #if __cplusplus >= 201103L
  503.       /**
  504.        *  @brief  Create an input file stream.
  505.        *  @param  __s  std::string specifying the filename.
  506.        *  @param  __mode  Open file in specified mode (see std::ios_base).
  507.        *
  508.        *  @c ios_base::in is automatically included in @a __mode.
  509.        */
  510.       explicit
  511.       basic_ifstream(const std::string& __s,
  512.                      ios_base::openmode __mode = ios_base::in)
  513.       : __istream_type(), _M_filebuf()
  514.       {
  515.         this->init(&_M_filebuf);
  516.         this->open(__s, __mode);
  517.       }
  518.  
  519.       basic_ifstream(const basic_ifstream&) = delete;
  520.  
  521.       basic_ifstream(basic_ifstream&& __rhs)
  522.       : __istream_type(std::move(__rhs)),
  523.       _M_filebuf(std::move(__rhs._M_filebuf))
  524.       { __istream_type::set_rdbuf(&_M_filebuf); }
  525. #endif
  526.  
  527.       /**
  528.        *  @brief  The destructor does nothing.
  529.        *
  530.        *  The file is closed by the filebuf object, not the formatting
  531.        *  stream.
  532.        */
  533.       ~basic_ifstream()
  534.       { }
  535.  
  536. #if __cplusplus >= 201103L
  537.       // 27.8.3.2 Assign and swap:
  538.  
  539.       basic_ifstream&
  540.       operator=(const basic_ifstream&) = delete;
  541.  
  542.       basic_ifstream&
  543.       operator=(basic_ifstream&& __rhs)
  544.       {
  545.         __istream_type::operator=(std::move(__rhs));
  546.         _M_filebuf = std::move(__rhs._M_filebuf);
  547.         return *this;
  548.       }
  549.  
  550.       void
  551.       swap(basic_ifstream& __rhs)
  552.       {
  553.         __istream_type::swap(__rhs);
  554.         _M_filebuf.swap(__rhs._M_filebuf);
  555.       }
  556. #endif
  557.  
  558.       // Members:
  559.       /**
  560.        *  @brief  Accessing the underlying buffer.
  561.        *  @return  The current basic_filebuf buffer.
  562.        *
  563.        *  This hides both signatures of std::basic_ios::rdbuf().
  564.        */
  565.       __filebuf_type*
  566.       rdbuf() const
  567.       { return const_cast<__filebuf_type*>(&_M_filebuf); }
  568.  
  569.       /**
  570.        *  @brief  Wrapper to test for an open file.
  571.        *  @return  @c rdbuf()->is_open()
  572.        */
  573.       bool
  574.       is_open()
  575.       { return _M_filebuf.is_open(); }
  576.  
  577.       // _GLIBCXX_RESOLVE_LIB_DEFECTS
  578.       // 365. Lack of const-qualification in clause 27
  579.       bool
  580.       is_open() const
  581.       { return _M_filebuf.is_open(); }
  582.  
  583.       /**
  584.        *  @brief  Opens an external file.
  585.        *  @param  __s  The name of the file.
  586.        *  @param  __mode  The open mode flags.
  587.        *
  588.        *  Calls @c std::basic_filebuf::open(s,__mode|in).  If that function
  589.        *  fails, @c failbit is set in the stream's error state.
  590.        *
  591.        *  Tip:  When using std::string to hold the filename, you must use
  592.        *  .c_str() before passing it to this constructor.
  593.        */
  594.       void
  595.       open(const char* __s, ios_base::openmode __mode = ios_base::in)
  596.       {
  597.         if (!_M_filebuf.open(__s, __mode | ios_base::in))
  598.           this->setstate(ios_base::failbit);
  599.         else
  600.           // _GLIBCXX_RESOLVE_LIB_DEFECTS
  601.           // 409. Closing an fstream should clear error state
  602.           this->clear();
  603.       }
  604.  
  605. #if __cplusplus >= 201103L
  606.       /**
  607.        *  @brief  Opens an external file.
  608.        *  @param  __s  The name of the file.
  609.        *  @param  __mode  The open mode flags.
  610.        *
  611.        *  Calls @c std::basic_filebuf::open(__s,__mode|in).  If that function
  612.        *  fails, @c failbit is set in the stream's error state.
  613.        */
  614.       void
  615.       open(const std::string& __s, ios_base::openmode __mode = ios_base::in)
  616.       {
  617.         if (!_M_filebuf.open(__s, __mode | ios_base::in))
  618.           this->setstate(ios_base::failbit);
  619.         else
  620.           // _GLIBCXX_RESOLVE_LIB_DEFECTS
  621.           // 409. Closing an fstream should clear error state
  622.           this->clear();
  623.       }
  624. #endif
  625.  
  626.       /**
  627.        *  @brief  Close the file.
  628.        *
  629.        *  Calls @c std::basic_filebuf::close().  If that function
  630.        *  fails, @c failbit is set in the stream's error state.
  631.        */
  632.       void
  633.       close()
  634.       {
  635.         if (!_M_filebuf.close())
  636.           this->setstate(ios_base::failbit);
  637.       }
  638.     };
  639.  
  640.  
  641.   // [27.8.1.8] Template class basic_ofstream
  642.   /**
  643.    *  @brief  Controlling output for files.
  644.    *  @ingroup io
  645.    *
  646.    *  @tparam _CharT  Type of character stream.
  647.    *  @tparam _Traits  Traits for character type, defaults to
  648.    *                   char_traits<_CharT>.
  649.    *
  650.    *  This class supports reading from named files, using the inherited
  651.    *  functions from std::basic_ostream.  To control the associated
  652.    *  sequence, an instance of std::basic_filebuf is used, which this page
  653.    *  refers to as @c sb.
  654.    */
  655.   template<typename _CharT, typename _Traits>
  656.     class basic_ofstream : public basic_ostream<_CharT,_Traits>
  657.     {
  658.     public:
  659.       // Types:
  660.       typedef _CharT                                    char_type;
  661.       typedef _Traits                                   traits_type;
  662.       typedef typename traits_type::int_type            int_type;
  663.       typedef typename traits_type::pos_type            pos_type;
  664.       typedef typename traits_type::off_type            off_type;
  665.  
  666.       // Non-standard types:
  667.       typedef basic_filebuf<char_type, traits_type>     __filebuf_type;
  668.       typedef basic_ostream<char_type, traits_type>     __ostream_type;
  669.  
  670.     private:
  671.       __filebuf_type    _M_filebuf;
  672.  
  673.     public:
  674.       // Constructors:
  675.       /**
  676.        *  @brief  Default constructor.
  677.        *
  678.        *  Initializes @c sb using its default constructor, and passes
  679.        *  @c &sb to the base class initializer.  Does not open any files
  680.        *  (you haven't given it a filename to open).
  681.        */
  682.       basic_ofstream(): __ostream_type(), _M_filebuf()
  683.       { this->init(&_M_filebuf); }
  684.  
  685.       /**
  686.        *  @brief  Create an output file stream.
  687.        *  @param  __s  Null terminated string specifying the filename.
  688.        *  @param  __mode  Open file in specified mode (see std::ios_base).
  689.        *
  690.        *  @c ios_base::out | @c ios_base::trunc is automatically included in
  691.        *  @a __mode.
  692.        *
  693.        *  Tip:  When using std::string to hold the filename, you must use
  694.        *  .c_str() before passing it to this constructor.
  695.        */
  696.       explicit
  697.       basic_ofstream(const char* __s,
  698.                      ios_base::openmode __mode = ios_base::out|ios_base::trunc)
  699.       : __ostream_type(), _M_filebuf()
  700.       {
  701.         this->init(&_M_filebuf);
  702.         this->open(__s, __mode);
  703.       }
  704.  
  705. #if __cplusplus >= 201103L
  706.       /**
  707.        *  @brief  Create an output file stream.
  708.        *  @param  __s  std::string specifying the filename.
  709.        *  @param  __mode  Open file in specified mode (see std::ios_base).
  710.        *
  711.        *  @c ios_base::out | @c ios_base::trunc is automatically included in
  712.        *  @a __mode.
  713.        */
  714.       explicit
  715.       basic_ofstream(const std::string& __s,
  716.                      ios_base::openmode __mode = ios_base::out|ios_base::trunc)
  717.       : __ostream_type(), _M_filebuf()
  718.       {
  719.         this->init(&_M_filebuf);
  720.         this->open(__s, __mode);
  721.       }
  722.  
  723.       basic_ofstream(const basic_ofstream&) = delete;
  724.  
  725.       basic_ofstream(basic_ofstream&& __rhs)
  726.       : __ostream_type(std::move(__rhs)),
  727.       _M_filebuf(std::move(__rhs._M_filebuf))
  728.       { __ostream_type::set_rdbuf(&_M_filebuf); }
  729. #endif
  730.  
  731.       /**
  732.        *  @brief  The destructor does nothing.
  733.        *
  734.        *  The file is closed by the filebuf object, not the formatting
  735.        *  stream.
  736.        */
  737.       ~basic_ofstream()
  738.       { }
  739.  
  740. #if __cplusplus >= 201103L
  741.       // 27.8.3.2 Assign and swap:
  742.  
  743.       basic_ofstream&
  744.       operator=(const basic_ofstream&) = delete;
  745.  
  746.       basic_ofstream&
  747.       operator=(basic_ofstream&& __rhs)
  748.       {
  749.         __ostream_type::operator=(std::move(__rhs));
  750.         _M_filebuf = std::move(__rhs._M_filebuf);
  751.         return *this;
  752.       }
  753.  
  754.       void
  755.       swap(basic_ofstream& __rhs)
  756.       {
  757.         __ostream_type::swap(__rhs);
  758.         _M_filebuf.swap(__rhs._M_filebuf);
  759.       }
  760. #endif
  761.  
  762.       // Members:
  763.       /**
  764.        *  @brief  Accessing the underlying buffer.
  765.        *  @return  The current basic_filebuf buffer.
  766.        *
  767.        *  This hides both signatures of std::basic_ios::rdbuf().
  768.        */
  769.       __filebuf_type*
  770.       rdbuf() const
  771.       { return const_cast<__filebuf_type*>(&_M_filebuf); }
  772.  
  773.       /**
  774.        *  @brief  Wrapper to test for an open file.
  775.        *  @return  @c rdbuf()->is_open()
  776.        */
  777.       bool
  778.       is_open()
  779.       { return _M_filebuf.is_open(); }
  780.  
  781.       // _GLIBCXX_RESOLVE_LIB_DEFECTS
  782.       // 365. Lack of const-qualification in clause 27
  783.       bool
  784.       is_open() const
  785.       { return _M_filebuf.is_open(); }
  786.  
  787.       /**
  788.        *  @brief  Opens an external file.
  789.        *  @param  __s  The name of the file.
  790.        *  @param  __mode  The open mode flags.
  791.        *
  792.        *  Calls @c std::basic_filebuf::open(__s,__mode|out|trunc).  If that
  793.        *  function fails, @c failbit is set in the stream's error state.
  794.        *
  795.        *  Tip:  When using std::string to hold the filename, you must use
  796.        *  .c_str() before passing it to this constructor.
  797.        */
  798.       void
  799.       open(const char* __s,
  800.            ios_base::openmode __mode = ios_base::out | ios_base::trunc)
  801.       {
  802.         if (!_M_filebuf.open(__s, __mode | ios_base::out))
  803.           this->setstate(ios_base::failbit);
  804.         else
  805.           // _GLIBCXX_RESOLVE_LIB_DEFECTS
  806.           // 409. Closing an fstream should clear error state
  807.           this->clear();
  808.       }
  809.  
  810. #if __cplusplus >= 201103L
  811.       /**
  812.        *  @brief  Opens an external file.
  813.        *  @param  __s  The name of the file.
  814.        *  @param  __mode  The open mode flags.
  815.        *
  816.        *  Calls @c std::basic_filebuf::open(s,mode|out|trunc).  If that
  817.        *  function fails, @c failbit is set in the stream's error state.
  818.        */
  819.       void
  820.       open(const std::string& __s,
  821.            ios_base::openmode __mode = ios_base::out | ios_base::trunc)
  822.       {
  823.         if (!_M_filebuf.open(__s, __mode | ios_base::out))
  824.           this->setstate(ios_base::failbit);
  825.         else
  826.           // _GLIBCXX_RESOLVE_LIB_DEFECTS
  827.           // 409. Closing an fstream should clear error state
  828.           this->clear();
  829.       }
  830. #endif
  831.  
  832.       /**
  833.        *  @brief  Close the file.
  834.        *
  835.        *  Calls @c std::basic_filebuf::close().  If that function
  836.        *  fails, @c failbit is set in the stream's error state.
  837.        */
  838.       void
  839.       close()
  840.       {
  841.         if (!_M_filebuf.close())
  842.           this->setstate(ios_base::failbit);
  843.       }
  844.     };
  845.  
  846.  
  847.   // [27.8.1.11] Template class basic_fstream
  848.   /**
  849.    *  @brief  Controlling input and output for files.
  850.    *  @ingroup io
  851.    *
  852.    *  @tparam _CharT  Type of character stream.
  853.    *  @tparam _Traits  Traits for character type, defaults to
  854.    *                   char_traits<_CharT>.
  855.    *
  856.    *  This class supports reading from and writing to named files, using
  857.    *  the inherited functions from std::basic_iostream.  To control the
  858.    *  associated sequence, an instance of std::basic_filebuf is used, which
  859.    *  this page refers to as @c sb.
  860.    */
  861.   template<typename _CharT, typename _Traits>
  862.     class basic_fstream : public basic_iostream<_CharT, _Traits>
  863.     {
  864.     public:
  865.       // Types:
  866.       typedef _CharT                                    char_type;
  867.       typedef _Traits                                   traits_type;
  868.       typedef typename traits_type::int_type            int_type;
  869.       typedef typename traits_type::pos_type            pos_type;
  870.       typedef typename traits_type::off_type            off_type;
  871.  
  872.       // Non-standard types:
  873.       typedef basic_filebuf<char_type, traits_type>     __filebuf_type;
  874.       typedef basic_ios<char_type, traits_type>         __ios_type;
  875.       typedef basic_iostream<char_type, traits_type>    __iostream_type;
  876.  
  877.     private:
  878.       __filebuf_type    _M_filebuf;
  879.  
  880.     public:
  881.       // Constructors/destructor:
  882.       /**
  883.        *  @brief  Default constructor.
  884.        *
  885.        *  Initializes @c sb using its default constructor, and passes
  886.        *  @c &sb to the base class initializer.  Does not open any files
  887.        *  (you haven't given it a filename to open).
  888.        */
  889.       basic_fstream()
  890.       : __iostream_type(), _M_filebuf()
  891.       { this->init(&_M_filebuf); }
  892.  
  893.       /**
  894.        *  @brief  Create an input/output file stream.
  895.        *  @param  __s  Null terminated string specifying the filename.
  896.        *  @param  __mode  Open file in specified mode (see std::ios_base).
  897.        *
  898.        *  Tip:  When using std::string to hold the filename, you must use
  899.        *  .c_str() before passing it to this constructor.
  900.        */
  901.       explicit
  902.       basic_fstream(const char* __s,
  903.                     ios_base::openmode __mode = ios_base::in | ios_base::out)
  904.       : __iostream_type(0), _M_filebuf()
  905.       {
  906.         this->init(&_M_filebuf);
  907.         this->open(__s, __mode);
  908.       }
  909.  
  910. #if __cplusplus >= 201103L
  911.       /**
  912.        *  @brief  Create an input/output file stream.
  913.        *  @param  __s  Null terminated string specifying the filename.
  914.        *  @param  __mode  Open file in specified mode (see std::ios_base).
  915.        */
  916.       explicit
  917.       basic_fstream(const std::string& __s,
  918.                     ios_base::openmode __mode = ios_base::in | ios_base::out)
  919.       : __iostream_type(0), _M_filebuf()
  920.       {
  921.         this->init(&_M_filebuf);
  922.         this->open(__s, __mode);
  923.       }
  924.  
  925.       basic_fstream(const basic_fstream&) = delete;
  926.  
  927.       basic_fstream(basic_fstream&& __rhs)
  928.       : __iostream_type(std::move(__rhs)),
  929.       _M_filebuf(std::move(__rhs._M_filebuf))
  930.       { __iostream_type::set_rdbuf(&_M_filebuf); }
  931. #endif
  932.  
  933.       /**
  934.        *  @brief  The destructor does nothing.
  935.        *
  936.        *  The file is closed by the filebuf object, not the formatting
  937.        *  stream.
  938.        */
  939.       ~basic_fstream()
  940.       { }
  941.  
  942. #if __cplusplus >= 201103L
  943.       // 27.8.3.2 Assign and swap:
  944.  
  945.       basic_fstream&
  946.       operator=(const basic_fstream&) = delete;
  947.  
  948.       basic_fstream&
  949.       operator=(basic_fstream&& __rhs)
  950.       {
  951.         __iostream_type::operator=(std::move(__rhs));
  952.         _M_filebuf = std::move(__rhs._M_filebuf);
  953.         return *this;
  954.       }
  955.  
  956.       void
  957.       swap(basic_fstream& __rhs)
  958.       {
  959.         __iostream_type::swap(__rhs);
  960.         _M_filebuf.swap(__rhs._M_filebuf);
  961.       }
  962. #endif
  963.  
  964.       // Members:
  965.       /**
  966.        *  @brief  Accessing the underlying buffer.
  967.        *  @return  The current basic_filebuf buffer.
  968.        *
  969.        *  This hides both signatures of std::basic_ios::rdbuf().
  970.        */
  971.       __filebuf_type*
  972.       rdbuf() const
  973.       { return const_cast<__filebuf_type*>(&_M_filebuf); }
  974.  
  975.       /**
  976.        *  @brief  Wrapper to test for an open file.
  977.        *  @return  @c rdbuf()->is_open()
  978.        */
  979.       bool
  980.       is_open()
  981.       { return _M_filebuf.is_open(); }
  982.  
  983.       // _GLIBCXX_RESOLVE_LIB_DEFECTS
  984.       // 365. Lack of const-qualification in clause 27
  985.       bool
  986.       is_open() const
  987.       { return _M_filebuf.is_open(); }
  988.  
  989.       /**
  990.        *  @brief  Opens an external file.
  991.        *  @param  __s  The name of the file.
  992.        *  @param  __mode  The open mode flags.
  993.        *
  994.        *  Calls @c std::basic_filebuf::open(__s,__mode).  If that
  995.        *  function fails, @c failbit is set in the stream's error state.
  996.        *
  997.        *  Tip:  When using std::string to hold the filename, you must use
  998.        *  .c_str() before passing it to this constructor.
  999.        */
  1000.       void
  1001.       open(const char* __s,
  1002.            ios_base::openmode __mode = ios_base::in | ios_base::out)
  1003.       {
  1004.         if (!_M_filebuf.open(__s, __mode))
  1005.           this->setstate(ios_base::failbit);
  1006.         else
  1007.           // _GLIBCXX_RESOLVE_LIB_DEFECTS
  1008.           // 409. Closing an fstream should clear error state
  1009.           this->clear();
  1010.       }
  1011.  
  1012. #if __cplusplus >= 201103L
  1013.       /**
  1014.        *  @brief  Opens an external file.
  1015.        *  @param  __s  The name of the file.
  1016.        *  @param  __mode  The open mode flags.
  1017.        *
  1018.        *  Calls @c std::basic_filebuf::open(__s,__mode).  If that
  1019.        *  function fails, @c failbit is set in the stream's error state.
  1020.        */
  1021.       void
  1022.       open(const std::string& __s,
  1023.            ios_base::openmode __mode = ios_base::in | ios_base::out)
  1024.       {
  1025.         if (!_M_filebuf.open(__s, __mode))
  1026.           this->setstate(ios_base::failbit);
  1027.         else
  1028.           // _GLIBCXX_RESOLVE_LIB_DEFECTS
  1029.           // 409. Closing an fstream should clear error state
  1030.           this->clear();
  1031.       }
  1032. #endif
  1033.  
  1034.       /**
  1035.        *  @brief  Close the file.
  1036.        *
  1037.        *  Calls @c std::basic_filebuf::close().  If that function
  1038.        *  fails, @c failbit is set in the stream's error state.
  1039.        */
  1040.       void
  1041.       close()
  1042.       {
  1043.         if (!_M_filebuf.close())
  1044.           this->setstate(ios_base::failbit);
  1045.       }
  1046.     };
  1047.  
  1048. #if __cplusplus >= 201103L
  1049.   /// Swap specialization for filebufs.
  1050.   template <class _CharT, class _Traits>
  1051.     inline void
  1052.     swap(basic_filebuf<_CharT, _Traits>& __x,
  1053.          basic_filebuf<_CharT, _Traits>& __y)
  1054.     { __x.swap(__y); }
  1055.  
  1056.   /// Swap specialization for ifstreams.
  1057.   template <class _CharT, class _Traits>
  1058.     inline void
  1059.     swap(basic_ifstream<_CharT, _Traits>& __x,
  1060.          basic_ifstream<_CharT, _Traits>& __y)
  1061.     { __x.swap(__y); }
  1062.  
  1063.   /// Swap specialization for ofstreams.
  1064.   template <class _CharT, class _Traits>
  1065.     inline void
  1066.     swap(basic_ofstream<_CharT, _Traits>& __x,
  1067.          basic_ofstream<_CharT, _Traits>& __y)
  1068.     { __x.swap(__y); }
  1069.  
  1070.   /// Swap specialization for fstreams.
  1071.   template <class _CharT, class _Traits>
  1072.     inline void
  1073.     swap(basic_fstream<_CharT, _Traits>& __x,
  1074.          basic_fstream<_CharT, _Traits>& __y)
  1075.     { __x.swap(__y); }
  1076. #endif
  1077.  
  1078. _GLIBCXX_END_NAMESPACE_VERSION
  1079. } // namespace
  1080.  
  1081. #include <bits/fstream.tcc>
  1082.  
  1083. #endif /* _GLIBCXX_FSTREAM */
  1084.