home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / set < prev    next >
Encoding:
Text File  |  1998-06-16  |  10.1 KB  |  314 lines
  1. // set standard header
  2.  
  3. #if     _MSC_VER > 1000
  4. #pragma once
  5. #endif
  6.  
  7. #ifndef _SET_
  8. #define _SET_
  9. #include <functional>
  10. #include <xtree>
  11.  
  12. #ifdef  _MSC_VER
  13. #pragma pack(push,8)
  14. #endif  /* _MSC_VER */
  15.  
  16. _STD_BEGIN
  17.         // TEMPLATE CLASS set
  18. template<class _K, class _Pr = less<_K>,
  19.     class _A = allocator<_K> >
  20.     class set {
  21. public:
  22.     typedef set<_K, _Pr, _A> _Myt;
  23.     typedef _K value_type;
  24.     struct _Kfn : public unary_function<value_type, _K> {
  25.         const _K& operator()(const value_type& _X) const
  26.         {return (_X); }
  27.         };
  28.     typedef _Pr value_compare;
  29.     typedef _K key_type;
  30.     typedef _Pr key_compare;
  31.     typedef _A allocator_type;
  32.     typedef _Tree<_K, value_type, _Kfn, _Pr, _A> _Imp;
  33.     typedef _Imp::size_type size_type;
  34.     typedef _Imp::difference_type difference_type;
  35.     typedef _Imp::reference reference;
  36.     typedef _Imp::const_reference const_reference;
  37.     typedef _Imp::iterator iterator;
  38.     typedef _Imp::const_iterator const_iterator;
  39.     typedef _Imp::reverse_iterator reverse_iterator;
  40.     typedef _Imp::const_reverse_iterator const_reverse_iterator;
  41.     typedef pair<iterator, bool> _Pairib;
  42.     typedef pair<iterator, iterator> _Pairii;
  43.     typedef pair<const_iterator, const_iterator> _Paircc;
  44.     explicit set(const _Pr& _Pred = _Pr(), const _A& _Al = _A())
  45.         : _Tr(_Pred, false, _Al) {}
  46.     typedef const value_type *_It;
  47.     set(_It _F, _It _L, const _Pr& _Pred = _Pr(),
  48.         const _A& _Al = _A())
  49.         : _Tr(_Pred, false, _Al)
  50.         {for (; _F != _L; ++_F)
  51.             _Tr.insert(*_F); }
  52.     _Myt& operator=(const _Myt& _X)
  53.         {_Tr = _X._Tr;
  54.         return (*this); }
  55.     iterator begin()
  56.         {return (_Tr.begin()); }
  57.     const_iterator begin() const
  58.         {return (_Tr.begin()); }
  59.     iterator end()
  60.         {return (_Tr.end()); }
  61.     const_iterator end() const
  62.         {return (_Tr.end()); }
  63.     reverse_iterator rbegin()
  64.         {return (_Tr.rbegin()); }
  65.     const_reverse_iterator rbegin() const
  66.         {return (_Tr.rbegin()); }
  67.     reverse_iterator rend()
  68.         {return (_Tr.rend()); }
  69.     const_reverse_iterator rend() const
  70.         {return (_Tr.rend()); }
  71.     size_type size() const
  72.         {return (_Tr.size()); }
  73.     size_type max_size() const
  74.         {return (_Tr.max_size()); }
  75.     bool empty() const
  76.         {return (_Tr.empty()); }
  77.     _A get_allocator() const
  78.         {return (_Tr.get_allocator()); }
  79.     _Pairib insert(const value_type& _X)
  80.         {_Imp::_Pairib _Ans = _Tr.insert(_X);
  81.         return (_Pairib(_Ans.first, _Ans.second)); }
  82.     iterator insert(iterator _P, const value_type& _X)
  83.         {return (_Tr.insert((_Imp::iterator&)_P, _X)); }
  84.     void insert(_It _F, _It _L)
  85.         {for (; _F != _L; ++_F)
  86.             _Tr.insert(*_F); }
  87.     iterator erase(iterator _P)
  88.         {return (_Tr.erase((_Imp::iterator&)_P)); }
  89.     iterator erase(iterator _F, iterator _L)
  90.         {return (_Tr.erase((_Imp::iterator&)_F,
  91.             (_Imp::iterator&)_L)); }
  92.     size_type erase(const _K& _Kv)
  93.         {return (_Tr.erase(_Kv)); }
  94.     void clear()
  95.         {_Tr.clear(); }
  96.     void swap(_Myt& _X)
  97.         {std::swap(_Tr, _X._Tr); }
  98.     friend void swap(_Myt& _X, _Myt& _Y)
  99.         {_X.swap(_Y); }
  100.     key_compare key_comp() const
  101.         {return (_Tr.key_comp()); }
  102.     value_compare value_comp() const
  103.         {return (_Tr.key_comp()); }
  104.     const_iterator find(const _K& _Kv) const
  105.         {return (_Tr.find(_Kv)); }
  106.     iterator find(const _K& _Kv)
  107.         {return (_Tr.find(_Kv)); }
  108.     size_type count(const _K& _Kv) const
  109.         {return (_Tr.count(_Kv)); }
  110.     iterator lower_bound(const _K& _Kv)
  111.         {return (_Tr.lower_bound(_Kv)); }
  112.     const_iterator lower_bound(const _K& _Kv) const
  113.         {return (_Tr.lower_bound(_Kv)); }
  114.     iterator upper_bound(const _K& _Kv)
  115.         {return (_Tr.upper_bound(_Kv)); }
  116.     const_iterator upper_bound(const _K& _Kv) const
  117.         {return (_Tr.upper_bound(_Kv)); }
  118.     _Pairii equal_range(const _K& _Kv)
  119.         {return (_Tr.equal_range(_Kv)); }
  120.     _Paircc equal_range(const _K& _Kv) const
  121.         {return (_Tr.equal_range(_Kv)); }
  122. protected:
  123.     _Imp _Tr;
  124.     };
  125.         // set TEMPLATE OPERATORS
  126. template<class _K, class _Pr, class _A> inline
  127.     bool operator==(const set<_K, _Pr, _A>& _X,
  128.         const set<_K, _Pr, _A>& _Y)
  129.     {return (_X.size() == _Y.size()
  130.         && equal(_X.begin(), _X.end(), _Y.begin())); }
  131. template<class _K, class _Pr, class _A> inline
  132.     bool operator!=(const set<_K, _Pr, _A>& _X,
  133.         const set<_K, _Pr, _A>& _Y)
  134.     {return (!(_X == _Y)); }
  135. template<class _K, class _Pr, class _A> inline
  136.     bool operator<(const set<_K, _Pr, _A>& _X,
  137.         const set<_K, _Pr, _A>& _Y)
  138.     {return (lexicographical_compare(_X.begin(), _X.end(),
  139.         _Y.begin(), _Y.end())); }
  140. template<class _K, class _Pr, class _A> inline
  141.     bool operator>(const set<_K, _Pr, _A>& _X,
  142.         const set<_K, _Pr, _A>& _Y)
  143.     {return (_Y < _X); }
  144. template<class _K, class _Pr, class _A> inline
  145.     bool operator<=(const set<_K, _Pr, _A>& _X,
  146.         const set<_K, _Pr, _A>& _Y)
  147.     {return (!(_Y < _X)); }
  148. template<class _K, class _Pr, class _A> inline
  149.     bool operator>=(const set<_K, _Pr, _A>& _X,
  150.         const set<_K, _Pr, _A>& _Y)
  151.     {return (!(_X < _Y)); }
  152.         // TEMPLATE CLASS multiset
  153. template<class _K, class _Pr = less<_K>,
  154.     class _A = allocator<_K> >
  155.     class multiset {
  156. public:
  157.     typedef multiset<_K, _Pr, _A> _Myt;
  158.     typedef _K value_type;
  159.     struct _Kfn : public unary_function<value_type, _K> {
  160.         const _K& operator()(const value_type& _X) const
  161.         {return (_X); }
  162.         };
  163.     typedef _Pr value_compare;
  164.     typedef _K key_type;
  165.     typedef _Pr key_compare;
  166.     typedef _A allocator_type;
  167.     typedef _Tree<_K, value_type, _Kfn, _Pr, _A> _Imp;
  168.     typedef _Imp::size_type size_type;
  169.     typedef _Imp::difference_type difference_type;
  170.     typedef _Imp::reference reference;
  171.     typedef _Imp::const_reference const_reference;
  172.     typedef _Imp::iterator iterator;
  173.     typedef _Imp::const_iterator const_iterator;
  174.     typedef _Imp::reverse_iterator reverse_iterator;
  175.     typedef _Imp::const_reverse_iterator const_reverse_iterator;
  176.     typedef pair<iterator, iterator> _Pairii;
  177.     typedef pair<const_iterator, const_iterator> _Paircc;
  178.     explicit multiset(const _Pr& _Pred = _Pr(),
  179.         const _A& _Al = _A())
  180.         : _Tr(_Pred, true, _Al) {}
  181.     typedef const value_type *_It;
  182.     multiset(_It _F, _It _L, const _Pr& _Pred = _Pr(),
  183.             const _A& _Al = _A())
  184.         : _Tr(_Pred, true, _Al)
  185.         {for (; _F != _L; ++_F)
  186.             _Tr.insert(*_F); }
  187.     _Myt& operator=(const _Myt& _X)
  188.         {_Tr = _X._Tr;
  189.         return (*this); }
  190.     iterator begin()
  191.         {return (_Tr.begin()); }
  192.     const_iterator begin() const
  193.         {return (_Tr.begin()); }
  194.     iterator end()
  195.         {return (_Tr.end()); }
  196.     const_iterator end() const
  197.         {return (_Tr.end()); }
  198.     reverse_iterator rbegin()
  199.         {return (_Tr.rbegin()); }
  200.     const_reverse_iterator rbegin() const
  201.         {return (_Tr.rbegin()); }
  202.     reverse_iterator rend()
  203.         {return (_Tr.rend()); }
  204.     const_reverse_iterator rend() const
  205.         {return (_Tr.rend()); }
  206.     size_type size() const
  207.         {return (_Tr.size()); }
  208.     size_type max_size() const
  209.         {return (_Tr.max_size()); }
  210.     bool empty() const
  211.         {return (_Tr.empty()); }
  212.     _A get_allocator() const
  213.         {return (_Tr.get_allocator()); }
  214.     iterator insert(const value_type& _X)
  215.         {return (_Tr.insert(_X).first); }
  216.     iterator insert(iterator _P, const value_type& _X)
  217.         {return (_Tr.insert((_Imp::iterator&)_P, _X)); }
  218.     void insert(_It _F, _It _L)
  219.         {for (; _F != _L; ++_F)
  220.             _Tr.insert(*_F); }
  221.     iterator erase(iterator _P)
  222.         {return (_Tr.erase((_Imp::iterator&)_P)); }
  223.     iterator erase(iterator _F, iterator _L)
  224.         {return (_Tr.erase((_Imp::iterator&)_F,
  225.             (_Imp::iterator&)_L)); }
  226.     size_type erase(const _K& _Kv)
  227.         {return (_Tr.erase(_Kv)); }
  228.     void clear()
  229.         {_Tr.clear(); }
  230.     void swap(_Myt& _X)
  231.         {std::swap(_Tr, _X._Tr); }
  232.     friend void swap(_Myt& _X, _Myt& _Y)
  233.         {_X.swap(_Y); }
  234.     key_compare key_comp() const
  235.         {return (_Tr.key_comp()); }
  236.     value_compare value_comp() const
  237.         {return (_Tr.key_comp()); }
  238.     iterator find(const _K& _Kv)
  239.         {return (_Tr.find(_Kv)); }
  240.     const_iterator find(const _K& _Kv) const
  241.         {return (_Tr.find(_Kv)); }
  242.     size_type count(const _K& _Kv) const
  243.         {return (_Tr.count(_Kv)); }
  244.     iterator lower_bound(const _K& _Kv)
  245.         {return (_Tr.lower_bound(_Kv)); }
  246.     const_iterator lower_bound(const _K& _Kv) const
  247.         {return (_Tr.lower_bound(_Kv)); }
  248.     iterator upper_bound(const _K& _Kv)
  249.         {return (_Tr.upper_bound(_Kv)); }
  250.     const_iterator upper_bound(const _K& _Kv) const
  251.         {return (_Tr.upper_bound(_Kv)); }
  252.     _Pairii equal_range(const _K& _Kv)
  253.         {return (_Tr.equal_range(_Kv)); }
  254.     _Paircc equal_range(const _K& _Kv) const
  255.         {return (_Tr.equal_range(_Kv)); }
  256. protected:
  257.     _Imp _Tr;
  258.     };
  259.         // multiset TEMPLATE OPERATORS
  260. template<class _K, class _Pr, class _A> inline
  261.     bool operator==(const multiset<_K, _Pr, _A>& _X,
  262.         const multiset<_K, _Pr, _A>& _Y)
  263.     {return (_X.size() == _Y.size()
  264.         && equal(_X.begin(), _X.end(), _Y.begin())); }
  265. template<class _K, class _Pr, class _A> inline
  266.     bool operator!=(const multiset<_K, _Pr, _A>& _X,
  267.         const multiset<_K, _Pr, _A>& _Y)
  268.     {return (!(_X == _Y)); }
  269. template<class _K, class _Pr, class _A> inline
  270.     bool operator<(const multiset<_K, _Pr, _A>& _X,
  271.         const multiset<_K, _Pr, _A>& _Y)
  272.     {return (lexicographical_compare(_X.begin(), _X.end(),
  273.         _Y.begin(), _Y.end())); }
  274. template<class _K, class _Pr, class _A> inline
  275.     bool operator>(const multiset<_K, _Pr, _A>& _X,
  276.         const multiset<_K, _Pr, _A>& _Y)
  277.     {return (_Y < _X); }
  278. template<class _K, class _Pr, class _A> inline
  279.     bool operator<=(const multiset<_K, _Pr, _A>& _X,
  280.         const multiset<_K, _Pr, _A>& _Y)
  281.     {return (!(_Y < _X)); }
  282. template<class _K, class _Pr, class _A> inline
  283.     bool operator>=(const multiset<_K, _Pr, _A>& _X,
  284.         const multiset<_K, _Pr, _A>& _Y)
  285.     {return (!(_X < _Y)); }
  286. _STD_END
  287. #ifdef  _MSC_VER
  288. #pragma pack(pop)
  289. #endif  /* _MSC_VER */
  290.  
  291. #endif /* _SET_ */
  292.  
  293. /*
  294.  * Copyright (c) 1995 by P.J. Plauger.  ALL RIGHTS RESERVED. 
  295.  * Consult your license regarding permissions and restrictions.
  296.  */
  297.  
  298. /*
  299.  * This file is derived from software bearing the following
  300.  * restrictions:
  301.  *
  302.  * Copyright (c) 1994
  303.  * Hewlett-Packard Company
  304.  *
  305.  * Permission to use, copy, modify, distribute and sell this
  306.  * software and its documentation for any purpose is hereby
  307.  * granted without fee, provided that the above copyright notice
  308.  * appear in all copies and that both that copyright notice and
  309.  * this permission notice appear in supporting documentation.
  310.  * Hewlett-Packard Company makes no representations about the
  311.  * suitability of this software for any purpose. It is provided
  312.  * "as is" without express or implied warranty.
  313.  */
  314.