00001 // File based streams -*- C++ -*- 00002 00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 00004 // 2006, 2007, 2008, 2009 00005 // Free Software Foundation, Inc. 00006 // 00007 // This file is part of the GNU ISO C++ Library. This library is free 00008 // software; you can redistribute it and/or modify it under the 00009 // terms of the GNU General Public License as published by the 00010 // Free Software Foundation; either version 3, or (at your option) 00011 // any later version. 00012 00013 // This library is distributed in the hope that it will be useful, 00014 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00015 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00016 // GNU General Public License for more details. 00017 00018 // Under Section 7 of GPL version 3, you are granted additional 00019 // permissions described in the GCC Runtime Library Exception, version 00020 // 3.1, as published by the Free Software Foundation. 00021 00022 // You should have received a copy of the GNU General Public License and 00023 // a copy of the GCC Runtime Library Exception along with this program; 00024 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 00025 // <http://www.gnu.org/licenses/>. 00026 00027 /** @file fstream 00028 * This is a Standard C++ Library header. 00029 */ 00030 00031 // 00032 // ISO C++ 14882: 27.8 File-based streams 00033 // 00034 00035 #ifndef _GLIBCXX_FSTREAM 00036 #define _GLIBCXX_FSTREAM 1 00037 00038 #pragma GCC system_header 00039 00040 #include <istream> 00041 #include <ostream> 00042 #include <bits/codecvt.h> 00043 #include <cstdio> // For BUFSIZ 00044 #include <bits/basic_file.h> // For __basic_file, __c_lock 00045 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 00046 #include <string> // For std::string overloads. 00047 #endif 00048 00049 _GLIBCXX_BEGIN_NAMESPACE(std) 00050 00051 // [27.8.1.1] template class basic_filebuf 00052 /** 00053 * @brief The actual work of input and output (for files). 00054 * @ingroup io 00055 * 00056 * This class associates both its input and output sequence with an 00057 * external disk file, and maintains a joint file position for both 00058 * sequences. Many of its semantics are described in terms of similar 00059 * behavior in the Standard C Library's @c FILE streams. 00060 */ 00061 // Requirements on traits_type, specific to this class: 00062 // traits_type::pos_type must be fpos<traits_type::state_type> 00063 // traits_type::off_type must be streamoff 00064 // traits_type::state_type must be Assignable and DefaultConstructible, 00065 // and traits_type::state_type() must be the initial state for codecvt. 00066 template<typename _CharT, typename _Traits> 00067 class basic_filebuf : public basic_streambuf<_CharT, _Traits> 00068 { 00069 public: 00070 // Types: 00071 typedef _CharT char_type; 00072 typedef _Traits traits_type; 00073 typedef typename traits_type::int_type int_type; 00074 typedef typename traits_type::pos_type pos_type; 00075 typedef typename traits_type::off_type off_type; 00076 00077 typedef basic_streambuf<char_type, traits_type> __streambuf_type; 00078 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 00079 typedef __basic_file<char> __file_type; 00080 typedef typename traits_type::state_type __state_type; 00081 typedef codecvt<char_type, char, __state_type> __codecvt_type; 00082 00083 friend class ios_base; // For sync_with_stdio. 00084 00085 protected: 00086 // Data Members: 00087 // MT lock inherited from libio or other low-level io library. 00088 __c_lock _M_lock; 00089 00090 // External buffer. 00091 __file_type _M_file; 00092 00093 /// Place to stash in || out || in | out settings for current filebuf. 00094 ios_base::openmode _M_mode; 00095 00096 // Beginning state type for codecvt. 00097 __state_type _M_state_beg; 00098 00099 // During output, the state that corresponds to pptr(), 00100 // during input, the state that corresponds to egptr() and 00101 // _M_ext_next. 00102 __state_type _M_state_cur; 00103 00104 // Not used for output. During input, the state that corresponds 00105 // to eback() and _M_ext_buf. 00106 __state_type _M_state_last; 00107 00108 /// Pointer to the beginning of internal buffer. 00109 char_type* _M_buf; 00110 00111 /** 00112 * Actual size of internal buffer. This number is equal to the size 00113 * of the put area + 1 position, reserved for the overflow char of 00114 * a full area. 00115 */ 00116 size_t _M_buf_size; 00117 00118 // Set iff _M_buf is allocated memory from _M_allocate_internal_buffer. 00119 bool _M_buf_allocated; 00120 00121 /** 00122 * _M_reading == false && _M_writing == false for 'uncommitted' mode; 00123 * _M_reading == true for 'read' mode; 00124 * _M_writing == true for 'write' mode; 00125 * 00126 * NB: _M_reading == true && _M_writing == true is unused. 00127 */ 00128 bool _M_reading; 00129 bool _M_writing; 00130 00131 //@{ 00132 /** 00133 * Necessary bits for putback buffer management. 00134 * 00135 * @note pbacks of over one character are not currently supported. 00136 */ 00137 char_type _M_pback; 00138 char_type* _M_pback_cur_save; 00139 char_type* _M_pback_end_save; 00140 bool _M_pback_init; 00141 //@} 00142 00143 // Cached codecvt facet. 00144 const __codecvt_type* _M_codecvt; 00145 00146 /** 00147 * Buffer for external characters. Used for input when 00148 * codecvt::always_noconv() == false. When valid, this corresponds 00149 * to eback(). 00150 */ 00151 char* _M_ext_buf; 00152 00153 /** 00154 * Size of buffer held by _M_ext_buf. 00155 */ 00156 streamsize _M_ext_buf_size; 00157 00158 /** 00159 * Pointers into the buffer held by _M_ext_buf that delimit a 00160 * subsequence of bytes that have been read but not yet converted. 00161 * When valid, _M_ext_next corresponds to egptr(). 00162 */ 00163 const char* _M_ext_next; 00164 char* _M_ext_end; 00165 00166 /** 00167 * Initializes pback buffers, and moves normal buffers to safety. 00168 * Assumptions: 00169 * _M_in_cur has already been moved back 00170 */ 00171 void 00172 _M_create_pback() 00173 { 00174 if (!_M_pback_init) 00175 { 00176 _M_pback_cur_save = this->gptr(); 00177 _M_pback_end_save = this->egptr(); 00178 this->setg(&_M_pback, &_M_pback, &_M_pback + 1); 00179 _M_pback_init = true; 00180 } 00181 } 00182 00183 /** 00184 * Deactivates pback buffer contents, and restores normal buffer. 00185 * Assumptions: 00186 * The pback buffer has only moved forward. 00187 */ 00188 void 00189 _M_destroy_pback() throw() 00190 { 00191 if (_M_pback_init) 00192 { 00193 // Length _M_in_cur moved in the pback buffer. 00194 _M_pback_cur_save += this->gptr() != this->eback(); 00195 this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save); 00196 _M_pback_init = false; 00197 } 00198 } 00199 00200 public: 00201 // Constructors/destructor: 00202 /** 00203 * @brief Does not open any files. 00204 * 00205 * The default constructor initializes the parent class using its 00206 * own default ctor. 00207 */ 00208 basic_filebuf(); 00209 00210 /** 00211 * @brief The destructor closes the file first. 00212 */ 00213 virtual 00214 ~basic_filebuf() 00215 { this->close(); } 00216 00217 // Members: 00218 /** 00219 * @brief Returns true if the external file is open. 00220 */ 00221 bool 00222 is_open() const throw() 00223 { return _M_file.is_open(); } 00224 00225 /** 00226 * @brief Opens an external file. 00227 * @param s The name of the file. 00228 * @param mode The open mode flags. 00229 * @return @c this on success, NULL on failure 00230 * 00231 * If a file is already open, this function immediately fails. 00232 * Otherwise it tries to open the file named @a s using the flags 00233 * given in @a mode. 00234 * 00235 * Table 92, adapted here, gives the relation between openmode 00236 * combinations and the equivalent fopen() flags. 00237 * (NB: lines app, in|out|app, in|app, binary|app, binary|in|out|app, 00238 * and binary|in|app per DR 596) 00239 * +---------------------------------------------------------+ 00240 * | ios_base Flag combination stdio equivalent | 00241 * |binary in out trunc app | 00242 * +---------------------------------------------------------+ 00243 * | + "w" | 00244 * | + + "a" | 00245 * | + "a" | 00246 * | + + "w" | 00247 * | + "r" | 00248 * | + + "r+" | 00249 * | + + + "w+" | 00250 * | + + + "a+" | 00251 * | + + "a+" | 00252 * +---------------------------------------------------------+ 00253 * | + + "wb" | 00254 * | + + + "ab" | 00255 * | + + "ab" | 00256 * | + + + "wb" | 00257 * | + + "rb" | 00258 * | + + + "r+b" | 00259 * | + + + + "w+b" | 00260 * | + + + + "a+b" | 00261 * | + + + "a+b" | 00262 * +---------------------------------------------------------+ 00263 */ 00264 __filebuf_type* 00265 open(const char* __s, ios_base::openmode __mode); 00266 00267 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 00268 /** 00269 * @brief Opens an external file. 00270 * @param s The name of the file. 00271 * @param mode The open mode flags. 00272 * @return @c this on success, NULL on failure 00273 */ 00274 __filebuf_type* 00275 open(const std::string& __s, ios_base::openmode __mode) 00276 { return open(__s.c_str(), __mode); } 00277 #endif 00278 00279 /** 00280 * @brief Closes the currently associated file. 00281 * @return @c this on success, NULL on failure 00282 * 00283 * If no file is currently open, this function immediately fails. 00284 * 00285 * If a "put buffer area" exists, @c overflow(eof) is called to flush 00286 * all the characters. The file is then closed. 00287 * 00288 * If any operations fail, this function also fails. 00289 */ 00290 __filebuf_type* 00291 close(); 00292 00293 protected: 00294 void 00295 _M_allocate_internal_buffer(); 00296 00297 void 00298 _M_destroy_internal_buffer() throw(); 00299 00300 // [27.8.1.4] overridden virtual functions 00301 virtual streamsize 00302 showmanyc(); 00303 00304 // Stroustrup, 1998, p. 628 00305 // underflow() and uflow() functions are called to get the next 00306 // character from the real input source when the buffer is empty. 00307 // Buffered input uses underflow() 00308 00309 virtual int_type 00310 underflow(); 00311 00312 virtual int_type 00313 pbackfail(int_type __c = _Traits::eof()); 00314 00315 // Stroustrup, 1998, p 648 00316 // The overflow() function is called to transfer characters to the 00317 // real output destination when the buffer is full. A call to 00318 // overflow(c) outputs the contents of the buffer plus the 00319 // character c. 00320 // 27.5.2.4.5 00321 // Consume some sequence of the characters in the pending sequence. 00322 virtual int_type 00323 overflow(int_type __c = _Traits::eof()); 00324 00325 // Convert internal byte sequence to external, char-based 00326 // sequence via codecvt. 00327 bool 00328 _M_convert_to_external(char_type*, streamsize); 00329 00330 /** 00331 * @brief Manipulates the buffer. 00332 * @param s Pointer to a buffer area. 00333 * @param n Size of @a s. 00334 * @return @c this 00335 * 00336 * If no file has been opened, and both @a s and @a n are zero, then 00337 * the stream becomes unbuffered. Otherwise, @c s is used as a 00338 * buffer; see 00339 * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html 00340 * for more. 00341 */ 00342 virtual __streambuf_type* 00343 setbuf(char_type* __s, streamsize __n); 00344 00345 virtual pos_type 00346 seekoff(off_type __off, ios_base::seekdir __way, 00347 ios_base::openmode __mode = ios_base::in | ios_base::out); 00348 00349 virtual pos_type 00350 seekpos(pos_type __pos, 00351 ios_base::openmode __mode = ios_base::in | ios_base::out); 00352 00353 // Common code for seekoff and seekpos 00354 pos_type 00355 _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state); 00356 00357 virtual int 00358 sync(); 00359 00360 virtual void 00361 imbue(const locale& __loc); 00362 00363 virtual streamsize 00364 xsgetn(char_type* __s, streamsize __n); 00365 00366 virtual streamsize 00367 xsputn(const char_type* __s, streamsize __n); 00368 00369 // Flushes output buffer, then writes unshift sequence. 00370 bool 00371 _M_terminate_output(); 00372 00373 /** 00374 * This function sets the pointers of the internal buffer, both get 00375 * and put areas. Typically: 00376 * 00377 * __off == egptr() - eback() upon underflow/uflow ('read' mode); 00378 * __off == 0 upon overflow ('write' mode); 00379 * __off == -1 upon open, setbuf, seekoff/pos ('uncommitted' mode). 00380 * 00381 * NB: epptr() - pbase() == _M_buf_size - 1, since _M_buf_size 00382 * reflects the actual allocated memory and the last cell is reserved 00383 * for the overflow char of a full put area. 00384 */ 00385 void 00386 _M_set_buffer(streamsize __off) 00387 { 00388 const bool __testin = _M_mode & ios_base::in; 00389 const bool __testout = _M_mode & ios_base::out; 00390 00391 if (__testin && __off > 0) 00392 this->setg(_M_buf, _M_buf, _M_buf + __off); 00393 else 00394 this->setg(_M_buf, _M_buf, _M_buf); 00395 00396 if (__testout && __off == 0 && _M_buf_size > 1 ) 00397 this->setp(_M_buf, _M_buf + _M_buf_size - 1); 00398 else 00399 this->setp(NULL, NULL); 00400 } 00401 }; 00402 00403 // [27.8.1.5] Template class basic_ifstream 00404 /** 00405 * @brief Controlling input for files. 00406 * @ingroup io 00407 * 00408 * This class supports reading from named files, using the inherited 00409 * functions from std::basic_istream. To control the associated 00410 * sequence, an instance of std::basic_filebuf is used, which this page 00411 * refers to as @c sb. 00412 */ 00413 template<typename _CharT, typename _Traits> 00414 class basic_ifstream : public basic_istream<_CharT, _Traits> 00415 { 00416 public: 00417 // Types: 00418 typedef _CharT char_type; 00419 typedef _Traits traits_type; 00420 typedef typename traits_type::int_type int_type; 00421 typedef typename traits_type::pos_type pos_type; 00422 typedef typename traits_type::off_type off_type; 00423 00424 // Non-standard types: 00425 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 00426 typedef basic_istream<char_type, traits_type> __istream_type; 00427 00428 private: 00429 __filebuf_type _M_filebuf; 00430 00431 public: 00432 // Constructors/Destructors: 00433 /** 00434 * @brief Default constructor. 00435 * 00436 * Initializes @c sb using its default constructor, and passes 00437 * @c &sb to the base class initializer. Does not open any files 00438 * (you haven't given it a filename to open). 00439 */ 00440 basic_ifstream() : __istream_type(), _M_filebuf() 00441 { this->init(&_M_filebuf); } 00442 00443 /** 00444 * @brief Create an input file stream. 00445 * @param s Null terminated string specifying the filename. 00446 * @param mode Open file in specified mode (see std::ios_base). 00447 * 00448 * @c ios_base::in is automatically included in @a mode. 00449 * 00450 * Tip: When using std::string to hold the filename, you must use 00451 * .c_str() before passing it to this constructor. 00452 */ 00453 explicit 00454 basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in) 00455 : __istream_type(), _M_filebuf() 00456 { 00457 this->init(&_M_filebuf); 00458 this->open(__s, __mode); 00459 } 00460 00461 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 00462 /** 00463 * @brief Create an input file stream. 00464 * @param s std::string specifying the filename. 00465 * @param mode Open file in specified mode (see std::ios_base). 00466 * 00467 * @c ios_base::in is automatically included in @a mode. 00468 */ 00469 explicit 00470 basic_ifstream(const std::string& __s, 00471 ios_base::openmode __mode = ios_base::in) 00472 : __istream_type(), _M_filebuf() 00473 { 00474 this->init(&_M_filebuf); 00475 this->open(__s, __mode); 00476 } 00477 #endif 00478 00479 /** 00480 * @brief The destructor does nothing. 00481 * 00482 * The file is closed by the filebuf object, not the formatting 00483 * stream. 00484 */ 00485 ~basic_ifstream() 00486 { } 00487 00488 // Members: 00489 /** 00490 * @brief Accessing the underlying buffer. 00491 * @return The current basic_filebuf buffer. 00492 * 00493 * This hides both signatures of std::basic_ios::rdbuf(). 00494 */ 00495 __filebuf_type* 00496 rdbuf() const 00497 { return const_cast<__filebuf_type*>(&_M_filebuf); } 00498 00499 /** 00500 * @brief Wrapper to test for an open file. 00501 * @return @c rdbuf()->is_open() 00502 */ 00503 bool 00504 is_open() 00505 { return _M_filebuf.is_open(); } 00506 00507 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00508 // 365. Lack of const-qualification in clause 27 00509 bool 00510 is_open() const 00511 { return _M_filebuf.is_open(); } 00512 00513 /** 00514 * @brief Opens an external file. 00515 * @param s The name of the file. 00516 * @param mode The open mode flags. 00517 * 00518 * Calls @c std::basic_filebuf::open(s,mode|in). If that function 00519 * fails, @c failbit is set in the stream's error state. 00520 * 00521 * Tip: When using std::string to hold the filename, you must use 00522 * .c_str() before passing it to this constructor. 00523 */ 00524 void 00525 open(const char* __s, ios_base::openmode __mode = ios_base::in) 00526 { 00527 if (!_M_filebuf.open(__s, __mode | ios_base::in)) 00528 this->setstate(ios_base::failbit); 00529 else 00530 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00531 // 409. Closing an fstream should clear error state 00532 this->clear(); 00533 } 00534 00535 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 00536 /** 00537 * @brief Opens an external file. 00538 * @param s The name of the file. 00539 * @param mode The open mode flags. 00540 * 00541 * Calls @c std::basic_filebuf::open(s,mode|in). If that function 00542 * fails, @c failbit is set in the stream's error state. 00543 */ 00544 void 00545 open(const std::string& __s, ios_base::openmode __mode = ios_base::in) 00546 { 00547 if (!_M_filebuf.open(__s, __mode | ios_base::in)) 00548 this->setstate(ios_base::failbit); 00549 else 00550 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00551 // 409. Closing an fstream should clear error state 00552 this->clear(); 00553 } 00554 #endif 00555 00556 /** 00557 * @brief Close the file. 00558 * 00559 * Calls @c std::basic_filebuf::close(). If that function 00560 * fails, @c failbit is set in the stream's error state. 00561 */ 00562 void 00563 close() 00564 { 00565 if (!_M_filebuf.close()) 00566 this->setstate(ios_base::failbit); 00567 } 00568 }; 00569 00570 00571 // [27.8.1.8] Template class basic_ofstream 00572 /** 00573 * @brief Controlling output for files. 00574 * @ingroup io 00575 * 00576 * This class supports reading from named files, using the inherited 00577 * functions from std::basic_ostream. To control the associated 00578 * sequence, an instance of std::basic_filebuf is used, which this page 00579 * refers to as @c sb. 00580 */ 00581 template<typename _CharT, typename _Traits> 00582 class basic_ofstream : public basic_ostream<_CharT,_Traits> 00583 { 00584 public: 00585 // Types: 00586 typedef _CharT char_type; 00587 typedef _Traits traits_type; 00588 typedef typename traits_type::int_type int_type; 00589 typedef typename traits_type::pos_type pos_type; 00590 typedef typename traits_type::off_type off_type; 00591 00592 // Non-standard types: 00593 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 00594 typedef basic_ostream<char_type, traits_type> __ostream_type; 00595 00596 private: 00597 __filebuf_type _M_filebuf; 00598 00599 public: 00600 // Constructors: 00601 /** 00602 * @brief Default constructor. 00603 * 00604 * Initializes @c sb using its default constructor, and passes 00605 * @c &sb to the base class initializer. Does not open any files 00606 * (you haven't given it a filename to open). 00607 */ 00608 basic_ofstream(): __ostream_type(), _M_filebuf() 00609 { this->init(&_M_filebuf); } 00610 00611 /** 00612 * @brief Create an output file stream. 00613 * @param s Null terminated string specifying the filename. 00614 * @param mode Open file in specified mode (see std::ios_base). 00615 * 00616 * @c ios_base::out|ios_base::trunc is automatically included in 00617 * @a mode. 00618 * 00619 * Tip: When using std::string to hold the filename, you must use 00620 * .c_str() before passing it to this constructor. 00621 */ 00622 explicit 00623 basic_ofstream(const char* __s, 00624 ios_base::openmode __mode = ios_base::out|ios_base::trunc) 00625 : __ostream_type(), _M_filebuf() 00626 { 00627 this->init(&_M_filebuf); 00628 this->open(__s, __mode); 00629 } 00630 00631 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 00632 /** 00633 * @brief Create an output file stream. 00634 * @param s std::string specifying the filename. 00635 * @param mode Open file in specified mode (see std::ios_base). 00636 * 00637 * @c ios_base::out|ios_base::trunc is automatically included in 00638 * @a mode. 00639 */ 00640 explicit 00641 basic_ofstream(const std::string& __s, 00642 ios_base::openmode __mode = ios_base::out|ios_base::trunc) 00643 : __ostream_type(), _M_filebuf() 00644 { 00645 this->init(&_M_filebuf); 00646 this->open(__s, __mode); 00647 } 00648 #endif 00649 00650 /** 00651 * @brief The destructor does nothing. 00652 * 00653 * The file is closed by the filebuf object, not the formatting 00654 * stream. 00655 */ 00656 ~basic_ofstream() 00657 { } 00658 00659 // Members: 00660 /** 00661 * @brief Accessing the underlying buffer. 00662 * @return The current basic_filebuf buffer. 00663 * 00664 * This hides both signatures of std::basic_ios::rdbuf(). 00665 */ 00666 __filebuf_type* 00667 rdbuf() const 00668 { return const_cast<__filebuf_type*>(&_M_filebuf); } 00669 00670 /** 00671 * @brief Wrapper to test for an open file. 00672 * @return @c rdbuf()->is_open() 00673 */ 00674 bool 00675 is_open() 00676 { return _M_filebuf.is_open(); } 00677 00678 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00679 // 365. Lack of const-qualification in clause 27 00680 bool 00681 is_open() const 00682 { return _M_filebuf.is_open(); } 00683 00684 /** 00685 * @brief Opens an external file. 00686 * @param s The name of the file. 00687 * @param mode The open mode flags. 00688 * 00689 * Calls @c std::basic_filebuf::open(s,mode|out|trunc). If that 00690 * function fails, @c failbit is set in the stream's error state. 00691 * 00692 * Tip: When using std::string to hold the filename, you must use 00693 * .c_str() before passing it to this constructor. 00694 */ 00695 void 00696 open(const char* __s, 00697 ios_base::openmode __mode = ios_base::out | ios_base::trunc) 00698 { 00699 if (!_M_filebuf.open(__s, __mode | ios_base::out)) 00700 this->setstate(ios_base::failbit); 00701 else 00702 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00703 // 409. Closing an fstream should clear error state 00704 this->clear(); 00705 } 00706 00707 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 00708 /** 00709 * @brief Opens an external file. 00710 * @param s The name of the file. 00711 * @param mode The open mode flags. 00712 * 00713 * Calls @c std::basic_filebuf::open(s,mode|out|trunc). If that 00714 * function fails, @c failbit is set in the stream's error state. 00715 */ 00716 void 00717 open(const std::string& __s, 00718 ios_base::openmode __mode = ios_base::out | ios_base::trunc) 00719 { 00720 if (!_M_filebuf.open(__s, __mode | ios_base::out)) 00721 this->setstate(ios_base::failbit); 00722 else 00723 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00724 // 409. Closing an fstream should clear error state 00725 this->clear(); 00726 } 00727 #endif 00728 00729 /** 00730 * @brief Close the file. 00731 * 00732 * Calls @c std::basic_filebuf::close(). If that function 00733 * fails, @c failbit is set in the stream's error state. 00734 */ 00735 void 00736 close() 00737 { 00738 if (!_M_filebuf.close()) 00739 this->setstate(ios_base::failbit); 00740 } 00741 }; 00742 00743 00744 // [27.8.1.11] Template class basic_fstream 00745 /** 00746 * @brief Controlling input and output for files. 00747 * @ingroup io 00748 * 00749 * This class supports reading from and writing to named files, using 00750 * the inherited functions from std::basic_iostream. To control the 00751 * associated sequence, an instance of std::basic_filebuf is used, which 00752 * this page refers to as @c sb. 00753 */ 00754 template<typename _CharT, typename _Traits> 00755 class basic_fstream : public basic_iostream<_CharT, _Traits> 00756 { 00757 public: 00758 // Types: 00759 typedef _CharT char_type; 00760 typedef _Traits traits_type; 00761 typedef typename traits_type::int_type int_type; 00762 typedef typename traits_type::pos_type pos_type; 00763 typedef typename traits_type::off_type off_type; 00764 00765 // Non-standard types: 00766 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 00767 typedef basic_ios<char_type, traits_type> __ios_type; 00768 typedef basic_iostream<char_type, traits_type> __iostream_type; 00769 00770 private: 00771 __filebuf_type _M_filebuf; 00772 00773 public: 00774 // Constructors/destructor: 00775 /** 00776 * @brief Default constructor. 00777 * 00778 * Initializes @c sb using its default constructor, and passes 00779 * @c &sb to the base class initializer. Does not open any files 00780 * (you haven't given it a filename to open). 00781 */ 00782 basic_fstream() 00783 : __iostream_type(), _M_filebuf() 00784 { this->init(&_M_filebuf); } 00785 00786 /** 00787 * @brief Create an input/output file stream. 00788 * @param s Null terminated string specifying the filename. 00789 * @param mode Open file in specified mode (see std::ios_base). 00790 * 00791 * Tip: When using std::string to hold the filename, you must use 00792 * .c_str() before passing it to this constructor. 00793 */ 00794 explicit 00795 basic_fstream(const char* __s, 00796 ios_base::openmode __mode = ios_base::in | ios_base::out) 00797 : __iostream_type(NULL), _M_filebuf() 00798 { 00799 this->init(&_M_filebuf); 00800 this->open(__s, __mode); 00801 } 00802 00803 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 00804 /** 00805 * @brief Create an input/output file stream. 00806 * @param s Null terminated string specifying the filename. 00807 * @param mode Open file in specified mode (see std::ios_base). 00808 */ 00809 explicit 00810 basic_fstream(const std::string& __s, 00811 ios_base::openmode __mode = ios_base::in | ios_base::out) 00812 : __iostream_type(NULL), _M_filebuf() 00813 { 00814 this->init(&_M_filebuf); 00815 this->open(__s, __mode); 00816 } 00817 #endif 00818 00819 /** 00820 * @brief The destructor does nothing. 00821 * 00822 * The file is closed by the filebuf object, not the formatting 00823 * stream. 00824 */ 00825 ~basic_fstream() 00826 { } 00827 00828 // Members: 00829 /** 00830 * @brief Accessing the underlying buffer. 00831 * @return The current basic_filebuf buffer. 00832 * 00833 * This hides both signatures of std::basic_ios::rdbuf(). 00834 */ 00835 __filebuf_type* 00836 rdbuf() const 00837 { return const_cast<__filebuf_type*>(&_M_filebuf); } 00838 00839 /** 00840 * @brief Wrapper to test for an open file. 00841 * @return @c rdbuf()->is_open() 00842 */ 00843 bool 00844 is_open() 00845 { return _M_filebuf.is_open(); } 00846 00847 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00848 // 365. Lack of const-qualification in clause 27 00849 bool 00850 is_open() const 00851 { return _M_filebuf.is_open(); } 00852 00853 /** 00854 * @brief Opens an external file. 00855 * @param s The name of the file. 00856 * @param mode The open mode flags. 00857 * 00858 * Calls @c std::basic_filebuf::open(s,mode). If that 00859 * function fails, @c failbit is set in the stream's error state. 00860 * 00861 * Tip: When using std::string to hold the filename, you must use 00862 * .c_str() before passing it to this constructor. 00863 */ 00864 void 00865 open(const char* __s, 00866 ios_base::openmode __mode = ios_base::in | ios_base::out) 00867 { 00868 if (!_M_filebuf.open(__s, __mode)) 00869 this->setstate(ios_base::failbit); 00870 else 00871 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00872 // 409. Closing an fstream should clear error state 00873 this->clear(); 00874 } 00875 00876 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 00877 /** 00878 * @brief Opens an external file. 00879 * @param s The name of the file. 00880 * @param mode The open mode flags. 00881 * 00882 * Calls @c std::basic_filebuf::open(s,mode). If that 00883 * function fails, @c failbit is set in the stream's error state. 00884 */ 00885 void 00886 open(const std::string& __s, 00887 ios_base::openmode __mode = ios_base::in | ios_base::out) 00888 { 00889 if (!_M_filebuf.open(__s, __mode)) 00890 this->setstate(ios_base::failbit); 00891 else 00892 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00893 // 409. Closing an fstream should clear error state 00894 this->clear(); 00895 } 00896 #endif 00897 00898 /** 00899 * @brief Close the file. 00900 * 00901 * Calls @c std::basic_filebuf::close(). If that function 00902 * fails, @c failbit is set in the stream's error state. 00903 */ 00904 void 00905 close() 00906 { 00907 if (!_M_filebuf.close()) 00908 this->setstate(ios_base::failbit); 00909 } 00910 }; 00911 00912 _GLIBCXX_END_NAMESPACE 00913 00914 #ifndef _GLIBCXX_EXPORT_TEMPLATE 00915 # include <bits/fstream.tcc> 00916 #endif 00917 00918 #endif /* _GLIBCXX_FSTREAM */