1// TR1 functional_hash.h header -*- C++ -*- 2 3// Copyright (C) 2007-2022 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/functional_hash.h 26 * This is an internal header file, included by other library headers. 27 * Do not attempt to use it directly. @headername{tr1/functional} 28 */ 29 30#ifndef _GLIBCXX_TR1_FUNCTIONAL_HASH_H 31#define _GLIBCXX_TR1_FUNCTIONAL_HASH_H 1 32 33#pragma GCC system_header 34 35namespace std _GLIBCXX_VISIBILITY(default) 36{ 37_GLIBCXX_BEGIN_NAMESPACE_VERSION 38 39namespace tr1 40{ 41// Ignore warnings about std::unary_function and std::binary_function. 42#pragma GCC diagnostic push 43#pragma GCC diagnostic ignored "-Wdeprecated-declarations" 44 45 /// Class template hash. 46 // Declaration of default hash functor std::tr1::hash. The types for 47 // which std::tr1::hash<T> is well-defined is in clause 6.3.3. of the PDTR. 48 template<typename _Tp> 49 struct hash : public std::unary_function<_Tp, size_t> 50 { 51 size_t 52 operator()(_Tp __val) const; 53 }; 54 55 /// Partial specializations for pointer types. 56 template<typename _Tp> 57 struct hash<_Tp*> : public std::unary_function<_Tp*, size_t> 58 { 59 size_t 60 operator()(_Tp* __p) const 61 { return reinterpret_cast<size_t>(__p); } 62 }; 63#pragma GCC diagnostic pop 64 65 /// Explicit specializations for integer types. 66#define _TR1_hashtable_define_trivial_hash(_Tp) \ 67 template<> \ 68 inline size_t \ 69 hash<_Tp>::operator()(_Tp __val) const \ 70 { return static_cast<size_t>(__val); } 71 72 _TR1_hashtable_define_trivial_hash(bool); 73 _TR1_hashtable_define_trivial_hash(char); 74 _TR1_hashtable_define_trivial_hash(signed char); 75 _TR1_hashtable_define_trivial_hash(unsigned char); 76 _TR1_hashtable_define_trivial_hash(wchar_t); 77 _TR1_hashtable_define_trivial_hash(short); 78 _TR1_hashtable_define_trivial_hash(int); 79 _TR1_hashtable_define_trivial_hash(long); 80 _TR1_hashtable_define_trivial_hash(long long); 81 _TR1_hashtable_define_trivial_hash(unsigned short); 82 _TR1_hashtable_define_trivial_hash(unsigned int); 83 _TR1_hashtable_define_trivial_hash(unsigned long); 84 _TR1_hashtable_define_trivial_hash(unsigned long long); 85 86#undef _TR1_hashtable_define_trivial_hash 87 88 // Fowler / Noll / Vo (FNV) Hash (type FNV-1a) 89 // (Used by the next specializations of std::tr1::hash.) 90 91 // N.B. These functions should work on unsigned char, otherwise they do not 92 // correctly implement the FNV-1a algorithm (see PR59406). 93 // The existing behaviour is retained for backwards compatibility. 94 95 /// Dummy generic implementation (for sizeof(size_t) != 4, 8). 96 template<size_t> 97 struct _Fnv_hash_base 98 { 99 template<typename _Tp> 100 static size_t 101 hash(const _Tp* __ptr, size_t __clength) 102 { 103 size_t __result = 0; 104 const char* __cptr = reinterpret_cast<const char*>(__ptr); 105 for (; __clength; --__clength) 106 __result = (__result * 131) + *__cptr++; 107 return __result; 108 } 109 }; 110 111 template<> 112 struct _Fnv_hash_base<4> 113 { 114 template<typename _Tp> 115 static size_t 116 hash(const _Tp* __ptr, size_t __clength) 117 { 118 size_t __result = static_cast<size_t>(2166136261UL); 119 const char* __cptr = reinterpret_cast<const char*>(__ptr); 120 for (; __clength; --__clength) 121 { 122 __result ^= static_cast<size_t>(*__cptr++); 123 __result *= static_cast<size_t>(16777619UL); 124 } 125 return __result; 126 } 127 }; 128 129 template<> 130 struct _Fnv_hash_base<8> 131 { 132 template<typename _Tp> 133 static size_t 134 hash(const _Tp* __ptr, size_t __clength) 135 { 136 size_t __result 137 = static_cast<size_t>(14695981039346656037ULL); 138 const char* __cptr = reinterpret_cast<const char*>(__ptr); 139 for (; __clength; --__clength) 140 { 141 __result ^= static_cast<size_t>(*__cptr++); 142 __result *= static_cast<size_t>(1099511628211ULL); 143 } 144 return __result; 145 } 146 }; 147 148 struct _Fnv_hash 149 : public _Fnv_hash_base<sizeof(size_t)> 150 { 151 using _Fnv_hash_base<sizeof(size_t)>::hash; 152 153 template<typename _Tp> 154 static size_t 155 hash(const _Tp& __val) 156 { return hash(&__val, sizeof(__val)); } 157 }; 158 159 /// Explicit specializations for float. 160 template<> 161 inline size_t 162 hash<float>::operator()(float __val) const 163 { 164 // 0 and -0 both hash to zero. 165 return __val != 0.0f ? std::tr1::_Fnv_hash::hash(__val) : 0; 166 } 167 168 /// Explicit specializations for double. 169 template<> 170 inline size_t 171 hash<double>::operator()(double __val) const 172 { 173 // 0 and -0 both hash to zero. 174 return __val != 0.0 ? std::tr1::_Fnv_hash::hash(__val) : 0; 175 } 176 177 /// Explicit specializations for long double. 178 template<> 179 _GLIBCXX_PURE size_t 180 hash<long double>::operator()(long double __val) const; 181 182 /// Explicit specialization of member operator for non-builtin types. 183 template<> 184 _GLIBCXX_PURE size_t 185 hash<string>::operator()(string) const; 186 187 template<> 188 _GLIBCXX_PURE size_t 189 hash<const string&>::operator()(const string&) const; 190 191#ifdef _GLIBCXX_USE_WCHAR_T 192 template<> 193 _GLIBCXX_PURE size_t 194 hash<wstring>::operator()(wstring) const; 195 196 template<> 197 _GLIBCXX_PURE size_t 198 hash<const wstring&>::operator()(const wstring&) const; 199#endif 200} 201 202_GLIBCXX_END_NAMESPACE_VERSION 203} 204 205#endif // _GLIBCXX_TR1_FUNCTIONAL_HASH_H 206