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