std_iterator.h: Include sbuf_iter.h via std_ios.h.

2001-06-26  Benjamin Kosnik  <bkoz@redhat.com>

	* include/bits/std_iterator.h: Include sbuf_iter.h via std_ios.h.

	* include/bits/stl_iterator.h (istream_iterator): Inherit from
	iterator.
	(ostream_iterator): Same.
	* testsuite/24_iterators/istream_iterator.cc: New file.
	* testsuite/24_iterators/ostream_iterator.cc: New file.

	* include/bits/sbuf_iter.h: Remove self typedef.
	* testsuite/24_iterators/ostreambuf_iterator.cc: Add test.
	* testsuite/24_iterators/istreambuf_iterator.cc: Add test.

	* include/bits/stl_iterator.h (reverse_iterator): Remove
	extraneous typedefs. Add typename.
	(__normal_iterator): Remove typedefs referring to self. Add typename.
	(reverse_bidiretional_iterator): Remove, not longer required.

From-SVN: r43570

libstdc++-v3/ChangeLog

+2001-06-26  Benjamin Kosnik  <bkoz@redhat.com>
+
+	* include/bits/std_iterator.h: Include sbuf_iter.h via std_ios.h.
+
+	* include/bits/stl_iterator.h (istream_iterator): Inherit from
+	iterator.
+	(ostream_iterator): Same.
+	* testsuite/24_iterators/istream_iterator.cc: New file.
+	* testsuite/24_iterators/ostream_iterator.cc: New file.
+	
+	* include/bits/sbuf_iter.h: Remove self typedef.
+	* testsuite/24_iterators/ostreambuf_iterator.cc: Add test.
+	* testsuite/24_iterators/istreambuf_iterator.cc: Add test.
+	
+	* include/bits/stl_iterator.h (reverse_iterator): Remove
+	extraneous typedefs. Add typename.
+	(__normal_iterator): Remove typedefs referring to self. Add typename.
+	(reverse_bidiretional_iterator): Remove, not longer required.
+
 2001-06-26  Gabriel Dos Reis  <gdr@merlin.codesourcery.com>
 
 	* include/bits/stl_iterator.h (__normal_iterator<>): Qualify

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

@@ -103,8 +103,6 @@ namespace std
       typedef typename _Traits::int_type     		int_type;
       typedef basic_streambuf<_CharT, _Traits> 		streambuf_type;
       typedef basic_istream<_CharT, _Traits>         	istream_type;
-      // Non-standard Types:
-      typedef istreambuf_iterator<_CharT, _Traits>	__istreambufiter_type;
 
     private:
       // 24.5.3 istreambuf_iterator 
@@ -144,7 +142,7 @@ namespace std
 	return __ret;
       }
 	
-      __istreambufiter_type& 
+      istreambuf_iterator& 
       operator++()
       { 
 	if (_M_sbuf)
@@ -153,10 +151,10 @@ namespace std
 	return *this; 
       }
 
-      __istreambufiter_type
+      istreambuf_iterator
       operator++(int)
       {
-	__istreambufiter_type __old = *this;
+	istreambuf_iterator __old = *this;
 	if (_M_sbuf)
 	  __old._M_c = _M_sbuf->sbumpc();
 	_M_c = -2;
@@ -164,7 +162,7 @@ namespace std
       }
 
       bool 
-      equal(const __istreambufiter_type& __b)
+      equal(const istreambuf_iterator& __b)
       { 
 	int_type __eof = traits_type::eof();
 	bool __thiseof = !_M_sbuf || _M_sbuf->sgetc() == __eof;
@@ -177,7 +175,7 @@ namespace std
       // 110 istreambuf_iterator::equal not const
       // NB: there is also number 111 pending on this function.
       bool 
-      equal(const __istreambufiter_type& __b) const
+      equal(const istreambuf_iterator& __b) const
       {
 	int_type __eof = traits_type::eof();
 	bool __thiseof = !_M_sbuf || _M_sbuf->sgetc() == __eof;

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

@@ -34,101 +34,98 @@
 namespace std
 {
   // 24.4.1 Reverse iterators
-  template<class _Iterator>
+  template<typename _Iterator>
     class reverse_iterator 
-      : public iterator<iterator_traits<_Iterator>::iterator_category,
-			iterator_traits<_Iterator>::value_type,
-		        iterator_traits<_Iterator>::difference_type,
-		        iterator_traits<_Iterator>::pointer,
-                        iterator_traits<_Iterator>::reference>
+      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
+			typename iterator_traits<_Iterator>::value_type,
+		        typename iterator_traits<_Iterator>::difference_type,
+		        typename iterator_traits<_Iterator>::pointer,
+                        typename iterator_traits<_Iterator>::reference>
     {
     protected:
-      _Iterator current;
+      _Iterator _M_current;
 
     public:
-      typedef iterator_traits<_Iterator>  		__traits_type;
-      typedef typename __traits_type::iterator_category	iterator_category;
-      typedef typename __traits_type::value_type 	value_type;
-      typedef typename __traits_type::difference_type 	difference_type;
-      typedef typename __traits_type::pointer          	pointer;
-      typedef typename __traits_type::reference 	reference;
-
-      typedef _Iterator iterator_type;
-      typedef reverse_iterator<_Iterator> _Self;
+      typedef _Iterator 				       iterator_type;
+      typedef typename iterator_traits<_Iterator>::difference_type 	
+      							       difference_type;
+      typedef typename iterator_traits<_Iterator>::reference   reference;
+      typedef typename iterator_traits<_Iterator>::pointer     pointer;
 
     public:
       reverse_iterator() {}
 
       explicit 
-      reverse_iterator(iterator_type __x) : current(__x) {}
+      reverse_iterator(iterator_type __x) : _M_current(__x) {}
 
-      reverse_iterator(const _Self& __x) : current(__x.current) {}
+      reverse_iterator(const reverse_iterator& __x) 
+	: _M_current(__x._M_current) { }
 
-      template <class _Iter>
+      template<typename _Iter>
         reverse_iterator(const reverse_iterator<_Iter>& __x)
-	: current(__x.base()) {}
+	: _M_current(__x.base()) {}
     
       iterator_type 
-      base() const { return current; }
+      base() const { return _M_current; }
 
       reference 
       operator*() const 
       {
-	_Iterator __tmp = current;
+	_Iterator __tmp = _M_current;
 	return *--__tmp;
       }
 
       pointer 
       operator->() const { return &(operator*()); }
 
-      _Self& 
+      reverse_iterator& 
       operator++() 
       {
-	--current;
+	--_M_current;
 	return *this;
       }
 
-      _Self 
+      reverse_iterator 
       operator++(int) 
       {
-	_Self __tmp = *this;
-	--current;
+	reverse_iterator __tmp = *this;
+	--_M_current;
 	return __tmp;
       }
 
-      _Self& 
+      reverse_iterator& 
       operator--() 
       {
-	++current;
+	++_M_current;
 	return *this;
       }
 
-      _Self operator--(int) 
+      reverse_iterator operator--(int) 
       {
-	_Self __tmp = *this;
-	++current;
+	reverse_iterator __tmp = *this;
+	++_M_current;
 	return __tmp;
       }
       
-      _Self 
+      reverse_iterator 
       operator+(difference_type __n) const 
-      { return _Self(current - __n); }
+      { return reverse_iterator(_M_current - __n); }
 
-      _Self& 
+      reverse_iterator& 
       operator+=(difference_type __n) 
       {
-	current -= __n;
+	_M_current -= __n;
 	return *this;
       }
 
-      _Self 
+      reverse_iterator 
       operator-(difference_type __n) const 
-      { return _Self(current + __n); }
+      { return reverse_iterator(_M_current + __n); }
 
-      _Self& 
+      reverse_iterator& 
       operator-=(difference_type __n) 
       {
-	current += __n;
+	_M_current += __n;
 	return *this;
       }
 
@@ -136,56 +133,56 @@ namespace std
       operator[](difference_type __n) const { return *(*this + __n); }  
     }; 
  
-  template<class _Iterator>
+  template<typename _Iterator>
     inline bool 
     operator==(const reverse_iterator<_Iterator>& __x, 
 	       const reverse_iterator<_Iterator>& __y) 
     { return __x.base() == __y.base(); }
 
-  template <class _Iterator>
+  template<typename _Iterator>
     inline bool 
     operator<(const reverse_iterator<_Iterator>& __x, 
 	      const reverse_iterator<_Iterator>& __y) 
     { return __y.base() < __x.base(); }
 
-  template <class _Iterator>
+  template<typename _Iterator>
     inline bool 
     operator!=(const reverse_iterator<_Iterator>& __x, 
 	       const reverse_iterator<_Iterator>& __y) 
     { return !(__x == __y); }
 
-  template <class _Iterator>
+  template<typename _Iterator>
     inline bool 
     operator>(const reverse_iterator<_Iterator>& __x, 
 	      const reverse_iterator<_Iterator>& __y) 
     { return __y < __x; }
 
-  template <class _Iterator>
+  template<typename _Iterator>
     inline bool 
     operator<=(const reverse_iterator<_Iterator>& __x, 
 		const reverse_iterator<_Iterator>& __y) 
     { return !(__y < __x); }
 
-  template <class _Iterator>
+  template<typename _Iterator>
     inline bool 
     operator>=(const reverse_iterator<_Iterator>& __x, 
 	       const reverse_iterator<_Iterator>& __y) 
     { return !(__x < __y); }
 
-  template<class _Iterator>
+  template<typename _Iterator>
     inline typename reverse_iterator<_Iterator>::difference_type
     operator-(const reverse_iterator<_Iterator>& __x, 
 	      const reverse_iterator<_Iterator>& __y) 
     { return __y.base() - __x.base(); }
 
-  template <class _Iterator>
+  template<typename _Iterator>
     inline reverse_iterator<_Iterator> 
     operator+(typename reverse_iterator<_Iterator>::difference_type __n,
 	      const reverse_iterator<_Iterator>& __x) 
     { return reverse_iterator<_Iterator>(__x.base() - __n); }
 
   // 24.4.2.2.1 back_insert_iterator
-  template <class _Container>
+  template<typename _Container>
   class back_insert_iterator 
     : public iterator<output_iterator_tag, void, void, void, void>
     {
@@ -215,12 +212,12 @@ namespace std
       operator++(int) { return *this; }
     };
 
-  template <class _Container>
+  template<typename _Container>
     inline back_insert_iterator<_Container> 
     back_inserter(_Container& __x) 
     { return back_insert_iterator<_Container>(__x); }
 
-  template <class _Container>
+  template<typename _Container>
     class front_insert_iterator 
       : public iterator<output_iterator_tag, void, void, void, void>
     {
@@ -241,12 +238,11 @@ namespace std
       front_insert_iterator<_Container>& operator++(int) { return *this; }
     };
 
-  template <class _Container>
-  inline front_insert_iterator<_Container> front_inserter(_Container& __x) {
-    return front_insert_iterator<_Container>(__x);
-  }
+  template<typename _Container>
+  inline front_insert_iterator<_Container> front_inserter(_Container& __x) 
+  { return front_insert_iterator<_Container>(__x); }
 
-  template <class _Container>
+  template<typename _Container>
     class insert_iterator 
       : public iterator<output_iterator_tag, void, void, void, void>
     {
@@ -271,304 +267,248 @@ namespace std
       insert_iterator<_Container>& operator++(int) { return *this; }
     };
   
-  template <class _Container, class _Iterator>
-  inline 
-  insert_iterator<_Container> inserter(_Container& __x, _Iterator __i)
-  {
-    typedef typename _Container::iterator __iter;
-    return insert_iterator<_Container>(__x, __iter(__i));
-  }
+  template<typename _Container, typename _Iterator>
+    inline 
+    insert_iterator<_Container> inserter(_Container& __x, _Iterator __i)
+    {
+      typedef typename _Container::iterator __iter;
+      return insert_iterator<_Container>(__x, __iter(__i));
+    }
   
-  template <class _BidirectionalIterator, class _Tp, class _Reference = _Tp&, 
-    class _Distance = ptrdiff_t> 
-  class reverse_bidirectional_iterator {
-    typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, 
-      _Reference, _Distance>  _Self;
-  protected:
-    _BidirectionalIterator current;
-  public:
-    typedef bidirectional_iterator_tag iterator_category;
-  typedef _Tp                        value_type;
-    typedef _Distance                  difference_type;
-  typedef _Tp*                       pointer;
-    typedef _Reference                 reference;
-    
-  reverse_bidirectional_iterator() {}
-    explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
-      : current(__x) {}
-    _BidirectionalIterator base() const { return current; }
-    _Reference operator*() const {
-      _BidirectionalIterator __tmp = current;
-    return *--__tmp;
-  }
-  pointer operator->() const { return &(operator*()); }
-  _Self& operator++() {
-    --current;
-    return *this;
-  }
-  _Self operator++(int) {
-    _Self __tmp = *this;
-    --current;
-    return __tmp;
-  }
-  _Self& operator--() {
-    ++current;
-    return *this;
-  }
-  _Self operator--(int) {
-    _Self __tmp = *this;
-    ++current;
-    return __tmp;
-  }
-};
-
-template <class _BiIter, class _Tp, class _Ref, class _Distance>
-inline bool operator==(
-    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x, 
-    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
-{
-  return __x.base() == __y.base();
-}
 
-template <class _BiIter, class _Tp, class _Ref, class _Distance>
-inline bool operator!=(
-    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x, 
-    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
-{
-  return !(__x == __y);
-}
-
-
-
-template <class _Tp, 
-          class _CharT = char, class _Traits = char_traits<_CharT>,
-          class _Dist = ptrdiff_t> 
-class istream_iterator {
-public:
-  typedef _CharT                         char_type;
-  typedef _Traits                        traits_type;
-  typedef basic_istream<_CharT, _Traits> istream_type;
-
-  typedef input_iterator_tag             iterator_category;
-  typedef _Tp                            value_type;
-  typedef _Dist                          difference_type;
-  typedef const _Tp*                     pointer;
-  typedef const _Tp&                     reference;
-
-  istream_iterator() : _M_stream(0), _M_ok(false) {}
-  istream_iterator(istream_type& __s) : _M_stream(&__s) { _M_read(); }
-
-  reference operator*() const { return _M_value; }
-  pointer operator->() const { return &(operator*()); }
-
-  istream_iterator& operator++() { 
-    _M_read(); 
-    return *this;
-  }
-  istream_iterator operator++(int)  {
-    istream_iterator __tmp = *this;
-    _M_read();
-    return __tmp;
-  }
-
-  bool _M_equal(const istream_iterator& __x) const
-    { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
-
-private:
-  istream_type* _M_stream;
-  _Tp _M_value;
-  bool _M_ok;
-
-  void _M_read() {
-    _M_ok = (_M_stream && *_M_stream) ? true : false;
-    if (_M_ok) {
-      *_M_stream >> _M_value;
-      _M_ok = *_M_stream ? true : false;
-    }
-  }
-};
-
-template <class _Tp, class _CharT, class _Traits, class _Dist>
-inline bool 
-operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
-           const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) {
-  return __x._M_equal(__y);
-}
-
-template <class _Tp, class _CharT, class _Traits, class _Dist>
-inline bool 
-operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
-           const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) {
-  return !__x._M_equal(__y);
-}
-
-
-template <class _Tp,
-          class _CharT = char, class _Traits = char_traits<_CharT> >
-class ostream_iterator {
-public:
-  typedef _CharT                         char_type;
-  typedef _Traits                        traits_type;
-  typedef basic_ostream<_CharT, _Traits> ostream_type;
-
-  typedef output_iterator_tag            iterator_category;
-  typedef void                           value_type;
-  typedef void                           difference_type;
-  typedef void                           pointer;
-  typedef void                           reference;
-
-  ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
-  ostream_iterator(ostream_type& __s, const _CharT* __c) 
-    : _M_stream(&__s), _M_string(__c)  {}
-  ostream_iterator<_Tp>& operator=(const _Tp& __value) { 
-    *_M_stream << __value;
-    if (_M_string) *_M_stream << _M_string;
-    return *this;
-  }
-  ostream_iterator<_Tp>& operator*() { return *this; }
-  ostream_iterator<_Tp>& operator++() { return *this; } 
-  ostream_iterator<_Tp>& operator++(int) { return *this; } 
-private:
-  ostream_type* _M_stream;
-  const _CharT* _M_string;
-};
-
-
-// This iterator adapter is 'normal' in the sense that it does not
-// change the semantics of any of the operators of its itererator
-// parameter.  Its primary purpose is to convert an iterator that is
-// not a class, e.g. a pointer, into an iterator that is a class.
-// The _Container parameter exists solely so that different containers
-// using this template can instantiate different types, even if the
-// _Iterator parameter is the same.
-template<typename _Iterator, typename _Container>
-class __normal_iterator
-  : public iterator<typename iterator_traits<_Iterator>::iterator_category,
-                    typename iterator_traits<_Iterator>::value_type,
-                    typename iterator_traits<_Iterator>::difference_type,
-                    typename iterator_traits<_Iterator>::pointer,
-                    typename iterator_traits<_Iterator>::reference>
-{
-  typedef iterator_traits<_Iterator> _Traits;
+  template<typename _Tp, typename _CharT = char, 
+           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t> 
+    class istream_iterator 
+      : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
+    {
+    public:
+      typedef _CharT                         char_type;
+      typedef _Traits                        traits_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+
+    private:
+      istream_type* 	_M_stream;
+      _Tp 		_M_value;
+      bool 		_M_ok;
+
+    public:      
+      istream_iterator() : _M_stream(0), _M_ok(false) {}
+      istream_iterator(istream_type& __s) : _M_stream(&__s) { _M_read(); }
+
+      reference 
+      operator*() const { return _M_value; }
+
+      pointer 
+      operator->() const { return &(operator*()); }
+
+      istream_iterator& 
+      operator++() 
+      { _M_read(); return *this; }
+
+      istream_iterator 
+      operator++(int)  
+      {
+	istream_iterator __tmp = *this;
+	_M_read();
+	return __tmp;
+      }
+
+      bool 
+      _M_equal(const istream_iterator& __x) const
+      { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream);}
+
+    private:      
+      void _M_read() 
+      {
+	_M_ok = (_M_stream && *_M_stream) ? true : false;
+	if (_M_ok) 
+	  {
+	    *_M_stream >> _M_value;
+	    _M_ok = *_M_stream ? true : false;
+	  }
+      }
+    };
   
-protected:
-  _Iterator _M_current;
+  template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
+    inline bool 
+    operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
+	       const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) 
+    { return __x._M_equal(__y); }
 
-public:
-  typedef __normal_iterator<_Iterator, _Container> normal_iterator_type;
-  typedef typename _Traits::iterator_category iterator_category;
-  typedef typename _Traits::value_type value_type;
-  typedef typename _Traits::difference_type difference_type;
-  typedef typename _Traits::pointer pointer;
-  typedef typename _Traits::reference reference;
+  template <class _Tp, class _CharT, class _Traits, class _Dist>
+    inline bool 
+  operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
+	     const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) 
+  { return !__x._M_equal(__y); }
+
+
+  template<typename _Tp, typename _CharT = char, 
+           typename _Traits = char_traits<_CharT> >
+    class ostream_iterator 
+      : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+      typedef _CharT                         char_type;
+      typedef _Traits                        traits_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
 
-  __normal_iterator() : _M_current(_Iterator()) { }
+    private:
+      ostream_type* 	_M_stream;
+      const _CharT* 	_M_string;
 
-  explicit __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
+    public:
+      ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
+      ostream_iterator(ostream_type& __s, const _CharT* __c) 
+	: _M_stream(&__s), _M_string(__c)  { }
 
-  // Allow iterator to const_iterator conversion
-  template<typename _Iter>
-  inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
-    : _M_current(__i.base()) { }
+      ostream_iterator& 
+      operator=(const _Tp& __value) 
+      { 
+	*_M_stream << __value;
+	if (_M_string) *_M_stream << _M_string;
+	return *this;
+      }
+      
+      ostream_iterator& 
+      operator*() { return *this; }
+      
+      ostream_iterator& 
+      operator++() { return *this; } 
+      
+      ostream_iterator& 
+      operator++(int) { return *this; } 
+    };
+  
+  
+  // This iterator adapter is 'normal' in the sense that it does not
+  // change the semantics of any of the operators of its itererator
+  // parameter.  Its primary purpose is to convert an iterator that is
+  // not a class, e.g. a pointer, into an iterator that is a class.
+  // The _Container parameter exists solely so that different containers
+  // using this template can instantiate different types, even if the
+  // _Iterator parameter is the same.
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator
+      : public iterator<typename iterator_traits<_Iterator>::iterator_category,
+                        typename iterator_traits<_Iterator>::value_type,
+                        typename iterator_traits<_Iterator>::difference_type,
+                        typename iterator_traits<_Iterator>::pointer,
+                        typename iterator_traits<_Iterator>::reference>
+    {
+    protected:
+      _Iterator _M_current;
+      
+    public:
+      typedef typename iterator_traits<_Iterator>::difference_type 	
+      							       difference_type;
+      typedef typename iterator_traits<_Iterator>::reference   reference;
+      typedef typename iterator_traits<_Iterator>::pointer     pointer;
 
-  // Forward iterator requirements
-  reference
-  operator*() const { return *_M_current; }
+      __normal_iterator() : _M_current(_Iterator()) { }
 
-  pointer
-  operator->() const { return _M_current; }
+      explicit 
+      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
 
-  normal_iterator_type&
-  operator++() { ++_M_current; return *this; }
+      // Allow iterator to const_iterator conversion
+      template<typename _Iter>
+      inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
+	: _M_current(__i.base()) { }
 
-  normal_iterator_type
-  operator++(int) { return __normal_iterator(_M_current++); }
+      // Forward iterator requirements
+      reference
+      operator*() const { return *_M_current; }
+      
+      pointer
+      operator->() const { return _M_current; }
+      
+      __normal_iterator&
+      operator++() { ++_M_current; return *this; }
+      
+      __normal_iterator
+      operator++(int) { return __normal_iterator(_M_current++); }
+      
+      // Bidirectional iterator requirements
+      __normal_iterator&
+      operator--() { --_M_current; return *this; }
+      
+      __normal_iterator
+      operator--(int) { return __normal_iterator(_M_current--); }
+      
+      // Random access iterator requirements
+      reference
+      operator[](const difference_type& __n) const
+      { return _M_current[__n]; }
+      
+      __normal_iterator&
+      operator+=(const difference_type& __n)
+      { _M_current += __n; return *this; }
 
-  // Bidirectional iterator requirements
-  normal_iterator_type&
-  operator--() { --_M_current; return *this; }
+      __normal_iterator
+      operator+(const difference_type& __n) const
+      { return __normal_iterator(_M_current + __n); }
+      
+      __normal_iterator&
+      operator-=(const difference_type& __n)
+      { _M_current -= __n; return *this; }
+      
+      __normal_iterator
+      operator-(const difference_type& __n) const
+      { return __normal_iterator(_M_current - __n); }
+      
+      difference_type
+      operator-(const __normal_iterator& __i) const
+      { return _M_current - __i._M_current; }
+      
+      const _Iterator& 
+      base() const { return _M_current; }
+    };
 
-  normal_iterator_type
-  operator--(int) { return __normal_iterator(_M_current--); }
+  // Forward iterator requirements
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+  inline bool
+  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	     const __normal_iterator<_IteratorR, _Container>& __rhs)
+  { return __lhs.base() == __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+  inline bool
+  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	     const __normal_iterator<_IteratorR, _Container>& __rhs)
+  { return !(__lhs == __rhs); }
 
   // Random access iterator requirements
-  reference
-  operator[](const difference_type& __n) const
-  { return _M_current[__n]; }
-
-  normal_iterator_type&
-  operator+=(const difference_type& __n)
-  { _M_current += __n; return *this; }
-
-  normal_iterator_type
-  operator+(const difference_type& __n) const
-  { return __normal_iterator(_M_current + __n); }
-
-  normal_iterator_type&
-  operator-=(const difference_type& __n)
-  { _M_current -= __n; return *this; }
-
-  normal_iterator_type
-  operator-(const difference_type& __n) const
-  { return __normal_iterator(_M_current - __n); }
-
-  difference_type
-  operator-(const normal_iterator_type& __i) const
-  { return _M_current - __i._M_current; }
-
-  const _Iterator& 
-  base() const { return _M_current; }
-};
-
-// forward iterator requirements
-
-template<typename _IteratorL, typename _IteratorR, typename _Container>
-inline bool
-operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
-	   const __normal_iterator<_IteratorR, _Container>& __rhs)
-{ return __lhs.base() == __rhs.base(); }
-
-template<typename _IteratorL, typename _IteratorR, typename _Container>
-inline bool
-operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-	   const __normal_iterator<_IteratorR, _Container>& __rhs)
-{ return !(__lhs == __rhs); }
-
-// random access iterator requirements
-
-template<typename _IteratorL, typename _IteratorR, typename _Container>
-inline bool 
-operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
-	  const __normal_iterator<_IteratorR, _Container>& __rhs)
-{ return __lhs.base() < __rhs.base(); }
-
-template<typename _IteratorL, typename _IteratorR, typename _Container>
-inline bool
-operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
-	  const __normal_iterator<_IteratorR, _Container>& __rhs)
-{ return __rhs < __lhs; }
-
-template<typename _IteratorL, typename _IteratorR, typename _Container>
-inline bool
-operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-	   const __normal_iterator<_IteratorR, _Container>& __rhs)
-{ return !(__rhs < __lhs); }
-
-template<typename _IteratorL, typename _IteratorR, typename _Container>
-inline bool
-operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-	   const __normal_iterator<_IteratorR, _Container>& __rhs)
-{ return !(__lhs < __rhs); }
-
-template<typename _Iterator, typename _Container>
-inline __normal_iterator<_Iterator, _Container>
-operator+(__normal_iterator<_Iterator, _Container>::difference_type __n,
-          const __normal_iterator<_Iterator, _Container>& __i)
-{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
-
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+  inline bool 
+  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	    const __normal_iterator<_IteratorR, _Container>& __rhs)
+  { return __lhs.base() < __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+  inline bool
+  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	    const __normal_iterator<_IteratorR, _Container>& __rhs)
+  { return __rhs < __lhs; }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+  inline bool
+  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	     const __normal_iterator<_IteratorR, _Container>& __rhs)
+  { return !(__rhs < __lhs); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+  inline bool
+  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+	     const __normal_iterator<_IteratorR, _Container>& __rhs)
+  { return !(__lhs < __rhs); }
+
+  template<typename _Iterator, typename _Container>
+  inline __normal_iterator<_Iterator, _Container>
+  operator+(__normal_iterator<_Iterator, _Container>::difference_type __n,
+	    const __normal_iterator<_Iterator, _Container>& __i)
+  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
 } // namespace std
 
-#endif /* __SGI_STL_INTERNAL_ITERATOR_H */
+#endif 
 
 // Local Variables:
 // mode:C++

libstdc++-v3/testsuite/24_iterators/istream_iterator.cc

+// 2001-06-25  Benjamin Kosnik  <bkoz@redhat.com>
+
+// Copyright (C) 2001 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// 24.5.1 Template class istream_iterator
+
+#include <iterator>
+
+void test01()
+{
+  using namespace std;
+
+  // Check for required base class.
+  typedef istream_iterator<long> test_iterator;
+  typedef iterator<input_iterator_tag, long, ptrdiff_t, const long*, 
+    		   const long&> base_iterator;
+  test_iterator  r_it;
+  base_iterator* base = &r_it;
+
+  // Check for required typedefs
+  typedef test_iterator::value_type value_type;
+  typedef test_iterator::difference_type difference_type;
+  typedef test_iterator::pointer pointer;
+  typedef test_iterator::reference reference;
+  typedef test_iterator::iterator_category iteratory_category;
+
+  typedef test_iterator::char_type char_type;
+  typedef test_iterator::traits_type traits_type;
+  typedef test_iterator::istream_type istream_type;
+}
+
+int main() 
+{ 
+  test01();
+  return 0;
+}

libstdc++-v3/testsuite/24_iterators/istreambuf_iterator.cc

@@ -24,7 +24,33 @@
 #include <iterator>
 #include <debug_assert.h>
 
-bool test01(void)
+void test01()
+{
+  using namespace std;
+
+  // Check for required base class.
+  typedef istreambuf_iterator<char> test_iterator;
+  typedef char_traits<char>::off_type off_type;
+  typedef iterator<input_iterator_tag, char, off_type, char*, char&> base_iterator;
+
+  istringstream isstream("this tag");
+  test_iterator  r_it(isstream);
+  base_iterator* base = &r_it;
+
+  // Check for required typedefs
+  typedef test_iterator::value_type value_type;
+  typedef test_iterator::difference_type difference_type;
+  typedef test_iterator::pointer pointer;
+  typedef test_iterator::reference reference;
+  typedef test_iterator::iterator_category iteratory_category;
+
+  typedef test_iterator::char_type char_type;
+  typedef test_iterator::traits_type traits_type;
+  typedef test_iterator::istream_type istream_type;
+  typedef test_iterator::streambuf_type streambuf_type;
+}
+
+bool test02(void)
 {
 
   typedef std::istreambuf_iterator<char> cistreambuf_iter;
@@ -116,7 +142,7 @@ bool test01(void)
 }
 
 // libstdc++/2627
-void test02()
+void test03()
 {
   bool test = true;
   const std::string s("free the vieques");
@@ -155,6 +181,6 @@ int main()
 {
   test01();
   test02();
-
+  test03();
   return 0;
 }

libstdc++-v3/testsuite/24_iterators/ostream_iterator.cc

+// 2001-06-25  Benjamin Kosnik  <bkoz@redhat.com>
+
+// Copyright (C) 2001 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// 24.5.4 Template class ostream_iterator
+
+#include <iterator>
+#include <ostream>
+#include <sstream>
+
+void test01()
+{
+  using namespace std;
+
+  // Check for required base class.
+  typedef ostream_iterator<long> test_iterator;
+  typedef iterator<output_iterator_tag, void, void, void, void> base_iterator;
+  ostringstream osstream("this tag");
+  test_iterator  r_it(osstream);
+  base_iterator* base = &r_it;
+
+  // Check for required typedefs
+  typedef test_iterator::value_type value_type;
+  typedef test_iterator::difference_type difference_type;
+  typedef test_iterator::pointer pointer;
+  typedef test_iterator::reference reference;
+  typedef test_iterator::iterator_category iteratory_category;
+
+  typedef test_iterator::char_type char_type;
+  typedef test_iterator::traits_type traits_type;
+  typedef test_iterator::ostream_type ostream_type;
+}
+
+int main() 
+{ 
+  test01();
+  return 0;
+}

libstdc++-v3/testsuite/24_iterators/ostreambuf_iterator.cc

@@ -24,7 +24,31 @@
 #include <iterator>
 #include <debug_assert.h>
 
-bool test01(void)
+void test01()
+{
+  using namespace std;
+
+  // Check for required base class.
+  typedef ostreambuf_iterator<char> test_iterator;
+  typedef iterator<output_iterator_tag, void, void, void, void> base_iterator;
+  ostringstream osstream("this tag");
+  test_iterator  r_it(osstream);
+  base_iterator* base = &r_it;
+
+  // Check for required typedefs
+  typedef test_iterator::value_type value_type;
+  typedef test_iterator::difference_type difference_type;
+  typedef test_iterator::pointer pointer;
+  typedef test_iterator::reference reference;
+  typedef test_iterator::iterator_category iteratory_category;
+
+  typedef test_iterator::char_type char_type;
+  typedef test_iterator::traits_type traits_type;
+  typedef test_iterator::ostream_type ostream_type;
+  typedef test_iterator::streambuf_type streambuf_type;
+}
+
+bool test02(void)
 {
   typedef std::ostreambuf_iterator<char> costreambuf_iter;
   typedef costreambuf_iter::streambuf_type cstreambuf_type;
@@ -93,6 +117,7 @@ bool test01(void)
 int main()
 {
   test01();
+  test02();
 
   return 0;
 }