stl_ite1.h
上传用户:nizebo
上传日期:2022-05-14
资源大小:882k
文件大小:12k
源码类别:

STL

开发平台:

Visual C++

  1. /*
  2.  *
  3.  * Copyright (c) 1994
  4.  * Hewlett-Packard Company
  5.  *
  6.  * Permission to use, copy, modify, distribute and sell this software
  7.  * and its documentation for any purpose is hereby granted without fee,
  8.  * provided that the above copyright notice appear in all copies and
  9.  * that both that copyright notice and this permission notice appear
  10.  * in supporting documentation.  Hewlett-Packard Company makes no
  11.  * representations about the suitability of this software for any
  12.  * purpose.  It is provided "as is" without express or implied warranty.
  13.  *
  14.  *
  15.  * Copyright (c) 1996-1998
  16.  * Silicon Graphics Computer Systems, Inc.
  17.  *
  18.  * Permission to use, copy, modify, distribute and sell this software
  19.  * and its documentation for any purpose is hereby granted without fee,
  20.  * provided that the above copyright notice appear in all copies and
  21.  * that both that copyright notice and this permission notice appear
  22.  * in supporting documentation.  Silicon Graphics makes no
  23.  * representations about the suitability of this software for any
  24.  * purpose.  It is provided "as is" without express or implied warranty.
  25.  */
  26. /* NOTE: This is an internal header file, included by other STL headers.
  27.  *   You should not attempt to use it directly.
  28.  */
  29. #ifndef __SGI_STL_INTERNAL_ITERATOR_BASE_H
  30. #define __SGI_STL_INTERNAL_ITERATOR_BASE_H
  31. // This file contains all of the general iterator-related utilities.
  32. // The internal file stl_iterator.h contains predefined iterators, 
  33. // such as front_insert_iterator and istream_iterator.
  34. #include <concept_checks.h>
  35. __STL_BEGIN_NAMESPACE
  36. struct input_iterator_tag {};
  37. struct output_iterator_tag {};
  38. struct forward_iterator_tag : public input_iterator_tag {};
  39. struct bidirectional_iterator_tag : public forward_iterator_tag {};
  40. struct random_access_iterator_tag : public bidirectional_iterator_tag {};
  41. // The base classes input_iterator, output_iterator, forward_iterator,
  42. // bidirectional_iterator, and random_access_iterator are not part of
  43. // the C++ standard.  (They have been replaced by struct iterator.)
  44. // They are included for backward compatibility with the HP STL.
  45. template <class _Tp, class _Distance> struct input_iterator {
  46.   typedef input_iterator_tag iterator_category;
  47.   typedef _Tp                value_type;
  48.   typedef _Distance          difference_type;
  49.   typedef _Tp*               pointer;
  50.   typedef _Tp&               reference;
  51. };
  52. struct output_iterator {
  53.   typedef output_iterator_tag iterator_category;
  54.   typedef void                value_type;
  55.   typedef void                difference_type;
  56.   typedef void                pointer;
  57.   typedef void                reference;
  58. };
  59. template <class _Tp, class _Distance> struct forward_iterator {
  60.   typedef forward_iterator_tag iterator_category;
  61.   typedef _Tp                  value_type;
  62.   typedef _Distance            difference_type;
  63.   typedef _Tp*                 pointer;
  64.   typedef _Tp&                 reference;
  65. };
  66. template <class _Tp, class _Distance> struct bidirectional_iterator {
  67.   typedef bidirectional_iterator_tag iterator_category;
  68.   typedef _Tp                        value_type;
  69.   typedef _Distance                  difference_type;
  70.   typedef _Tp*                       pointer;
  71.   typedef _Tp&                       reference;
  72. };
  73. template <class _Tp, class _Distance> struct random_access_iterator {
  74.   typedef random_access_iterator_tag iterator_category;
  75.   typedef _Tp                        value_type;
  76.   typedef _Distance                  difference_type;
  77.   typedef _Tp*                       pointer;
  78.   typedef _Tp&                       reference;
  79. };
  80. #ifdef __STL_USE_NAMESPACES
  81. template <class _Category, class _Tp, class _Distance = ptrdiff_t,
  82.           class _Pointer = _Tp*, class _Reference = _Tp&>
  83. struct iterator {
  84.   typedef _Category  iterator_category;
  85.   typedef _Tp        value_type;
  86.   typedef _Distance  difference_type;
  87.   typedef _Pointer   pointer;
  88.   typedef _Reference reference;
  89. };
  90. #endif /* __STL_USE_NAMESPACES */
  91. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  92. template <class _Iterator>
  93. struct iterator_traits {
  94.   typedef typename _Iterator::iterator_category iterator_category;
  95.   typedef typename _Iterator::value_type        value_type;
  96.   typedef typename _Iterator::difference_type   difference_type;
  97.   typedef typename _Iterator::pointer           pointer;
  98.   typedef typename _Iterator::reference         reference;
  99. };
  100. template <class _Tp>
  101. struct iterator_traits<_Tp*> {
  102.   typedef random_access_iterator_tag iterator_category;
  103.   typedef _Tp                         value_type;
  104.   typedef ptrdiff_t                   difference_type;
  105.   typedef _Tp*                        pointer;
  106.   typedef _Tp&                        reference;
  107. };
  108. template <class _Tp>
  109. struct iterator_traits<const _Tp*> {
  110.   typedef random_access_iterator_tag iterator_category;
  111.   typedef _Tp                         value_type;
  112.   typedef ptrdiff_t                   difference_type;
  113.   typedef const _Tp*                  pointer;
  114.   typedef const _Tp&                  reference;
  115. };
  116. // The overloaded functions iterator_category, distance_type, and
  117. // value_type are not part of the C++ standard.  (They have been
  118. // replaced by struct iterator_traits.)  They are included for
  119. // backward compatibility with the HP STL.
  120. // We introduce internal names for these functions.
  121. template <class _Iter>
  122. inline typename iterator_traits<_Iter>::iterator_category
  123. __iterator_category(const _Iter&)
  124. {
  125.   typedef typename iterator_traits<_Iter>::iterator_category _Category;
  126.   return _Category();
  127. }
  128. template <class _Iter>
  129. inline typename iterator_traits<_Iter>::difference_type*
  130. __distance_type(const _Iter&)
  131. {
  132.   return static_cast<typename iterator_traits<_Iter>::difference_type*>(0);
  133. }
  134. template <class _Iter>
  135. inline typename iterator_traits<_Iter>::value_type*
  136. __value_type(const _Iter&)
  137. {
  138.   return static_cast<typename iterator_traits<_Iter>::value_type*>(0);
  139. }
  140. template <class _Iter>
  141. inline typename iterator_traits<_Iter>::iterator_category
  142. iterator_category(const _Iter& __i) { return __iterator_category(__i); }
  143. template <class _Iter>
  144. inline typename iterator_traits<_Iter>::difference_type*
  145. distance_type(const _Iter& __i) { return __distance_type(__i); }
  146. template <class _Iter>
  147. inline typename iterator_traits<_Iter>::value_type*
  148. value_type(const _Iter& __i) { return __value_type(__i); }
  149. #define __ITERATOR_CATEGORY(__i) __iterator_category(__i)
  150. #define __DISTANCE_TYPE(__i)     __distance_type(__i)
  151. #define __VALUE_TYPE(__i)        __value_type(__i)
  152. #else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  153. template <class _Tp, class _Distance> 
  154. inline input_iterator_tag 
  155. iterator_category(const input_iterator<_Tp, _Distance>&)
  156.   { return input_iterator_tag(); }
  157. inline output_iterator_tag iterator_category(const output_iterator&)
  158.   { return output_iterator_tag(); }
  159. template <class _Tp, class _Distance> 
  160. inline forward_iterator_tag
  161. iterator_category(const forward_iterator<_Tp, _Distance>&)
  162.   { return forward_iterator_tag(); }
  163. template <class _Tp, class _Distance> 
  164. inline bidirectional_iterator_tag
  165. iterator_category(const bidirectional_iterator<_Tp, _Distance>&)
  166.   { return bidirectional_iterator_tag(); }
  167. template <class _Tp, class _Distance> 
  168. inline random_access_iterator_tag
  169. iterator_category(const random_access_iterator<_Tp, _Distance>&)
  170.   { return random_access_iterator_tag(); }
  171. template <class _Tp>
  172. inline random_access_iterator_tag iterator_category(const _Tp*)
  173.   { return random_access_iterator_tag(); }
  174. template <class _Tp, class _Distance> 
  175. inline _Tp* value_type(const input_iterator<_Tp, _Distance>&)
  176.   { return (_Tp*)(0); }
  177. template <class _Tp, class _Distance> 
  178. inline _Tp* value_type(const forward_iterator<_Tp, _Distance>&)
  179.   { return (_Tp*)(0); }
  180. template <class _Tp, class _Distance> 
  181. inline _Tp* value_type(const bidirectional_iterator<_Tp, _Distance>&)
  182.   { return (_Tp*)(0); }
  183. template <class _Tp, class _Distance> 
  184. inline _Tp* value_type(const random_access_iterator<_Tp, _Distance>&)
  185.   { return (_Tp*)(0); }
  186. template <class _Tp>
  187. inline _Tp* value_type(const _Tp*) { return (_Tp*)(0); }
  188. template <class _Tp, class _Distance> 
  189. inline _Distance* distance_type(const input_iterator<_Tp, _Distance>&)
  190. {
  191.   return (_Distance*)(0);
  192. }
  193. template <class _Tp, class _Distance> 
  194. inline _Distance* distance_type(const forward_iterator<_Tp, _Distance>&)
  195. {
  196.   return (_Distance*)(0);
  197. }
  198. template <class _Tp, class _Distance> 
  199. inline _Distance* 
  200. distance_type(const bidirectional_iterator<_Tp, _Distance>&)
  201. {
  202.   return (_Distance*)(0);
  203. }
  204. template <class _Tp, class _Distance> 
  205. inline _Distance* 
  206. distance_type(const random_access_iterator<_Tp, _Distance>&)
  207. {
  208.   return (_Distance*)(0);
  209. }
  210. template <class _Tp>
  211. inline ptrdiff_t* distance_type(const _Tp*) { return (ptrdiff_t*)(0); }
  212. // Without partial specialization we can't use iterator_traits, so
  213. // we must keep the old iterator query functions around.  
  214. #define __ITERATOR_CATEGORY(__i) iterator_category(__i)
  215. #define __DISTANCE_TYPE(__i)     distance_type(__i)
  216. #define __VALUE_TYPE(__i)        value_type(__i)
  217. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  218. template <class _InputIterator, class _Distance>
  219. inline void __distance(_InputIterator __first, _InputIterator __last,
  220.                        _Distance& __n, input_iterator_tag)
  221. {
  222.   while (__first != __last) { ++__first; ++__n; }
  223. }
  224. template <class _RandomAccessIterator, class _Distance>
  225. inline void __distance(_RandomAccessIterator __first, 
  226.                        _RandomAccessIterator __last, 
  227.                        _Distance& __n, random_access_iterator_tag)
  228. {
  229.   __STL_REQUIRES(_RandomAccessIterator, _RandomAccessIterator);
  230.   __n += __last - __first;
  231. }
  232. template <class _InputIterator, class _Distance>
  233. inline void distance(_InputIterator __first, 
  234.                      _InputIterator __last, _Distance& __n)
  235. {
  236.   __STL_REQUIRES(_InputIterator, _InputIterator);
  237.   __distance(__first, __last, __n, iterator_category(__first));
  238. }
  239. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  240. template <class _InputIterator>
  241. inline typename iterator_traits<_InputIterator>::difference_type
  242. __distance(_InputIterator __first, _InputIterator __last, input_iterator_tag)
  243. {
  244.   typename iterator_traits<_InputIterator>::difference_type __n = 0;
  245.   while (__first != __last) {
  246.     ++__first; ++__n;
  247.   }
  248.   return __n;
  249. }
  250. template <class _RandomAccessIterator>
  251. inline typename iterator_traits<_RandomAccessIterator>::difference_type
  252. __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
  253.            random_access_iterator_tag) {
  254.   __STL_REQUIRES(_RandomAccessIterator, _RandomAccessIterator);
  255.   return __last - __first;
  256. }
  257. template <class _InputIterator>
  258. inline typename iterator_traits<_InputIterator>::difference_type
  259. distance(_InputIterator __first, _InputIterator __last) {
  260.   typedef typename iterator_traits<_InputIterator>::iterator_category 
  261.     _Category;
  262.   __STL_REQUIRES(_InputIterator, _InputIterator);
  263.   return __distance(__first, __last, _Category());
  264. }
  265. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  266. template <class _InputIter, class _Distance>
  267. inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag) {
  268.   while (__n--) ++__i;
  269. }
  270. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  271. #pragma set woff 1183
  272. #endif
  273. template <class _BidirectionalIterator, class _Distance>
  274. inline void __advance(_BidirectionalIterator& __i, _Distance __n, 
  275.                       bidirectional_iterator_tag) {
  276.   __STL_REQUIRES(_BidirectionalIterator, _BidirectionalIterator);
  277.   if (__n >= 0)
  278.     while (__n--) ++__i;
  279.   else
  280.     while (__n++) --__i;
  281. }
  282. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  283. #pragma reset woff 1183
  284. #endif
  285. template <class _RandomAccessIterator, class _Distance>
  286. inline void __advance(_RandomAccessIterator& __i, _Distance __n, 
  287.                       random_access_iterator_tag) {
  288.   __STL_REQUIRES(_RandomAccessIterator, _RandomAccessIterator);
  289.   __i += __n;
  290. }
  291. template <class _InputIterator, class _Distance>
  292. inline void advance(_InputIterator& __i, _Distance __n) {
  293.   __STL_REQUIRES(_InputIterator, _InputIterator);
  294.   __advance(__i, __n, iterator_category(__i));
  295. }
  296. __STL_END_NAMESPACE
  297. #endif /* __SGI_STL_INTERNAL_ITERATOR_BASE_H */
  298. // Local Variables:
  299. // mode:C++
  300. // End: