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 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
85 hash_list( hash_tuple_type&& t)
86 : hash_tuple( std::forward<hash_tuple_type>(t) )
90 template <size_t I, typename T>
91 typename std::enable_if< (I == sizeof...(Functors)) >::type apply( size_t * dest, T const& v ) const
94 template <size_t I, typename T>
95 typename std::enable_if< (I < sizeof...(Functors)) >::type apply( size_t * dest, T const& v ) const
97 dest[I] = std::get<I>( hash_tuple )( v );
98 apply<I+1>( dest, v );
101 template <typename T>
102 void operator()( size_t * dest, T const& v ) const
107 } // namespace details
111 // At least, two functors must be provided. Single functor is not supported
112 //#if CDS_COMPILER != CDS_COMPILER_INTEL
113 // Intel C++ compiler does not support
114 template <typename Functor> struct hash< std::tuple<Functor> >;
118 /// Multi-functor hash option setter - specialization for std::tuple
119 template <typename... Functors>
120 struct hash< std::tuple<Functors...> >
122 //# if CDS_COMPILER == CDS_COMPILER_INTEL
123 //static_assert( sizeof...(Functors) > 1, "At least, two functors must be provided. Single functor is not supported" );
126 template <typename Base> struct pack: public Base
128 typedef details::hash_list< std::tuple<Functors...> > hash;
137 template <class HashList, typename WrappedType, typename Wrapper>
138 struct hash_list_wrapper {
139 typedef HashList hash_list;
140 typedef WrappedType wrapped_type;
141 typedef Wrapper wrapper_type;
143 typedef typename hash_list::hash_tuple_type hash_tuple_type;
144 static size_t const size = hash_list::size;
146 hash_list m_wrappedList;
150 hash_list_wrapper( hash_tuple_type const& t)
153 # ifdef CDS_MOVE_SEMANTICS_SUPPORT
154 hash_list_wrapper( hash_tuple_type&& t)
155 : m_wrappedList( std::forward<hash_tuple_type>(t) )
159 void operator()( size_t * dest, wrapped_type const& what ) const
161 m_wrappedList( dest, wrapper_type()( what ));
164 template <typename Q>
165 void operator()( size_t * dest, Q const& what) const
167 m_wrappedList( dest, what );
171 } // namespace details
174 }} // namespace cds::opt
176 #endif // #ifndef __CDS_OPT_HASH_H