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
47namespace 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