Disable warnings as errors for hash.

[SVN r61207]

doc/CMakeLists.txt

@@ -1,2 +0,0 @@
-message(STATUS "functional/hash docs need love")
-

doc/Jamfile.v2

@@ -5,10 +5,7 @@
 
 xml hash : hash.qbk ;
 boostbook standalone : hash :
-    <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
     <xsl:param>boost.root=../../../..
-    <xsl:param>boost.libraries=../../../libraries.htm
-    <xsl:param>navig.graphics=1
 
     <xsl:param>chunk.first.sections=1
     <xsl:param>chunk.section.depth=2

doc/changes.qbk

@@ -84,4 +84,16 @@
 * [@https://svn.boost.org/trac/boost/ticket/2957 Ticket 2957]: Fix configuration
   for vxworks.
 
+[h2 Boost 1.40.0]
+
+* Automatically configure the float functions using template metaprogramming
+  instead of trying to configure every possibility manually.
+* Workaround for when STLport doesn't support long double.
+
+[h2 Boost 1.42.0]
+
+* Reduce the number of warnings for Visual C++ warning level 4.
+* Some code formatting changes to fit lines into 80 characters.
+* Rename an internal namespace.
+
 [endsect]

doc/tutorial.qbk

@@ -110,7 +110,7 @@ And you can now use [classref boost::hash] with book:
     assert(books.find(dandelion) == books.end());
 
 The full example can be found in:
-[@boost:/libs/functional/hash/examples/books.cpp /libs/functional/hash/examples/books.hpp]
+[@boost:/libs/functional/hash/examples/books.hpp /libs/functional/hash/examples/books.hpp]
 and
 [@boost:/libs/functional/hash/examples/books.cpp /libs/functional/hash/examples/books.cpp].
 

examples/CMakeLists.txt

@@ -1,9 +0,0 @@
-#-------------------------------------------------------------------------
-#-- Needed include directories for the tests
-boost_additional_test_dependencies(config BOOST_DEPENDS test)
-#-------------------------------------------------------------------------
-boost_test_run(books)
-boost_test_run(point)
-boost_test_run(portable)
-
-

examples/books.cpp

@@ -20,6 +20,7 @@ int main()
 
     boost::hash<library::book> book_hasher;
     std::size_t knife_hash_value = book_hasher(knife);
+    (void)knife_hash_value; // suppress unused variable warning
 
     // If std::unordered_set was available:
     //

include/boost/functional/hash/detail/float_functions.hpp

@@ -6,6 +6,7 @@
 #if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP)
 #define BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP
 
+#include <boost/config.hpp>
 #include <boost/config/no_tr1/cmath.hpp>
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
@@ -17,146 +18,229 @@
 // library implementations don't support this. On some that don't, the C99
 // float functions (frexpf, frexpl, etc.) are available.
 //
-// Some of this is based on guess work. If I don't know any better I assume that
-// the standard C++ overloaded functions are available. If they're not then this
-// means that the argument is cast to a double and back, which is inefficient
-// and will give pretty bad results for long doubles - so if you know better
-// let me know.
+// The following tries to automatically detect which are available.
 
-// STLport:
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#  if (defined(__GNUC__) && __GNUC__ < 3 && (defined(linux) || defined(__linux) || defined(__linux__))) || defined(__DMC__)
-#    define BOOST_HASH_USE_C99_FLOAT_FUNCS
-#  elif defined(BOOST_MSVC) && BOOST_MSVC < 1300
-#    define BOOST_HASH_USE_C99_FLOAT_FUNCS
-#  else
-#    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
-#  endif
+namespace boost {
+    namespace hash_detail {
 
-// Roguewave:
+        // Returned by dummy versions of the float functions.
+    
+        struct not_found {
+            // Implicitly convertible to float and long double in order to avoid
+            // a compile error when the dummy float functions are used.
+
+            inline operator float() const { return 0; }
+            inline operator long double() const { return 0; }
+        };
+          
+        // A type for detecting the return type of functions.
+
+        template <typename T> struct is;
+        template <> struct is<float> { char x[10]; };
+        template <> struct is<double> { char x[20]; };
+        template <> struct is<long double> { char x[30]; };
+        template <> struct is<boost::hash_detail::not_found> { char x[40]; };
+            
+        // Used to convert the return type of a function to a type for sizeof.
+
+        template <typename T> is<T> float_type(T);
+
+        // call_ldexp
+        //
+        // This will get specialized for float and long double
+        
+        template <typename Float> struct call_ldexp
+        {
+            typedef double float_type;
+            
+            inline double operator()(double a, int b) const
+            {
+                using namespace std;
+                return ldexp(a, b);
+            }
+        };
+
+        // call_frexp
+        //
+        // This will get specialized for float and long double
+
+        template <typename Float> struct call_frexp
+        {
+            typedef double float_type;
+            
+            inline double operator()(double a, int* b) const
+            {
+                using namespace std;
+                return frexp(a, b);
+            }
+        };
+    }
+}
+            
+// A namespace for dummy functions to detect when the actual function we want
+// isn't available. ldexpl, ldexpf etc. might be added tby the macros below.
 //
-// On borland 5.51, with roguewave 2.1.1 the standard C++ overloads aren't
-// defined, but for the same version of roguewave on sunpro they are.
-#elif defined(_RWSTD_VER)
-#  if defined(__BORLANDC__)
-#    define BOOST_HASH_USE_C99_FLOAT_FUNCS
-#    define BOOST_HASH_C99_NO_FLOAT_FUNCS
-#  elif defined(__DECCXX)
-#    define BOOST_HASH_USE_C99_FLOAT_FUNCS
-#  else
-#    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
-#  endif
+// AFAICT these have to be outside of the boost namespace, as if they're in
+// the boost namespace they'll always be preferable to any other function
+// (since the arguments are built in types, ADL can't be used).
 
-// libstdc++ (gcc 3.0 onwards, I think)
-#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-#  define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
+namespace boost_hash_detect_float_functions {
+    template <class Float> boost::hash_detail::not_found ldexp(Float, int);
+    template <class Float> boost::hash_detail::not_found frexp(Float, int*);    
+}
 
-// SGI:
-#elif defined(__STL_CONFIG_H)
-#  if defined(linux) || defined(__linux) || defined(__linux__)
-#    define BOOST_HASH_USE_C99_FLOAT_FUNCS
-#  else
-#    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
-#  endif
+// Macros for generating specializations of call_ldexp and call_frexp.
+//
+// check_cpp and check_c99 check if the C++ or C99 functions are available.
+//
+// Then the call_* functions select an appropriate implementation.
+//
+// I used c99_func in a few places just to get a unique name.
+//
+// Important: when using 'using namespace' at namespace level, include as
+// little as possible in that namespace, as Visual C++ has an odd bug which
+// can cause the namespace to be imported at the global level. This seems to
+// happen mainly when there's a template in the same namesapce.
 
-// vxWorks. It has its own math library, but uses Dinkumware STL
-#elif defined(__VXWORKS__)
-#  define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
+#define BOOST_HASH_CALL_FLOAT_FUNC(cpp_func, c99_func, type1, type2)    \
+namespace boost_hash_detect_float_functions {                           \
+    template <class Float>                                              \
+    boost::hash_detail::not_found c99_func(Float, type2);               \
+}                                                                       \
+                                                                        \
+namespace boost {                                                       \
+    namespace hash_detail {                                             \
+        namespace c99_func##_detect {                                   \
+            using namespace std;                                        \
+            using namespace boost_hash_detect_float_functions;          \
+                                                                        \
+            struct check {                                              \
+                static type1 x;                                         \
+                static type2 y;                                         \
+                BOOST_STATIC_CONSTANT(bool, cpp =                       \
+                    sizeof(float_type(cpp_func(x,y)))                   \
+                        == sizeof(is<type1>));                          \
+                BOOST_STATIC_CONSTANT(bool, c99 =                       \
+                    sizeof(float_type(c99_func(x,y)))                   \
+                        == sizeof(is<type1>));                          \
+            };                                                          \
+        }                                                               \
+                                                                        \
+        template <bool x>                                               \
+        struct call_c99_##c99_func :                                    \
+            boost::hash_detail::call_##cpp_func<double> {};             \
+                                                                        \
+        template <>                                                     \
+        struct call_c99_##c99_func<true> {                              \
+            typedef type1 float_type;                                   \
+                                                                        \
+            template <typename T>                                       \
+            inline type1 operator()(type1 a, T b)  const                \
+            {                                                           \
+                using namespace std;                                    \
+                return c99_func(a, b);                                  \
+            }                                                           \
+        };                                                              \
+                                                                        \
+        template <bool x>                                               \
+        struct call_cpp_##c99_func :                                    \
+            call_c99_##c99_func<                                        \
+                ::boost::hash_detail::c99_func##_detect::check::c99     \
+            > {};                                                       \
+                                                                        \
+        template <>                                                     \
+        struct call_cpp_##c99_func<true> {                              \
+            typedef type1 float_type;                                   \
+                                                                        \
+            template <typename T>                                       \
+            inline type1 operator()(type1 a, T b)  const                \
+            {                                                           \
+                using namespace std;                                    \
+                return cpp_func(a, b);                                  \
+            }                                                           \
+        };                                                              \
+                                                                        \
+        template <>                                                     \
+        struct call_##cpp_func<type1> :                                 \
+            call_cpp_##c99_func<                                        \
+                ::boost::hash_detail::c99_func##_detect::check::cpp     \
+            > {};                                                       \
+    }                                                                   \
+}
 
-// Dinkumware.
-#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
-// Some versions of Visual C++ don't seem to have the C++ overloads but they
-// all seem to have the c99 float overloads
-#  if defined(BOOST_MSVC)
-#    define BOOST_HASH_USE_C99_FLOAT_FUNCS
-// On other platforms the C++ overloads seem to have been introduced sometime
-// before 402.
-#  elif defined(_CPPLIB_VER) && (_CPPLIB_VER >= 402)
-#    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
-#  else
-#    define BOOST_HASH_USE_C99_FLOAT_FUNCS
-#  endif
+#define BOOST_HASH_CALL_FLOAT_MACRO(cpp_func, c99_func, type1, type2)   \
+namespace boost {                                                       \
+    namespace hash_detail {                                             \
+                                                                        \
+        template <>                                                     \
+        struct call_##cpp_func<type1> {                                 \
+            typedef type1 float_type;                                   \
+            inline type1 operator()(type1 x, type2 y) const {           \
+                return c99_func(x, y);                                  \
+            }                                                           \
+        };                                                              \
+    }                                                                   \
+}
 
-// Digital Mars
-#elif defined(__DMC__)
-#  define BOOST_HASH_USE_C99_FLOAT_FUNCS
-
-// Use overloaded float functions by default.
+#if defined(ldexpf)
+BOOST_HASH_CALL_FLOAT_MACRO(ldexp, ldexpf, float, int)
 #else
-#  define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
+BOOST_HASH_CALL_FLOAT_FUNC(ldexp, ldexpf, float, int)
 #endif
 
+#if defined(ldexpl)
+BOOST_HASH_CALL_FLOAT_MACRO(ldexp, ldexpl, long double, int)
+#else
+BOOST_HASH_CALL_FLOAT_FUNC(ldexp, ldexpl, long double, int)
+#endif
+
+#if defined(frexpf)
+BOOST_HASH_CALL_FLOAT_MACRO(frexp, frexpf, float, int*)
+#else
+BOOST_HASH_CALL_FLOAT_FUNC(frexp, frexpf, float, int*)
+#endif
+
+#if defined(frexpl)
+BOOST_HASH_CALL_FLOAT_MACRO(frexp, frexpl, long double, int*)
+#else
+BOOST_HASH_CALL_FLOAT_FUNC(frexp, frexpl, long double, int*)
+#endif
+
+#undef BOOST_HASH_CALL_FLOAT_MACRO
+#undef BOOST_HASH_CALL_FLOAT_FUNC
+
+
 namespace boost
 {
     namespace hash_detail
     {
+        template <typename Float1, typename Float2>
+        struct select_hash_type_impl {
+            typedef double type;
+        };
 
-        inline float call_ldexp(float v, int exp)
-        {
-            using namespace std;
-#if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS) || \
-    defined(BOOST_HASH_C99_NO_FLOAT_FUNCS)
-            return ldexp(v, exp);
-#else
-            return ldexpf(v, exp);
-#endif
-        }
+        template <>
+        struct select_hash_type_impl<float, float> {
+            typedef float type;
+        };
 
-        inline double call_ldexp(double v, int exp)
-        {
-            using namespace std;
-            return ldexp(v, exp);
-        }
+        template <>
+        struct select_hash_type_impl<long double, long double> {
+            typedef long double type;
+        };
 
-        inline long double call_ldexp(long double v, int exp)
-        {
-            using namespace std;
-#if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS)
-            return ldexp(v, exp);
-#else
-            return ldexpl(v, exp);
-#endif
-        }
 
-        inline float call_frexp(float v, int* exp)
-        {
-            using namespace std;
-#if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS) || \
-    defined(BOOST_HASH_C99_NO_FLOAT_FUNCS)
-            return frexp(v, exp);
-#else
-            return frexpf(v, exp);
-#endif
-        }
-
-        inline double call_frexp(double v, int* exp)
-        {
-            using namespace std;
-            return frexp(v, exp);
-        }
-
-        inline long double call_frexp(long double v, int* exp)
-        {
-            using namespace std;
-#if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS)
-            return frexp(v, exp);
-#else
-            return frexpl(v, exp);
-#endif
-        }
+        // select_hash_type
+        //
+        // If there is support for a particular floating point type, use that
+        // otherwise use double (there's always support for double).
+             
+        template <typename Float>
+        struct select_hash_type : select_hash_type_impl<
+                BOOST_DEDUCED_TYPENAME call_ldexp<Float>::float_type,
+                BOOST_DEDUCED_TYPENAME call_frexp<Float>::float_type
+            > {};            
     }
 }
 
-#if defined(BOOST_HASH_USE_C99_FLOAT_FUNCS)
-#undef BOOST_HASH_USE_C99_FLOAT_FUNCS
-#endif
-
-#if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS)
-#undef BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
-#endif
-
-#if defined(BOOST_HASH_C99_NO_FLOAT_FUNCS)
-#undef BOOST_HASH_C99_NO_FLOAT_FUNCS
-#endif
-
 #endif

include/boost/functional/hash/detail/hash_float.hpp

@@ -10,164 +10,57 @@
 # pragma once
 #endif
 
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#if BOOST_MSVC >= 1400
-#pragma warning(disable:6294) // Ill-defined for-loop: initial condition does
-                              // not satisfy test. Loop body not executed 
-#endif
-#endif
-
+#include <boost/config.hpp>
 #include <boost/functional/hash/detail/float_functions.hpp>
+#include <boost/functional/hash/detail/limits.hpp>
 #include <boost/integer/static_log2.hpp>
 #include <boost/cstdint.hpp>
-#include <boost/limits.hpp>
 #include <boost/assert.hpp>
 
-// Select implementation for the current platform.
+// Include hash implementation for the current platform.
 
 // Cygwn
 #if defined(__CYGWIN__)
 #  if defined(__i386__) || defined(_M_IX86)
-#    define BOOST_HASH_USE_x86_BINARY_HASH
+#    include <boost/functional/hash/detail/hash_float_x86.hpp>
+#  else
+#    include <boost/functional/hash/detail/hash_float_generic.hpp>
 #  endif
+#else
+#  include <boost/functional/hash/detail/hash_float_generic.hpp>
+#endif
+
+// Can we use fpclassify?
 
 // STLport
-#elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-// fpclassify aren't good enough on STLport.
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define BOOST_HASH_USE_FPCLASSIFY 0
 
 // GNU libstdc++ 3
 #elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
 #  if (defined(__USE_ISOC99) || defined(_GLIBCXX_USE_C99_MATH)) && \
       !(defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))
-#    define BOOST_HASH_USE_FPCLASSIFY
+#    define BOOST_HASH_USE_FPCLASSIFY 1
+#  else
+#    define BOOST_HASH_USE_FPCLASSIFY 0
 #  endif
 
-// Dinkumware Library, on Visual C++ 
-#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
-
-// Not using _fpclass because it is only available for double.
-
+// Everything else
+#else
+#  define BOOST_HASH_USE_FPCLASSIFY 0
 #endif
 
-// On OpenBSD, numeric_limits is not reliable for long doubles, but
-// the macros defined in <float.h> are.
+#if BOOST_HASH_USE_FPCLASSIFY
 
-#if defined(__OpenBSD__)
-#include <float.h>
-#endif
+#include <boost/config/no_tr1/cmath.hpp>
 
 namespace boost
 {
     namespace hash_detail
     {
-        template <class T>
-        struct limits : std::numeric_limits<T> {};
-
-#if defined(__OpenBSD__)
-        template <>
-        struct limits<long double>
-             : std::numeric_limits<long double>
-        {
-            static long double epsilon() {
-                return LDBL_EPSILON;
-            }
-
-            static long double (max)() {
-                return LDBL_MAX;
-            }
-
-            static long double (min)() {
-                return LDBL_MIN;
-            }
-
-            BOOST_STATIC_CONSTANT(int, digits = LDBL_MANT_DIG);
-            BOOST_STATIC_CONSTANT(int, max_exponent = LDBL_MAX_EXP);
-            BOOST_STATIC_CONSTANT(int, min_exponent = LDBL_MIN_EXP);
-        };
-#endif // __OpenBSD__
-
-        inline void hash_float_combine(std::size_t& seed, std::size_t value)
-        {
-            seed ^= value + (seed<<6) + (seed>>2);
-        }
-
-// A simple, non-portable hash algorithm for x86.
-#if defined(BOOST_HASH_USE_x86_BINARY_HASH)
-        inline std::size_t float_hash_impl(float v)
-        {
-            boost::uint32_t* ptr = (boost::uint32_t*)&v;
-            std::size_t seed = *ptr;
-            return seed;
-        }
-
-        inline std::size_t float_hash_impl(double v)
-        {
-            boost::uint32_t* ptr = (boost::uint32_t*)&v;
-            std::size_t seed = *ptr++;
-            hash_float_combine(seed, *ptr);
-            return seed;
-        }
-
-        inline std::size_t float_hash_impl(long double v)
-        {
-            boost::uint32_t* ptr = (boost::uint32_t*)&v;
-            std::size_t seed = *ptr++;
-            hash_float_combine(seed, *ptr++);
-            hash_float_combine(seed, *(boost::uint16_t*)ptr);
-            return seed;
-        }
-
-#else
-
-        template <class T>
-        inline std::size_t float_hash_impl(T v)
-        {
-            int exp = 0;
-
-            v = boost::hash_detail::call_frexp(v, &exp);
-
-            // A postive value is easier to hash, so combine the
-            // sign with the exponent.
-            if(v < 0) {
-                v = -v;
-                exp += limits<T>::max_exponent -
-                    limits<T>::min_exponent;
-            }
-
-            // The result of frexp is always between 0.5 and 1, so its
-            // top bit will always be 1. Subtract by 0.5 to remove that.
-            v -= T(0.5);
-            v = boost::hash_detail::call_ldexp(v,
-                    limits<std::size_t>::digits + 1);
-            std::size_t seed = static_cast<std::size_t>(v);
-            v -= seed;
-
-            // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1;
-            std::size_t const length
-                = (limits<T>::digits *
-                        boost::static_log2<limits<T>::radix>::value - 1)
-                / limits<std::size_t>::digits;
-
-            for(std::size_t i = 0; i != length; ++i)
-            {
-                v = boost::hash_detail::call_ldexp(v,
-                        limits<std::size_t>::digits);
-                std::size_t part = static_cast<std::size_t>(v);
-                v -= part;
-                hash_float_combine(seed, part);
-            }
-
-            hash_float_combine(seed, exp);
-
-            return seed;
-        }
-#endif
-
         template <class T>
         inline std::size_t float_hash_value(T v)
         {
-#if defined(BOOST_HASH_USE_FPCLASSIFY)
             using namespace std;
             switch (fpclassify(v)) {
             case FP_ZERO:
@@ -183,15 +76,26 @@ namespace boost
                 BOOST_ASSERT(0);
                 return 0;
             }
-#else
-            return v == 0 ? 0 : float_hash_impl(v);
-#endif
         }
     }
 }
 
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
+#else // !BOOST_HASH_USE_FPCLASSIFY
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        template <class T>
+        inline std::size_t float_hash_value(T v)
+        {
+            return v == 0 ? 0 : float_hash_impl(v);
+        }
+    }
+}
+
+#endif // BOOST_HASH_USE_FPCLASSIFY
+
+#undef BOOST_HASH_USE_FPCLASSIFY
 
 #endif

include/boost/functional/hash/detail/hash_float_generic.hpp

@@ -0,0 +1,91 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// A general purpose hash function for non-zero floating point values.
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_GENERIC_HEADER)
+#define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_GENERIC_HEADER
+
+#include <boost/functional/hash/detail/float_functions.hpp>
+#include <boost/integer/static_log2.hpp>
+#include <boost/functional/hash/detail/limits.hpp>
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#if BOOST_MSVC >= 1400
+#pragma warning(disable:6294) // Ill-defined for-loop: initial condition does
+                              // not satisfy test. Loop body not executed 
+#endif
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        inline void hash_float_combine(std::size_t& seed, std::size_t value)
+        {
+            seed ^= value + (seed<<6) + (seed>>2);
+        }
+
+        template <class T>
+        inline std::size_t float_hash_impl2(T v)
+        {
+            boost::hash_detail::call_frexp<T> frexp;
+            boost::hash_detail::call_ldexp<T> ldexp;
+        
+            int exp = 0;
+
+            v = frexp(v, &exp);
+
+            // A postive value is easier to hash, so combine the
+            // sign with the exponent and use the absolute value.
+            if(v < 0) {
+                v = -v;
+                exp += limits<T>::max_exponent -
+                    limits<T>::min_exponent;
+            }
+
+            v = ldexp(v, limits<std::size_t>::digits);
+            std::size_t seed = static_cast<std::size_t>(v);
+            v -= seed;
+
+            // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1;
+            std::size_t const length
+                = (limits<T>::digits *
+                        boost::static_log2<limits<T>::radix>::value
+                        + limits<std::size_t>::digits - 1)
+                / limits<std::size_t>::digits;
+
+            for(std::size_t i = 0; i != length; ++i)
+            {
+                v = ldexp(v, limits<std::size_t>::digits);
+                std::size_t part = static_cast<std::size_t>(v);
+                v -= part;
+                hash_float_combine(seed, part);
+            }
+
+            hash_float_combine(seed, exp);
+
+            return seed;
+        }
+
+        template <class T>
+        inline std::size_t float_hash_impl(T v)
+        {
+            typedef BOOST_DEDUCED_TYPENAME select_hash_type<T>::type type;
+            return float_hash_impl2(static_cast<type>(v));
+        }
+    }
+}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif

include/boost/functional/hash/detail/hash_float_x86.hpp

@@ -0,0 +1,56 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// A non-portable hash function form non-zero floats on x86.
+//
+// Even if you're on an x86 platform, this might not work if their floating
+// point isn't set up as this expects. So this should only be used if it's
+// absolutely certain that it will work.
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_X86_HEADER)
+#define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_X86_HEADER
+
+#include <boost/cstdint.hpp>
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        inline void hash_float_combine(std::size_t& seed, std::size_t value)
+        {
+            seed ^= value + (seed<<6) + (seed>>2);
+        }
+
+        inline std::size_t float_hash_impl(float v)
+        {
+            boost::uint32_t* ptr = (boost::uint32_t*)&v;
+            std::size_t seed = *ptr;
+            return seed;
+        }
+
+        inline std::size_t float_hash_impl(double v)
+        {
+            boost::uint32_t* ptr = (boost::uint32_t*)&v;
+            std::size_t seed = *ptr++;
+            hash_float_combine(seed, *ptr);
+            return seed;
+        }
+
+        inline std::size_t float_hash_impl(long double v)
+        {
+            boost::uint32_t* ptr = (boost::uint32_t*)&v;
+            std::size_t seed = *ptr++;
+            hash_float_combine(seed, *ptr++);
+            hash_float_combine(seed, *(boost::uint16_t*)ptr);
+            return seed;
+        }
+    }
+}
+
+#endif

include/boost/functional/hash/detail/limits.hpp

@@ -0,0 +1,61 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// On some platforms std::limits gives incorrect values for long double.
+// This tries to work around them.
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER)
+#define BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/limits.hpp>
+
+// On OpenBSD, numeric_limits is not reliable for long doubles, but
+// the macros defined in <float.h> are and support long double when STLport
+// doesn't.
+
+#if defined(__OpenBSD__) || defined(_STLP_NO_LONG_DOUBLE)
+#include <float.h>
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        template <class T>
+        struct limits : std::numeric_limits<T> {};
+
+#if defined(__OpenBSD__) || defined(_STLP_NO_LONG_DOUBLE)
+        template <>
+        struct limits<long double>
+             : std::numeric_limits<long double>
+        {
+            static long double epsilon() {
+                return LDBL_EPSILON;
+            }
+
+            static long double (max)() {
+                return LDBL_MAX;
+            }
+
+            static long double (min)() {
+                return LDBL_MIN;
+            }
+
+            BOOST_STATIC_CONSTANT(int, digits = LDBL_MANT_DIG);
+            BOOST_STATIC_CONSTANT(int, max_exponent = LDBL_MAX_EXP);
+            BOOST_STATIC_CONSTANT(int, min_exponent = LDBL_MIN_EXP);
+#if defined(_STLP_NO_LONG_DOUBLE)
+            BOOST_STATIC_CONSTANT(int, radix = FLT_RADIX);
+#endif
+        };
+#endif // __OpenBSD__
+    }
+}
+
+#endif

include/boost/functional/hash/extensions.hpp

@@ -7,15 +7,114 @@
 //  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
 //  issue 6.18. 
 
+// This implements the extensions to the standard.
+// It's undocumented, so you shouldn't use it....
+
 #if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
 #define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP
 
+#include <boost/functional/hash/hash.hpp>
+#include <boost/detail/container_fwd.hpp>
+
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 
+#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#include <boost/type_traits/is_array.hpp>
+#endif
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#include <boost/type_traits/is_const.hpp>
+#endif
+
 namespace boost
 {
+    template <class A, class B>
+    std::size_t hash_value(std::pair<A, B> const&);
+    template <class T, class A>
+    std::size_t hash_value(std::vector<T, A> const&);
+    template <class T, class A>
+    std::size_t hash_value(std::list<T, A> const& v);
+    template <class T, class A>
+    std::size_t hash_value(std::deque<T, A> const& v);
+    template <class K, class C, class A>
+    std::size_t hash_value(std::set<K, C, A> const& v);
+    template <class K, class C, class A>
+    std::size_t hash_value(std::multiset<K, C, A> const& v);
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::map<K, T, C, A> const& v);
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::multimap<K, T, C, A> const& v);
+
+    template <class T>
+    std::size_t hash_value(std::complex<T> const&);
+
+    template <class A, class B>
+    std::size_t hash_value(std::pair<A, B> const& v)
+    {
+        std::size_t seed = 0;
+        hash_combine(seed, v.first);
+        hash_combine(seed, v.second);
+        return seed;
+    }
+
+    template <class T, class A>
+    std::size_t hash_value(std::vector<T, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+    template <class T, class A>
+    std::size_t hash_value(std::list<T, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+    template <class T, class A>
+    std::size_t hash_value(std::deque<T, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class C, class A>
+    std::size_t hash_value(std::set<K, C, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class C, class A>
+    std::size_t hash_value(std::multiset<K, C, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::map<K, T, C, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::multimap<K, T, C, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+    template <class T>
+    std::size_t hash_value(std::complex<T> const& v)
+    {
+        boost::hash<T> hasher;
+        std::size_t seed = hasher(v.imag());
+        seed ^= hasher(v.real()) + (seed<<6) + (seed>>2);
+        return seed;
+    }
+
+    //
+    // call_hash_impl
+    //
+
+    // On compilers without function template ordering, this deals with arrays.
 
 #if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
     namespace hash_detail
@@ -61,6 +160,11 @@ namespace boost
     }
 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
+    //
+    // boost::hash
+    //
+
+
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
     template <class T> struct hash
@@ -94,7 +198,7 @@ namespace boost
 
     // On compilers without partial specialization, boost::hash<T>
     // has already been declared to deal with pointers, so just
-    // need to supply the non-pointer version.
+    // need to supply the non-pointer version of hash_impl.
 
     namespace hash_detail
     {
@@ -126,8 +230,8 @@ namespace boost
 
 #else // Visual C++ 6.5
 
-    // There's probably a more elegant way to Visual C++ 6.5 to work
-    // but I don't know what it is.
+        // Visual C++ 6.5 has problems with nested member functions and
+        // applying const to const types in templates. So we get this:
 
         template <bool IsConst>
         struct hash_impl_msvc

include/boost/functional/hash/hash.hpp

@@ -13,19 +13,18 @@
 #include <boost/functional/hash/hash_fwd.hpp>
 #include <functional>
 #include <boost/functional/hash/detail/hash_float.hpp>
-#include <boost/detail/container_fwd.hpp>
 #include <string>
+#include <boost/limits.hpp>
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 #include <boost/type_traits/is_pointer.hpp>
 #endif
 
-#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#include <boost/type_traits/is_array.hpp>
-#endif
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-#include <boost/type_traits/is_const.hpp>
+#if BOOST_WORKAROUND(__GNUC__, < 3) \
+    && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+#define BOOST_HASH_CHAR_TRAITS string_char_traits
+#else
+#define BOOST_HASH_CHAR_TRAITS char_traits
 #endif
 
 namespace boost
@@ -45,7 +44,7 @@ namespace boost
     std::size_t hash_value(wchar_t);
 #endif
     
-#if defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_LONG_LONG)
     std::size_t hash_value(boost::long_long_type);
     std::size_t hash_value(boost::ulong_long_type);
 #endif
@@ -69,27 +68,8 @@ namespace boost
     std::size_t hash_value(long double v);
 
     template <class Ch, class A>
-    std::size_t hash_value(std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&);
-
-    template <class A, class B>
-    std::size_t hash_value(std::pair<A, B> const&);
-    template <class T, class A>
-    std::size_t hash_value(std::vector<T, A> const&);
-    template <class T, class A>
-    std::size_t hash_value(std::list<T, A> const& v);
-    template <class T, class A>
-    std::size_t hash_value(std::deque<T, A> const& v);
-    template <class K, class C, class A>
-    std::size_t hash_value(std::set<K, C, A> const& v);
-    template <class K, class C, class A>
-    std::size_t hash_value(std::multiset<K, C, A> const& v);
-    template <class K, class T, class C, class A>
-    std::size_t hash_value(std::map<K, T, C, A> const& v);
-    template <class K, class T, class C, class A>
-    std::size_t hash_value(std::multimap<K, T, C, A> const& v);
-
-    template <class T>
-    std::size_t hash_value(std::complex<T> const&);
+    std::size_t hash_value(
+        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&);
 
     // Implementation
 
@@ -194,7 +174,7 @@ namespace boost
     }
 #endif
 
-#if defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_LONG_LONG)
     inline std::size_t hash_value(boost::long_long_type v)
     {
         return hash_detail::hash_value_signed(v);
@@ -219,6 +199,16 @@ namespace boost
         return x + (x >> 3);
     }
 
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#if BOOST_MSVC <= 1400
+#pragma warning(disable:4267) // 'argument' : conversion from 'size_t' to
+                              // 'unsigned int', possible loss of data
+                              // A misguided attempt to detect 64-bit
+                              // incompatability.
+#endif
+#endif
+
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
     template <class T>
     inline void hash_combine(std::size_t& seed, T& v)
@@ -231,6 +221,10 @@ namespace boost
         seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
     }
 
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
     template <class It>
     inline std::size_t hash_range(It first, It last)
     {
@@ -294,7 +288,8 @@ namespace boost
 #endif
 
     template <class Ch, class A>
-    inline std::size_t hash_value(std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const& v)
+    inline std::size_t hash_value(
+        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const& v)
     {
         return hash_range(v.begin(), v.end());
     }
@@ -314,69 +309,21 @@ namespace boost
         return boost::hash_detail::float_hash_value(v);
     }
 
-    template <class A, class B>
-    std::size_t hash_value(std::pair<A, B> const& v)
-    {
-        std::size_t seed = 0;
-        hash_combine(seed, v.first);
-        hash_combine(seed, v.second);
-        return seed;
-    }
-
-    template <class T, class A>
-    std::size_t hash_value(std::vector<T, A> const& v)
-    {
-        return hash_range(v.begin(), v.end());
-    }
-
-    template <class T, class A>
-    std::size_t hash_value(std::list<T, A> const& v)
-    {
-        return hash_range(v.begin(), v.end());
-    }
-
-    template <class T, class A>
-    std::size_t hash_value(std::deque<T, A> const& v)
-    {
-        return hash_range(v.begin(), v.end());
-    }
-
-    template <class K, class C, class A>
-    std::size_t hash_value(std::set<K, C, A> const& v)
-    {
-        return hash_range(v.begin(), v.end());
-    }
-
-    template <class K, class C, class A>
-    std::size_t hash_value(std::multiset<K, C, A> const& v)
-    {
-        return hash_range(v.begin(), v.end());
-    }
-
-    template <class K, class T, class C, class A>
-    std::size_t hash_value(std::map<K, T, C, A> const& v)
-    {
-        return hash_range(v.begin(), v.end());
-    }
-
-    template <class K, class T, class C, class A>
-    std::size_t hash_value(std::multimap<K, T, C, A> const& v)
-    {
-        return hash_range(v.begin(), v.end());
-    }
-
-    template <class T>
-    std::size_t hash_value(std::complex<T> const& v)
-    {
-        boost::hash<T> hasher;
-        std::size_t seed = hasher(v.imag());
-        seed ^= hasher(v.real()) + (seed<<6) + (seed>>2);
-        return seed;
-    }
-
     //
     // boost::hash
     //
+    
+    // Define the specializations required by the standard. The general purpose
+    // boost::hash is defined later in extensions.hpp if
+    // BOOST_HASH_NO_EXTENSIONS is not defined.
+    
+    // BOOST_HASH_SPECIALIZE - define a specialization for a type which is
+    // passed by copy.
+    //
+    // BOOST_HASH_SPECIALIZE_REF - define a specialization for a type which is
+    // passed by copy.
+    //
+    // These are undefined later.
 
 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 #define BOOST_HASH_SPECIALIZE(type) \
@@ -461,10 +408,18 @@ namespace boost
     BOOST_HASH_SPECIALIZE_REF(std::wstring)
 #endif
 
+#if !defined(BOOST_NO_LONG_LONG)
+    BOOST_HASH_SPECIALIZE(boost::long_long_type)
+    BOOST_HASH_SPECIALIZE(boost::ulong_long_type)
+#endif
+
 #undef BOOST_HASH_SPECIALIZE
 #undef BOOST_HASH_SPECIALIZE_REF
 
+// Specializing boost::hash for pointers.
+
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
     template <class T>
     struct hash<T*>
         : public std::unary_function<T*, std::size_t>
@@ -481,7 +436,15 @@ namespace boost
 #endif
         }
     };
+
 #else
+
+    // For compilers without partial specialization, we define a
+    // boost::hash for all remaining types. But hash_impl is only defined
+    // for pointers in 'extensions.hpp' - so when BOOST_HASH_NO_EXTENSIONS
+    // is defined there will still be a compile error for types not supported
+    // in the standard.
+
     namespace hash_detail
     {
         template <bool IsPointer>
@@ -514,9 +477,12 @@ namespace boost
             ::BOOST_NESTED_TEMPLATE inner<T>
     {
     };
+
 #endif
 }
 
+#undef BOOST_HASH_CHAR_TRAITS
+
 #endif // BOOST_FUNCTIONAL_HASH_HASH_HPP
 
 // Include this outside of the include guards in case the file is included

test/CMakeLists.txt

@@ -1,51 +0,0 @@
-#project hash-tests
-#    : requirements
-#        <toolset>gcc:<define>_GLIBCXX_DEBUG
-#    ;
-if (GCC)
-  ADD_DEFINITIONS(-D_GLIBCXX_DEBUG)
-endif(GCC)
-
-#        [ run .cpp : : : <test-info>always_show_run_output ]
-
-
-
-#-------------------------------------------------------------------------
-#-- Needed include directories for the tests
-  boost_additional_test_dependencies(functional BOOST_DEPENDS test)
-#-------------------------------------------------------------------------
-
-SET(tests
-hash_float_test
-hash_fwd_test_1
-hash_fwd_test_2
-hash_number_test
-hash_pointer_test
-hash_function_pointer_test
-hash_string_test
-hash_range_test
-hash_custom_test
-hash_global_namespace_test
-hash_friend_test
-hash_built_in_array_test
-hash_value_array_test
-hash_vector_test
-hash_list_test
-hash_deque_test
-hash_set_test
-hash_map_test
-container_fwd_test
-hash_no_ext_macro_1
-hash_no_ext_macro_2
-)
-
-boost_test_run(link_test link_test.cpp link_test_2.cpp)
-boost_test_run(link_ext_test link_ext_test.cpp link_no_ext_test.cpp)
-
-foreach(test ${tests})
-  boost_test_run(${test})
-endforeach(test ${tests})
-
-boost_test_compile_fail(hash_no_ext_fail_test)
-
-# build-project ../examples ;

test/Jamfile.v2

@@ -7,9 +7,14 @@ import testing ;
 
 project hash-tests
     : requirements
-        <toolset>gcc:<define>_GLIBCXX_DEBUG
-        <toolset>gcc:<cxxflags>-Wsign-promo
-        #<toolset>gcc:<cxxflags>-Wextra
+        <warnings>all
+        <toolset>intel:<warnings>on
+        <toolset>intel:<cxxflags>-strict-ansi
+        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
+        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
+        <toolset>msvc:<warnings-as-errors>on
+        #<toolset>gcc:<warnings-as-errors>on
+        #<toolset>darwin:<warnings-as-errors>on
     ;
 
 test-suite functional/hash
@@ -36,10 +41,28 @@ test-suite functional/hash
         [ run hash_complex_test.cpp ]
         [ run link_test.cpp link_test_2.cpp ]
         [ run link_ext_test.cpp link_no_ext_test.cpp ]
+        [ run extensions_hpp_test.cpp ]
         [ run container_fwd_test.cpp ]
+        [ run container_fwd_test.cpp : :
+            :   <toolset>gcc:<define>_GLIBCXX_DEBUG
+                <toolset>darwin:<define>_GLIBCXX_DEBUG
+            :   container_fwd_gcc_debug ]
+        [ run container_no_fwd_test.cpp ]
         [ compile-fail hash_no_ext_fail_test.cpp ]
+        [ compile-fail namespace_fail_test.cpp ]
         [ run hash_no_ext_macro_1.cpp ]
         [ run hash_no_ext_macro_2.cpp ]
     ;
 
+test-suite functional/hash_no_ext
+    :
+        [ run hash_number_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_number_test ]
+        [ run hash_pointer_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_pointer_test ]
+        [ run hash_function_pointer_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_function_pointer_test ]
+        [ run hash_float_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_float_test ]
+        [ run hash_long_double_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_long_double_test ]
+        [ run hash_string_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_string_test ]
+        [ run link_test.cpp link_test_2.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_link_test ]
+    ;
+
 build-project ../examples ;

test/config.hpp

@@ -5,10 +5,17 @@
 
 #if defined(TEST_STD)
 #  define TEST_STD_INCLUDES
-#  define HASH_NAMESPACE std::tr1
+#  define HASH_NAMESPACE std
 #else
 #  define HASH_NAMESPACE boost
 #  if !defined(BOOST_HASH_NO_EXTENSIONS)
 #    define TEST_EXTENSIONS
 #  endif
 #endif
+
+#if defined(_WIN32_WCE)
+// The standard windows mobile headers trigger this warning so I disable it
+// before doing anything else.
+#pragma warning(disable:4201)   // nonstandard extension used :
+                                // nameless struct/union
+#endif

test/container_fwd_test.cpp

@@ -3,16 +3,21 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #include <boost/functional/detail/container_fwd.hpp>
 
-#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+#if BOOST_WORKAROUND(__GNUC__, < 3) && \
+    !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
 template <class charT, class Allocator>
-static void test(std::basic_string<charT, std::string_char_traits<charT>, Allocator> const&)
+static void test(
+    std::basic_string<charT, std::string_char_traits<charT>, Allocator> const&)
 {
 }
 #else
 template <class charT, class Allocator>
-static void test(std::basic_string<charT, std::char_traits<charT>, Allocator> const&)
+static void test(
+    std::basic_string<charT, std::char_traits<charT>, Allocator> const&)
 {
 }
 #endif

test/container_no_fwd_test.cpp

@@ -0,0 +1,14 @@
+
+// Copyright 2010 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_DETAIL_NO_CONTAINER_FWD
+
+#include <boost/detail/container_fwd.hpp>
+
+int main()
+{
+    std::set<int> x;
+    std::vector<std::string> y;
+}

test/extensions_hpp_test.cpp

@@ -0,0 +1,19 @@
+
+// Copyright 2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Check that boost/functional/hash/extensions.hpp works okay.
+//
+// It probably should be in boost/functional/hash/detail, but since it isn't it
+// should work.
+
+#include "./config.hpp"
+
+#include <boost/functional/hash/extensions.hpp>
+
+int main() {
+    int x[2] = { 2, 3 };
+    boost::hash<int[2]> hf;
+    hf(x);
+}

test/hash_complex_test.cpp

@@ -5,37 +5,40 @@
 
 #include "./config.hpp"
 
-#ifdef TEST_EXTENSIONS
-#  ifdef TEST_STD_INCLUDES
-#    include <functional>
-#  else
-#    include <boost/functional/hash.hpp>
-#  endif
+#if !defined(TEST_EXTENSIONS)
+
+int main() {}
+
+#else
+
+#ifdef TEST_STD_INCLUDES
+#  include <functional>
+#else
+#  include <boost/functional/hash.hpp>
 #endif
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef TEST_EXTENSIONS
+#if defined(BOOST_MSVC)
+#pragma warning(disable:4244)   // conversion from 'unsigned long' to
+                                // 'unsigned short', possible loss of data
+#pragma warning(disable:4245)   // conversion from 'int' to
+                                // 'const unsigned short',
+                                // signed/unsigned mismatch
+#pragma warning(disable:4305)   // truncation from 'double' to
+                                // 'const std::complex<float>::_Ty'
+#pragma warning(disable:4309)   // truncation of constant value
+#pragma warning(disable:4512)   // assignment operator could not be generated
+#if BOOST_MSVC < 1400
+#pragma warning(disable:4267)   // conversion from 'size_t' to 'unsigned int',
+                                // possible loss of data
+#endif
+#endif
 
 #include <complex>
 #include <sstream>
 #include <boost/limits.hpp>
 
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4244) // conversion from 'unsigned long' to 'unsigned short', possible loss of data
-#pragma warning(disable:4512) // assignment operator could not be generated
-#endif
-
-#include <boost/random/mersenne_twister.hpp>
-#include <boost/random/uniform_int.hpp>
-#include <boost/random/uniform_real.hpp>
-#include <boost/random/variate_generator.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
 template <class T>
 void generic_complex_tests(std::complex<T> v)
 {
@@ -61,48 +64,43 @@ void generic_complex_tests(std::complex<T> v)
 template <class Float>
 void complex_float_tests(Float*)
 {
-    boost::mt19937 rng;
-    boost::uniform_real<Float> uniform;
-    boost::variate_generator<boost::mt19937&, boost::uniform_real<Float> >
-        uniform_generator(rng, uniform);
-
-    for(int i = 0; i < 100; ++i)
-    {
-        std::complex<Float> v(uniform_generator(), uniform_generator());
-        generic_complex_tests(v);
-    }
+    typedef std::complex<Float> complex;
+    generic_complex_tests(complex(0,0));
+    generic_complex_tests(complex(0.5,0));
+    generic_complex_tests(complex(25,0));
+    generic_complex_tests(complex(25,0));
+    generic_complex_tests(complex(-67.5324535,56.23578678));
 }
 
 template <class Integer>
 void complex_integral_tests(Integer*)
 {
-    boost::mt19937 rng;
-    boost::uniform_int<Integer> uniform(
-            (std::numeric_limits<Integer>::min)(),
-            (std::numeric_limits<Integer>::max)());
-    boost::variate_generator<boost::mt19937&, boost::uniform_int<Integer> >
-        uniform_generator(rng, uniform);
-
-    for(int i = 0; i < 100; ++i)
-    {
-        std::complex<Integer>v(uniform_generator(), uniform_generator());
-        generic_complex_tests(v);
-    }
+    typedef std::complex<Integer> complex;
+    generic_complex_tests(complex(0,0));
+    generic_complex_tests(complex(15342,124));
+    generic_complex_tests(complex(25,54356));
+    generic_complex_tests(complex(5325,2346));
+    generic_complex_tests(complex(-243897,-49923874));
+    generic_complex_tests(complex(-543,763));
 }
 
 int main()
 {
+    // I've comments out the short and unsigned short tests
+    // as they cause warnings and don't really test
+    // anything that the other tests already deal with.
+
     complex_float_tests((float*) 0);
     complex_float_tests((double*) 0);
     complex_float_tests((long double*) 0);
-    complex_integral_tests((short*) 0);
+    //complex_integral_tests((short*) 0);
     complex_integral_tests((int*) 0);
     complex_integral_tests((long*) 0);
-    complex_integral_tests((unsigned short*) 0);
+    //complex_integral_tests((unsigned short*) 0);
     complex_integral_tests((unsigned int*) 0);
     complex_integral_tests((unsigned long*) 0);
 
     return boost::report_errors();
 }
 
-#endif
+#endif // TEST_EXTENSIONS

test/hash_custom_test.cpp

@@ -3,6 +3,7 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
 #include <boost/config.hpp>
 #include <cstddef>
 
@@ -83,8 +84,8 @@ void custom_tests()
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_TEST(seed ==
-            HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(
+        custom_vector.begin(), custom_vector.end()));
     BOOST_TEST(seed == seed2);
 }
 

test/hash_float_test.hpp

@@ -14,28 +14,56 @@
 #include <boost/detail/lightweight_test.hpp>
 
 #include <cmath>
-#include <boost/limits.hpp>
+#include <boost/functional/hash/detail/limits.hpp>
+#include <boost/functional/hash/detail/float_functions.hpp>
+#include <boost/detail/workaround.hpp>
 
 #include <iostream>
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4127) // conditional expression is constant
+#pragma warning(disable:4127)   // conditional expression is constant
+#pragma warning(disable:4723)   // conditional expression is constant
+#if BOOST_MSVC < 1400
+#pragma warning(disable:4267)   // conversion from 'size_t' to 'unsigned int',
+                                // possible loss of data
 #endif
+#endif
+
+char const* float_type(float*) { return "float"; }
+char const* float_type(double*) { return "double"; }
+char const* float_type(long double*) { return "long double"; }
 
 template <class T>
 void float_tests(char const* name, T* = 0)
 {
-    std::cerr<<"\n"
-        <<"Testing " BOOST_STRINGIZE(HASH_NAMESPACE) "::hash<"<<name<<">\n"
-        <<"\n"
-        <<"boost::hash_detail::limits<T>::digits = "
-            <<boost::hash_detail::limits<T>::digits<<"\n"
-        <<"boost::hash_detail::limits<int>::digits = "
-            <<boost::hash_detail::limits<int>::digits<<"\n"
-        <<"boost::hash_detail::limits<std::size_t>::digits = "
-            <<boost::hash_detail::limits<std::size_t>::digits<<"\n"
-        <<"\n"
+    std::cerr
+        <<  "\n"
+        <<  "Testing " BOOST_STRINGIZE(HASH_NAMESPACE) "::hash<"
+        <<  name
+        <<  ">\n"
+        <<  "\n"
+        <<  "boost::hash_detail::limits<T>::digits = "
+        <<  boost::hash_detail::limits<T>::digits<< "\n"
+        <<  "boost::hash_detail::limits<int>::digits = "
+        <<  boost::hash_detail::limits<int>::digits<< "\n"
+        <<  "boost::hash_detail::limits<std::size_t>::digits = "
+        <<  boost::hash_detail::limits<std::size_t>::digits
+        <<  "\n"
+        <<  "\n"
+        <<  "boost::hash_detail::call_ldexp<T>::float_type = "
+        <<  float_type(static_cast<BOOST_DEDUCED_TYPENAME
+                boost::hash_detail::call_ldexp<T>::float_type*>(0))
+        <<  "\n"
+        <<  "boost::hash_detail::call_frexp<T>::float_type = "
+        <<  float_type(static_cast<BOOST_DEDUCED_TYPENAME
+                boost::hash_detail::call_frexp<T>::float_type*>(0))
+        <<  "\n"
+        <<  "boost::hash_detail::select_hash_type<T>::type = "
+        <<  float_type(static_cast<BOOST_DEDUCED_TYPENAME
+                boost::hash_detail::select_hash_type<T>::type*>(0))
+        <<  "\n"
+        <<  "\n"
         ;
 
     HASH_NAMESPACE::hash<T> x1;
@@ -46,14 +74,23 @@ void float_tests(char const* name, T* = 0)
     BOOST_TEST(zero == minus_zero);
     BOOST_TEST(x1(zero) == x1(minus_zero));
 
+#if defined(TEST_EXTENSIONS)
     BOOST_TEST(x1(zero) == HASH_NAMESPACE::hash_value(zero));
     BOOST_TEST(x1(minus_zero) == HASH_NAMESPACE::hash_value(minus_zero));
+#endif
+
+    BOOST_TEST(x1(zero) != x1(0.5));
+    BOOST_TEST(x1(minus_zero) != x1(0.5));
+    BOOST_TEST(x1(0.5) != x1(-0.5));
+    BOOST_TEST(x1(1) != x1(-1));
 
     using namespace std;
 
 // Doing anything with infinity causes borland to crash.
 #if defined(__BORLANDC__)
-    std::cerr<<"Not running infinity checks on Borland, as it causes it to crash.\n";
+    std::cerr
+        <<  "Not running infinity checks on Borland, as it causes it to crash."
+            "\n";
 #else
     if(boost::hash_detail::limits<T>::has_infinity) {
         T infinity = -log(zero);
@@ -65,9 +102,11 @@ void float_tests(char const* name, T* = 0)
         T minus_infinity2 = (T) -1. / zero;
         T minus_infinity3 = (T) 1. / minus_zero;
 
+#if defined(TEST_EXTENSIONS)
         BOOST_TEST(x1(infinity) == HASH_NAMESPACE::hash_value(infinity));
         BOOST_TEST(x1(minus_infinity)
                 == HASH_NAMESPACE::hash_value(minus_infinity));
+#endif
 
         if(infinity == infinity2)
             BOOST_TEST(x1(infinity) == x1(infinity2));
@@ -90,19 +129,40 @@ void float_tests(char const* name, T* = 0)
         // This should really be 'has_denorm == denorm_present' but some
         // compilers don't have 'denorm_present'. See also a later use.
         if(boost::hash_detail::limits<T>::has_denorm) {
-            if(x1(boost::hash_detail::limits<T>::denorm_min()) == x1(infinity)) {
-                std::cerr<<"x1(denorm_min) == x1(infinity) == "<<x1(infinity)<<"\n";
+            if(x1(boost::hash_detail::limits<T>::denorm_min()) == x1(infinity))
+            {
+                std::cerr
+                    <<  "x1(denorm_min) == x1(infinity) == "
+                    <<  x1(infinity)
+                    <<  "\n";
             }
-            if(x1(boost::hash_detail::limits<T>::denorm_min()) == x1(minus_infinity)) {
-                std::cerr<<"x1(denorm_min) == x1(-infinity) == "<<x1(minus_infinity)<<"\n";
+
+            if(x1(boost::hash_detail::limits<T>::denorm_min()) ==
+                x1(minus_infinity))
+            {
+                std::cerr
+                    <<  "x1(denorm_min) == x1(-infinity) == "
+                    <<  x1(minus_infinity)
+                    <<  "\n";
             }
         }
+
         if(boost::hash_detail::limits<T>::has_quiet_NaN) {
-            if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(infinity)) {
-                std::cerr<<"x1(quiet_NaN) == x1(infinity) == "<<x1(infinity)<<"\n";
+            if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(infinity))
+            {
+                std::cerr
+                    <<  "x1(quiet_NaN) == x1(infinity) == "
+                    <<  x1(infinity)
+                    <<  "\n";
             }
-            if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(minus_infinity)) {
-                std::cerr<<"x1(quiet_NaN) == x1(-infinity) == "<<x1(minus_infinity)<<"\n";
+
+            if(x1(boost::hash_detail::limits<T>::quiet_NaN()) ==
+                x1(minus_infinity))
+            {
+                std::cerr
+                    <<  "x1(quiet_NaN) == x1(-infinity) == "
+                    <<  x1(minus_infinity)
+                    <<  "\n";
             }
         }
     }
@@ -112,13 +172,31 @@ void float_tests(char const* name, T* = 0)
     T half_max = max / 2;
     T quarter_max = max / 4;
     T three_quarter_max = max - quarter_max;
+    
+    // Check the limits::max is in range.
+    BOOST_TEST(max != half_max);
+    BOOST_TEST(max != quarter_max);
+    BOOST_TEST(max != three_quarter_max);
+    BOOST_TEST(half_max != quarter_max);
+    BOOST_TEST(half_max != three_quarter_max);
+    BOOST_TEST(quarter_max != three_quarter_max);
 
+    BOOST_TEST(max != -max);
+    BOOST_TEST(half_max != -half_max);
+    BOOST_TEST(quarter_max != -quarter_max);
+    BOOST_TEST(three_quarter_max != -three_quarter_max);
+
+
+#if defined(TEST_EXTENSIONS)
     BOOST_TEST(x1(max) == HASH_NAMESPACE::hash_value(max));
     BOOST_TEST(x1(half_max) == HASH_NAMESPACE::hash_value(half_max));
     BOOST_TEST(x1(quarter_max) == HASH_NAMESPACE::hash_value(quarter_max));
-    BOOST_TEST(x1(three_quarter_max) == HASH_NAMESPACE::hash_value(three_quarter_max));
+    BOOST_TEST(x1(three_quarter_max) ==
+        HASH_NAMESPACE::hash_value(three_quarter_max));
+#endif
 
-    // The '!=' tests could legitimately fail, but with my hash it indicates a bug.
+    // The '!=' tests could legitimately fail, but with my hash it indicates a
+    // bug.
     BOOST_TEST(x1(max) == x1(max));
     BOOST_TEST(x1(max) != x1(quarter_max));
     BOOST_TEST(x1(max) != x1(half_max));
@@ -130,6 +208,12 @@ void float_tests(char const* name, T* = 0)
     BOOST_TEST(x1(half_max) != x1(three_quarter_max));
     BOOST_TEST(x1(three_quarter_max) == x1(three_quarter_max));
 
+    BOOST_TEST(x1(max) != x1(-max));
+    BOOST_TEST(x1(half_max) != x1(-half_max));
+    BOOST_TEST(x1(quarter_max) != x1(-quarter_max));
+    BOOST_TEST(x1(three_quarter_max) != x1(-three_quarter_max));
+
+
 // Intel with gcc stdlib sometimes segfaults on calls to asin and acos.
 #if !((defined(__INTEL_COMPILER) || defined(__ICL) || \
         defined(__ICC) || defined(__ECC)) && \
@@ -138,12 +222,19 @@ void float_tests(char const* name, T* = 0)
     T v2 = acos((T) 0);
     if(v1 == v2)
         BOOST_TEST(x1(v1) == x1(v2));
+
+#if defined(TEST_EXTENSIONS)
     BOOST_TEST(x1(v1) == HASH_NAMESPACE::hash_value(v1));
     BOOST_TEST(x1(v2) == HASH_NAMESPACE::hash_value(v2));
 #endif
+    
+#endif
 
+#if defined(TEST_EXTENSIONS)
     BOOST_TEST(x1(boost::hash_detail::limits<T>::epsilon()) ==
-            HASH_NAMESPACE::hash_value(boost::hash_detail::limits<T>::epsilon()));
+            HASH_NAMESPACE::hash_value(
+                boost::hash_detail::limits<T>::epsilon()));
+#endif
 
     BOOST_TEST(boost::hash_detail::limits<T>::epsilon() != (T) 0);
     if(x1(boost::hash_detail::limits<T>::epsilon()) == x1((T) 0))
@@ -174,31 +265,37 @@ void float_tests(char const* name, T* = 0)
         if(x1(boost::hash_detail::limits<T>::denorm_min()) == x1(zero)) {
             std::cerr<<"x1(denorm_min) == x1(zero) == "<<x1(zero)<<"\n";
         }
-#if !BOOST_WORKAROUND(__DECCXX_VER,<70190006)
+#if !BOOST_WORKAROUND(__DECCXX_VER,<70190006) && defined(TEST_EXTENSIONS)
         // The Tru64/CXX standard library prior to 7.1 contains a bug in the
         // specialization of boost::hash_detail::limits::denorm_min() for long
         // doubles which causes this test to fail.
         if(x1(boost::hash_detail::limits<T>::denorm_min()) !=
-            HASH_NAMESPACE::hash_value(boost::hash_detail::limits<T>::denorm_min()))
+            HASH_NAMESPACE::hash_value(
+                boost::hash_detail::limits<T>::denorm_min()))
         {
-            std::cerr<<"x1(boost::hash_detail::limits<T>::denorm_min()) = "
-                << x1(boost::hash_detail::limits<T>::denorm_min())
-                << "\nhash_value(boost::hash_detail::limits<T>::denorm_min()) = "
-                << HASH_NAMESPACE::hash_value(
+            std::cerr
+                <<  "x1(boost::hash_detail::limits<T>::denorm_min()) = "
+                <<  x1(boost::hash_detail::limits<T>::denorm_min())
+                <<  "\nhash_value(boost::hash_detail::limits<T>::denorm_min())"
+                    " = "
+                <<  HASH_NAMESPACE::hash_value(
                         boost::hash_detail::limits<T>::denorm_min())
-                << "\nx1(0) = "<<x1(0)<<"\n";
+                <<  "\nx1(0) = "
+                <<  x1(0)
+                <<  "\n";
         }
 #endif
     }
 
 // NaN also causes borland to crash.
-#if !defined(__BORLANDC__)
+#if !defined(__BORLANDC__) && defined(TEST_EXTENSIONS)
     if(boost::hash_detail::limits<T>::has_quiet_NaN) {
         if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(1.0)) {
             std::cerr<<"x1(quiet_NaN) == x1(1.0) == "<<x1(1.0)<<"\n";
         }
         BOOST_TEST(x1(boost::hash_detail::limits<T>::quiet_NaN()) ==
-            HASH_NAMESPACE::hash_value(boost::hash_detail::limits<T>::quiet_NaN()));
+            HASH_NAMESPACE::hash_value(
+                boost::hash_detail::limits<T>::quiet_NaN()));
     }
 #endif
 }

test/hash_friend_test.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #include <boost/config.hpp>
 #include <cstddef>
 
@@ -85,8 +87,8 @@ void custom_tests()
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_TEST(seed ==
-            HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(
+        custom_vector.begin(), custom_vector.end()));
     BOOST_TEST(seed == seed2);
 }
 

test/hash_function_pointer_test.cpp

@@ -13,7 +13,6 @@
 
 #include <boost/detail/lightweight_test.hpp>
 
-#include <boost/limits.hpp>
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 

test/hash_fwd_test.hpp

@@ -60,7 +60,8 @@ namespace test {
     template <class T>
     std::size_t hash_value(test_type3<T> const& x)
     {
-        std::size_t seed = HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end());
+        std::size_t seed =
+            HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end());
         HASH_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end());
         return seed;
     }
@@ -91,7 +92,8 @@ namespace boost
     template <class T>
     std::size_t hash_value(test::test_type3<T> const& x)
     {
-        std::size_t seed = HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end());
+        std::size_t seed =
+            HASH_NAMESPACE::hash_range(x.values.begin(), x.values.end());
         HASH_NAMESPACE::hash_range(seed, x.values.begin(), x.values.end());
         return seed;
     }

test/hash_fwd_test_1.cpp

@@ -5,6 +5,8 @@
 
 // This checks that template code implemented using hash_fwd will work.
 
+#include "./config.hpp"
+
 #include "./hash_fwd_test.hpp"
 
 #include <boost/detail/lightweight_test.hpp>
@@ -66,10 +68,12 @@ void fwd_test3()
     test::test_type3<int> x(values1.begin(), values1.end());
     test::test_type3<std::string> y(values2.begin(), values2.end());
 
-    std::size_t seed1 = HASH_NAMESPACE::hash_range(values1.begin(), values1.end());
+    std::size_t seed1 =
+        HASH_NAMESPACE::hash_range(values1.begin(), values1.end());
     HASH_NAMESPACE::hash_range(seed1, values1.begin(), values1.end());
 
-    std::size_t seed2 = HASH_NAMESPACE::hash_range(values2.begin(), values2.end());
+    std::size_t seed2 =
+        HASH_NAMESPACE::hash_range(values2.begin(), values2.end());
     HASH_NAMESPACE::hash_range(seed2, values2.begin(), values2.end());
 
     HASH_NAMESPACE::hash<test::test_type3<int> > hasher_test_int;
@@ -90,4 +94,3 @@ int main()
 #endif
     return boost::report_errors();
 }
-

test/hash_fwd_test_2.cpp

@@ -6,8 +6,15 @@
 // This test just makes sure a header which uses hash_fwd can compile without
 // the main hash headers.
 
-#include "./hash_fwd_test.hpp"
+#include "./config.hpp"
 
+#if !defined(TEST_EXTENSIONS) || defined(TEST_STD_INCLUDES)
+
+int main() {}
+
+#else
+
+#include "./hash_fwd_test.hpp"
 #include <boost/detail/lightweight_test.hpp>
 
 template <class T> void unused(T const&) {}
@@ -30,10 +37,11 @@ void fwd_test()
     unused(y1); unused(y2); unused(y3);
 }
 
-
 int main()
 {
     fwd_test();
+
     return boost::report_errors();
 }
 
+#endif // defined(TEST_EXTENSIONS) && !defined(TEST_STD_INCLUDES)

test/hash_global_namespace_test.cpp

@@ -6,6 +6,8 @@
 // This test demonstrates an ADL bug in Borland 5.5 where ADL isn't performed
 // in the global namespace.
 
+#include "./config.hpp"
+
 #include <boost/config.hpp>
 #include <cstddef>
 
@@ -83,8 +85,8 @@ void custom_tests()
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_TEST(seed ==
-            HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(
+        custom_vector.begin(), custom_vector.end()));
     BOOST_TEST(seed == seed2);
 }
 

test/hash_map_test.hpp

@@ -11,6 +11,7 @@
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
+#pragma warning(disable:4244) // conversion from 'int' to 'float'
 #pragma warning(disable:4245) // signed/unsigned mismatch
 #endif
 
@@ -21,19 +22,21 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
     {
         const int number_of_containers = 10;
         T containers[number_of_containers];
-        typedef typename T::value_type pair;
+        typedef BOOST_DEDUCED_TYPENAME T::value_type pair;
+        typedef BOOST_DEDUCED_TYPENAME T::key_type key;
+        typedef BOOST_DEDUCED_TYPENAME T::mapped_type value;
 
         for(int i = 0; i < 5; ++i) {
             for(int j = 0; j < i; ++j)
-                containers[i].insert(pair(0, 0));
+                containers[i].insert(pair(key(0), value(0)));
         }
 
-        containers[6].insert(pair(1,0));
-        containers[7].insert(pair(1,0));
-        containers[7].insert(pair(1,0));
-        containers[8].insert(pair(-1,1));
-        containers[9].insert(pair(-1,3));
-        containers[9].insert(pair(-1,3));
+        containers[6].insert(pair(key(1),value(0)));
+        containers[7].insert(pair(key(1),value(0)));
+        containers[7].insert(pair(key(1),value(0)));
+        containers[8].insert(pair(key(-1),value(1)));
+        containers[9].insert(pair(key(-1),value(3)));
+        containers[9].insert(pair(key(-1),value(3)));
 
         HASH_NAMESPACE::hash<T> hasher;
 

test/hash_no_ext_fail_test.cpp

@@ -3,17 +3,26 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#define HASH_NAMESPACE boost
+#include "./config.hpp"
 
 // Simple test to make sure BOOST_HASH_NO_EXTENSIONS does disable extensions
 // (or at least one of them).
-#define BOOST_HASH_NO_EXTENSIONS
+#if !defined(BOOST_HASH_NO_EXTENSIONS)
+#  define BOOST_HASH_NO_EXTENSIONS
+#endif
 
-#include <boost/functional/hash.hpp>
-#include <boost/functional/hash.hpp>
+#ifdef TEST_STD_INCLUDES
+#  include <functional>
+#else
+#  include <boost/functional/hash.hpp>
+#endif
+
+template <class T> void ignore(T const&) {}
 
 int main()
 {
     HASH_NAMESPACE::hash< int[10] > hasher;
+    ignore(hasher);
+
     return 0;
 }

test/hash_no_ext_macro_1.cpp

@@ -3,16 +3,27 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#define HASH_NAMESPACE boost
-#include <boost/functional/hash.hpp>
-#define BOOST_HASH_NO_EXTENSIONS
-#include <boost/functional/hash.hpp>
+#include "./config.hpp"
+
+#if defined(TEST_EXTENSIONS)
+
+// Include header without BOOST_HASH_NO_EXTENSIONS defined
+#  if defined(BOOST_HASH_NO_EXTENSIONS)
+#    undef BOOST_HASH_NO_EXTENSIONS
+#  endif
+#  include <boost/functional/hash.hpp>
+
+// Include header with BOOST_HASH_NO_EXTENSIONS defined
+#  define BOOST_HASH_NO_EXTENSIONS
+#  include <boost/functional/hash.hpp>
+#endif
+
 #include <boost/detail/lightweight_test.hpp>
 #include <deque>
-#include <cassert>
 
 int main()
 {
+#if defined(TEST_EXTENSIONS)
     std::deque<int> x;
 
     x.push_back(1);
@@ -20,6 +31,7 @@ int main()
 
     HASH_NAMESPACE::hash<std::deque<int> > hasher;
     BOOST_TEST(hasher(x) == HASH_NAMESPACE::hash_value(x));
+#endif
 
     return boost::report_errors();
 }

test/hash_no_ext_macro_2.cpp

@@ -3,16 +3,27 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#define HASH_NAMESPACE boost
-#define BOOST_HASH_NO_EXTENSIONS
-#include <boost/functional/hash.hpp>
-#undef BOOST_HASH_NO_EXTENSIONS
-#include <boost/functional/hash.hpp>
+#include "./config.hpp"
+
+#if defined(TEST_EXTENSIONS)
+
+// Include header with BOOST_HASH_NO_EXTENSIONS defined
+#  if !defined(BOOST_HASH_NO_EXTENSIONS)
+#    define BOOST_HASH_NO_EXTENSIONS
+#  endif
+#  include <boost/functional/hash.hpp>
+
+// Include header without BOOST_HASH_NO_EXTENSIONS defined
+#  undef BOOST_HASH_NO_EXTENSIONS
+#  include <boost/functional/hash.hpp>
+#endif
+
 #include <boost/detail/lightweight_test.hpp>
 #include <map>
 
 int main()
 {
+#if defined(TEST_EXTENSIONS)
     std::map<int, int> x;
 
     x.insert(std::map<int, int>::value_type(53, -42));
@@ -20,6 +31,7 @@ int main()
 
     HASH_NAMESPACE::hash<std::map<int, int> > hasher;
     BOOST_TEST(hasher(x) == HASH_NAMESPACE::hash_value(x));
+#endif
     
     return boost::report_errors();
 }

test/hash_number_test.cpp

@@ -15,7 +15,7 @@
 #include <boost/detail/lightweight_test.hpp>
 
 #include <boost/preprocessor/cat.hpp>
-#include <boost/limits.hpp>
+#include <boost/functional/hash/detail/limits.hpp>
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 
@@ -55,8 +55,11 @@ void numeric_test(T*)
 
     if (limits::is_integer)
     {
-        if(limits::is_signed || limits::digits <= boost::hash_detail::limits<std::size_t>::digits)
+        if(limits::is_signed ||
+            limits::digits <= boost::hash_detail::limits<std::size_t>::digits)
+        {
             BOOST_TEST(HASH_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5));
+        }
         BOOST_TEST(HASH_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u));
         BOOST_TEST(HASH_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u));
         BOOST_TEST(HASH_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u));
@@ -149,7 +152,7 @@ int main()
     NUMERIC_TEST(long, hash_long)
     NUMERIC_TEST(unsigned long, ulong)
 
-#if defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_LONG_LONG)
     NUMERIC_TEST_NO_LIMITS(boost::long_long_type, long_long)
     NUMERIC_TEST_NO_LIMITS(boost::ulong_long_type, ulong_long)
 #endif
@@ -157,6 +160,9 @@ int main()
     NUMERIC_TEST(float, float)
     NUMERIC_TEST(double, double)
 
+    NUMERIC_TEST(std::size_t, size_t)
+    NUMERIC_TEST(std::ptrdiff_t, ptrdiff_t)
+
     bool_test();
 
     return boost::report_errors();

test/hash_range_test.cpp

@@ -5,18 +5,20 @@
 
 #include "./config.hpp"
 
-#ifdef TEST_EXTENSIONS
-#  ifdef TEST_STD_INCLUDES
-#    include <functional>
-#  else
-#    include <boost/functional/hash.hpp>
-#  endif
+#if !defined(TEST_EXTENSIONS)
+
+int main() {}
+
+#else
+
+#ifdef TEST_STD_INCLUDES
+#  include <functional>
+#else
+#  include <boost/functional/hash.hpp>
 #endif
 
 #include <boost/detail/lightweight_test.hpp>
 
-#ifdef TEST_EXTENSIONS
-
 #include <boost/limits.hpp>
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
@@ -68,14 +70,14 @@ void hash_range_tests()
     BOOST_TEST(HASH_NAMESPACE::hash_range(values3.begin(), values3.end())
         == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    std::size_t seed = HASH_NAMESPACE::hash_range(values3.begin(), values3.end());
+    std::size_t seed =
+        HASH_NAMESPACE::hash_range(values3.begin(), values3.end());
     HASH_NAMESPACE::hash_range(seed, values4.begin(), values4.end());
     HASH_NAMESPACE::hash_range(seed, x.begin(), x.end());
-    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
+    BOOST_TEST(seed ==
+        HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
 }
 
-#endif
-
 int main()
 {
     hash_range_tests();
@@ -83,3 +85,4 @@ int main()
     return boost::report_errors();
 }
 
+#endif // TEST_EXTESNIONS

test/hash_string_test.cpp

@@ -13,7 +13,6 @@
 
 #include <boost/detail/lightweight_test.hpp>
 
-#include <boost/limits.hpp>
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 #include <string>

test/link_ext_test.cpp

@@ -3,20 +3,31 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #define HASH_NAMESPACE boost
 #include <boost/functional/hash.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <vector>
 
 int f(std::size_t hash1, int* x1) {
+
     // Check that HASH_NAMESPACE::hash<int*> works in both files.
     HASH_NAMESPACE::hash<int*> ptr_hasher;
     BOOST_TEST(hash1 == ptr_hasher(x1));
 
+#if defined(TEST_EXTENSIONS)
+
     // Check that std::vector<std::size_t> is avaiable in this file.
     std::vector<std::size_t> x;
     x.push_back(*x1);
     HASH_NAMESPACE::hash<std::vector<std::size_t> > vector_hasher;
     return vector_hasher(x) != HASH_NAMESPACE::hash_value(x);
+    
+#else
+
+    return 0;
+
+#endif
 }
 

test/link_no_ext_test.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #define HASH_NAMESPACE boost
 #define BOOST_HASH_NO_EXTENSIONS
 #include <boost/functional/hash.hpp>

test/link_test.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #include <boost/functional/hash.hpp>
 
 extern int f();

test/link_test_2.cpp

@@ -3,6 +3,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include "./config.hpp"
+
 #include <boost/functional/hash.hpp>
 
 int f() { return 0; }

test/namespace_fail_test.cpp

@@ -0,0 +1,16 @@
+
+// Copyright 2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Check that I haven't inadvertantly pulled namespace std into the global
+// namespace.
+
+#include "./config.hpp"
+
+#include <list>
+#include <boost/functional/hash.hpp>
+
+typedef list<int> foo;
+
+int main() {}