epoc32/include/stdapis/stlportv5/stl/_hash_set.h
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:33:34 +0100
branchSymbian3
changeset 4 837f303aceeb
permissions -rw-r--r--
Current Symbian^3 public API header files (from PDK 3.0.h)
This is the epoc32/include tree with the "platform" subtrees removed, and
all but a selected few mbg and rsg files removed.
     1 /*
     2  *
     3  * Copyright (c) 1994
     4  * Hewlett-Packard Company
     5  *
     6  * Copyright (c) 1996,1997
     7  * Silicon Graphics Computer Systems, Inc.
     8  *
     9  * Copyright (c) 1997
    10  * Moscow Center for SPARC Technology
    11  *
    12  * Copyright (c) 1999
    13  * Boris Fomitchev
    14  *
    15  * This material is provided "as is", with absolutely no warranty expressed
    16  * or implied. Any use is at your own risk.
    17  *
    18  * Permission to use or copy this software for any purpose is hereby granted
    19  * without fee, provided the above notices are retained on all copies.
    20  * Permission to modify the code and to distribute modified code is granted,
    21  * provided the above notices are retained, and a notice that the code was
    22  * modified is included with the above copyright notice.
    23  *
    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 
    30 #ifndef _STLP_INTERNAL_HASH_SET_H
    31 #define _STLP_INTERNAL_HASH_SET_H
    32 
    33 #ifndef _STLP_INTERNAL_HASHTABLE_H
    34 #  include <stl/_hashtable.h>
    35 #endif
    36 
    37 _STLP_BEGIN_NAMESPACE
    38 
    39 //Specific iterator traits creation
    40 _STLP_CREATE_HASH_ITERATOR_TRAITS(HashSetTraitsT, Const_traits)
    41 
    42 template <class _Value, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Value>),
    43           _STLP_DFL_TMPL_PARAM(_EqualKey,equal_to<_Value>),
    44           _STLP_DEFAULT_ALLOCATOR_SELECT(_Value) >
    45 class hash_set
    46 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
    47                : public __stlport_class<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> >
    48 #endif
    49 {
    50   typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
    51   //Specific iterator traits creation
    52   typedef _STLP_PRIV _HashSetTraitsT<_Value> _HashSetTraits;
    53 public:
    54   typedef hashtable<_Value, _Value, _HashFcn,
    55                     _HashSetTraits, _STLP_PRIV _Identity<_Value>, _EqualKey, _Alloc> _Ht;
    56 public:
    57   typedef typename _Ht::key_type key_type;
    58   typedef typename _Ht::value_type value_type;
    59   typedef typename _Ht::hasher hasher;
    60   typedef typename _Ht::key_equal key_equal;
    61 
    62   typedef typename _Ht::size_type size_type;
    63   typedef typename _Ht::difference_type difference_type;
    64   typedef typename _Ht::pointer         pointer;
    65   typedef typename _Ht::const_pointer   const_pointer;
    66   typedef typename _Ht::reference       reference;
    67   typedef typename _Ht::const_reference const_reference;
    68 
    69   typedef typename _Ht::iterator iterator;
    70   typedef typename _Ht::const_iterator const_iterator;
    71 
    72   typedef typename _Ht::allocator_type allocator_type;
    73 
    74   hasher hash_funct() const { return _M_ht.hash_funct(); }
    75   key_equal key_eq() const { return _M_ht.key_eq(); }
    76   allocator_type get_allocator() const { return _M_ht.get_allocator(); }
    77 
    78 private:
    79   _Ht _M_ht;
    80   _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
    81 
    82 public:
    83   hash_set()
    84     : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
    85   explicit hash_set(size_type __n)
    86     : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
    87   hash_set(size_type __n, const hasher& __hf)
    88     : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
    89 #if !defined (_STLP_DONT_SUP_DFLT_PARAM)
    90   hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
    91            const allocator_type& __a = allocator_type())
    92 #else
    93   hash_set(size_type __n, const hasher& __hf, const key_equal& __eql)
    94     : _M_ht(__n, __hf, __eql, allocator_type()) {}
    95   hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
    96            const allocator_type& __a)
    97 #endif
    98     : _M_ht(__n, __hf, __eql, __a) {}
    99 
   100   hash_set(__move_source<_Self> src)
   101     : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
   102 
   103 #if defined (_STLP_MEMBER_TEMPLATES)
   104   template <class _InputIterator>
   105   hash_set(_InputIterator __f, _InputIterator __l)
   106     : _M_ht(100, hasher(), key_equal(), allocator_type())
   107     { _M_ht.insert_unique(__f, __l); }
   108   template <class _InputIterator>
   109   hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
   110     : _M_ht(__n, hasher(), key_equal(), allocator_type())
   111     { _M_ht.insert_unique(__f, __l); }
   112   template <class _InputIterator>
   113   hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
   114            const hasher& __hf)
   115     : _M_ht(__n, __hf, key_equal(), allocator_type())
   116     { _M_ht.insert_unique(__f, __l); }
   117   template <class _InputIterator>
   118   hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
   119            const hasher& __hf, const key_equal& __eql,
   120            const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
   121     : _M_ht(__n, __hf, __eql, __a)
   122     { _M_ht.insert_unique(__f, __l); }
   123 #  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
   124   template <class _InputIterator>
   125   hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
   126            const hasher& __hf, const key_equal& __eql)
   127     : _M_ht(__n, __hf, __eql, allocator_type())
   128     { _M_ht.insert_unique(__f, __l); }
   129 #  endif
   130 #else
   131   hash_set(const value_type* __f, const value_type* __l)
   132     : _M_ht(100, hasher(), key_equal(), allocator_type())
   133     { _M_ht.insert_unique(__f, __l); }
   134   hash_set(const value_type* __f, const value_type* __l, size_type __n)
   135     : _M_ht(__n, hasher(), key_equal(), allocator_type())
   136     { _M_ht.insert_unique(__f, __l); }
   137   hash_set(const value_type* __f, const value_type* __l, size_type __n,
   138            const hasher& __hf)
   139     : _M_ht(__n, __hf, key_equal(), allocator_type())
   140     { _M_ht.insert_unique(__f, __l); }
   141   hash_set(const value_type* __f, const value_type* __l, size_type __n,
   142            const hasher& __hf, const key_equal& __eql,
   143            const allocator_type& __a = allocator_type())
   144     : _M_ht(__n, __hf, __eql, __a)
   145     { _M_ht.insert_unique(__f, __l); }
   146 
   147   hash_set(const_iterator __f, const_iterator __l)
   148     : _M_ht(100, hasher(), key_equal(), allocator_type())
   149     { _M_ht.insert_unique(__f, __l); }
   150   hash_set(const_iterator __f, const_iterator __l, size_type __n)
   151     : _M_ht(__n, hasher(), key_equal(), allocator_type())
   152     { _M_ht.insert_unique(__f, __l); }
   153   hash_set(const_iterator __f, const_iterator __l, size_type __n,
   154            const hasher& __hf)
   155     : _M_ht(__n, __hf, key_equal(), allocator_type())
   156     { _M_ht.insert_unique(__f, __l); }
   157   hash_set(const_iterator __f, const_iterator __l, size_type __n,
   158            const hasher& __hf, const key_equal& __eql,
   159            const allocator_type& __a = allocator_type())
   160     : _M_ht(__n, __hf, __eql, __a)
   161     { _M_ht.insert_unique(__f, __l); }
   162 #endif /*_STLP_MEMBER_TEMPLATES */
   163 
   164 public:
   165   size_type size() const { return _M_ht.size(); }
   166   size_type max_size() const { return _M_ht.max_size(); }
   167   bool empty() const { return _M_ht.empty(); }
   168   void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
   169 
   170   iterator begin() { return _M_ht.begin(); }
   171   iterator end() { return _M_ht.end(); }
   172   const_iterator begin() const { return _M_ht.begin(); }
   173   const_iterator end() const { return _M_ht.end(); }
   174 
   175 public:
   176   pair<iterator, bool> insert(const value_type& __obj)
   177   { return _M_ht.insert_unique(__obj); }
   178 #if defined (_STLP_MEMBER_TEMPLATES)
   179   template <class _InputIterator>
   180   void insert(_InputIterator __f, _InputIterator __l)
   181 #else
   182   void insert(const_iterator __f, const_iterator __l)
   183   {_M_ht.insert_unique(__f, __l); }
   184   void insert(const value_type* __f, const value_type* __l)
   185 #endif
   186   { _M_ht.insert_unique(__f,__l); }
   187 
   188   pair<iterator, bool> insert_noresize(const value_type& __obj)
   189   { return _M_ht.insert_unique_noresize(__obj); }
   190 
   191   _STLP_TEMPLATE_FOR_CONT_EXT
   192   iterator find(const _KT& __key) { return _M_ht.find(__key); }
   193   _STLP_TEMPLATE_FOR_CONT_EXT
   194   const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
   195 
   196   _STLP_TEMPLATE_FOR_CONT_EXT
   197   size_type count(const _KT& __key) const { return _M_ht.count(__key); }
   198 
   199   _STLP_TEMPLATE_FOR_CONT_EXT
   200   pair<iterator, iterator> equal_range(const _KT& __key)
   201   { return _M_ht.equal_range(__key); }
   202   _STLP_TEMPLATE_FOR_CONT_EXT
   203   pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
   204   { return _M_ht.equal_range(__key); }
   205 
   206   _STLP_TEMPLATE_FOR_CONT_EXT
   207   size_type erase(const _KT& __key) {return _M_ht.erase(__key); }
   208   void erase(iterator __it) { _M_ht.erase(__it); }
   209   void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
   210   void clear() { _M_ht.clear(); }
   211 
   212 public:
   213   void resize(size_type __hint) { _M_ht.resize(__hint); }
   214   size_type bucket_count() const { return _M_ht.bucket_count(); }
   215   size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
   216   size_type elems_in_bucket(size_type __n) const
   217   { return _M_ht.elems_in_bucket(__n); }
   218 };
   219 
   220 //Specific iterator traits creation
   221 _STLP_CREATE_HASH_ITERATOR_TRAITS(HashMultisetTraitsT, Const_traits)
   222 
   223 template <class _Value, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Value>),
   224           _STLP_DFL_TMPL_PARAM(_EqualKey,equal_to<_Value>),
   225           _STLP_DEFAULT_ALLOCATOR_SELECT(_Value) >
   226 class hash_multiset
   227 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
   228                     : public __stlport_class<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> >
   229 #endif
   230 {
   231   typedef hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
   232   //Specific iterator traits creation
   233   typedef _STLP_PRIV _HashMultisetTraitsT<_Value> _HashMultisetTraits;
   234 public:
   235   typedef hashtable<_Value, _Value, _HashFcn,
   236                     _HashMultisetTraits, _STLP_PRIV _Identity<_Value>, _EqualKey, _Alloc> _Ht;
   237 
   238   typedef typename _Ht::key_type key_type;
   239   typedef typename _Ht::value_type value_type;
   240   typedef typename _Ht::hasher hasher;
   241   typedef typename _Ht::key_equal key_equal;
   242 
   243   typedef typename _Ht::size_type size_type;
   244   typedef typename _Ht::difference_type difference_type;
   245   typedef typename _Ht::pointer       pointer;
   246   typedef typename _Ht::const_pointer const_pointer;
   247   typedef typename _Ht::reference reference;
   248   typedef typename _Ht::const_reference const_reference;
   249 
   250   typedef typename _Ht::iterator iterator;
   251   typedef typename _Ht::const_iterator const_iterator;
   252 
   253   typedef typename _Ht::allocator_type allocator_type;
   254 
   255   hasher hash_funct() const { return _M_ht.hash_funct(); }
   256   key_equal key_eq() const { return _M_ht.key_eq(); }
   257   allocator_type get_allocator() const { return _M_ht.get_allocator(); }
   258 
   259 private:
   260   _Ht _M_ht;
   261   _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
   262 
   263 public:
   264   hash_multiset()
   265     : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
   266   explicit hash_multiset(size_type __n)
   267     : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
   268   hash_multiset(size_type __n, const hasher& __hf)
   269     : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
   270   hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql)
   271     : _M_ht(__n, __hf, __eql, allocator_type()) {}
   272   hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
   273                 const allocator_type& __a)
   274     : _M_ht(__n, __hf, __eql, __a) {}
   275 
   276   hash_multiset(__move_source<_Self> src)
   277     : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
   278 
   279 #if defined (_STLP_MEMBER_TEMPLATES)
   280   template <class _InputIterator>
   281   hash_multiset(_InputIterator __f, _InputIterator __l)
   282     : _M_ht(100, hasher(), key_equal(), allocator_type())
   283     { _M_ht.insert_equal(__f, __l); }
   284   template <class _InputIterator>
   285   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
   286     : _M_ht(__n, hasher(), key_equal(), allocator_type())
   287     { _M_ht.insert_equal(__f, __l); }
   288   template <class _InputIterator>
   289   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
   290                 const hasher& __hf)
   291     : _M_ht(__n, __hf, key_equal(), allocator_type())
   292     { _M_ht.insert_equal(__f, __l); }
   293 
   294   template <class _InputIterator>
   295   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
   296                 const hasher& __hf, const key_equal& __eql,
   297                 const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
   298     : _M_ht(__n, __hf, __eql, __a)
   299     { _M_ht.insert_equal(__f, __l); }
   300 #  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
   301   template <class _InputIterator>
   302   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
   303                 const hasher& __hf, const key_equal& __eql)
   304     : _M_ht(__n, __hf, __eql, allocator_type())
   305     { _M_ht.insert_equal(__f, __l); }
   306 #  endif
   307 #else
   308   hash_multiset(const value_type* __f, const value_type* __l)
   309     : _M_ht(100, hasher(), key_equal(), allocator_type())
   310     { _M_ht.insert_equal(__f, __l); }
   311   hash_multiset(const value_type* __f, const value_type* __l, size_type __n)
   312     : _M_ht(__n, hasher(), key_equal(), allocator_type())
   313     { _M_ht.insert_equal(__f, __l); }
   314   hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
   315                 const hasher& __hf)
   316     : _M_ht(__n, __hf, key_equal(), allocator_type())
   317     { _M_ht.insert_equal(__f, __l); }
   318   hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
   319                 const hasher& __hf, const key_equal& __eql,
   320                 const allocator_type& __a = allocator_type())
   321     : _M_ht(__n, __hf, __eql, __a)
   322     { _M_ht.insert_equal(__f, __l); }
   323 
   324   hash_multiset(const_iterator __f, const_iterator __l)
   325     : _M_ht(100, hasher(), key_equal(), allocator_type())
   326     { _M_ht.insert_equal(__f, __l); }
   327   hash_multiset(const_iterator __f, const_iterator __l, size_type __n)
   328     : _M_ht(__n, hasher(), key_equal(), allocator_type())
   329     { _M_ht.insert_equal(__f, __l); }
   330   hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
   331                 const hasher& __hf)
   332     : _M_ht(__n, __hf, key_equal(), allocator_type())
   333     { _M_ht.insert_equal(__f, __l); }
   334   hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
   335                 const hasher& __hf, const key_equal& __eql,
   336                 const allocator_type& __a = allocator_type())
   337     : _M_ht(__n, __hf, __eql, __a)
   338     { _M_ht.insert_equal(__f, __l); }
   339 #endif /*_STLP_MEMBER_TEMPLATES */
   340 
   341 public:
   342   size_type size() const { return _M_ht.size(); }
   343   size_type max_size() const { return _M_ht.max_size(); }
   344   bool empty() const { return _M_ht.empty(); }
   345   void swap(_Self& hs) { _M_ht.swap(hs._M_ht); }
   346 
   347   iterator begin() { return _M_ht.begin(); }
   348   iterator end() { return _M_ht.end(); }
   349   const_iterator begin() const { return _M_ht.begin(); }
   350   const_iterator end() const { return _M_ht.end(); }
   351 
   352 public:
   353   iterator insert(const value_type& __obj) { return _M_ht.insert_equal(__obj); }
   354 #if defined (_STLP_MEMBER_TEMPLATES)
   355   template <class _InputIterator>
   356   void insert(_InputIterator __f, _InputIterator __l)
   357   { _M_ht.insert_equal(__f,__l); }
   358 #else
   359   void insert(const value_type* __f, const value_type* __l)
   360   { _M_ht.insert_equal(__f,__l); }
   361   void insert(const_iterator __f, const_iterator __l)
   362   { _M_ht.insert_equal(__f, __l); }
   363 #endif /*_STLP_MEMBER_TEMPLATES */
   364   iterator insert_noresize(const value_type& __obj)
   365   { return _M_ht.insert_equal_noresize(__obj); }
   366 
   367   _STLP_TEMPLATE_FOR_CONT_EXT
   368   iterator find(const _KT& __key) { return _M_ht.find(__key); }
   369 
   370   _STLP_TEMPLATE_FOR_CONT_EXT
   371   const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
   372 
   373   _STLP_TEMPLATE_FOR_CONT_EXT
   374   size_type count(const _KT& __key) const { return _M_ht.count(__key); }
   375 
   376   _STLP_TEMPLATE_FOR_CONT_EXT
   377   pair<iterator, iterator> equal_range(const _KT& __key)
   378   { return _M_ht.equal_range(__key); }
   379   _STLP_TEMPLATE_FOR_CONT_EXT
   380   pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
   381   { return _M_ht.equal_range(__key); }
   382 
   383   _STLP_TEMPLATE_FOR_CONT_EXT
   384   size_type erase(const _KT& __key) {return _M_ht.erase(__key); }
   385   void erase(iterator __it) { _M_ht.erase(__it); }
   386   void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
   387   void clear() { _M_ht.clear(); }
   388 
   389 public:
   390   void resize(size_type __hint) { _M_ht.resize(__hint); }
   391   size_type bucket_count() const { return _M_ht.bucket_count(); }
   392   size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
   393   size_type elems_in_bucket(size_type __n) const
   394   { return _M_ht.elems_in_bucket(__n); }
   395 };
   396 
   397 #define _STLP_TEMPLATE_HEADER template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
   398 #define _STLP_TEMPLATE_CONTAINER hash_set<_Value,_HashFcn,_EqualKey,_Alloc>
   399 
   400 #include <stl/_relops_hash_cont.h>
   401 
   402 #undef _STLP_TEMPLATE_CONTAINER
   403 #define _STLP_TEMPLATE_CONTAINER hash_multiset<_Value,_HashFcn,_EqualKey,_Alloc>
   404 #include <stl/_relops_hash_cont.h>
   405 
   406 #undef _STLP_TEMPLATE_CONTAINER
   407 #undef _STLP_TEMPLATE_HEADER
   408 
   409 // Specialization of insert_iterator so that it will work for hash_set
   410 // and hash_multiset.
   411 
   412 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
   413 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
   414 struct __move_traits<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > :
   415   _STLP_PRIV __move_traits_aux<typename hash_set<_Value, _HashFcn, _EqualKey, _Alloc>::_Ht>
   416 {};
   417 
   418 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
   419 struct __move_traits<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > :
   420   _STLP_PRIV __move_traits_aux<typename hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>::_Ht>
   421 {};
   422 
   423 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
   424 class insert_iterator<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > {
   425 protected:
   426   typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
   427   _Container* container;
   428 public:
   429   typedef _Container          container_type;
   430   typedef output_iterator_tag iterator_category;
   431   typedef void                value_type;
   432   typedef void                difference_type;
   433   typedef void                pointer;
   434   typedef void                reference;
   435 
   436   insert_iterator(_Container& __x) : container(&__x) {}
   437   insert_iterator(_Container& __x, typename _Container::iterator)
   438     : container(&__x) {}
   439   insert_iterator<_Container>&
   440   operator=(const typename _Container::value_type& __val) {
   441     container->insert(__val);
   442     return *this;
   443   }
   444   insert_iterator<_Container>& operator*() { return *this; }
   445   insert_iterator<_Container>& operator++() { return *this; }
   446   insert_iterator<_Container>& operator++(int) { return *this; }
   447 };
   448 
   449 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
   450 class insert_iterator<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > {
   451 protected:
   452   typedef hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
   453   _Container* container;
   454   typename _Container::iterator iter;
   455 public:
   456   typedef _Container          container_type;
   457   typedef output_iterator_tag iterator_category;
   458   typedef void                value_type;
   459   typedef void                difference_type;
   460   typedef void                pointer;
   461   typedef void                reference;
   462 
   463   insert_iterator(_Container& __x) : container(&__x) {}
   464   insert_iterator(_Container& __x, typename _Container::iterator)
   465     : container(&__x) {}
   466   insert_iterator<_Container>&
   467   operator=(const typename _Container::value_type& __val) {
   468     container->insert(__val);
   469     return *this;
   470   }
   471   insert_iterator<_Container>& operator*() { return *this; }
   472   insert_iterator<_Container>& operator++() { return *this; }
   473   insert_iterator<_Container>& operator++(int) { return *this; }
   474 };
   475 #endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
   476 
   477 _STLP_END_NAMESPACE
   478 
   479 #endif /* _STLP_INTERNAL_HASH_SET_H */
   480 
   481 // Local Variables:
   482 // mode:C++
   483 // End: