home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 January / PCWorld_2000-01_cd.bin / Software / Servis / Devc / _SETUP.4 / Group3 / stl_map.h < prev    next >
C/C++ Source or Header  |  1998-03-08  |  7KB  |  218 lines
  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.  
  27. /* NOTE: This is an internal header file, included by other STL headers.
  28.  *   You should not attempt to use it directly.
  29.  */
  30.  
  31. #ifndef __SGI_STL_INTERNAL_MAP_H
  32. #define __SGI_STL_INTERNAL_MAP_H
  33.  
  34. __STL_BEGIN_NAMESPACE
  35.  
  36. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  37. #pragma set woff 1174
  38. #endif
  39.  
  40. #ifndef __STL_LIMITED_DEFAULT_TEMPLATES
  41. template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>
  42. #else
  43. template <class Key, class T, class Compare, class Alloc = alloc>
  44. #endif
  45. class map {
  46. public:
  47.  
  48. // typedefs:
  49.  
  50.   typedef Key key_type;
  51.   typedef T data_type;
  52.   typedef T mapped_type;
  53.   typedef pair<const Key, T> value_type;
  54.   typedef Compare key_compare;
  55.     
  56.   class value_compare
  57.     : public binary_function<value_type, value_type, bool> {
  58.   friend class map<Key, T, Compare, Alloc>;
  59.   protected :
  60.     Compare comp;
  61.     value_compare(Compare c) : comp(c) {}
  62.   public:
  63.     bool operator()(const value_type& x, const value_type& y) const {
  64.       return comp(x.first, y.first);
  65.     }
  66.   };
  67.  
  68. private:
  69.   typedef rb_tree<key_type, value_type, 
  70.                   select1st<value_type>, key_compare, Alloc> rep_type;
  71.   rep_type t;  // red-black tree representing map
  72. public:
  73.   typedef typename rep_type::pointer pointer;
  74.   typedef typename rep_type::const_pointer const_pointer;
  75.   typedef typename rep_type::reference reference;
  76.   typedef typename rep_type::const_reference const_reference;
  77.   typedef typename rep_type::iterator iterator;
  78.   typedef typename rep_type::const_iterator const_iterator;
  79.   typedef typename rep_type::reverse_iterator reverse_iterator;
  80.   typedef typename rep_type::const_reverse_iterator const_reverse_iterator;
  81.   typedef typename rep_type::size_type size_type;
  82.   typedef typename rep_type::difference_type difference_type;
  83.  
  84.   // allocation/deallocation
  85.  
  86.   map() : t(Compare()) {}
  87.   explicit map(const Compare& comp) : t(comp) {}
  88.  
  89. #ifdef __STL_MEMBER_TEMPLATES
  90.   template <class InputIterator>
  91.   map(InputIterator first, InputIterator last)
  92.     : t(Compare()) { t.insert_unique(first, last); }
  93.  
  94.   template <class InputIterator>
  95.   map(InputIterator first, InputIterator last, const Compare& comp)
  96.     : t(comp) { t.insert_unique(first, last); }
  97. #else
  98.   map(const value_type* first, const value_type* last)
  99.     : t(Compare()) { t.insert_unique(first, last); }
  100.   map(const value_type* first, const value_type* last, const Compare& comp)
  101.     : t(comp) { t.insert_unique(first, last); }
  102.  
  103.   map(const_iterator first, const_iterator last)
  104.     : t(Compare()) { t.insert_unique(first, last); }
  105.   map(const_iterator first, const_iterator last, const Compare& comp)
  106.     : t(comp) { t.insert_unique(first, last); }
  107. #endif /* __STL_MEMBER_TEMPLATES */
  108.  
  109.   map(const map<Key, T, Compare, Alloc>& x) : t(x.t) {}
  110.   map<Key, T, Compare, Alloc>& operator=(const map<Key, T, Compare, Alloc>& x)
  111.   {
  112.     t = x.t;
  113.     return *this; 
  114.   }
  115.  
  116.   // accessors:
  117.  
  118.   key_compare key_comp() const { return t.key_comp(); }
  119.   value_compare value_comp() const { return value_compare(t.key_comp()); }
  120.   iterator begin() { return t.begin(); }
  121.   const_iterator begin() const { return t.begin(); }
  122.   iterator end() { return t.end(); }
  123.   const_iterator end() const { return t.end(); }
  124.   reverse_iterator rbegin() { return t.rbegin(); }
  125.   const_reverse_iterator rbegin() const { return t.rbegin(); }
  126.   reverse_iterator rend() { return t.rend(); }
  127.   const_reverse_iterator rend() const { return t.rend(); }
  128.   bool empty() const { return t.empty(); }
  129.   size_type size() const { return t.size(); }
  130.   size_type max_size() const { return t.max_size(); }
  131.   T& operator[](const key_type& k) {
  132.     return (*((insert(value_type(k, T()))).first)).second;
  133.   }
  134.   void swap(map<Key, T, Compare, Alloc>& x) { t.swap(x.t); }
  135.  
  136.   // insert/erase
  137.  
  138.   pair<iterator,bool> insert(const value_type& x) { return t.insert_unique(x); }
  139.   iterator insert(iterator position, const value_type& x) {
  140.     return t.insert_unique(position, x);
  141.   }
  142. #ifdef __STL_MEMBER_TEMPLATES
  143.   template <class InputIterator>
  144.   void insert(InputIterator first, InputIterator last) {
  145.     t.insert_unique(first, last);
  146.   }
  147. #else
  148.   void insert(const value_type* first, const value_type* last) {
  149.     t.insert_unique(first, last);
  150.   }
  151.   void insert(const_iterator first, const_iterator last) {
  152.     t.insert_unique(first, last);
  153.   }
  154. #endif /* __STL_MEMBER_TEMPLATES */
  155.  
  156.   void erase(iterator position) { t.erase(position); }
  157.   size_type erase(const key_type& x) { return t.erase(x); }
  158.   void erase(iterator first, iterator last) { t.erase(first, last); }
  159.   void clear() { t.clear(); }
  160.  
  161.   // map operations:
  162.  
  163.   iterator find(const key_type& x) { return t.find(x); }
  164.   const_iterator find(const key_type& x) const { return t.find(x); }
  165.   size_type count(const key_type& x) const { return t.count(x); }
  166.   iterator lower_bound(const key_type& x) {return t.lower_bound(x); }
  167.   const_iterator lower_bound(const key_type& x) const {
  168.     return t.lower_bound(x); 
  169.   }
  170.   iterator upper_bound(const key_type& x) {return t.upper_bound(x); }
  171.   const_iterator upper_bound(const key_type& x) const {
  172.     return t.upper_bound(x); 
  173.   }
  174.   
  175.   pair<iterator,iterator> equal_range(const key_type& x) {
  176.     return t.equal_range(x);
  177.   }
  178.   pair<const_iterator,const_iterator> equal_range(const key_type& x) const {
  179.     return t.equal_range(x);
  180.   }
  181.   friend bool operator== __STL_NULL_TMPL_ARGS (const map&, const map&);
  182.   friend bool operator< __STL_NULL_TMPL_ARGS (const map&, const map&);
  183. };
  184.  
  185. template <class Key, class T, class Compare, class Alloc>
  186. inline bool operator==(const map<Key, T, Compare, Alloc>& x, 
  187.                        const map<Key, T, Compare, Alloc>& y) {
  188.   return x.t == y.t;
  189. }
  190.  
  191. template <class Key, class T, class Compare, class Alloc>
  192. inline bool operator<(const map<Key, T, Compare, Alloc>& x, 
  193.                       const map<Key, T, Compare, Alloc>& y) {
  194.   return x.t < y.t;
  195. }
  196.  
  197. #ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
  198.  
  199. template <class Key, class T, class Compare, class Alloc>
  200. inline void swap(map<Key, T, Compare, Alloc>& x, 
  201.                  map<Key, T, Compare, Alloc>& y) {
  202.   x.swap(y);
  203. }
  204.  
  205. #endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
  206.  
  207. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  208. #pragma reset woff 1174
  209. #endif
  210.  
  211. __STL_END_NAMESPACE
  212.  
  213. #endif /* __SGI_STL_INTERNAL_MAP_H */
  214.  
  215. // Local Variables:
  216. // mode:C++
  217. // End:
  218.