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