Skip to content

R
riscv-gcc-1
Commit b581eaf7 by Benjamin Kosnik Committed by Benjamin Kosnik
Options

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
parent b2b263e1
Showing with 462 additions and 348 deletions
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> 2001-06-26 Gabriel Dos Reis <gdr@merlin.codesourcery.com>
* include/bits/stl_iterator.h (__normal_iterator<>): Qualify * include/bits/stl_iterator.h (__normal_iterator<>): Qualify
......
libstdc++-v3/include/bits/sbuf_iter.h
...@@ -103,8 +103,6 @@ namespace std ...@@ -103,8 +103,6 @@ namespace std
typedef typename _Traits::int_type int_type; typedef typename _Traits::int_type int_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type; typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_istream<_CharT, _Traits> istream_type; typedef basic_istream<_CharT, _Traits> istream_type;
// Non-standard Types:
typedef istreambuf_iterator<_CharT, _Traits> __istreambufiter_type;
private: private:
// 24.5.3 istreambuf_iterator // 24.5.3 istreambuf_iterator
...@@ -144,7 +142,7 @@ namespace std ...@@ -144,7 +142,7 @@ namespace std
return __ret; return __ret;
} }
__istreambufiter_type& istreambuf_iterator&
operator++() operator++()
{ {
if (_M_sbuf) if (_M_sbuf)
...@@ -153,10 +151,10 @@ namespace std ...@@ -153,10 +151,10 @@ namespace std
return *this; return *this;
} }
__istreambufiter_type istreambuf_iterator
operator++(int) operator++(int)
{ {
__istreambufiter_type __old = *this; istreambuf_iterator __old = *this;
if (_M_sbuf) if (_M_sbuf)
__old._M_c = _M_sbuf->sbumpc(); __old._M_c = _M_sbuf->sbumpc();
_M_c = -2; _M_c = -2;
...@@ -164,7 +162,7 @@ namespace std ...@@ -164,7 +162,7 @@ namespace std
} }
bool bool
equal(const __istreambufiter_type& __b) equal(const istreambuf_iterator& __b)
{ {
int_type __eof = traits_type::eof(); int_type __eof = traits_type::eof();
bool __thiseof = !_M_sbuf || _M_sbuf->sgetc() == __eof; bool __thiseof = !_M_sbuf || _M_sbuf->sgetc() == __eof;
...@@ -177,7 +175,7 @@ namespace std ...@@ -177,7 +175,7 @@ namespace std
// 110 istreambuf_iterator::equal not const // 110 istreambuf_iterator::equal not const
// NB: there is also number 111 pending on this function. // NB: there is also number 111 pending on this function.
bool bool
equal(const __istreambufiter_type& __b) const equal(const istreambuf_iterator& __b) const
{ {
int_type __eof = traits_type::eof(); int_type __eof = traits_type::eof();
bool __thiseof = !_M_sbuf || _M_sbuf->sgetc() == __eof; bool __thiseof = !_M_sbuf || _M_sbuf->sgetc() == __eof;
......
libstdc++-v3/include/bits/stl_iterator.h
...@@ -34,101 +34,98 @@ ...@@ -34,101 +34,98 @@
namespace std namespace std
{ {
// 24.4.1 Reverse iterators // 24.4.1 Reverse iterators
template<class _Iterator> template<typename _Iterator>
class reverse_iterator class reverse_iterator
: public iterator<iterator_traits<_Iterator>::iterator_category, : public iterator<typename iterator_traits<_Iterator>::iterator_category,
iterator_traits<_Iterator>::value_type, typename iterator_traits<_Iterator>::value_type,
iterator_traits<_Iterator>::difference_type, typename iterator_traits<_Iterator>::difference_type,
iterator_traits<_Iterator>::pointer, typename iterator_traits<_Iterator>::pointer,
iterator_traits<_Iterator>::reference> typename iterator_traits<_Iterator>::reference>
{ {
protected: protected:
_Iterator current; _Iterator _M_current;
public: public:
typedef iterator_traits<_Iterator> __traits_type; typedef _Iterator iterator_type;
typedef typename __traits_type::iterator_category iterator_category; typedef typename iterator_traits<_Iterator>::difference_type
typedef typename __traits_type::value_type value_type; difference_type;
typedef typename __traits_type::difference_type difference_type; typedef typename iterator_traits<_Iterator>::reference reference;
typedef typename __traits_type::pointer pointer; typedef typename iterator_traits<_Iterator>::pointer pointer;
typedef typename __traits_type::reference reference;
typedef _Iterator iterator_type;
typedef reverse_iterator<_Iterator> _Self;
public: public:
reverse_iterator() {} reverse_iterator() {}
explicit 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) reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) {} : _M_current(__x.base()) {}
iterator_type iterator_type
base() const { return current; } base() const { return _M_current; }
reference reference
operator*() const operator*() const
{ {
_Iterator __tmp = current; _Iterator __tmp = _M_current;
return *--__tmp; return *--__tmp;
} }
pointer pointer
operator->() const { return &(operator*()); } operator->() const { return &(operator*()); }
_Self& reverse_iterator&
operator++() operator++()
{ {
--current; --_M_current;
return *this; return *this;
} }
_Self reverse_iterator
operator++(int) operator++(int)
{ {
_Self __tmp = *this; reverse_iterator __tmp = *this;
--current; --_M_current;
return __tmp; return __tmp;
} }
_Self& reverse_iterator&
operator--() operator--()
{ {
++current; ++_M_current;
return *this; return *this;
} }
_Self operator--(int) reverse_iterator operator--(int)
{ {
_Self __tmp = *this; reverse_iterator __tmp = *this;
++current; ++_M_current;
return __tmp; return __tmp;
} }
_Self reverse_iterator
operator+(difference_type __n) const operator+(difference_type __n) const
{ return _Self(current - __n); } { return reverse_iterator(_M_current - __n); }
_Self& reverse_iterator&
operator+=(difference_type __n) operator+=(difference_type __n)
{ {
current -= __n; _M_current -= __n;
return *this; return *this;
} }
_Self reverse_iterator
operator-(difference_type __n) const operator-(difference_type __n) const
{ return _Self(current + __n); } { return reverse_iterator(_M_current + __n); }
_Self& reverse_iterator&
operator-=(difference_type __n) operator-=(difference_type __n)
{ {
current += __n; _M_current += __n;
return *this; return *this;
} }
...@@ -136,56 +133,56 @@ namespace std ...@@ -136,56 +133,56 @@ namespace std
operator[](difference_type __n) const { return *(*this + __n); } operator[](difference_type __n) const { return *(*this + __n); }
}; };
template<class _Iterator> template<typename _Iterator>
inline bool inline bool
operator==(const reverse_iterator<_Iterator>& __x, operator==(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y) const reverse_iterator<_Iterator>& __y)
{ return __x.base() == __y.base(); } { return __x.base() == __y.base(); }
template <class _Iterator> template<typename _Iterator>
inline bool inline bool
operator<(const reverse_iterator<_Iterator>& __x, operator<(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y) const reverse_iterator<_Iterator>& __y)
{ return __y.base() < __x.base(); } { return __y.base() < __x.base(); }
template <class _Iterator> template<typename _Iterator>
inline bool inline bool
operator!=(const reverse_iterator<_Iterator>& __x, operator!=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y) const reverse_iterator<_Iterator>& __y)
{ return !(__x == __y); } { return !(__x == __y); }
template <class _Iterator> template<typename _Iterator>
inline bool inline bool
operator>(const reverse_iterator<_Iterator>& __x, operator>(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y) const reverse_iterator<_Iterator>& __y)
{ return __y < __x; } { return __y < __x; }
template <class _Iterator> template<typename _Iterator>
inline bool inline bool
operator<=(const reverse_iterator<_Iterator>& __x, operator<=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y) const reverse_iterator<_Iterator>& __y)
{ return !(__y < __x); } { return !(__y < __x); }
template <class _Iterator> template<typename _Iterator>
inline bool inline bool
operator>=(const reverse_iterator<_Iterator>& __x, operator>=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y) const reverse_iterator<_Iterator>& __y)
{ return !(__x < __y); } { return !(__x < __y); }
template<class _Iterator> template<typename _Iterator>
inline typename reverse_iterator<_Iterator>::difference_type inline typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x, operator-(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y) const reverse_iterator<_Iterator>& __y)
{ return __y.base() - __x.base(); } { return __y.base() - __x.base(); }
template <class _Iterator> template<typename _Iterator>
inline reverse_iterator<_Iterator> inline reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n, operator+(typename reverse_iterator<_Iterator>::difference_type __n,
const reverse_iterator<_Iterator>& __x) const reverse_iterator<_Iterator>& __x)
{ return reverse_iterator<_Iterator>(__x.base() - __n); } { return reverse_iterator<_Iterator>(__x.base() - __n); }
// 24.4.2.2.1 back_insert_iterator // 24.4.2.2.1 back_insert_iterator
template <class _Container> template<typename _Container>
class back_insert_iterator class back_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
{ {
...@@ -215,12 +212,12 @@ namespace std ...@@ -215,12 +212,12 @@ namespace std
operator++(int) { return *this; } operator++(int) { return *this; }
}; };
template <class _Container> template<typename _Container>
inline back_insert_iterator<_Container> inline back_insert_iterator<_Container>
back_inserter(_Container& __x) back_inserter(_Container& __x)
{ return back_insert_iterator<_Container>(__x); } { return back_insert_iterator<_Container>(__x); }
template <class _Container> template<typename _Container>
class front_insert_iterator class front_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
{ {
...@@ -241,12 +238,11 @@ namespace std ...@@ -241,12 +238,11 @@ namespace std
front_insert_iterator<_Container>& operator++(int) { return *this; } front_insert_iterator<_Container>& operator++(int) { return *this; }
}; };
template <class _Container> template<typename _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) { inline front_insert_iterator<_Container> front_inserter(_Container& __x)
return front_insert_iterator<_Container>(__x); { return front_insert_iterator<_Container>(__x); }
}
template <class _Container> template<typename _Container>
class insert_iterator class insert_iterator
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
{ {
...@@ -271,304 +267,248 @@ namespace std ...@@ -271,304 +267,248 @@ namespace std
insert_iterator<_Container>& operator++(int) { return *this; } insert_iterator<_Container>& operator++(int) { return *this; }
}; };
template <class _Container, class _Iterator> template<typename _Container, typename _Iterator>
inline inline
insert_iterator<_Container> inserter(_Container& __x, _Iterator __i) insert_iterator<_Container> inserter(_Container& __x, _Iterator __i)
{ {
typedef typename _Container::iterator __iter; typedef typename _Container::iterator __iter;
return insert_iterator<_Container>(__x, __iter(__i)); 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> template<typename _Tp, typename _CharT = char,
inline bool operator!=( typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x, class istream_iterator
const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y) : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
{ {
return !(__x == __y); public:
} typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_istream<_CharT, _Traits> istream_type;
template <class _Tp, private:
class _CharT = char, class _Traits = char_traits<_CharT>, istream_type* _M_stream;
class _Dist = ptrdiff_t> _Tp _M_value;
class istream_iterator { bool _M_ok;
public:
typedef _CharT char_type; public:
typedef _Traits traits_type; istream_iterator() : _M_stream(0), _M_ok(false) {}
typedef basic_istream<_CharT, _Traits> istream_type; istream_iterator(istream_type& __s) : _M_stream(&__s) { _M_read(); }
typedef input_iterator_tag iterator_category; reference
typedef _Tp value_type; operator*() const { return _M_value; }
typedef _Dist difference_type;
typedef const _Tp* pointer; pointer
typedef const _Tp& reference; operator->() const { return &(operator*()); }
istream_iterator() : _M_stream(0), _M_ok(false) {} istream_iterator&
istream_iterator(istream_type& __s) : _M_stream(&__s) { _M_read(); } operator++()
{ _M_read(); return *this; }
reference operator*() const { return _M_value; }
pointer operator->() const { return &(operator*()); } istream_iterator
operator++(int)
istream_iterator& operator++() { {
_M_read(); istream_iterator __tmp = *this;
return *this; _M_read();
} return __tmp;
istream_iterator operator++(int) { }
istream_iterator __tmp = *this;
_M_read(); bool
return __tmp; _M_equal(const istream_iterator& __x) const
} { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream);}
bool _M_equal(const istream_iterator& __x) const private:
{ return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); } void _M_read()
{
private: _M_ok = (_M_stream && *_M_stream) ? true : false;
istream_type* _M_stream; if (_M_ok)
_Tp _M_value; {
bool _M_ok; *_M_stream >> _M_value;
_M_ok = *_M_stream ? true : false;
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;
protected: template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
_Iterator _M_current; 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: template <class _Tp, class _CharT, class _Traits, class _Dist>
typedef __normal_iterator<_Iterator, _Container> normal_iterator_type; inline bool
typedef typename _Traits::iterator_category iterator_category; operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
typedef typename _Traits::value_type value_type; const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
typedef typename _Traits::difference_type difference_type; { return !__x._M_equal(__y); }
typedef typename _Traits::pointer pointer;
typedef typename _Traits::reference reference;
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 ostream_iterator&
template<typename _Iter> operator=(const _Tp& __value)
inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) {
: _M_current(__i.base()) { } *_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 __normal_iterator() : _M_current(_Iterator()) { }
reference
operator*() const { return *_M_current; }
pointer explicit
operator->() const { return _M_current; } __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
normal_iterator_type& // Allow iterator to const_iterator conversion
operator++() { ++_M_current; return *this; } template<typename _Iter>
inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
: _M_current(__i.base()) { }
normal_iterator_type // Forward iterator requirements
operator++(int) { return __normal_iterator(_M_current++); } 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
normal_iterator_type& operator+(const difference_type& __n) const
operator--() { --_M_current; return *this; } { 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 // Forward iterator requirements
operator--(int) { return __normal_iterator(_M_current--); } 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 // Random access iterator requirements
reference template<typename _IteratorL, typename _IteratorR, typename _Container>
operator[](const difference_type& __n) const inline bool
{ return _M_current[__n]; } operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
normal_iterator_type& { return __lhs.base() < __rhs.base(); }
operator+=(const difference_type& __n)
{ _M_current += __n; return *this; } template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
normal_iterator_type operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
operator+(const difference_type& __n) const const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __normal_iterator(_M_current + __n); } { return __rhs < __lhs; }
normal_iterator_type& template<typename _IteratorL, typename _IteratorR, typename _Container>
operator-=(const difference_type& __n) inline bool
{ _M_current -= __n; return *this; } operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
normal_iterator_type { return !(__rhs < __lhs); }
operator-(const difference_type& __n) const
{ return __normal_iterator(_M_current - __n); } template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
difference_type operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
operator-(const normal_iterator_type& __i) const const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return _M_current - __i._M_current; } { return !(__lhs < __rhs); }
const _Iterator& template<typename _Iterator, typename _Container>
base() const { return _M_current; } inline __normal_iterator<_Iterator, _Container>
}; operator+(__normal_iterator<_Iterator, _Container>::difference_type __n,
const __normal_iterator<_Iterator, _Container>& __i)
// forward iterator requirements { 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 !(__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); }
} // namespace std } // namespace std
#endif /* __SGI_STL_INTERNAL_ITERATOR_H */ #endif
// Local Variables: // Local Variables:
// mode:C++ // mode:C++
......
libstdc++-v3/testsuite/24_iterators/istream_iterator.cc 0 → 100644
// 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 @@ ...@@ -24,7 +24,33 @@
#include <iterator> #include <iterator>
#include <debug_assert.h> #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; typedef std::istreambuf_iterator<char> cistreambuf_iter;
...@@ -116,7 +142,7 @@ bool test01(void) ...@@ -116,7 +142,7 @@ bool test01(void)
} }
// libstdc++/2627 // libstdc++/2627
void test02() void test03()
{ {
bool test = true; bool test = true;
const std::string s("free the vieques"); const std::string s("free the vieques");
...@@ -155,6 +181,6 @@ int main() ...@@ -155,6 +181,6 @@ int main()
{ {
test01(); test01();
test02(); test02();
test03();
return 0; return 0;
} }
libstdc++-v3/testsuite/24_iterators/ostream_iterator.cc 0 → 100644
// 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 @@ ...@@ -24,7 +24,31 @@
#include <iterator> #include <iterator>
#include <debug_assert.h> #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 std::ostreambuf_iterator<char> costreambuf_iter;
typedef costreambuf_iter::streambuf_type cstreambuf_type; typedef costreambuf_iter::streambuf_type cstreambuf_type;
...@@ -93,6 +117,7 @@ bool test01(void) ...@@ -93,6 +117,7 @@ bool test01(void)
int main() int main()
{ {
test01(); test01();
test02();
return 0; return 0;
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment