home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / iterator < prev    next >
Encoding:
Text File  |  1998-06-16  |  8.0 KB  |  280 lines
  1. // iterator standard header
  2.  
  3. #if     _MSC_VER > 1000
  4. #pragma once
  5. #endif
  6.  
  7. #ifndef _ITERATOR_
  8. #define _ITERATOR_
  9. #include <utility>
  10.  
  11. #ifdef  _MSC_VER
  12. #pragma pack(push,8)
  13. #endif  /* _MSC_VER */
  14. _STD_BEGIN
  15.         // TEMPLATE CLASS reverse_bidirectional_iterator
  16. template<class _BI,
  17.     class _Ty,
  18.     class _Rt = _Ty&,
  19.     class _Pt = _Ty *,
  20.     class _D = ptrdiff_t>
  21.     class reverse_bidirectional_iterator
  22.         : public _Bidit<_Ty, _D> {
  23. public:
  24.     typedef reverse_bidirectional_iterator<_BI,
  25.         _Ty, _Rt, _Pt, _D> _Myt;
  26.     typedef _BI iter_type;
  27.     typedef _Rt reference_type;
  28.     typedef _Pt pointer_type;
  29.     reverse_bidirectional_iterator()
  30.         {}
  31.     explicit reverse_bidirectional_iterator(_BI _X)
  32.         : current(_X) {}
  33.     _BI base() const
  34.         {return (current); }
  35.     _Rt operator*() const
  36.         {_BI _Tmp = current;
  37.         return (*--_Tmp); }
  38.     _Pt operator->() const
  39.         {return (&**this); }
  40.     _Myt& operator++()
  41.         {--current;
  42.         return (*this); }
  43.     _Myt operator++(int)
  44.         {_Myt _Tmp = *this;
  45.         --current;
  46.         return (_Tmp); }
  47.     _Myt& operator--()
  48.         {++current;
  49.         return (*this); }
  50.     _Myt operator--(int)
  51.         {_Myt _Tmp = *this;
  52.         ++current;
  53.         return (_Tmp); }
  54. protected:
  55.     _BI current;
  56.     };
  57. template<class _BI, class _Ty, class _Rt, class _Pt,
  58.     class _D> inline
  59.     bool operator==(const reverse_bidirectional_iterator<_BI,
  60.             _Ty, _Rt, _Pt, _D>& _X,
  61.         const reverse_bidirectional_iterator<_BI,
  62.             _Ty, _Rt, _Pt, _D>& _Y)
  63.     {return (_X.base() == _Y.base()); }
  64. template<class _BI, class _Ty, class _Rt, class _Pt,
  65.     class _D> inline
  66.     bool operator!=(const reverse_bidirectional_iterator<_BI,
  67.             _Ty, _Rt, _Pt, _D>& _X,
  68.         const reverse_bidirectional_iterator<_BI,
  69.             _Ty, _Rt, _Pt, _D>& _Y)
  70.     {return (!(_X == _Y)); }
  71.         // TEMPLATE CLASS back_insert_iterator
  72. template<class _C>
  73.     class back_insert_iterator
  74.         : public iterator<output_iterator_tag, void, void> {
  75. public:
  76.     typedef _C container_type;
  77.     typedef _C::value_type value_type;
  78.     explicit back_insert_iterator(_C& _X)
  79.         : container(_X) {}
  80.     back_insert_iterator<_C>& operator=(
  81.         const value_type& _V)
  82.         {container.push_back(_V);
  83.         return (*this); }
  84.     back_insert_iterator<_C>& operator*()
  85.         {return (*this); }
  86.     back_insert_iterator<_C>& operator++()
  87.         {return (*this); }
  88.     back_insert_iterator<_C> operator++(int)
  89.         {return (*this); }
  90. protected:
  91.     _C& container;
  92.     };
  93. template<class _C> inline
  94.     back_insert_iterator<_C> back_inserter(_C& _X)
  95.     {return (back_insert_iterator<_C>(_X)); }
  96.         // TEMPLATE CLASS front_insert_iterator
  97. template<class _C>
  98.     class front_insert_iterator
  99.         : public iterator<output_iterator_tag, void, void> {
  100. public:
  101.     typedef _C container_type;
  102.     typedef _C::value_type value_type;
  103.     explicit front_insert_iterator(_C& _X)
  104.         : container(_X) {}
  105.     front_insert_iterator<_C>& operator=(
  106.         const value_type& _V)
  107.         {container.push_front(_V);
  108.         return (*this); }
  109.     front_insert_iterator<_C>& operator*()
  110.         {return (*this); }
  111.     front_insert_iterator<_C>& operator++()
  112.         {return (*this); }
  113.     front_insert_iterator<_C> operator++(int)
  114.         {return (*this); }
  115. protected:
  116.     _C& container;
  117.     };
  118. template<class _C> inline
  119.     front_insert_iterator<_C> front_inserter(_C& _X)
  120.     {return (front_insert_iterator<_C>(_X)); }
  121.         // TEMPLATE CLASS insert_iterator
  122. template<class _C>
  123.     class insert_iterator
  124.         : public iterator<output_iterator_tag, void, void> {
  125. public:
  126.     typedef _C container_type;
  127.     typedef _C::value_type value_type;
  128.     insert_iterator(_C& _X, _C::iterator _I)
  129.         : container(_X), iter(_I) {}
  130.     insert_iterator<_C>& operator=(
  131.         const value_type& _V)
  132.         {iter = container.insert(iter, _V);
  133.         ++iter;
  134.         return (*this); }
  135.     insert_iterator<_C>& operator*()
  136.         {return (*this); }
  137.     insert_iterator<_C>& operator++()
  138.         {return (*this); }
  139.     insert_iterator<_C>& operator++(int)
  140.         {return (*this); }
  141. protected:
  142.     _C& container;
  143.     _C::iterator iter;
  144.     };
  145. template<class _C, class _XI> inline
  146.     insert_iterator<_C> inserter(_C& _X, _XI _I)
  147.     {return (insert_iterator<_C>(_X, _C::iterator(_I))); }
  148.         // TEMPLATE CLASS istream_iterator
  149. template<class _U, class _E = char,
  150.     class _Tr = char_traits<_E> >
  151.     class istream_iterator
  152.         : public iterator<input_iterator_tag, _U, ptrdiff_t> {
  153. public:
  154.     typedef _E char_type;
  155.     typedef _Tr traits_type;
  156.     typedef basic_istream<_E, _Tr> istream_type;
  157.     istream_iterator()
  158.         : _Istr(0) {}
  159.     istream_iterator(istream_type& _I)
  160.         : _Istr(&_I) {_Getval(); }
  161.     const _U& operator*() const
  162.         {return (_Val); }
  163.     const _U *operator->() const
  164.         {return (&**this); }
  165.     istream_iterator<_U, _E, _Tr>& operator++()
  166.         {_Getval();
  167.         return (*this); }
  168.     istream_iterator<_U, _E, _Tr> operator++(int)
  169.         {istream_iterator<_U, _E, _Tr> _Tmp = *this;
  170.         _Getval();
  171.         return (_Tmp); }
  172.     bool _Equal(const istream_iterator<_U, _E, _Tr>& _X) const
  173.         {return (_Istr == _X._Istr); }
  174. protected:
  175.     void _Getval()
  176.         {if (_Istr != 0 && !(*_Istr >> _Val))
  177.             _Istr = 0; }
  178.     istream_type *_Istr;
  179.     _U _Val;
  180.     };
  181. template<class _U, class _E, class _Tr> inline
  182.     bool operator==(const istream_iterator<_U, _E, _Tr>& _X,
  183.         const istream_iterator<_U, _E, _Tr>& _Y)
  184.     {return (_X._Equal(_Y)); }
  185. template<class _U, class _E, class _Tr> inline
  186.     bool operator!=(const istream_iterator<_U, _E, _Tr>& _X,
  187.         const istream_iterator<_U, _E, _Tr>& _Y)
  188.     {return (!(_X == _Y)); }
  189.         // TEMPLATE CLASS ostream_iterator
  190. template<class _U, class _E = char,
  191.     class _Tr = char_traits<_E> >
  192.     class ostream_iterator
  193.         : public iterator<output_iterator_tag, void, void> {
  194. public:
  195.     typedef _U value_type;
  196.     typedef _E char_type;
  197.     typedef _Tr traits_type;
  198.     typedef basic_ostream<_E, _Tr> ostream_type;
  199.     ostream_iterator(ostream_type& _O,
  200.         const _E *_D = 0)
  201.         : _Ostr(&_O), _Delim(_D) {}
  202.     ostream_iterator<_U, _E, _Tr>& operator=(const _U& _X)
  203.         {*_Ostr << _X;
  204.         if (_Delim != 0)
  205.             *_Ostr << _Delim;
  206.         return (*this); }
  207.     ostream_iterator<_U, _E, _Tr>& operator*()
  208.         {return (*this); }
  209.     ostream_iterator<_U, _E, _Tr>& operator++()
  210.         {return (*this); }
  211.     ostream_iterator<_U, _E, _Tr> operator++(int)
  212.         {return (*this); }
  213. protected:
  214.     const _E *_Delim;
  215.     ostream_type *_Ostr;
  216.     };
  217.         // TEMPLATE FUNCTION _Val_type
  218. template<class _C, class _Ty, class _D> inline
  219.     _Ty *_Val_type(const iterator<_C, _Ty, _D>&)
  220.     {return ((_Ty *)0); }
  221. template<class _Ty> inline
  222.     _Ty *_Val_type(const _Ty *)
  223.     {return ((_Ty *)0); }
  224.         // TEMPLATE FUNCTION advance
  225. template<class _II, class _D> inline
  226.     void advance(_II& _I, _D _N)
  227.     {_Advance(_I, _N, _Iter_cat(_I)); }
  228. template<class _II, class _D> inline
  229.     void _Advance(_II& _I, _D _N, input_iterator_tag)
  230.     {for (; 0 < _N; --_N)
  231.         ++_I; }
  232. template<class _FI, class _D> inline
  233.     void _Advance(_FI& _I, _D _N, forward_iterator_tag)
  234.     {for (; 0 < _N; --_N)
  235.         ++_I; }
  236. template<class _BI, class _D> inline
  237.     void _Advance(_BI& _I, _D _N, bidirectional_iterator_tag)
  238.     {for (; 0 < _N; --_N)
  239.         ++_I;
  240.     for (; _N < 0; ++_N)
  241.         --_I; }
  242. template<class _RI, class _D> inline
  243.     void _Advance(_RI& _I, _D _N, random_access_iterator_tag)
  244.     {_I += _N; }
  245.         // TEMPLATE FUNCTION _Dist_type
  246. template<class _C, class _Ty, class _D> inline
  247.     _D *_Dist_type(const iterator<_C, _Ty, _D>&)
  248.     {return ((_D *)0); }
  249. template<class _Ty> inline
  250.     ptrdiff_t *_Dist_type(const _Ty *)
  251.     {return ((ptrdiff_t *)0); }
  252. _STD_END
  253. #ifdef  _MSC_VER
  254. #pragma pack(pop)
  255. #endif  /* _MSC_VER */
  256.  
  257. #endif /* _ITERATOR_ */
  258.  
  259. /*
  260.  * Copyright (c) 1995 by P.J. Plauger.  ALL RIGHTS RESERVED. 
  261.  * Consult your license regarding permissions and restrictions.
  262.  */
  263.  
  264. /*
  265.  * This file is derived from software bearing the following
  266.  * restrictions:
  267.  *
  268.  * Copyright (c) 1994
  269.  * Hewlett-Packard Company
  270.  *
  271.  * Permission to use, copy, modify, distribute and sell this
  272.  * software and its documentation for any purpose is hereby
  273.  * granted without fee, provided that the above copyright notice
  274.  * appear in all copies and that both that copyright notice and
  275.  * this permission notice appear in supporting documentation.
  276.  * Hewlett-Packard Company makes no representations about the
  277.  * suitability of this software for any purpose. It is provided
  278.  * "as is" without express or implied warranty.
  279.  */
  280.