879 lines
27 KiB
C++
879 lines
27 KiB
C++
#ifndef __RW_ITERATOR_H
|
||
#define __RW_ITERATOR_H
|
||
#pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
|
||
// -*- C++ -*-
|
||
#ifndef __STD_RW_ITERATOR__
|
||
#define __STD_RW_ITERATOR__
|
||
|
||
/***************************************************************************
|
||
*
|
||
* iterator - iterator declarations for the Standard Library
|
||
*
|
||
***************************************************************************
|
||
*
|
||
* Copyright (c) 1994
|
||
* Hewlett-Packard Company
|
||
*
|
||
* Permission to use, copy, modify, distribute and sell this software
|
||
* and its documentation for any purpose is hereby granted without fee,
|
||
* provided that the above copyright notice appear in all copies and
|
||
* that both that copyright notice and this permission notice appear
|
||
* in supporting documentation. Hewlett-Packard Company makes no
|
||
* representations about the suitability of this software for any
|
||
* purpose. It is provided "as is" without express or implied warranty.
|
||
*
|
||
*
|
||
***************************************************************************
|
||
*
|
||
* Copyright (c) 1994-1999 Rogue Wave Software, Inc. All Rights Reserved.
|
||
*
|
||
* This computer software is owned by Rogue Wave Software, Inc. and is
|
||
* protected by U.S. copyright laws and other laws and by international
|
||
* treaties. This computer software is furnished by Rogue Wave Software,
|
||
* Inc. pursuant to a written license agreement and may be used, copied,
|
||
* transmitted, and stored only in accordance with the terms of such
|
||
* license and with the inclusion of the above copyright notice. This
|
||
* computer software or any other copies thereof may not be provided or
|
||
* otherwise made available to any other person.
|
||
*
|
||
* U.S. Government Restricted Rights. This computer software is provided
|
||
* with Restricted Rights. Use, duplication, or disclosure by the
|
||
* Government is subject to restrictions as set forth in subparagraph (c)
|
||
* (1) (ii) of The Rights in Technical Data and Computer Software clause
|
||
* at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
|
||
* Commercial Computer Software – Restricted Rights at 48 CFR 52.227-19,
|
||
* as applicable. Manufacturer is Rogue Wave Software, Inc., 5500
|
||
* Flatiron Parkway, Boulder, Colorado 80301 USA.
|
||
*
|
||
**************************************************************************/
|
||
|
||
#include <stdcomp.h>
|
||
#include <rw/stddefs.h>
|
||
|
||
#ifndef _RWSTD_NO_NEW_HEADER
|
||
#include <cstddef>
|
||
#else
|
||
#include <stddef.h>
|
||
#endif
|
||
|
||
#ifdef _RWSTD_NO_BASE_CLASS_MATCH
|
||
#define _RWSTD_VALUE_TYPE(a) __value_type(*(a))
|
||
#else
|
||
#define _RWSTD_VALUE_TYPE(a) __value_type(a)
|
||
#endif
|
||
|
||
#ifndef _RWSTD_NO_NAMESPACE
|
||
namespace std {
|
||
#endif
|
||
|
||
//
|
||
// Standard iterator tags.
|
||
//
|
||
|
||
struct input_iterator_tag
|
||
{
|
||
input_iterator_tag() {;}
|
||
};
|
||
|
||
struct output_iterator_tag
|
||
{
|
||
output_iterator_tag() {;}
|
||
};
|
||
|
||
struct forward_iterator_tag : public input_iterator_tag
|
||
{
|
||
forward_iterator_tag() {;}
|
||
};
|
||
|
||
struct bidirectional_iterator_tag : public forward_iterator_tag
|
||
{
|
||
bidirectional_iterator_tag() {;}
|
||
};
|
||
|
||
struct random_access_iterator_tag : public bidirectional_iterator_tag
|
||
{
|
||
random_access_iterator_tag() {;}
|
||
};
|
||
//
|
||
// Basic iterators.
|
||
//
|
||
|
||
//
|
||
// Note that _RWSTD_SIMPLE_DEFAULT(x)
|
||
// will expand to: ' = x', or nothing,
|
||
// depending on your compiler's capabilities and/or
|
||
// flag settings (see stdcomp.h).
|
||
//
|
||
template <class Category, class T,
|
||
class Distance _RWSTD_SIMPLE_DEFAULT(ptrdiff_t),
|
||
class Pointer _RWSTD_SIMPLE_DEFAULT(T*),
|
||
class Reference _RWSTD_SIMPLE_DEFAULT(T&)>
|
||
struct iterator
|
||
{
|
||
typedef T value_type;
|
||
typedef Distance difference_type;
|
||
typedef Pointer pointer;
|
||
typedef Reference reference;
|
||
typedef Category iterator_category;
|
||
};
|
||
|
||
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
|
||
template <class Iterator> struct iterator_traits
|
||
{
|
||
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;
|
||
};
|
||
template <class T> struct iterator_traits<T*>
|
||
{
|
||
typedef T value_type;
|
||
typedef ptrdiff_t difference_type;
|
||
typedef T* pointer;
|
||
typedef T& reference;
|
||
typedef random_access_iterator_tag iterator_category;
|
||
};
|
||
template <class T> struct iterator_traits<const T*>
|
||
{
|
||
typedef T value_type;
|
||
typedef ptrdiff_t difference_type;
|
||
typedef const T* pointer;
|
||
typedef const T& reference;
|
||
typedef random_access_iterator_tag iterator_category;
|
||
};
|
||
|
||
template <class ForwardIterator>
|
||
inline _TYPENAME iterator_traits<ForwardIterator>::difference_type
|
||
distance (ForwardIterator first, ForwardIterator last)
|
||
{
|
||
_TYPENAME iterator_traits<ForwardIterator>::difference_type n = 0;
|
||
__distance(first, last, n,
|
||
iterator_traits<ForwardIterator>::iterator_category());
|
||
return n;
|
||
}
|
||
|
||
template <class ForwardIterator, class Distance>
|
||
inline void advance (ForwardIterator& i, Distance n)
|
||
{
|
||
__advance(i, n,
|
||
iterator_traits<ForwardIterator>::iterator_category());
|
||
}
|
||
|
||
#endif /* _RWSTD_NO_CLASS_PARTIAL_SPEC */
|
||
|
||
//
|
||
// __iterator_category returns the category of an iterator
|
||
//
|
||
|
||
template <class T>
|
||
inline random_access_iterator_tag
|
||
__iterator_category (const T*)
|
||
{
|
||
return random_access_iterator_tag();
|
||
}
|
||
|
||
/*
|
||
template <class T>
|
||
inline _TYPENAME T::iterator_category
|
||
__iterator_category (const T&)
|
||
{
|
||
_TYPENAME T::iterator_category tmp;
|
||
return tmp;
|
||
}
|
||
*/
|
||
template <class Category, class T, class Distance,
|
||
class Pointer, class Reference>
|
||
inline Category
|
||
__iterator_category (const iterator<Category, T, Distance,Pointer,Reference>&)
|
||
{
|
||
_TYPENAME iterator<Category, T, Distance,T*,T&>::iterator_category tmp;
|
||
return tmp;
|
||
}
|
||
|
||
//
|
||
// Special implementation function for determining whether
|
||
// or not we can back up an iterator
|
||
//
|
||
template <class _TAG>
|
||
inline bool __is_input_iterator(_TAG)
|
||
{ return false; }
|
||
|
||
template <class _TAG>
|
||
inline bool __is_bidirectional_iterator(_TAG)
|
||
{ return false; }
|
||
|
||
template <class _TAG>
|
||
inline bool __is_random_access_iterator(_TAG)
|
||
{ return false; }
|
||
|
||
inline bool __is_input_iterator(input_iterator_tag)
|
||
{ return true; }
|
||
|
||
inline bool __is_bidirectional_iterator(bidirectional_iterator_tag)
|
||
{ return true; }
|
||
|
||
inline bool __is_bidirectional_iterator(random_access_iterator_tag)
|
||
{ return true; }
|
||
|
||
inline bool __is_random_access_iterator(random_access_iterator_tag)
|
||
{ return true; }
|
||
|
||
//
|
||
// __value_type returns the type of value held by an iterator
|
||
//
|
||
template <class Category,class T, class Distance,
|
||
class Pointer, class Reference>
|
||
inline T* __value_type (const iterator<Category,T, Distance,Pointer,Reference>&)
|
||
{
|
||
return _RWSTD_STATIC_CAST(T*,0);
|
||
}
|
||
/*
|
||
template <class T>
|
||
inline _TYPENAME T::value_type*
|
||
__value_type (const T&)
|
||
{
|
||
return _RWSTD_STATIC_CAST(_TYPENAME T::value_type*,0);
|
||
}
|
||
*/
|
||
template <class T>
|
||
inline T*
|
||
__value_type (const T*)
|
||
{
|
||
return _RWSTD_STATIC_CAST(T*,0);
|
||
}
|
||
|
||
//
|
||
// __distance_type returns the difference type of an iterator
|
||
//
|
||
template <class Category,class T, class Distance,
|
||
class Pointer, class Reference>
|
||
inline Distance*
|
||
__distance_type (const iterator<Category,T, Distance,Pointer,Reference>&)
|
||
{
|
||
return _RWSTD_STATIC_CAST(Distance*,0);
|
||
}
|
||
/*
|
||
template <class T>
|
||
inline _TYPENAME T::difference_type*
|
||
__distance_type(const T&)
|
||
{
|
||
return _RWSTD_STATIC_CAST(_TYPENAME T::difference_type*,0);
|
||
}
|
||
*/
|
||
template <class T>
|
||
inline ptrdiff_t*
|
||
__distance_type (const T*)
|
||
{
|
||
return _RWSTD_STATIC_CAST(ptrdiff_t*,0);
|
||
}
|
||
|
||
//
|
||
// Implementation specific iterator operations.
|
||
//
|
||
|
||
template <class InputIterator, class Distance>
|
||
void __advance (InputIterator& i, Distance n, input_iterator_tag);
|
||
|
||
template <class ForwardIterator, class Distance>
|
||
void __advance (ForwardIterator& i, Distance n, forward_iterator_tag);
|
||
|
||
template <class BidirectionalIterator, class Distance>
|
||
void __advance (BidirectionalIterator& i, Distance n,
|
||
bidirectional_iterator_tag);
|
||
|
||
template <class InputIterator, class Distance>
|
||
void __distance (InputIterator first, InputIterator last, Distance& n,
|
||
input_iterator_tag);
|
||
|
||
template <class ForwardIterator, class Distance>
|
||
void __distance (ForwardIterator first, ForwardIterator last, Distance& n,
|
||
forward_iterator_tag);
|
||
|
||
template <class BidirectionalIterator, class Distance>
|
||
void __distance (BidirectionalIterator first, BidirectionalIterator last,
|
||
Distance& n, bidirectional_iterator_tag);
|
||
|
||
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 __advance (RandomAccessIterator& i, Distance n,
|
||
random_access_iterator_tag)
|
||
{
|
||
i += n;
|
||
}
|
||
|
||
//
|
||
// End of implemention specific functions
|
||
//
|
||
|
||
template <class ForwardIterator, class Distance>
|
||
inline void distance (ForwardIterator first, ForwardIterator last, Distance& n)
|
||
{
|
||
#ifndef _RWSTD_NO_BASE_CLASS_MATCH
|
||
__distance(first, last, n, __iterator_category(first));
|
||
#else
|
||
__distance(first, last, n, input_iterator_tag());
|
||
#endif
|
||
}
|
||
#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
template <class ForwardIterator, class Distance>
|
||
inline void advance (ForwardIterator& i, Distance n)
|
||
{
|
||
#ifndef _RWSTD_NO_BASE_CLASS_MATCH
|
||
__advance(i, n, __iterator_category(i));
|
||
#else
|
||
__advance(i, n, input_iterator_tag());
|
||
#endif
|
||
}
|
||
#endif /* _RWSTD_NO_CLASS_PARTIAL_SPEC */
|
||
|
||
//
|
||
// Reverse iterator.
|
||
//
|
||
|
||
//
|
||
// Macros for reverse iterator to accomodate non-standard compilers
|
||
//
|
||
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
#define _RWSTD_REVERSE_ITERATOR_TEMPLATE template <class Iterator>
|
||
#define _RWSTD_REVERSE_ITERATOR_TYPE reverse_iterator<Iterator>
|
||
#else
|
||
#define _RWSTD_REVERSE_ITERATOR_TEMPLATE \
|
||
template <class Iterator, class Category, class T, class Reference, class Pointer, class Distance>
|
||
#define _RWSTD_REVERSE_ITERATOR_TYPE \
|
||
reverse_iterator<Iterator,Category,T,Reference,Pointer,Distance>
|
||
#endif
|
||
//
|
||
// Forward Declarations.
|
||
//
|
||
#ifdef _RWSTD_NO_UNDEFINED_FRIEND
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE class reverse_iterator;
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator== (const _RWSTD_REVERSE_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& y);
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator< (const _RWSTD_REVERSE_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& y);
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline
|
||
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
_TYPENAME iterator_traits<Iterator>::difference_type
|
||
#else
|
||
Distance
|
||
#endif // _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
operator- (const _RWSTD_REVERSE_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& y);
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline _RWSTD_REVERSE_ITERATOR_TYPE
|
||
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
operator+ (_TYPENAME iterator_traits<Iterator>::difference_type n,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& x);
|
||
#else
|
||
operator+ (Distance n, const _RWSTD_REVERSE_ITERATOR_TYPE& x);
|
||
#endif // _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
#endif // _RWSTD_NO_UNDEFINED_FRIEND
|
||
|
||
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
template <class Iterator>
|
||
class reverse_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 reverse_iterator<Iterator> self;
|
||
public:
|
||
typedef typename iterator_traits<Iterator>::difference_type difference_type;
|
||
typedef typename iterator_traits<Iterator>::value_type value_type;
|
||
typedef typename iterator_traits<Iterator>::pointer pointer;
|
||
typedef typename iterator_traits<Iterator>::reference reference;
|
||
private:
|
||
#else
|
||
template <class Iterator, class Category, class T,
|
||
class Reference _RWSTD_COMPLEX_DEFAULT(T&),
|
||
class Pointer _RWSTD_COMPLEX_DEFAULT(T*),
|
||
class Distance _RWSTD_COMPLEX_DEFAULT(ptrdiff_t) >
|
||
class reverse_iterator
|
||
: public iterator<Category,T, Distance,Pointer,Reference>
|
||
|
||
{
|
||
typedef reverse_iterator<Iterator,Category,T,Reference,Pointer,Distance> self;
|
||
public:
|
||
typedef Distance difference_type;
|
||
typedef T value_type;
|
||
typedef Reference reference;
|
||
typedef Pointer pointer;
|
||
private:
|
||
#endif
|
||
#ifdef __TURBOC__
|
||
friend inline bool (std::operator==) (const self& x, const self& y);
|
||
friend inline bool (std::operator<) (const self& x, const self& y);
|
||
friend inline difference_type (std::operator-) (const self& x, const self& y);
|
||
friend inline self (std::operator+) (difference_type n, const self& x);
|
||
#else
|
||
friend inline bool operator== (const self& x, const self& y);
|
||
friend inline bool operator< (const self& x, const self& y);
|
||
friend inline difference_type operator- (const self& x, const self& y);
|
||
friend inline self operator+ (difference_type n, const self& x);
|
||
#endif
|
||
protected:
|
||
|
||
Iterator current;
|
||
|
||
public:
|
||
typedef Iterator iterator_type;
|
||
|
||
reverse_iterator() {}
|
||
_EXPLICIT reverse_iterator (Iterator x) : current(x) {}
|
||
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
template <class U>
|
||
reverse_iterator (const reverse_iterator<U>& x) : current(x.base()) {}
|
||
#endif
|
||
Iterator base () const { return current; }
|
||
reference operator* () const
|
||
{ Iterator tmp = current; return *--tmp; }
|
||
#ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN
|
||
pointer operator->() const
|
||
{ reference tmp = operator*(); return (pointer)&tmp; }
|
||
#endif
|
||
|
||
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; }
|
||
|
||
self operator+ (difference_type n) const
|
||
{ self tmp(current - n); return tmp; }
|
||
self& operator+= (difference_type n) { current -= n; return *this; }
|
||
self operator- (difference_type n) const { self tmp(current + n); return tmp; }
|
||
self& operator-= (difference_type n) { current += n; return *this; }
|
||
|
||
reference operator[] (difference_type n) const { return *(*this + n); }
|
||
};
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator== (const _RWSTD_REVERSE_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& y)
|
||
{
|
||
return x.current == y.current;
|
||
}
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator< (const _RWSTD_REVERSE_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& y)
|
||
{
|
||
return y.current < x.current;
|
||
}
|
||
|
||
#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator!= (const _RWSTD_REVERSE_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& y)
|
||
{
|
||
return !(x == y);
|
||
}
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator> (const _RWSTD_REVERSE_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& y)
|
||
{
|
||
return y < x;
|
||
}
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator<= (const _RWSTD_REVERSE_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& y)
|
||
{
|
||
return !(y < x);
|
||
}
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator>= (const _RWSTD_REVERSE_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& y)
|
||
{
|
||
return !(x < y);
|
||
}
|
||
#endif // _RWSTD_NO_NAMESPACE) || _RWSTD_NO_PART_SPEC_OVERLOAD
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline
|
||
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
_TYPENAME iterator_traits<Iterator>::difference_type
|
||
#else
|
||
Distance
|
||
#endif
|
||
operator- (const _RWSTD_REVERSE_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_ITERATOR_TYPE& y)
|
||
{
|
||
return y.current - x.current;
|
||
}
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline _RWSTD_REVERSE_ITERATOR_TYPE
|
||
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
operator+ (_TYPENAME iterator_traits<Iterator>::difference_type n,
|
||
_RWSTD_REVERSE_ITERATOR_TYPE& x)
|
||
#else
|
||
operator+ (Distance n, _RWSTD_REVERSE_ITERATOR_TYPE& x)
|
||
#endif
|
||
{
|
||
return _RWSTD_REVERSE_ITERATOR_TYPE(x.current - n);
|
||
}
|
||
#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
//
|
||
// Reverse bidirectional iterator.
|
||
// This is needed to get around non-standard compilers that insist
|
||
// on instantiating all members of a class whether they're used
|
||
// or not.
|
||
//
|
||
|
||
//
|
||
// Macros for reverse iterator to accomodate non-standard compilers
|
||
//
|
||
#define _RWSTD_REVERSE_BI_ITERATOR_TYPE \
|
||
__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance>
|
||
//
|
||
// Forward Declarations.
|
||
//
|
||
#ifdef _RWSTD_NO_UNDEFINED_FRIEND
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE class __reverse_bi_iterator;
|
||
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator== (const _RWSTD_REVERSE_BI_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_BI_ITERATOR_TYPE& y);
|
||
|
||
#endif // _RWSTD_NO_UNDEFINED_FRIEND
|
||
|
||
template <class Iterator, class Category, class T,
|
||
class Reference _RWSTD_COMPLEX_DEFAULT(T&),
|
||
class Pointer _RWSTD_COMPLEX_DEFAULT(T*),
|
||
class Distance _RWSTD_COMPLEX_DEFAULT(ptrdiff_t) >
|
||
class __reverse_bi_iterator
|
||
: public iterator<Category,T, Distance,Pointer,Reference>
|
||
|
||
{
|
||
typedef __reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> self;
|
||
typedef Distance difference_type;
|
||
typedef T value_type;
|
||
typedef Reference reference;
|
||
typedef Pointer pointer;
|
||
|
||
friend inline bool operator== (const self& x, const self& y);
|
||
|
||
protected:
|
||
|
||
Iterator current;
|
||
|
||
public:
|
||
typedef Iterator iterator_type;
|
||
|
||
__reverse_bi_iterator() {}
|
||
_EXPLICIT __reverse_bi_iterator (Iterator x) : current(x) {}
|
||
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
template <class U>
|
||
_EXPLICIT __reverse_bi_iterator (const reverse_iterator<U>) : current(x) {}
|
||
#endif
|
||
Iterator base () const { return current; }
|
||
reference operator* () const
|
||
{ Iterator tmp = current; return *--tmp; }
|
||
#ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN
|
||
pointer operator->() const
|
||
{ reference tmp = operator*(); return (pointer)&tmp; }
|
||
#endif
|
||
|
||
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; }
|
||
};
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator== (const _RWSTD_REVERSE_BI_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_BI_ITERATOR_TYPE& y)
|
||
{
|
||
return x.current == y.current;
|
||
}
|
||
|
||
#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
|
||
_RWSTD_REVERSE_ITERATOR_TEMPLATE
|
||
inline bool operator!= (const _RWSTD_REVERSE_BI_ITERATOR_TYPE& x,
|
||
const _RWSTD_REVERSE_BI_ITERATOR_TYPE& y)
|
||
{
|
||
return !(x == y);
|
||
}
|
||
|
||
#endif // _RWSTD_NO_NAMESPACE || _RWSTD_NO_PART_SPEC_OVERLOAD
|
||
#endif // _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
|
||
//
|
||
// Back insert iterator.
|
||
//
|
||
|
||
template <class Container>
|
||
class back_insert_iterator
|
||
: public iterator<output_iterator_tag, void, void, void, void>
|
||
{
|
||
protected:
|
||
|
||
Container* container;
|
||
|
||
public:
|
||
typedef Container container_type;
|
||
|
||
_EXPLICIT back_insert_iterator (Container& x) : container(&x) {}
|
||
back_insert_iterator<Container>&
|
||
operator= (const _TYPENAME Container::const_reference 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; }
|
||
};
|
||
|
||
template <class Container>
|
||
inline back_insert_iterator<Container> back_inserter (Container& x)
|
||
{
|
||
return back_insert_iterator<Container>(x);
|
||
}
|
||
|
||
//
|
||
// Front insert iterator.
|
||
//
|
||
|
||
template <class Container>
|
||
class front_insert_iterator
|
||
: public iterator<output_iterator_tag,
|
||
_TYPENAME Container::value_type,
|
||
_TYPENAME Container::difference_type,
|
||
_TYPENAME Container::pointer,
|
||
_TYPENAME Container::reference>
|
||
{
|
||
protected:
|
||
|
||
Container* container;
|
||
|
||
public:
|
||
typedef Container container_type;
|
||
typedef _TYPENAME Container::value_type value_type;
|
||
|
||
_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; }
|
||
};
|
||
|
||
template <class Container>
|
||
inline front_insert_iterator<Container> front_inserter (Container& x)
|
||
{
|
||
return front_insert_iterator<Container>(x);
|
||
}
|
||
|
||
//
|
||
// Insert iterator.
|
||
//
|
||
|
||
template <class Container>
|
||
class insert_iterator
|
||
: public iterator<output_iterator_tag,
|
||
_TYPENAME Container::value_type,
|
||
_TYPENAME Container::difference_type,
|
||
_TYPENAME Container::pointer,
|
||
_TYPENAME Container::reference>
|
||
{
|
||
private:
|
||
_TYPENAME Container::iterator iter;
|
||
|
||
protected:
|
||
Container* container;
|
||
|
||
public:
|
||
typedef Container container_type;
|
||
typedef _TYPENAME Container::value_type value_type;
|
||
|
||
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; }
|
||
};
|
||
|
||
template <class Container, class Iterator>
|
||
inline insert_iterator<Container> inserter (Container& x, Iterator i)
|
||
{
|
||
_TYPENAME Container::iterator c(i);
|
||
insert_iterator<Container> tmp(x, c);
|
||
return tmp;
|
||
}
|
||
|
||
#ifndef __RW_TRAITS
|
||
template <class charT> struct _RWSTDExportTemplate char_traits;
|
||
_RWSTD_TEMPLATE struct _RWSTDExport char_traits<char>;
|
||
#ifndef _RWSTD_NO_WIDE_CHAR
|
||
_RWSTD_TEMPLATE struct _RWSTDExport char_traits<wchar_t>;
|
||
#endif
|
||
#endif // __RW_TRAITS
|
||
|
||
#ifndef _RWSTD_NO_NAMESPACE
|
||
}
|
||
#endif
|
||
|
||
#ifdef _RW_STD_IOSTREAM
|
||
//#include <iostream>
|
||
#else
|
||
#include <iostream.h>
|
||
#endif
|
||
|
||
#ifndef _RWSTD_NO_NAMESPACE
|
||
namespace std {
|
||
#endif
|
||
|
||
#ifndef _RW_STD_IOSTREAM
|
||
//
|
||
// Stream iterators.
|
||
//
|
||
|
||
#ifdef _RWSTD_NO_UNDEFINED_FRIEND
|
||
template <class T, class charT, class traits, class Distance>
|
||
class istream_iterator;
|
||
|
||
template <class T, class charT, class traits, class Distance>
|
||
bool operator== (const istream_iterator<T, charT,traits,Distance>& x,
|
||
const istream_iterator<T, charT,traits,Distance>& y);
|
||
#endif
|
||
|
||
template <class T, class charT = char,
|
||
class traits = char_traits<charT>,
|
||
class Distance = ptrdiff_t>
|
||
class istream_iterator
|
||
: public iterator<input_iterator_tag,T,Distance,const T*,const T&>
|
||
{
|
||
friend inline bool operator== (const istream_iterator<T, charT,traits,Distance>& x,
|
||
const istream_iterator<T, charT,traits,Distance>& y);
|
||
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;
|
||
}
|
||
public:
|
||
typedef T value_type;
|
||
typedef charT char_type;
|
||
typedef traits traits_type;
|
||
typedef istream istream_type;
|
||
|
||
istream_iterator () : stream(&cin), end_marker(false) {}
|
||
istream_iterator (istream& s) : stream(&s) { read(); }
|
||
istream_iterator ( const istream_iterator<T,charT,traits,Distance>& x )
|
||
:stream(x.stream) , value(x.value) , end_marker(x.end_marker)
|
||
{ }
|
||
const T& operator* () const { return value; }
|
||
#ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN
|
||
const T* operator->() const { return &value; }
|
||
#endif
|
||
istream_iterator<T, charT,traits,Distance>& operator++ ()
|
||
{
|
||
read(); return *this;
|
||
}
|
||
istream_iterator<T, charT,traits,Distance> operator++ (int)
|
||
{
|
||
istream_iterator<T, charT,traits,Distance> tmp = *this;
|
||
read();
|
||
return tmp;
|
||
}
|
||
};
|
||
|
||
template <class T, class charT, class traits, class Distance>
|
||
inline bool operator== (const istream_iterator<T, charT,traits,Distance>& x,
|
||
const istream_iterator<T, charT,traits,Distance>& y)
|
||
{
|
||
return x.stream == y.stream && x.end_marker == y.end_marker ||
|
||
x.end_marker == false && y.end_marker == false;
|
||
}
|
||
|
||
#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
|
||
template <class T, class charT, class traits, class Distance>
|
||
inline bool operator!= (const istream_iterator<T, charT,traits,Distance>& x,
|
||
const istream_iterator<T, charT,traits,Distance>& y)
|
||
{
|
||
return !(x == y);
|
||
}
|
||
#endif
|
||
|
||
#ifndef _RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES
|
||
template <class T, class charT = char,
|
||
class traits = char_traits<charT> >
|
||
#else
|
||
template <class T, class charT, class traits>
|
||
#endif
|
||
class ostream_iterator : public iterator<output_iterator_tag,T,ptrdiff_t,T*,T&>
|
||
{
|
||
protected:
|
||
|
||
ostream* stream;
|
||
const char* str;
|
||
|
||
public:
|
||
typedef T value_type;
|
||
typedef charT char_type;
|
||
typedef traits traits_type;
|
||
typedef ostream istream_type;
|
||
|
||
ostream_iterator (ostream& s) : stream(&s), str(0) { ; }
|
||
ostream_iterator (ostream& s,const char* c)
|
||
: stream(&s), str((char *)c) { ; }
|
||
ostream_iterator ( const ostream_iterator<T,charT,traits>& x )
|
||
:stream(x.stream) , str(x.str)
|
||
{ ; }
|
||
ostream_iterator<T,charT,traits>& operator= (const T& value)
|
||
{
|
||
*stream << value;
|
||
if (str) *stream << str;
|
||
return *this;
|
||
}
|
||
ostream_iterator<T,charT,traits>& operator* () { return *this; }
|
||
ostream_iterator<T,charT,traits>& operator++ () { return *this; }
|
||
ostream_iterator<T,charT,traits>& operator++ (int) { return *this; }
|
||
};
|
||
|
||
#endif /* _RW_STD_IOSTREAM */
|
||
#ifndef _RWSTD_NO_NAMESPACE
|
||
}
|
||
#endif
|
||
|
||
#ifdef _RWSTD_NO_TEMPLATE_REPOSITORY
|
||
#include <rw/iterator.cc>
|
||
#endif
|
||
|
||
#endif /* __STD_RW_ITERATOR__ */
|
||
|
||
#pragma option pop
|
||
#endif /* __RW_ITERATOR_H */
|