fstream source code [include/c++/7/fstream]

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