contrib/gcc-4.4/libstdc++-v3/include/bits/stream_iterator.h

   1 // Stream iterators
   2
   3 // Copyright (C) 2001, 2004, 2005, 2009 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 stream_iterator.h
  26  *  This is an internal header file, included by other library headers.
  27  *  You should not attempt to use it directly.
  28  */
  29
  30 #ifndef _STREAM_ITERATOR_H
  31 #define _STREAM_ITERATOR_H 1
  32
  33 #pragma GCC system_header
  34
  35 #include <debug/debug.h>
  36
  37 _GLIBCXX_BEGIN_NAMESPACE(std)
  38
  39   /// Provides input iterator semantics for streams.
  40   template<typename _Tp, typename _CharT = char,
  41            typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
  42     class istream_iterator
  43     : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
  44     {
  45     public:
  46       typedef _CharT                         char_type;
  47       typedef _Traits                        traits_type;
  48       typedef basic_istream<_CharT, _Traits> istream_type;
  49
  50     private:
  51       istream_type*     _M_stream;
  52       _Tp               _M_value;
  53       bool              _M_ok;
  54
  55     public:
  56       ///  Construct end of input stream iterator.
  57       istream_iterator()
  58       : _M_stream(0), _M_value(), _M_ok(false) {}
  59
  60       ///  Construct start of input stream iterator.
  61       istream_iterator(istream_type& __s)
  62       : _M_stream(&__s)
  63       { _M_read(); }
  64
  65       istream_iterator(const istream_iterator& __obj)
  66       : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
  67         _M_ok(__obj._M_ok)
  68       { }
  69
  70       const _Tp&
  71       operator*() const
  72       {
  73         __glibcxx_requires_cond(_M_ok,
  74                                 _M_message(__gnu_debug::__msg_deref_istream)
  75                                 ._M_iterator(*this));
  76         return _M_value;
  77       }
  78
  79       const _Tp*
  80       operator->() const { return &(operator*()); }
  81
  82       istream_iterator&
  83       operator++()
  84       {
  85         __glibcxx_requires_cond(_M_ok,
  86                                 _M_message(__gnu_debug::__msg_inc_istream)
  87                                 ._M_iterator(*this));
  88         _M_read();
  89         return *this;
  90       }
  91
  92       istream_iterator
  93       operator++(int)
  94       {
  95         __glibcxx_requires_cond(_M_ok,
  96                                 _M_message(__gnu_debug::__msg_inc_istream)
  97                                 ._M_iterator(*this));
  98         istream_iterator __tmp = *this;
  99         _M_read();
 100         return __tmp;
 101       }
 102
 103       bool
 104       _M_equal(const istream_iterator& __x) const
 105       { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
 106
 107     private:
 108       void
 109       _M_read()
 110       {
 111         _M_ok = (_M_stream && *_M_stream) ? true : false;
 112         if (_M_ok)
 113           {
 114             *_M_stream >> _M_value;
 115             _M_ok = *_M_stream ? true : false;
 116           }
 117       }
 118     };
 119
 120   ///  Return true if x and y are both end or not end, or x and y are the same.
 121   template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
 122     inline bool
 123     operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
 124                const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
 125     { return __x._M_equal(__y); }
 126
 127   ///  Return false if x and y are both end or not end, or x and y are the same.
 128   template <class _Tp, class _CharT, class _Traits, class _Dist>
 129     inline bool
 130     operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
 131                const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
 132     { return !__x._M_equal(__y); }
 133
 134   /**
 135    *  @brief  Provides output iterator semantics for streams.
 136    *
 137    *  This class provides an iterator to write to an ostream.  The type Tp is
 138    *  the only type written by this iterator and there must be an
 139    *  operator<<(Tp) defined.
 140    *
 141    *  @param  Tp  The type to write to the ostream.
 142    *  @param  CharT  The ostream char_type.
 143    *  @param  Traits  The ostream char_traits.
 144   */
 145   template<typename _Tp, typename _CharT = char,
 146            typename _Traits = char_traits<_CharT> >
 147     class ostream_iterator
 148     : public iterator<output_iterator_tag, void, void, void, void>
 149     {
 150     public:
 151       //@{
 152       /// Public typedef
 153       typedef _CharT                         char_type;
 154       typedef _Traits                        traits_type;
 155       typedef basic_ostream<_CharT, _Traits> ostream_type;
 156       //@}
 157
 158     private:
 159       ostream_type*     _M_stream;
 160       const _CharT*     _M_string;
 161
 162     public:
 163       /// Construct from an ostream.
 164       ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
 165
 166       /**
 167        *  Construct from an ostream.
 168        *
 169        *  The delimiter string @a c is written to the stream after every Tp
 170        *  written to the stream.  The delimiter is not copied, and thus must
 171        *  not be destroyed while this iterator is in use.
 172        *
 173        *  @param  s  Underlying ostream to write to.
 174        *  @param  c  CharT delimiter string to insert.
 175       */
 176       ostream_iterator(ostream_type& __s, const _CharT* __c)
 177       : _M_stream(&__s), _M_string(__c)  { }
 178
 179       /// Copy constructor.
 180       ostream_iterator(const ostream_iterator& __obj)
 181       : _M_stream(__obj._M_stream), _M_string(__obj._M_string)  { }
 182
 183       /// Writes @a value to underlying ostream using operator<<.  If
 184       /// constructed with delimiter string, writes delimiter to ostream.
 185       ostream_iterator&
 186       operator=(const _Tp& __value)
 187       {
 188         __glibcxx_requires_cond(_M_stream != 0,
 189                                 _M_message(__gnu_debug::__msg_output_ostream)
 190                                 ._M_iterator(*this));
 191         *_M_stream << __value;
 192         if (_M_string) *_M_stream << _M_string;
 193         return *this;
 194       }
 195
 196       ostream_iterator&
 197       operator*()
 198       { return *this; }
 199
 200       ostream_iterator&
 201       operator++()
 202       { return *this; }
 203
 204       ostream_iterator&
 205       operator++(int)
 206       { return *this; }
 207     };
 208
 209 _GLIBCXX_END_NAMESPACE
 210
 211 #endif