3 #ifndef __CDS_OPT_HASH_H
4 #define __CDS_OPT_HASH_H
6 #include <cds/opt/options.h>
7 #include <cds/details/hash_functor_selector.h>
8 #include <cds/details/std/tuple.h>
10 namespace cds { namespace opt {
12 /// [type-option] Option setter for a hash function
14 This option setter specifies hash functor used in unordered containers.
16 The default value of template argument \p Functor is \p cds::opt::v::hash
17 that is synonym for <tt>std::hash</tt> implementation of standard library.
18 If standard C++ library of the compiler you use does not provide TR1 implementation
19 the \p cds library automatically selects <tt>boost::hash</tt>.
21 template <typename Functor>
24 template <typename Base> struct pack: public Base
33 using cds::details::hash;
35 /// Metafunction selecting default hash implementation
37 The metafunction selects appropriate hash functor implementation.
38 If \p Hash is not equal to opt::none, then result of metafunction is \p Hash.
39 Otherwise, the result is <tt> std::hash<Q> </tt> or <tt> boost::hash<Q> </tt>
40 depending of compiler you use.
42 Note that default hash function like <tt> std::hash<Q> </tt> or <tt> boost::hash<Q> </tt>
43 is generally not suitable for complex type \p Q and its derivatives.
44 You should manually provide particular hash functor for such types.
46 template <typename Hash>
49 typedef Hash type ; ///< resulting implementation of hash functor
53 struct hash_selector<opt::none>
57 size_t operator()( Q const& key ) const
59 return hash<Q>()( key );
66 #ifdef CDS_CXX11_VARIADIC_TEMPLATE_SUPPORT
69 template <class> struct hash_list;
70 template <typename... Functors>
71 struct hash_list< std::tuple<Functors...> >
73 static size_t const size = sizeof...(Functors);
74 typedef size_t values[size];
75 typedef std::tuple<Functors...> hash_tuple_type;
77 hash_tuple_type hash_tuple;
82 hash_list( hash_tuple_type const& t)
85 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
86 hash_list( hash_tuple_type&& t)
87 : hash_tuple( std::forward<hash_tuple_type>(t) )
91 template <size_t I, typename T>
92 typename std::enable_if< (I == sizeof...(Functors)) >::type apply( size_t * dest, T const& v ) const
95 template <size_t I, typename T>
96 typename std::enable_if< (I < sizeof...(Functors)) >::type apply( size_t * dest, T const& v ) const
98 dest[I] = std::get<I>( hash_tuple )( v );
99 apply<I+1>( dest, v );
102 template <typename T>
103 void operator()( size_t * dest, T const& v ) const
108 } // namespace details
112 // At least, two functors must be provided. Single functor is not supported
113 //#if CDS_COMPILER != CDS_COMPILER_INTEL
114 // Intel C++ compiler does not support
115 template <typename Functor> struct hash< std::tuple<Functor> >;
119 /// Multi-functor hash option setter - specialization for std::tuple
120 template <typename... Functors>
121 struct hash< std::tuple<Functors...> >
123 //# if CDS_COMPILER == CDS_COMPILER_INTEL
124 //static_assert( sizeof...(Functors) > 1, "At least, two functors must be provided. Single functor is not supported" );
127 template <typename Base> struct pack: public Base
129 typedef details::hash_list< std::tuple<Functors...> > hash;
134 #else // no variadic template support
136 template <typename T> struct hash_list;
137 template <typename F1, typename F2>
138 struct hash_list< std::tuple<F1, F2> >
140 static size_t const size = 2;
141 typedef size_t values[size];
142 typedef std::tuple<F1, F2> hash_tuple_type;
144 hash_tuple_type hash_tuple;
148 hash_list( hash_tuple_type const& t)
151 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
152 hash_list( hash_tuple_type&& t)
157 template <typename T>
158 void operator()( size_t * dest, T const& v ) const
160 dest[0] = std::get<0>( hash_tuple )( v );
161 dest[1] = std::get<1>( hash_tuple )( v );
165 template <typename F1, typename F2, typename F3>
166 struct hash_list< std::tuple<F1, F2, F3> >
168 static size_t const size = 3;
169 typedef size_t values[size];
170 typedef std::tuple<F1, F2, F3> hash_tuple_type;
172 hash_tuple_type hash_tuple;
176 hash_list( hash_tuple_type const& t)
179 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
180 hash_list( hash_tuple_type&& t)
185 template <typename T>
186 void operator()( size_t * dest, T const& v ) const
188 dest[0] = std::get<0>( hash_tuple )( v );
189 dest[1] = std::get<1>( hash_tuple )( v );
190 dest[2] = std::get<2>( hash_tuple )( v );
194 template <typename F1, typename F2, typename F3, typename F4>
195 struct hash_list< std::tuple<F1, F2, F3, F4> >
197 static size_t const size = 4;
198 typedef size_t values[size];
199 typedef std::tuple<F1, F2, F3, F4> hash_tuple_type;
201 hash_tuple_type hash_tuple;
205 hash_list( hash_tuple_type const& t)
208 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
209 hash_list( hash_tuple_type&& t)
214 template <typename T>
215 void operator()( size_t * dest, T const& v ) const
217 dest[0] = std::get<0>( hash_tuple )( v );
218 dest[1] = std::get<1>( hash_tuple )( v );
219 dest[2] = std::get<2>( hash_tuple )( v );
220 dest[3] = std::get<3>( hash_tuple )( v );
224 template <typename F1, typename F2, typename F3, typename F4, typename F5>
225 struct hash_list< std::tuple<F1, F2, F3, F4, F5> >
227 static size_t const size = 5;
228 typedef size_t values[size];
229 typedef std::tuple<F1, F2, F3, F4, F5> hash_tuple_type;
231 hash_tuple_type hash_tuple;
235 hash_list( hash_tuple_type const& t)
238 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
239 hash_list( hash_tuple_type&& t)
244 template <typename T>
245 void operator()( size_t * dest, T const& v ) const
247 dest[0] = std::get<0>( hash_tuple )( v );
248 dest[1] = std::get<1>( hash_tuple )( v );
249 dest[2] = std::get<2>( hash_tuple )( v );
250 dest[3] = std::get<3>( hash_tuple )( v );
251 dest[4] = std::get<4>( hash_tuple )( v );
255 template <typename F1, typename F2, typename F3, typename F4, typename F5, typename F6>
256 struct hash_list< std::tuple<F1, F2, F3, F4, F5, F6> >
258 static size_t const size = 6;
259 typedef size_t values[size];
260 typedef std::tuple<F1, F2, F3, F4, F5, F6> hash_tuple_type;
262 hash_tuple_type hash_tuple;
266 hash_list( hash_tuple_type const& t)
269 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
270 hash_list( hash_tuple_type&& t)
275 template <typename T>
276 void operator()( size_t * dest, T const& v ) const
278 dest[0] = std::get<0>( hash_tuple )( v );
279 dest[1] = std::get<1>( hash_tuple )( v );
280 dest[2] = std::get<2>( hash_tuple )( v );
281 dest[3] = std::get<3>( hash_tuple )( v );
282 dest[4] = std::get<4>( hash_tuple )( v );
283 dest[5] = std::get<5>( hash_tuple )( v );
287 template <typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7>
288 struct hash_list< std::tuple<F1, F2, F3, F4, F5, F6, F7> >
290 static size_t const size = 7;
291 typedef size_t values[size];
292 typedef std::tuple<F1, F2, F3, F4, F5, F6, F7> hash_tuple_type;
294 hash_tuple_type hash_tuple;
298 hash_list( hash_tuple_type const& t)
301 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
302 hash_list( hash_tuple_type&& t)
307 template <typename T>
308 void operator()( size_t * dest, T const& v ) const
310 dest[0] = std::get<0>( hash_tuple )( v );
311 dest[1] = std::get<1>( hash_tuple )( v );
312 dest[2] = std::get<2>( hash_tuple )( v );
313 dest[3] = std::get<3>( hash_tuple )( v );
314 dest[4] = std::get<4>( hash_tuple )( v );
315 dest[5] = std::get<5>( hash_tuple )( v );
316 dest[6] = std::get<6>( hash_tuple )( v );
320 template <typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7, typename F8>
321 struct hash_list< std::tuple<F1, F2, F3, F4, F5, F6, F7, F8> >
323 static size_t const size = 8;
324 typedef size_t values[size];
325 typedef std::tuple<F1, F2, F3, F4, F5, F6, F7, F8> hash_tuple_type;
327 hash_tuple_type hash_tuple;
331 hash_list( hash_tuple_type const& t)
334 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
335 hash_list( hash_tuple_type&& t)
340 template <typename T>
341 void operator()( size_t * dest, T const& v ) const
343 dest[0] = std::get<0>( hash_tuple )( v );
344 dest[1] = std::get<1>( hash_tuple )( v );
345 dest[2] = std::get<2>( hash_tuple )( v );
346 dest[3] = std::get<3>( hash_tuple )( v );
347 dest[4] = std::get<4>( hash_tuple )( v );
348 dest[5] = std::get<5>( hash_tuple )( v );
349 dest[6] = std::get<6>( hash_tuple )( v );
350 dest[7] = std::get<7>( hash_tuple )( v );
354 #if !((CDS_COMPILER == CDS_COMPILER_MSVC || CDS_COMPILER == CDS_COMPILER_INTEL) && _MSC_VER == 1700)
355 // MSVC 11: max count of argument is 8
357 template <typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7, typename F8, typename F9>
358 struct hash_list< std::tuple<F1, F2, F3, F4, F5, F6, F7, F8, F9> >
360 static size_t const size = 9;
361 typedef size_t values[size];
362 typedef std::tuple<F1, F2, F3, F4, F5, F6, F7, F8, F9> hash_tuple_type;
364 hash_tuple_type hash_tuple;
368 hash_list( hash_tuple_type const& t)
371 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
372 hash_list( hash_tuple_type&& t)
377 template <typename T>
378 void operator()( size_t * dest, T const& v ) const
380 dest[0] = std::get<0>( hash_tuple )( v );
381 dest[1] = std::get<1>( hash_tuple )( v );
382 dest[2] = std::get<2>( hash_tuple )( v );
383 dest[3] = std::get<3>( hash_tuple )( v );
384 dest[4] = std::get<4>( hash_tuple )( v );
385 dest[5] = std::get<5>( hash_tuple )( v );
386 dest[6] = std::get<6>( hash_tuple )( v );
387 dest[7] = std::get<7>( hash_tuple )( v );
388 dest[8] = std::get<8>( hash_tuple )( v );
392 template <typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7, typename F8, typename F9,
394 struct hash_list< std::tuple<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> >
396 static size_t const size = 10;
397 typedef size_t values[size];
398 typedef std::tuple<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> hash_tuple_type;
400 hash_tuple_type hash_tuple;
404 hash_list( hash_tuple_type const& t)
407 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
408 hash_list( hash_tuple_type&& t)
413 template <typename T>
414 void operator()( size_t * dest, T const& v ) const
416 dest[0] = std::get<0>( hash_tuple )( v );
417 dest[1] = std::get<1>( hash_tuple )( v );
418 dest[2] = std::get<2>( hash_tuple )( v );
419 dest[3] = std::get<3>( hash_tuple )( v );
420 dest[4] = std::get<4>( hash_tuple )( v );
421 dest[5] = std::get<5>( hash_tuple )( v );
422 dest[6] = std::get<6>( hash_tuple )( v );
423 dest[7] = std::get<7>( hash_tuple )( v );
424 dest[8] = std::get<8>( hash_tuple )( v );
425 dest[9] = std::get<9>( hash_tuple )( v );
429 } // namespace details
431 template< typename F1, typename F2 >
432 struct hash< std::tuple< F1, F2 > >
435 template <typename Base> struct pack: public Base
437 typedef details::hash_list< std::tuple<F1, F2> > hash;
441 template< typename F1, typename F2, typename F3 >
442 struct hash< std::tuple< F1, F2, F3 > >
445 template <typename Base> struct pack: public Base
447 typedef details::hash_list< std::tuple<F1, F2, F3> > hash;
451 template< typename F1, typename F2, typename F3, typename F4 >
452 struct hash< std::tuple< F1, F2, F3, F4 > >
455 template <typename Base> struct pack: public Base
457 typedef details::hash_list< std::tuple<F1, F2, F3, F4> > hash;
461 template< typename F1, typename F2, typename F3, typename F4, typename F5 >
462 struct hash< std::tuple< F1, F2, F3, F4, F5 > >
465 template <typename Base> struct pack: public Base
467 typedef details::hash_list< std::tuple<F1, F2, F3, F4, F5> > hash;
471 template< typename F1, typename F2, typename F3, typename F4, typename F5, typename F6 >
472 struct hash< std::tuple< F1, F2, F3, F4, F5, F6 > >
475 template <typename Base> struct pack: public Base
477 typedef details::hash_list< std::tuple<F1, F2, F3, F4, F5, F6> > hash;
481 template< typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7 >
482 struct hash< std::tuple< F1, F2, F3, F4, F5, F6, F7 > >
485 template <typename Base> struct pack: public Base
487 typedef details::hash_list< std::tuple<F1, F2, F3, F4, F5, F6, F7> > hash;
491 template< typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7, typename F8 >
492 struct hash< std::tuple< F1, F2, F3, F4, F5, F6, F7, F8 > >
495 template <typename Base> struct pack: public Base
497 typedef details::hash_list< std::tuple<F1, F2, F3, F4, F5, F6, F7, F8> > hash;
502 #if !((CDS_COMPILER == CDS_COMPILER_MSVC || CDS_COMPILER == CDS_COMPILER_INTEL) && _MSC_VER == 1700)
503 // MSVC 11: max count of argument is 8
505 template< typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7, typename F8, typename F9 >
506 struct hash< std::tuple< F1, F2, F3, F4, F5, F6, F7, F8, F9 > >
509 template <typename Base> struct pack: public Base
511 typedef details::hash_list< std::tuple<F1, F2, F3, F4, F5, F6, F7, F8, F9> > hash;
515 template< typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7, typename F8, typename F9,
517 struct hash< std::tuple< F1, F2, F3, F4, F5, F6, F7, F8, F9, F10 > >
520 template <typename Base> struct pack: public Base
522 typedef details::hash_list< std::tuple<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> > hash;
527 #endif // #ifdef CDS_CXX11_VARIADIC_TEMPLATE_SUPPORT
532 template <class HashList, typename WrappedType, typename Wrapper>
533 struct hash_list_wrapper {
534 typedef HashList hash_list;
535 typedef WrappedType wrapped_type;
536 typedef Wrapper wrapper_type;
538 typedef typename hash_list::hash_tuple_type hash_tuple_type;
539 static size_t const size = hash_list::size;
541 hash_list m_wrappedList;
545 hash_list_wrapper( hash_tuple_type const& t)
548 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
549 hash_list_wrapper( hash_tuple_type&& t)
550 : m_wrappedList( std::forward<hash_tuple_type>(t) )
554 void operator()( size_t * dest, wrapped_type const& what ) const
556 m_wrappedList( dest, wrapper_type()( what ));
559 template <typename Q>
560 void operator()( size_t * dest, Q const& what) const
562 m_wrappedList( dest, what );
566 } // namespace details
569 }} // namespace cds::opt
571 #endif // #ifndef __CDS_OPT_HASH_H