* purpose. It is provided "as is" without express or implied warranty.
*
*
- * Copyright (c) 1996,1997
+ * Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
-template <class T, class Distance> struct input_iterator {
+// The base classes input_iterator, output_iterator, forward_iterator,
+// bidirectional_iterator, and random_access_iterator are not part of
+// the C++ standard. (they have been replaced by struct iterator.)
+// They are included for backward compatibility with the HP STL.
+
+template <class _Tp, class _Distance> struct input_iterator {
typedef input_iterator_tag iterator_category;
- typedef T value_type;
- typedef Distance difference_type;
- typedef T* pointer;
- typedef T& reference;
+ typedef _Tp value_type;
+ typedef _Distance difference_type;
+ typedef _Tp* pointer;
+ typedef _Tp& reference;
};
struct output_iterator {
typedef void reference;
};
-template <class T, class Distance> struct forward_iterator {
+template <class _Tp, class _Distance> struct forward_iterator {
typedef forward_iterator_tag iterator_category;
- typedef T value_type;
- typedef Distance difference_type;
- typedef T* pointer;
- typedef T& reference;
+ typedef _Tp value_type;
+ typedef _Distance difference_type;
+ typedef _Tp* pointer;
+ typedef _Tp& reference;
};
-template <class T, class Distance> struct bidirectional_iterator {
+template <class _Tp, class _Distance> struct bidirectional_iterator {
typedef bidirectional_iterator_tag iterator_category;
- typedef T value_type;
- typedef Distance difference_type;
- typedef T* pointer;
- typedef T& reference;
+ typedef _Tp value_type;
+ typedef _Distance difference_type;
+ typedef _Tp* pointer;
+ typedef _Tp& reference;
};
-template <class T, class Distance> struct random_access_iterator {
+template <class _Tp, class _Distance> struct random_access_iterator {
typedef random_access_iterator_tag iterator_category;
- typedef T value_type;
- typedef Distance difference_type;
- typedef T* pointer;
- typedef T& reference;
+ typedef _Tp value_type;
+ typedef _Distance difference_type;
+ typedef _Tp* pointer;
+ typedef _Tp& reference;
};
#ifdef __STL_USE_NAMESPACES
-template <class Category, class T, class Distance = ptrdiff_t,
- class Pointer = T*, class Reference = T&>
+template <class _Category, class _Tp, class _Distance = ptrdiff_t,
+ class _Pointer = _Tp*, class _Reference = _Tp&>
struct iterator {
- typedef Category iterator_category;
- typedef T value_type;
- typedef Distance difference_type;
- typedef Pointer pointer;
- typedef Reference reference;
+ typedef _Category iterator_category;
+ typedef _Tp value_type;
+ typedef _Distance difference_type;
+ typedef _Pointer pointer;
+ typedef _Reference reference;
};
#endif /* __STL_USE_NAMESPACES */
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
-template <class Iterator>
+template <class _Iterator>
struct iterator_traits {
- typedef typename Iterator::iterator_category iterator_category;
- typedef typename Iterator::value_type value_type;
- typedef typename Iterator::difference_type difference_type;
- typedef typename Iterator::pointer pointer;
- typedef typename Iterator::reference reference;
+ typedef typename _Iterator::iterator_category iterator_category;
+ typedef typename _Iterator::value_type value_type;
+ typedef typename _Iterator::difference_type difference_type;
+ typedef typename _Iterator::pointer pointer;
+ typedef typename _Iterator::reference reference;
};
-template <class T>
-struct iterator_traits<T*> {
+template <class _Tp>
+struct iterator_traits<_Tp*> {
typedef random_access_iterator_tag iterator_category;
- typedef T value_type;
- typedef ptrdiff_t difference_type;
- typedef T* pointer;
- typedef T& reference;
+ typedef _Tp value_type;
+ typedef ptrdiff_t difference_type;
+ typedef _Tp* pointer;
+ typedef _Tp& reference;
};
-template <class T>
-struct iterator_traits<const T*> {
+template <class _Tp>
+struct iterator_traits<const _Tp*> {
typedef random_access_iterator_tag iterator_category;
- typedef T value_type;
- typedef ptrdiff_t difference_type;
- typedef const T* pointer;
- typedef const T& reference;
+ typedef _Tp value_type;
+ typedef ptrdiff_t difference_type;
+ typedef const _Tp* pointer;
+ typedef const _Tp& reference;
};
-template <class Iterator>
-inline typename iterator_traits<Iterator>::iterator_category
-iterator_category(const Iterator&) {
- typedef typename iterator_traits<Iterator>::iterator_category category;
- return category();
+// The overloaded functions iterator_category, distance_type, and
+// value_type are not part of the C++ standard. (They have been
+// replaced by struct iterator_traits.) They are included for
+// backward compatibility with the HP STL.
+
+// We introduce internal names for these functions.
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::iterator_category
+__iterator_category(const _Iter&)
+{
+ typedef typename iterator_traits<_Iter>::iterator_category _Category;
+ return _Category();
}
-template <class Iterator>
-inline typename iterator_traits<Iterator>::difference_type*
-distance_type(const Iterator&) {
- return static_cast<typename iterator_traits<Iterator>::difference_type*>(0);
+template <class _Iter>
+inline typename iterator_traits<_Iter>::difference_type*
+__distance_type(const _Iter&)
+{
+ return static_cast<typename iterator_traits<_Iter>::difference_type*>(0);
}
-template <class Iterator>
-inline typename iterator_traits<Iterator>::value_type*
-value_type(const Iterator&) {
- return static_cast<typename iterator_traits<Iterator>::value_type*>(0);
+template <class _Iter>
+inline typename iterator_traits<_Iter>::value_type*
+__value_type(const _Iter&)
+{
+ return static_cast<typename iterator_traits<_Iter>::value_type*>(0);
}
+template <class _Iter>
+inline typename iterator_traits<_Iter>::iterator_category
+iterator_category(const _Iter& __i) { return __iterator_category(__i); }
+
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::difference_type*
+distance_type(const _Iter& __i) { return __distance_type(__i); }
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::value_type*
+value_type(const _Iter& __i) { return __value_type(__i); }
+
+#define __ITERATOR_CATEGORY(__i) __iterator_category(__i)
+#define __DISTANCE_TYPE(__i) __distance_type(__i)
+#define __VALUE_TYPE(__i) __value_type(__i)
+
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
-template <class T, class Distance>
+template <class _Tp, class _Distance>
inline input_iterator_tag
-iterator_category(const input_iterator<T, Distance>&) {
- return input_iterator_tag();
-}
+iterator_category(const input_iterator<_Tp, _Distance>&)
+ { return input_iterator_tag(); }
-inline output_iterator_tag iterator_category(const output_iterator&) {
- return output_iterator_tag();
-}
+inline output_iterator_tag iterator_category(const output_iterator&)
+ { return output_iterator_tag(); }
-template <class T, class Distance>
+template <class _Tp, class _Distance>
inline forward_iterator_tag
-iterator_category(const forward_iterator<T, Distance>&) {
- return forward_iterator_tag();
-}
+iterator_category(const forward_iterator<_Tp, _Distance>&)
+ { return forward_iterator_tag(); }
-template <class T, class Distance>
+template <class _Tp, class _Distance>
inline bidirectional_iterator_tag
-iterator_category(const bidirectional_iterator<T, Distance>&) {
- return bidirectional_iterator_tag();
-}
+iterator_category(const bidirectional_iterator<_Tp, _Distance>&)
+ { return bidirectional_iterator_tag(); }
-template <class T, class Distance>
+template <class _Tp, class _Distance>
inline random_access_iterator_tag
-iterator_category(const random_access_iterator<T, Distance>&) {
- return random_access_iterator_tag();
-}
+iterator_category(const random_access_iterator<_Tp, _Distance>&)
+ { return random_access_iterator_tag(); }
-template <class T>
-inline random_access_iterator_tag iterator_category(const T*) {
- return random_access_iterator_tag();
-}
+template <class _Tp>
+inline random_access_iterator_tag iterator_category(const _Tp*)
+ { return random_access_iterator_tag(); }
-template <class T, class Distance>
-inline T* value_type(const input_iterator<T, Distance>&) {
- return (T*)(0);
-}
+template <class _Tp, class _Distance>
+inline _Tp* value_type(const input_iterator<_Tp, _Distance>&)
+ { return (_Tp*)(0); }
-template <class T, class Distance>
-inline T* value_type(const forward_iterator<T, Distance>&) {
- return (T*)(0);
-}
+template <class _Tp, class _Distance>
+inline _Tp* value_type(const forward_iterator<_Tp, _Distance>&)
+ { return (_Tp*)(0); }
-template <class T, class Distance>
-inline T* value_type(const bidirectional_iterator<T, Distance>&) {
- return (T*)(0);
-}
+template <class _Tp, class _Distance>
+inline _Tp* value_type(const bidirectional_iterator<_Tp, _Distance>&)
+ { return (_Tp*)(0); }
-template <class T, class Distance>
-inline T* value_type(const random_access_iterator<T, Distance>&) {
- return (T*)(0);
-}
+template <class _Tp, class _Distance>
+inline _Tp* value_type(const random_access_iterator<_Tp, _Distance>&)
+ { return (_Tp*)(0); }
-template <class T>
-inline T* value_type(const T*) { return (T*)(0); }
+template <class _Tp>
+inline _Tp* value_type(const _Tp*) { return (_Tp*)(0); }
-template <class T, class Distance>
-inline Distance* distance_type(const input_iterator<T, Distance>&) {
- return (Distance*)(0);
+template <class _Tp, class _Distance>
+inline _Distance* distance_type(const input_iterator<_Tp, _Distance>&)
+{
+ return (_Distance*)(0);
}
-template <class T, class Distance>
-inline Distance* distance_type(const forward_iterator<T, Distance>&) {
- return (Distance*)(0);
+template <class _Tp, class _Distance>
+inline _Distance* distance_type(const forward_iterator<_Tp, _Distance>&)
+{
+ return (_Distance*)(0);
}
-template <class T, class Distance>
-inline Distance*
-distance_type(const bidirectional_iterator<T, Distance>&) {
- return (Distance*)(0);
+template <class _Tp, class _Distance>
+inline _Distance*
+distance_type(const bidirectional_iterator<_Tp, _Distance>&)
+{
+ return (_Distance*)(0);
}
-template <class T, class Distance>
-inline Distance*
-distance_type(const random_access_iterator<T, Distance>&) {
- return (Distance*)(0);
+template <class _Tp, class _Distance>
+inline _Distance*
+distance_type(const random_access_iterator<_Tp, _Distance>&)
+{
+ return (_Distance*)(0);
}
-template <class T>
-inline ptrdiff_t* distance_type(const T*) { return (ptrdiff_t*)(0); }
+template <class _Tp>
+inline ptrdiff_t* distance_type(const _Tp*) { return (ptrdiff_t*)(0); }
+
+// Without partial specialization we can't use iterator_traits, so
+// we must keep the old iterator query functions around.
+
+#define __ITERATOR_CATEGORY(__i) iterator_category(__i)
+#define __DISTANCE_TYPE(__i) distance_type(__i)
+#define __VALUE_TYPE(__i) value_type(__i)
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
-template <class InputIterator, class Distance>
-inline void __distance(InputIterator first, InputIterator last, Distance& n,
- input_iterator_tag) {
- while (first != last) { ++first; ++n; }
+template <class _InputIterator, class _Distance>
+inline void __distance(_InputIterator __first, _InputIterator __last,
+ _Distance& __n, input_iterator_tag)
+{
+ while (__first != __last) { ++__first; ++__n; }
}
-template <class RandomAccessIterator, class Distance>
-inline void __distance(RandomAccessIterator first, RandomAccessIterator last,
- Distance& n, random_access_iterator_tag) {
- n += last - first;
+template <class _RandomAccessIterator, class _Distance>
+inline void __distance(_RandomAccessIterator __first,
+ _RandomAccessIterator __last,
+ _Distance& __n, random_access_iterator_tag)
+{
+ __n += __last - __first;
}
-template <class InputIterator, class Distance>
-inline void distance(InputIterator first, InputIterator last, Distance& n) {
- __distance(first, last, n, iterator_category(first));
+template <class _InputIterator, class _Distance>
+inline void distance(_InputIterator __first,
+ _InputIterator __last, _Distance& __n)
+{
+ __distance(__first, __last, __n, iterator_category(__first));
}
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
-template <class InputIterator>
-inline iterator_traits<InputIterator>::difference_type
-__distance(InputIterator first, InputIterator last, input_iterator_tag) {
- iterator_traits<InputIterator>::difference_type n = 0;
- while (first != last) {
- ++first; ++n;
+template <class _InputIterator>
+inline typename iterator_traits<_InputIterator>::difference_type
+__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag)
+{
+ typename iterator_traits<_InputIterator>::difference_type __n = 0;
+ while (__first != __last) {
+ ++__first; ++__n;
}
- return n;
+ return __n;
}
-template <class RandomAccessIterator>
-inline iterator_traits<RandomAccessIterator>::difference_type
-__distance(RandomAccessIterator first, RandomAccessIterator last,
+template <class _RandomAccessIterator>
+inline typename iterator_traits<_RandomAccessIterator>::difference_type
+__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag) {
- return last - first;
+ return __last - __first;
}
-template <class InputIterator>
-inline iterator_traits<InputIterator>::difference_type
-distance(InputIterator first, InputIterator last) {
- typedef typename iterator_traits<InputIterator>::iterator_category category;
- return __distance(first, last, category());
+template <class _InputIterator>
+inline typename iterator_traits<_InputIterator>::difference_type
+distance(_InputIterator __first, _InputIterator __last) {
+ typedef typename iterator_traits<_InputIterator>::iterator_category
+ _Category;
+ return __distance(__first, __last, _Category());
}
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
-template <class InputIterator, class Distance>
-inline void __advance(InputIterator& i, Distance n, input_iterator_tag) {
- while (n--) ++i;
+template <class _InputIter, class _Distance>
+inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag) {
+ while (__n--) ++__i;
}
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1183
#endif
-template <class BidirectionalIterator, class Distance>
-inline void __advance(BidirectionalIterator& i, Distance n,
+template <class _BidirectionalIterator, class _Distance>
+inline void __advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag) {
- if (n >= 0)
- while (n--) ++i;
+ if (__n >= 0)
+ while (__n--) ++__i;
else
- while (n++) --i;
+ while (__n++) --__i;
}
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1183
#endif
-template <class RandomAccessIterator, class Distance>
-inline void __advance(RandomAccessIterator& i, Distance n,
+template <class _RandomAccessIterator, class _Distance>
+inline void __advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag) {
- i += n;
+ __i += __n;
}
-template <class InputIterator, class Distance>
-inline void advance(InputIterator& i, Distance n) {
- __advance(i, n, iterator_category(i));
+template <class _InputIterator, class _Distance>
+inline void advance(_InputIterator& __i, _Distance __n) {
+ __advance(__i, __n, iterator_category(__i));
}
-template <class Container>
+template <class _Container>
class back_insert_iterator {
protected:
- Container* container;
+ _Container* container;
public:
+ typedef _Container container_type;
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
- explicit back_insert_iterator(Container& x) : container(&x) {}
- back_insert_iterator<Container>&
- operator=(const typename Container::value_type& value) {
- container->push_back(value);
+ explicit back_insert_iterator(_Container& __x) : container(&__x) {}
+ back_insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __value) {
+ container->push_back(__value);
return *this;
}
- back_insert_iterator<Container>& operator*() { return *this; }
- back_insert_iterator<Container>& operator++() { return *this; }
- back_insert_iterator<Container>& operator++(int) { return *this; }
+ back_insert_iterator<_Container>& operator*() { return *this; }
+ back_insert_iterator<_Container>& operator++() { return *this; }
+ back_insert_iterator<_Container>& operator++(int) { return *this; }
};
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
-template <class Container>
+template <class _Container>
inline output_iterator_tag
-iterator_category(const back_insert_iterator<Container>&)
+iterator_category(const back_insert_iterator<_Container>&)
{
return output_iterator_tag();
}
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
-template <class Container>
-inline back_insert_iterator<Container> back_inserter(Container& x) {
- return back_insert_iterator<Container>(x);
+template <class _Container>
+inline back_insert_iterator<_Container> back_inserter(_Container& __x) {
+ return back_insert_iterator<_Container>(__x);
}
-template <class Container>
+template <class _Container>
class front_insert_iterator {
protected:
- Container* container;
+ _Container* container;
public:
+ typedef _Container container_type;
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
- explicit front_insert_iterator(Container& x) : container(&x) {}
- front_insert_iterator<Container>&
- operator=(const typename Container::value_type& value) {
- container->push_front(value);
+ explicit front_insert_iterator(_Container& __x) : container(&__x) {}
+ front_insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __value) {
+ container->push_front(__value);
return *this;
}
- front_insert_iterator<Container>& operator*() { return *this; }
- front_insert_iterator<Container>& operator++() { return *this; }
- front_insert_iterator<Container>& operator++(int) { return *this; }
+ front_insert_iterator<_Container>& operator*() { return *this; }
+ front_insert_iterator<_Container>& operator++() { return *this; }
+ front_insert_iterator<_Container>& operator++(int) { return *this; }
};
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
-template <class Container>
+template <class _Container>
inline output_iterator_tag
-iterator_category(const front_insert_iterator<Container>&)
+iterator_category(const front_insert_iterator<_Container>&)
{
return output_iterator_tag();
}
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
-template <class Container>
-inline front_insert_iterator<Container> front_inserter(Container& x) {
- return front_insert_iterator<Container>(x);
+template <class _Container>
+inline front_insert_iterator<_Container> front_inserter(_Container& __x) {
+ return front_insert_iterator<_Container>(__x);
}
-template <class Container>
+template <class _Container>
class insert_iterator {
protected:
- Container* container;
- typename Container::iterator iter;
+ _Container* container;
+ typename _Container::iterator iter;
public:
+ typedef _Container container_type;
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
- insert_iterator(Container& x, typename Container::iterator i)
- : container(&x), iter(i) {}
- insert_iterator<Container>&
- operator=(const typename Container::value_type& value) {
- iter = container->insert(iter, value);
+ insert_iterator(_Container& __x, typename _Container::iterator __i)
+ : container(&__x), iter(__i) {}
+ insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __value) {
+ iter = container->insert(iter, __value);
++iter;
return *this;
}
- insert_iterator<Container>& operator*() { return *this; }
- insert_iterator<Container>& operator++() { return *this; }
- insert_iterator<Container>& operator++(int) { return *this; }
+ insert_iterator<_Container>& operator*() { return *this; }
+ insert_iterator<_Container>& operator++() { return *this; }
+ insert_iterator<_Container>& operator++(int) { return *this; }
};
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
-template <class Container>
+template <class _Container>
inline output_iterator_tag
-iterator_category(const insert_iterator<Container>&)
+iterator_category(const insert_iterator<_Container>&)
{
return output_iterator_tag();
}
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
-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 <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));
}
#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
-template <class BidirectionalIterator, class T, class Reference = T&,
- class Distance = ptrdiff_t>
+template <class _BidirectionalIterator, class _Tp, class _Reference = _Tp&,
+ class _Distance = ptrdiff_t>
#else
-template <class BidirectionalIterator, class T, class Reference,
- class Distance>
+template <class _BidirectionalIterator, class _Tp, class _Reference,
+ class _Distance>
#endif
class reverse_bidirectional_iterator {
- typedef reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
- Distance> self;
+ typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
+ _Reference, _Distance> _Self;
protected:
- BidirectionalIterator current;
+ _BidirectionalIterator current;
public:
typedef bidirectional_iterator_tag iterator_category;
- typedef T value_type;
- typedef Distance difference_type;
- typedef T* pointer;
- typedef Reference reference;
+ 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;
+ explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
+ : current(__x) {}
+ _BidirectionalIterator base() const { return current; }
+ _Reference operator*() const {
+ _BidirectionalIterator __tmp = current;
+ return *--__tmp;
}
#ifndef __SGI_STL_NO_ARROW_OPERATOR
pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
- self& operator++() {
+ _Self& operator++() {
--current;
return *this;
}
- self operator++(int) {
- self tmp = *this;
+ _Self operator++(int) {
+ _Self __tmp = *this;
--current;
- return tmp;
+ return __tmp;
}
- self& operator--() {
+ _Self& operator--() {
++current;
return *this;
}
- self operator--(int) {
- self tmp = *this;
+ _Self operator--(int) {
+ _Self __tmp = *this;
++current;
- return tmp;
+ return __tmp;
}
};
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
-template <class BidirectionalIterator, class T, class Reference,
- class Distance>
+template <class _BidirectionalIterator, class _Tp, class _Reference,
+ class _Distance>
inline bidirectional_iterator_tag
-iterator_category(const reverse_bidirectional_iterator<BidirectionalIterator,
- T,
- Reference, Distance>&) {
+iterator_category(const reverse_bidirectional_iterator<_BidirectionalIterator,
+ _Tp, _Reference,
+ _Distance>&)
+{
return bidirectional_iterator_tag();
}
-template <class BidirectionalIterator, class T, class Reference,
- class Distance>
-inline T*
-value_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
- Reference, Distance>&) {
- return (T*) 0;
+template <class _BidirectionalIterator, class _Tp, class _Reference,
+ class _Distance>
+inline _Tp*
+value_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
+ _Reference, _Distance>&)
+{
+ return (_Tp*) 0;
}
-template <class BidirectionalIterator, class T, class Reference,
- class Distance>
-inline Distance*
-distance_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
- Reference, Distance>&) {
- return (Distance*) 0;
+template <class _BidirectionalIterator, class _Tp, class _Reference,
+ class _Distance>
+inline _Distance*
+distance_type(const reverse_bidirectional_iterator<_BidirectionalIterator,
+ _Tp,
+ _Reference, _Distance>&)
+{
+ return (_Distance*) 0;
}
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
-template <class BidirectionalIterator, class T, class Reference,
- class Distance>
+template <class _BiIter, class _Tp, class _Ref,
+ class _Distance>
inline bool operator==(
- const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
- Distance>& x,
- const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
- Distance>& y) {
- return x.base() == y.base();
+ const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x,
+ const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
+{
+ return __x.base() == __y.base();
}
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
// reverse_bidirectional_iterator is no longer part of the draft
// standard, but it is retained for backward compatibility.
-template <class Iterator>
+template <class _Iterator>
class reverse_iterator
{
protected:
- Iterator current;
+ _Iterator current;
public:
- typedef typename iterator_traits<Iterator>::iterator_category
+ typedef typename iterator_traits<_Iterator>::iterator_category
iterator_category;
- typedef typename iterator_traits<Iterator>::value_type
+ typedef typename iterator_traits<_Iterator>::value_type
value_type;
- typedef typename iterator_traits<Iterator>::difference_type
+ typedef typename iterator_traits<_Iterator>::difference_type
difference_type;
- typedef typename iterator_traits<Iterator>::pointer
+ typedef typename iterator_traits<_Iterator>::pointer
pointer;
- typedef typename iterator_traits<Iterator>::reference
+ typedef typename iterator_traits<_Iterator>::reference
reference;
- typedef Iterator iterator_type;
- typedef reverse_iterator<Iterator> self;
+ typedef _Iterator iterator_type;
+ typedef reverse_iterator<_Iterator> _Self;
public:
reverse_iterator() {}
- explicit reverse_iterator(iterator_type x) : current(x) {}
+ explicit reverse_iterator(iterator_type __x) : current(__x) {}
- reverse_iterator(const self& x) : current(x.current) {}
+ reverse_iterator(const _Self& __x) : current(__x.current) {}
#ifdef __STL_MEMBER_TEMPLATES
- template <class Iter>
- reverse_iterator(const reverse_iterator<Iter>& x) : current(x.current) {}
+ template <class _Iter>
+ reverse_iterator(const reverse_iterator<_Iter>& __x)
+ : current(__x.base()) {}
#endif /* __STL_MEMBER_TEMPLATES */
iterator_type base() const { return current; }
reference operator*() const {
- Iterator tmp = current;
- return *--tmp;
+ _Iterator __tmp = current;
+ return *--__tmp;
}
#ifndef __SGI_STL_NO_ARROW_OPERATOR
pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
- self& operator++() {
+ _Self& operator++() {
--current;
return *this;
}
- self operator++(int) {
- self tmp = *this;
+ _Self operator++(int) {
+ _Self __tmp = *this;
--current;
- return tmp;
+ return __tmp;
}
- self& operator--() {
+ _Self& operator--() {
++current;
return *this;
}
- self operator--(int) {
- self tmp = *this;
+ _Self operator--(int) {
+ _Self __tmp = *this;
++current;
- return tmp;
+ return __tmp;
}
- self operator+(difference_type n) const {
- return self(current - n);
+ _Self operator+(difference_type __n) const {
+ return _Self(current - __n);
}
- self& operator+=(difference_type n) {
- current -= n;
+ _Self& operator+=(difference_type __n) {
+ current -= __n;
return *this;
}
- self operator-(difference_type n) const {
- return self(current + n);
+ _Self operator-(difference_type __n) const {
+ return _Self(current + __n);
}
- self& operator-=(difference_type n) {
- current += n;
+ _Self& operator-=(difference_type __n) {
+ current += __n;
return *this;
}
- reference operator[](difference_type n) const { return *(*this + n); }
+ reference operator[](difference_type __n) const { return *(*this + __n); }
};
-template <class Iterator>
-inline bool operator==(const reverse_iterator<Iterator>& x,
- const reverse_iterator<Iterator>& y) {
- return x.base() == y.base();
+template <class _Iterator>
+inline bool operator==(const reverse_iterator<_Iterator>& __x,
+ const reverse_iterator<_Iterator>& __y) {
+ return __x.base() == __y.base();
}
-template <class Iterator>
-inline bool operator<(const reverse_iterator<Iterator>& x,
- const reverse_iterator<Iterator>& y) {
- return y.base() < x.base();
+template <class _Iterator>
+inline bool operator<(const reverse_iterator<_Iterator>& __x,
+ const reverse_iterator<_Iterator>& __y) {
+ return __y.base() < __x.base();
}
-template <class 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>
+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>
-inline reverse_iterator<Iterator>
-operator+(reverse_iterator<Iterator>::difference_type n,
- const reverse_iterator<Iterator>& x) {
- return reverse_iterator<Iterator>(x.base() - n);
+template <class _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);
}
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
// HP STL. It does not use partial specialization.
#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
-template <class RandomAccessIterator, class T, class Reference = T&,
- class Distance = ptrdiff_t>
+template <class _RandomAccessIterator, class _Tp, class _Reference = _Tp&,
+ class _Distance = ptrdiff_t>
#else
-template <class RandomAccessIterator, class T, class Reference,
- class Distance>
+template <class _RandomAccessIterator, class _Tp, class _Reference,
+ class _Distance>
#endif
class reverse_iterator {
- typedef reverse_iterator<RandomAccessIterator, T, Reference, Distance>
- self;
+ typedef reverse_iterator<_RandomAccessIterator, _Tp, _Reference, _Distance>
+ _Self;
protected:
- RandomAccessIterator current;
+ _RandomAccessIterator current;
public:
typedef random_access_iterator_tag iterator_category;
- typedef T value_type;
- typedef Distance difference_type;
- typedef T* pointer;
- typedef Reference reference;
+ typedef _Tp value_type;
+ typedef _Distance difference_type;
+ typedef _Tp* pointer;
+ typedef _Reference reference;
reverse_iterator() {}
- explicit reverse_iterator(RandomAccessIterator x) : current(x) {}
- RandomAccessIterator base() const { return current; }
- Reference operator*() const { return *(current - 1); }
+ explicit reverse_iterator(_RandomAccessIterator __x) : current(__x) {}
+ _RandomAccessIterator base() const { return current; }
+ _Reference operator*() const { return *(current - 1); }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
- self& operator++() {
+ _Self& operator++() {
--current;
return *this;
}
- self operator++(int) {
- self tmp = *this;
+ _Self operator++(int) {
+ _Self __tmp = *this;
--current;
- return tmp;
+ return __tmp;
}
- self& operator--() {
+ _Self& operator--() {
++current;
return *this;
}
- self operator--(int) {
- self tmp = *this;
+ _Self operator--(int) {
+ _Self __tmp = *this;
++current;
- return tmp;
+ return __tmp;
}
- self operator+(Distance n) const {
- return self(current - n);
+ _Self operator+(_Distance __n) const {
+ return _Self(current - __n);
}
- self& operator+=(Distance n) {
- current -= n;
+ _Self& operator+=(_Distance __n) {
+ current -= __n;
return *this;
}
- self operator-(Distance n) const {
- return self(current + n);
+ _Self operator-(_Distance __n) const {
+ return _Self(current + __n);
}
- self& operator-=(Distance n) {
- current += n;
+ _Self& operator-=(_Distance __n) {
+ current += __n;
return *this;
}
- Reference operator[](Distance n) const { return *(*this + n); }
+ _Reference operator[](_Distance __n) const { return *(*this + __n); }
};
-template <class RandomAccessIterator, class T, class Reference, class Distance>
+template <class _RandomAccessIterator, class _Tp,
+ class _Reference, class _Distance>
inline random_access_iterator_tag
-iterator_category(const reverse_iterator<RandomAccessIterator, T,
- Reference, Distance>&) {
+iterator_category(const reverse_iterator<_RandomAccessIterator, _Tp,
+ _Reference, _Distance>&)
+{
return random_access_iterator_tag();
}
-template <class RandomAccessIterator, class T, class Reference, class Distance>
-inline T* value_type(const reverse_iterator<RandomAccessIterator, T,
- Reference, Distance>&) {
- return (T*) 0;
+template <class _RandomAccessIterator, class _Tp,
+ class _Reference, class _Distance>
+inline _Tp* value_type(const reverse_iterator<_RandomAccessIterator, _Tp,
+ _Reference, _Distance>&)
+{
+ return (_Tp*) 0;
}
-template <class RandomAccessIterator, class T, class Reference, class Distance>
-inline Distance* distance_type(const reverse_iterator<RandomAccessIterator, T,
- Reference, Distance>&) {
- return (Distance*) 0;
+template <class _RandomAccessIterator, class _Tp,
+ class _Reference, class _Distance>
+inline _Distance*
+distance_type(const reverse_iterator<_RandomAccessIterator,
+ _Tp, _Reference, _Distance>&)
+{
+ return (_Distance*) 0;
}
-template <class RandomAccessIterator, class T, class Reference, class Distance>
-inline bool operator==(const reverse_iterator<RandomAccessIterator, T,
- Reference, Distance>& x,
- const reverse_iterator<RandomAccessIterator, T,
- Reference, Distance>& y) {
- return x.base() == y.base();
+template <class _RandomAccessIterator, class _Tp,
+ class _Reference, class _Distance>
+inline bool
+operator==(const reverse_iterator<_RandomAccessIterator, _Tp,
+ _Reference, _Distance>& __x,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ _Reference, _Distance>& __y)
+{
+ return __x.base() == __y.base();
}
-template <class RandomAccessIterator, class T, class Reference, class Distance>
-inline bool operator<(const reverse_iterator<RandomAccessIterator, T,
- Reference, Distance>& x,
- const reverse_iterator<RandomAccessIterator, T,
- Reference, Distance>& y) {
- return y.base() < x.base();
+template <class _RandomAccessIterator, class _Tp,
+ class _Reference, class _Distance>
+inline bool
+operator<(const reverse_iterator<_RandomAccessIterator, _Tp,
+ _Reference, _Distance>& __x,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ _Reference, _Distance>& __y)
+{
+ return __y.base() < __x.base();
}
-template <class RandomAccessIterator, class T, class Reference, class Distance>
-inline Distance operator-(const reverse_iterator<RandomAccessIterator, T,
- Reference, Distance>& x,
- const reverse_iterator<RandomAccessIterator, T,
- Reference, Distance>& y) {
- return y.base() - x.base();
+template <class _RandomAccessIterator, class _Tp,
+ class _Reference, class _Distance>
+inline _Distance
+operator-(const reverse_iterator<_RandomAccessIterator, _Tp,
+ _Reference, _Distance>& __x,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ _Reference, _Distance>& __y)
+{
+ return __y.base() - __x.base();
}
-template <class RandomAccessIter, class T, class Ref, class Dist>
-inline reverse_iterator<RandomAccessIter, T, Ref, Dist>
-operator+(Dist n, const reverse_iterator<RandomAccessIter, T, Ref, Dist>& x) {
- return reverse_iterator<RandomAccessIter, T, Ref, Dist>(x.base() - n);
+template <class _RandAccIter, class _Tp, class _Ref, class _Dist>
+inline reverse_iterator<_RandAccIter, _Tp, _Ref, _Dist>
+operator+(_Dist __n,
+ const reverse_iterator<_RandAccIter, _Tp, _Ref, _Dist>& __x)
+{
+ return reverse_iterator<_RandAccIter, _Tp, _Ref, _Dist>(__x.base() - __n);
}
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
-template <class T, class Distance = ptrdiff_t>
+// When we have templatized iostreams, istream_iterator and ostream_iterator
+// must be rewritten.
+
+template <class _Tp, class _Dist = ptrdiff_t>
class istream_iterator {
- friend bool
- operator== __STL_NULL_TMPL_ARGS (const istream_iterator<T, Distance>& x,
- const istream_iterator<T, Distance>& y);
+ friend bool operator== __STL_NULL_TMPL_ARGS (const istream_iterator&,
+ const istream_iterator&);
protected:
- istream* stream;
- T value;
- bool end_marker;
- void read() {
- end_marker = (*stream) ? true : false;
- if (end_marker) *stream >> value;
- end_marker = (*stream) ? true : false;
+ istream* _M_stream;
+ _Tp _M_value;
+ bool _M_end_marker;
+ void _M_read() {
+ _M_end_marker = (*_M_stream) ? true : false;
+ if (_M_end_marker) *_M_stream >> _M_value;
+ _M_end_marker = (*_M_stream) ? true : false;
}
public:
- typedef input_iterator_tag iterator_category;
- typedef T value_type;
- typedef Distance difference_type;
- typedef const T* pointer;
- typedef const T& reference;
-
- istream_iterator() : stream(&cin), end_marker(false) {}
- istream_iterator(istream& s) : stream(&s) { read(); }
- reference operator*() const { return value; }
+ 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(&cin), _M_end_marker(false) {}
+ istream_iterator(istream& __s) : _M_stream(&__s) { _M_read(); }
+ reference operator*() const { return _M_value; }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
- istream_iterator<T, Distance>& operator++() {
- read();
+ istream_iterator<_Tp, _Dist>& operator++() {
+ _M_read();
return *this;
}
- istream_iterator<T, Distance> operator++(int) {
- istream_iterator<T, Distance> tmp = *this;
- read();
- return tmp;
+ istream_iterator<_Tp, _Dist> operator++(int) {
+ istream_iterator<_Tp, _Dist> __tmp = *this;
+ _M_read();
+ return __tmp;
}
};
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
-template <class T, class Distance>
+template <class _Tp, class _Dist>
inline input_iterator_tag
-iterator_category(const istream_iterator<T, Distance>&) {
+iterator_category(const istream_iterator<_Tp, _Dist>&)
+{
return input_iterator_tag();
}
-template <class T, class Distance>
-inline T* value_type(const istream_iterator<T, Distance>&) { return (T*) 0; }
+template <class _Tp, class _Dist>
+inline _Tp*
+value_type(const istream_iterator<_Tp, _Dist>&) { return (_Tp*) 0; }
-template <class T, class Distance>
-inline Distance* distance_type(const istream_iterator<T, Distance>&) {
- return (Distance*) 0;
-}
+template <class _Tp, class _Dist>
+inline _Dist*
+distance_type(const istream_iterator<_Tp, _Dist>&) { return (_Dist*)0; }
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
-template <class T, class Distance>
-inline bool operator==(const istream_iterator<T, Distance>& x,
- const istream_iterator<T, Distance>& y) {
- return x.stream == y.stream && x.end_marker == y.end_marker ||
- x.end_marker == false && y.end_marker == false;
+template <class _Tp, class _Distance>
+inline bool operator==(const istream_iterator<_Tp, _Distance>& __x,
+ const istream_iterator<_Tp, _Distance>& __y) {
+ return (__x._M_stream == __y._M_stream &&
+ __x._M_end_marker == __y._M_end_marker) ||
+ __x._M_end_marker == false && __y._M_end_marker == false;
}
-template <class T>
+template <class _Tp>
class ostream_iterator {
protected:
- ostream* stream;
- const char* string;
+ ostream* _M_stream;
+ const char* _M_string;
public:
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void pointer;
typedef void reference;
- ostream_iterator(ostream& s) : stream(&s), string(0) {}
- ostream_iterator(ostream& s, const char* c) : stream(&s), string(c) {}
- ostream_iterator<T>& operator=(const T& value) {
- *stream << value;
- if (string) *stream << string;
+ ostream_iterator(ostream& __s) : _M_stream(&__s), _M_string(0) {}
+ ostream_iterator(ostream& __s, const char* __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<T>& operator*() { return *this; }
- ostream_iterator<T>& operator++() { return *this; }
- ostream_iterator<T>& operator++(int) { return *this; }
+ ostream_iterator<_Tp>& operator*() { return *this; }
+ ostream_iterator<_Tp>& operator++() { return *this; }
+ ostream_iterator<_Tp>& operator++(int) { return *this; }
};
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
-template <class T>
+template <class _Tp>
inline output_iterator_tag
-iterator_category(const ostream_iterator<T>&) {
+iterator_category(const ostream_iterator<_Tp>&) {
return output_iterator_tag();
}
projects / gcc.git / blobdiff