LTP GCOV extension - code coverage report
Current view: directory - usr/include/c++/4.3/bits - stream_iterator.h
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 33
Code covered: 100.0 % Executed lines: 33

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

Generated by: LTP GCOV extension version 1.6