1 // Streambuf iterators 2 3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 4 // Free Software Foundation, Inc. 5 // 6 // This file is part of the GNU ISO C++ Library. This library is free 7 // software; you can redistribute it and/or modify it under the 8 // terms of the GNU General Public License as published by the 9 // Free Software Foundation; either version 2, or (at your option) 10 // any later version. 11 12 // This library is distributed in the hope that it will be useful, 13 // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 // GNU General Public License for more details. 16 17 // You should have received a copy of the GNU General Public License along 18 // with this library; see the file COPYING. If not, write to the Free 19 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 20 // USA. 21 22 // As a special exception, you may use this file as part of a free software 23 // library without restriction. Specifically, if other files instantiate 24 // templates or use macros or inline functions from this file, or you compile 25 // this file and link it with other files to produce an executable, this 26 // file does not by itself cause the resulting executable to be covered by 27 // the GNU General Public License. This exception does not however 28 // invalidate any other reasons why the executable file might be covered by 29 // the GNU General Public License. 30 31 // XXX Should specialize copy, find algorithms for streambuf iterators. 32 33 /** @file streambuf_iterator.h 34 * This is an internal header file, included by other library headers. 35 * You should not attempt to use it directly. 36 */ 37 38 #ifndef _CPP_BITS_STREAMBUF_ITERATOR_H 39 #define _CPP_BITS_STREAMBUF_ITERATOR_H 1 40 41 #pragma GCC system_header 42 43 namespace std 44 { 45 // 24.5.3 Template class istreambuf_iterator 46 template<typename _CharT, typename _Traits> 47 class istreambuf_iterator 48 : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type, 49 _CharT*, _CharT&> 50 { 51 public: 52 // Types: 53 typedef _CharT char_type; 54 typedef _Traits traits_type; 55 typedef typename _Traits::int_type int_type; 56 typedef basic_streambuf<_CharT, _Traits> streambuf_type; 57 typedef basic_istream<_CharT, _Traits> istream_type; 58 59 private: 60 // 24.5.3 istreambuf_iterator 61 // p 1 62 // If the end of stream is reached (streambuf_type::sgetc() 63 // returns traits_type::eof()), the iterator becomes equal to 64 // the "end of stream" iterator value. 65 // NB: This implementation assumes the "end of stream" value 66 // is EOF, or -1. 67 mutable streambuf_type* _M_sbuf; 68 int_type _M_c; 69 70 public: 71 istreambuf_iterator() throw() 72 : _M_sbuf(0), _M_c(traits_type::eof()) { } 73 74 istreambuf_iterator(istream_type& __s) throw() 75 : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { } 76 77 istreambuf_iterator(streambuf_type* __s) throw() 78 : _M_sbuf(__s), _M_c(traits_type::eof()) { } 79 80 // NB: The result of operator*() on an end of stream is undefined. 81 char_type 82 operator*() const 83 { return traits_type::to_char_type(_M_get()); } 84 85 istreambuf_iterator& 86 operator++() 87 { 88 const int_type __eof = traits_type::eof(); 89 if (_M_sbuf && traits_type::eq_int_type(_M_sbuf->sbumpc(), __eof)) 90 _M_sbuf = 0; 91 else 92 _M_c = __eof; 93 return *this; 94 } 95 96 istreambuf_iterator 97 operator++(int) 98 { 99 const int_type __eof = traits_type::eof(); 100 istreambuf_iterator __old = *this; 101 if (_M_sbuf 102 && traits_type::eq_int_type((__old._M_c = _M_sbuf->sbumpc()), 103 __eof)) 104 _M_sbuf = 0; 105 else 106 _M_c = __eof; 107 return __old; 108 } 109 110 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 111 // 110 istreambuf_iterator::equal not const 112 // NB: there is also number 111 (NAD, Future) pending on this function. 113 bool 114 equal(const istreambuf_iterator& __b) const 115 { 116 const int_type __eof = traits_type::eof(); 117 bool __thiseof = traits_type::eq_int_type(_M_get(), __eof); 118 bool __beof = traits_type::eq_int_type(__b._M_get(), __eof); 119 return (__thiseof && __beof || (!__thiseof && !__beof)); 120 } 121 #endif 122 123 private: 124 int_type 125 _M_get() const 126 { 127 const int_type __eof = traits_type::eof(); 128 int_type __ret = __eof; 129 if (_M_sbuf) 130 { 131 if (!traits_type::eq_int_type(_M_c, __eof)) 132 __ret = _M_c; 133 else 134 if (traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), __eof)) 135 _M_sbuf = 0; 136 } 137 return __ret; 138 } 139 }; 140 141 template<typename _CharT, typename _Traits> 142 inline bool 143 operator==(const istreambuf_iterator<_CharT, _Traits>& __a, 144 const istreambuf_iterator<_CharT, _Traits>& __b) 145 { return __a.equal(__b); } 146 147 template<typename _CharT, typename _Traits> 148 inline bool 149 operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, 150 const istreambuf_iterator<_CharT, _Traits>& __b) 151 { return !__a.equal(__b); } 152 153 template<typename _CharT, typename _Traits> 154 class ostreambuf_iterator 155 : public iterator<output_iterator_tag, void, void, void, void> 156 { 157 public: 158 // Types: 159 typedef _CharT char_type; 160 typedef _Traits traits_type; 161 typedef basic_streambuf<_CharT, _Traits> streambuf_type; 162 typedef basic_ostream<_CharT, _Traits> ostream_type; 163 164 private: 165 streambuf_type* _M_sbuf; 166 bool _M_failed; 167 168 public: 169 inline 170 ostreambuf_iterator(ostream_type& __s) throw () 171 : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { } 172 173 ostreambuf_iterator(streambuf_type* __s) throw () 174 : _M_sbuf(__s), _M_failed(!_M_sbuf) { } 175 176 ostreambuf_iterator& 177 operator=(_CharT __c); 178 179 ostreambuf_iterator& 180 operator*() throw() 181 { return *this; } 182 183 ostreambuf_iterator& 184 operator++(int) throw() 185 { return *this; } 186 187 ostreambuf_iterator& 188 operator++() throw() 189 { return *this; } 190 191 bool 192 failed() const throw() 193 { return _M_failed; } 194 }; 195 196 template<typename _CharT, typename _Traits> 197 inline ostreambuf_iterator<_CharT, _Traits>& 198 ostreambuf_iterator<_CharT, _Traits>::operator=(_CharT __c) 199 { 200 if (!_M_failed && 201 _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof())) 202 _M_failed = true; 203 return *this; 204 } 205 } // namespace std 206 #endif 207