gnu/dist/gcc4/libstdc++-v3/include/tr1/unordered_map

   1 // TR1 unordered_map -*- C++ -*-
   2
   3 // Copyright (C) 2005 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 2, 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 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 /** @file
  31  *  This is a TR1 C++ Library header.
  32  */
  33
  34 #ifndef GNU_LIBSTDCXX_TR1_UNORDERED_MAP_
  35 #define GNU_LIBSTDCXX_TR1_UNORDERED_MAP_
  36
  37 #include <tr1/hashtable>
  38 #include <tr1/functional>
  39 #include <tr1/functional>
  40 #include <utility>
  41 #include <memory>
  42
  43 namespace std
  44 {
  45 namespace tr1
  46 {
  47   // XXX When we get typedef templates these class definitions
  48   // will be unnecessary.
  49
  50   template<class Key, class T,
  51            class Hash = hash<Key>,
  52            class Pred = std::equal_to<Key>,
  53            class Alloc = std::allocator<std::pair<const Key, T> >,
  54            bool cache_hash_code = false>
  55     class unordered_map
  56     : public hashtable <Key, std::pair<const Key, T>,
  57                         Alloc,
  58                         Internal::extract1st<std::pair<const Key, T> >, Pred,
  59                         Hash, Internal::mod_range_hashing,
  60                         Internal::default_ranged_hash,
  61                         Internal::prime_rehash_policy,
  62                         cache_hash_code, false, true>
  63     {
  64       typedef hashtable <Key, std::pair<const Key, T>,
  65                          Alloc,
  66                          Internal::extract1st<std::pair<const Key, T> >, Pred,
  67                          Hash, Internal::mod_range_hashing,
  68                          Internal::default_ranged_hash,
  69                          Internal::prime_rehash_policy,
  70                          cache_hash_code, false, true>
  71         Base;
  72
  73     public:
  74       typedef typename Base::size_type size_type;
  75       typedef typename Base::hasher hasher;
  76       typedef typename Base::key_equal key_equal;
  77       typedef typename Base::allocator_type allocator_type;
  78
  79       explicit
  80       unordered_map(size_type n = 10,
  81                     const hasher& hf = hasher(),
  82                     const key_equal& eql = key_equal(),
  83                     const allocator_type& a = allocator_type())
  84       : Base(n, hf, Internal::mod_range_hashing(),
  85              Internal::default_ranged_hash(),
  86              eql, Internal::extract1st<std::pair<const Key, T> >(), a)
  87       { }
  88
  89       template<typename InputIterator>
  90         unordered_map(InputIterator f, InputIterator l,
  91                       size_type n = 10,
  92                       const hasher& hf = hasher(),
  93                       const key_equal& eql = key_equal(),
  94                       const allocator_type& a = allocator_type())
  95         : Base (f, l, n, hf, Internal::mod_range_hashing(),
  96                 Internal::default_ranged_hash(),
  97                 eql, Internal::extract1st<std::pair<const Key, T> >(), a)
  98         { }
  99     };
 100
 101   template<class Key, class T,
 102            class Hash = hash<Key>,
 103            class Pred = std::equal_to<Key>,
 104            class Alloc = std::allocator<std::pair<const Key, T> >,
 105            bool cache_hash_code = false>
 106     class unordered_multimap
 107     : public hashtable <Key, std::pair<const Key, T>,
 108                         Alloc,
 109                         Internal::extract1st<std::pair<const Key, T> >, Pred,
 110                         Hash, Internal::mod_range_hashing,
 111                         Internal::default_ranged_hash,
 112                         Internal::prime_rehash_policy,
 113                         cache_hash_code, false, false>
 114     {
 115       typedef hashtable <Key, std::pair<const Key, T>,
 116                          Alloc,
 117                          Internal::extract1st<std::pair<const Key, T> >, Pred,
 118                          Hash, Internal::mod_range_hashing,
 119                          Internal::default_ranged_hash,
 120                          Internal::prime_rehash_policy,
 121                          cache_hash_code, false, false>
 122         Base;
 123
 124     public:
 125       typedef typename Base::size_type size_type;
 126       typedef typename Base::hasher hasher;
 127       typedef typename Base::key_equal key_equal;
 128       typedef typename Base::allocator_type allocator_type;
 129
 130       explicit
 131       unordered_multimap(size_type n = 10,
 132                          const hasher& hf = hasher(),
 133                          const key_equal& eql = key_equal(),
 134                          const allocator_type& a = allocator_type())
 135       : Base (n, hf, Internal::mod_range_hashing(),
 136               Internal::default_ranged_hash(),
 137               eql, Internal::extract1st<std::pair<const Key, T> >(), a)
 138       { }
 139
 140
 141       template<typename InputIterator>
 142         unordered_multimap(InputIterator f, InputIterator l,
 143                            typename Base::size_type n = 0,
 144                            const hasher& hf = hasher(),
 145                            const key_equal& eql = key_equal(),
 146                            const allocator_type& a = allocator_type())
 147         : Base (f, l, n, hf, Internal::mod_range_hashing(),
 148                 Internal::default_ranged_hash(),
 149                 eql, Internal::extract1st<std::pair<const Key, T> >(), a)
 150         { }
 151     };
 152
 153   template<class Key, class T, class Hash, class Pred, class Alloc,
 154            bool cache_hash_code>
 155     inline void
 156     swap(unordered_map<Key, T, Hash, Pred, Alloc, cache_hash_code>& x,
 157          unordered_map<Key, T, Hash, Pred, Alloc, cache_hash_code>& y)
 158     { x.swap(y); }
 159
 160   template<class Key, class T, class Hash, class Pred, class Alloc,
 161            bool cache_hash_code>
 162     inline void
 163     swap(unordered_multimap<Key, T, Hash, Pred, Alloc, cache_hash_code>& x,
 164          unordered_multimap<Key, T, Hash, Pred, Alloc, cache_hash_code>& y)
 165     { x.swap(y); }
 166
 167 }
 168 }
 169
 170 #endif /* GNU_LIBSTDCXX_TR1_UNORDERED_MAP_ */