1.1 --- a/epoc32/include/stdapis/stlport/stl/_iterator_base.h Tue Nov 24 13:55:44 2009 +0000
1.2 +++ b/epoc32/include/stdapis/stlport/stl/_iterator_base.h Tue Mar 16 16:12:26 2010 +0000
1.3 @@ -1,1 +1,463 @@
1.4 -_iterator_base.h
1.5 +/*
1.6 + *
1.7 + * Copyright (c) 1994
1.8 + * Hewlett-Packard Company
1.9 + *
1.10 + * Copyright (c) 1996-1998
1.11 + * Silicon Graphics Computer Systems, Inc.
1.12 + *
1.13 + * Copyright (c) 1997
1.14 + * Moscow Center for SPARC Technology
1.15 + *
1.16 + * Copyright (c) 1999
1.17 + * Boris Fomitchev
1.18 + *
1.19 + * This material is provided "as is", with absolutely no warranty expressed
1.20 + * or implied. Any use is at your own risk.
1.21 + *
1.22 + * Permission to use or copy this software for any purpose is hereby granted
1.23 + * without fee, provided the above notices are retained on all copies.
1.24 + * Permission to modify the code and to distribute modified code is granted,
1.25 + * provided the above notices are retained, and a notice that the code was
1.26 + * modified is included with the above copyright notice.
1.27 + *
1.28 + */
1.29 +
1.30 +/* NOTE: This is an internal header file, included by other STL headers.
1.31 + * You should not attempt to use it directly.
1.32 + */
1.33 +
1.34 +#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
1.35 +#define _STLP_INTERNAL_ITERATOR_BASE_H
1.36 +
1.37 +#ifndef _STLP_CSTDDEF
1.38 +# include <cstddef>
1.39 +#endif
1.40 +
1.41 +# if defined (_STLP_IMPORT_VENDOR_CSTD) && ! defined (_STLP_VENDOR_GLOBAL_CSTD)
1.42 +_STLP_BEGIN_NAMESPACE
1.43 +using namespace _STLP_VENDOR_CSTD;
1.44 +_STLP_END_NAMESPACE
1.45 +#endif /* _STLP_IMPORT_VENDOR_CSTD */
1.46 +
1.47 +#ifndef __TYPE_TRAITS_H
1.48 +# include <stl/type_traits.h>
1.49 +#endif
1.50 +
1.51 +_STLP_BEGIN_NAMESPACE
1.52 +
1.53 +struct input_iterator_tag {};
1.54 +struct output_iterator_tag {};
1.55 +struct forward_iterator_tag : public input_iterator_tag {};
1.56 +struct bidirectional_iterator_tag : public forward_iterator_tag {};
1.57 +struct random_access_iterator_tag : public bidirectional_iterator_tag {};
1.58 +
1.59 +
1.60 +template <class _Category, class _Tp, __DFL_TMPL_PARAM(_Distance,ptrdiff_t),
1.61 + __DFL_TMPL_PARAM(_Pointer,_Tp*), __DFL_TMPL_PARAM(_Reference,_Tp&) >
1.62 +struct iterator {
1.63 + typedef _Category iterator_category;
1.64 + typedef _Tp value_type;
1.65 + typedef _Distance difference_type;
1.66 + typedef _Pointer pointer;
1.67 + typedef _Reference reference;
1.68 +};
1.69 +_STLP_TEMPLATE_NULL
1.70 +struct iterator<output_iterator_tag, void, void, void, void> {
1.71 + typedef output_iterator_tag iterator_category;
1.72 +#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
1.73 + typedef void value_type;
1.74 + typedef void difference_type;
1.75 + typedef void pointer;
1.76 + typedef void reference;
1.77 +#endif
1.78 +};
1.79 +
1.80 +# ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
1.81 +# define _STLP_ITERATOR_CATEGORY(_It, _Tp) iterator_category(_It)
1.82 +# define _STLP_DISTANCE_TYPE(_It, _Tp) distance_type(_It)
1.83 +# define _STLP_VALUE_TYPE(_It, _Tp) value_type(_It)
1.84 +# else
1.85 +# ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
1.86 +# define _STLP_VALUE_TYPE(_It, _Tp) (typename iterator_traits< _Tp >::value_type*)0
1.87 +# define _STLP_DISTANCE_TYPE(_It, _Tp) (typename iterator_traits< _Tp >::difference_type*)0
1.88 +# if defined (__BORLANDC__) || defined (__SUNPRO_CC) || ( defined (__MWERKS__) && (__MWERKS__ <= 0x2303)) || ( defined (__sgi) && defined (_COMPILER_VERSION)) || defined (__DMC__)
1.89 +# define _STLP_ITERATOR_CATEGORY(_It, _Tp) iterator_traits< _Tp >::iterator_category()
1.90 +# else
1.91 +# define _STLP_ITERATOR_CATEGORY(_It, _Tp) typename iterator_traits< _Tp >::iterator_category()
1.92 +# endif
1.93 +# else
1.94 +# define _STLP_ITERATOR_CATEGORY(_It, _Tp) __iterator_category(_It, _IsPtrType<_Tp>::_Ret())
1.95 +# define _STLP_DISTANCE_TYPE(_It, _Tp) (ptrdiff_t*)0
1.96 +# define _STLP_VALUE_TYPE(_It, _Tp) __value_type(_It, _IsPtrType<_Tp>::_Ret() )
1.97 +# endif
1.98 +# endif
1.99 +
1.100 +template <class _Iterator>
1.101 +struct iterator_traits {
1.102 + typedef typename _Iterator::iterator_category iterator_category;
1.103 + typedef typename _Iterator::value_type value_type;
1.104 + typedef typename _Iterator::difference_type difference_type;
1.105 + typedef typename _Iterator::pointer pointer;
1.106 + typedef typename _Iterator::reference reference;
1.107 +};
1.108 +
1.109 +
1.110 +# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && ! defined (__SUNPRO_CC)
1.111 +# define _STLP_DIFFERENCE_TYPE(_Iterator) typename iterator_traits<_Iterator>::difference_type
1.112 +# else
1.113 +# define _STLP_DIFFERENCE_TYPE(_Iterator) ptrdiff_t
1.114 +# endif
1.115 +
1.116 +# ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
1.117 +
1.118 +// fbp : this order keeps gcc happy
1.119 +template <class _Tp>
1.120 +struct iterator_traits<const _Tp*> {
1.121 + typedef random_access_iterator_tag iterator_category;
1.122 + typedef _Tp value_type;
1.123 + typedef ptrdiff_t difference_type;
1.124 + typedef const _Tp* pointer;
1.125 + typedef const _Tp& reference;
1.126 +};
1.127 +
1.128 +template <class _Tp>
1.129 +struct iterator_traits<_Tp*> {
1.130 + typedef random_access_iterator_tag iterator_category;
1.131 + typedef _Tp value_type;
1.132 + typedef ptrdiff_t difference_type;
1.133 + typedef _Tp* pointer;
1.134 + typedef _Tp& reference;
1.135 +};
1.136 +
1.137 +# if defined (__BORLANDC__)
1.138 +template <class _Tp>
1.139 +struct iterator_traits<_Tp* const> {
1.140 + typedef random_access_iterator_tag iterator_category;
1.141 + typedef _Tp value_type;
1.142 + typedef ptrdiff_t difference_type;
1.143 + typedef const _Tp* pointer;
1.144 + typedef const _Tp& reference;
1.145 +};
1.146 +# endif
1.147 +
1.148 +# endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
1.149 +
1.150 +
1.151 +# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) \
1.152 + || (defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) && ! defined (_STLP_NO_ARROW_OPERATOR))
1.153 +# define _STLP_POINTERS_SPECIALIZE( _TpP )
1.154 +# define _STLP_DEFINE_ARROW_OPERATOR pointer operator->() const { return &(operator*()); }
1.155 +# else
1.156 +# include <stl/_ptrs_specialize.h>
1.157 +# endif
1.158 +
1.159 +# ifndef _STLP_USE_OLD_HP_ITERATOR_QUERIES
1.160 +// The overloaded functions iterator_category, distance_type, and
1.161 +// value_type are not part of the C++ standard. (They have been
1.162 +// replaced by struct iterator_traits.) They are included for
1.163 +// backward compatibility with the HP STL.
1.164 +// We introduce internal names for these functions.
1.165 +
1.166 +# ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
1.167 +
1.168 +template <class _Iter>
1.169 +inline typename iterator_traits<_Iter>::iterator_category __iterator_category(const _Iter&) {
1.170 + typedef typename iterator_traits<_Iter>::iterator_category _Category;
1.171 + return _Category();
1.172 +}
1.173 +
1.174 +template <class _Iter>
1.175 +inline typename iterator_traits<_Iter>::difference_type* __distance_type(const _Iter&) {
1.176 + typedef typename iterator_traits<_Iter>::difference_type _diff_type;
1.177 + return __STATIC_CAST(_diff_type*,0);
1.178 +}
1.179 +
1.180 +template <class _Iter>
1.181 +inline typename iterator_traits<_Iter>::value_type* __value_type(const _Iter&) {
1.182 + typedef typename iterator_traits<_Iter>::value_type _value_type;
1.183 + return __STATIC_CAST(_value_type*,0);
1.184 +}
1.185 +
1.186 +# else
1.187 +
1.188 +template <class _Iter>
1.189 +inline random_access_iterator_tag
1.190 +__iterator_category(const _Iter&, const __true_type&) {
1.191 + return random_access_iterator_tag();
1.192 +}
1.193 +
1.194 +template <class _Iter>
1.195 +inline _STLP_TYPENAME_ON_RETURN_TYPE iterator_traits<_Iter>::iterator_category
1.196 +__iterator_category(const _Iter&, const __false_type&) {
1.197 + typedef typename iterator_traits<_Iter>::iterator_category _Category;
1.198 + return _Category();
1.199 +}
1.200 +
1.201 +
1.202 +template <class _Iter>
1.203 +inline ptrdiff_t* _STLP_CALL __distance_type(const _Iter&) { return (ptrdiff_t*)(0); }
1.204 +
1.205 +template <class _Iter>
1.206 +inline _STLP_TYPENAME_ON_RETURN_TYPE iterator_traits<_Iter>::value_type*
1.207 +__value_type(const _Iter&, const __false_type&) {
1.208 + typedef typename iterator_traits<_Iter>::value_type _value_type;
1.209 + return __STATIC_CAST(_value_type*,0);
1.210 +}
1.211 +
1.212 +template <class _Tp>
1.213 +inline _Tp*
1.214 +__value_type(const _Tp*, const __true_type&) {
1.215 + return __STATIC_CAST(_Tp*, 0);
1.216 +}
1.217 +
1.218 +# endif
1.219 +
1.220 +#else /* old queries */
1.221 +template <class _Category, class _Tp, class _Distance, class _Pointer, class _Reference>
1.222 +inline _Category _STLP_CALL iterator_category(const iterator<_Category,_Tp,_Distance,_Pointer,_Reference>&) { return _Category(); }
1.223 +template <class _Category, class _Tp, class _Distance, class _Pointer, class _Reference>
1.224 +inline _Tp* _STLP_CALL value_type(const iterator<_Category,_Tp,_Distance,_Pointer,_Reference>&) { return (_Tp*)(0); }
1.225 +template <class _Category, class _Tp, class _Distance, class _Pointer, class _Reference>
1.226 +inline _Distance* _STLP_CALL distance_type(const iterator<_Category,_Tp,_Distance,_Pointer,_Reference>&) { return (_Distance*)(0); }
1.227 +template <class _Tp>
1.228 +inline random_access_iterator_tag _STLP_CALL iterator_category(const _Tp*) { return random_access_iterator_tag(); }
1.229 +template <class _Tp>
1.230 +inline _Tp* _STLP_CALL value_type(const _Tp*) { return (_Tp*)(0); }
1.231 +template <class _Tp>
1.232 +inline ptrdiff_t* _STLP_CALL distance_type(const _Tp*) { return (ptrdiff_t*)(0); }
1.233 +#endif /* _STLP_USE_OLD_HP_ITERATOR_QUERIES */
1.234 +
1.235 +# if ! defined (_STLP_NO_ANACHRONISMS)
1.236 +// The base classes input_iterator, output_iterator, forward_iterator,
1.237 +// bidirectional_iterator, and random_access_iterator are not part of
1.238 +// the C++ standard. (They have been replaced by struct iterator.)
1.239 +// They are included for backward compatibility with the HP STL.
1.240 +template <class _Tp, class _Distance> struct input_iterator :
1.241 + public iterator <input_iterator_tag, _Tp, _Distance, _Tp*, _Tp&> {};
1.242 +struct output_iterator : public iterator <output_iterator_tag, void, void, void, void> {};
1.243 +template <class _Tp, class _Distance> struct forward_iterator :
1.244 + public iterator<forward_iterator_tag, _Tp, _Distance, _Tp*, _Tp&> {};
1.245 +template <class _Tp, class _Distance> struct bidirectional_iterator :
1.246 + public iterator<bidirectional_iterator_tag, _Tp, _Distance, _Tp*, _Tp&> {};
1.247 +template <class _Tp, class _Distance> struct random_access_iterator :
1.248 + public iterator<random_access_iterator_tag, _Tp, _Distance, _Tp*, _Tp&> {};
1.249 +
1.250 +# if defined (_STLP_BASE_MATCH_BUG) && defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
1.251 +template <class _Tp, class _Distance>
1.252 +inline input_iterator_tag _STLP_CALL
1.253 +iterator_category(const input_iterator<_Tp, _Distance>&) { return input_iterator_tag(); }
1.254 +inline output_iterator_tag _STLP_CALL
1.255 +iterator_category(const output_iterator&) { return output_iterator_tag(); }
1.256 +template <class _Tp, class _Distance>
1.257 +inline forward_iterator_tag _STLP_CALL
1.258 +iterator_category(const forward_iterator<_Tp, _Distance>&) { return forward_iterator_tag(); }
1.259 +template <class _Tp, class _Distance>
1.260 +inline bidirectional_iterator_tag _STLP_CALL
1.261 +iterator_category(const bidirectional_iterator<_Tp, _Distance>&) { return bidirectional_iterator_tag(); }
1.262 +template <class _Tp, class _Distance>
1.263 +inline random_access_iterator_tag _STLP_CALL
1.264 +iterator_category(const random_access_iterator<_Tp, _Distance>&) { return random_access_iterator_tag(); }
1.265 +template <class _Tp, class _Distance>
1.266 +inline _Tp* _STLP_CALL value_type(const input_iterator<_Tp, _Distance>&) { return (_Tp*)(0); }
1.267 +template <class _Tp, class _Distance>
1.268 +inline _Tp* _STLP_CALL value_type(const forward_iterator<_Tp, _Distance>&) { return (_Tp*)(0); }
1.269 +template <class _Tp, class _Distance>
1.270 +inline _Tp* _STLP_CALL value_type(const bidirectional_iterator<_Tp, _Distance>&) { return (_Tp*)(0); }
1.271 +template <class _Tp, class _Distance>
1.272 +inline _Tp* _STLP_CALL value_type(const random_access_iterator<_Tp, _Distance>&) { return (_Tp*)(0); }
1.273 +template <class _Tp, class _Distance>
1.274 +inline _Distance* _STLP_CALL distance_type(const input_iterator<_Tp, _Distance>&) { return (_Distance*)(0); }
1.275 +template <class _Tp, class _Distance>
1.276 +inline _Distance* _STLP_CALL distance_type(const forward_iterator<_Tp, _Distance>&) { return (_Distance*)(0); }
1.277 +template <class _Tp, class _Distance>
1.278 +inline _Distance* _STLP_CALL distance_type(const bidirectional_iterator<_Tp, _Distance>&) { return (_Distance*)(0);}
1.279 +template <class _Tp, class _Distance>
1.280 +inline _Distance* _STLP_CALL distance_type(const random_access_iterator<_Tp, _Distance>&) { return (_Distance*)(0); }
1.281 +# endif /* BASE_MATCH */
1.282 +
1.283 +#endif /* _STLP_NO_ANACHRONISMS */
1.284 +
1.285 +template <class _InputIterator, class _Distance>
1.286 +inline void _STLP_CALL __distance(const _InputIterator& __first, const _InputIterator& __last,
1.287 + _Distance& __n, const input_iterator_tag &) {
1.288 + _InputIterator __it(__first);
1.289 + while (__it != __last) { ++__it; ++__n; }
1.290 +}
1.291 +
1.292 +# if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
1.293 +template <class _ForwardIterator, class _Distance>
1.294 +inline void _STLP_CALL __distance(const _ForwardIterator& __first, const _ForwardIterator& __last,
1.295 + _Distance& __n, const forward_iterator_tag &) {
1.296 + _ForwardIterator __it(__first);
1.297 + while (__it != __last) { ++__first; ++__n; }
1.298 +}
1.299 +
1.300 +template <class _BidirectionalIterator, class _Distance>
1.301 +_STLP_INLINE_LOOP void _STLP_CALL __distance(const _BidirectionalIterator& __first,
1.302 + const _BidirectionalIterator& __last,
1.303 + _Distance& __n, const bidirectional_iterator_tag &) {
1.304 + _BidirectionalIterator __it(__first);
1.305 + while (__it != __last) { ++__it; ++__n; }
1.306 +}
1.307 +# endif
1.308 +
1.309 +template <class _RandomAccessIterator, class _Distance>
1.310 +inline void _STLP_CALL __distance(const _RandomAccessIterator& __first,
1.311 + const _RandomAccessIterator& __last,
1.312 + _Distance& __n, const random_access_iterator_tag &) {
1.313 + __n += __last - __first;
1.314 +}
1.315 +
1.316 +#ifndef _STLP_NO_ANACHRONISMS
1.317 +template <class _InputIterator, class _Distance>
1.318 +inline void _STLP_CALL distance(const _InputIterator& __first,
1.319 + const _InputIterator& __last, _Distance& __n) {
1.320 + __distance(__first, __last, __n, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
1.321 +}
1.322 +#endif
1.323 +
1.324 +template <class _InputIterator>
1.325 +inline _STLP_DIFFERENCE_TYPE(_InputIterator) _STLP_CALL
1.326 +__distance(const _InputIterator& __first, const _InputIterator& __last, const input_iterator_tag &) {
1.327 + _STLP_DIFFERENCE_TYPE(_InputIterator) __n = 0;
1.328 + _InputIterator __it(__first);
1.329 + while (__it != __last) {
1.330 + ++__it; ++__n;
1.331 + }
1.332 + return __n;
1.333 +}
1.334 +
1.335 +# if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
1.336 +template <class _ForwardIterator>
1.337 +inline _STLP_DIFFERENCE_TYPE(_ForwardIterator) _STLP_CALL
1.338 +__distance(const _ForwardIterator& __first, const _ForwardIterator& __last,
1.339 + const forward_iterator_tag &)
1.340 +{
1.341 + _STLP_DIFFERENCE_TYPE(_ForwardIterator) __n = 0;
1.342 + _ForwardIterator __it(__first);
1.343 + while (__it != __last) {
1.344 + ++__it; ++__n;
1.345 + }
1.346 + return __n;
1.347 +}
1.348 +
1.349 +template <class _BidirectionalIterator>
1.350 +_STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_BidirectionalIterator) _STLP_CALL
1.351 +__distance(const _BidirectionalIterator& __first,
1.352 + const _BidirectionalIterator& __last,
1.353 + const bidirectional_iterator_tag &) {
1.354 + _STLP_DIFFERENCE_TYPE(_BidirectionalIterator) __n = 0;
1.355 + _BidirectionalIterator __it(__first);
1.356 + while (__it != __last) {
1.357 + ++__it; ++__n;
1.358 + }
1.359 + return __n;
1.360 +}
1.361 +# endif
1.362 +
1.363 +template <class _RandomAccessIterator>
1.364 +inline _STLP_DIFFERENCE_TYPE(_RandomAccessIterator) _STLP_CALL
1.365 +__distance(const _RandomAccessIterator& __first, const _RandomAccessIterator& __last,
1.366 + const random_access_iterator_tag &) {
1.367 + return __last - __first;
1.368 +}
1.369 +
1.370 +template <class _InputIterator>
1.371 +inline _STLP_DIFFERENCE_TYPE(_InputIterator) _STLP_CALL
1.372 +distance(const _InputIterator& __first, const _InputIterator& __last) {
1.373 + return __distance(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
1.374 +}
1.375 +
1.376 +
1.377 +// fbp: those are being used for iterator/const_iterator definitions everywhere
1.378 +template <class _Tp>
1.379 +struct _Nonconst_traits;
1.380 +
1.381 +template <class _Tp>
1.382 +struct _Const_traits {
1.383 + typedef _Tp value_type;
1.384 + typedef const _Tp& reference;
1.385 + typedef const _Tp* pointer;
1.386 + typedef _Nonconst_traits<_Tp> _Non_const_traits;
1.387 +};
1.388 +
1.389 +template <class _Tp>
1.390 +struct _Nonconst_traits {
1.391 + typedef _Tp value_type;
1.392 + typedef _Tp& reference;
1.393 + typedef _Tp* pointer;
1.394 + typedef _Nonconst_traits<_Tp> _Non_const_traits;
1.395 +};
1.396 +
1.397 +# if defined (_STLP_BASE_TYPEDEF_BUG)
1.398 +// this workaround is needed for SunPro 4.0.1
1.399 +template <class _Traits>
1.400 +struct __cnst_traits_aux : private _Traits
1.401 +{
1.402 + typedef typename _Traits::value_type value_type;
1.403 +};
1.404 +# define __TRAITS_VALUE_TYPE(_Traits) __cnst_traits_aux<_Traits>::value_type
1.405 +# else
1.406 +# define __TRAITS_VALUE_TYPE(_Traits) _Traits::value_type
1.407 +# endif
1.408 +
1.409 +# if defined (_STLP_MSVC)
1.410 +// MSVC specific
1.411 +template <class _InputIterator, class _Dist>
1.412 +inline void _STLP_CALL _Distance(_InputIterator __first,
1.413 + _InputIterator __last, _Dist& __n) {
1.414 + __distance(__first, __last, __n, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
1.415 +}
1.416 +# endif
1.417 +
1.418 +template <class _InputIter, class _Distance>
1.419 +_STLP_INLINE_LOOP void _STLP_CALL __advance(_InputIter& __i, _Distance __n, const input_iterator_tag &) {
1.420 + while (__n--) ++__i;
1.421 +}
1.422 +
1.423 +// fbp : added output iterator tag variant
1.424 +template <class _InputIter, class _Distance>
1.425 +_STLP_INLINE_LOOP void _STLP_CALL __advance(_InputIter& __i, _Distance __n, const output_iterator_tag &) {
1.426 + while (__n--) ++__i;
1.427 +}
1.428 +
1.429 +# if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
1.430 +template <class _ForwardIterator, class _Distance>
1.431 +_STLP_INLINE_LOOP void _STLP_CALL __advance(_ForwardIterator& i, _Distance n, const forward_iterator_tag &) {
1.432 + while (n--) ++i;
1.433 +}
1.434 +# endif
1.435 +
1.436 +template <class _BidirectionalIterator, class _Distance>
1.437 +_STLP_INLINE_LOOP void _STLP_CALL __advance(_BidirectionalIterator& __i, _Distance __n,
1.438 + const bidirectional_iterator_tag &) {
1.439 + if (__n > 0)
1.440 + while (__n--) ++__i;
1.441 + else
1.442 + while (__n++) --__i;
1.443 +}
1.444 +
1.445 +template <class _RandomAccessIterator, class _Distance>
1.446 +inline void _STLP_CALL __advance(_RandomAccessIterator& __i, _Distance __n,
1.447 + const random_access_iterator_tag &) {
1.448 + __i += __n;
1.449 +}
1.450 +
1.451 +template <class _InputIterator, class _Distance>
1.452 +inline void _STLP_CALL advance(_InputIterator& __i, _Distance __n) {
1.453 + __advance(__i, __n, _STLP_ITERATOR_CATEGORY(__i, _InputIterator));
1.454 +}
1.455 +
1.456 +_STLP_END_NAMESPACE
1.457 +
1.458 +# if defined (_STLP_DEBUG) && ! defined (_STLP_DEBUG_H)
1.459 +# include <stl/debug/_debug.h>
1.460 +# endif
1.461 +
1.462 +#endif /* _STLP_INTERNAL_ITERATOR_BASE_H */
1.463 +
1.464 +
1.465 +// Local Variables:
1.466 +// mode:C++
1.467 +// End: