libstdc++
streambuf_iterator.h
Go to the documentation of this file.
1 // Streambuf iterators
2 
3 // Copyright (C) 1997-2021 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 bits/streambuf_iterator.h
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{iterator}
28  */
29 
30 #ifndef _STREAMBUF_ITERATOR_H
31 #define _STREAMBUF_ITERATOR_H 1
32 
33 #pragma GCC system_header
34 
35 #include <streambuf>
36 #include <debug/debug.h>
37 
38 namespace std _GLIBCXX_VISIBILITY(default)
39 {
40 _GLIBCXX_BEGIN_NAMESPACE_VERSION
41 
42  /**
43  * @addtogroup iterators
44  * @{
45  */
46 
47  // 24.5.3 Template class istreambuf_iterator
48  /// Provides input iterator semantics for streambufs.
49  template<typename _CharT, typename _Traits>
51  : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
52  _CharT*, _CharT>
53  {
54  public:
55  // Types:
56  ///@{
57  /// Public typedefs
58 #if __cplusplus < 201103L
59  typedef _CharT& reference; // Changed to _CharT by LWG 445
60 #elif __cplusplus > 201703L
61  // _GLIBCXX_RESOLVE_LIB_DEFECTS
62  // 3188. istreambuf_iterator::pointer should not be unspecified
63  using pointer = void;
64 #endif
65 
66  typedef _CharT char_type;
67  typedef _Traits traits_type;
68  typedef typename _Traits::int_type int_type;
71  ///@}
72 
73  template<typename _CharT2>
74  friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
78 
79  template<bool _IsMove, typename _CharT2>
80  friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
81  _CharT2*>::__type
82  __copy_move_a2(istreambuf_iterator<_CharT2>,
84 
85  template<typename _CharT2, typename _Size>
86  friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
87  _CharT2*>::__type
88  __copy_n_a(istreambuf_iterator<_CharT2>, _Size, _CharT2*, bool);
89 
90  template<typename _CharT2>
91  friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
94  const _CharT2&);
95 
96  template<typename _CharT2, typename _Distance>
97  friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
98  void>::__type
99  advance(istreambuf_iterator<_CharT2>&, _Distance);
100 
101  private:
102  // 24.5.3 istreambuf_iterator
103  // p 1
104  // If the end of stream is reached (streambuf_type::sgetc()
105  // returns traits_type::eof()), the iterator becomes equal to
106  // the "end of stream" iterator value.
107  // NB: This implementation assumes the "end of stream" value
108  // is EOF, or -1.
109  mutable streambuf_type* _M_sbuf;
110  int_type _M_c;
111 
112  public:
113  /// Construct end of input stream iterator.
114  _GLIBCXX_CONSTEXPR istreambuf_iterator() _GLIBCXX_USE_NOEXCEPT
115  : _M_sbuf(0), _M_c(traits_type::eof()) { }
116 
117 #if __cplusplus > 201703L && __cpp_lib_concepts
118  constexpr istreambuf_iterator(default_sentinel_t) noexcept
119  : istreambuf_iterator() { }
120 #endif
121 
122 #if __cplusplus >= 201103L
123  istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
124 
125  ~istreambuf_iterator() = default;
126 #endif
127 
128  /// Construct start of input stream iterator.
129  istreambuf_iterator(istream_type& __s) _GLIBCXX_USE_NOEXCEPT
130  : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
131 
132  /// Construct start of streambuf iterator.
133  istreambuf_iterator(streambuf_type* __s) _GLIBCXX_USE_NOEXCEPT
134  : _M_sbuf(__s), _M_c(traits_type::eof()) { }
135 
136 #if __cplusplus >= 201103L
138  operator=(const istreambuf_iterator&) noexcept = default;
139 #endif
140 
141  /// Return the current character pointed to by iterator. This returns
142  /// streambuf.sgetc(). It cannot be assigned. NB: The result of
143  /// operator*() on an end of stream is undefined.
144  _GLIBCXX_NODISCARD
145  char_type
146  operator*() const
147  {
148  int_type __c = _M_get();
149 
150 #ifdef _GLIBCXX_DEBUG_PEDANTIC
151  // Dereferencing a past-the-end istreambuf_iterator is a
152  // libstdc++ extension
153  __glibcxx_requires_cond(!_S_is_eof(__c),
154  _M_message(__gnu_debug::__msg_deref_istreambuf)
155  ._M_iterator(*this));
156 #endif
157  return traits_type::to_char_type(__c);
158  }
159 
160  /// Advance the iterator. Calls streambuf.sbumpc().
163  {
164  __glibcxx_requires_cond(_M_sbuf &&
165  (!_S_is_eof(_M_c) || !_S_is_eof(_M_sbuf->sgetc())),
166  _M_message(__gnu_debug::__msg_inc_istreambuf)
167  ._M_iterator(*this));
168 
169  _M_sbuf->sbumpc();
170  _M_c = traits_type::eof();
171  return *this;
172  }
173 
174  /// Advance the iterator. Calls streambuf.sbumpc().
177  {
178  __glibcxx_requires_cond(_M_sbuf &&
179  (!_S_is_eof(_M_c) || !_S_is_eof(_M_sbuf->sgetc())),
180  _M_message(__gnu_debug::__msg_inc_istreambuf)
181  ._M_iterator(*this));
182 
183  istreambuf_iterator __old = *this;
184  __old._M_c = _M_sbuf->sbumpc();
185  _M_c = traits_type::eof();
186  return __old;
187  }
188 
189  // _GLIBCXX_RESOLVE_LIB_DEFECTS
190  // 110 istreambuf_iterator::equal not const
191  // NB: there is also number 111 (NAD) relevant to this function.
192  /// Return true both iterators are end or both are not end.
193  _GLIBCXX_NODISCARD
194  bool
195  equal(const istreambuf_iterator& __b) const
196  { return _M_at_eof() == __b._M_at_eof(); }
197 
198  private:
199  int_type
200  _M_get() const
201  {
202  int_type __ret = _M_c;
203  if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc()))
204  _M_sbuf = 0;
205  return __ret;
206  }
207 
208  bool
209  _M_at_eof() const
210  { return _S_is_eof(_M_get()); }
211 
212  static bool
213  _S_is_eof(int_type __c)
214  {
215  const int_type __eof = traits_type::eof();
216  return traits_type::eq_int_type(__c, __eof);
217  }
218 
219 #if __cplusplus > 201703L && __cpp_lib_concepts
220  [[nodiscard]]
221  friend bool
222  operator==(const istreambuf_iterator& __i, default_sentinel_t __s)
223  { return __i._M_at_eof(); }
224 #endif
225  };
226 
227  template<typename _CharT, typename _Traits>
228  _GLIBCXX_NODISCARD
229  inline bool
230  operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
231  const istreambuf_iterator<_CharT, _Traits>& __b)
232  { return __a.equal(__b); }
233 
234 #if __cpp_impl_three_way_comparison < 201907L
235  template<typename _CharT, typename _Traits>
236  _GLIBCXX_NODISCARD
237  inline bool
238  operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
239  const istreambuf_iterator<_CharT, _Traits>& __b)
240  { return !__a.equal(__b); }
241 #endif
242 
243  /// Provides output iterator semantics for streambufs.
244  template<typename _CharT, typename _Traits>
246  : public iterator<output_iterator_tag, void, void, void, void>
247  {
248  public:
249  // Types:
250  ///@{
251  /// Public typedefs
252 #if __cplusplus > 201703L
253  using difference_type = ptrdiff_t;
254 #endif
255  typedef _CharT char_type;
256  typedef _Traits traits_type;
259  ///@}
260 
261  template<typename _CharT2>
262  friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
266 
267  private:
268  streambuf_type* _M_sbuf;
269  bool _M_failed;
270 
271  public:
272 
273 #if __cplusplus > 201703L
274  constexpr
275  ostreambuf_iterator() noexcept
276  : _M_sbuf(nullptr), _M_failed(true) { }
277 #endif
278 
279  /// Construct output iterator from ostream.
280  ostreambuf_iterator(ostream_type& __s) _GLIBCXX_USE_NOEXCEPT
281  : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
282 
283  /// Construct output iterator from streambuf.
284  ostreambuf_iterator(streambuf_type* __s) _GLIBCXX_USE_NOEXCEPT
285  : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
286 
287  /// Write character to streambuf. Calls streambuf.sputc().
289  operator=(_CharT __c)
290  {
291  if (!_M_failed &&
292  _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
293  _M_failed = true;
294  return *this;
295  }
296 
297  /// Return *this.
298  _GLIBCXX_NODISCARD
301  { return *this; }
302 
303  /// Return *this.
306  { return *this; }
307 
308  /// Return *this.
311  { return *this; }
312 
313  /// Return true if previous operator=() failed.
314  _GLIBCXX_NODISCARD
315  bool
316  failed() const _GLIBCXX_USE_NOEXCEPT
317  { return _M_failed; }
318 
320  _M_put(const _CharT* __ws, streamsize __len)
321  {
322  if (__builtin_expect(!_M_failed, true)
323  && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
324  false))
325  _M_failed = true;
326  return *this;
327  }
328  };
329 
330  // Overloads for streambuf iterators.
331  template<typename _CharT>
332  typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
333  ostreambuf_iterator<_CharT> >::__type
334  copy(istreambuf_iterator<_CharT> __first,
335  istreambuf_iterator<_CharT> __last,
336  ostreambuf_iterator<_CharT> __result)
337  {
338  if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
339  {
340  bool __ineof;
341  __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
342  if (!__ineof)
343  __result._M_failed = true;
344  }
345  return __result;
346  }
347 
348  template<bool _IsMove, typename _CharT>
349  typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
350  ostreambuf_iterator<_CharT> >::__type
351  __copy_move_a2(_CharT* __first, _CharT* __last,
352  ostreambuf_iterator<_CharT> __result)
353  {
354  const streamsize __num = __last - __first;
355  if (__num > 0)
356  __result._M_put(__first, __num);
357  return __result;
358  }
359 
360  template<bool _IsMove, typename _CharT>
361  typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
362  ostreambuf_iterator<_CharT> >::__type
363  __copy_move_a2(const _CharT* __first, const _CharT* __last,
364  ostreambuf_iterator<_CharT> __result)
365  {
366  const streamsize __num = __last - __first;
367  if (__num > 0)
368  __result._M_put(__first, __num);
369  return __result;
370  }
371 
372  template<bool _IsMove, typename _CharT>
373  typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
374  _CharT*>::__type
375  __copy_move_a2(istreambuf_iterator<_CharT> __first,
376  istreambuf_iterator<_CharT> __last, _CharT* __result)
377  {
378  typedef istreambuf_iterator<_CharT> __is_iterator_type;
379  typedef typename __is_iterator_type::traits_type traits_type;
380  typedef typename __is_iterator_type::streambuf_type streambuf_type;
381  typedef typename traits_type::int_type int_type;
382 
383  if (__first._M_sbuf && !__last._M_sbuf)
384  {
385  streambuf_type* __sb = __first._M_sbuf;
386  int_type __c = __sb->sgetc();
387  while (!traits_type::eq_int_type(__c, traits_type::eof()))
388  {
389  const streamsize __n = __sb->egptr() - __sb->gptr();
390  if (__n > 1)
391  {
392  traits_type::copy(__result, __sb->gptr(), __n);
393  __sb->__safe_gbump(__n);
394  __result += __n;
395  __c = __sb->underflow();
396  }
397  else
398  {
399  *__result++ = traits_type::to_char_type(__c);
400  __c = __sb->snextc();
401  }
402  }
403  }
404  return __result;
405  }
406 
407  template<typename _CharT, typename _Size>
408  typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
409  _CharT*>::__type
410  __copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result,
411  bool __strict __attribute__((__unused__)))
412  {
413  if (__n == 0)
414  return __result;
415 
416  __glibcxx_requires_cond(__it._M_sbuf,
417  _M_message(__gnu_debug::__msg_inc_istreambuf)
418  ._M_iterator(__it));
419  _CharT* __beg = __result;
420  __result += __it._M_sbuf->sgetn(__beg, __n);
421  __glibcxx_requires_cond(!__strict || __result - __beg == __n,
422  _M_message(__gnu_debug::__msg_inc_istreambuf)
423  ._M_iterator(__it));
424  return __result;
425  }
426 
427  template<typename _CharT>
428  typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
429  istreambuf_iterator<_CharT> >::__type
430  find(istreambuf_iterator<_CharT> __first,
431  istreambuf_iterator<_CharT> __last, const _CharT& __val)
432  {
433  typedef istreambuf_iterator<_CharT> __is_iterator_type;
434  typedef typename __is_iterator_type::traits_type traits_type;
435  typedef typename __is_iterator_type::streambuf_type streambuf_type;
436  typedef typename traits_type::int_type int_type;
437  const int_type __eof = traits_type::eof();
438 
439  if (__first._M_sbuf && !__last._M_sbuf)
440  {
441  const int_type __ival = traits_type::to_int_type(__val);
442  streambuf_type* __sb = __first._M_sbuf;
443  int_type __c = __sb->sgetc();
444  while (!traits_type::eq_int_type(__c, __eof)
445  && !traits_type::eq_int_type(__c, __ival))
446  {
447  streamsize __n = __sb->egptr() - __sb->gptr();
448  if (__n > 1)
449  {
450  const _CharT* __p = traits_type::find(__sb->gptr(),
451  __n, __val);
452  if (__p)
453  __n = __p - __sb->gptr();
454  __sb->__safe_gbump(__n);
455  __c = __sb->sgetc();
456  }
457  else
458  __c = __sb->snextc();
459  }
460 
461  __first._M_c = __eof;
462  }
463 
464  return __first;
465  }
466 
467  template<typename _CharT, typename _Distance>
468  typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
469  void>::__type
470  advance(istreambuf_iterator<_CharT>& __i, _Distance __n)
471  {
472  if (__n == 0)
473  return;
474 
475  __glibcxx_assert(__n > 0);
476  __glibcxx_requires_cond(!__i._M_at_eof(),
477  _M_message(__gnu_debug::__msg_inc_istreambuf)
478  ._M_iterator(__i));
479 
480  typedef istreambuf_iterator<_CharT> __is_iterator_type;
481  typedef typename __is_iterator_type::traits_type traits_type;
482  typedef typename __is_iterator_type::streambuf_type streambuf_type;
483  typedef typename traits_type::int_type int_type;
484  const int_type __eof = traits_type::eof();
485 
486  streambuf_type* __sb = __i._M_sbuf;
487  while (__n > 0)
488  {
489  streamsize __size = __sb->egptr() - __sb->gptr();
490  if (__size > __n)
491  {
492  __sb->__safe_gbump(__n);
493  break;
494  }
495 
496  __sb->__safe_gbump(__size);
497  __n -= __size;
498  if (traits_type::eq_int_type(__sb->underflow(), __eof))
499  {
500  __glibcxx_requires_cond(__n == 0,
501  _M_message(__gnu_debug::__msg_inc_istreambuf)
502  ._M_iterator(__i));
503  break;
504  }
505  }
506 
507  __i._M_c = __eof;
508  }
509 
510 /// @} group iterators
511 
512 _GLIBCXX_END_NAMESPACE_VERSION
513 } // namespace
514 
515 #endif
ISO C++ entities toplevel namespace is std.
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:68
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
The actual work of input and output (interface).
Definition: streambuf:123
streamsize sputn(const char_type *__s, streamsize __n)
Entry point for all single-character output functions.
Definition: streambuf:455
int_type sbumpc()
Getting the next character.
Definition: streambuf:321
int_type sgetc()
Getting the next character.
Definition: streambuf:343
int_type sputc(char_type __c)
Entry point for all single-character output functions.
Definition: streambuf:429
Template class basic_istream.
Definition: istream:59
Template class basic_ostream.
Definition: ostream:59
Provides input iterator semantics for streambufs.
basic_streambuf< _CharT, _Traits > streambuf_type
Public typedefs.
void pointer
Public typedefs.
istreambuf_iterator & operator++()
Advance the iterator. Calls streambuf.sbumpc().
constexpr istreambuf_iterator() noexcept
Construct end of input stream iterator.
basic_istream< _CharT, _Traits > istream_type
Public typedefs.
char_type operator*() const
Return the current character pointed to by iterator. This returns streambuf.sgetc()....
bool equal(const istreambuf_iterator &__b) const
Return true both iterators are end or both are not end.
_Traits traits_type
Public typedefs.
istreambuf_iterator(istream_type &__s) noexcept
Construct start of input stream iterator.
istreambuf_iterator operator++(int)
Advance the iterator. Calls streambuf.sbumpc().
_CharT char_type
Public typedefs.
istreambuf_iterator(streambuf_type *__s) noexcept
Construct start of streambuf iterator.
_Traits::int_type int_type
Public typedefs.
Provides output iterator semantics for streambufs.
ostreambuf_iterator & operator++()
Return *this.
ostreambuf_iterator & operator*()
Return *this.
ptrdiff_t difference_type
Public typedefs.
bool failed() const noexcept
Return true if previous operator=() failed.
_Traits traits_type
Public typedefs.
basic_ostream< _CharT, _Traits > ostream_type
Public typedefs.
basic_streambuf< _CharT, _Traits > streambuf_type
Public typedefs.
ostreambuf_iterator & operator=(_CharT __c)
Write character to streambuf. Calls streambuf.sputc().
ostreambuf_iterator(ostream_type &__s) noexcept
Construct output iterator from ostream.
ostreambuf_iterator & operator++(int)
Return *this.
_CharT char_type
Public typedefs.
ostreambuf_iterator(streambuf_type *__s) noexcept
Construct output iterator from streambuf.
Common iterator class.