3 #ifndef __CDS_OPT_HASH_H
4 #define __CDS_OPT_HASH_H
7 #include <cds/opt/options.h>
8 #include <cds/details/hash_functor_selector.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 );
68 template <class> struct hash_list;
69 template <typename... Functors>
70 struct hash_list< std::tuple<Functors...> >
72 static size_t const size = sizeof...(Functors);
73 typedef size_t values[size];
74 typedef std::tuple<Functors...> hash_tuple_type;
76 hash_tuple_type hash_tuple;
81 hash_list( hash_tuple_type const& t)
84 hash_list( hash_tuple_type&& t)
85 : hash_tuple( std::forward<hash_tuple_type>(t) )
88 template <size_t I, typename T>
89 typename std::enable_if< (I == sizeof...(Functors)) >::type apply( size_t * dest, T const& v ) const
92 template <size_t I, typename T>
93 typename std::enable_if< (I < sizeof...(Functors)) >::type apply( size_t * dest, T const& v ) const
95 dest[I] = std::get<I>( hash_tuple )( v );
96 apply<I+1>( dest, v );
100 void operator()( size_t * dest, T const& v ) const
105 } // namespace details
109 // At least, two functors must be provided. Single functor is not supported
110 //#if CDS_COMPILER != CDS_COMPILER_INTEL
111 // Intel C++ compiler does not support
112 template <typename Functor> struct hash< std::tuple<Functor> >;
116 /// Multi-functor hash option setter - specialization for std::tuple
117 template <typename... Functors>
118 struct hash< std::tuple<Functors...> >
120 //# if CDS_COMPILER == CDS_COMPILER_INTEL
121 //static_assert( sizeof...(Functors) > 1, "At least, two functors must be provided. Single functor is not supported" );
124 template <typename Base> struct pack: public Base
126 typedef details::hash_list< std::tuple<Functors...> > hash;
135 template <class HashList, typename WrappedType, typename Wrapper>
136 struct hash_list_wrapper {
137 typedef HashList hash_list;
138 typedef WrappedType wrapped_type;
139 typedef Wrapper wrapper_type;
141 typedef typename hash_list::hash_tuple_type hash_tuple_type;
142 static size_t const size = hash_list::size;
144 hash_list m_wrappedList;
148 hash_list_wrapper( hash_tuple_type const& t)
151 hash_list_wrapper( hash_tuple_type&& t)
152 : m_wrappedList( std::forward<hash_tuple_type>(t) )
155 void operator()( size_t * dest, wrapped_type const& what ) const
157 m_wrappedList( dest, wrapper_type()( what ));
160 template <typename Q>
161 void operator()( size_t * dest, Q const& what) const
163 m_wrappedList( dest, what );
167 } // namespace details
170 }} // namespace cds::opt
172 #endif // #ifndef __CDS_OPT_HASH_H