1 // Streambuf iterators 2 3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 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 /** @file streambuf_iterator.h 32 * This is an internal header file, included by other library headers. 33 * You should not attempt to use it directly. 34 */ 35 36 #ifndef _CPP_BITS_STREAMBUF_ITERATOR_H 37 #define _CPP_BITS_STREAMBUF_ITERATOR_H 1 38 39 #pragma GCC system_header 40 41 #include <streambuf> 42 43 // NB: Should specialize copy, find algorithms for streambuf iterators. 44 45 namespace std 46 { 47 // 24.5.3 Template class istreambuf_iterator 48 template<typename _CharT, typename _Traits> 49 class istreambuf_iterator 50 : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type, 51 _CharT*, _CharT&> 52 { 53 public: 54 // Types: 55 typedef _CharT char_type; 56 typedef _Traits traits_type; 57 typedef typename _Traits::int_type int_type; 58 typedef basic_streambuf<_CharT, _Traits> streambuf_type; 59 typedef basic_istream<_CharT, _Traits> istream_type; 60 61 private: 62 // 24.5.3 istreambuf_iterator 63 // p 1 64 // If the end of stream is reached (streambuf_type::sgetc() 65 // returns traits_type::eof()), the iterator becomes equal to 66 // the "end of stream" iterator value. 67 // NB: This implementation assumes the "end of stream" value 68 // is EOF, or -1. 69 mutable streambuf_type* _M_sbuf; 70 int_type _M_c; 71 72 public: 73 istreambuf_iterator() throw() 74 : _M_sbuf(0), _M_c(traits_type::eof()) { } 75 76 istreambuf_iterator(istream_type& __s) throw() 77 : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { } 78 79 istreambuf_iterator(streambuf_type* __s) throw() 80 : _M_sbuf(__s), _M_c(traits_type::eof()) { } 81 82 // NB: The result of operator*() on an end of stream is undefined. 83 char_type 84 operator*() const 85 { return traits_type::to_char_type(_M_get()); } 86 87 istreambuf_iterator& 88 operator++() 89 { 90 const int_type __eof = traits_type::eof(); 91 if (_M_sbuf && traits_type::eq_int_type(_M_sbuf->sbumpc(), __eof)) 92 _M_sbuf = 0; 93 else 94 _M_c = __eof; 95 return *this; 96 } 97 98 istreambuf_iterator 99 operator++(int) 100 { 101 const int_type __eof = traits_type::eof(); 102 istreambuf_iterator __old = *this; 103 if (_M_sbuf 104 && traits_type::eq_int_type((__old._M_c = _M_sbuf->sbumpc()), 105 __eof)) 106 _M_sbuf = 0; 107 else 108 _M_c = __eof; 109 return __old; 110 } 111 112 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 113 // 110 istreambuf_iterator::equal not const 114 // NB: there is also number 111 (NAD, Future) pending on this function. 115 bool 116 equal(const istreambuf_iterator& __b) const 117 { 118 const int_type __eof = traits_type::eof(); 119 bool __thiseof = traits_type::eq_int_type(_M_get(), __eof); 120 bool __beof = traits_type::eq_int_type(__b._M_get(), __eof); 121 return (__thiseof && __beof || (!__thiseof && !__beof)); 122 } 123 #endif 124 125 private: 126 int_type 127 _M_get() const 128 { 129 const int_type __eof = traits_type::eof(); 130 int_type __ret = __eof; 131 if (_M_sbuf) 132 { 133 if (!traits_type::eq_int_type(_M_c, __eof)) 134 __ret = _M_c; 135 else 136 if (traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), __eof)) 137 _M_sbuf = 0; 138 } 139 return __ret; 140 } 141 }; 142 143 template<typename _CharT, typename _Traits> 144 inline bool 145 operator==(const istreambuf_iterator<_CharT, _Traits>& __a, 146 const istreambuf_iterator<_CharT, _Traits>& __b) 147 { return __a.equal(__b); } 148 149 template<typename _CharT, typename _Traits> 150 inline bool 151 operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, 152 const istreambuf_iterator<_CharT, _Traits>& __b) 153 { return !__a.equal(__b); } 154 155 template<typename _CharT, typename _Traits> 156 class ostreambuf_iterator 157 : public iterator<output_iterator_tag, void, void, void, void> 158 { 159 public: 160 // Types: 161 typedef _CharT char_type; 162 typedef _Traits traits_type; 163 typedef basic_streambuf<_CharT, _Traits> streambuf_type; 164 typedef basic_ostream<_CharT, _Traits> ostream_type; 165 166 private: 167 streambuf_type* _M_sbuf; 168 bool _M_failed; 169 170 public: 171 ostreambuf_iterator(ostream_type& __s) throw () 172 : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { } 173 174 ostreambuf_iterator(streambuf_type* __s) throw () 175 : _M_sbuf(__s), _M_failed(!_M_sbuf) { } 176 177 ostreambuf_iterator& 178 operator=(_CharT __c) 179 { 180 if (!_M_failed && 181 _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof())) 182 _M_failed = true; 183 return *this; 184 } 185 186 ostreambuf_iterator& 187 operator*() throw() 188 { return *this; } 189 190 ostreambuf_iterator& 191 operator++(int) throw() 192 { return *this; } 193 194 ostreambuf_iterator& 195 operator++() throw() 196 { return *this; } 197 198 bool 199 failed() const throw() 200 { return _M_failed; } 201 202 ostreambuf_iterator& 203 _M_put(const _CharT* __ws, streamsize __len) 204 { 205 if (__builtin_expect(!_M_failed, true) && 206 __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, false)) 207 _M_failed = true; 208 return *this; 209 } 210 }; 211 } // namespace std 212 #endif 213