Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

Process #ifndef...#else...#endif blocks.

[SVN r86245]

.travis.yml

@@ -1,71 +0,0 @@
-# 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-tools-dev
-
-matrix:
-    include:
-      - compiler: gcc
-        env: |
-            USER_CONFIG="using gcc : : g++-4.8 -Werror --std=c++03 ;"
-      - compiler: gcc
-        env: |
-            USER_CONFIG="using gcc : : g++-4.8 -Werror --std=c++11 ;"
-      - compiler: clang
-        env: |
-            USER_CONFIG="using clang : : clang++ -Werror --std=c++03 ;"
-      - compiler: clang
-        env: |
-            USER_CONFIG="using clang : : clang++ -Werror --std=c++11 ;"
-      - compiler: clang
-        env: |
-            USER_CONFIG="using clang : : clang++ -Werror --std=c++11 -D_HAS_AUTO_PTR_ETC=0 ;"
-
-before_script:
-    - export BOOST_VERSION=1.65.1
-    - export BOOST_FILENAME=boost_1_65_1
-    - export BOOST_ROOT=${HOME}/boost
-    - cd ${TRAVIS_BUILD_DIR}
-    - touch Jamroot.jam
-    - cd $HOME
-    - echo $USER_CONFIG > ~/user-config.jam
-    - cat ~/user-config.jam
-    - |
-        mkdir $HOME/download
-        mkdir $HOME/extract
-        cd $HOME/download
-        if [ "$TRAVIS_EVENT_TYPE" == "cron" ]
-        then
-            if [ "$TRAVIS_BRANCH" == "master" ]
-            then
-                snapshot_branch=master
-            else
-                snapshot_branch=develop
-            fi
-            download_url=$(curl https://api.bintray.com/packages/boostorg/$snapshot_branch/snapshot/files |
-                    python -c "import os.path, sys, json; x = json.load(sys.stdin); print '\n'.join(a['path'] for a in x if os.path.splitext(a['path'])[1] == '.bz2')" |
-                    head -n 1 |
-                    sed "s/^/http:\/\/dl.bintray.com\/boostorg\/$snapshot_branch\//")
-        else
-            download_url=https://sourceforge.net/projects/boost/files/boost/${BOOST_VERSION}/${BOOST_FILENAME}.tar.bz2/download
-        fi
-        echo "Downloading ${download_url}"
-        wget -O boost.tar.bz2 $download_url
-        cd $HOME/extract
-        tar -xjf $HOME/download/boost.tar.bz2
-        mv * ${BOOST_ROOT}
-    - rm -r ${BOOST_ROOT}/boost/functional
-
-script:
-    - cd ${TRAVIS_BUILD_DIR}/test
-    - bjam -q ${BJAM_TOOLSET} include=${BOOST_ROOT} include=${TRAVIS_BUILD_DIR}/include

doc/changes.qbk

@@ -168,37 +168,5 @@
   ([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`
-
-[h2 Boost 1.66.0]
-
-* Avoid float comparison warning when using Clang - this workaround was
-  already in place for GCC, and was used when Clang pretends to be GCC,
-  but the warning was appearing when running Clang in other contexts.
 
 [endsect]

doc/ref.xml

@@ -59,11 +59,6 @@ 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
@@ -162,42 +157,6 @@ 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>
@@ -432,42 +391,6 @@ 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"/>
@@ -527,15 +450,7 @@ 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>
-            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>
+        <effects><programlisting>seed ^= <functionname>hash_value</functionname>(v) + 0x9e3779b9 + (seed &lt;&lt; 6) + (seed &gt;&gt; 2);</programlisting></effects>
         <notes>
           <para><functionname>hash_value</functionname> is called without
           qualification, so that overloads can be found via ADL.</para>
@@ -544,11 +459,6 @@ 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.
@@ -617,11 +527,6 @@ 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>
@@ -669,16 +574,6 @@ 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>
@@ -889,11 +784,6 @@ 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>
@@ -915,8 +805,7 @@ 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>char16_t</code>, <code>char32_t</code>,
+                    <code>char</code>, <code>signed char</code>, <code>unsigned char</code>, <code>wchar_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,11 +3,6 @@
 // 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,11 +3,6 @@
 // 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/hash_float.hpp

@@ -68,7 +68,7 @@ namespace boost
             std::size_t seed = 0;
 
             if (length >= sizeof(std::size_t)) {
-                std::memcpy(&seed, ptr, sizeof(std::size_t));
+                seed = *(std::size_t*) ptr;
                 length -= sizeof(std::size_t);
                 ptr += sizeof(std::size_t);
 
@@ -179,7 +179,7 @@ namespace boost
                 hash_float_combine(seed, part);
             }
 
-            hash_float_combine(seed, static_cast<std::size_t>(exp));
+            hash_float_combine(seed, exp);
 
             return seed;
         }
@@ -241,7 +241,7 @@ namespace boost
         template <class T>
         inline bool is_zero(T v)
         {
-#if !defined(__GNUC__) && !defined(__clang__)
+#if !defined(__GNUC__)
             return v == 0;
 #else
             // GCC's '-Wfloat-equal' will complain about comparing

include/boost/functional/hash/extensions.hpp

@@ -251,10 +251,9 @@ namespace boost
     //
 
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
     template <class T> struct hash
-        : boost::hash_detail::hash_base<T>
+        : std::unary_function<T, std::size_t>
     {
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
         std::size_t operator()(T const& val) const
@@ -271,7 +270,7 @@ namespace boost
 
 #if BOOST_WORKAROUND(__DMC__, <= 0x848)
     template <class T, unsigned int n> struct hash<T[n]>
-        : boost::hash_detail::hash_base<T[n]>
+        : std::unary_function<T[n], std::size_t>
     {
         std::size_t operator()(const T* val) const
         {
@@ -280,39 +279,6 @@ namespace boost
     };
 #endif
 
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-    // 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 of hash_impl.
-
-    namespace hash_detail
-    {
-        template <bool IsPointer>
-        struct hash_impl;
-
-        template <>
-        struct hash_impl<false>
-        {
-            template <class T>
-            struct inner
-                : boost::hash_detail::hash_base<T>
-            {
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-                std::size_t operator()(T const& val) const
-                {
-                    return hash_value(val);
-                }
-#else
-                std::size_t operator()(T const& val) const
-                {
-                    return hash_detail::call_hash<T>::call(val);
-                }
-#endif
-            };
-        };
-    }
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 }
 
 #endif

include/boost/functional/hash/hash.hpp

@@ -1,17 +1,11 @@
 
-// Copyright 2005-2014 Daniel James.
+// 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)
 
 //  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
@@ -24,11 +18,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>
-#endif
 
 #if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
 #include <typeindex>
@@ -45,35 +35,10 @@
 
 #endif
 
-#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
-
-#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 {};
@@ -107,16 +72,6 @@ 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.
@@ -174,7 +129,7 @@ namespace boost
 
     template <class Ch, class A>
     std::size_t hash_value(
-        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&);
+        std::basic_string<Ch, std::char_traits<Ch>, A> const&);
 
     template <typename T>
     typename boost::hash_detail::float_numbers<T>::type hash_value(T);
@@ -190,10 +145,10 @@ namespace boost
         template <class T>
         inline std::size_t hash_value_signed(T val)
         {
-             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             const 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)
-                 / static_cast<int>(size_t_bits);
+                 / size_t_bits;
 
              std::size_t seed = 0;
              T positive = val < 0 ? -1 - val : val;
@@ -211,10 +166,10 @@ namespace boost
         template <class T>
         inline std::size_t hash_value_unsigned(T val)
         {
-             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             const 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)
-                 / static_cast<int>(size_t_bits);
+                 / size_t_bits;
 
              std::size_t seed = 0;
 
@@ -227,53 +182,6 @@ 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>
@@ -334,7 +242,7 @@ namespace boost
     inline void hash_combine(std::size_t& seed, T const& v)
     {
         boost::hash<T> hasher;
-        return boost::hash_detail::hash_combine_impl(seed, hasher(v));
+        seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
     }
 
 #if defined(BOOST_MSVC)
@@ -405,7 +313,7 @@ namespace boost
 
     template <class Ch, class A>
     inline std::size_t hash_value(
-        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const& v)
+        std::basic_string<Ch, std::char_traits<Ch>, A> const& v)
     {
         return hash_range(v.begin(), v.end());
     }
@@ -435,13 +343,13 @@ namespace boost
     // passed by copy.
     //
     // BOOST_HASH_SPECIALIZE_REF - define a specialization for a type which is
-    // passed by const reference.
+    // passed by copy.
     //
     // These are undefined later.
 
 #define BOOST_HASH_SPECIALIZE(type) \
     template <> struct hash<type> \
-         : public boost::hash_detail::hash_base<type> \
+         : public std::unary_function<type, std::size_t> \
     { \
         std::size_t operator()(type v) const \
         { \
@@ -451,7 +359,7 @@ namespace boost
 
 #define BOOST_HASH_SPECIALIZE_REF(type) \
     template <> struct hash<type> \
-         : public boost::hash_detail::hash_base<type> \
+         : public std::unary_function<type, std::size_t> \
     { \
         std::size_t operator()(type const& v) const \
         { \
@@ -465,12 +373,6 @@ 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)
@@ -484,15 +386,9 @@ namespace boost
     BOOST_HASH_SPECIALIZE(long double)
 
     BOOST_HASH_SPECIALIZE_REF(std::string)
-#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#if !defined(BOOST_NO_STD_WSTRING)
     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)
@@ -513,11 +409,10 @@ namespace boost
 
 // Specializing boost::hash for pointers.
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
     template <class T>
     struct hash<T*>
-        : public boost::hash_detail::hash_base<T*>
+        : public std::unary_function<T*, std::size_t>
     {
         std::size_t operator()(T* v) const
         {
@@ -532,53 +427,8 @@ namespace boost
         }
     };
 
-#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>
-        struct hash_impl;
-
-        template <>
-        struct hash_impl<true>
-        {
-            template <class T>
-            struct inner
-                : public boost::hash_detail::hash_base<T>
-            {
-                std::size_t operator()(T val) const
-                {
-#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 590)
-                    return boost::hash_value(val);
-#else
-                    std::size_t x = static_cast<std::size_t>(
-                        reinterpret_cast<std::ptrdiff_t>(val));
-
-                    return x + (x >> 3);
-#endif
-                }
-            };
-        };
-    }
-
-    template <class T> struct hash
-        : public boost::hash_detail::hash_impl<boost::is_pointer<T>::value>
-            ::BOOST_NESTED_TEMPLATE inner<T>
-    {
-    };
-
-#endif
 }
 
-#undef BOOST_HASH_CHAR_TRAITS
-#undef BOOST_FUNCTIONAL_HASH_ROTL32
-
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
 #endif

meta/explicit-failures-markup.xml

@@ -1,90 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<explicit-failures-markup>
-    <!-- functional/hash -->
-    <library name="functional/hash">
-        <mark-expected-failures>
-            <test name="hash_value_array_test"/>
-            <toolset name="msvc-6.5*"/>
-            <toolset name="msvc-7.0*"/>
-            <note author="Daniel James">
-              hash_value is not overloaded for arrays for older versions
-              of Visual C++. There is a work around so that
-              boost::hash&lt;T[N]&gt;, boost::hash_combine and boost::hash_range
-              work.
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="hash_function_pointer_test"/>
-            <toolset name="msvc-6.5*"/>
-            <toolset name="msvc-7.0*"/>
-            <note refid="2" author="Daniel James"/>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="hash_function_pointer_test"/>
-            <toolset name="sun-5.7"/>
-            <toolset name="sun-5.8"/>
-            <toolset name="sun-5.9"/>
-            <note author="Daniel James">
-                On these compilers the wrong overload of hash_value is called
-                when the argument is a hash function pointer. So calling
-                hash_value doesn't work but boost::hash does work (and it's
-                recommended that user never call hash_value directly so this
-                shouldn't be a problem).
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="hash_long_double_test"/>
-            <toolset name="gcc-3.4.3_sunos"/>
-            <toolset name="*pa_risc"/>
-            <note author="Daniel James">
-                This platform has poor support for <code>long double</code> so
-                the hash function perform poorly for values out of the range
-                of <code>double</code> or if they differ at a greater precision
-                that <code>double</code> is capable of representing.
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="point" />
-            <test name="books" />
-            <toolset name="msvc-6.5*"/>
-            <toolset name="msvc-7.0*"/>
-            <note author="Daniel James">
-                These examples only work on compilers with support for ADL.
-                It is possible to work around this, but I wanted to keep the
-                example code as clean as possible.
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="point" />
-            <toolset name="borland-*"/>
-            <note author="Daniel James">
-                It appears that Borland doesn't find friend functions defined
-                in a class by ADL. This is easily fixed but this example is
-                meant to show the typical way of customising boost::hash, not
-                the portable way.
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="hash_global_namespace_test" />
-            <toolset name="borland-*"/>
-            <note author="Daniel James">
-                The test demonstrates a Borland bug - functions that aren't
-                in a namespace don't appear to be found by ADL.
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="container_fwd_gcc_debug"/>
-            <toolset name="darwin-4.2"/>
-            <note author="Daniel James">
-              Debug containers aren't supported on Apple's version of gcc 4.2.
-            </note>
-        </mark-expected-failures>
-    </library>
-</explicit-failures-markup>

meta/libraries.json

@@ -1,20 +0,0 @@
-[
-    {
-        "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,7 +12,6 @@ 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
@@ -20,7 +19,6 @@ 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,9 +10,7 @@
 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

@@ -0,0 +1,13 @@
+
+# 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(Integer(-243897),Integer(-49923874)));
-    generic_complex_tests(complex(Integer(-543),Integer(763)));
+    generic_complex_tests(complex(-243897,-49923874));
+    generic_complex_tests(complex(-543,763));
 }
 
 int main()

test/hash_custom_test.cpp

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

test/hash_number_test.cpp

@@ -58,6 +58,8 @@ 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;
@@ -127,13 +129,9 @@ 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)));
-
-    // 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));
-    }
+    if((limits::max)() != (limits::max)() - 1)
+        BOOST_TEST(x1(static_cast<T>((limits::max)()))
+            != x2(static_cast<T>((limits::max)() - 1)));
 }
 
 void bool_test()
@@ -164,12 +162,6 @@ 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,8 +19,6 @@ 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];
 
@@ -29,16 +27,16 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
                 containers[i].push_back(0);
         }
 
-        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));
+        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);
 
         BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
 

test/hash_set_test.hpp

@@ -19,8 +19,6 @@ 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];
 
@@ -29,19 +27,19 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
                 containers[i].insert(0);
         }
 
-        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));
+        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);
 
         BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
 

test/hash_string_test.cpp

@@ -38,24 +38,7 @@ void string_tests()
 #endif
 }
 
-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)
+#if !defined(BOOST_NO_STD_WSTRING)
 void wstring_tests()
 {
     compile_time_tests((std::wstring*) 0);
@@ -80,68 +63,11 @@ 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();
-    string0_tests();
-#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#if !defined(BOOST_NO_STD_WSTRING)
     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(static_cast<std::size_t>(*x1));
+    x.push_back(*x1);
     BOOST_HASH_TEST_NAMESPACE::hash<std::vector<std::size_t> > vector_hasher;
     return vector_hasher(x) != BOOST_HASH_TEST_NAMESPACE::hash_value(x);