stl_iterator.h
上传用户:sichengcw
上传日期:2009-02-17
资源大小:202k
文件大小:26k
源码类别:

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,1997
  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_H
  30. #define __SGI_STL_INTERNAL_ITERATOR_H
  31. __STL_BEGIN_NAMESPACE
  32. struct input_iterator_tag {};
  33. struct output_iterator_tag {};
  34. struct forward_iterator_tag : public input_iterator_tag {};
  35. struct bidirectional_iterator_tag : public forward_iterator_tag {};
  36. struct random_access_iterator_tag : public bidirectional_iterator_tag {};
  37. template <class T, class Distance> struct input_iterator {
  38.   typedef input_iterator_tag iterator_category;
  39.   typedef T                  value_type;
  40.   typedef Distance           difference_type;
  41.   typedef T*                 pointer;
  42.   typedef T&                 reference;
  43. };
  44. struct output_iterator {
  45.   typedef output_iterator_tag iterator_category;
  46.   typedef void                value_type;
  47.   typedef void                difference_type;
  48.   typedef void                pointer;
  49.   typedef void                reference;
  50. };
  51. template <class T, class Distance> struct forward_iterator {
  52.   typedef forward_iterator_tag iterator_category;
  53.   typedef T                    value_type;
  54.   typedef Distance             difference_type;
  55.   typedef T*                   pointer;
  56.   typedef T&                   reference;
  57. };
  58. template <class T, class Distance> struct bidirectional_iterator {
  59.   typedef bidirectional_iterator_tag iterator_category;
  60.   typedef T                          value_type;
  61.   typedef Distance                   difference_type;
  62.   typedef T*                         pointer;
  63.   typedef T&                         reference;
  64. };
  65. template <class T, class Distance> struct random_access_iterator {
  66.   typedef random_access_iterator_tag iterator_category;
  67.   typedef T                          value_type;
  68.   typedef Distance                   difference_type;
  69.   typedef T*                         pointer;
  70.   typedef T&                         reference;
  71. };
  72. #ifdef __STL_USE_NAMESPACES
  73. template <class Category, class T, class Distance = ptrdiff_t,
  74.           class Pointer = T*, class Reference = T&>
  75. struct iterator {
  76.   typedef Category  iterator_category;
  77.   typedef T         value_type;
  78.   typedef Distance  difference_type;
  79.   typedef Pointer   pointer;
  80.   typedef Reference reference;
  81. };
  82. #endif /* __STL_USE_NAMESPACES */
  83. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  84. template <class Iterator>
  85. struct iterator_traits {
  86.   typedef typename Iterator::iterator_category iterator_category;
  87.   typedef typename Iterator::value_type        value_type;
  88.   typedef typename Iterator::difference_type   difference_type;
  89.   typedef typename Iterator::pointer           pointer;
  90.   typedef typename Iterator::reference         reference;
  91. };
  92. template <class T>
  93. struct iterator_traits<T*> {
  94.   typedef random_access_iterator_tag iterator_category;
  95.   typedef T                          value_type;
  96.   typedef ptrdiff_t                  difference_type;
  97.   typedef T*                         pointer;
  98.   typedef T&                         reference;
  99. };
  100. template <class T>
  101. struct iterator_traits<const T*> {
  102.   typedef random_access_iterator_tag iterator_category;
  103.   typedef T                          value_type;
  104.   typedef ptrdiff_t                  difference_type;
  105.   typedef const T*                   pointer;
  106.   typedef const T&                   reference;
  107. };
  108. template <class Iterator>
  109. inline typename iterator_traits<Iterator>::iterator_category
  110. iterator_category(const Iterator&) {
  111.   typedef typename iterator_traits<Iterator>::iterator_category category;
  112.   return category();
  113. }
  114. template <class Iterator>
  115. inline typename iterator_traits<Iterator>::difference_type*
  116. distance_type(const Iterator&) {
  117.   return static_cast<typename iterator_traits<Iterator>::difference_type*>(0);
  118. }
  119. template <class Iterator>
  120. inline typename iterator_traits<Iterator>::value_type*
  121. value_type(const Iterator&) {
  122.   return static_cast<typename iterator_traits<Iterator>::value_type*>(0);
  123. }
  124. #else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  125. template <class T, class Distance> 
  126. inline input_iterator_tag 
  127. iterator_category(const input_iterator<T, Distance>&) {
  128.   return input_iterator_tag();
  129. }
  130. inline output_iterator_tag iterator_category(const output_iterator&) {
  131.   return output_iterator_tag();
  132. }
  133. template <class T, class Distance> 
  134. inline forward_iterator_tag
  135. iterator_category(const forward_iterator<T, Distance>&) {
  136.   return forward_iterator_tag();
  137. }
  138. template <class T, class Distance> 
  139. inline bidirectional_iterator_tag
  140. iterator_category(const bidirectional_iterator<T, Distance>&) {
  141.   return bidirectional_iterator_tag();
  142. }
  143. template <class T, class Distance> 
  144. inline random_access_iterator_tag
  145. iterator_category(const random_access_iterator<T, Distance>&) {
  146.   return random_access_iterator_tag();
  147. }
  148. template <class T>
  149. inline random_access_iterator_tag iterator_category(const T*) {
  150.   return random_access_iterator_tag();
  151. }
  152. template <class T, class Distance> 
  153. inline T* value_type(const input_iterator<T, Distance>&) {
  154.   return (T*)(0); 
  155. }
  156. template <class T, class Distance> 
  157. inline T* value_type(const forward_iterator<T, Distance>&) {
  158.   return (T*)(0);
  159. }
  160. template <class T, class Distance> 
  161. inline T* value_type(const bidirectional_iterator<T, Distance>&) {
  162.   return (T*)(0);
  163. }
  164. template <class T, class Distance> 
  165. inline T* value_type(const random_access_iterator<T, Distance>&) {
  166.   return (T*)(0);
  167. }
  168. template <class T>
  169. inline T* value_type(const T*) { return (T*)(0); }
  170. template <class T, class Distance> 
  171. inline Distance* distance_type(const input_iterator<T, Distance>&) {
  172.   return (Distance*)(0);
  173. }
  174. template <class T, class Distance> 
  175. inline Distance* distance_type(const forward_iterator<T, Distance>&) {
  176.   return (Distance*)(0);
  177. }
  178. template <class T, class Distance> 
  179. inline Distance* 
  180. distance_type(const bidirectional_iterator<T, Distance>&) {
  181.   return (Distance*)(0);
  182. }
  183. template <class T, class Distance> 
  184. inline Distance* 
  185. distance_type(const random_access_iterator<T, Distance>&) {
  186.   return (Distance*)(0);
  187. }
  188. template <class T>
  189. inline ptrdiff_t* distance_type(const T*) { return (ptrdiff_t*)(0); }
  190. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  191. template <class InputIterator, class Distance>
  192. inline void __distance(InputIterator first, InputIterator last, Distance& n, 
  193.                        input_iterator_tag) {
  194.   while (first != last) { ++first; ++n; }
  195. }
  196. template <class RandomAccessIterator, class Distance>
  197. inline void __distance(RandomAccessIterator first, RandomAccessIterator last, 
  198.                        Distance& n, random_access_iterator_tag) {
  199.   n += last - first;
  200. }
  201. template <class InputIterator, class Distance>
  202. inline void distance(InputIterator first, InputIterator last, Distance& n) {
  203.   __distance(first, last, n, iterator_category(first));
  204. }
  205. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  206. template <class InputIterator>
  207. inline iterator_traits<InputIterator>::difference_type
  208. __distance(InputIterator first, InputIterator last, input_iterator_tag) {
  209.   iterator_traits<InputIterator>::difference_type n = 0;
  210.   while (first != last) {
  211.     ++first; ++n;
  212.   }
  213.   return n;
  214. }
  215. template <class RandomAccessIterator>
  216. inline iterator_traits<RandomAccessIterator>::difference_type
  217. __distance(RandomAccessIterator first, RandomAccessIterator last,
  218.            random_access_iterator_tag) {
  219.   return last - first;
  220. }
  221. template <class InputIterator>
  222. inline iterator_traits<InputIterator>::difference_type
  223. distance(InputIterator first, InputIterator last) {
  224.   typedef typename iterator_traits<InputIterator>::iterator_category category;
  225.   return __distance(first, last, category());
  226. }
  227. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  228. template <class InputIterator, class Distance>
  229. inline void __advance(InputIterator& i, Distance n, input_iterator_tag) {
  230.   while (n--) ++i;
  231. }
  232. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  233. #pragma set woff 1183
  234. #endif
  235. template <class BidirectionalIterator, class Distance>
  236. inline void __advance(BidirectionalIterator& i, Distance n, 
  237.                       bidirectional_iterator_tag) {
  238.   if (n >= 0)
  239.     while (n--) ++i;
  240.   else
  241.     while (n++) --i;
  242. }
  243. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  244. #pragma reset woff 1183
  245. #endif
  246. template <class RandomAccessIterator, class Distance>
  247. inline void __advance(RandomAccessIterator& i, Distance n, 
  248.                       random_access_iterator_tag) {
  249.   i += n;
  250. }
  251. template <class InputIterator, class Distance>
  252. inline void advance(InputIterator& i, Distance n) {
  253.   __advance(i, n, iterator_category(i));
  254. }
  255. template <class Container>
  256. class back_insert_iterator {
  257. protected:
  258.   Container* container;
  259. public:
  260.   typedef output_iterator_tag iterator_category;
  261.   typedef void                value_type;
  262.   typedef void                difference_type;
  263.   typedef void                pointer;
  264.   typedef void                reference;
  265.   explicit back_insert_iterator(Container& x) : container(&x) {}
  266.   back_insert_iterator<Container>&
  267.   operator=(const typename Container::value_type& value) { 
  268.     container->push_back(value);
  269.     return *this;
  270.   }
  271.   back_insert_iterator<Container>& operator*() { return *this; }
  272.   back_insert_iterator<Container>& operator++() { return *this; }
  273.   back_insert_iterator<Container>& operator++(int) { return *this; }
  274. };
  275. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  276. template <class Container>
  277. inline output_iterator_tag
  278. iterator_category(const back_insert_iterator<Container>&)
  279. {
  280.   return output_iterator_tag();
  281. }
  282. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  283. template <class Container>
  284. inline back_insert_iterator<Container> back_inserter(Container& x) {
  285.   return back_insert_iterator<Container>(x);
  286. }
  287. template <class Container>
  288. class front_insert_iterator {
  289. protected:
  290.   Container* container;
  291. public:
  292.   typedef output_iterator_tag iterator_category;
  293.   typedef void                value_type;
  294.   typedef void                difference_type;
  295.   typedef void                pointer;
  296.   typedef void                reference;
  297.   explicit front_insert_iterator(Container& x) : container(&x) {}
  298.   front_insert_iterator<Container>&
  299.   operator=(const typename Container::value_type& value) { 
  300.     container->push_front(value);
  301.     return *this;
  302.   }
  303.   front_insert_iterator<Container>& operator*() { return *this; }
  304.   front_insert_iterator<Container>& operator++() { return *this; }
  305.   front_insert_iterator<Container>& operator++(int) { return *this; }
  306. };
  307. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  308. template <class Container>
  309. inline output_iterator_tag
  310. iterator_category(const front_insert_iterator<Container>&)
  311. {
  312.   return output_iterator_tag();
  313. }
  314. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  315. template <class Container>
  316. inline front_insert_iterator<Container> front_inserter(Container& x) {
  317.   return front_insert_iterator<Container>(x);
  318. }
  319. template <class Container>
  320. class insert_iterator {
  321. protected:
  322.   Container* container;
  323.   typename Container::iterator iter;
  324. public:
  325.   typedef output_iterator_tag iterator_category;
  326.   typedef void                value_type;
  327.   typedef void                difference_type;
  328.   typedef void                pointer;
  329.   typedef void                reference;
  330.   insert_iterator(Container& x, typename Container::iterator i) 
  331.     : container(&x), iter(i) {}
  332.   insert_iterator<Container>&
  333.   operator=(const typename Container::value_type& value) { 
  334.     iter = container->insert(iter, value);
  335.     ++iter;
  336.     return *this;
  337.   }
  338.   insert_iterator<Container>& operator*() { return *this; }
  339.   insert_iterator<Container>& operator++() { return *this; }
  340.   insert_iterator<Container>& operator++(int) { return *this; }
  341. };
  342. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  343. template <class Container>
  344. inline output_iterator_tag
  345. iterator_category(const insert_iterator<Container>&)
  346. {
  347.   return output_iterator_tag();
  348. }
  349. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  350. template <class Container, class Iterator>
  351. inline insert_iterator<Container> inserter(Container& x, Iterator i) {
  352.   typedef typename Container::iterator iter;
  353.   return insert_iterator<Container>(x, iter(i));
  354. }
  355. #ifndef __STL_LIMITED_DEFAULT_TEMPLATES
  356. template <class BidirectionalIterator, class T, class Reference = T&, 
  357.           class Distance = ptrdiff_t> 
  358. #else
  359. template <class BidirectionalIterator, class T, class Reference, 
  360.           class Distance> 
  361. #endif
  362. class reverse_bidirectional_iterator {
  363.   typedef reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  364.                                          Distance> self;
  365. protected:
  366.   BidirectionalIterator current;
  367. public:
  368.   typedef bidirectional_iterator_tag iterator_category;
  369.   typedef T                          value_type;
  370.   typedef Distance                   difference_type;
  371.   typedef T*                         pointer;
  372.   typedef Reference                  reference;
  373.   reverse_bidirectional_iterator() {}
  374.   explicit reverse_bidirectional_iterator(BidirectionalIterator x)
  375.     : current(x) {}
  376.   BidirectionalIterator base() const { return current; }
  377.   Reference operator*() const {
  378.     BidirectionalIterator tmp = current;
  379.     return *--tmp;
  380.   }
  381. #ifndef __SGI_STL_NO_ARROW_OPERATOR
  382.   pointer operator->() const { return &(operator*()); }
  383. #endif /* __SGI_STL_NO_ARROW_OPERATOR */
  384.   self& operator++() {
  385.     --current;
  386.     return *this;
  387.   }
  388.   self operator++(int) {
  389.     self tmp = *this;
  390.     --current;
  391.     return tmp;
  392.   }
  393.   self& operator--() {
  394.     ++current;
  395.     return *this;
  396.   }
  397.   self operator--(int) {
  398.     self tmp = *this;
  399.     ++current;
  400.     return tmp;
  401.   }
  402. };
  403. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  404. template <class BidirectionalIterator, class T, class Reference, 
  405.           class Distance>
  406. inline bidirectional_iterator_tag
  407. iterator_category(const reverse_bidirectional_iterator<BidirectionalIterator,
  408.                                                        T,
  409.                                                        Reference, Distance>&) {
  410.   return bidirectional_iterator_tag();
  411. }
  412. template <class BidirectionalIterator, class T, class Reference, 
  413.           class Distance>
  414. inline T*
  415. value_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
  416.                                                Reference, Distance>&) {
  417.   return (T*) 0;
  418. }
  419. template <class BidirectionalIterator, class T, class Reference, 
  420.           class Distance>
  421. inline Distance*
  422. distance_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
  423.                                                   Reference, Distance>&) {
  424.   return (Distance*) 0;
  425. }
  426. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  427. template <class BidirectionalIterator, class T, class Reference,
  428.           class Distance>
  429. inline bool operator==(
  430.     const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  431.                                          Distance>& x, 
  432.     const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  433.                                          Distance>& y) {
  434.   return x.base() == y.base();
  435. }
  436. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  437. // This is the new version of reverse_iterator, as defined in the
  438. //  draft C++ standard.  It relies on the iterator_traits template,
  439. //  which in turn relies on partial specialization.  The class
  440. //  reverse_bidirectional_iterator is no longer part of the draft
  441. //  standard, but it is retained for backward compatibility.
  442. template <class Iterator>
  443. class reverse_iterator 
  444. {
  445. protected:
  446.   Iterator current;
  447. public:
  448.   typedef typename iterator_traits<Iterator>::iterator_category
  449.           iterator_category;
  450.   typedef typename iterator_traits<Iterator>::value_type
  451.           value_type;
  452.   typedef typename iterator_traits<Iterator>::difference_type
  453.           difference_type;
  454.   typedef typename iterator_traits<Iterator>::pointer
  455.           pointer;
  456.   typedef typename iterator_traits<Iterator>::reference
  457.           reference;
  458.   typedef Iterator iterator_type;
  459.   typedef reverse_iterator<Iterator> self;
  460. public:
  461.   reverse_iterator() {}
  462.   explicit reverse_iterator(iterator_type x) : current(x) {}
  463.   reverse_iterator(const self& x) : current(x.current) {}
  464. #ifdef __STL_MEMBER_TEMPLATES
  465.   template <class Iter>
  466.   reverse_iterator(const reverse_iterator<Iter>& x) : current(x.current) {}
  467. #endif /* __STL_MEMBER_TEMPLATES */
  468.     
  469.   iterator_type base() const { return current; }
  470.   reference operator*() const {
  471.     Iterator tmp = current;
  472.     return *--tmp;
  473.   }
  474. #ifndef __SGI_STL_NO_ARROW_OPERATOR
  475.   pointer operator->() const { return &(operator*()); }
  476. #endif /* __SGI_STL_NO_ARROW_OPERATOR */
  477.   self& operator++() {
  478.     --current;
  479.     return *this;
  480.   }
  481.   self operator++(int) {
  482.     self tmp = *this;
  483.     --current;
  484.     return tmp;
  485.   }
  486.   self& operator--() {
  487.     ++current;
  488.     return *this;
  489.   }
  490.   self operator--(int) {
  491.     self tmp = *this;
  492.     ++current;
  493.     return tmp;
  494.   }
  495.   self operator+(difference_type n) const {
  496.     return self(current - n);
  497.   }
  498.   self& operator+=(difference_type n) {
  499.     current -= n;
  500.     return *this;
  501.   }
  502.   self operator-(difference_type n) const {
  503.     return self(current + n);
  504.   }
  505.   self& operator-=(difference_type n) {
  506.     current += n;
  507.     return *this;
  508.   }
  509.   reference operator[](difference_type n) const { return *(*this + n); }  
  510. }; 
  511.  
  512. template <class Iterator>
  513. inline bool operator==(const reverse_iterator<Iterator>& x, 
  514.                        const reverse_iterator<Iterator>& y) {
  515.   return x.base() == y.base();
  516. }
  517. template <class Iterator>
  518. inline bool operator<(const reverse_iterator<Iterator>& x, 
  519.                       const reverse_iterator<Iterator>& y) {
  520.   return y.base() < x.base();
  521. }
  522. template <class Iterator>
  523. inline typename reverse_iterator<Iterator>::difference_type
  524. operator-(const reverse_iterator<Iterator>& x, 
  525.           const reverse_iterator<Iterator>& y) {
  526.   return y.base() - x.base();
  527. }
  528. template <class Iterator>
  529. inline reverse_iterator<Iterator> 
  530. operator+(reverse_iterator<Iterator>::difference_type n,
  531.           const reverse_iterator<Iterator>& x) {
  532.   return reverse_iterator<Iterator>(x.base() - n);
  533. }
  534. #else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  535. // This is the old version of reverse_iterator, as found in the original
  536. //  HP STL.  It does not use partial specialization.
  537. #ifndef __STL_LIMITED_DEFAULT_TEMPLATES
  538. template <class RandomAccessIterator, class T, class Reference = T&,
  539.           class Distance = ptrdiff_t> 
  540. #else
  541. template <class RandomAccessIterator, class T, class Reference,
  542.           class Distance> 
  543. #endif
  544. class reverse_iterator {
  545.   typedef reverse_iterator<RandomAccessIterator, T, Reference, Distance>
  546.         self;
  547. protected:
  548.   RandomAccessIterator current;
  549. public:
  550.   typedef random_access_iterator_tag iterator_category;
  551.   typedef T                          value_type;
  552.   typedef Distance                   difference_type;
  553.   typedef T*                         pointer;
  554.   typedef Reference                  reference;
  555.   reverse_iterator() {}
  556.   explicit reverse_iterator(RandomAccessIterator x) : current(x) {}
  557.   RandomAccessIterator base() const { return current; }
  558.   Reference operator*() const { return *(current - 1); }
  559. #ifndef __SGI_STL_NO_ARROW_OPERATOR
  560.   pointer operator->() const { return &(operator*()); }
  561. #endif /* __SGI_STL_NO_ARROW_OPERATOR */
  562.   self& operator++() {
  563.     --current;
  564.     return *this;
  565.   }
  566.   self operator++(int) {
  567.     self tmp = *this;
  568.     --current;
  569.     return tmp;
  570.   }
  571.   self& operator--() {
  572.     ++current;
  573.     return *this;
  574.   }
  575.   self operator--(int) {
  576.     self tmp = *this;
  577.     ++current;
  578.     return tmp;
  579.   }
  580.   self operator+(Distance n) const {
  581.     return self(current - n);
  582.   }
  583.   self& operator+=(Distance n) {
  584.     current -= n;
  585.     return *this;
  586.   }
  587.   self operator-(Distance n) const {
  588.     return self(current + n);
  589.   }
  590.   self& operator-=(Distance n) {
  591.     current += n;
  592.     return *this;
  593.   }
  594.   Reference operator[](Distance n) const { return *(*this + n); }
  595. };
  596. template <class RandomAccessIterator, class T, class Reference, class Distance>
  597. inline random_access_iterator_tag
  598. iterator_category(const reverse_iterator<RandomAccessIterator, T,
  599.                                          Reference, Distance>&) {
  600.   return random_access_iterator_tag();
  601. }
  602. template <class RandomAccessIterator, class T, class Reference, class Distance>
  603. inline T* value_type(const reverse_iterator<RandomAccessIterator, T,
  604.                                             Reference, Distance>&) {
  605.   return (T*) 0;
  606. }
  607. template <class RandomAccessIterator, class T, class Reference, class Distance>
  608. inline Distance* distance_type(const reverse_iterator<RandomAccessIterator, T,
  609.                                                       Reference, Distance>&) {
  610.   return (Distance*) 0;
  611. }
  612. template <class RandomAccessIterator, class T, class Reference, class Distance>
  613. inline bool operator==(const reverse_iterator<RandomAccessIterator, T,
  614.                                               Reference, Distance>& x, 
  615.                        const reverse_iterator<RandomAccessIterator, T,
  616.                                               Reference, Distance>& y) {
  617.   return x.base() == y.base();
  618. }
  619. template <class RandomAccessIterator, class T, class Reference, class Distance>
  620. inline bool operator<(const reverse_iterator<RandomAccessIterator, T,
  621.                                              Reference, Distance>& x, 
  622.                       const reverse_iterator<RandomAccessIterator, T,
  623.                                              Reference, Distance>& y) {
  624.   return y.base() < x.base();
  625. }
  626. template <class RandomAccessIterator, class T, class Reference, class Distance>
  627. inline Distance operator-(const reverse_iterator<RandomAccessIterator, T,
  628.                                                  Reference, Distance>& x, 
  629.                           const reverse_iterator<RandomAccessIterator, T,
  630.                                                  Reference, Distance>& y) {
  631.   return y.base() - x.base();
  632. }
  633. template <class RandomAccessIter, class T, class Ref, class Dist>
  634. inline reverse_iterator<RandomAccessIter, T, Ref, Dist> 
  635. operator+(Dist n, const reverse_iterator<RandomAccessIter, T, Ref, Dist>& x) {
  636.   return reverse_iterator<RandomAccessIter, T, Ref, Dist>(x.base() - n);
  637. }
  638. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  639. template <class T, class Distance = ptrdiff_t> 
  640. class istream_iterator {
  641.   friend bool
  642.   operator== __STL_NULL_TMPL_ARGS (const istream_iterator<T, Distance>& x,
  643.                                    const istream_iterator<T, Distance>& y);
  644. protected:
  645.   istream* stream;
  646.   T value;
  647.   bool end_marker;
  648.   void read() {
  649.     end_marker = (*stream) ? true : false;
  650.     if (end_marker) *stream >> value;
  651.     end_marker = (*stream) ? true : false;
  652.   }
  653. public:
  654.   typedef input_iterator_tag iterator_category;
  655.   typedef T                  value_type;
  656.   typedef Distance           difference_type;
  657.   typedef const T*           pointer;
  658.   typedef const T&           reference;
  659.   istream_iterator() : stream(&cin), end_marker(false) {}
  660.   istream_iterator(istream& s) : stream(&s) { read(); }
  661.   reference operator*() const { return value; }
  662. #ifndef __SGI_STL_NO_ARROW_OPERATOR
  663.   pointer operator->() const { return &(operator*()); }
  664. #endif /* __SGI_STL_NO_ARROW_OPERATOR */
  665.   istream_iterator<T, Distance>& operator++() { 
  666.     read(); 
  667.     return *this;
  668.   }
  669.   istream_iterator<T, Distance> operator++(int)  {
  670.     istream_iterator<T, Distance> tmp = *this;
  671.     read();
  672.     return tmp;
  673.   }
  674. };
  675. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  676. template <class T, class Distance>
  677. inline input_iterator_tag 
  678. iterator_category(const istream_iterator<T, Distance>&) {
  679.   return input_iterator_tag();
  680. }
  681. template <class T, class Distance>
  682. inline T* value_type(const istream_iterator<T, Distance>&) { return (T*) 0; }
  683. template <class T, class Distance>
  684. inline Distance* distance_type(const istream_iterator<T, Distance>&) {
  685.   return (Distance*) 0;
  686. }
  687. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  688. template <class T, class Distance>
  689. inline bool operator==(const istream_iterator<T, Distance>& x,
  690.                        const istream_iterator<T, Distance>& y) {
  691.   return x.stream == y.stream && x.end_marker == y.end_marker ||
  692.          x.end_marker == false && y.end_marker == false;
  693. }
  694. template <class T>
  695. class ostream_iterator {
  696. protected:
  697.   ostream* stream;
  698.   const char* string;
  699. public:
  700.   typedef output_iterator_tag iterator_category;
  701.   typedef void                value_type;
  702.   typedef void                difference_type;
  703.   typedef void                pointer;
  704.   typedef void                reference;
  705.   ostream_iterator(ostream& s) : stream(&s), string(0) {}
  706.   ostream_iterator(ostream& s, const char* c) : stream(&s), string(c)  {}
  707.   ostream_iterator<T>& operator=(const T& value) { 
  708.     *stream << value;
  709.     if (string) *stream << string;
  710.     return *this;
  711.   }
  712.   ostream_iterator<T>& operator*() { return *this; }
  713.   ostream_iterator<T>& operator++() { return *this; } 
  714.   ostream_iterator<T>& operator++(int) { return *this; } 
  715. };
  716. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  717. template <class T>
  718. inline output_iterator_tag 
  719. iterator_category(const ostream_iterator<T>&) {
  720.   return output_iterator_tag();
  721. }
  722. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  723. __STL_END_NAMESPACE
  724. #endif /* __SGI_STL_INTERNAL_ITERATOR_H */
  725. // Local Variables:
  726. // mode:C++
  727. // End: