Use the underlying type for hashing enums

include/boost/container_hash/hash.hpp

@@ -26,7 +26,9 @@
 #include <boost/type_traits/is_floating_point.hpp>
 #include <boost/type_traits/is_signed.hpp>
 #include <boost/type_traits/is_unsigned.hpp>
+#include <boost/type_traits/make_signed.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/conditional.hpp>
 #include <boost/type_traits/enable_if.hpp>
 #include <boost/type_traits/conjunction.hpp>
 #include <boost/cstdint.hpp>
@@ -38,6 +40,10 @@
 #include <climits>
 #include <cstring>
 
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+# include <type_traits>
+#endif
+
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
 # include <memory>
 #endif
@@ -163,21 +169,17 @@ namespace boost
     typename boost::enable_if_<boost::is_enum<T>::value, std::size_t>::type
         hash_value( T v )
     {
-        // This should in principle return the equivalent of
-        //
-        // boost::hash_value( to_underlying(v) );
-        //
-        // However, the C++03 implementation of underlying_type,
-        //
-        // conditional<is_signed<T>, make_signed<T>, make_unsigned<T>>::type::type
-        //
-        // generates a legitimate -Wconversion warning in is_signed,
-        // because -1 is not a valid enum value when all the enumerators
-        // are nonnegative.
-        //
-        // So the legacy implementation will have to do for now.
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
 
-        return static_cast<std::size_t>( v );
+        typedef typename std::underlying_type<T>::type U;
+
+#else
+
+        typedef typename boost::conditional< boost::is_signed<T>::value, boost::make_signed<T>, boost::make_unsigned<T> >::type::type U;
+
+#endif
+
+        return boost::hash_value( static_cast<U>( v ) );
     }
 
     // floating point types
@@ -344,11 +346,12 @@ namespace boost
 
     // pointer types
 
-    // `x + (x >> 3)` adjustment by Alberto Barbati and Dave Harris.
+    // Implementation by Alberto Barbati and Dave Harris.
     template <class T> std::size_t hash_value( T* const& v )
     {
-        boost::uintptr_t x = reinterpret_cast<boost::uintptr_t>( v );
-        return boost::hash_value( x + (x >> 3) );
+        std::size_t x = static_cast<std::size_t>(
+           reinterpret_cast<boost::uintptr_t>(v));
+        return x + (x >> 3);
     }
 
     // array types