Merge branch 'develop'

This hopefuly fixes #8552.

https://svn.boost.org/trac/boost/ticket/8552

.travis.yml

@@ -0,0 +1,42 @@
+# Copyright (C) 2016 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)
+
+# Use Trusty to get a reasonably recent version of Boost.
+sudo: required
+dist: trusty
+
+language: c++
+
+addons:
+    apt:
+        packages:
+            - libboost-dev
+            - libboost-tools-dev
+
+matrix:
+    include:
+      - compiler: gcc
+        env: BJAM_TOOLSET=gcc-std03
+      - compiler: gcc
+        env: BJAM_TOOLSET=gcc-std11
+      - compiler: clang
+        env: BJAM_TOOLSET=clang-std03
+      - compiler: clang
+        env: BJAM_TOOLSET=clang-std11
+      - compiler: clang
+        env: BJAM_TOOLSET=clang-pretend_no_auto_ptr_etc
+
+before_script:
+    - |
+        echo "using gcc : std03 : g++-4.8 -Werror --std=c++03 ;" > ~/user-config.jam
+        echo "using gcc : std11 : g++-4.8 -Werror --std=c++11 ;" >> ~/user-config.jam
+        echo "using clang : std03 : clang++ -Werror --std=c++03 ;" >> ~/user-config.jam
+        echo "using clang : std11 : clang++ -Werror --std=c++11 ;" >> ~/user-config.jam
+        echo "using clang : pretend_no_auto_ptr_etc : clang++ -Werror --std=c++11 -D_HAS_AUTO_PTR_ETC=0 ;" >> ~/user-config.jam
+    - cat ~/user-config.jam
+    - touch Jamroot.jam
+
+script:
+    - cd ${TRAVIS_BUILD_DIR}/test
+    - bjam -q ${BJAM_TOOLSET} include=${TRAVIS_BUILD_DIR}/include

doc/changes.qbk

@@ -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) ]
 
+[template ticket[number]'''<ulink url="https://svn.boost.org/trac/boost/ticket/'''[number]'''">'''#[number]'''</ulink>''']
+
 [section:changes Change Log]
 
 [h2 Boost 1.33.0]
@@ -160,4 +162,37 @@
 * [@https://svn.boost.org/trac/boost/ticket/7957 Ticket 7957]:
   Fixed a typo.
 
+[h2 Boost 1.55.0]
+
+* Simplify a SFINAE check so that it will hopefully work on Sun 5.9
+  ([ticket 8822]).
+* Suppress Visual C++ infinite loop warning ([ticket 8568]).
+
+[h2 Boost 1.56.0]
+
+* Removed some Visual C++ 6 workarounds.
+* Ongoing work on improving `hash_combine`. This changes the combine function
+  which was previously defined in the reference documentation.
+
+[h2 Boost 1.58.0]
+
+* Fixed strict aliasing violation
+  ([@https://github.com/boostorg/functional/pull/3 GitHub #3]).
+
+[h2 Boost 1.63.0]
+
+* Fixed some warnings.
+* Only define hash for `std::wstring` when we know we have a `wchar_t`.
+  Otherwise there's a compile error as there's no overload for hashing
+  the characters in wide strings ([ticket 8552]).
+
+[h2 Boost 1.64.0]
+
+* Fix for recent versions of Visual C++ which have removed `std::unary_function`
+  and `std::binary_function` ([ticket 12353]).
+
+[h2 Boost 1.65.0]
+
+* Support for `char16_t`, `char32_t`, `u16string`, `u32string`
+
 [endsect]

doc/rationale.qbk

@@ -34,7 +34,7 @@ For other use cases, if you do need a higher quality hash function,
 then neither the standard hash function or `boost::hash` are appropriate.
 There are several options
 available. One is to use a second hash on the output of this hash
-function, such as [@http://www.concentric.net/~ttwang/tech/inthash.htm
+function, such as [@http://web.archive.org/web/20121102023700/http://www.concentric.net/~Ttwang/tech/inthash.htm
 Thomas Wang's hash function]. This this may not work as
 well as a hash algorithm tailored for the input.
 

doc/ref.xml

@@ -59,6 +59,11 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               Forward declared in
               <code>&lt;boost/functional/hash_fwd.hpp&gt;</code>
             </para>
+            <para>
+              This hash function is not intended for general use, and isn't
+              guaranteed to be equal during separate runs of a program - so
+              please don't use it for any persistent storage or communication.
+            </para>
           </notes>
           <throws><para>
             Only throws if
@@ -157,6 +162,42 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
         </method>
       </struct-specialization>
 
+      <struct-specialization name="hash">
+        <template></template>
+        <specialization>
+          <template-arg>char16_t</template-arg>
+        </specialization>
+        <method name="operator()" cv="const">
+          <type>std::size_t</type>
+          <parameter name="val">
+            <paramtype>char16_t</paramtype>
+          </parameter>
+          <returns>
+            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
+            <para><functionname>hash_value</functionname>(val) in Boost.</para>
+          </returns>
+          <throws><para>Doesn't throw</para></throws>
+        </method>
+      </struct-specialization>
+
+      <struct-specialization name="hash">
+        <template></template>
+        <specialization>
+          <template-arg>char32_t</template-arg>
+        </specialization>
+        <method name="operator()" cv="const">
+          <type>std::size_t</type>
+          <parameter name="val">
+            <paramtype>char32_t</paramtype>
+          </parameter>
+          <returns>
+            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
+            <para><functionname>hash_value</functionname>(val) in Boost.</para>
+          </returns>
+          <throws><para>Doesn't throw</para></throws>
+        </method>
+      </struct-specialization>
+
       <struct-specialization name="hash">
         <template></template>
         <specialization>
@@ -391,6 +432,42 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
         </method>
       </struct-specialization>
 
+      <struct-specialization name="hash">
+        <template></template>
+        <specialization>
+          <template-arg>std::u16string</template-arg>
+        </specialization>
+        <method name="operator()" cv="const">
+          <type>std::size_t</type>
+          <parameter name="val">
+            <paramtype>std::u16string const&amp;</paramtype>
+          </parameter>
+          <returns>
+            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
+            <para><functionname>hash_value</functionname>(val) in Boost.</para>
+          </returns>
+          <throws><para>Doesn't throw</para></throws>
+        </method>
+      </struct-specialization>
+
+      <struct-specialization name="hash">
+        <template></template>
+        <specialization>
+          <template-arg>std::u32string</template-arg>
+        </specialization>
+        <method name="operator()" cv="const">
+          <type>std::size_t</type>
+          <parameter name="val">
+            <paramtype>std::u32string const&amp;</paramtype>
+          </parameter>
+          <returns>
+            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
+            <para><functionname>hash_value</functionname>(val) in Boost.</para>
+          </returns>
+          <throws><para>Doesn't throw</para></throws>
+        </method>
+      </struct-specialization>
+
       <struct-specialization name="hash">
         <template>
           <template-type-parameter name="T"/>
@@ -450,7 +527,15 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
             Called repeatedly to incrementally create a hash value from
             several variables.
         </simpara></purpose>
-        <effects><programlisting>seed ^= <functionname>hash_value</functionname>(v) + 0x9e3779b9 + (seed &lt;&lt; 6) + (seed &gt;&gt; 2);</programlisting></effects>
+        <effects>
+            Updates <code>seed</code> with a new hash value generated by
+            combining it with the result of
+            <code><functionname>hash_value</functionname>(v)</code>. Will
+            always produce the same result for the same combination of
+            <code>seed</code> and
+            <code><functionname>hash_value</functionname>(v)</code> during
+            the single run of a program.
+        </effects>
         <notes>
           <para><functionname>hash_value</functionname> is called without
           qualification, so that overloads can be found via ADL.</para>
@@ -459,6 +544,11 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
             Forward declared in
             <code>&lt;boost/functional/hash_fwd.hpp&gt;</code>
           </para>
+          <para>
+            This hash function is not intended for general use, and isn't
+            guaranteed to be equal during separate runs of a program - so
+            please don't use it for any persistent storage or communication.
+          </para>
         </notes>
         <throws>
           Only throws if <functionname>hash_value</functionname>(T) throws.
@@ -527,6 +617,11 @@ for(; first != last; ++first)
             Forward declared in
             <code>&lt;boost/functional/hash_fwd.hpp&gt;</code>
           </para>
+          <para>
+            This hash function is not intended for general use, and isn't
+            guaranteed to be equal during separate runs of a program - so
+            please don't use it for any persistent storage or communication.
+          </para>
         </notes>
         <throws><para>
           Only throws if <code><functionname>hash_value</functionname>(std::iterator_traits&lt;It&gt;::value_type)</code>
@@ -574,6 +669,16 @@ for(; first != last; ++first)
           <parameter name="val"><paramtype>wchar_t</paramtype></parameter>
         </signature>
 
+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>char16_t</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>char32_t</paramtype></parameter>
+        </signature>
+
         <signature>
           <type>std::size_t</type>
           <parameter name="val"><paramtype>short</paramtype></parameter>
@@ -784,6 +889,11 @@ for(; first != last; ++first)
 
         <notes>
           <para>This is an extension to TR1</para>
+          <para>
+            This hash function is not intended for general use, and isn't
+            guaranteed to be equal during separate runs of a program - so
+            please don't use it for any persistent storage or communication.
+          </para>
         </notes>
 
         <throws>
@@ -805,7 +915,8 @@ for(; first != last; ++first)
               <tbody>
                 <row>
                   <entry><code>bool</code>,
-                    <code>char</code>, <code>signed char</code>, <code>unsigned char</code>, <code>wchar_t</code>,
+                    <code>char</code>, <code>signed char</code>, <code>unsigned char</code>,
+                    <code>wchar_t</code>, <code>char16_t</code>, <code>char32_t</code>,
                     <code>short</code>, <code>unsigned short</code>,
                     <code>int</code>, <code>unsigned int</code>, <code>long</code>, <code>unsigned long</code>
                   </entry>

examples/point.cpp

@@ -3,6 +3,11 @@
 // 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)
 
+// Force use of assert.
+#if defined(NDEBUG)
+#undef NDEBUG
+#endif
+
 #include <boost/functional/hash.hpp>
 #include <cassert>
 

examples/portable.cpp

@@ -3,6 +3,11 @@
 // 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)
 
+// Force use of assert.
+#if defined(NDEBUG)
+#undef NDEBUG
+#endif
+
 #include <boost/functional/hash.hpp>
 #include <cassert>
 

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

@@ -7,12 +7,12 @@
 #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)
-# pragma once
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
 #endif
 
+#include <boost/config/no_tr1/cmath.hpp>
+
 // Set BOOST_HASH_CONFORMANT_FLOATS to 1 for libraries known to have
 // sufficiently good floating point support to not require any
 // workarounds.

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

@@ -6,11 +6,11 @@
 #if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER)
 #define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
 #endif
 
-#include <boost/config.hpp>
 #include <boost/functional/hash/detail/float_functions.hpp>
 #include <boost/functional/hash/detail/limits.hpp>
 #include <boost/utility/enable_if.hpp>
@@ -68,7 +68,7 @@ namespace boost
             std::size_t seed = 0;
 
             if (length >= sizeof(std::size_t)) {
-                seed = *(std::size_t*) ptr;
+                std::memcpy(&seed, ptr, sizeof(std::size_t));
                 length -= sizeof(std::size_t);
                 ptr += sizeof(std::size_t);
 
@@ -90,15 +90,21 @@ namespace boost
             return seed;
         }
 
+        template <typename Float, unsigned digits, unsigned max_exponent>
+        struct enable_binary_hash
+        {
+            BOOST_STATIC_CONSTANT(bool, value =
+                std::numeric_limits<Float>::is_iec559 &&
+                std::numeric_limits<Float>::digits == digits &&
+                std::numeric_limits<Float>::radix == 2 &&
+                std::numeric_limits<Float>::max_exponent == max_exponent);
+        };
+
         template <typename Float>
         inline std::size_t float_hash_impl(Float v,
             BOOST_DEDUCED_TYPENAME boost::enable_if_c<
-                std::numeric_limits<Float>::is_iec559 &&
-                std::numeric_limits<Float>::digits == 24 &&
-                std::numeric_limits<Float>::radix == 2 &&
-                std::numeric_limits<Float>::max_exponent == 128,
-                int>::type
-            )
+                enable_binary_hash<Float, 24, 128>::value,
+                std::size_t>::type)
         {
             return hash_binary((char*) &v, 4);
         }
@@ -107,12 +113,8 @@ namespace boost
         template <typename Float>
         inline std::size_t float_hash_impl(Float v,
             BOOST_DEDUCED_TYPENAME boost::enable_if_c<
-                std::numeric_limits<Float>::is_iec559 &&
-                std::numeric_limits<Float>::digits == 53 &&
-                std::numeric_limits<Float>::radix == 2 &&
-                std::numeric_limits<Float>::max_exponent == 1024,
-                int>::type
-            )
+                enable_binary_hash<Float, 53, 1024>::value,
+                std::size_t>::type)
         {
             return hash_binary((char*) &v, 8);
         }
@@ -120,12 +122,8 @@ namespace boost
         template <typename Float>
         inline std::size_t float_hash_impl(Float v,
             BOOST_DEDUCED_TYPENAME boost::enable_if_c<
-                std::numeric_limits<Float>::is_iec559 &&
-                std::numeric_limits<Float>::digits == 64 &&
-                std::numeric_limits<Float>::radix == 2 &&
-                std::numeric_limits<Float>::max_exponent == 16384,
-                int>::type
-            )
+                enable_binary_hash<Float, 64, 16384>::value,
+                std::size_t>::type)
         {
             return hash_binary((char*) &v, 10);
         }
@@ -133,12 +131,8 @@ namespace boost
         template <typename Float>
         inline std::size_t float_hash_impl(Float v,
             BOOST_DEDUCED_TYPENAME boost::enable_if_c<
-                std::numeric_limits<Float>::is_iec559 &&
-                std::numeric_limits<Float>::digits == 113 &&
-                std::numeric_limits<Float>::radix == 2 &&
-                std::numeric_limits<Float>::max_exponent == 16384,
-                int>::type
-            )
+                enable_binary_hash<Float, 113, 16384>::value,
+                std::size_t>::type)
         {
             return hash_binary((char*) &v, 16);
         }
@@ -185,7 +179,7 @@ namespace boost
                 hash_float_combine(seed, part);
             }
 
-            hash_float_combine(seed, exp);
+            hash_float_combine(seed, static_cast<std::size_t>(exp));
 
             return seed;
         }

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

@@ -9,8 +9,9 @@
 #if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER)
 #define BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
 #endif
 
 #include <boost/limits.hpp>

include/boost/functional/hash/extensions.hpp

@@ -13,6 +13,11 @@
 #if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
 #define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP
 
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
 #include <boost/functional/hash/hash.hpp>
 #include <boost/detail/container_fwd.hpp>
 #include <boost/utility/enable_if.hpp>
@@ -32,18 +37,10 @@
 #   include <memory>
 #endif
 
-#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>
@@ -232,11 +229,7 @@ namespace boost
             template <class Array>
             struct inner
             {
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
                 static std::size_t call(Array const& v)
-#else
-                static std::size_t call(Array& v)
-#endif
                 {
                     const int size = sizeof(v) / sizeof(*v);
                     return boost::hash_range(v, v + size);
@@ -261,7 +254,7 @@ namespace boost
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
     template <class T> struct hash
-        : std::unary_function<T, std::size_t>
+        : boost::hash_detail::hash_base<T>
     {
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
         std::size_t operator()(T const& val) const
@@ -278,7 +271,7 @@ namespace boost
 
 #if BOOST_WORKAROUND(__DMC__, <= 0x848)
     template <class T, unsigned int n> struct hash<T[n]>
-        : std::unary_function<T[n], std::size_t>
+        : boost::hash_detail::hash_base<T[n]>
     {
         std::size_t operator()(const T* val) const
         {
@@ -298,14 +291,12 @@ namespace boost
         template <bool IsPointer>
         struct hash_impl;
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-
         template <>
         struct hash_impl<false>
         {
             template <class T>
             struct inner
-                : std::unary_function<T, std::size_t>
+                : boost::hash_detail::hash_base<T>
             {
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
                 std::size_t operator()(T const& val) const
@@ -320,58 +311,6 @@ namespace boost
 #endif
             };
         };
-
-#else // Visual C++ 6.5
-
-        // 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
-        {
-            template <class T>
-            struct inner
-                : public std::unary_function<T, std::size_t>
-            {
-                std::size_t operator()(T const& val) const
-                {
-                    return hash_detail::call_hash<T const>::call(val);
-                }
-
-                std::size_t operator()(T& val) const
-                {
-                    return hash_detail::call_hash<T>::call(val);
-                }
-            };
-        };
-
-        template <>
-        struct hash_impl_msvc<true>
-        {
-            template <class T>
-            struct inner
-                : public std::unary_function<T, std::size_t>
-            {
-                std::size_t operator()(T& val) const
-                {
-                    return hash_detail::call_hash<T>::call(val);
-                }
-            };
-        };
-        
-        template <class T>
-        struct hash_impl_msvc2
-            : public hash_impl_msvc<boost::is_const<T>::value>
-                    ::BOOST_NESTED_TEMPLATE inner<T> {};
-        
-        template <>
-        struct hash_impl<false>
-        {
-            template <class T>
-            struct inner : public hash_impl_msvc2<T> {};
-        };
-
-#endif // Visual C++ 6.5
     }
 #endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 }

include/boost/functional/hash/hash.hpp

@@ -1,11 +1,17 @@
 
-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-2014 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)
 
 //  Based on Peter Dimov's proposal
 //  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
 //  issue 6.18. 
+//
+//  This also contains public domain code from MurmurHash. From the
+//  MurmurHash header:
+
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
 
 #if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP)
 #define BOOST_FUNCTIONAL_HASH_HASH_HPP
@@ -18,6 +24,7 @@
 #include <boost/type_traits/is_enum.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/utility/enable_if.hpp>
+#include <boost/cstdint.hpp>
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 #include <boost/type_traits/is_pointer.hpp>
@@ -27,6 +34,17 @@
 #include <typeindex>
 #endif
 
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+
+#if BOOST_MSVC >= 1400
+#pragma warning(disable:6295) // Ill-defined for-loop : 'unsigned int' values
+                              // are always of range '0' to '4294967295'.
+                              // Loop executes infinitely.
+#endif
+
+#endif
+
 #if BOOST_WORKAROUND(__GNUC__, < 3) \
     && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
 #define BOOST_HASH_CHAR_TRAITS string_char_traits
@@ -34,10 +52,28 @@
 #define BOOST_HASH_CHAR_TRAITS char_traits
 #endif
 
+#if defined(_MSC_VER)
+#   define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) _rotl(x,r)
+#else
+#   define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r))
+#endif
+
 namespace boost
 {
     namespace hash_detail
     {
+#if defined(_HAS_AUTO_PTR_ETC) && !_HAS_AUTO_PTR_ETC
+        template <typename T>
+        struct hash_base
+        {
+            typedef T argument_type;
+            typedef std::size_t result_type;
+        };
+#else
+        template <typename T>
+        struct hash_base : std::unary_function<T, std::size_t> {};
+#endif
+
         struct enable_hash_value { typedef std::size_t type; };
 
         template <typename T> struct basic_numbers {};
@@ -71,6 +107,16 @@ namespace boost
             boost::hash_detail::enable_hash_value {};
 #endif
 
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+        template <> struct basic_numbers<char16_t> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+        template <> struct basic_numbers<char32_t> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
         // long_numbers is defined like this to allow for separate
         // specialization for long_long and int128_type, in case
         // they conflict.
@@ -144,10 +190,10 @@ namespace boost
         template <class T>
         inline std::size_t hash_value_signed(T val)
         {
-             const int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
              // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
              const int length = (std::numeric_limits<T>::digits - 1)
-                 / size_t_bits;
+                 / static_cast<int>(size_t_bits);
 
              std::size_t seed = 0;
              T positive = val < 0 ? -1 - val : val;
@@ -165,10 +211,10 @@ namespace boost
         template <class T>
         inline std::size_t hash_value_unsigned(T val)
         {
-             const int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
              // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
              const int length = (std::numeric_limits<T>::digits - 1)
-                 / size_t_bits;
+                 / static_cast<int>(size_t_bits);
 
              std::size_t seed = 0;
 
@@ -181,6 +227,53 @@ namespace boost
 
              return seed;
         }
+
+        template <typename SizeT>
+        inline void hash_combine_impl(SizeT& seed, SizeT value)
+        {
+            seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        }
+
+        inline void hash_combine_impl(boost::uint32_t& h1,
+                boost::uint32_t k1)
+        {
+            const uint32_t c1 = 0xcc9e2d51;
+            const uint32_t c2 = 0x1b873593;
+
+            k1 *= c1;
+            k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
+            k1 *= c2;
+
+            h1 ^= k1;
+            h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
+            h1 = h1*5+0xe6546b64;
+        }
+
+
+// Don't define 64-bit hash combine on platforms without 64 bit integers,
+// and also not for 32-bit gcc as it warns about the 64-bit constant.
+#if !defined(BOOST_NO_INT64_T) && \
+        !(defined(__GNUC__) && ULONG_MAX == 0xffffffff)
+
+        inline void hash_combine_impl(boost::uint64_t& h,
+                boost::uint64_t k)
+        {
+            const boost::uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
+            const int r = 47;
+
+            k *= m;
+            k ^= k >> r;
+            k *= m;
+
+            h ^= k;
+            h *= m;
+
+            // Completely arbitrary number, to prevent 0's
+            // from hashing to 0.
+            h += 0xe6546b64;
+        }
+
+#endif // BOOST_NO_INT64_T
     }
 
     template <typename T>
@@ -237,16 +330,11 @@ namespace boost
 #endif
 #endif
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    template <class T>
-    inline void hash_combine(std::size_t& seed, T& v)
-#else
     template <class T>
     inline void hash_combine(std::size_t& seed, T const& v)
-#endif
     {
         boost::hash<T> hasher;
-        seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        return boost::hash_detail::hash_combine_impl(seed, hasher(v));
     }
 
 #if defined(BOOST_MSVC)
@@ -347,14 +435,13 @@ namespace boost
     // passed by copy.
     //
     // BOOST_HASH_SPECIALIZE_REF - define a specialization for a type which is
-    // passed by copy.
+    // passed by const reference.
     //
     // These are undefined later.
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 #define BOOST_HASH_SPECIALIZE(type) \
     template <> struct hash<type> \
-         : public std::unary_function<type, std::size_t> \
+         : public boost::hash_detail::hash_base<type> \
     { \
         std::size_t operator()(type v) const \
         { \
@@ -364,52 +451,13 @@ namespace boost
 
 #define BOOST_HASH_SPECIALIZE_REF(type) \
     template <> struct hash<type> \
-         : public std::unary_function<type, std::size_t> \
+         : public boost::hash_detail::hash_base<type> \
     { \
         std::size_t operator()(type const& v) const \
         { \
             return boost::hash_value(v); \
         } \
     };
-#else
-#define BOOST_HASH_SPECIALIZE(type) \
-    template <> struct hash<type> \
-         : public std::unary_function<type, std::size_t> \
-    { \
-        std::size_t operator()(type v) const \
-        { \
-            return boost::hash_value(v); \
-        } \
-    }; \
-    \
-    template <> struct hash<const type> \
-         : public std::unary_function<const type, std::size_t> \
-    { \
-        std::size_t operator()(const type v) const \
-        { \
-            return boost::hash_value(v); \
-        } \
-    };
-
-#define BOOST_HASH_SPECIALIZE_REF(type) \
-    template <> struct hash<type> \
-         : public std::unary_function<type, std::size_t> \
-    { \
-        std::size_t operator()(type const& v) const \
-        { \
-            return boost::hash_value(v); \
-        } \
-    }; \
-    \
-    template <> struct hash<const type> \
-         : public std::unary_function<const type, std::size_t> \
-    { \
-        std::size_t operator()(type const& v) const \
-        { \
-            return boost::hash_value(v); \
-        } \
-    };
-#endif
 
     BOOST_HASH_SPECIALIZE(bool)
     BOOST_HASH_SPECIALIZE(char)
@@ -417,6 +465,12 @@ namespace boost
     BOOST_HASH_SPECIALIZE(unsigned char)
 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
     BOOST_HASH_SPECIALIZE(wchar_t)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    BOOST_HASH_SPECIALIZE(char16_t)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    BOOST_HASH_SPECIALIZE(char32_t)
 #endif
     BOOST_HASH_SPECIALIZE(short)
     BOOST_HASH_SPECIALIZE(unsigned short)
@@ -430,9 +484,15 @@ namespace boost
     BOOST_HASH_SPECIALIZE(long double)
 
     BOOST_HASH_SPECIALIZE_REF(std::string)
-#if !defined(BOOST_NO_STD_WSTRING)
+#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
     BOOST_HASH_SPECIALIZE_REF(std::wstring)
 #endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    BOOST_HASH_SPECIALIZE_REF(std::basic_string<char16_t>)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    BOOST_HASH_SPECIALIZE_REF(std::basic_string<char32_t>)
+#endif
 
 #if !defined(BOOST_NO_LONG_LONG)
     BOOST_HASH_SPECIALIZE(boost::long_long_type)
@@ -457,7 +517,7 @@ namespace boost
 
     template <class T>
     struct hash<T*>
-        : public std::unary_function<T*, std::size_t>
+        : public boost::hash_detail::hash_base<T*>
     {
         std::size_t operator()(T* v) const
         {
@@ -490,7 +550,7 @@ namespace boost
         {
             template <class T>
             struct inner
-                : public std::unary_function<T, std::size_t>
+                : public boost::hash_detail::hash_base<T>
             {
                 std::size_t operator()(T val) const
                 {
@@ -517,6 +577,11 @@ namespace boost
 }
 
 #undef BOOST_HASH_CHAR_TRAITS
+#undef BOOST_FUNCTIONAL_HASH_ROTL32
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
 
 #endif // BOOST_FUNCTIONAL_HASH_HASH_HPP
 

include/boost/functional/hash/hash_fwd.hpp

@@ -10,11 +10,11 @@
 #if !defined(BOOST_FUNCTIONAL_HASH_FWD_HPP)
 #define BOOST_FUNCTIONAL_HASH_FWD_HPP
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
 #endif
 
-#include <boost/config.hpp>
 #include <cstddef>
 #include <boost/detail/workaround.hpp>
 
@@ -22,11 +22,7 @@ namespace boost
 {
     template <class T> struct hash;
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    template <class T> void hash_combine(std::size_t& seed, T& v);
-#else
     template <class T> void hash_combine(std::size_t& seed, T const& v);
-#endif
 
     template <class It> std::size_t hash_range(It, It);
     template <class It> void hash_range(std::size_t&, It, It);

include/boost/functional/hash_fwd.hpp

@@ -3,5 +3,9 @@
 // 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 <boost/functional/hash/hash_fwd.hpp>
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
 
+#include <boost/functional/hash/hash_fwd.hpp>

meta/libraries.json

@@ -0,0 +1,20 @@
+[
+    {
+        "key": "functional/hash",
+        "boost-version": "1.33.0",
+        "name": "Functional/Hash",
+        "authors": [
+            "Daniel James"
+        ],
+        "maintainers": [
+            "Daniel James <dnljms -at- gmail.com>"
+        ],
+        "description": "A TR1 hash function object that can be extended to hash user defined types.",
+        "std": [
+            "tr1"
+        ],
+        "category": [
+            "Function-objects"
+        ]
+    }
+]

test/Jamfile.v2

@@ -12,6 +12,7 @@ project hash-tests
         #<toolset>intel:<cxxflags>-strict-ansi
         <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
         <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
+        <toolset>clang:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wsign-conversion -Wconversion -Wfloat-equal -Wshadow"
         #<toolset>msvc:<warnings-as-errors>on
         #<toolset>gcc:<warnings-as-errors>on
         #<toolset>darwin:<warnings-as-errors>on
@@ -19,6 +20,7 @@ project hash-tests
 
 test-suite functional/hash
     :
+        [ compile check_float_funcs.cpp ]
         [ run hash_fwd_test_1.cpp ]
         [ run hash_fwd_test_2.cpp ]
         [ run hash_number_test.cpp ]

test/compile_time.hpp

@@ -10,7 +10,9 @@
 template <class T>
 void compile_time_tests(T*)
 {
+#if !defined(_HAS_AUTO_PTR_ETC) || _HAS_AUTO_PTR_ETC
     BOOST_STATIC_ASSERT((boost::is_base_and_derived<
         std::unary_function<T, std::size_t>, BOOST_HASH_TEST_NAMESPACE::hash<T> >::value));
+#endif
 }
 

test/extra/Jamfile.v2

@@ -1,13 +0,0 @@
-
-# Copyright 2012 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)
-
-import testing ;
-
-build-project .. ;
-
-test-suite functional/hash/config
-    :
-        [ compile check_float_funcs.cpp ]
-    ;

test/hash_complex_test.cpp

@@ -84,8 +84,8 @@ void complex_integral_tests(Integer*)
     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));
+    generic_complex_tests(complex(Integer(-243897),Integer(-49923874)));
+    generic_complex_tests(complex(Integer(-543),Integer(763)));
 }
 
 int main()

test/hash_custom_test.cpp

@@ -15,7 +15,7 @@ namespace test
 
         std::size_t hash() const
         {
-            return value_ * 10;
+            return static_cast<std::size_t>(value_ * 10);
         }
 
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)

test/hash_friend_test.cpp

@@ -17,7 +17,7 @@ namespace test
 
         std::size_t hash() const
         {
-            return value_ * 10;
+            return static_cast<std::size_t>(value_ * 10);
         }
 
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)

test/hash_global_namespace_test.cpp

@@ -17,7 +17,7 @@ struct custom
 
     std::size_t hash() const
     {
-        return value_ * 10;
+        return static_cast<std::size_t>(value_ * 10);
     }
 
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)

test/hash_number_test.cpp

@@ -58,8 +58,6 @@ void numeric_extra_tests(typename
 template <class T>
 void numeric_test(T*)
 {
-    typedef boost::hash_detail::limits<T> limits;
-
     compile_time_tests((T*) 0);
 
     BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
@@ -129,9 +127,13 @@ void poor_quality_tests(T*)
         BOOST_TEST(x1(T(1)) !=  x2(T(-1)));
     if(T(1) != T(2))
         BOOST_TEST(x1(T(1)) !=  x2(T(2)));
-    if((limits::max)() != (limits::max)() - 1)
-        BOOST_TEST(x1(static_cast<T>((limits::max)()))
-            != x2(static_cast<T>((limits::max)() - 1)));
+
+    // TODO: This test is useless for floating point numbers.
+    T max_number = static_cast<T>((limits::max)());
+    T max_minus_one = static_cast<T>(max_number - 1);
+    if (max_number != max_minus_one) {
+        BOOST_TEST(x1(max_number) != x1(max_minus_one));
+    }
 }
 
 void bool_test()
@@ -162,6 +164,12 @@ int main()
     NUMERIC_TEST(unsigned char, uchar)
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
     NUMERIC_TEST(wchar_t, wchar)
+#endif
+#ifndef BOOST_NO_CXX11_CHAR16_T
+    NUMERIC_TEST(char16_t, char16)
+#endif
+#ifndef BOOST_NO_CXX11_CHAR32_T
+    NUMERIC_TEST(char32_t, char32)
 #endif
     NUMERIC_TEST(short, short)
     NUMERIC_TEST(unsigned short, ushort)

test/hash_sequence_test.hpp

@@ -19,6 +19,8 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
     template <class T>
     void integer_tests(T* = 0)
     {
+        typedef typename T::value_type value_type;
+
         const int number_of_containers = 11;
         T containers[number_of_containers];
 
@@ -27,16 +29,16 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
                 containers[i].push_back(0);
         }
 
-        containers[5].push_back(1);
-        containers[6].push_back(1);
-        containers[6].push_back(1);
-        containers[7].push_back(-1);
-        containers[8].push_back(-1);
-        containers[8].push_back(-1);
-        containers[9].push_back(1);
-        containers[9].push_back(-1);
-        containers[10].push_back(-1);
-        containers[10].push_back(1);
+        containers[5].push_back(value_type(1));
+        containers[6].push_back(value_type(1));
+        containers[6].push_back(value_type(1));
+        containers[7].push_back(value_type(-1));
+        containers[8].push_back(value_type(-1));
+        containers[8].push_back(value_type(-1));
+        containers[9].push_back(value_type(1));
+        containers[9].push_back(value_type(-1));
+        containers[10].push_back(value_type(-1));
+        containers[10].push_back(value_type(1));
 
         BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
 

test/hash_set_test.hpp

@@ -19,6 +19,8 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
     template <class T>
     void integer_tests(T* = 0)
     {
+        typedef typename T::value_type value_type;
+
         const int number_of_containers = 12;
         T containers[number_of_containers];
 
@@ -27,19 +29,19 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
                 containers[i].insert(0);
         }
 
-        containers[6].insert(1);
-        containers[7].insert(1);
-        containers[7].insert(1);
-        containers[8].insert(-1);
-        containers[9].insert(-1);
-        containers[9].insert(-1);
-        containers[10].insert(-1);
-        containers[10].insert(1);
-        containers[11].insert(1);
-        containers[11].insert(2);
-        containers[11].insert(3);
-        containers[11].insert(4);
-        containers[11].insert(5);
+        containers[6].insert(value_type(1));
+        containers[7].insert(value_type(1));
+        containers[7].insert(value_type(1));
+        containers[8].insert(value_type(-1));
+        containers[9].insert(value_type(-1));
+        containers[9].insert(value_type(-1));
+        containers[10].insert(value_type(-1));
+        containers[10].insert(value_type(1));
+        containers[11].insert(value_type(1));
+        containers[11].insert(value_type(2));
+        containers[11].insert(value_type(3));
+        containers[11].insert(value_type(4));
+        containers[11].insert(value_type(5));
 
         BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
 

test/hash_string_test.cpp

@@ -38,7 +38,24 @@ void string_tests()
 #endif
 }
 
-#if !defined(BOOST_NO_STD_WSTRING)
+void string0_tests()
+{
+    std::string x1(1, '\0');
+    std::string x2(2, '\0');
+    std::string x3(3, '\0');
+    std::string x4(10, '\0');
+
+    BOOST_HASH_TEST_NAMESPACE::hash<std::string> hasher;
+
+    BOOST_TEST(hasher(x1) != hasher(x2));
+    BOOST_TEST(hasher(x1) != hasher(x3));
+    BOOST_TEST(hasher(x1) != hasher(x4));
+    BOOST_TEST(hasher(x2) != hasher(x3));
+    BOOST_TEST(hasher(x2) != hasher(x4));
+    BOOST_TEST(hasher(x3) != hasher(x4));
+}
+
+#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
 void wstring_tests()
 {
     compile_time_tests((std::wstring*) 0);
@@ -63,11 +80,68 @@ void wstring_tests()
 }
 #endif
 
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+void u16string_tests()
+{
+    compile_time_tests((std::u16string*) 0);
+
+    BOOST_HASH_TEST_NAMESPACE::hash<std::u16string> x1;
+    BOOST_HASH_TEST_NAMESPACE::hash<std::u16string> x2;
+
+    BOOST_TEST(x1(u"Hello") == x2(std::u16string(u"Hel") + u"lo"));
+    BOOST_TEST(x1(u"") == x2(std::u16string()));
+
+#if defined(BOOST_HASH_TEST_EXTENSIONS)
+    std::u16string value1;
+    std::u16string value2(u"Hello");
+
+    BOOST_TEST(x1(value1) == BOOST_HASH_TEST_NAMESPACE::hash_value(value1));
+    BOOST_TEST(x1(value2) == BOOST_HASH_TEST_NAMESPACE::hash_value(value2));
+    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value1) ==
+            BOOST_HASH_TEST_NAMESPACE::hash_range(value1.begin(), value1.end()));
+    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value2) ==
+            BOOST_HASH_TEST_NAMESPACE::hash_range(value2.begin(), value2.end()));
+#endif
+}
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+void u32string_tests()
+{
+    compile_time_tests((std::u32string*) 0);
+
+    BOOST_HASH_TEST_NAMESPACE::hash<std::u32string> x1;
+    BOOST_HASH_TEST_NAMESPACE::hash<std::u32string> x2;
+
+    BOOST_TEST(x1(U"Hello") == x2(std::u32string(U"Hel") + U"lo"));
+    BOOST_TEST(x1(U"") == x2(std::u32string()));
+
+#if defined(BOOST_HASH_TEST_EXTENSIONS)
+    std::u32string value1;
+    std::u32string value2(U"Hello");
+
+    BOOST_TEST(x1(value1) == BOOST_HASH_TEST_NAMESPACE::hash_value(value1));
+    BOOST_TEST(x1(value2) == BOOST_HASH_TEST_NAMESPACE::hash_value(value2));
+    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value1) ==
+            BOOST_HASH_TEST_NAMESPACE::hash_range(value1.begin(), value1.end()));
+    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value2) ==
+            BOOST_HASH_TEST_NAMESPACE::hash_range(value2.begin(), value2.end()));
+#endif
+}
+#endif
+
 int main()
 {
     string_tests();
-#if !defined(BOOST_NO_STD_WSTRING)
+    string0_tests();
+#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
     wstring_tests();
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    u16string_tests();
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    u32string_tests();
 #endif
     return boost::report_errors();
 }

test/link_ext_test.cpp

@@ -20,7 +20,7 @@ int f(std::size_t hash1, int* x1) {
 
     // Check that std::vector<std::size_t> is avaiable in this file.
     std::vector<std::size_t> x;
-    x.push_back(*x1);
+    x.push_back(static_cast<std::size_t>(*x1));
     BOOST_HASH_TEST_NAMESPACE::hash<std::vector<std::size_t> > vector_hasher;
     return vector_hasher(x) != BOOST_HASH_TEST_NAMESPACE::hash_value(x);