contrib/gcc-4.4/libstdc++-v3/include/tr1_impl/functional_hash.h

   1 // TR1 functional -*- C++ -*-
   2
   3 // Copyright (C) 2007, 2008, 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/functional_hash.h
  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   /// Class template hash.
  35   // Declaration of default hash functor std::tr1::hash.  The types for
  36   // which std::tr1::hash<T> is well-defined is in clause 6.3.3. of the PDTR.
  37   template<typename _Tp>
  38     struct hash : public std::unary_function<_Tp, size_t>
  39     {
  40       size_t
  41       operator()(_Tp __val) const;
  42     };
  43
  44   /// Partial specializations for pointer types.
  45   template<typename _Tp>
  46     struct hash<_Tp*> : public std::unary_function<_Tp*, size_t>
  47     {
  48       size_t
  49       operator()(_Tp* __p) const
  50       { return reinterpret_cast<size_t>(__p); }
  51     };
  52
  53   /// Explicit specializations for integer types.
  54 #define _TR1_hashtable_define_trivial_hash(_Tp)         \
  55   template<>                                            \
  56     inline size_t                                       \
  57     hash<_Tp>::operator()(_Tp __val) const              \
  58     { return static_cast<size_t>(__val); }
  59
  60   _TR1_hashtable_define_trivial_hash(bool);
  61   _TR1_hashtable_define_trivial_hash(char);
  62   _TR1_hashtable_define_trivial_hash(signed char);
  63   _TR1_hashtable_define_trivial_hash(unsigned char);
  64   _TR1_hashtable_define_trivial_hash(wchar_t);
  65 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
  66   _TR1_hashtable_define_trivial_hash(char16_t);
  67   _TR1_hashtable_define_trivial_hash(char32_t);
  68 #endif
  69   _TR1_hashtable_define_trivial_hash(short);
  70   _TR1_hashtable_define_trivial_hash(int);
  71   _TR1_hashtable_define_trivial_hash(long);
  72   _TR1_hashtable_define_trivial_hash(long long);
  73   _TR1_hashtable_define_trivial_hash(unsigned short);
  74   _TR1_hashtable_define_trivial_hash(unsigned int);
  75   _TR1_hashtable_define_trivial_hash(unsigned long);
  76   _TR1_hashtable_define_trivial_hash(unsigned long long);
  77
  78 #undef _TR1_hashtable_define_trivial_hash
  79
  80   // Fowler / Noll / Vo (FNV) Hash (type FNV-1a)
  81   // (Used by the next specializations of std::tr1::hash.)
  82
  83   /// Dummy generic implementation (for sizeof(size_t) != 4, 8).
  84   template<size_t = sizeof(size_t)>
  85     struct _Fnv_hash
  86     {
  87       static size_t
  88       hash(const char* __first, size_t __length)
  89       {
  90         size_t __result = 0;
  91         for (; __length > 0; --__length)
  92           __result = (__result * 131) + *__first++;
  93         return __result;
  94       }
  95     };
  96
  97   template<>
  98     struct _Fnv_hash<4>
  99     {
 100       static size_t
 101       hash(const char* __first, size_t __length)
 102       {
 103         size_t __result = static_cast<size_t>(2166136261UL);
 104         for (; __length > 0; --__length)
 105           {
 106             __result ^= static_cast<size_t>(*__first++);
 107             __result *= static_cast<size_t>(16777619UL);
 108           }
 109         return __result;
 110       }
 111     };
 112
 113   template<>
 114     struct _Fnv_hash<8>
 115     {
 116       static size_t
 117       hash(const char* __first, size_t __length)
 118       {
 119         size_t __result =
 120           static_cast<size_t>(14695981039346656037ULL);
 121         for (; __length > 0; --__length)
 122           {
 123             __result ^= static_cast<size_t>(*__first++);
 124             __result *= static_cast<size_t>(1099511628211ULL);
 125           }
 126         return __result;
 127       }
 128     };
 129
 130   /// Explicit specializations for float.
 131   template<>
 132     inline size_t
 133     hash<float>::operator()(float __val) const
 134     {
 135       size_t __result = 0;
 136
 137       // 0 and -0 both hash to zero.
 138       if (__val != 0.0f)
 139         __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__val),
 140                                      sizeof(__val));
 141       return __result;
 142     };
 143
 144   /// Explicit specializations for double.
 145   template<>
 146     inline size_t
 147     hash<double>::operator()(double __val) const
 148     {
 149         size_t __result = 0;
 150
 151         // 0 and -0 both hash to zero.
 152         if (__val != 0.0)
 153           __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__val),
 154                                        sizeof(__val));
 155         return __result;
 156     };
 157
 158   /// Explicit specializations for long double.
 159   template<>
 160     size_t
 161     hash<long double>::operator()(long double __val) const;
 162
 163   /// Explicit specialization of member operator for non-builtin types.
 164   template<>
 165     size_t
 166     hash<string>::operator()(string) const;
 167
 168   template<>
 169     size_t
 170     hash<const string&>::operator()(const string&) const;
 171
 172 #ifdef _GLIBCXX_USE_WCHAR_T
 173   template<>
 174     size_t
 175     hash<wstring>::operator()(wstring) const;
 176
 177   template<>
 178     size_t
 179     hash<const wstring&>::operator()(const wstring&) const;
 180 #endif
 181
 182 _GLIBCXX_END_NAMESPACE_TR1
 183 }