File Coverage

/usr/include/c++/5/bits/functional_hash.h
Criterion Covered Total %
statement 3 4 75.0
branch n/a
condition n/a
subroutine n/a
pod n/a
total 3 4 75.0


line stmt bran cond sub pod time code
1             // functional_hash.h header -*- C++ -*-
2              
3             // Copyright (C) 2007-2015 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             // .
24              
25             /** @file bits/functional_hash.h
26             * This is an internal header file, included by other library headers.
27             * Do not attempt to use it directly. @headername{functional}
28             */
29              
30             #ifndef _FUNCTIONAL_HASH_H
31             #define _FUNCTIONAL_HASH_H 1
32              
33             #pragma GCC system_header
34              
35             #include
36              
37             namespace std _GLIBCXX_VISIBILITY(default)
38             {
39             _GLIBCXX_BEGIN_NAMESPACE_VERSION
40              
41             /** @defgroup hashes Hashes
42             * @ingroup functors
43             *
44             * Hashing functors taking a variable type and returning a @c std::size_t.
45             *
46             * @{
47             */
48              
49             template
50             struct __hash_base
51             {
52             typedef _Result result_type;
53             typedef _Arg argument_type;
54             };
55              
56             /// Primary class template hash.
57             template
58             struct hash;
59              
60             /// Partial specializations for pointer types.
61             template
62             struct hash<_Tp*> : public __hash_base
63             {
64             size_t
65             operator()(_Tp* __p) const noexcept
66             { return reinterpret_cast(__p); }
67             };
68              
69             // Explicit specializations for integer types.
70             #define _Cxx_hashtable_define_trivial_hash(_Tp) \
71             template<> \
72             struct hash<_Tp> : public __hash_base \
73             { \
74             size_t \
75             operator()(_Tp __val) const noexcept \
76             { return static_cast(__val); } \
77             };
78              
79             /// Explicit specialization for bool.
80             _Cxx_hashtable_define_trivial_hash(bool)
81              
82             /// Explicit specialization for char.
83             _Cxx_hashtable_define_trivial_hash(char)
84              
85             /// Explicit specialization for signed char.
86             _Cxx_hashtable_define_trivial_hash(signed char)
87              
88             /// Explicit specialization for unsigned char.
89             _Cxx_hashtable_define_trivial_hash(unsigned char)
90              
91             /// Explicit specialization for wchar_t.
92             _Cxx_hashtable_define_trivial_hash(wchar_t)
93              
94             /// Explicit specialization for char16_t.
95             _Cxx_hashtable_define_trivial_hash(char16_t)
96              
97             /// Explicit specialization for char32_t.
98 98           _Cxx_hashtable_define_trivial_hash(char32_t)
99              
100             /// Explicit specialization for short.
101             _Cxx_hashtable_define_trivial_hash(short)
102              
103             /// Explicit specialization for int.
104 0           _Cxx_hashtable_define_trivial_hash(int)
105              
106             /// Explicit specialization for long.
107             _Cxx_hashtable_define_trivial_hash(long)
108              
109             /// Explicit specialization for long long.
110             _Cxx_hashtable_define_trivial_hash(long long)
111              
112             /// Explicit specialization for unsigned short.
113             _Cxx_hashtable_define_trivial_hash(unsigned short)
114              
115             /// Explicit specialization for unsigned int.
116 8           _Cxx_hashtable_define_trivial_hash(unsigned int)
117              
118             /// Explicit specialization for unsigned long.
119             _Cxx_hashtable_define_trivial_hash(unsigned long)
120              
121             /// Explicit specialization for unsigned long long.
122             _Cxx_hashtable_define_trivial_hash(unsigned long long)
123              
124             #undef _Cxx_hashtable_define_trivial_hash
125              
126             struct _Hash_impl
127             {
128             static size_t
129             hash(const void* __ptr, size_t __clength,
130             size_t __seed = static_cast(0xc70f6907UL))
131 813           { return _Hash_bytes(__ptr, __clength, __seed); }
132              
133             template
134             static size_t
135             hash(const _Tp& __val)
136             { return hash(&__val, sizeof(__val)); }
137              
138             template
139             static size_t
140             __hash_combine(const _Tp& __val, size_t __hash)
141             { return hash(&__val, sizeof(__val), __hash); }
142             };
143              
144             struct _Fnv_hash_impl
145             {
146             static size_t
147             hash(const void* __ptr, size_t __clength,
148             size_t __seed = static_cast(2166136261UL))
149             { return _Fnv_hash_bytes(__ptr, __clength, __seed); }
150              
151             template
152             static size_t
153             hash(const _Tp& __val)
154             { return hash(&__val, sizeof(__val)); }
155              
156             template
157             static size_t
158             __hash_combine(const _Tp& __val, size_t __hash)
159             { return hash(&__val, sizeof(__val), __hash); }
160             };
161              
162             /// Specialization for float.
163             template<>
164             struct hash : public __hash_base
165             {
166             size_t
167             operator()(float __val) const noexcept
168             {
169             // 0 and -0 both hash to zero.
170             return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
171             }
172             };
173              
174             /// Specialization for double.
175             template<>
176             struct hash : public __hash_base
177             {
178             size_t
179             operator()(double __val) const noexcept
180             {
181             // 0 and -0 both hash to zero.
182             return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
183             }
184             };
185              
186             /// Specialization for long double.
187             template<>
188             struct hash
189             : public __hash_base
190             {
191             _GLIBCXX_PURE size_t
192             operator()(long double __val) const noexcept;
193             };
194              
195             // @} group hashes
196              
197             // Hint about performance of hash functor. If not fast the hash based
198             // containers will cache the hash code.
199             // Default behavior is to consider that hasher are fast unless specified
200             // otherwise.
201             template
202             struct __is_fast_hash : public std::true_type
203             { };
204              
205             template<>
206             struct __is_fast_hash> : public std::false_type
207             { };
208              
209             _GLIBCXX_END_NAMESPACE_VERSION
210             } // namespace
211              
212             #endif // _FUNCTIONAL_HASH_H