libstdc++-v3/include/tr1_impl/unordered_map

   1 // TR1 unordered_map -*- C++ -*-
   2
   3 // Copyright (C) 2007, 2009 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_impl/unordered_map
  26  *  This is an internal header file, included by other library headers.
  27  *  You should not attempt to use it directly.
  28  */
  29
  30 namespace std
  31 {
  32 _GLIBCXX_BEGIN_NAMESPACE_TR1
  33
  34   // XXX When we get typedef templates these class definitions
  35   // will be unnecessary.
  36   template<class _Key, class _Tp,
  37            class _Hash = hash<_Key>,
  38            class _Pred = std::equal_to<_Key>,
  39            class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
  40            bool __cache_hash_code = false>
  41     class __unordered_map
  42     : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
  43                         std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
  44                         _Hash, __detail::_Mod_range_hashing,
  45                         __detail::_Default_ranged_hash,
  46                         __detail::_Prime_rehash_policy,
  47                         __cache_hash_code, false, true>
  48     {
  49       typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
  50                          std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
  51                          _Hash, __detail::_Mod_range_hashing,
  52                          __detail::_Default_ranged_hash,
  53                          __detail::_Prime_rehash_policy,
  54                          __cache_hash_code, false, true>
  55         _Base;
  56
  57     public:
  58       typedef typename _Base::size_type       size_type;
  59       typedef typename _Base::hasher          hasher;
  60       typedef typename _Base::key_equal       key_equal;
  61       typedef typename _Base::allocator_type  allocator_type;
  62
  63       explicit
  64       __unordered_map(size_type __n = 10,
  65                       const hasher& __hf = hasher(),
  66                       const key_equal& __eql = key_equal(),
  67                       const allocator_type& __a = allocator_type())
  68       : _Base(__n, __hf, __detail::_Mod_range_hashing(),
  69               __detail::_Default_ranged_hash(),
  70               __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
  71       { }
  72
  73       template<typename _InputIterator>
  74         __unordered_map(_InputIterator __f, _InputIterator __l,
  75                         size_type __n = 10,
  76                         const hasher& __hf = hasher(),
  77                         const key_equal& __eql = key_equal(),
  78                         const allocator_type& __a = allocator_type())
  79         : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
  80                 __detail::_Default_ranged_hash(),
  81                 __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
  82         { }
  83
  84 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
  85       __unordered_map(__unordered_map&& __x)
  86       : _Base(std::forward<_Base>(__x)) { }
  87 #endif
  88     };
  89
  90   template<class _Key, class _Tp,
  91            class _Hash = hash<_Key>,
  92            class _Pred = std::equal_to<_Key>,
  93            class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
  94            bool __cache_hash_code = false>
  95     class __unordered_multimap
  96     : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
  97                         _Alloc,
  98                         std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
  99                         _Hash, __detail::_Mod_range_hashing,
 100                         __detail::_Default_ranged_hash,
 101                         __detail::_Prime_rehash_policy,
 102                         __cache_hash_code, false, false>
 103     {
 104       typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
 105                          _Alloc,
 106                          std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
 107                          _Hash, __detail::_Mod_range_hashing,
 108                          __detail::_Default_ranged_hash,
 109                          __detail::_Prime_rehash_policy,
 110                          __cache_hash_code, false, false>
 111         _Base;
 112
 113     public:
 114       typedef typename _Base::size_type       size_type;
 115       typedef typename _Base::hasher          hasher;
 116       typedef typename _Base::key_equal       key_equal;
 117       typedef typename _Base::allocator_type  allocator_type;
 118
 119       explicit
 120       __unordered_multimap(size_type __n = 10,
 121                            const hasher& __hf = hasher(),
 122                            const key_equal& __eql = key_equal(),
 123                            const allocator_type& __a = allocator_type())
 124       : _Base(__n, __hf, __detail::_Mod_range_hashing(),
 125               __detail::_Default_ranged_hash(),
 126               __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
 127       { }
 128
 129
 130       template<typename _InputIterator>
 131         __unordered_multimap(_InputIterator __f, _InputIterator __l,
 132                              typename _Base::size_type __n = 0,
 133                              const hasher& __hf = hasher(),
 134                              const key_equal& __eql = key_equal(),
 135                              const allocator_type& __a = allocator_type())
 136         : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
 137                 __detail::_Default_ranged_hash(),
 138                 __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
 139         { }
 140
 141 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
 142       __unordered_multimap(__unordered_multimap&& __x)
 143       : _Base(std::forward<_Base>(__x)) { }
 144 #endif
 145     };
 146
 147   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
 148            bool __cache_hash_code>
 149     inline void
 150     swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
 151          _Alloc, __cache_hash_code>& __x,
 152          __unordered_map<_Key, _Tp, _Hash, _Pred,
 153          _Alloc, __cache_hash_code>& __y)
 154     { __x.swap(__y); }
 155
 156   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
 157            bool __cache_hash_code>
 158     inline void
 159     swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
 160          _Alloc, __cache_hash_code>& __x,
 161          __unordered_multimap<_Key, _Tp, _Hash, _Pred,
 162          _Alloc, __cache_hash_code>& __y)
 163     { __x.swap(__y); }
 164
 165
 166   /**
 167    *  @brief A standard container composed of unique keys (containing
 168    *  at most one of each key value) that associates values of another type
 169    *  with the keys.
 170    *
 171    *  @ingroup unordered_associative_containers
 172    *
 173    *  Meets the requirements of a <a href="tables.html#65">container</a>, and
 174    *  <a href="tables.html#xx">unordered associative container</a>
 175    *
 176    *  @param  Key  Type of key objects.
 177    *  @param  Tp  Type of mapped objects.
 178    *  @param  Hash  Hashing function object type, defaults to hash<Value>.
 179    *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
 180    *  @param  Alloc  Allocator type, defaults to allocator<Key>.
 181    *
 182    * The resulting value type of the container is std::pair<const Key, Tp>.
 183    */
 184   template<class _Key, class _Tp,
 185            class _Hash = hash<_Key>,
 186            class _Pred = std::equal_to<_Key>,
 187            class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
 188     class unordered_map
 189     : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
 190     {
 191       typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>  _Base;
 192
 193     public:
 194       typedef typename _Base::value_type      value_type;
 195       typedef typename _Base::size_type       size_type;
 196       typedef typename _Base::hasher          hasher;
 197       typedef typename _Base::key_equal       key_equal;
 198       typedef typename _Base::allocator_type  allocator_type;
 199
 200       explicit
 201       unordered_map(size_type __n = 10,
 202                     const hasher& __hf = hasher(),
 203                     const key_equal& __eql = key_equal(),
 204                     const allocator_type& __a = allocator_type())
 205       : _Base(__n, __hf, __eql, __a)
 206       { }
 207
 208       template<typename _InputIterator>
 209         unordered_map(_InputIterator __f, _InputIterator __l,
 210                       size_type __n = 10,
 211                       const hasher& __hf = hasher(),
 212                       const key_equal& __eql = key_equal(),
 213                       const allocator_type& __a = allocator_type())
 214         : _Base(__f, __l, __n, __hf, __eql, __a)
 215         { }
 216
 217 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
 218       unordered_map(unordered_map&& __x)
 219       : _Base(std::forward<_Base>(__x)) { }
 220
 221       unordered_map(initializer_list<value_type> __l,
 222                     size_type __n = 10,
 223                     const hasher& __hf = hasher(),
 224                     const key_equal& __eql = key_equal(),
 225                     const allocator_type& __a = allocator_type())
 226         : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
 227       { }
 228
 229       unordered_map&
 230       operator=(unordered_map&& __x)
 231       {
 232         // NB: DR 675.
 233         this->clear();
 234         this->swap(__x);
 235         return *this;
 236       }
 237
 238       unordered_map&
 239       operator=(initializer_list<value_type> __l)
 240       {
 241         this->clear();
 242         this->insert(__l.begin(), __l.end());
 243         return *this;
 244       }
 245 #endif
 246     };
 247
 248   /**
 249    *  @brief A standard container composed of equivalent keys
 250    *  (possibly containing multiple of each key value) that associates
 251    *  values of another type with the keys.
 252    *
 253    *  @ingroup unordered_associative_containers
 254    *
 255    *  Meets the requirements of a <a href="tables.html#65">container</a>, and
 256    *  <a href="tables.html#xx">unordered associative container</a>
 257    *
 258    *  @param  Key  Type of key objects.
 259    *  @param  Tp  Type of mapped objects.
 260    *  @param  Hash  Hashing function object type, defaults to hash<Value>.
 261    *  @param  Pred  Predicate function object type, defaults to equal_to<Value>.
 262    *  @param  Alloc  Allocator type, defaults to allocator<Key>.
 263    *
 264    * The resulting value type of the container is std::pair<const Key, Tp>.
 265    */
 266   template<class _Key, class _Tp,
 267            class _Hash = hash<_Key>,
 268            class _Pred = std::equal_to<_Key>,
 269            class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
 270     class unordered_multimap
 271     : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
 272     {
 273       typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>  _Base;
 274
 275     public:
 276       typedef typename _Base::value_type      value_type;
 277       typedef typename _Base::size_type       size_type;
 278       typedef typename _Base::hasher          hasher;
 279       typedef typename _Base::key_equal       key_equal;
 280       typedef typename _Base::allocator_type  allocator_type;
 281
 282       explicit
 283       unordered_multimap(size_type __n = 10,
 284                          const hasher& __hf = hasher(),
 285                          const key_equal& __eql = key_equal(),
 286                          const allocator_type& __a = allocator_type())
 287       : _Base(__n, __hf, __eql, __a)
 288       { }
 289
 290
 291       template<typename _InputIterator>
 292         unordered_multimap(_InputIterator __f, _InputIterator __l,
 293                            typename _Base::size_type __n = 0,
 294                            const hasher& __hf = hasher(),
 295                            const key_equal& __eql = key_equal(),
 296                            const allocator_type& __a = allocator_type())
 297         : _Base(__f, __l, __n, __hf, __eql, __a)
 298         { }
 299
 300 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
 301       unordered_multimap(unordered_multimap&& __x)
 302       : _Base(std::forward<_Base>(__x)) { }
 303
 304       unordered_multimap(initializer_list<value_type> __l,
 305                          size_type __n = 10,
 306                          const hasher& __hf = hasher(),
 307                          const key_equal& __eql = key_equal(),
 308                          const allocator_type& __a = allocator_type())
 309         : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
 310       { }
 311
 312       unordered_multimap&
 313       operator=(unordered_multimap&& __x)
 314       {
 315         // NB: DR 675.
 316         this->clear();
 317         this->swap(__x);
 318         return *this;
 319       }
 320
 321       unordered_multimap&
 322       operator=(initializer_list<value_type> __l)
 323       {
 324         this->clear();
 325         this->insert(__l.begin(), __l.end());
 326         return *this;
 327       }
 328 #endif
 329     };
 330
 331   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 332     inline void
 333     swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 334          unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 335     { __x.swap(__y); }
 336
 337   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 338     inline void
 339     swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 340          unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 341     { __x.swap(__y); }
 342
 343 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
 344   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 345     inline void
 346     swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
 347          unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 348     { __x.swap(__y); }
 349
 350   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 351     inline void
 352     swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 353          unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
 354     { __x.swap(__y); }
 355
 356   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 357     inline void
 358     swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
 359          unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 360     { __x.swap(__y); }
 361
 362   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 363     inline void
 364     swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 365          unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
 366     { __x.swap(__y); }
 367 #endif
 368
 369 _GLIBCXX_END_NAMESPACE_TR1
 370 }