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

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_SET_H
  30. #define __SGI_STL_INTERNAL_HASH_SET_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 _Value,
  39.           class _HashFcn  __STL_DEPENDENT_DEFAULT_TMPL(hash<_Value>),
  40.           class _EqualKey __STL_DEPENDENT_DEFAULT_TMPL(equal_to<_Value>),
  41.           class _Alloc =  __STL_DEFAULT_ALLOCATOR(_Value) >
  42. class hash_set;
  43. template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
  44. inline bool 
  45. operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
  46.            const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2);
  47. template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
  48. class hash_set
  49. {
  50.   // requirements:
  51.   __STL_CLASS_REQUIRES(_Value, _Assignable);
  52.   __STL_CLASS_UNARY_FUNCTION_CHECK(_HashFcn, size_t, _Value);
  53.   __STL_CLASS_BINARY_FUNCTION_CHECK(_EqualKey, bool, _Value, _Value);
  54. private:
  55.   typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, 
  56.                     _EqualKey, _Alloc> _Ht;
  57.   _Ht _M_ht;
  58. public:
  59.   typedef typename _Ht::key_type key_type;
  60.   typedef typename _Ht::value_type value_type;
  61.   typedef typename _Ht::hasher hasher;
  62.   typedef typename _Ht::key_equal key_equal;
  63.   typedef typename _Ht::size_type size_type;
  64.   typedef typename _Ht::difference_type difference_type;
  65.   typedef typename _Ht::const_pointer pointer;
  66.   typedef typename _Ht::const_pointer const_pointer;
  67.   typedef typename _Ht::const_reference reference;
  68.   typedef typename _Ht::const_reference const_reference;
  69.   typedef typename _Ht::const_iterator iterator;
  70.   typedef typename _Ht::const_iterator const_iterator;
  71.   typedef typename _Ht::allocator_type allocator_type;
  72.   hasher hash_funct() const { return _M_ht.hash_funct(); }
  73.   key_equal key_eq() const { return _M_ht.key_eq(); }
  74.   allocator_type get_allocator() const { return _M_ht.get_allocator(); }
  75. public:
  76.   hash_set()
  77.     : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
  78.   explicit hash_set(size_type __n)
  79.     : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
  80.   hash_set(size_type __n, const hasher& __hf)
  81.     : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
  82.   hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
  83.            const allocator_type& __a = allocator_type())
  84.     : _M_ht(__n, __hf, __eql, __a) {}
  85. #ifdef __STL_MEMBER_TEMPLATES
  86.   template <class _InputIterator>
  87.   hash_set(_InputIterator __f, _InputIterator __l)
  88.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  89.     { _M_ht.insert_unique(__f, __l); }
  90.   template <class _InputIterator>
  91.   hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
  92.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  93.     { _M_ht.insert_unique(__f, __l); }
  94.   template <class _InputIterator>
  95.   hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
  96.            const hasher& __hf)
  97.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  98.     { _M_ht.insert_unique(__f, __l); }
  99.   template <class _InputIterator>
  100.   hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
  101.            const hasher& __hf, const key_equal& __eql,
  102.            const allocator_type& __a = allocator_type())
  103.     : _M_ht(__n, __hf, __eql, __a)
  104.     { _M_ht.insert_unique(__f, __l); }
  105. #else
  106.   hash_set(const value_type* __f, const value_type* __l)
  107.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  108.     { _M_ht.insert_unique(__f, __l); }
  109.   hash_set(const value_type* __f, const value_type* __l, size_type __n)
  110.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  111.     { _M_ht.insert_unique(__f, __l); }
  112.   hash_set(const value_type* __f, const value_type* __l, size_type __n,
  113.            const hasher& __hf)
  114.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  115.     { _M_ht.insert_unique(__f, __l); }
  116.   hash_set(const value_type* __f, const value_type* __l, size_type __n,
  117.            const hasher& __hf, const key_equal& __eql,
  118.            const allocator_type& __a = allocator_type())
  119.     : _M_ht(__n, __hf, __eql, __a)
  120.     { _M_ht.insert_unique(__f, __l); }
  121.   hash_set(const_iterator __f, const_iterator __l)
  122.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  123.     { _M_ht.insert_unique(__f, __l); }
  124.   hash_set(const_iterator __f, const_iterator __l, size_type __n)
  125.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  126.     { _M_ht.insert_unique(__f, __l); }
  127.   hash_set(const_iterator __f, const_iterator __l, size_type __n,
  128.            const hasher& __hf)
  129.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  130.     { _M_ht.insert_unique(__f, __l); }
  131.   hash_set(const_iterator __f, const_iterator __l, size_type __n,
  132.            const hasher& __hf, const key_equal& __eql,
  133.            const allocator_type& __a = allocator_type())
  134.     : _M_ht(__n, __hf, __eql, __a)
  135.     { _M_ht.insert_unique(__f, __l); }
  136. #endif /*__STL_MEMBER_TEMPLATES */
  137. public:
  138.   size_type size() const { return _M_ht.size(); }
  139.   size_type max_size() const { return _M_ht.max_size(); }
  140.   bool empty() const { return _M_ht.empty(); }
  141.   void swap(hash_set& __hs) { _M_ht.swap(__hs._M_ht); }
  142. #ifdef __STL_MEMBER_TEMPLATES
  143.   template <class _Val, class _HF, class _EqK, class _Al>  
  144.   friend bool operator== (const hash_set<_Val, _HF, _EqK, _Al>&,
  145.                           const hash_set<_Val, _HF, _EqK, _Al>&);
  146. #else /* __STL_MEMBER_TEMPLATES */
  147.   friend bool __STD_QUALIFIER
  148.   operator== __STL_NULL_TMPL_ARGS (const hash_set&, const hash_set&);
  149. #endif /* __STL_MEMBER_TEMPLATES */
  150.   iterator begin() const { return _M_ht.begin(); }
  151.   iterator end() const { return _M_ht.end(); }
  152. public:
  153.   pair<iterator, bool> insert(const value_type& __obj)
  154.     {
  155.       pair<typename _Ht::iterator, bool> __p = _M_ht.insert_unique(__obj);
  156.       return pair<iterator,bool>(__p.first, __p.second);
  157.     }
  158. #ifdef __STL_MEMBER_TEMPLATES
  159.   template <class _InputIterator>
  160.   void insert(_InputIterator __f, _InputIterator __l) 
  161.     { _M_ht.insert_unique(__f,__l); }
  162. #else
  163.   void insert(const value_type* __f, const value_type* __l) {
  164.     _M_ht.insert_unique(__f,__l);
  165.   }
  166.   void insert(const_iterator __f, const_iterator __l) 
  167.     {_M_ht.insert_unique(__f, __l); }
  168. #endif /*__STL_MEMBER_TEMPLATES */
  169.   pair<iterator, bool> insert_noresize(const value_type& __obj)
  170.   {
  171.     pair<typename _Ht::iterator, bool> __p = 
  172.       _M_ht.insert_unique_noresize(__obj);
  173.     return pair<iterator, bool>(__p.first, __p.second);
  174.   }
  175.   iterator find(const key_type& __key) const { return _M_ht.find(__key); }
  176.   size_type count(const key_type& __key) const { return _M_ht.count(__key); }
  177.   
  178.   pair<iterator, iterator> equal_range(const key_type& __key) const
  179.     { return _M_ht.equal_range(__key); }
  180.   size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
  181.   void erase(iterator __it) { _M_ht.erase(__it); }
  182.   void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
  183.   void clear() { _M_ht.clear(); }
  184. public:
  185.   void resize(size_type __hint) { _M_ht.resize(__hint); }
  186.   size_type bucket_count() const { return _M_ht.bucket_count(); }
  187.   size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
  188.   size_type elems_in_bucket(size_type __n) const
  189.     { return _M_ht.elems_in_bucket(__n); }
  190. };
  191. template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
  192. inline bool 
  193. operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
  194.            const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2)
  195. {
  196.   return __hs1._M_ht == __hs2._M_ht;
  197. }
  198. #ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
  199. template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
  200. inline bool 
  201. operator!=(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
  202.            const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2) {
  203.   return !(__hs1 == __hs2);
  204. }
  205. template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
  206. inline void 
  207. swap(hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
  208.      hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2)
  209. {
  210.   __hs1.swap(__hs2);
  211. }
  212. #endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
  213. template <class _Value,
  214.           class _HashFcn  __STL_DEPENDENT_DEFAULT_TMPL(hash<_Value>),
  215.           class _EqualKey __STL_DEPENDENT_DEFAULT_TMPL(equal_to<_Value>),
  216.           class _Alloc =  __STL_DEFAULT_ALLOCATOR(_Value) >
  217. class hash_multiset;
  218. template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
  219. inline bool 
  220. operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
  221.            const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2);
  222. template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
  223. class hash_multiset
  224. {
  225.   // requirements:
  226.   __STL_CLASS_REQUIRES(_Value, _Assignable);
  227.   __STL_CLASS_UNARY_FUNCTION_CHECK(_HashFcn, size_t, _Value);
  228.   __STL_CLASS_BINARY_FUNCTION_CHECK(_EqualKey, bool, _Value, _Value);
  229. private:
  230.   typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, 
  231.                     _EqualKey, _Alloc> _Ht;
  232.   _Ht _M_ht;
  233. public:
  234.   typedef typename _Ht::key_type key_type;
  235.   typedef typename _Ht::value_type value_type;
  236.   typedef typename _Ht::hasher hasher;
  237.   typedef typename _Ht::key_equal key_equal;
  238.   typedef typename _Ht::size_type size_type;
  239.   typedef typename _Ht::difference_type difference_type;
  240.   typedef typename _Ht::const_pointer pointer;
  241.   typedef typename _Ht::const_pointer const_pointer;
  242.   typedef typename _Ht::const_reference reference;
  243.   typedef typename _Ht::const_reference const_reference;
  244.   typedef typename _Ht::const_iterator iterator;
  245.   typedef typename _Ht::const_iterator const_iterator;
  246.   typedef typename _Ht::allocator_type allocator_type;
  247.   hasher hash_funct() const { return _M_ht.hash_funct(); }
  248.   key_equal key_eq() const { return _M_ht.key_eq(); }
  249.   allocator_type get_allocator() const { return _M_ht.get_allocator(); }
  250. public:
  251.   hash_multiset()
  252.     : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
  253.   explicit hash_multiset(size_type __n)
  254.     : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
  255.   hash_multiset(size_type __n, const hasher& __hf)
  256.     : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
  257.   hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
  258.                 const allocator_type& __a = allocator_type())
  259.     : _M_ht(__n, __hf, __eql, __a) {}
  260. #ifdef __STL_MEMBER_TEMPLATES
  261.   template <class _InputIterator>
  262.   hash_multiset(_InputIterator __f, _InputIterator __l)
  263.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  264.     { _M_ht.insert_equal(__f, __l); }
  265.   template <class _InputIterator>
  266.   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
  267.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  268.     { _M_ht.insert_equal(__f, __l); }
  269.   template <class _InputIterator>
  270.   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
  271.                 const hasher& __hf)
  272.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  273.     { _M_ht.insert_equal(__f, __l); }
  274.   template <class _InputIterator>
  275.   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
  276.                 const hasher& __hf, const key_equal& __eql,
  277.                 const allocator_type& __a = allocator_type())
  278.     : _M_ht(__n, __hf, __eql, __a)
  279.     { _M_ht.insert_equal(__f, __l); }
  280. #else
  281.   hash_multiset(const value_type* __f, const value_type* __l)
  282.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  283.     { _M_ht.insert_equal(__f, __l); }
  284.   hash_multiset(const value_type* __f, const value_type* __l, size_type __n)
  285.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  286.     { _M_ht.insert_equal(__f, __l); }
  287.   hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
  288.                 const hasher& __hf)
  289.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  290.     { _M_ht.insert_equal(__f, __l); }
  291.   hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
  292.                 const hasher& __hf, const key_equal& __eql,
  293.                 const allocator_type& __a = allocator_type())
  294.     : _M_ht(__n, __hf, __eql, __a)
  295.     { _M_ht.insert_equal(__f, __l); }
  296.   hash_multiset(const_iterator __f, const_iterator __l)
  297.     : _M_ht(100, hasher(), key_equal(), allocator_type())
  298.     { _M_ht.insert_equal(__f, __l); }
  299.   hash_multiset(const_iterator __f, const_iterator __l, size_type __n)
  300.     : _M_ht(__n, hasher(), key_equal(), allocator_type())
  301.     { _M_ht.insert_equal(__f, __l); }
  302.   hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
  303.                 const hasher& __hf)
  304.     : _M_ht(__n, __hf, key_equal(), allocator_type())
  305.     { _M_ht.insert_equal(__f, __l); }
  306.   hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
  307.                 const hasher& __hf, const key_equal& __eql,
  308.                 const allocator_type& __a = allocator_type())
  309.     : _M_ht(__n, __hf, __eql, __a)
  310.     { _M_ht.insert_equal(__f, __l); }
  311. #endif /*__STL_MEMBER_TEMPLATES */
  312. public:
  313.   size_type size() const { return _M_ht.size(); }
  314.   size_type max_size() const { return _M_ht.max_size(); }
  315.   bool empty() const { return _M_ht.empty(); }
  316.   void swap(hash_multiset& hs) { _M_ht.swap(hs._M_ht); }
  317. #ifdef __STL_MEMBER_TEMPLATES
  318.   template <class _Val, class _HF, class _EqK, class _Al>  
  319.   friend bool operator== (const hash_multiset<_Val, _HF, _EqK, _Al>&,
  320.                           const hash_multiset<_Val, _HF, _EqK, _Al>&);
  321. #else /* __STL_MEMBER_TEMPLATES */
  322.   friend bool __STD_QUALIFIER
  323.   operator== __STL_NULL_TMPL_ARGS (const hash_multiset&,const hash_multiset&);
  324. #endif /* __STL_MEMBER_TEMPLATES */
  325.   iterator begin() const { return _M_ht.begin(); }
  326.   iterator end() const { return _M_ht.end(); }
  327. public:
  328.   iterator insert(const value_type& __obj)
  329.     { return _M_ht.insert_equal(__obj); }
  330. #ifdef __STL_MEMBER_TEMPLATES
  331.   template <class _InputIterator>
  332.   void insert(_InputIterator __f, _InputIterator __l) 
  333.     { _M_ht.insert_equal(__f,__l); }
  334. #else
  335.   void insert(const value_type* __f, const value_type* __l) {
  336.     _M_ht.insert_equal(__f,__l);
  337.   }
  338.   void insert(const_iterator __f, const_iterator __l) 
  339.     { _M_ht.insert_equal(__f, __l); }
  340. #endif /*__STL_MEMBER_TEMPLATES */
  341.   iterator insert_noresize(const value_type& __obj)
  342.     { return _M_ht.insert_equal_noresize(__obj); }    
  343.   iterator find(const key_type& __key) const { return _M_ht.find(__key); }
  344.   size_type count(const key_type& __key) const { return _M_ht.count(__key); }
  345.   
  346.   pair<iterator, iterator> equal_range(const key_type& __key) const
  347.     { return _M_ht.equal_range(__key); }
  348.   size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
  349.   void erase(iterator __it) { _M_ht.erase(__it); }
  350.   void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
  351.   void clear() { _M_ht.clear(); }
  352. public:
  353.   void resize(size_type __hint) { _M_ht.resize(__hint); }
  354.   size_type bucket_count() const { return _M_ht.bucket_count(); }
  355.   size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
  356.   size_type elems_in_bucket(size_type __n) const
  357.     { return _M_ht.elems_in_bucket(__n); }
  358. };
  359. template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
  360. inline bool 
  361. operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
  362.            const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2)
  363. {
  364.   return __hs1._M_ht == __hs2._M_ht;
  365. }
  366. #ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
  367. template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
  368. inline bool 
  369. operator!=(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
  370.            const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) {
  371.   return !(__hs1 == __hs2);
  372. }
  373. template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
  374. inline void 
  375. swap(hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
  376.      hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) {
  377.   __hs1.swap(__hs2);
  378. }
  379. #endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
  380. // Specialization of insert_iterator so that it will work for hash_set
  381. // and hash_multiset.
  382. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  383. template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
  384. class insert_iterator<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > {
  385. protected:
  386.   typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
  387.   _Container* container;
  388. public:
  389.   typedef _Container          container_type;
  390.   typedef output_iterator_tag iterator_category;
  391.   typedef void                value_type;
  392.   typedef void                difference_type;
  393.   typedef void                pointer;
  394.   typedef void                reference;
  395.   insert_iterator(_Container& __x) : container(&__x) {}
  396.   insert_iterator(_Container& __x, typename _Container::iterator)
  397.     : container(&__x) {}
  398.   insert_iterator<_Container>&
  399.   operator=(const typename _Container::value_type& __value) { 
  400.     container->insert(__value);
  401.     return *this;
  402.   }
  403.   insert_iterator<_Container>& operator*() { return *this; }
  404.   insert_iterator<_Container>& operator++() { return *this; }
  405.   insert_iterator<_Container>& operator++(int) { return *this; }
  406. };
  407. template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
  408. class insert_iterator<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > {
  409. protected:
  410.   typedef hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
  411.   _Container* container;
  412.   typename _Container::iterator iter;
  413. public:
  414.   typedef _Container          container_type;
  415.   typedef output_iterator_tag iterator_category;
  416.   typedef void                value_type;
  417.   typedef void                difference_type;
  418.   typedef void                pointer;
  419.   typedef void                reference;
  420.   insert_iterator(_Container& __x) : container(&__x) {}
  421.   insert_iterator(_Container& __x, typename _Container::iterator)
  422.     : container(&__x) {}
  423.   insert_iterator<_Container>&
  424.   operator=(const typename _Container::value_type& __value) { 
  425.     container->insert(__value);
  426.     return *this;
  427.   }
  428.   insert_iterator<_Container>& operator*() { return *this; }
  429.   insert_iterator<_Container>& operator++() { return *this; }
  430.   insert_iterator<_Container>& operator++(int) { return *this; }
  431. };
  432. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  433. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  434. #pragma reset woff 1174
  435. #pragma reset woff 1375
  436. #endif
  437. __STL_END_NAMESPACE
  438. #endif /* __SGI_STL_INTERNAL_HASH_SET_H */
  439. // Local Variables:
  440. // mode:C++
  441. // End: