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