/home/ntakagi/work/STLport-5.1.5/stlport/stl/_hash_set.h

Go to the documentation of this file.
00001 /*
00002  *
00003  * Copyright (c) 1994
00004  * Hewlett-Packard Company
00005  *
00006  * Copyright (c) 1996,1997
00007  * Silicon Graphics Computer Systems, Inc.
00008  *
00009  * Copyright (c) 1997
00010  * Moscow Center for SPARC Technology
00011  *
00012  * Copyright (c) 1999
00013  * Boris Fomitchev
00014  *
00015  * This material is provided "as is", with absolutely no warranty expressed
00016  * or implied. Any use is at your own risk.
00017  *
00018  * Permission to use or copy this software for any purpose is hereby granted
00019  * without fee, provided the above notices are retained on all copies.
00020  * Permission to modify the code and to distribute modified code is granted,
00021  * provided the above notices are retained, and a notice that the code was
00022  * modified is included with the above copyright notice.
00023  *
00024  */
00025 
00026 /* NOTE: This is an internal header file, included by other STL headers.
00027  *   You should not attempt to use it directly.
00028  */
00029 
00030 #ifndef _STLP_INTERNAL_HASH_SET_H
00031 #define _STLP_INTERNAL_HASH_SET_H
00032 
00033 #ifndef _STLP_INTERNAL_HASHTABLE_H
00034 #  include <stl/_hashtable.h>
00035 #endif
00036 
00037 _STLP_BEGIN_NAMESPACE
00038 
00039 //Specific iterator traits creation
00040 _STLP_CREATE_HASH_ITERATOR_TRAITS(HashSetTraitsT, Const_traits)
00041 
00042 template <class _Value, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Value>),
00043           _STLP_DFL_TMPL_PARAM(_EqualKey,equal_to<_Value>),
00044           _STLP_DEFAULT_ALLOCATOR_SELECT(_Value) >
00045 class hash_set
00046 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
00047                : public __stlport_class<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> >
00048 #endif
00049 {
00050   typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
00051   //Specific iterator traits creation
00052   typedef _STLP_PRIV _HashSetTraitsT<_Value> _HashSetTraits;
00053 public:
00054   typedef hashtable<_Value, _Value, _HashFcn,
00055                     _HashSetTraits, _STLP_PRIV _Identity<_Value>, _EqualKey, _Alloc> _Ht;
00056 public:
00057   typedef typename _Ht::key_type key_type;
00058   typedef typename _Ht::value_type value_type;
00059   typedef typename _Ht::hasher hasher;
00060   typedef typename _Ht::key_equal key_equal;
00061 
00062   typedef typename _Ht::size_type size_type;
00063   typedef typename _Ht::difference_type difference_type;
00064   typedef typename _Ht::pointer         pointer;
00065   typedef typename _Ht::const_pointer   const_pointer;
00066   typedef typename _Ht::reference       reference;
00067   typedef typename _Ht::const_reference const_reference;
00068 
00069   typedef typename _Ht::iterator iterator;
00070   typedef typename _Ht::const_iterator const_iterator;
00071 
00072   typedef typename _Ht::allocator_type allocator_type;
00073 
00074   hasher hash_funct() const { return _M_ht.hash_funct(); }
00075   key_equal key_eq() const { return _M_ht.key_eq(); }
00076   allocator_type get_allocator() const { return _M_ht.get_allocator(); }
00077 
00078 private:
00079   _Ht _M_ht;
00080   _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
00081 
00082 public:
00083   hash_set()
00084     : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
00085   explicit hash_set(size_type __n)
00086     : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
00087   hash_set(size_type __n, const hasher& __hf)
00088     : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
00089 #if !defined (_STLP_DONT_SUP_DFLT_PARAM)
00090   hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
00091            const allocator_type& __a = allocator_type())
00092 #else
00093   hash_set(size_type __n, const hasher& __hf, const key_equal& __eql)
00094     : _M_ht(__n, __hf, __eql, allocator_type()) {}
00095   hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
00096            const allocator_type& __a)
00097 #endif
00098     : _M_ht(__n, __hf, __eql, __a) {}
00099 
00100   hash_set(__move_source<_Self> src)
00101     : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
00102 
00103 #if defined (_STLP_MEMBER_TEMPLATES)
00104   template <class _InputIterator>
00105   hash_set(_InputIterator __f, _InputIterator __l)
00106     : _M_ht(100, hasher(), key_equal(), allocator_type())
00107     { _M_ht.insert_unique(__f, __l); }
00108   template <class _InputIterator>
00109   hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
00110     : _M_ht(__n, hasher(), key_equal(), allocator_type())
00111     { _M_ht.insert_unique(__f, __l); }
00112   template <class _InputIterator>
00113   hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
00114            const hasher& __hf)
00115     : _M_ht(__n, __hf, key_equal(), allocator_type())
00116     { _M_ht.insert_unique(__f, __l); }
00117   template <class _InputIterator>
00118   hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
00119            const hasher& __hf, const key_equal& __eql,
00120            const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
00121     : _M_ht(__n, __hf, __eql, __a)
00122     { _M_ht.insert_unique(__f, __l); }
00123 #  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
00124   template <class _InputIterator>
00125   hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
00126            const hasher& __hf, const key_equal& __eql)
00127     : _M_ht(__n, __hf, __eql, allocator_type())
00128     { _M_ht.insert_unique(__f, __l); }
00129 #  endif
00130 #else
00131   hash_set(const value_type* __f, const value_type* __l)
00132     : _M_ht(100, hasher(), key_equal(), allocator_type())
00133     { _M_ht.insert_unique(__f, __l); }
00134   hash_set(const value_type* __f, const value_type* __l, size_type __n)
00135     : _M_ht(__n, hasher(), key_equal(), allocator_type())
00136     { _M_ht.insert_unique(__f, __l); }
00137   hash_set(const value_type* __f, const value_type* __l, size_type __n,
00138            const hasher& __hf)
00139     : _M_ht(__n, __hf, key_equal(), allocator_type())
00140     { _M_ht.insert_unique(__f, __l); }
00141   hash_set(const value_type* __f, const value_type* __l, size_type __n,
00142            const hasher& __hf, const key_equal& __eql,
00143            const allocator_type& __a = allocator_type())
00144     : _M_ht(__n, __hf, __eql, __a)
00145     { _M_ht.insert_unique(__f, __l); }
00146 
00147   hash_set(const_iterator __f, const_iterator __l)
00148     : _M_ht(100, hasher(), key_equal(), allocator_type())
00149     { _M_ht.insert_unique(__f, __l); }
00150   hash_set(const_iterator __f, const_iterator __l, size_type __n)
00151     : _M_ht(__n, hasher(), key_equal(), allocator_type())
00152     { _M_ht.insert_unique(__f, __l); }
00153   hash_set(const_iterator __f, const_iterator __l, size_type __n,
00154            const hasher& __hf)
00155     : _M_ht(__n, __hf, key_equal(), allocator_type())
00156     { _M_ht.insert_unique(__f, __l); }
00157   hash_set(const_iterator __f, const_iterator __l, size_type __n,
00158            const hasher& __hf, const key_equal& __eql,
00159            const allocator_type& __a = allocator_type())
00160     : _M_ht(__n, __hf, __eql, __a)
00161     { _M_ht.insert_unique(__f, __l); }
00162 #endif /*_STLP_MEMBER_TEMPLATES */
00163 
00164 public:
00165   size_type size() const { return _M_ht.size(); }
00166   size_type max_size() const { return _M_ht.max_size(); }
00167   bool empty() const { return _M_ht.empty(); }
00168   void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
00169 
00170   iterator begin() { return _M_ht.begin(); }
00171   iterator end() { return _M_ht.end(); }
00172   const_iterator begin() const { return _M_ht.begin(); }
00173   const_iterator end() const { return _M_ht.end(); }
00174 
00175 public:
00176   pair<iterator, bool> insert(const value_type& __obj)
00177   { return _M_ht.insert_unique(__obj); }
00178 #if defined (_STLP_MEMBER_TEMPLATES)
00179   template <class _InputIterator>
00180   void insert(_InputIterator __f, _InputIterator __l)
00181 #else
00182   void insert(const_iterator __f, const_iterator __l)
00183   {_M_ht.insert_unique(__f, __l); }
00184   void insert(const value_type* __f, const value_type* __l)
00185 #endif
00186   { _M_ht.insert_unique(__f,__l); }
00187 
00188   pair<iterator, bool> insert_noresize(const value_type& __obj)
00189   { return _M_ht.insert_unique_noresize(__obj); }
00190 
00191   _STLP_TEMPLATE_FOR_CONT_EXT
00192   iterator find(const _KT& __key) { return _M_ht.find(__key); }
00193   _STLP_TEMPLATE_FOR_CONT_EXT
00194   const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
00195 
00196   _STLP_TEMPLATE_FOR_CONT_EXT
00197   size_type count(const _KT& __key) const { return _M_ht.count(__key); }
00198 
00199   _STLP_TEMPLATE_FOR_CONT_EXT
00200   pair<iterator, iterator> equal_range(const _KT& __key)
00201   { return _M_ht.equal_range(__key); }
00202   _STLP_TEMPLATE_FOR_CONT_EXT
00203   pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
00204   { return _M_ht.equal_range(__key); }
00205 
00206   _STLP_TEMPLATE_FOR_CONT_EXT
00207   size_type erase(const _KT& __key) {return _M_ht.erase(__key); }
00208   void erase(iterator __it) { _M_ht.erase(__it); }
00209   void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
00210   void clear() { _M_ht.clear(); }
00211 
00212 public:
00213   void resize(size_type __hint) { _M_ht.resize(__hint); }
00214   size_type bucket_count() const { return _M_ht.bucket_count(); }
00215   size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
00216   size_type elems_in_bucket(size_type __n) const
00217   { return _M_ht.elems_in_bucket(__n); }
00218 };
00219 
00220 //Specific iterator traits creation
00221 _STLP_CREATE_HASH_ITERATOR_TRAITS(HashMultisetTraitsT, Const_traits)
00222 
00223 template <class _Value, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Value>),
00224           _STLP_DFL_TMPL_PARAM(_EqualKey,equal_to<_Value>),
00225           _STLP_DEFAULT_ALLOCATOR_SELECT(_Value) >
00226 class hash_multiset
00227 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
00228                     : public __stlport_class<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> >
00229 #endif
00230 {
00231   typedef hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
00232   //Specific iterator traits creation
00233   typedef _STLP_PRIV _HashMultisetTraitsT<_Value> _HashMultisetTraits;
00234 public:
00235   typedef hashtable<_Value, _Value, _HashFcn,
00236                     _HashMultisetTraits, _STLP_PRIV _Identity<_Value>, _EqualKey, _Alloc> _Ht;
00237 
00238   typedef typename _Ht::key_type key_type;
00239   typedef typename _Ht::value_type value_type;
00240   typedef typename _Ht::hasher hasher;
00241   typedef typename _Ht::key_equal key_equal;
00242 
00243   typedef typename _Ht::size_type size_type;
00244   typedef typename _Ht::difference_type difference_type;
00245   typedef typename _Ht::pointer       pointer;
00246   typedef typename _Ht::const_pointer const_pointer;
00247   typedef typename _Ht::reference reference;
00248   typedef typename _Ht::const_reference const_reference;
00249 
00250   typedef typename _Ht::iterator iterator;
00251   typedef typename _Ht::const_iterator const_iterator;
00252 
00253   typedef typename _Ht::allocator_type allocator_type;
00254 
00255   hasher hash_funct() const { return _M_ht.hash_funct(); }
00256   key_equal key_eq() const { return _M_ht.key_eq(); }
00257   allocator_type get_allocator() const { return _M_ht.get_allocator(); }
00258 
00259 private:
00260   _Ht _M_ht;
00261   _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
00262 
00263 public:
00264   hash_multiset()
00265     : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
00266   explicit hash_multiset(size_type __n)
00267     : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
00268   hash_multiset(size_type __n, const hasher& __hf)
00269     : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
00270   hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql)
00271     : _M_ht(__n, __hf, __eql, allocator_type()) {}
00272   hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
00273                 const allocator_type& __a)
00274     : _M_ht(__n, __hf, __eql, __a) {}
00275 
00276   hash_multiset(__move_source<_Self> src)
00277     : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
00278 
00279 #if defined (_STLP_MEMBER_TEMPLATES)
00280   template <class _InputIterator>
00281   hash_multiset(_InputIterator __f, _InputIterator __l)
00282     : _M_ht(100, hasher(), key_equal(), allocator_type())
00283     { _M_ht.insert_equal(__f, __l); }
00284   template <class _InputIterator>
00285   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
00286     : _M_ht(__n, hasher(), key_equal(), allocator_type())
00287     { _M_ht.insert_equal(__f, __l); }
00288   template <class _InputIterator>
00289   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
00290                 const hasher& __hf)
00291     : _M_ht(__n, __hf, key_equal(), allocator_type())
00292     { _M_ht.insert_equal(__f, __l); }
00293 
00294   template <class _InputIterator>
00295   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
00296                 const hasher& __hf, const key_equal& __eql,
00297                 const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
00298     : _M_ht(__n, __hf, __eql, __a)
00299     { _M_ht.insert_equal(__f, __l); }
00300 #  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
00301   template <class _InputIterator>
00302   hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
00303                 const hasher& __hf, const key_equal& __eql)
00304     : _M_ht(__n, __hf, __eql, allocator_type())
00305     { _M_ht.insert_equal(__f, __l); }
00306 #  endif
00307 #else
00308   hash_multiset(const value_type* __f, const value_type* __l)
00309     : _M_ht(100, hasher(), key_equal(), allocator_type())
00310     { _M_ht.insert_equal(__f, __l); }
00311   hash_multiset(const value_type* __f, const value_type* __l, size_type __n)
00312     : _M_ht(__n, hasher(), key_equal(), allocator_type())
00313     { _M_ht.insert_equal(__f, __l); }
00314   hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
00315                 const hasher& __hf)
00316     : _M_ht(__n, __hf, key_equal(), allocator_type())
00317     { _M_ht.insert_equal(__f, __l); }
00318   hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
00319                 const hasher& __hf, const key_equal& __eql,
00320                 const allocator_type& __a = allocator_type())
00321     : _M_ht(__n, __hf, __eql, __a)
00322     { _M_ht.insert_equal(__f, __l); }
00323 
00324   hash_multiset(const_iterator __f, const_iterator __l)
00325     : _M_ht(100, hasher(), key_equal(), allocator_type())
00326     { _M_ht.insert_equal(__f, __l); }
00327   hash_multiset(const_iterator __f, const_iterator __l, size_type __n)
00328     : _M_ht(__n, hasher(), key_equal(), allocator_type())
00329     { _M_ht.insert_equal(__f, __l); }
00330   hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
00331                 const hasher& __hf)
00332     : _M_ht(__n, __hf, key_equal(), allocator_type())
00333     { _M_ht.insert_equal(__f, __l); }
00334   hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
00335                 const hasher& __hf, const key_equal& __eql,
00336                 const allocator_type& __a = allocator_type())
00337     : _M_ht(__n, __hf, __eql, __a)
00338     { _M_ht.insert_equal(__f, __l); }
00339 #endif /*_STLP_MEMBER_TEMPLATES */
00340 
00341 public:
00342   size_type size() const { return _M_ht.size(); }
00343   size_type max_size() const { return _M_ht.max_size(); }
00344   bool empty() const { return _M_ht.empty(); }
00345   void swap(_Self& hs) { _M_ht.swap(hs._M_ht); }
00346 
00347   iterator begin() { return _M_ht.begin(); }
00348   iterator end() { return _M_ht.end(); }
00349   const_iterator begin() const { return _M_ht.begin(); }
00350   const_iterator end() const { return _M_ht.end(); }
00351 
00352 public:
00353   iterator insert(const value_type& __obj) { return _M_ht.insert_equal(__obj); }
00354 #if defined (_STLP_MEMBER_TEMPLATES)
00355   template <class _InputIterator>
00356   void insert(_InputIterator __f, _InputIterator __l)
00357   { _M_ht.insert_equal(__f,__l); }
00358 #else
00359   void insert(const value_type* __f, const value_type* __l)
00360   { _M_ht.insert_equal(__f,__l); }
00361   void insert(const_iterator __f, const_iterator __l)
00362   { _M_ht.insert_equal(__f, __l); }
00363 #endif /*_STLP_MEMBER_TEMPLATES */
00364   iterator insert_noresize(const value_type& __obj)
00365   { return _M_ht.insert_equal_noresize(__obj); }
00366 
00367   _STLP_TEMPLATE_FOR_CONT_EXT
00368   iterator find(const _KT& __key) { return _M_ht.find(__key); }
00369 
00370   _STLP_TEMPLATE_FOR_CONT_EXT
00371   const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
00372 
00373   _STLP_TEMPLATE_FOR_CONT_EXT
00374   size_type count(const _KT& __key) const { return _M_ht.count(__key); }
00375 
00376   _STLP_TEMPLATE_FOR_CONT_EXT
00377   pair<iterator, iterator> equal_range(const _KT& __key)
00378   { return _M_ht.equal_range(__key); }
00379   _STLP_TEMPLATE_FOR_CONT_EXT
00380   pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
00381   { return _M_ht.equal_range(__key); }
00382 
00383   _STLP_TEMPLATE_FOR_CONT_EXT
00384   size_type erase(const _KT& __key) {return _M_ht.erase(__key); }
00385   void erase(iterator __it) { _M_ht.erase(__it); }
00386   void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
00387   void clear() { _M_ht.clear(); }
00388 
00389 public:
00390   void resize(size_type __hint) { _M_ht.resize(__hint); }
00391   size_type bucket_count() const { return _M_ht.bucket_count(); }
00392   size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
00393   size_type elems_in_bucket(size_type __n) const
00394   { return _M_ht.elems_in_bucket(__n); }
00395 };
00396 
00397 #define _STLP_TEMPLATE_HEADER template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00398 #define _STLP_TEMPLATE_CONTAINER hash_set<_Value,_HashFcn,_EqualKey,_Alloc>
00399 
00400 #include <stl/_relops_hash_cont.h>
00401 
00402 #undef _STLP_TEMPLATE_CONTAINER
00403 #define _STLP_TEMPLATE_CONTAINER hash_multiset<_Value,_HashFcn,_EqualKey,_Alloc>
00404 #include <stl/_relops_hash_cont.h>
00405 
00406 #undef _STLP_TEMPLATE_CONTAINER
00407 #undef _STLP_TEMPLATE_HEADER
00408 
00409 // Specialization of insert_iterator so that it will work for hash_set
00410 // and hash_multiset.
00411 
00412 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
00413 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00414 struct __move_traits<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > :
00415   _STLP_PRIV __move_traits_aux<typename hash_set<_Value, _HashFcn, _EqualKey, _Alloc>::_Ht>
00416 {};
00417 
00418 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00419 struct __move_traits<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > :
00420   _STLP_PRIV __move_traits_aux<typename hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>::_Ht>
00421 {};
00422 
00423 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00424 class insert_iterator<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > {
00425 protected:
00426   typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
00427   _Container* container;
00428 public:
00429   typedef _Container          container_type;
00430   typedef output_iterator_tag iterator_category;
00431   typedef void                value_type;
00432   typedef void                difference_type;
00433   typedef void                pointer;
00434   typedef void                reference;
00435 
00436   insert_iterator(_Container& __x) : container(&__x) {}
00437   insert_iterator(_Container& __x, typename _Container::iterator)
00438     : container(&__x) {}
00439   insert_iterator<_Container>&
00440   operator=(const typename _Container::value_type& __val) {
00441     container->insert(__val);
00442     return *this;
00443   }
00444   insert_iterator<_Container>& operator*() { return *this; }
00445   insert_iterator<_Container>& operator++() { return *this; }
00446   insert_iterator<_Container>& operator++(int) { return *this; }
00447 };
00448 
00449 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00450 class insert_iterator<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > {
00451 protected:
00452   typedef hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
00453   _Container* container;
00454   typename _Container::iterator iter;
00455 public:
00456   typedef _Container          container_type;
00457   typedef output_iterator_tag iterator_category;
00458   typedef void                value_type;
00459   typedef void                difference_type;
00460   typedef void                pointer;
00461   typedef void                reference;
00462 
00463   insert_iterator(_Container& __x) : container(&__x) {}
00464   insert_iterator(_Container& __x, typename _Container::iterator)
00465     : container(&__x) {}
00466   insert_iterator<_Container>&
00467   operator=(const typename _Container::value_type& __val) {
00468     container->insert(__val);
00469     return *this;
00470   }
00471   insert_iterator<_Container>& operator*() { return *this; }
00472   insert_iterator<_Container>& operator++() { return *this; }
00473   insert_iterator<_Container>& operator++(int) { return *this; }
00474 };
00475 #endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
00476 
00477 _STLP_END_NAMESPACE
00478 
00479 #endif /* _STLP_INTERNAL_HASH_SET_H */
00480 
00481 // Local Variables:
00482 // mode:C++
00483 // End:



Generated on Mon Mar 10 15:32:24 2008 by  doxygen 1.5.1