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