libstdc++-v3/include/tr1/unordered_set.h

   1 // TR1 unordered_set implementation -*- C++ -*-
   2
   3 // Copyright (C) 2010-2023 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file tr1/unordered_set.h
  26  *  This is an internal header file, included by other library headers.
  27  *  Do not attempt to use it directly. @headername{tr1/unordered_set}
  28  */
  29
  30 namespace std _GLIBCXX_VISIBILITY(default)
  31 {
  32 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  33
  34 namespace tr1
  35 {
  36   // NB: When we get typedef templates these class definitions
  37   // will be unnecessary.
  38   template<class _Value,
  39            class _Hash = hash<_Value>,
  40            class _Pred = std::equal_to<_Value>,
  41            class _Alloc = std::allocator<_Value>,
  42            bool __cache_hash_code = false>
  43     class __unordered_set
  44     : public _Hashtable<_Value, _Value, _Alloc,
  45                         std::_Identity<_Value>, _Pred,
  46                         _Hash, __detail::_Mod_range_hashing,
  47                         __detail::_Default_ranged_hash,
  48                         __detail::_Prime_rehash_policy,
  49                         __cache_hash_code, true, true>
  50     {
  51       typedef _Hashtable<_Value, _Value, _Alloc,
  52                          std::_Identity<_Value>, _Pred,
  53                          _Hash, __detail::_Mod_range_hashing,
  54                          __detail::_Default_ranged_hash,
  55                          __detail::_Prime_rehash_policy,
  56                          __cache_hash_code, true, true>
  57         _Base;
  58
  59     public:
  60       typedef typename _Base::size_type       size_type;
  61       typedef typename _Base::hasher          hasher;
  62       typedef typename _Base::key_equal       key_equal;
  63       typedef typename _Base::allocator_type  allocator_type;
  64
  65       explicit
  66       __unordered_set(size_type __n = 10,
  67                       const hasher& __hf = hasher(),
  68                       const key_equal& __eql = key_equal(),
  69                       const allocator_type& __a = allocator_type())
  70       : _Base(__n, __hf, __detail::_Mod_range_hashing(),
  71               __detail::_Default_ranged_hash(), __eql,
  72               std::_Identity<_Value>(), __a)
  73       { }
  74
  75       template<typename _InputIterator>
  76         __unordered_set(_InputIterator __f, _InputIterator __l,
  77                         size_type __n = 10,
  78                         const hasher& __hf = hasher(),
  79                         const key_equal& __eql = key_equal(),
  80                         const allocator_type& __a = allocator_type())
  81         : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
  82                 __detail::_Default_ranged_hash(), __eql,
  83                 std::_Identity<_Value>(), __a)
  84         { }
  85     };
  86
  87   template<class _Value,
  88            class _Hash = hash<_Value>,
  89            class _Pred = std::equal_to<_Value>,
  90            class _Alloc = std::allocator<_Value>,
  91            bool __cache_hash_code = false>
  92     class __unordered_multiset
  93     : public _Hashtable<_Value, _Value, _Alloc,
  94                         std::_Identity<_Value>, _Pred,
  95                         _Hash, __detail::_Mod_range_hashing,
  96                         __detail::_Default_ranged_hash,
  97                         __detail::_Prime_rehash_policy,
  98                         __cache_hash_code, true, false>
  99     {
 100       typedef _Hashtable<_Value, _Value, _Alloc,
 101                          std::_Identity<_Value>, _Pred,
 102                          _Hash, __detail::_Mod_range_hashing,
 103                          __detail::_Default_ranged_hash,
 104                          __detail::_Prime_rehash_policy,
 105                          __cache_hash_code, true, false>
 106         _Base;
 107
 108     public:
 109       typedef typename _Base::size_type       size_type;
 110       typedef typename _Base::hasher          hasher;
 111       typedef typename _Base::key_equal       key_equal;
 112       typedef typename _Base::allocator_type  allocator_type;
 113
 114       explicit
 115       __unordered_multiset(size_type __n = 10,
 116                            const hasher& __hf = hasher(),
 117                            const key_equal& __eql = key_equal(),
 118                            const allocator_type& __a = allocator_type())
 119       : _Base(__n, __hf, __detail::_Mod_range_hashing(),
 120               __detail::_Default_ranged_hash(), __eql,
 121               std::_Identity<_Value>(), __a)
 122       { }
 123
 124
 125       template<typename _InputIterator>
 126         __unordered_multiset(_InputIterator __f, _InputIterator __l,
 127                              typename _Base::size_type __n = 0,
 128                              const hasher& __hf = hasher(),
 129                              const key_equal& __eql = key_equal(),
 130                              const allocator_type& __a = allocator_type())
 131         : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
 132                 __detail::_Default_ranged_hash(), __eql,
 133                 std::_Identity<_Value>(), __a)
 134         { }
 135     };
 136
 137   template<class _Value, class _Hash, class _Pred, class _Alloc,
 138            bool __cache_hash_code>
 139     inline void
 140     swap(__unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __x,
 141          __unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __y)
 142     { __x.swap(__y); }
 143
 144   template<class _Value, class _Hash, class _Pred, class _Alloc,
 145            bool __cache_hash_code>
 146     inline void
 147     swap(__unordered_multiset<_Value, _Hash, _Pred,
 148          _Alloc, __cache_hash_code>& __x,
 149          __unordered_multiset<_Value, _Hash, _Pred,
 150          _Alloc, __cache_hash_code>& __y)
 151     { __x.swap(__y); }
 152
 153
 154   /**
 155    *  @brief A standard container composed of unique keys (containing
 156    *  at most one of each key value) in which the elements' keys are
 157    *  the elements themselves.
 158    *
 159    *  @ingroup unordered_associative_containers
 160    *
 161    *  Meets the requirements of a <a href="tables.html#65">container</a>, and
 162    *  <a href="tables.html#xx">unordered associative container</a>
 163    *
 164    *  @param  Value  Type of key objects.
 165    *  @param  Hash  Hashing function object type, defaults to hash<Value>.
 166    *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
 167    *  @param  Alloc  Allocator type, defaults to allocator<Key>.
 168    */
 169   template<class _Value,
 170            class _Hash = hash<_Value>,
 171            class _Pred = std::equal_to<_Value>,
 172            class _Alloc = std::allocator<_Value> >
 173     class unordered_set
 174     : public __unordered_set<_Value, _Hash, _Pred, _Alloc>
 175     {
 176       typedef __unordered_set<_Value, _Hash, _Pred, _Alloc>  _Base;
 177
 178     public:
 179       typedef typename _Base::value_type      value_type;
 180       typedef typename _Base::size_type       size_type;
 181       typedef typename _Base::hasher          hasher;
 182       typedef typename _Base::key_equal       key_equal;
 183       typedef typename _Base::allocator_type  allocator_type;
 184
 185       explicit
 186       unordered_set(size_type __n = 10,
 187                     const hasher& __hf = hasher(),
 188                     const key_equal& __eql = key_equal(),
 189                     const allocator_type& __a = allocator_type())
 190       : _Base(__n, __hf, __eql, __a)
 191       { }
 192
 193       template<typename _InputIterator>
 194         unordered_set(_InputIterator __f, _InputIterator __l,
 195                       size_type __n = 10,
 196                       const hasher& __hf = hasher(),
 197                       const key_equal& __eql = key_equal(),
 198                       const allocator_type& __a = allocator_type())
 199         : _Base(__f, __l, __n, __hf, __eql, __a)
 200         { }
 201     };
 202
 203   /**
 204    *  @brief A standard container composed of equivalent keys
 205    *  (possibly containing multiple of each key value) in which the
 206    *  elements' keys are the elements themselves.
 207    *
 208    *  @ingroup unordered_associative_containers
 209    *
 210    *  Meets the requirements of a <a href="tables.html#65">container</a>, and
 211    *  <a href="tables.html#xx">unordered associative container</a>
 212    *
 213    *  @param  Value  Type of key objects.
 214    *  @param  Hash  Hashing function object type, defaults to hash<Value>.
 215    *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
 216    *  @param  Alloc  Allocator type, defaults to allocator<Key>.
 217    */
 218   template<class _Value,
 219            class _Hash = hash<_Value>,
 220            class _Pred = std::equal_to<_Value>,
 221            class _Alloc = std::allocator<_Value> >
 222     class unordered_multiset
 223     : public __unordered_multiset<_Value, _Hash, _Pred, _Alloc>
 224     {
 225       typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc>  _Base;
 226
 227     public:
 228       typedef typename _Base::value_type      value_type;
 229       typedef typename _Base::size_type       size_type;
 230       typedef typename _Base::hasher          hasher;
 231       typedef typename _Base::key_equal       key_equal;
 232       typedef typename _Base::allocator_type  allocator_type;
 233
 234       explicit
 235       unordered_multiset(size_type __n = 10,
 236                          const hasher& __hf = hasher(),
 237                          const key_equal& __eql = key_equal(),
 238                          const allocator_type& __a = allocator_type())
 239       : _Base(__n, __hf, __eql, __a)
 240       { }
 241
 242
 243       template<typename _InputIterator>
 244         unordered_multiset(_InputIterator __f, _InputIterator __l,
 245                            typename _Base::size_type __n = 0,
 246                            const hasher& __hf = hasher(),
 247                            const key_equal& __eql = key_equal(),
 248                            const allocator_type& __a = allocator_type())
 249         : _Base(__f, __l, __n, __hf, __eql, __a)
 250         { }
 251     };
 252
 253   template<class _Value, class _Hash, class _Pred, class _Alloc>
 254     inline void
 255     swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
 256          unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
 257     { __x.swap(__y); }
 258
 259   template<class _Value, class _Hash, class _Pred, class _Alloc>
 260     inline void
 261     swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
 262          unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
 263     { __x.swap(__y); }
 264 }
 265
 266 _GLIBCXX_END_NAMESPACE_VERSION
 267 }