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

STL

开发平台:

Visual C++

  1. /*
  2.  * Copyright (c) 1996
  3.  * Silicon Graphics Computer Systems, Inc.
  4.  *
  5.  * Permission to use, copy, modify, distribute and sell this software
  6.  * and its documentation for any purpose is hereby granted without fee,
  7.  * provided that the above copyright notice appear in all copies and
  8.  * that both that copyright notice and this permission notice appear
  9.  * in supporting documentation.  Silicon Graphics makes no
  10.  * representations about the suitability of this software for any
  11.  * purpose.  It is provided "as is" without express or implied warranty.
  12.  *
  13.  *
  14.  * Copyright (c) 1994
  15.  * Hewlett-Packard Company
  16.  *
  17.  * Permission to use, copy, modify, distribute and sell this software
  18.  * and its documentation for any purpose is hereby granted without fee,
  19.  * provided that the above copyright notice appear in all copies and
  20.  * that both that copyright notice and this permission notice appear
  21.  * in supporting documentation.  Hewlett-Packard Company makes no
  22.  * representations about the suitability of this software for any
  23.  * purpose.  It is provided "as is" without express or implied warranty.
  24.  *
  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_HASH_MAP_H
  30. #define __SGI_STL_INTERNAL_HASH_MAP_H
  31. #include <concept_checks.h>
  32. __STL_BEGIN_NAMESPACE
  33. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  34. #pragma set woff 1174
  35. #pragma set woff 1375
  36. #endif
  37. // Forward declaration of equality operator; needed for friend declaration.
  38. template <class _Key, class _Tp,
  39.           class _HashFcn  __STL_DEPENDENT_DEFAULT_TMPL(hash<_Key>),
  40.           class _EqualKey __STL_DEPENDENT_DEFAULT_TMPL(equal_to<_Key>),
  41.           class _Alloc =  __STL_DEFAULT_ALLOCATOR(_Tp) >
  42. class hash_map;
  43. template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
  44. inline bool operator==(const hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>&,
  45.                        const hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>&);
  46. template <class _Key, class _Tp, class _HashFcn, class _EqualKey,
  47.           class _Alloc>
  48. class hash_map
  49. {
  50.   // requirements:
  51.   __STL_CLASS_REQUIRES(_Key, _Assignable);
  52.   __STL_CLASS_REQUIRES(_Tp, _Assignable);
  53.   __STL_CLASS_UNARY_FUNCTION_CHECK(_HashFcn, size_t, _Key);
  54.   __STL_CLASS_BINARY_FUNCTION_CHECK(_EqualKey, bool, _Key, _Key);
  55. private:
  56.   typedef hashtable<pair<const _Key,_Tp>,_Key,_HashFcn,
  57.                     _Select1st<pair<const _Key,_Tp> >,_EqualKey,_Alloc> _Ht;
  58.   _Ht _M_ht;
  59. public:
  60.   typedef typename _Ht::key_type key_type;
  61.   typedef _Tp data_type;
  62.   typedef _Tp mapped_type;
  63.   typedef typename _Ht::value_type value_type;
  64.   typedef typename _Ht::hasher hasher;
  65.   typedef typename _Ht::key_equal key_equal;
  66.   
  67.   typedef typename _Ht::size_type size_type;
  68.   typedef typename _Ht::difference_type difference_type;
  69.   typedef typename _Ht::pointer pointer;
  70.   typedef typename _Ht::const_pointer const_pointer;
  71.   typedef typename _Ht::reference reference;
  72.   typedef typename _Ht::const_reference const_reference;
  73.   typedef typename _Ht::iterator iterator;
  74.   typedef typename _Ht::const_iterator const_iterator;
  75.   typedef typename _Ht::allocator_type allocator_type;
  76.   hasher hash_funct() const { return _M_ht.hash_funct(); }
  77.   key_equal key_eq() const { return _M_ht.key_eq(); }
  78.   allocator_type get_allocator() const { return _M_ht.get_allocator(); }
  79. public:
  80.   hash_map() : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
  81.   explicit hash_map(size_type __n)
  82.     : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
  83.   hash_map(size_type __n, const hasher& __hf)
  84.     : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
  85.   hash_map(size_type __n, const hasher& __hf, const key_equal& __eql,
  86.            const allocator_type& __a = allocator_type())
  87.     : _M_ht(__n, __hf, __eql, __a) {}
  88. #ifdef __STL_MEMBER_TEMPLATES
  89.   template <class _InputIterator>
  90.   hash_map(_InputIterator __f, _InputIterator __l)
  91.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  92.     { _M_ht.insert_unique(__f, __l); }
  93.   template <class _InputIterator>
  94.   hash_map(_InputIterator __f, _InputIterator __l, size_type __n)
  95.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  96.     { _M_ht.insert_unique(__f, __l); }
  97.   template <class _InputIterator>
  98.   hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
  99.            const hasher& __hf)
  100.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  101.     { _M_ht.insert_unique(__f, __l); }
  102.   template <class _InputIterator>
  103.   hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
  104.            const hasher& __hf, const key_equal& __eql,
  105.            const allocator_type& __a = allocator_type())
  106.     : _M_ht(__n, __hf, __eql, __a)
  107.     { _M_ht.insert_unique(__f, __l); }
  108. #else
  109.   hash_map(const value_type* __f, const value_type* __l)
  110.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  111.     { _M_ht.insert_unique(__f, __l); }
  112.   hash_map(const value_type* __f, const value_type* __l, size_type __n)
  113.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  114.     { _M_ht.insert_unique(__f, __l); }
  115.   hash_map(const value_type* __f, const value_type* __l, size_type __n,
  116.            const hasher& __hf)
  117.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  118.     { _M_ht.insert_unique(__f, __l); }
  119.   hash_map(const value_type* __f, const value_type* __l, size_type __n,
  120.            const hasher& __hf, const key_equal& __eql,
  121.            const allocator_type& __a = allocator_type())
  122.     : _M_ht(__n, __hf, __eql, __a)
  123.     { _M_ht.insert_unique(__f, __l); }
  124.   hash_map(const_iterator __f, const_iterator __l)
  125.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  126.     { _M_ht.insert_unique(__f, __l); }
  127.   hash_map(const_iterator __f, const_iterator __l, size_type __n)
  128.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  129.     { _M_ht.insert_unique(__f, __l); }
  130.   hash_map(const_iterator __f, const_iterator __l, size_type __n,
  131.            const hasher& __hf)
  132.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  133.     { _M_ht.insert_unique(__f, __l); }
  134.   hash_map(const_iterator __f, const_iterator __l, size_type __n,
  135.            const hasher& __hf, const key_equal& __eql,
  136.            const allocator_type& __a = allocator_type())
  137.     : _M_ht(__n, __hf, __eql, __a)
  138.     { _M_ht.insert_unique(__f, __l); }
  139. #endif /*__STL_MEMBER_TEMPLATES */
  140. public:
  141.   size_type size() const { return _M_ht.size(); }
  142.   size_type max_size() const { return _M_ht.max_size(); }
  143.   bool empty() const { return _M_ht.empty(); }
  144.   void swap(hash_map& __hs) { _M_ht.swap(__hs._M_ht); }
  145. #ifdef __STL_MEMBER_TEMPLATES
  146.   template <class _K1, class _T1, class _HF, class _EqK, class _Al>
  147.   friend bool operator== (const hash_map<_K1, _T1, _HF, _EqK, _Al>&,
  148.                           const hash_map<_K1, _T1, _HF, _EqK, _Al>&);
  149. #else /* __STL_MEMBER_TEMPLATES */
  150.   friend bool __STD_QUALIFIER
  151.   operator== __STL_NULL_TMPL_ARGS (const hash_map&, const hash_map&);
  152. #endif /* __STL_MEMBER_TEMPLATES */
  153.   iterator begin() { return _M_ht.begin(); }
  154.   iterator end() { return _M_ht.end(); }
  155.   const_iterator begin() const { return _M_ht.begin(); }
  156.   const_iterator end() const { return _M_ht.end(); }
  157. public:
  158.   pair<iterator,bool> insert(const value_type& __obj)
  159.     { return _M_ht.insert_unique(__obj); }
  160. #ifdef __STL_MEMBER_TEMPLATES
  161.   template <class _InputIterator>
  162.   void insert(_InputIterator __f, _InputIterator __l)
  163.     { _M_ht.insert_unique(__f,__l); }
  164. #else
  165.   void insert(const value_type* __f, const value_type* __l) {
  166.     _M_ht.insert_unique(__f,__l);
  167.   }
  168.   void insert(const_iterator __f, const_iterator __l)
  169.     { _M_ht.insert_unique(__f, __l); }
  170. #endif /*__STL_MEMBER_TEMPLATES */
  171.   pair<iterator,bool> insert_noresize(const value_type& __obj)
  172.     { return _M_ht.insert_unique_noresize(__obj); }    
  173.   iterator find(const key_type& __key) { return _M_ht.find(__key); }
  174.   const_iterator find(const key_type& __key) const 
  175.     { return _M_ht.find(__key); }
  176.   _Tp& operator[](const key_type& __key) {
  177.     return _M_ht.find_or_insert(value_type(__key, _Tp())).second;
  178.   }
  179.   size_type count(const key_type& __key) const { return _M_ht.count(__key); }
  180.   
  181.   pair<iterator, iterator> equal_range(const key_type& __key)
  182.     { return _M_ht.equal_range(__key); }
  183.   pair<const_iterator, const_iterator>
  184.   equal_range(const key_type& __key) const
  185.     { return _M_ht.equal_range(__key); }
  186.   size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
  187.   void erase(iterator __it) { _M_ht.erase(__it); }
  188.   void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
  189.   void clear() { _M_ht.clear(); }
  190.   void resize(size_type __hint) { _M_ht.resize(__hint); }
  191.   size_type bucket_count() const { return _M_ht.bucket_count(); }
  192.   size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
  193.   size_type elems_in_bucket(size_type __n) const
  194.     { return _M_ht.elems_in_bucket(__n); }
  195. };
  196. template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
  197. inline bool 
  198. operator==(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
  199.            const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
  200. {
  201.   return __hm1._M_ht == __hm2._M_ht;
  202. }
  203. #ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
  204. template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
  205. inline bool 
  206. operator!=(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
  207.            const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2) {
  208.   return !(__hm1 == __hm2);
  209. }
  210. template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
  211. inline void 
  212. swap(hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
  213.      hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
  214. {
  215.   __hm1.swap(__hm2);
  216. }
  217. #endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
  218. // Forward declaration of equality operator; needed for friend declaration.
  219. template <class _Key, class _Tp,
  220.           class _HashFcn  __STL_DEPENDENT_DEFAULT_TMPL(hash<_Key>),
  221.           class _EqualKey __STL_DEPENDENT_DEFAULT_TMPL(equal_to<_Key>),
  222.           class _Alloc =  __STL_DEFAULT_ALLOCATOR(_Tp) >
  223. class hash_multimap;
  224. template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
  225. inline bool 
  226. operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1,
  227.            const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2);
  228. template <class _Key, class _Tp, class _HashFcn, class _EqualKey, 
  229.           class _Alloc>
  230. class hash_multimap
  231. {
  232.   // requirements:
  233.   __STL_CLASS_REQUIRES(_Key, _Assignable);
  234.   __STL_CLASS_REQUIRES(_Tp, _Assignable);
  235.   __STL_CLASS_UNARY_FUNCTION_CHECK(_HashFcn, size_t, _Key);
  236.   __STL_CLASS_BINARY_FUNCTION_CHECK(_EqualKey, bool, _Key, _Key);
  237. private:
  238.   typedef hashtable<pair<const _Key, _Tp>, _Key, _HashFcn,
  239.                     _Select1st<pair<const _Key, _Tp> >, _EqualKey, _Alloc> 
  240.           _Ht;
  241.   _Ht _M_ht;
  242. public:
  243.   typedef typename _Ht::key_type key_type;
  244.   typedef _Tp data_type;
  245.   typedef _Tp mapped_type;
  246.   typedef typename _Ht::value_type value_type;
  247.   typedef typename _Ht::hasher hasher;
  248.   typedef typename _Ht::key_equal key_equal;
  249.   typedef typename _Ht::size_type size_type;
  250.   typedef typename _Ht::difference_type difference_type;
  251.   typedef typename _Ht::pointer pointer;
  252.   typedef typename _Ht::const_pointer const_pointer;
  253.   typedef typename _Ht::reference reference;
  254.   typedef typename _Ht::const_reference const_reference;
  255.   typedef typename _Ht::iterator iterator;
  256.   typedef typename _Ht::const_iterator const_iterator;
  257.   typedef typename _Ht::allocator_type allocator_type;
  258.   hasher hash_funct() const { return _M_ht.hash_funct(); }
  259.   key_equal key_eq() const { return _M_ht.key_eq(); }
  260.   allocator_type get_allocator() const { return _M_ht.get_allocator(); }
  261. public:
  262.   hash_multimap() : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
  263.   explicit hash_multimap(size_type __n)
  264.     : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
  265.   hash_multimap(size_type __n, const hasher& __hf)
  266.     : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
  267.   hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql,
  268.                 const allocator_type& __a = allocator_type())
  269.     : _M_ht(__n, __hf, __eql, __a) {}
  270. #ifdef __STL_MEMBER_TEMPLATES
  271.   template <class _InputIterator>
  272.   hash_multimap(_InputIterator __f, _InputIterator __l)
  273.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  274.     { _M_ht.insert_equal(__f, __l); }
  275.   template <class _InputIterator>
  276.   hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n)
  277.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  278.     { _M_ht.insert_equal(__f, __l); }
  279.   template <class _InputIterator>
  280.   hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
  281.                 const hasher& __hf)
  282.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  283.     { _M_ht.insert_equal(__f, __l); }
  284.   template <class _InputIterator>
  285.   hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
  286.                 const hasher& __hf, const key_equal& __eql,
  287.                 const allocator_type& __a = allocator_type())
  288.     : _M_ht(__n, __hf, __eql, __a)
  289.     { _M_ht.insert_equal(__f, __l); }
  290. #else
  291.   hash_multimap(const value_type* __f, const value_type* __l)
  292.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  293.     { _M_ht.insert_equal(__f, __l); }
  294.   hash_multimap(const value_type* __f, const value_type* __l, size_type __n)
  295.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  296.     { _M_ht.insert_equal(__f, __l); }
  297.   hash_multimap(const value_type* __f, const value_type* __l, size_type __n,
  298.                 const hasher& __hf)
  299.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  300.     { _M_ht.insert_equal(__f, __l); }
  301.   hash_multimap(const value_type* __f, const value_type* __l, size_type __n,
  302.                 const hasher& __hf, const key_equal& __eql,
  303.                 const allocator_type& __a = allocator_type())
  304.     : _M_ht(__n, __hf, __eql, __a)
  305.     { _M_ht.insert_equal(__f, __l); }
  306.   hash_multimap(const_iterator __f, const_iterator __l)
  307.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  308.     { _M_ht.insert_equal(__f, __l); }
  309.   hash_multimap(const_iterator __f, const_iterator __l, size_type __n)
  310.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  311.     { _M_ht.insert_equal(__f, __l); }
  312.   hash_multimap(const_iterator __f, const_iterator __l, size_type __n,
  313.                 const hasher& __hf)
  314.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  315.     { _M_ht.insert_equal(__f, __l); }
  316.   hash_multimap(const_iterator __f, const_iterator __l, size_type __n,
  317.                 const hasher& __hf, const key_equal& __eql,
  318.                 const allocator_type& __a = allocator_type())
  319.     : _M_ht(__n, __hf, __eql, __a)
  320.     { _M_ht.insert_equal(__f, __l); }
  321. #endif /*__STL_MEMBER_TEMPLATES */
  322. public:
  323.   size_type size() const { return _M_ht.size(); }
  324.   size_type max_size() const { return _M_ht.max_size(); }
  325.   bool empty() const { return _M_ht.empty(); }
  326.   void swap(hash_multimap& __hs) { _M_ht.swap(__hs._M_ht); }
  327. #ifdef __STL_MEMBER_TEMPLATES
  328.   template <class _K1, class _T1, class _HF, class _EqK, class _Al>
  329.   friend bool operator== (const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&,
  330.                           const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&);
  331. #else /* __STL_MEMBER_TEMPLATES */
  332.   friend bool __STD_QUALIFIER
  333.   operator== __STL_NULL_TMPL_ARGS (const hash_multimap&,const hash_multimap&);
  334. #endif /* __STL_MEMBER_TEMPLATES */
  335.   iterator begin() { return _M_ht.begin(); }
  336.   iterator end() { return _M_ht.end(); }
  337.   const_iterator begin() const { return _M_ht.begin(); }
  338.   const_iterator end() const { return _M_ht.end(); }
  339. public:
  340.   iterator insert(const value_type& __obj) 
  341.     { return _M_ht.insert_equal(__obj); }
  342. #ifdef __STL_MEMBER_TEMPLATES
  343.   template <class _InputIterator>
  344.   void insert(_InputIterator __f, _InputIterator __l) 
  345.     { _M_ht.insert_equal(__f,__l); }
  346. #else
  347.   void insert(const value_type* __f, const value_type* __l) {
  348.     _M_ht.insert_equal(__f,__l);
  349.   }
  350.   void insert(const_iterator __f, const_iterator __l) 
  351.     { _M_ht.insert_equal(__f, __l); }
  352. #endif /*__STL_MEMBER_TEMPLATES */
  353.   iterator insert_noresize(const value_type& __obj)
  354.     { return _M_ht.insert_equal_noresize(__obj); }    
  355.   iterator find(const key_type& __key) { return _M_ht.find(__key); }
  356.   const_iterator find(const key_type& __key) const 
  357.     { return _M_ht.find(__key); }
  358.   size_type count(const key_type& __key) const { return _M_ht.count(__key); }
  359.   
  360.   pair<iterator, iterator> equal_range(const key_type& __key)
  361.     { return _M_ht.equal_range(__key); }
  362.   pair<const_iterator, const_iterator>
  363.   equal_range(const key_type& __key) const
  364.     { return _M_ht.equal_range(__key); }
  365.   size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
  366.   void erase(iterator __it) { _M_ht.erase(__it); }
  367.   void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
  368.   void clear() { _M_ht.clear(); }
  369. public:
  370.   void resize(size_type __hint) { _M_ht.resize(__hint); }
  371.   size_type bucket_count() const { return _M_ht.bucket_count(); }
  372.   size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
  373.   size_type elems_in_bucket(size_type __n) const
  374.     { return _M_ht.elems_in_bucket(__n); }
  375. };
  376. template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
  377. inline bool 
  378. operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1,
  379.            const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2)
  380. {
  381.   return __hm1._M_ht == __hm2._M_ht;
  382. }
  383. #ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
  384. template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
  385. inline bool 
  386. operator!=(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1,
  387.            const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2) {
  388.   return !(__hm1 == __hm2);
  389. }
  390. template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
  391. inline void 
  392. swap(hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
  393.      hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
  394. {
  395.   __hm1.swap(__hm2);
  396. }
  397. #endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
  398. // Specialization of insert_iterator so that it will work for hash_map
  399. // and hash_multimap.
  400. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  401. template <class _Key, class _Tp, class _HashFn,  class _EqKey, class _Alloc>
  402. class insert_iterator<hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
  403. protected:
  404.   typedef hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
  405.   _Container* container;
  406. public:
  407.   typedef _Container          container_type;
  408.   typedef output_iterator_tag iterator_category;
  409.   typedef void                value_type;
  410.   typedef void                difference_type;
  411.   typedef void                pointer;
  412.   typedef void                reference;
  413.   insert_iterator(_Container& __x) : container(&__x) {}
  414.   insert_iterator(_Container& __x, typename _Container::iterator)
  415.     : container(&__x) {}
  416.   insert_iterator<_Container>&
  417.   operator=(const typename _Container::value_type& __value) { 
  418.     container->insert(__value);
  419.     return *this;
  420.   }
  421.   insert_iterator<_Container>& operator*() { return *this; }
  422.   insert_iterator<_Container>& operator++() { return *this; }
  423.   insert_iterator<_Container>& operator++(int) { return *this; }
  424. };
  425. template <class _Key, class _Tp, class _HashFn,  class _EqKey, class _Alloc>
  426. class insert_iterator<hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
  427. protected:
  428.   typedef hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
  429.   _Container* container;
  430.   typename _Container::iterator iter;
  431. public:
  432.   typedef _Container          container_type;
  433.   typedef output_iterator_tag iterator_category;
  434.   typedef void                value_type;
  435.   typedef void                difference_type;
  436.   typedef void                pointer;
  437.   typedef void                reference;
  438.   insert_iterator(_Container& __x) : container(&__x) {}
  439.   insert_iterator(_Container& __x, typename _Container::iterator)
  440.     : container(&__x) {}
  441.   insert_iterator<_Container>&
  442.   operator=(const typename _Container::value_type& __value) { 
  443.     container->insert(__value);
  444.     return *this;
  445.   }
  446.   insert_iterator<_Container>& operator*() { return *this; }
  447.   insert_iterator<_Container>& operator++() { return *this; }
  448.   insert_iterator<_Container>& operator++(int) { return *this; }
  449. };
  450. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  451. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  452. #pragma reset woff 1174
  453. #pragma reset woff 1375
  454. #endif
  455. __STL_END_NAMESPACE
  456. #endif /* __SGI_STL_INTERNAL_HASH_MAP_H */
  457. // Local Variables:
  458. // mode:C++
  459. // End: