-// TR1 functional -*- C++ -*-
+// TR1 functional_hash.h header -*- C++ -*-
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 2, or (at your option)
+// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
-// You should have received a copy of the GNU General Public License along
-// with this library; see the file COPYING. If not, write to the Free
-// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-// USA.
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
-// As a special exception, you may use this file as part of a free software
-// library without restriction. Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License. This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
/** @file tr1/functional_hash.h
* This is an internal header file, included by other library headers.
- * You should not attempt to use it directly.
+ * Do not attempt to use it directly. @headername{tr1/functional}
*/
-#ifndef _TR1_FUNCTIONAL_HASH_H
-#define _TR1_FUNCTIONAL_HASH_H 1
+#ifndef _GLIBCXX_TR1_FUNCTIONAL_HASH_H
+#define _GLIBCXX_TR1_FUNCTIONAL_HASH_H 1
-#include <string>
-#include <cmath> // for std::frexp
+#pragma GCC system_header
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
-_GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_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.
- template<typename T>
- 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); } \
- }
+namespace tr1
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /// 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 : 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)>
- struct _Fnv_hash
+ /// Dummy generic implementation (for sizeof(size_t) != 4, 8).
+ template<size_t>
+ struct _Fnv_hash_base
{
- static std::size_t
- hash(const char* __first, std::size_t __length)
- {
- std::size_t __result = 0;
- for (; __length > 0; --__length)
- __result = (__result * 131) + *__first++;
- return __result;
- }
+ template<typename _Tp>
+ static size_t
+ hash(const _Tp* __ptr, size_t __clength)
+ {
+ size_t __result = 0;
+ const char* __cptr = reinterpret_cast<const char*>(__ptr);
+ for (; __clength; --__clength)
+ __result = (__result * 131) + *__cptr++;
+ return __result;
+ }
};
template<>
- struct _Fnv_hash<4>
+ struct _Fnv_hash_base<4>
{
- static std::size_t
- hash(const char* __first, std::size_t __length)
- {
- std::size_t __result = static_cast<std::size_t>(2166136261UL);
- for (; __length > 0; --__length)
- {
- __result ^= static_cast<std::size_t>(*__first++);
- __result *= static_cast<std::size_t>(16777619UL);
- }
- return __result;
- }
+ template<typename _Tp>
+ static size_t
+ hash(const _Tp* __ptr, size_t __clength)
+ {
+ size_t __result = static_cast<size_t>(2166136261UL);
+ const char* __cptr = reinterpret_cast<const char*>(__ptr);
+ for (; __clength; --__clength)
+ {
+ __result ^= static_cast<size_t>(*__cptr++);
+ __result *= static_cast<size_t>(16777619UL);
+ }
+ return __result;
+ }
};
template<>
- struct _Fnv_hash<8>
+ struct _Fnv_hash_base<8>
{
- static std::size_t
- hash(const char* __first, std::size_t __length)
- {
- std::size_t __result =
- static_cast<std::size_t>(14695981039346656037ULL);
- for (; __length > 0; --__length)
- {
- __result ^= static_cast<std::size_t>(*__first++);
- __result *= static_cast<std::size_t>(1099511628211ULL);
- }
- return __result;
- }
+ template<typename _Tp>
+ static size_t
+ hash(const _Tp* __ptr, size_t __clength)
+ {
+ size_t __result
+ = static_cast<size_t>(14695981039346656037ULL);
+ const char* __cptr = reinterpret_cast<const char*>(__ptr);
+ for (; __clength; --__clength)
+ {
+ __result ^= static_cast<size_t>(*__cptr++);
+ __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()); }
- };
+ struct _Fnv_hash
+ : public _Fnv_hash_base<sizeof(size_t)>
+ {
+ using _Fnv_hash_base<sizeof(size_t)>::hash;
-#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
+ template<typename _Tp>
+ static size_t
+ hash(const _Tp& __val)
+ { return hash(&__val, sizeof(__val)); }
+ };
+ /// Explicit specializations for float.
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;
- }
- };
+ // 0 and -0 both hash to zero.
+ return __val != 0.0f ? std::tr1::_Fnv_hash::hash(__val) : 0;
+ }
+ /// Explicit specializations for double.
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;
-
- // 0 and -0 both hash to zero.
- if (__dval != 0.0)
- __result = _Fnv_hash<>::hash(reinterpret_cast<const char*>(&__dval),
- sizeof(__dval));
- return __result;
- }
- };
+ // 0 and -0 both hash to zero.
+ return __val != 0.0 ? std::tr1::_Fnv_hash::hash(__val) : 0;
+ }
- // For long double, careful with random padding bits (e.g., on x86,
- // 10 bytes -> 12 bytes) and resort to frexp.
+ /// Explicit specializations for long double.
template<>
- struct hash<long double>
- : public std::unary_function<long double, std::size_t>
- {
- 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 =
- std::numeric_limits<std::size_t>::max() + 1.0l;
- __ldval *= __mult;
+ _GLIBCXX_PURE size_t
+ hash<long double>::operator()(long double __val) const;
- // 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;
+ /// Explicit specialization of member operator for non-builtin types.
+ template<>
+ _GLIBCXX_PURE size_t
+ hash<string>::operator()(string) const;
- const std::size_t __coeff =
- (std::numeric_limits<std::size_t>::max()
- / std::numeric_limits<long double>::max_exponent);
+ template<>
+ _GLIBCXX_PURE size_t
+ hash<const string&>::operator()(const string&) const;
- __result = __hibits + (std::size_t)__ldval + __coeff * __exponent;
+#ifdef _GLIBCXX_USE_WCHAR_T
+ template<>
+ _GLIBCXX_PURE size_t
+ hash<wstring>::operator()(wstring) const;
- return __result;
- }
- };
+ template<>
+ _GLIBCXX_PURE size_t
+ hash<const wstring&>::operator()(const wstring&) const;
+#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+}
}
-#endif
+#endif // _GLIBCXX_TR1_FUNCTIONAL_HASH_H
OSDN Git Service
