{
_GLIBCXX_BEGIN_NAMESPACE_TR1
- // Definition of default hash function std::tr1::hash<>. The types for
- // which std::tr1::hash<T> is defined is in clause 6.3.3. of the PDTR.
+ // Class template hash.
+ // Declaration of default hash functor std::tr1::hash. The types for
+ // which std::tr1::hash<T> is well-defined is in clause 6.3.3. of the PDTR.
template<typename _Tp>
- struct hash;
-
-#define _TR1_hashtable_define_trivial_hash(_Tp) \
- template<> \
- struct hash<_Tp> \
- : public std::unary_function<_Tp, std::size_t> \
- { \
- std::size_t \
- operator()(_Tp __val) const \
- { return static_cast<std::size_t>(__val); } \
- }
+ struct hash : public std::unary_function<_Tp, size_t>
+ {
+ size_t
+ operator()(_Tp __val) const;
+ };
+
+ // Partial specializations for pointer types.
+ template<typename _Tp>
+ struct hash<_Tp*> : public std::unary_function<_Tp*, size_t>
+ {
+ size_t
+ operator()(_Tp* __p) const
+ { return reinterpret_cast<size_t>(__p); }
+ };
+
+ // Explicit specializations for integer types.
+#define _TR1_hashtable_define_trivial_hash(_Tp) \
+ template<> \
+ inline size_t \
+ hash<_Tp>::operator()(_Tp __val) const \
+ { return static_cast<size_t>(__val); }
_TR1_hashtable_define_trivial_hash(bool);
_TR1_hashtable_define_trivial_hash(char);
#undef _TR1_hashtable_define_trivial_hash
- template<typename _Tp>
- struct hash<_Tp*>
- : public std::unary_function<_Tp*, std::size_t>
- {
- std::size_t
- operator()(_Tp* __p) const
- { return reinterpret_cast<std::size_t>(__p); }
- };
-
// Fowler / Noll / Vo (FNV) Hash (type FNV-1a)
- // (used by the next specializations of std::tr1::hash<>)
+ // (Used by the next specializations of std::tr1::hash.)
// Dummy generic implementation (for sizeof(size_t) != 4, 8).
- template<std::size_t = sizeof(std::size_t)>
+ template<size_t = sizeof(size_t)>
struct _Fnv_hash
{
- static std::size_t
- hash(const char* __first, std::size_t __length)
+ static size_t
+ hash(const char* __first, size_t __length)
{
- std::size_t __result = 0;
+ size_t __result = 0;
for (; __length > 0; --__length)
__result = (__result * 131) + *__first++;
return __result;
template<>
struct _Fnv_hash<4>
{
- static std::size_t
- hash(const char* __first, std::size_t __length)
+ static size_t
+ hash(const char* __first, size_t __length)
{
- std::size_t __result = static_cast<std::size_t>(2166136261UL);
+ size_t __result = static_cast<size_t>(2166136261UL);
for (; __length > 0; --__length)
{
- __result ^= static_cast<std::size_t>(*__first++);
- __result *= static_cast<std::size_t>(16777619UL);
+ __result ^= static_cast<size_t>(*__first++);
+ __result *= static_cast<size_t>(16777619UL);
}
return __result;
}
template<>
struct _Fnv_hash<8>
{
- static std::size_t
- hash(const char* __first, std::size_t __length)
+ static size_t
+ hash(const char* __first, size_t __length)
{
- std::size_t __result =
- static_cast<std::size_t>(14695981039346656037ULL);
+ size_t __result =
+ static_cast<size_t>(14695981039346656037ULL);
for (; __length > 0; --__length)
{
- __result ^= static_cast<std::size_t>(*__first++);
- __result *= static_cast<std::size_t>(1099511628211ULL);
+ __result ^= static_cast<size_t>(*__first++);
+ __result *= static_cast<size_t>(1099511628211ULL);
}
return __result;
}
};
- // XXX String and floating point hashes probably shouldn't be inline
- // member functions, since are nontrivial. Once we have the framework
- // for TR1 .cc files, these should go in one.
- template<>
- struct hash<std::string>
- : public std::unary_function<std::string, std::size_t>
- {
- std::size_t
- operator()(const std::string& __s) const
- { return _Fnv_hash<>::hash(__s.data(), __s.length()); }
- };
-
-#ifdef _GLIBCXX_USE_WCHAR_T
- template<>
- struct hash<std::wstring>
- : public std::unary_function<std::wstring, std::size_t>
- {
- std::size_t
- operator()(const std::wstring& __s) const
- {
- return _Fnv_hash<>::hash(reinterpret_cast<const char*>(__s.data()),
- __s.length() * sizeof(wchar_t));
- }
- };
-#endif
-
+ // Explicit specializations for floating point types.
template<>
- struct hash<float>
- : public std::unary_function<float, std::size_t>
+ inline size_t
+ hash<float>::operator()(float __val) const
{
- std::size_t
- operator()(float __fval) const
- {
- std::size_t __result = 0;
-
- // 0 and -0 both hash to zero.
- if (__fval != 0.0f)
- __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__fval),
- sizeof(__fval));
- return __result;
- }
+ size_t __result = 0;
+
+ // 0 and -0 both hash to zero.
+ if (__val != 0.0f)
+ __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__val),
+ sizeof(__val));
+ return __result;
};
template<>
- struct hash<double>
- : public std::unary_function<double, std::size_t>
+ inline size_t
+ hash<double>::operator()(double __val) const
{
- std::size_t
- operator()(double __dval) const
- {
- std::size_t __result = 0;
+ size_t __result = 0;
// 0 and -0 both hash to zero.
- if (__dval != 0.0)
- __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__dval),
- sizeof(__dval));
+ if (__val != 0.0)
+ __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__val),
+ sizeof(__val));
return __result;
- }
};
// For long double, careful with random padding bits (e.g., on x86,
// 10 bytes -> 12 bytes) and resort to frexp.
template<>
- struct hash<long double>
- : public std::unary_function<long double, std::size_t>
+ inline size_t
+ hash<long double>::operator()(long double __val) const
{
- std::size_t
- operator()(long double __ldval) const
- {
- std::size_t __result = 0;
-
- int __exponent;
- __ldval = std::frexp(__ldval, &__exponent);
- __ldval = __ldval < 0.0l ? -(__ldval + 0.5l) : __ldval;
-
- const long double __mult =
- __gnu_cxx::__numeric_traits<std::size_t>::__max + 1.0l;
- __ldval *= __mult;
-
+ size_t __result = 0;
+
+ int __exponent;
+ __val = std::frexp(__val, &__exponent);
+ __val = __val < 0.0l ? -(__val + 0.5l) : __val;
+
+ const long double __mult =
+ __gnu_cxx::__numeric_traits<size_t>::__max + 1.0l;
+ __val *= __mult;
+
// Try to use all the bits of the mantissa (really necessary only
// on 32-bit targets, at least for 80-bit floating point formats).
- const std::size_t __hibits = (std::size_t)__ldval;
- __ldval = (__ldval - (long double)__hibits) * __mult;
+ const size_t __hibits = (size_t)__val;
+ __val = (__val - (long double)__hibits) * __mult;
+
+ const size_t __coeff =
+ __gnu_cxx::__numeric_traits<size_t>::__max / __LDBL_MAX_EXP__;
+
+ __result = __hibits + (size_t)__val + __coeff * __exponent;
+
+ return __result;
+ };
- const std::size_t __coeff =
- __gnu_cxx::__numeric_traits<std::size_t>::__max / __LDBL_MAX_EXP__;
+ // Explicit specialization of member operator for types that are not builtin.
+ template<>
+ size_t
+ hash<string>::operator()(string) const;
- __result = __hibits + (std::size_t)__ldval + __coeff * __exponent;
+ template<>
+ size_t
+ hash<const string&>::operator()(const string&) const;
- return __result;
- }
- };
+#ifdef _GLIBCXX_USE_WCHAR_T
+ template<>
+ size_t
+ hash<wstring>::operator()(wstring) const;
+
+ template<>
+ size_t
+ hash<const wstring&>::operator()(const wstring&) const;
+#endif
_GLIBCXX_END_NAMESPACE_TR1
}
projects / thirdparty / gcc.git / blobdiff