CodeMover prototype
[dyninst.git] / external / boost / functional / hash / extensions.hpp
1 \r
2 // Copyright 2005-2008 Daniel James.\r
3 // Distributed under the Boost Software License, Version 1.0. (See accompanying\r
4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\r
5 \r
6 //  Based on Peter Dimov's proposal\r
7 //  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf\r
8 //  issue 6.18. \r
9 \r
10 #if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)\r
11 #define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP\r
12 \r
13 #if defined(_MSC_VER) && (_MSC_VER >= 1020)\r
14 # pragma once\r
15 #endif\r
16 \r
17 namespace boost\r
18 {\r
19 \r
20 #if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)\r
21     namespace hash_detail\r
22     {\r
23         template <bool IsArray>\r
24         struct call_hash_impl\r
25         {\r
26             template <class T>\r
27             struct inner\r
28             {\r
29                 static std::size_t call(T const& v)\r
30                 {\r
31                     using namespace boost;\r
32                     return hash_value(v);\r
33                 }\r
34             };\r
35         };\r
36 \r
37         template <>\r
38         struct call_hash_impl<true>\r
39         {\r
40             template <class Array>\r
41             struct inner\r
42             {\r
43 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\r
44                 static std::size_t call(Array const& v)\r
45 #else\r
46                 static std::size_t call(Array& v)\r
47 #endif\r
48                 {\r
49                     const int size = sizeof(v) / sizeof(*v);\r
50                     return boost::hash_range(v, v + size);\r
51                 }\r
52             };\r
53         };\r
54 \r
55         template <class T>\r
56         struct call_hash\r
57             : public call_hash_impl<boost::is_array<T>::value>\r
58                 ::BOOST_NESTED_TEMPLATE inner<T>\r
59         {\r
60         };\r
61     }\r
62 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING\r
63 \r
64 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)\r
65 \r
66     template <class T> struct hash\r
67         : std::unary_function<T, std::size_t>\r
68     {\r
69 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)\r
70         std::size_t operator()(T const& val) const\r
71         {\r
72             return hash_value(val);\r
73         }\r
74 #else\r
75         std::size_t operator()(T const& val) const\r
76         {\r
77             return hash_detail::call_hash<T>::call(val);\r
78         }\r
79 #endif\r
80     };\r
81 \r
82 #if BOOST_WORKAROUND(__DMC__, <= 0x848)\r
83     template <class T, unsigned int n> struct hash<T[n]>\r
84         : std::unary_function<T[n], std::size_t>\r
85     {\r
86         std::size_t operator()(const T* val) const\r
87         {\r
88             return boost::hash_range(val, val+n);\r
89         }\r
90     };\r
91 #endif\r
92 \r
93 #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\r
94 \r
95     // On compilers without partial specialization, boost::hash<T>\r
96     // has already been declared to deal with pointers, so just\r
97     // need to supply the non-pointer version.\r
98 \r
99     namespace hash_detail\r
100     {\r
101         template <bool IsPointer>\r
102         struct hash_impl;\r
103 \r
104 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\r
105 \r
106         template <>\r
107         struct hash_impl<false>\r
108         {\r
109             template <class T>\r
110             struct inner\r
111                 : std::unary_function<T, std::size_t>\r
112             {\r
113 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)\r
114                 std::size_t operator()(T const& val) const\r
115                 {\r
116                     return hash_value(val);\r
117                 }\r
118 #else\r
119                 std::size_t operator()(T const& val) const\r
120                 {\r
121                     return hash_detail::call_hash<T>::call(val);\r
122                 }\r
123 #endif\r
124             };\r
125         };\r
126 \r
127 #else // Visual C++ 6.5\r
128 \r
129     // There's probably a more elegant way to Visual C++ 6.5 to work\r
130     // but I don't know what it is.\r
131 \r
132         template <bool IsConst>\r
133         struct hash_impl_msvc\r
134         {\r
135             template <class T>\r
136             struct inner\r
137                 : public std::unary_function<T, std::size_t>\r
138             {\r
139                 std::size_t operator()(T const& val) const\r
140                 {\r
141                     return hash_detail::call_hash<T const>::call(val);\r
142                 }\r
143 \r
144                 std::size_t operator()(T& val) const\r
145                 {\r
146                     return hash_detail::call_hash<T>::call(val);\r
147                 }\r
148             };\r
149         };\r
150 \r
151         template <>\r
152         struct hash_impl_msvc<true>\r
153         {\r
154             template <class T>\r
155             struct inner\r
156                 : public std::unary_function<T, std::size_t>\r
157             {\r
158                 std::size_t operator()(T& val) const\r
159                 {\r
160                     return hash_detail::call_hash<T>::call(val);\r
161                 }\r
162             };\r
163         };\r
164         \r
165         template <class T>\r
166         struct hash_impl_msvc2\r
167             : public hash_impl_msvc<boost::is_const<T>::value>\r
168                     ::BOOST_NESTED_TEMPLATE inner<T> {};\r
169         \r
170         template <>\r
171         struct hash_impl<false>\r
172         {\r
173             template <class T>\r
174             struct inner : public hash_impl_msvc2<T> {};\r
175         };\r
176 \r
177 #endif // Visual C++ 6.5\r
178     }\r
179 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION\r
180 }\r
181 \r
182 #endif\r