Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/13/tr1/functional_hash.h
$ cat -n /usr/include/c++/13/tr1/functional_hash.h 1 // TR1 functional_hash.h header -*- C++ -*- 2 3 // Copyright (C) 2007-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/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 35 namespace std _GLIBCXX_VISIBILITY(default) 36 { 37 _GLIBCXX_BEGIN_NAMESPACE_VERSION 38 39 namespace 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
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
