libstdc++-v3/include/bits/streambuf_iterator.h

   1 // Streambuf iterators
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  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 _STREAMBUF_ITERATOR_H
  37 #define _STREAMBUF_ITERATOR_H 1
  38
  39 #pragma GCC system_header
  40
  41 #include <streambuf>
  42 #include <debug/debug.h>
  43
  44 _GLIBCXX_BEGIN_NAMESPACE(std)
  45
  46   // 24.5.3 Template class istreambuf_iterator
  47   /// Provides input iterator semantics for streambufs.
  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       //@{
  56       /// Public typedefs
  57       typedef _CharT                                    char_type;
  58       typedef _Traits                                   traits_type;
  59       typedef typename _Traits::int_type                int_type;
  60       typedef basic_streambuf<_CharT, _Traits>          streambuf_type;
  61       typedef basic_istream<_CharT, _Traits>            istream_type;
  62       //@}
  63
  64       template<typename _CharT2>
  65         friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
  66                                     ostreambuf_iterator<_CharT2> >::__type
  67         copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
  68              ostreambuf_iterator<_CharT2>);
  69
  70       template<typename _CharT2>
  71         friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
  72                                                _CharT2*>::__type
  73         __copy_aux(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
  74                    _CharT2*);
  75
  76       template<typename _CharT2>
  77         friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
  78                                     istreambuf_iterator<_CharT2> >::__type
  79         find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
  80              const _CharT2&);
  81
  82     private:
  83       // 24.5.3 istreambuf_iterator
  84       // p 1
  85       // If the end of stream is reached (streambuf_type::sgetc()
  86       // returns traits_type::eof()), the iterator becomes equal to
  87       // the "end of stream" iterator value.
  88       // NB: This implementation assumes the "end of stream" value
  89       // is EOF, or -1.
  90       mutable streambuf_type*   _M_sbuf;
  91       mutable int_type          _M_c;
  92
  93     public:
  94       ///  Construct end of input stream iterator.
  95       istreambuf_iterator() throw()
  96       : _M_sbuf(0), _M_c(traits_type::eof()) { }
  97
  98       ///  Construct start of input stream iterator.
  99       istreambuf_iterator(istream_type& __s) throw()
 100       : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
 101
 102       ///  Construct start of streambuf iterator.
 103       istreambuf_iterator(streambuf_type* __s) throw()
 104       : _M_sbuf(__s), _M_c(traits_type::eof()) { }
 105
 106       ///  Return the current character pointed to by iterator.  This returns
 107       ///  streambuf.sgetc().  It cannot be assigned.  NB: The result of
 108       ///  operator*() on an end of stream is undefined.
 109       char_type
 110       operator*() const
 111       {
 112 #ifdef _GLIBCXX_DEBUG_PEDANTIC
 113         // Dereferencing a past-the-end istreambuf_iterator is a
 114         // libstdc++ extension
 115         __glibcxx_requires_cond(!_M_at_eof(),
 116                                 _M_message(__gnu_debug::__msg_deref_istreambuf)
 117                                 ._M_iterator(*this));
 118 #endif
 119         return traits_type::to_char_type(_M_get());
 120       }
 121
 122       /// Advance the iterator.  Calls streambuf.sbumpc().
 123       istreambuf_iterator&
 124       operator++()
 125       {
 126         __glibcxx_requires_cond(!_M_at_eof(),
 127                                 _M_message(__gnu_debug::__msg_inc_istreambuf)
 128                                 ._M_iterator(*this));
 129         if (_M_sbuf)
 130           {
 131             _M_sbuf->sbumpc();
 132             _M_c = traits_type::eof();
 133           }
 134         return *this;
 135       }
 136
 137       /// Advance the iterator.  Calls streambuf.sbumpc().
 138       istreambuf_iterator
 139       operator++(int)
 140       {
 141         __glibcxx_requires_cond(!_M_at_eof(),
 142                                 _M_message(__gnu_debug::__msg_inc_istreambuf)
 143                                 ._M_iterator(*this));
 144
 145         istreambuf_iterator __old = *this;
 146         if (_M_sbuf)
 147           {
 148             __old._M_c = _M_sbuf->sbumpc();
 149             _M_c = traits_type::eof();
 150           }
 151         return __old;
 152       }
 153
 154       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 155       // 110 istreambuf_iterator::equal not const
 156       // NB: there is also number 111 (NAD, Future) pending on this function.
 157       /// Return true both iterators are end or both are not end.
 158       bool
 159       equal(const istreambuf_iterator& __b) const
 160       {
 161         const bool __thiseof = _M_at_eof();
 162         const bool __beof = __b._M_at_eof();
 163         return (__thiseof && __beof || (!__thiseof && !__beof));
 164       }
 165
 166     private:
 167       int_type
 168       _M_get() const
 169       {
 170         const int_type __eof = traits_type::eof();
 171         int_type __ret = __eof;
 172         if (_M_sbuf)
 173           {
 174             if (!traits_type::eq_int_type(_M_c, __eof))
 175               __ret = _M_c;
 176             else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
 177                                                __eof))
 178               _M_c = __ret;
 179             else
 180               _M_sbuf = 0;
 181           }
 182         return __ret;
 183       }
 184
 185       bool
 186       _M_at_eof() const
 187       {
 188         const int_type __eof = traits_type::eof();
 189         return traits_type::eq_int_type(_M_get(), __eof);
 190       }
 191     };
 192
 193   template<typename _CharT, typename _Traits>
 194     inline bool
 195     operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
 196                const istreambuf_iterator<_CharT, _Traits>& __b)
 197     { return __a.equal(__b); }
 198
 199   template<typename _CharT, typename _Traits>
 200     inline bool
 201     operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
 202                const istreambuf_iterator<_CharT, _Traits>& __b)
 203     { return !__a.equal(__b); }
 204
 205   /// Provides output iterator semantics for streambufs.
 206   template<typename _CharT, typename _Traits>
 207     class ostreambuf_iterator
 208     : public iterator<output_iterator_tag, void, void, void, void>
 209     {
 210     public:
 211       // Types:
 212       //@{
 213       /// Public typedefs
 214       typedef _CharT                           char_type;
 215       typedef _Traits                          traits_type;
 216       typedef basic_streambuf<_CharT, _Traits> streambuf_type;
 217       typedef basic_ostream<_CharT, _Traits>   ostream_type;
 218       //@}
 219
 220       template<typename _CharT2>
 221         friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
 222                                     ostreambuf_iterator<_CharT2> >::__type
 223         copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
 224              ostreambuf_iterator<_CharT2>);
 225
 226     private:
 227       streambuf_type*   _M_sbuf;
 228       bool              _M_failed;
 229
 230     public:
 231       ///  Construct output iterator from ostream.
 232       ostreambuf_iterator(ostream_type& __s) throw ()
 233       : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
 234
 235       ///  Construct output iterator from streambuf.
 236       ostreambuf_iterator(streambuf_type* __s) throw ()
 237       : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
 238
 239       ///  Write character to streambuf.  Calls streambuf.sputc().
 240       ostreambuf_iterator&
 241       operator=(_CharT __c)
 242       {
 243         if (!_M_failed &&
 244             _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
 245           _M_failed = true;
 246         return *this;
 247       }
 248
 249       /// Return *this.
 250       ostreambuf_iterator&
 251       operator*()
 252       { return *this; }
 253
 254       /// Return *this.
 255       ostreambuf_iterator&
 256       operator++(int)
 257       { return *this; }
 258
 259       /// Return *this.
 260       ostreambuf_iterator&
 261       operator++()
 262       { return *this; }
 263
 264       /// Return true if previous operator=() failed.
 265       bool
 266       failed() const throw()
 267       { return _M_failed; }
 268
 269       ostreambuf_iterator&
 270       _M_put(const _CharT* __ws, streamsize __len)
 271       {
 272         if (__builtin_expect(!_M_failed, true)
 273             && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
 274                                 false))
 275           _M_failed = true;
 276         return *this;
 277       }
 278     };
 279
 280   // Overloads for streambuf iterators.
 281   template<typename _CharT>
 282     typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
 283                                     ostreambuf_iterator<_CharT> >::__type
 284     copy(istreambuf_iterator<_CharT> __first,
 285          istreambuf_iterator<_CharT> __last,
 286          ostreambuf_iterator<_CharT> __result)
 287     {
 288       if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
 289         {
 290           bool __ineof;
 291           __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
 292           if (!__ineof)
 293             __result._M_failed = true;
 294         }
 295       return __result;
 296     }
 297
 298   template<typename _CharT>
 299     typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
 300                                     ostreambuf_iterator<_CharT> >::__type
 301     __copy_aux(_CharT* __first, _CharT* __last,
 302                ostreambuf_iterator<_CharT> __result)
 303     {
 304       const streamsize __num = __last - __first;
 305       if (__num > 0)
 306         __result._M_put(__first, __num);
 307       return __result;
 308     }
 309
 310   template<typename _CharT>
 311     typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
 312                                     ostreambuf_iterator<_CharT> >::__type
 313     __copy_aux(const _CharT* __first, const _CharT* __last,
 314                ostreambuf_iterator<_CharT> __result)
 315     {
 316       const streamsize __num = __last - __first;
 317       if (__num > 0)
 318         __result._M_put(__first, __num);
 319       return __result;
 320     }
 321
 322   template<typename _CharT>
 323     typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
 324                                     _CharT*>::__type
 325     __copy_aux(istreambuf_iterator<_CharT> __first,
 326                istreambuf_iterator<_CharT> __last, _CharT* __result)
 327     {
 328       typedef istreambuf_iterator<_CharT>                  __is_iterator_type;
 329       typedef typename __is_iterator_type::traits_type     traits_type;
 330       typedef typename __is_iterator_type::streambuf_type  streambuf_type;
 331       typedef typename traits_type::int_type               int_type;
 332
 333       if (__first._M_sbuf && !__last._M_sbuf)
 334         {
 335           streambuf_type* __sb = __first._M_sbuf;
 336           int_type __c = __sb->sgetc();
 337           while (!traits_type::eq_int_type(__c, traits_type::eof()))
 338             {
 339               const streamsize __n = __sb->egptr() - __sb->gptr();
 340               if (__n > 1)
 341                 {
 342                   traits_type::copy(__result, __sb->gptr(), __n);
 343                   __sb->gbump(__n);
 344                   __result += __n;
 345                   __c = __sb->underflow();
 346                 }
 347               else
 348                 {
 349                   *__result++ = traits_type::to_char_type(__c);
 350                   __c = __sb->snextc();
 351                 }
 352             }
 353         }
 354       return __result;
 355     }
 356
 357   template<typename _CharT>
 358     typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
 359                                     istreambuf_iterator<_CharT> >::__type
 360     find(istreambuf_iterator<_CharT> __first,
 361          istreambuf_iterator<_CharT> __last, const _CharT& __val)
 362     {
 363       typedef istreambuf_iterator<_CharT>                  __is_iterator_type;
 364       typedef typename __is_iterator_type::traits_type     traits_type;
 365       typedef typename __is_iterator_type::streambuf_type  streambuf_type;
 366       typedef typename traits_type::int_type               int_type;
 367
 368       if (__first._M_sbuf && !__last._M_sbuf)
 369         {
 370           const int_type __ival = traits_type::to_int_type(__val);
 371           streambuf_type* __sb = __first._M_sbuf;
 372           int_type __c = __sb->sgetc();
 373           while (!traits_type::eq_int_type(__c, traits_type::eof())
 374                  && !traits_type::eq_int_type(__c, __ival))
 375             {
 376               streamsize __n = __sb->egptr() - __sb->gptr();
 377               if (__n > 1)
 378                 {
 379                   const _CharT* __p = traits_type::find(__sb->gptr(),
 380                                                         __n, __val);
 381                   if (__p)
 382                     __n = __p - __sb->gptr();
 383                   __sb->gbump(__n);
 384                   __c = __sb->sgetc();
 385                 }
 386               else
 387                 __c = __sb->snextc();
 388             }
 389
 390           if (!traits_type::eq_int_type(__c, traits_type::eof()))
 391             __first._M_c = __c;
 392           else
 393             __first._M_sbuf = 0;
 394         }
 395       return __first;
 396     }
 397
 398 _GLIBCXX_END_NAMESPACE
 399
 400 #endif