Add tests for linking two object files that include the hash libraries.

[SVN r29710]

doc/Jamfile.v2

@@ -0,0 +1,9 @@
+
+# Copyright Daniel James 2005. Use, modification, and distribution are
+# subject to 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)
+
+using quickbook ;
+
+xml hash : hash.qbk ;
+boostbook standalone : hash ;

doc/hash.qbk

@@ -0,0 +1,931 @@
+[library Boost.Functional/Hash
+    [authors [James, Daniel]]
+    [copyright 2005 Daniel James]
+    [purpose A TR1 hash function object that can be extended to hash user
+        defined types]
+    [category higher-order]
+    [id hash]
+    [dirname hash]
+    [license
+        Distributed under the Boost Software License, Version 1.0.
+        (See accompanying file LICENSE_1_0.txt or copy at
+        <ulink url="http://www.boost.org/LICENSE_1_0.txt">
+            http://www.boost.org/LICENSE_1_0.txt
+        </ulink>)
+    ]
+]
+
+[/ QuickBook Document version 1.0 ]
+[/ Feb 8, 2005 ]
+
+[def __note__       [$images/note.png]]
+[def __alert__      [$images/alert.png]]
+[def __tip__        [$images/tip.png]]
+[def __boost_hash   [classref boost::hash]]
+[def __hash_value   [funcref boost::hash_value hash_value]]
+[def __hash_combine [funcref boost::hash_combine]]
+[def __hash_range   [funcref boost::hash_range]]
+
+[section:intro Introduction]
+
+[def __tr1__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1745.pdf
+    C++ Standard Library Technical Report]]
+[def __tr1-short__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1745.pdf
+    Technical Report]]
+[def __multi-index__ [@../../libs/multi_index/doc/index.html
+    Boost Multi-Index Containers Library]]
+[def __multi-index-short__ [@../../libs/multi_index/doc/index.html
+    Boost.MultiIndex]]
+[def __issues__ [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+    Library Extension Technical Report Issues List]]
+[def __hash-function__ [@http://en.wikipedia.org/wiki/Hash_function hash function]]
+[def __hash-table__ [@http://en.wikipedia.org/wiki/Hash_table hash table]]
+
+__boost_hash is an implementation of the __hash-function__ object
+specified by the __tr1-short__. It is intended for use as the default hash function
+for unordered associative containers, and the __multi-index__'s hash indexes.
+
+As it is compliant with the __tr1-short__, it will work with:
+
+* integers
+* floats
+* pointers
+* strings
+
+It also implements the extension proposed by Peter Dimov in issue 6.18 of the
+__issues__, this adds support for:
+
+* arrays
+* `std::pair`
+* the standard containers.
+* extending __boost_hash for custom types.
+
+[endsect]
+
+[section:tutorial Tutorial]
+
+When using a hash index with __multi-index-short__, you don't need to do
+anything to use __boost_hash as it uses it by default.
+To find out how to use a user-defined type, read the
+[link hash.custom section on extending boost::hash for a custom data type].
+
+If your standard library supplies its own implementation of the unordered
+associative containers and you wish to use
+__boost_hash, just use an extra template parameter:
+
+    std::unordered_multiset<std::vector<int>, __boost_hash<int> >
+            set_of_ints;
+
+    std::unordered_set<std::pair<int, int>, __boost_hash<std::pair<int, int> >
+            set_of_pairs;
+
+    std::unordered_map<int, std::string, __boost_hash<int> > map_int_to_string;
+
+To use __boost_hash directly, create an instance and call it as a function:
+
+    #include <boost/hash/hash.hpp>
+
+    int main()
+    {
+        __boost_hash<std::string> string_hash;
+
+        std::size_t h = string_hash("Hash me");
+    }
+
+If you wish to make use of the extensions, you will need to include the
+appropriate header (see the
+[link hash.reference.specification reference documentation] for the full list).
+
+    #include <boost/hash/pair.hpp>
+
+    int main()
+    {
+        __boost_hash<std::pair<int, int> > pair_hash;
+
+        std::size_t h = pair_hash(std::make_pair(1, 2));
+    }
+
+Or alternatively, include `<boost/hash.hpp>` for the full library.
+
+For an example of generic use, here is a function to generate a vector
+containing the hashes of the elements of a container:
+
+    template <class Container>
+    std::vector<std::size_t> get_hashes(Container const& x)
+    {
+        std::vector<std::size_t> hashes;
+        std::transform(x.begin(), x.end(), std::insert_iterator(hashes),
+            __boost_hash<typename Container::value_type>());
+
+        return hashes;
+    }
+
+[endsect]
+
+[section:custom Extending boost::hash for a custom data type]
+
+__boost_hash is implemented by calling the function __hash_value.
+The namespace isn't specified so that it can detect overloads via argument
+dependant lookup. So if there is a free function `hash_value` in the same
+namespace as a custom type, it will get called.
+
+If you have a structure `library::book`, where each `book` is uniquely
+defined by it's member `id`:
+
+    namespace library
+    {
+        struct book
+        {
+            int id;
+            std::string author;
+            std::string title;
+
+            // ....
+        };
+
+        bool operator==(book const& a, book const& b)
+        {
+            return a.id == b.id;
+        }
+    }
+
+Then all you would need to do is write the function `library::hash_value`:
+
+    namespace library
+    {
+        std::size_t hash_value(book const& b)
+        {
+            __boost_hash<int> hasher;
+            return hasher(b.id);
+        }
+    }
+
+And you can now use __boost_hash with book:
+
+    library::book knife(3458, "Zane Grey", "The Hash Knife Outfit");
+    library::book dandelion(1354, "Paul J. Shanley",
+        "Hash & Dandelion Greens");
+
+    __boost_hash<library::book> book_hasher;
+    std::size_t knife_hash_value = book_hasher(knife);
+
+    // If std::unordered_set is available:
+    std::unordered_set<library::book, __boost_hash<library::book> > books;
+    books.insert(knife);
+    books.insert(library::book(2443, "Lindgren, Torgny", "Hash"));
+    books.insert(library::book(1953, "Snyder, Bernadette M.",
+        "Heavenly Hash: A Tasty Mix of a Mother's Meditations"));
+
+    assert(books.find(knife) != books.end());
+    assert(books.find(dandelion) == books.end());
+
+The full example can be found in:
+[@../../libs/functional/hash/examples/books.cpp /libs/functional/hash/examples/books.hpp]
+and
+[@../../libs/functional/hash/examples/books.cpp /libs/functional/hash/examples/books.cpp].
+
+[blurb
+When writing a hash function, first look at how the equality function works.
+Objects that are equal must generate the same hash value.
+When objects are not equal the should generate different hash values.
+In this object equality was based just on the id, if it was based
+on the objects name and author the hash function should take them into account
+(how to do this is discussed in the next section).
+]
+
+[endsect]
+
+[section:combine Combining hash values]
+
+Say you have a point class, representing a two dimensional location:
+
+    class point
+    {
+        int x;
+        int y;
+    public:
+        point() : x(0), y(0) {}
+        point(int x, int y) : x(x), y(y) {}
+
+        bool operator==(point const& other) const
+        {
+            return x = other.x && y == other.y;
+        }
+    };
+
+and you wish to use it as the key for an `unordered_map`. You need to
+customise the hash for this structure. To do this we need to combine
+the hash values for `x` and `y`. The function
+__hash_combine is supplied for this purpose:
+
+    class point
+    {
+        ...
+
+        friend std::size_t hash_value(point const& p)
+        {
+            std::size_t seed = 0;
+            __hash_combine(seed, p.x);
+            __hash_combine(seed, p.y);
+
+            return seed;
+        }
+
+        ...
+    };
+
+Calls to hash_combine incrementally build the hash from the different members
+of point, it can be repeatedly called for any number of elements. It calls
+__hash_value on the supplied element, and combines it with the seed.
+
+Full code for this example is at
+[@../../libs/functional/hash/examples/point.cpp /libs/functional/hash/examples/point.cpp].
+
+[blurb
+'''
+When using __hash_combine the order of the
+calls matters.
+<programlisting>
+    std::size_t seed = 0;
+    boost::hash_combine(seed, 1);
+    boost::hash_combine(seed, 2);
+</programlisting>
+results in a different seed to:
+<programlisting>
+    std::size_t seed = 0;
+    boost::hash_combine(seed, 2);
+    boost::hash_combine(seed, 1);
+</programlisting>
+If you are calculating a hash value for data where the order of the data
+doesn't matter in comparisons (e.g. a set) you will have to ensure that the
+data is always supplied in the same order.
+'''
+]
+
+To calculate the hash of an iterator range you can use __hash_range:
+
+    std::vector<std::string> some_strings;
+    std::size_t hash = __hash_range(some_strings.begin(), some_strings.end());
+
+[endsect]
+
+[section:portability Portability]
+
+__boost_hash is written to be as portable as possible, but unfortunately, several
+older compilers don't support argument dependent lookup (ADL) - the mechanism
+used for customization.  On those compilers custom overloads for hash_value
+need to be declared in the boost namespace.
+
+On a strictly standards compliant compiler, an overload defined in the
+boost namespace won't be found when __boost_hash is instantiated,
+so for these compilers the overload should only be declared in the same
+namespace as the class.
+
+Let's say we have a simple custom type:
+
+    namespace foo
+    {
+        struct custom_type
+        {
+            int value;
+
+            friend inline std::size_t hash_value(custom_type x)
+            {
+                __boost_hash<int> hasher;
+                return hasher(x.value);
+            }
+        };
+    }
+
+On a compliant compiler, when `hash_value` is called for this type,
+it will look at the namespace inside the type and find `hash_value`
+but on a compiler which doesn't support ADL `hash_value` won't be found.
+
+So on these compilers define a member function:
+
+    #ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+            friend inline std::size_t hash_value(custom_type x)
+            {
+                __boost_hash<int> hasher;
+                return hasher(x.value);
+            }
+    #else
+            std::size_t hash() const
+            {
+                __boost_hash<int> hasher;
+                return hasher(value);
+            }
+    #endif
+
+which will be called from the `boost` namespace:
+
+    #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+    namespace boost
+    {
+        std::size_t hash_value(foo::custom_type x)
+        {
+            return x.hash();
+        }
+    }
+    #endif
+
+Full code for this example is at
+[@../../libs/functional/hash/examples/portable.cpp /libs/functional/hash/examples/portable.cpp].
+
+[h2 Other Issues]
+
+On Visual C++ versions 6.5 and 7.0, `hash_value` isn't overloaded for built in
+arrays. __boost_hash, __hash_combine and __hash_range all use a workaround to
+support built in arrays so this shouldn't be a problem in most cases.
+
+On Visual C++ versions 6.5 and 7.0, function pointers aren't currently supported.
+
+`boost::hash_value(long double)` on GCC on Solaris appears to treat
+`long double`s as doubles - so the hash function doesn't take into account the
+full range of values.
+
+[endsect]
+
+[/ Quickbook insists on putting a paragraph around the escaped code, which
+messes up the library section, so I wrap it in another section. This is no good,
+but there you go. ]
+
+[section:reference_ Reference]
+'''
+<library-reference>
+  <section id="hash.reference.specification">
+    <para>For the full specification, see section 6.3 of the
+        <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1745.pdf">C++ Standard Library Technical Report</ulink>
+        and issue 6.18 of the
+        <ulink url="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf">Library Extension Technical Report Issues List</ulink>.
+    </para>
+  </section>
+  <header name="boost/functional/hash.hpp">
+    <para>Includes all the following headers.</para>
+  </header>
+  <header name="boost/functional/hash/hash.hpp">
+    <para>
+      Defines <code><classname>boost::hash</classname></code>,
+      the implementation for built in types and
+      <code>std::string</code> and customisation functions.
+    </para>
+
+    <namespace name="boost">
+
+      <!--
+        boost::hash
+        -->
+
+      <struct name="hash">
+        <template>
+          <template-type-parameter name="T"/>
+        </template>
+
+        <inherit access="public">
+          <classname>std::unary_function&lt;T, std::size_t&gt;</classname>
+        </inherit>
+
+        <purpose>An STL compliant hash function object.</purpose>
+
+        <method name="operator()" cv="const">
+          <type>std::size_t</type>
+          <parameter name="val">
+            <paramtype>T const&amp;</paramtype>
+          </parameter>
+          <returns><para>
+            <programlisting><functionname>hash_value</functionname>(val)</programlisting>
+          </para></returns>
+          <notes><para>
+            The call to <code><functionname>hash_value</functionname></code>
+            is unqualified, so that custom overloads can be
+            found via argument dependent lookup.
+          </para></notes>
+          <throws><para>
+            Only throws if
+            <code><functionname>hash_value</functionname>(T)</code> throws.
+          </para></throws>
+        </method>
+      </struct>
+
+      <!--
+        boost::hash_combine
+        -->
+
+      <function name="hash_combine">
+        <template>
+          <template-type-parameter name="T"/>
+        </template>
+        <type>void</type>
+        <parameter name="seed"><paramtype>size_t &amp;</paramtype></parameter>
+        <parameter name="v"><paramtype>T const &amp;</paramtype></parameter>
+        <purpose>
+            Called repeatedly to incrementally create a hash value from
+            several variables.
+        </purpose>
+        <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>
+          <para>This is an extension to TR1</para>
+        </notes>
+        <throws>
+          Only throws if <functionname>hash_value</functionname>(T) throws.
+          Strong exception safety, as long as <functionname>hash_value</functionname>(T)
+          also has strong exception safety.
+        </throws>
+      </function>
+
+      <!--
+        boost::hash_range
+        -->
+
+      <overloaded-function name="hash_range">
+        <signature>
+          <template>
+            <template-type-parameter name="It"/>
+          </template>
+          <type>std::size_t</type>
+          <parameter name="first"><paramtype>It</paramtype></parameter>
+          <parameter name="last"><paramtype>It</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <template>
+            <template-type-parameter name="It"/>
+          </template>
+          <type>void</type>
+          <parameter name="seed"><paramtype>std::size_t&amp;</paramtype></parameter>
+          <parameter name="first"><paramtype>It</paramtype></parameter>
+          <parameter name="last"><paramtype>It</paramtype></parameter>
+        </signature>
+
+        <purpose>
+            Calculate the combined hash value of the elements of an iterator
+            range.
+        </purpose>
+        <effects>
+          <para>For the two argument overload:
+<programlisting>
+size_t seed = 0;
+
+for(; first != last; ++first)
+{
+    <functionname>hash_combine</functionname>(seed, *first);
+}
+
+return seed;
+</programlisting>
+          </para>For the three arguments overload:
+<programlisting>
+for(; first != last; ++first)
+{
+    <functionname>hash_combine</functionname>(seed, *first);
+}
+</programlisting>
+          <para>
+          </para>
+        </effects>
+        <notes>
+          <para>
+            <code>hash_range</code> is sensitive to the order of the elements
+            so it wouldn't be appropriate to use this with an unordered
+            container.
+          </para>
+          <para>This is an extension to TR1</para>
+        </notes>
+        <throws><para>
+          Only throws if <code><functionname>hash_value</functionname>(std::iterator_traits&lt;It&gt;::value_type)</code>
+          throws. <code>hash_range(std::size_t&amp;, It, It)</code> has basic exception safety as long as
+          <code><functionname>hash_value</functionname>(std::iterator_traits&lt;It&gt;::value_type)</code>
+          has basic exception safety.
+        </para></throws>
+      </overloaded-function>
+
+      <!--
+        boost::hash_value - integers
+        -->
+
+      <overloaded-function name="hash_value">
+        <purpose>
+            Implementation of a hash function for integers.
+        </purpose>
+
+        <description><para>
+          Generally shouldn't be called directly by users, instead they should use
+          <classname>boost::hash</classname>, <functionname>boost::hash_range</functionname>
+          or <functionname>boost::hash_combine</functionname> which
+          call hash_value without namespace qualification so that overloads
+          for custom types are found via ADL.
+        </para></description>
+        <notes>
+          <para>Overloads for other types supplied in other headers.</para>
+          <para>This is an extension to TR1</para>
+        </notes>
+
+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>int</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>unsigned int</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>long</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>unsigned long</paramtype></parameter>
+        </signature>
+
+        <returns>
+          <code>val</code>
+        </returns>
+      </overloaded-function>
+
+      <!--
+        boost::hash_value - floating point
+        -->
+
+      <overloaded-function name="hash_value">
+        <purpose>
+            Implementation of a hash function for floating point values.
+        </purpose>
+
+        <description><para>
+          Generally shouldn't be called directly by users, instead they should use
+          <classname>boost::hash</classname>, <functionname>boost::hash_range</functionname>
+          or <functionname>boost::hash_combine</functionname> which
+          call hash_value without namespace qualification so that overloads
+          for custom types are found via ADL.
+        </para></description>
+        <notes>
+          <para>Overloads for other types supplied in other headers.</para>
+          <para>This is an extension to TR1</para>
+        </notes>
+
+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>float</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>double</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>long double</paramtype></parameter>
+        </signature>
+
+        <returns>
+          <para>
+            An unspecified value, except that equal arguments shall yield the same
+            result
+          </para>
+        </returns>
+      </overloaded-function>
+
+      <!--
+        boost::hash_value - pointers
+        -->
+
+      <overloaded-function name="hash_value">
+        <purpose>
+            Implementation of a hash function for pointers.
+        </purpose>
+
+        <description><para>
+          Generally shouldn't be called directly by users, instead they should use
+          <classname>boost::hash</classname>, <functionname>boost::hash_range</functionname>
+          or <functionname>boost::hash_combine</functionname> which
+          call hash_value without namespace qualification so that overloads
+          for custom types are found via ADL.
+        </para></description>
+        <notes>
+          <para>Overloads for other types supplied in other headers.</para>
+          <para>This is an extension to TR1</para>
+        </notes>
+
+        <signature>
+          <template><template-type-parameter name="T"/></template>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>T* const&amp;</paramtype></parameter>
+        </signature>
+
+        <returns>
+          <para>
+            An unspecified value, except that equal arguments shall yield the same
+            result
+          </para>
+        </returns>
+      </overloaded-function>
+
+      <!--
+        boost::hash_value - arrays
+        -->
+
+      <overloaded-function name="hash_value">
+        <purpose>
+            Implementation of a hash function for built in arrays.
+        </purpose>
+
+        <description><para>
+          Generally shouldn't be called directly by users, instead they should use
+          <classname>boost::hash</classname>, <functionname>boost::hash_range</functionname>
+          or <functionname>boost::hash_combine</functionname> which
+          call hash_value without namespace qualification so that overloads
+          for custom types are found via ADL.
+        </para></description>
+        <notes>
+          <para>Overloads for other types supplied in other headers.</para>
+          <para>This is an extension to TR1</para>
+        </notes>
+        
+        <signature>
+          <template>
+            <template-type-parameter name="T"/>
+            <template-nontype-parameter name="N"><type>unsigned</type></template-nontype-parameter>
+          </template>
+          <type>std::size_t</type>
+          <parameter><paramtype>T (&amp;val)[N]</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <template>
+            <template-type-parameter name="T"/>
+            <template-nontype-parameter name="N"><type>unsigned</type></template-nontype-parameter>
+          </template>
+          <type>std::size_t</type>
+          <parameter><paramtype>const T (&amp;val)[N]</paramtype></parameter>
+        </signature>
+
+        <returns><code>hash_range(val, val+N)</code></returns>
+      </overloaded-function>
+
+      <!--
+        boost::hash_value - string
+        -->
+
+      <overloaded-function name="hash_value">
+        <purpose>
+            Implementation of a hash function for <code>std::basic_string</code>.
+        </purpose>
+
+        <description><para>
+          Generally shouldn't be called directly by users, instead they should use
+          <classname>boost::hash</classname>, <functionname>boost::hash_range</functionname>
+          or <functionname>boost::hash_combine</functionname> which
+          call hash_value without namespace qualification so that overloads
+          for custom types are found via ADL.
+        </para></description>
+        <notes>
+          <para>Overloads for other types supplied in other headers.</para>
+          <para>This is an extension to TR1</para>
+        </notes>
+
+        <signature>
+          <template>
+            <template-type-parameter name="Ch"/>
+            <template-type-parameter name="A"/>
+          </template>
+          <type>std::size_t</type>
+          <parameter name="val">
+              <paramtype>std::basic_string&lt;Ch, std::char_traits&lt;Ch&gt;, A&gt; const&amp;</paramtype>
+          </parameter>
+        </signature>
+
+        <returns><code>hash_range(val.begin(), val.end())</code></returns>
+      </overloaded-function>
+    </namespace>
+  </header>
+
+  <header name="boost/functional/hash/pair.hpp">
+    <para>
+      Hash implementation for <code>std::pair</code>.
+    </para>
+    <namespace name="boost">
+      <overloaded-function name="hash_value">
+        <signature>
+          <template>
+            <template-type-parameter name="A"/>
+            <template-type-parameter name="B"/>
+          </template>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>std::pair&lt;A, B&gt; const &amp;</paramtype></parameter>
+        </signature>
+        <effects><programlisting>
+size_t seed = 0;
+<functionname>hash_combine</functionname>(seed, val.first);
+<functionname>hash_combine</functionname>(seed, val.second);
+return seed;
+        </programlisting></effects>
+        <throws>
+          Only throws if <code><functionname>hash_value</functionname>(A)</code>
+          or <code><functionname>hash_value</functionname>(B)</code> throws.
+        </throws>
+        <notes><para>This is an extension to TR1</para></notes>
+      </overloaded-function>
+    </namespace>
+  </header>
+
+  <header name="boost/functional/hash/vector.hpp">
+    <para>
+      Hash implementation for <code>std::vector</code>.
+    </para>
+    <namespace name="boost">
+      <overloaded-function name="hash_value">
+        <signature>
+          <template>
+            <template-type-parameter name="T"/>
+            <template-type-parameter name="A"/>
+          </template>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>std::vector&lt;T, A&gt; const &amp;</paramtype></parameter>
+        </signature>
+        <returns>
+          <code><functionname>hash_range</functionname>(val.begin(), val.end());</code>
+        </returns>
+        <throws>
+          Only throws if <code><functionname>hash_value</functionname>(T)</code> throws.
+        </throws>
+        <notes><para>This is an extension to TR1</para></notes>
+      </overloaded-function>      
+    </namespace>
+  </header>
+
+  <header name="boost/functional/hash/list.hpp">
+    <para>
+      Hash implementation for <code>std::list</code>.
+    </para>
+    <namespace name="boost">
+      <overloaded-function name="hash_value">
+        <signature>
+          <template>
+            <template-type-parameter name="T"/>
+            <template-type-parameter name="A"/>
+          </template>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>std::list&lt;T, A&gt; const &amp;</paramtype></parameter>
+        </signature>
+        <returns>
+          <code><functionname>hash_range</functionname>(val.begin(), val.end());</code>
+        </returns>
+        <throws>
+          Only throws if <code><functionname>hash_value</functionname>(T)</code> throws.
+        </throws>
+        <notes><para>This is an extension to TR1</para></notes>
+      </overloaded-function>      
+    </namespace>
+  </header>
+
+  <header name="boost/functional/hash/deque.hpp">
+    <para>
+      Hash implementation for <code>std::deque</code>.
+    </para>
+    <namespace name="boost">
+      <overloaded-function name="hash_value">
+        <signature>
+          <template>
+            <template-type-parameter name="T"/>
+            <template-type-parameter name="A"/>
+          </template>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>std::deque&lt;T, A&gt; const &amp;</paramtype></parameter>
+        </signature>
+        <returns>
+          <code><functionname>hash_range</functionname>(val.begin(), val.end());</code>
+        </returns>
+        <throws>
+          Only throws if <code><functionname>hash_value</functionname>(T)</code> throws.
+        </throws>
+        <notes><para>This is an extension to TR1</para></notes>
+      </overloaded-function>      
+    </namespace>
+  </header>
+
+  <header name="boost/functional/hash/set.hpp">
+    <para>
+      Hash implementation for <code>std::set</code> and <code>std::multiset</code>.
+    </para>
+    <namespace name="boost">
+      <overloaded-function name="hash_value">
+        <signature>
+          <template>
+            <template-type-parameter name="K"/>
+            <template-type-parameter name="C"/>
+            <template-type-parameter name="A"/>
+          </template>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>std::set&lt;K, C, A&gt; const &amp;</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <template>
+            <template-type-parameter name="K"/>
+            <template-type-parameter name="C"/>
+            <template-type-parameter name="A"/>
+          </template>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>std::multiset&lt;K, C, A&gt; const &amp;</paramtype></parameter>
+        </signature>
+        <returns>
+          <code><functionname>hash_range</functionname>(val.begin(), val.end());</code>
+        </returns>
+        <throws>
+          Only throws if <code><functionname>hash_value</functionname>(T)</code> throws.
+        </throws>
+        <notes><para>This is an extension to TR1</para></notes>
+      </overloaded-function>      
+    </namespace>
+  </header>
+
+  <header name="boost/functional/hash/map.hpp">
+    <para>
+      Hash implementation for <code>std::map</code> and <code>std::multimap</code>.
+    </para>
+    <namespace name="boost">
+      <overloaded-function name="hash_value">
+        <signature>
+          <template>
+            <template-type-parameter name="K"/>
+            <template-type-parameter name="T"/>
+            <template-type-parameter name="C"/>
+            <template-type-parameter name="A"/>
+          </template>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>std::map&lt;K, T, C, A&gt; const &amp;</paramtype></parameter>
+        </signature>
+
+        <signature>
+          <template>
+            <template-type-parameter name="K"/>
+            <template-type-parameter name="T"/>
+            <template-type-parameter name="C"/>
+            <template-type-parameter name="A"/>
+          </template>
+          <type>std::size_t</type>
+          <parameter name="val"><paramtype>std::multimap&lt;K, T, C, A&gt; const &amp;</paramtype></parameter>
+        </signature>
+        <returns>
+          <code><functionname>hash_range</functionname>(val.begin(), val.end());</code>
+        </returns>
+        <throws>
+          Only throws if
+          <code><functionname>hash_value</functionname>(std::pair&lt;K const, T&gt;)</code>
+          throws.
+        </throws>
+        <notes><para>This is an extension to TR1</para></notes>
+      </overloaded-function>      
+    </namespace>
+  </header>
+</library-reference>
+'''
+[/ Remove this comment and everything goes wrong! ;) ]
+[endsect]
+
+[section:links Links]
+
+[*A Proposal to Add Hash Tables to the Standard Library]\n
+[@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1456.html]\n
+The hash table proposal explains much of the design. The hash function object
+is discussed in Section D.
+
+[*The C++ Standard Library Technical Report.]\n
+[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1745.pdf]\n
+Contains the hash function specification in section 6.3.2.
+
+[*Library Extension Technical Report Issues List.]\n
+[@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf]\n
+The library implements the extension described in Issue 6.18.
+
+[*Methods for Identifying Versioned and Plagiarised Documents]\n
+Timothy C. Hoad, Justin Zobel\n
+[@http://www.cs.rmit.edu.au/~jz/fulltext/jasist-tch.pdf]\n
+Contains the hash function that __hash_combine is based on.
+
+[endsect]
+
+[section:acknowledgements Acknowledgements]
+
+This library is based on the design by Peter Dimov. During the inital development
+Joaquín M López Muñoz made many useful suggestions and contributed fixes.
+
+The review was managed by Thorsten Ottosen, and the library reviewed by:
+David Abrahams, Alberto Barbati, Topher Cooper, Caleb Epstein, Dave Harris,
+Chris Jefferson, Bronek Kozicki, John Maddock, Tobias Swinger,Jaap Suter
+and Rob Stewart.
+
+The implementation of the hash function for pointers is based on suggestions
+made by Alberto Barbati and Dave Harris. Dave Harris also suggested an
+important improvement to __hash_combine that was taken up.
+
+The original implementation came from Jeremy B. Maitin-Shepard's hash table
+library, although this is a complete rewrite.
+
+[endsect]

examples/Jamfile.v2

@@ -0,0 +1,8 @@
+
+# Copyright Daniel James 2005. Use, modification, and distribution are
+# subject to 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)
+
+exe books : books.cpp ;
+exe point : point.cpp ;
+exe portable : portable.cpp ;

examples/books.cpp

@@ -0,0 +1,48 @@
+
+//  Copyright Daniel James 2005. Use, modification, and distribution are
+//  subject to 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 "./books.hpp"
+#include <boost/functional/hash.hpp>
+#include <cassert>
+
+// If std::unordered_set was available:
+//#include <unordered_set>
+
+// This example illustrates how to use boost::hash with a custom hash function.
+// For full details, see the tutorial.
+
+int main()
+{
+    library::book knife(3458, "Zane Grey", "The Hash Knife Outfit");
+    library::book dandelion(1354, "Paul J. Shanley", "Hash & Dandelion Greens");
+
+    boost::hash<library::book> book_hasher;
+    std::size_t knife_hash_value = book_hasher(knife);
+
+    // If std::unordered_set was available:
+    //
+    //std::unordered_set<library::book, boost::hash<library::book> > books;
+    //books.insert(knife);
+    //books.insert(library::book(2443, "Lindgren, Torgny", "Hash"));
+    //books.insert(library::book(1953, "Snyder, Bernadette M.",
+    //    "Heavenly Hash: A Tasty Mix of a Mother's Meditations"));
+
+    //assert(books.find(knife) != books.end());
+    //assert(books.find(dandelion) == books.end());
+}
+
+namespace library
+{
+    bool operator==(book const& a, book const& b)
+    {
+        return a.id == b.id;
+    }
+
+    std::size_t hash_value(book const& b)
+    {
+        boost::hash<int> hasher;
+        return hasher(b.id);
+    }
+}

examples/books.hpp

@@ -0,0 +1,26 @@
+
+//  Copyright Daniel James 2005. Use, modification, and distribution are
+//  subject to 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)
+
+// This example illustrates how to use boost::hash with a custom hash function.
+// The implementation is contained in books.cpp
+
+#include <cstddef>
+#include <string>
+
+namespace library
+{
+    struct book
+    {
+        int id;
+        std::string author;
+        std::string title;
+
+        book(int i, std::string const& a, std::string const& t)
+            : id(i), author(a), title(t) {}
+    };
+
+    bool operator==(book const&, book const&);
+    std::size_t hash_value(book const&);
+}

examples/point.cpp

@@ -0,0 +1,51 @@
+
+//  Copyright Daniel James 2005. Use, modification, and distribution are
+//  subject to 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.hpp>
+#include <cassert>
+
+// This example illustrates how to use boost::hash_combine to generate a hash
+// value from the different members of a class. For full details see the hash
+// tutorial.
+
+class point
+{
+    int x;
+    int y;
+public:
+    point() : x(0), y(0) {}
+    point(int x, int y) : x(x), y(y) {}
+
+    bool operator==(point const& other) const
+    {
+        return x = other.x && y == other.y;
+    }
+
+    friend std::size_t hash_value(point const& p)
+    {
+        std::size_t seed = 0;
+        boost::hash_combine(seed, p.x);
+        boost::hash_combine(seed, p.y);
+
+        return seed;
+    }
+};
+
+int main()
+{
+    boost::hash<point> point_hasher;
+
+    point p1(0, 0);
+    point p2(1, 2);
+    point p3(4, 1);
+    point p4 = p1;
+
+    assert(point_hasher(p1) == point_hasher(p4));
+
+    // These tests could legally fail, but if they did it'd be a pretty bad
+    // hash function.
+    assert(point_hasher(p1) != point_hasher(p2));
+    assert(point_hasher(p1) != point_hasher(p3));
+}

examples/portable.cpp

@@ -0,0 +1,56 @@
+
+//  Copyright Daniel James 2005. Use, modification, and distribution are
+//  subject to 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.hpp>
+#include <cassert>
+
+// This example illustrates how to customise boost::hash portably, so that
+// it'll work on both compilers that don't implement argument dependent lookup
+// and compilers that implement strict two-phase template instantiation.
+
+namespace foo
+{
+    struct custom_type
+    {
+        int value;
+
+        custom_type(int x) : value(x) {}
+
+#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+        friend inline std::size_t hash_value(custom_type x)
+        {
+            boost::hash<int> hasher;
+            return hasher(x.value);
+        }
+#else
+        std::size_t hash() const
+        {
+            boost::hash<int> hasher;
+            return hasher(value);
+        }
+#endif
+    };
+}
+
+#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+namespace boost
+{
+    std::size_t hash_value(foo::custom_type x)
+    {
+        return x.hash();
+    }
+}
+#endif
+
+int main()
+{
+    foo::custom_type x(1), y(2), z(1);
+
+    boost::hash<foo::custom_type> hasher;
+
+    assert(hasher(x) == hasher(x));
+    assert(hasher(x) != hasher(y));
+    assert(hasher(x) == hasher(z));
+}

include/boost/functional/detail/float_functions.hpp

@@ -0,0 +1,152 @@
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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)
+
+#if !defined(BOOST_FUNCTIONAL_DETAIL_FLOAT_FUNCTIONS_HPP)
+#define BOOST_FUNCTIONAL_DETAIL_FLOAT_FUNCTIONS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// The C++ standard requires that the C float functions are overloarded
+// for float, double and long double in the std namespace, but some of the older
+// 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.
+
+// STLport:
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#  if defined(__GNUC__) && __GNUC__ < 3 && (defined(linux) || defined(__linux) || defined(__linux__))
+#    define BOOST_HASH_USE_C99_FLOAT_FUNCS
+#  elif defined(BOOST_MSVC) && BOOST_MSVC <= 1200
+#    define BOOST_HASH_USE_C99_FLOAT_FUNCS
+#  else
+#    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
+#  endif
+
+// Roguewave:
+//
+// 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
+
+// libstdc++ (gcc 3.0 onwards, I think)
+#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+#  define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
+
+// 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
+
+// Dinkumware.
+#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
+// Overloaded float functions were probably introduced in an earlier version
+// than this.
+#  if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 402)
+#    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
+#  else
+#    define BOOST_HASH_USE_C99_FLOAT_FUNCS
+#  endif
+
+// Digital Mars
+#elif defined(__DMC__)
+#  define BOOST_HASH_USE_C99_FLOAT_FUNCS
+
+// Use overloaded float functions by default.
+#else
+#  define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+
+        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
+        }
+
+        inline double call_ldexp(double v, int exp)
+        {
+            using namespace std;
+            return ldexp(v, exp);
+        }
+
+        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
+        }
+    }
+}
+
+#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.hpp

@@ -0,0 +1,25 @@
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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. 
+
+#if !defined(BOOST_FUNCTIONAL_HASH_HPP)
+#define BOOST_FUNCTIONAL_HASH_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/functional/hash/hash.hpp>
+#include <boost/functional/hash/pair.hpp>
+#include <boost/functional/hash/vector.hpp>
+#include <boost/functional/hash/list.hpp>
+#include <boost/functional/hash/deque.hpp>
+#include <boost/functional/hash/set.hpp>
+#include <boost/functional/hash/map.hpp>
+
+#endif

include/boost/functional/hash/deque.hpp

@@ -0,0 +1,45 @@
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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. 
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DEQUE_HPP)
+#define BOOST_FUNCTIONAL_HASH_DEQUE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <deque>
+#include <boost/functional/hash/hash.hpp>
+
+namespace boost
+{
+    template <class T, class A>
+    std::size_t hash_value(std::deque<T, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+    namespace hash_detail
+    {
+        template <class T, class A>
+        struct call_hash<std::deque<T, A> >
+        {
+            static std::size_t call(std::deque<T, A> const& val)
+            {
+                return boost::hash_value(val);
+            }
+        };
+    }
+#endif
+}
+
+#endif
+

include/boost/functional/hash/hash.hpp

@@ -0,0 +1,328 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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. 
+
+#if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP)
+#define BOOST_FUNCTIONAL_HASH_HASH_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <cstddef>
+#include <cmath>
+#include <string>
+#include <functional>
+#include <errno.h>
+#include <boost/limits.hpp>
+#include <boost/functional/detail/float_functions.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#include <boost/type_traits/is_array.hpp>
+#endif
+
+namespace boost
+{
+#if defined(__BORLANDC__)
+    // Borland complains about an ambiguous function overload
+    // when compiling boost::hash<bool>.
+    std::size_t hash_value(bool);
+#endif
+    
+    std::size_t hash_value(int);
+    std::size_t hash_value(unsigned int);
+    std::size_t hash_value(long);
+    std::size_t hash_value(unsigned long);
+
+    template <class T> std::size_t hash_value(T* const&);
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+    template< class T, unsigned N >
+    std::size_t hash_value(const T (&array)[N]);
+
+    template< class T, unsigned N >
+    std::size_t hash_value(T (&array)[N]);
+#endif
+
+    std::size_t hash_value(float v);
+    std::size_t hash_value(double v);
+    std::size_t hash_value(long double v);
+
+#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+    template <class Ch, class A>
+    std::size_t hash_value(std::basic_string<Ch, std::string_char_traits<Ch>, A> const&);
+#else
+    template <class Ch, class A>
+    std::size_t hash_value(std::basic_string<Ch, std::char_traits<Ch>, A> const&);
+#endif
+
+    template <class It> std::size_t hash_range(It first, It last);
+    template <class It> void hash_range(std::size_t&, It first, It last);
+#if defined(__BORLANDC__)
+    template <class T> inline std::size_t hash_range(T*, T*);
+    template <class T> inline void hash_range(std::size_t&, T*, T*);
+#endif
+
+#if defined(BOOST_MSVC) && 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
+
+    // Implementation
+
+#if defined(__BORLANDC__)
+    inline std::size_t hash_value(bool v)
+    {
+        return static_cast<std::size_t>(v);
+    }
+#endif
+
+    inline std::size_t hash_value(int v)
+    {
+        return static_cast<std::size_t>(v);
+    }
+
+    inline std::size_t hash_value(unsigned int v)
+    {
+        return static_cast<std::size_t>(v);
+    }
+
+    inline std::size_t hash_value(long v)
+    {
+        return static_cast<std::size_t>(v);
+    }
+
+    inline std::size_t hash_value(unsigned long v)
+    {
+        return static_cast<std::size_t>(v);
+    }
+
+    // Implementation by Alberto Barbati and Dave Harris.
+    template <class T> std::size_t hash_value(T* const& v)
+    {
+        std::size_t x = static_cast<std::size_t>(
+           reinterpret_cast<std::ptrdiff_t>(v));
+        return x + (x >> 3);
+    }
+
+    namespace hash_detail
+    {
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+        // This allows boost::hash to be specialised for classes in the
+        // standard namespace. It appears that a strict two phase template
+        // implementation only finds overloads that are in the current
+        // namespace at the point of definition (at instantiation
+        // it only finds new overloads via. ADL on the dependant paramters or
+        // something like that).
+        template <class T>
+        struct call_hash
+        {
+            static std::size_t call(T const& v)
+            {
+                using namespace boost;
+                return hash_value(v);
+            }
+        };
+#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+        template <bool IsArray>
+        struct call_hash_impl
+        {
+            template <class T>
+            struct inner
+            {
+                static std::size_t call(T const& v)
+                {
+                    using namespace boost;
+                    return hash_value(v);
+                }
+            };
+        };
+
+        template <>
+        struct call_hash_impl<true>
+        {
+            template <class Array>
+            struct inner
+            {
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1300
+                static std::size_t call(Array& v)
+#else
+                static std::size_t call(Array const& v)
+#endif
+                {
+                    const int size = sizeof(v) / sizeof(*v);
+                    return boost::hash_range(v, v + size);
+                }
+            };
+        };
+
+        template <class T>
+        struct call_hash
+            : public call_hash_impl<boost::is_array<T>::value>
+                ::BOOST_NESTED_TEMPLATE inner<T>
+        {
+        };
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    }
+
+#if defined(BOOST_MSVC) && 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
+    {
+        seed ^= hash_detail::call_hash<T>::call(v)
+            + 0x9e3779b9 + (seed<<6) + (seed>>2);
+    }
+
+    template <class It>
+    inline std::size_t hash_range(It first, It last)
+    {
+        std::size_t seed = 0;
+
+        for(; first != last; ++first)
+        {
+            hash_combine(seed, *first);
+        }
+
+        return seed;
+    }
+
+    template <class It>
+    inline void hash_range(std::size_t& seed, It first, It last)
+    {
+        for(; first != last; ++first)
+        {
+            hash_combine(seed, *first);
+        }
+    }
+
+#if defined(__BORLANDC__)
+    template <class T>
+    inline std::size_t hash_range(T* first, T* last)
+    {
+        std::size_t seed = 0;
+
+        for(; first != last; ++first)
+        {
+            seed ^= hash_detail::call_hash<T>::call(*first)
+                + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        }
+
+        return seed;
+    }
+
+    template <class T>
+    inline void hash_range(std::size_t& seed, T* first, T* last)
+    {
+        for(; first != last; ++first)
+        {
+            seed ^= hash_detail::call_hash<T>::call(*first)
+                + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        }
+    }
+#endif
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+    template< class T, unsigned N >
+    inline std::size_t hash_value(const T (&array)[N])
+    {
+        return hash_range(array, array + N);
+    }
+
+    template< class T, unsigned N >
+    inline std::size_t hash_value(T (&array)[N])
+    {
+        return hash_range(array, array + N);
+    }
+#endif
+
+#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+    template <class Ch, class A>
+    inline std::size_t hash_value(std::basic_string<Ch, std::string_char_traits<Ch>, A> const& v)
+#else
+    template <class Ch, class A>
+    inline std::size_t hash_value(std::basic_string<Ch, std::char_traits<Ch>, A> const& v)
+#endif
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+    namespace hash_detail
+    {
+        template <class T>
+        inline std::size_t float_hash_value(T v)
+        {
+            int exp = 0;
+            errno = 0;
+            v = boost::hash_detail::call_frexp(v, &exp);
+            if(errno) return 0;
+
+            std::size_t seed = 0;
+
+            std::size_t const length
+                = (std::numeric_limits<T>::digits +
+                        std::numeric_limits<int>::digits - 1)
+                / std::numeric_limits<int>::digits;
+
+            for(std::size_t i = 0; i < length; ++i)
+            {
+                v = boost::hash_detail::call_ldexp(v, std::numeric_limits<int>::digits);
+                int const part = static_cast<int>(v);
+                v -= part;
+                boost::hash_combine(seed, part);
+            }
+
+            boost::hash_combine(seed, exp);
+
+            return seed;
+        }
+    }
+
+    inline std::size_t hash_value(float v)
+    {
+        return boost::hash_detail::float_hash_value(v);
+    }
+
+    inline std::size_t hash_value(double v)
+    {
+        return boost::hash_detail::float_hash_value(v);
+    }
+
+    inline std::size_t hash_value(long double v)
+    {
+        return boost::hash_detail::float_hash_value(v);
+    }
+
+    // boost::hash
+
+    template <class T> struct hash
+        : std::unary_function<T, std::size_t>
+    {
+        std::size_t operator()(T const& val) const
+        {
+            return hash_detail::call_hash<T>::call(val);
+        }
+
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1300
+        std::size_t operator()(T& val) const
+        {
+            return hash_detail::call_hash<T>::call(val);
+        }
+#endif        
+    };
+}
+
+#endif
+

include/boost/functional/hash/list.hpp

@@ -0,0 +1,46 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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. 
+
+#if !defined(BOOST_FUNCTIONAL_HASH_LIST_HPP)
+#define BOOST_FUNCTIONAL_HASH_LIST_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <list>
+#include <boost/functional/hash/hash.hpp>
+
+namespace boost
+{
+    template <class T, class A>
+    std::size_t hash_value(std::list<T, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+    namespace hash_detail
+    {
+        template <class T, class A>
+        struct call_hash<std::list<T, A> >
+        {
+            static std::size_t call(std::list<T, A> const& val)
+            {
+                return boost::hash_value(val);
+            }
+        };
+    }
+#endif
+}
+
+#endif
+

include/boost/functional/hash/map.hpp

@@ -0,0 +1,63 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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. 
+
+#if !defined(BOOST_FUNCTIONAL_HASH_MAP_HPP)
+#define BOOST_FUNCTIONAL_HASH_MAP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <map>
+#include <boost/functional/hash/hash.hpp>
+#include <boost/functional/hash/pair.hpp>
+
+namespace boost
+{
+    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());
+    }
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+    namespace hash_detail
+    {
+        template <class K, class T, class C, class A>
+        struct call_hash<std::map<K, T, C, A> >
+        {
+            static std::size_t call(std::map<K, T, C, A> const& val)
+            {
+                return boost::hash_value(val);
+            }
+        };
+
+        template <class K, class T, class C, class A>
+        struct call_hash<std::multimap<K, T, C, A> >
+        {
+            static std::size_t call(std::multimap<K, T, C, A> const& val)
+            {
+                return boost::hash_value(val);
+            }
+        };
+    }
+#endif
+}
+
+#endif
+
+

include/boost/functional/hash/pair.hpp

@@ -0,0 +1,48 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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. 
+
+#if !defined(BOOST_FUNCTIONAL_HASH_PAIR_HPP)
+#define BOOST_FUNCTIONAL_HASH_PAIR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <utility>
+#include <boost/functional/hash/hash.hpp>
+
+namespace boost
+{
+    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;
+    }
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+    namespace hash_detail
+    {
+        template <class A, class B>
+        struct call_hash<std::pair<A, B> >
+        {
+            static std::size_t call(std::pair<A, B> const& val)
+            {
+                return boost::hash_value(val);
+            }
+        };
+    }
+#endif
+}
+
+#endif

include/boost/functional/hash/set.hpp

@@ -0,0 +1,61 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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. 
+
+#if !defined(BOOST_FUNCTIONAL_HASH_SET_HPP)
+#define BOOST_FUNCTIONAL_HASH_SET_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <set>
+#include <boost/functional/hash/hash.hpp>
+
+namespace boost
+{
+    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());
+    }
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+    namespace hash_detail
+    {
+        template <class K, class C, class A>
+        struct call_hash<std::set<K, C, A> >
+        {
+            static std::size_t call(std::set<K, C, A> const& val)
+            {
+                return boost::hash_value(val);
+            }
+        };
+
+        template <class K, class C, class A>
+        struct call_hash<std::multiset<K, C, A> >
+        {
+            static std::size_t call(std::multiset<K, C, A> const& val)
+            {
+                return boost::hash_value(val);
+            }
+        };
+    }
+#endif
+}
+
+#endif
+

include/boost/functional/hash/vector.hpp

@@ -0,0 +1,45 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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. 
+
+#if !defined(BOOST_FUNCTIONAL_HASH_VECTOR_HPP)
+#define BOOST_FUNCTIONAL_HASH_VECTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <vector>
+#include <boost/functional/hash/hash.hpp>
+
+namespace boost
+{
+    template <class T, class A>
+    std::size_t hash_value(std::vector<T, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+    namespace hash_detail
+    {
+        template <class T, class A>
+        struct call_hash<std::vector<T, A> >
+        {
+            static std::size_t call(std::vector<T, A> const& val)
+            {
+                return boost::hash_value(val);
+            }
+        };
+    }
+#endif
+}
+
+#endif

index.html

@@ -0,0 +1,9 @@
+<html>
+<head>
+    <meta http-equiv="refresh" content="0; URL=../../doc/html/hash.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/hash.html">../../doc/html/hash.html</a>
+</body>
+</html>

test/Jamfile

@@ -0,0 +1,50 @@
+
+#  (C) Copyright Daniel James 2005.
+#  Use, modification and distribution are subject to 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)
+
+subproject libs/functional/hash/test ;
+
+import testing ;
+
+DEPENDS all : test ;
+
+rule hash-test ( name )
+{
+    return [
+        run $(name).cpp
+        <lib>../../../test/build/boost_unit_test_framework
+        : : : <include>$(BOOST_ROOT)
+        ] ;
+}
+
+rule hash-test-output ( name )
+{
+    return [
+        run $(name).cpp
+        <lib>../../../test/build/boost_unit_test_framework
+        : : : <include>$(BOOST_ROOT) <test-info>always_show_run_output
+        ] ;
+}
+
+{
+    test-suite functional/hash
+        :
+            [ hash-test hash_number_test ]
+            [ hash-test hash_pointer_test ]
+            [ hash-test hash_function_pointer_test ]
+            [ hash-test-output hash_float_test ]
+            [ hash-test hash_string_test ]
+            [ hash-test hash_range_test ]
+            [ hash-test hash_custom_test ]
+            [ hash-test hash_built_in_array_test ]
+            [ hash-test hash_value_array_test ]
+            [ hash-test hash_vector_test ]
+            [ hash-test hash_list_test ]
+            [ hash-test hash_deque_test ]
+            [ hash-test hash_set_test ]
+            [ hash-test hash_map_test ]
+            [ run link_test.cpp link_test_2.cpp : : : <include>$(BOOST_ROOT) ]
+        ;
+}

test/Jamfile.v2

@@ -0,0 +1,28 @@
+
+#  (C) Copyright Daniel James 2005.
+#  Use, modification and distribution are subject to 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 ;
+
+alias framework : /boost/test//boost_unit_test_framework ;
+
+test-suite functional/hash
+    :
+        [ run hash_number_test.cpp framework ]
+        [ run hash_pointer_test.cpp framework ]
+        [ run hash_function_pointer_test.cpp framework ]
+        [ run hash_float_test.cpp framework : : : <test-info>always_show_run_output ]
+        [ run hash_string_test.cpp framework ]
+        [ run hash_range_test.cpp framework ]
+        [ run hash_custom_test.cpp framework ]
+        [ run hash_built_in_array_test.cpp framework ]
+        [ run hash_value_array_test.cpp framework ]
+        [ run hash_vector_test.cpp framework ]
+        [ run hash_list_test.cpp framework ]
+        [ run hash_deque_test.cpp framework ]
+        [ run hash_set_test.cpp framework ]
+        [ run hash_map_test.cpp framework ]
+        [ run link_test.cpp link_test_2.cpp ]
+    ;

test/compile_time.hpp

@@ -0,0 +1,16 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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/config.hpp>
+#include <boost/static_assert.hpp>
+
+template <class T>
+void compile_time_tests(T*)
+{
+    BOOST_STATIC_ASSERT((boost::is_base_and_derived<
+        std::unary_function<T, std::size_t>, HASH_NAMESPACE::hash<T> >::value));
+};
+

test/config.hpp

@@ -0,0 +1,13 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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)
+
+#if defined(TEST_STD)
+#  define TEST_STD_INCLUDES
+#  define HASH_NAMESPACE std::tr1
+#else
+#  define HASH_NAMESPACE boost
+#  define TEST_EXTENSIONS
+#endif

test/hash_built_in_array_test.cpp

@@ -0,0 +1,69 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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"
+
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
+#    include <functional>
+#  else
+#    include <boost/functional/hash/hash.hpp>
+#  endif
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#ifdef TEST_EXTENSIONS
+
+BOOST_AUTO_UNIT_TEST(array_int_test)
+{
+    const int length1 = 25;
+    int array1[25] = {
+        26, -43, 32, 65, 45,
+        12, 67, 32, 12, 23,
+        0, 0, 0, 0, 0,
+        8, -12, 23, 65, 45,
+        -1, 93, -54, 987, 3
+    };
+    HASH_NAMESPACE::hash<int[25]> hasher1;
+
+    const int length2 = 1;
+    int array2[1] = {3};
+    HASH_NAMESPACE::hash<int[1]> hasher2;
+
+    const int length3 = 2;
+    int array3[2] = {2, 3};
+    HASH_NAMESPACE::hash<int[2]> hasher3;
+
+    BOOST_CHECK(hasher1(array1)
+            == HASH_NAMESPACE::hash_range(array1, array1 + length1));
+    BOOST_CHECK(hasher2(array2)
+            == HASH_NAMESPACE::hash_range(array2, array2 + length2));
+    BOOST_CHECK(hasher3(array3)
+            == HASH_NAMESPACE::hash_range(array3, array3 + length3));
+}
+
+BOOST_AUTO_UNIT_TEST(two_dimensional_array_test)
+{
+    int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}};
+    HASH_NAMESPACE::hash<int[3][2]> hasher;
+
+    std::size_t seed1 = 0;
+    for(int i = 0; i < 3; ++i)
+    {
+        std::size_t seed2 = 0;
+        for(int j = 0; j < 2; ++j)
+            HASH_NAMESPACE::hash_combine(seed2, array[i][j]);
+        HASH_NAMESPACE::hash_combine(seed1, seed2);
+    }
+
+    BOOST_CHECK(hasher(array) == seed1);
+    BOOST_CHECK(hasher(array) == HASH_NAMESPACE::hash_range(array, array + 3));
+}
+
+#endif // TEST_EXTENSIONS
+

test/hash_custom_test.cpp

@@ -0,0 +1,93 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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/config.hpp>
+#include <cstddef>
+
+namespace test
+{
+    struct custom
+    {
+        int value_;
+
+        std::size_t hash() const
+        {
+            return value_ * 10;
+        }
+
+#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+        friend std::size_t hash_value(custom const& x )
+        {
+            return x.hash();
+        }
+#endif
+
+        custom(int x) : value_(x) {}
+    };
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace boost
+{
+    std::size_t hash_value(test::custom x)
+    {
+        return x.hash();
+    }
+}
+#endif
+
+#include "./config.hpp"
+
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
+#    include <functional>
+#  else
+#    include <boost/functional/hash/hash.hpp>
+#  endif
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#ifdef TEST_EXTENSIONS
+
+#include <vector>
+#include <string>
+#include <cctype>
+
+BOOST_AUTO_UNIT_TEST(custom_tests)
+{
+    HASH_NAMESPACE::hash<test::custom> custom_hasher;
+    BOOST_CHECK(custom_hasher(10) == 100u);
+    test::custom x(55);
+    BOOST_CHECK(custom_hasher(x) == 550u);
+
+    {
+        using namespace HASH_NAMESPACE;
+        BOOST_CHECK(custom_hasher(x) == hash_value(x));
+    }
+
+    std::vector<test::custom> custom_vector;
+    custom_vector.push_back(5);
+    custom_vector.push_back(25);
+    custom_vector.push_back(35);
+
+    std::size_t seed = 0;
+    HASH_NAMESPACE::hash_combine(seed, test::custom(5));
+    HASH_NAMESPACE::hash_combine(seed, test::custom(25));
+    HASH_NAMESPACE::hash_combine(seed, test::custom(35));
+
+    std::size_t seed2 = 0;
+    HASH_NAMESPACE::hash_combine(seed2, 50u);
+    HASH_NAMESPACE::hash_combine(seed2, 250u);
+    HASH_NAMESPACE::hash_combine(seed2, 350u);
+
+    BOOST_CHECK(seed ==
+            HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
+    BOOST_CHECK(seed == seed2);
+}
+
+#endif // TEST_EXTENSIONS

test/hash_deque_test.cpp

@@ -0,0 +1,28 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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"
+
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
+#    include <functional>
+#  else
+#    include <boost/functional/hash/deque.hpp>
+#  endif
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#ifdef TEST_EXTENSIONS
+
+#include <deque>
+
+using std::deque;
+#define CONTAINER_TYPE deque
+#include "./hash_sequence_test.hpp"
+
+#endif // TEST_EXTENSIONS

test/hash_float_test.cpp

@@ -0,0 +1,178 @@
+
+//  Copyright Daniel James 2005. Use, modification, and distribution are
+//  subject to 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"
+
+#ifdef TEST_STD_INCLUDES
+#  include <functional>
+#else
+#  include <boost/functional/hash/hash.hpp>
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#include <cmath>
+#include <boost/limits.hpp>
+
+#include <iostream>
+
+template <class T>
+void float_tests(char const* name, T* = 0)
+{
+    std::cout<<"\n"
+        "Testing " BOOST_STRINGIZE(HASH_NAMESPACE) "::hash<"<<name<<">\n"
+        "\n";
+
+    HASH_NAMESPACE::hash<T> x1;
+
+    T zero = 0;
+    T minus_zero = (T) -1 * zero;
+
+    BOOST_CHECK(zero == minus_zero);
+    BOOST_CHECK(x1(zero) == x1(minus_zero));
+
+    BOOST_CHECK(x1(zero) == HASH_NAMESPACE::hash_value(zero));
+    BOOST_CHECK(x1(minus_zero) == HASH_NAMESPACE::hash_value(minus_zero));
+
+    using namespace std;
+
+// Doing anything with infinity causes borland to crash.
+#if defined(__BORLANDC__)
+    std::cout<<"Not running infinity checks on Borland, as it causes it to crash.\n";
+#else
+    if(std::numeric_limits<T>::has_infinity) {
+        T infinity = -log(zero);
+        T infinity2 = (T) 1. / zero;
+        T infinity3 = (T) -1. / minus_zero;
+        T infinity4 = std::numeric_limits<T>::infinity();
+
+        T minus_infinity = log(zero);
+        T minus_infinity2 = (T) -1. / zero;
+        T minus_infinity3 = (T) 1. / minus_zero;
+
+        BOOST_CHECK(x1(infinity) == HASH_NAMESPACE::hash_value(infinity));
+        BOOST_CHECK(x1(minus_infinity)
+                == HASH_NAMESPACE::hash_value(minus_infinity));
+
+        BOOST_CHECK(infinity == infinity2);
+        BOOST_CHECK(infinity == infinity3);
+        BOOST_CHECK(infinity == infinity4);
+        BOOST_CHECK(x1(infinity) == x1(infinity2));
+        BOOST_CHECK(x1(infinity) == x1(infinity3));
+        BOOST_CHECK(x1(infinity) == x1(infinity4));
+
+        BOOST_CHECK(minus_infinity == minus_infinity2);
+        BOOST_CHECK(x1(minus_infinity) == x1(minus_infinity2));
+        BOOST_CHECK(minus_infinity == minus_infinity3);
+        BOOST_CHECK(x1(minus_infinity) == x1(minus_infinity3));
+
+        BOOST_CHECK(infinity != minus_infinity);
+
+        // My hash fails this one, I guess it's not that bad.
+        if(x1(infinity) == x1(minus_infinity)) {
+            std::cout<<"x1(infinity) == x1(-infinity) == "<<x1(infinity)<<"\n";
+        }
+
+        // This should really be 'has_denorm == denorm_present' but some
+        // compilers don't have 'denorm_present'. See also a later use.
+        if(std::numeric_limits<T>::has_denorm) {
+            if(x1(std::numeric_limits<T>::denorm_min()) == x1(infinity)) {
+                std::cout<<"x1(denorm_min) == x1(infinity) == "<<x1(infinity)<<"\n";
+            }
+            if(x1(std::numeric_limits<T>::denorm_min()) == x1(minus_infinity)) {
+                std::cout<<"x1(denorm_min) == x1(-infinity) == "<<x1(minus_infinity)<<"\n";
+            }
+        }
+
+        if(std::numeric_limits<T>::has_quiet_NaN) {
+            if(x1(std::numeric_limits<T>::quiet_NaN()) == x1(infinity)) {
+                std::cout<<"x1(quiet_NaN) == x1(infinity) == "<<x1(infinity)<<"\n";
+            }
+            if(x1(std::numeric_limits<T>::quiet_NaN()) == x1(minus_infinity)) {
+                std::cout<<"x1(quiet_NaN) == x1(-infinity) == "<<x1(minus_infinity)<<"\n";
+            }
+        }
+    }
+#endif
+
+    T max = (std::numeric_limits<T>::max)();
+    T half_max = max / 2;
+    T quarter_max = max / 4;
+    T three_quarter_max = max - quarter_max;
+
+    BOOST_CHECK(x1(max) == HASH_NAMESPACE::hash_value(max));
+    BOOST_CHECK(x1(half_max) == HASH_NAMESPACE::hash_value(half_max));
+    BOOST_CHECK(x1(quarter_max) == HASH_NAMESPACE::hash_value(quarter_max));
+    BOOST_CHECK(x1(three_quarter_max) == HASH_NAMESPACE::hash_value(three_quarter_max));
+
+    // The '!=' tests could legitimately fail, but with my hash it indicates a bug.
+    BOOST_CHECK(x1(max) == x1(max));
+    BOOST_CHECK(x1(max) != x1(quarter_max));
+    BOOST_CHECK(x1(max) != x1(half_max));
+    BOOST_CHECK(x1(max) != x1(three_quarter_max));
+    BOOST_CHECK(x1(quarter_max) == x1(quarter_max));
+    BOOST_CHECK(x1(quarter_max) != x1(half_max));
+    BOOST_CHECK(x1(quarter_max) != x1(three_quarter_max));
+    BOOST_CHECK(x1(half_max) == x1(half_max));
+    BOOST_CHECK(x1(half_max) != x1(three_quarter_max));
+    BOOST_CHECK(x1(three_quarter_max) == x1(three_quarter_max));
+
+    T v1 = asin((T) 1);
+    T v2 = acos((T) 0);
+    if(v1 == v2)
+        BOOST_CHECK(x1(v1) == x1(v2));
+    BOOST_CHECK(x1(v1) == HASH_NAMESPACE::hash_value(v1));
+    BOOST_CHECK(x1(v2) == HASH_NAMESPACE::hash_value(v2));
+
+    BOOST_CHECK(x1(std::numeric_limits<T>::epsilon()) != x1((T) 0));
+    BOOST_CHECK(x1(std::numeric_limits<T>::epsilon()) ==
+            HASH_NAMESPACE::hash_value(std::numeric_limits<T>::epsilon()));
+
+    // As before.
+    if(std::numeric_limits<T>::has_denorm) {
+        if(x1(std::numeric_limits<T>::denorm_min()) == x1(zero)) {
+            std::cout<<"x1(denorm_min) == x1(zero) == "<<x1(zero)<<"\n";
+        }
+        BOOST_CHECK_MESSAGE(x1(std::numeric_limits<T>::denorm_min()) ==
+            HASH_NAMESPACE::hash_value(std::numeric_limits<T>::denorm_min()),
+            "x1(std::numeric_limits<T>::denorm_min()) = "
+                << x1(std::numeric_limits<T>::denorm_min())
+                << "\nhash_value(std::numeric_limits<T>::denorm_min()) = "
+                << HASH_NAMESPACE::hash_value(
+                    std::numeric_limits<T>::denorm_min())
+                << "\nx1(0) = "<<x1(0)<<"\n");
+    }
+
+// NaN also causes borland to crash.
+#if !defined(__BORLANDC__)
+    if(std::numeric_limits<T>::has_quiet_NaN) {
+        if(x1(std::numeric_limits<T>::quiet_NaN()) == x1(1.0)) {
+            std::cout<<"x1(quiet_NaN) == x1(1.0) == "<<x1(1.0)<<"\n";
+        }
+        BOOST_CHECK(x1(std::numeric_limits<T>::quiet_NaN()) ==
+            HASH_NAMESPACE::hash_value(std::numeric_limits<T>::quiet_NaN()));
+    }
+#endif
+}
+
+BOOST_AUTO_UNIT_TEST(hash_float_tests)
+{
+    std::cout<<"Compiler: "<<BOOST_COMPILER<<"\n";
+    std::cout<<"Platform: "<<BOOST_PLATFORM<<"\n";
+    std::cout<<"Library: "<<BOOST_STDLIB<<"\n\n";
+
+    float_tests("float", (float*) 0);
+}
+
+BOOST_AUTO_UNIT_TEST(hash_double_tests)
+{
+    float_tests("double", (double*) 0);
+}
+
+BOOST_AUTO_UNIT_TEST(hash_long_double_tests)
+{
+    float_tests("long double", (long double*) 0);
+}

test/hash_function_pointer_test.cpp

@@ -0,0 +1,57 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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"
+
+#ifdef TEST_STD_INCLUDES
+#  include <functional>
+#else
+#  include <boost/functional/hash/hash.hpp>
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#include <boost/limits.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include "./compile_time.hpp"
+
+void void_func1() { static int x = 1; ++x; }
+void void_func2() { static int x = 2; --x; }
+int int_func1(int) { return 0; }
+int int_func2(int) { return 1; }
+
+BOOST_AUTO_UNIT_TEST(function_pointer_tests)
+{
+    compile_time_tests((void(**)()) 0);
+    compile_time_tests((int(**)(int)) 0);
+
+    HASH_NAMESPACE::hash<void(*)()> hasher_void;
+    HASH_NAMESPACE::hash<int(*)(int)> hasher_int;
+
+    BOOST_CHECK(&void_func1 != &void_func2);
+    BOOST_CHECK(&int_func1 != &int_func2);
+
+    BOOST_CHECK(hasher_void(0) == hasher_void(0));
+    BOOST_CHECK(hasher_void(&void_func1) == hasher_void(&void_func1));
+    BOOST_CHECK(hasher_void(&void_func1) != hasher_void(&void_func2));
+    BOOST_CHECK(hasher_void(&void_func1) != hasher_void(0));
+    BOOST_CHECK(hasher_int(0) == hasher_int(0));
+    BOOST_CHECK(hasher_int(&int_func1) == hasher_int(&int_func1));
+    BOOST_CHECK(hasher_int(&int_func1) != hasher_int(&int_func2));
+    BOOST_CHECK(hasher_int(&int_func1) != hasher_int(0));
+#if defined(TEST_EXTENSIONS)
+    BOOST_CHECK(hasher_void(&void_func1)
+            == HASH_NAMESPACE::hash_value(&void_func1));
+    BOOST_CHECK(hasher_int(&int_func1)
+            == HASH_NAMESPACE::hash_value(&int_func1));
+
+    // This isn't specified in Peter's proposal:
+    BOOST_CHECK(hasher_void(0) == 0);
+#endif
+}

test/hash_list_test.cpp

@@ -0,0 +1,28 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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"
+
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
+#    include <functional>
+#  else
+#    include <boost/functional/hash/list.hpp>
+#  endif
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#ifdef TEST_EXTENSIONS
+
+#include <list>
+
+using std::list;
+#define CONTAINER_TYPE list
+#include "./hash_sequence_test.hpp"
+
+#endif // TEST_EXTENSIONS

test/hash_map_test.cpp

@@ -0,0 +1,32 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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"
+
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
+#    include <functional>
+#  else
+#    include <boost/functional/hash/map.hpp>
+#  endif
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#include <map>
+
+#ifdef TEST_EXTENSIONS
+
+using std::map;
+#define CONTAINER_TYPE map
+#include "./hash_map_test.hpp"
+
+using std::multimap;
+#define CONTAINER_TYPE multimap
+#include "./hash_map_test.hpp"
+
+#endif // TEST_EXTENSTIONS

test/hash_map_test.hpp

@@ -0,0 +1,65 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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)
+
+#if !defined(CONTAINER_TYPE)
+#error "CONTAINER_TYPE not defined"
+#else
+
+#include <boost/preprocessor/cat.hpp>
+
+namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
+{
+    template <class T>
+    void integer_tests(T* = 0)
+    {
+        const int number_of_containers = 10;
+        T containers[number_of_containers];
+        typedef typename T::value_type pair;
+
+        for(int i = 0; i < 5; ++i) {
+            for(int j = 0; j < i; ++j)
+                containers[i].insert(pair(0, 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));
+
+        HASH_NAMESPACE::hash<T> hasher;
+
+        for(int i2 = 0; i2 < number_of_containers; ++i2) {
+            BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
+
+            BOOST_CHECK(hasher(containers[i2]) ==
+                    HASH_NAMESPACE::hash_value(containers[i2]));
+
+            BOOST_CHECK(hasher(containers[i2])
+                    == HASH_NAMESPACE::hash_range(
+                        containers[i2].begin(), containers[i2].end()));
+
+            for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
+                BOOST_CHECK(
+                        (containers[i2] == containers[j2]) ==
+                        (hasher(containers[i2]) == hasher(containers[j2]))
+                        );
+            }
+        }
+    }
+
+    BOOST_AUTO_UNIT_TEST(BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests))
+    {
+        integer_tests((CONTAINER_TYPE<char, unsigned char>*) 0);
+        integer_tests((CONTAINER_TYPE<int, float>*) 0);
+        integer_tests((CONTAINER_TYPE<unsigned long, unsigned long>*) 0);
+        integer_tests((CONTAINER_TYPE<double, short>*) 0);
+    }
+}
+
+#undef CONTAINER_TYPE
+#endif

test/hash_number_test.cpp

@@ -0,0 +1,131 @@
+
+//  Copyright Daniel James 2005. Use, modification, and distribution are
+//  subject to 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"
+
+#ifdef TEST_STD_INCLUDES
+#  include <functional>
+#else
+#  include <boost/functional/hash/hash.hpp>
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/limits.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include "./compile_time.hpp"
+
+template <class T>
+void numeric_test(T*)
+{
+    typedef std::numeric_limits<T> limits;
+
+    compile_time_tests((T*) 0);
+
+    HASH_NAMESPACE::hash<T> x1;
+    HASH_NAMESPACE::hash<T> x2;
+
+    T v1 = -5;
+    BOOST_CHECK(x1(v1) == x2(v1));
+    BOOST_CHECK(x1(T(-5)) == x2(T(-5)));
+    BOOST_CHECK(x1(T(0)) == x2(T(0)));
+    BOOST_CHECK(x1(T(10)) == x2(T(10)));
+    BOOST_CHECK(x1(T(25)) == x2(T(25)));
+    BOOST_CHECK(x1(T(5) - T(5)) == x2(T(0)));
+    BOOST_CHECK(x1(T(6) + T(4)) == x2(T(10)));
+
+#if defined(TEST_EXTENSIONS)
+    BOOST_CHECK(x1(T(-5)) == HASH_NAMESPACE::hash_value(T(-5)));
+    BOOST_CHECK(x1(T(0)) == HASH_NAMESPACE::hash_value(T(0)));
+    BOOST_CHECK(x1(T(10)) == HASH_NAMESPACE::hash_value(T(10)));
+    BOOST_CHECK(x1(T(25)) == HASH_NAMESPACE::hash_value(T(25)));
+
+    if (limits::is_integer)
+    {
+        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5));
+        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u));
+        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u));
+        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u));
+    }
+#endif
+}
+
+template <class T>
+void limits_test(T*)
+{
+    typedef std::numeric_limits<T> limits;
+
+    if(limits::is_specialized)
+    {
+        HASH_NAMESPACE::hash<T> x1;
+        HASH_NAMESPACE::hash<T> x2;
+
+        T min_value = (limits::min)();
+        T max_value = (limits::max)();
+
+        BOOST_CHECK(x1(min_value) == x2((limits::min)()));
+        BOOST_CHECK(x1(max_value) == x2((limits::max)()));
+
+#if defined(TEST_EXTENSIONS)
+        BOOST_CHECK(x1(min_value) == HASH_NAMESPACE::hash_value(min_value));
+        BOOST_CHECK(x1(max_value) == HASH_NAMESPACE::hash_value(max_value));
+
+        if (limits::is_integer)
+        {
+            BOOST_CHECK(HASH_NAMESPACE::hash_value(min_value)
+                    == std::size_t(min_value));
+            BOOST_CHECK(HASH_NAMESPACE::hash_value(max_value)
+                    == std::size_t(max_value));
+        }
+#endif
+    }
+}
+
+template <class T>
+void poor_quality_tests(T*)
+{
+    typedef std::numeric_limits<T> limits;
+
+    HASH_NAMESPACE::hash<T> x1;
+    HASH_NAMESPACE::hash<T> x2;
+
+    // A hash function can legally fail these tests, but it'll not be a good
+    // sign.
+    if(T(1) != T(-1))
+        BOOST_CHECK(x1(T(1)) !=  x2(T(-1)));
+    if(T(1) != T(2))
+        BOOST_CHECK(x1(T(1)) !=  x2(T(2)));
+    if((limits::max)() != (limits::max)() - 1)
+        BOOST_CHECK(x1((limits::max)()) != x2((limits::max)() - 1));
+}
+
+#define NUMERIC_TEST(type, name) \
+    BOOST_AUTO_UNIT_TEST(BOOST_PP_CAT(test_, name)) { \
+        numeric_test((type*) 0); \
+        limits_test((type*) 0); \
+        poor_quality_tests((type*) 0); \
+    }
+
+NUMERIC_TEST(bool, bool)
+NUMERIC_TEST(char, char)
+NUMERIC_TEST(signed char, schar)
+NUMERIC_TEST(unsigned char, uchar)
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+NUMERIC_TEST(wchar_t, wchar)
+#endif
+NUMERIC_TEST(short, short)
+NUMERIC_TEST(unsigned short, ushort)
+NUMERIC_TEST(int, int)
+NUMERIC_TEST(unsigned int, uint)
+NUMERIC_TEST(long, hash_long)
+NUMERIC_TEST(unsigned long, ulong)
+
+NUMERIC_TEST(float, float)
+NUMERIC_TEST(double, double)
+NUMERIC_TEST(long double, ldouble)

test/hash_pointer_test.cpp

@@ -0,0 +1,45 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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"
+
+#ifdef TEST_STD_INCLUDES
+#  include <functional>
+#else
+#  include <boost/functional/hash/hash.hpp>
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#include <boost/limits.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include "./compile_time.hpp"
+
+BOOST_AUTO_UNIT_TEST(pointer_tests)
+{
+    compile_time_tests((int**) 0);
+    compile_time_tests((void**) 0);
+
+    HASH_NAMESPACE::hash<int*> x1;
+    HASH_NAMESPACE::hash<int*> x2;
+
+    int int1;
+    int int2;
+
+    BOOST_CHECK(x1(0) == x2(0));
+    BOOST_CHECK(x1(&int1) == x2(&int1));
+    BOOST_CHECK(x1(&int2) == x2(&int2));
+#if defined(TEST_EXTENSIONS)
+    BOOST_CHECK(x1(&int1) == HASH_NAMESPACE::hash_value(&int1));
+    BOOST_CHECK(x1(&int2) == HASH_NAMESPACE::hash_value(&int2));
+
+    // This isn't specified in Peter's proposal:
+    BOOST_CHECK(x1(0) == 0);
+#endif
+}

test/hash_range_test.cpp

@@ -0,0 +1,77 @@
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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"
+
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
+#    include <functional>
+#  else
+#    include <boost/functional/hash/hash.hpp>
+#  endif
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#ifdef TEST_EXTENSIONS
+
+#include <boost/limits.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+BOOST_AUTO_UNIT_TEST(hash_range_tests)
+{
+    std::vector<int> empty, values1, values2, values3, values4, values5;
+    values1.push_back(0);
+    values2.push_back(10);
+    values3.push_back(10);
+    values3.push_back(20);
+    values4.push_back(15);
+    values4.push_back(75);
+    values5.push_back(10);
+    values5.push_back(20);
+    values5.push_back(15);
+    values5.push_back(75);
+    values5.push_back(10);
+    values5.push_back(20);
+
+    std::vector<int> x;
+
+    std::size_t x_seed = 0;
+    BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+
+    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+        == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+        != HASH_NAMESPACE::hash_range(values1.begin(), values1.end()));
+
+    x.push_back(10);
+    HASH_NAMESPACE::hash_combine(x_seed, 10);
+    BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+
+    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+        != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_CHECK(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
+        == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+
+    x.push_back(20);
+    HASH_NAMESPACE::hash_combine(x_seed, 20);
+    BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+
+    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+        != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_CHECK(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
+        != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_CHECK(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());
+    HASH_NAMESPACE::hash_range(seed, values4.begin(), values4.end());
+    HASH_NAMESPACE::hash_range(seed, x.begin(), x.end());
+    BOOST_CHECK(seed == HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
+}
+
+#endif

test/hash_sequence_test.hpp

@@ -0,0 +1,68 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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)
+
+#if !defined(CONTAINER_TYPE)
+#error "CONTAINER_TYPE not defined"
+#else
+
+#include <boost/preprocessor/cat.hpp>
+
+namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
+{
+    template <class T>
+    void integer_tests(T* = 0)
+    {
+        const int number_of_containers = 11;
+        T containers[number_of_containers];
+
+        for(int i = 0; i < 5; ++i) {
+            for(int j = 0; j < i; ++j)
+                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);
+
+        HASH_NAMESPACE::hash<T> hasher;
+
+        for(int i2 = 0; i2 < number_of_containers; ++i2) {
+            BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
+
+            BOOST_CHECK(hasher(containers[i2]) ==
+                    HASH_NAMESPACE::hash_value(containers[i2]));
+
+            BOOST_CHECK(hasher(containers[i2])
+                    == HASH_NAMESPACE::hash_range(
+                        containers[i2].begin(), containers[i2].end()));
+
+            for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
+                BOOST_CHECK(
+                        (containers[i2] == containers[j2]) ==
+                        (hasher(containers[i2]) == hasher(containers[j2]))
+                        );
+            }
+        }
+    }
+
+    BOOST_AUTO_UNIT_TEST(BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests))
+    {
+        integer_tests((CONTAINER_TYPE<char>*) 0);
+        integer_tests((CONTAINER_TYPE<int>*) 0);
+        integer_tests((CONTAINER_TYPE<unsigned long>*) 0);
+        integer_tests((CONTAINER_TYPE<double>*) 0);
+    }
+}
+
+#undef CONTAINER_TYPE
+#endif

test/hash_set_test.cpp

@@ -0,0 +1,32 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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"
+
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
+#    include <functional>
+#  else
+#    include <boost/functional/hash/set.hpp>
+#  endif
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#ifdef TEST_EXTENSIONS
+
+#include <set>
+
+using std::set;
+#define CONTAINER_TYPE set
+#include "./hash_set_test.hpp"
+
+using std::multiset;
+#define CONTAINER_TYPE multiset
+#include "./hash_set_test.hpp"
+
+#endif

test/hash_set_test.hpp

@@ -0,0 +1,66 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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)
+
+#if !defined(CONTAINER_TYPE)
+#error "CONTAINER_TYPE not defined"
+#else
+
+#include <boost/preprocessor/cat.hpp>
+
+namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
+{
+    template <class T>
+    void integer_tests(T* = 0)
+    {
+        const int number_of_containers = 11;
+        T containers[number_of_containers];
+
+        for(int i = 0; i < 5; ++i) {
+            for(int j = 0; j < i; ++j)
+                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);
+
+        HASH_NAMESPACE::hash<T> hasher;
+
+        for(int i2 = 0; i2 < number_of_containers; ++i2) {
+            BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
+
+            BOOST_CHECK(hasher(containers[i2]) ==
+                    HASH_NAMESPACE::hash_value(containers[i2]));
+
+            BOOST_CHECK(hasher(containers[i2])
+                    == HASH_NAMESPACE::hash_range(
+                        containers[i2].begin(), containers[i2].end()));
+
+            for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
+                BOOST_CHECK(
+                        (containers[i2] == containers[j2]) ==
+                        (hasher(containers[i2]) == hasher(containers[j2]))
+                        );
+            }
+        }
+    }
+
+    BOOST_AUTO_UNIT_TEST(BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests))
+    {
+        integer_tests((CONTAINER_TYPE<char>*) 0);
+        integer_tests((CONTAINER_TYPE<int>*) 0);
+        integer_tests((CONTAINER_TYPE<unsigned long>*) 0);
+        integer_tests((CONTAINER_TYPE<double>*) 0);
+    }
+}
+
+#undef CONTAINER_TYPE
+#endif

test/hash_string_test.cpp

@@ -0,0 +1,69 @@
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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"
+
+#ifdef TEST_STD_INCLUDES
+#  include <functional>
+#else
+#  include <boost/functional/hash/hash.hpp>
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#include <boost/limits.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include "./compile_time.hpp"
+
+BOOST_AUTO_UNIT_TEST(string_tests)
+{
+    compile_time_tests((std::string*) 0);
+
+    HASH_NAMESPACE::hash<std::string> x1;
+    HASH_NAMESPACE::hash<std::string> x2;
+
+    BOOST_CHECK(x1("Hello") == x2(std::string("Hel") + "lo"));
+    BOOST_CHECK(x1("") == x2(std::string()));
+
+#if defined(TEST_EXTENSIONS)
+    std::string value1;
+    std::string value2("Hello");
+
+    BOOST_CHECK(x1(value1) == HASH_NAMESPACE::hash_value(value1));
+    BOOST_CHECK(x1(value2) == HASH_NAMESPACE::hash_value(value2));
+    BOOST_CHECK(HASH_NAMESPACE::hash_value(value1) ==
+            HASH_NAMESPACE::hash_range(value1.begin(), value1.end()));
+    BOOST_CHECK(HASH_NAMESPACE::hash_value(value2) ==
+            HASH_NAMESPACE::hash_range(value2.begin(), value2.end()));
+#endif
+}
+
+#if !defined(BOOST_NO_STD_WSTRING)
+BOOST_AUTO_UNIT_TEST(wstring_tests)
+{
+    compile_time_tests((std::wstring*) 0);
+
+    HASH_NAMESPACE::hash<std::wstring> x1;
+    HASH_NAMESPACE::hash<std::wstring> x2;
+
+    BOOST_CHECK(x1(L"Hello") == x2(std::wstring(L"Hel") + L"lo"));
+    BOOST_CHECK(x1(L"") == x2(std::wstring()));
+
+#if defined(TEST_EXTENSIONS)
+    std::wstring value1;
+    std::wstring value2(L"Hello");
+
+    BOOST_CHECK(x1(value1) == HASH_NAMESPACE::hash_value(value1));
+    BOOST_CHECK(x1(value2) == HASH_NAMESPACE::hash_value(value2));
+    BOOST_CHECK(HASH_NAMESPACE::hash_value(value1) ==
+            HASH_NAMESPACE::hash_range(value1.begin(), value1.end()));
+    BOOST_CHECK(HASH_NAMESPACE::hash_value(value2) ==
+            HASH_NAMESPACE::hash_range(value2.begin(), value2.end()));
+#endif
+}
+#endif

test/hash_value_array_test.cpp

@@ -0,0 +1,55 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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 compilers hash_value isn't available for arrays, so I test it
+// separately from the main array tests.
+
+#include "./config.hpp"
+
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
+#    include <functional>
+#  else
+#    include <boost/functional/hash/hash.hpp>
+#  endif
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#ifdef TEST_EXTENSIONS
+
+BOOST_AUTO_UNIT_TEST(array_int_test)
+{
+    const int array1[25] = {
+        26, -43, 32, 65, 45,
+        12, 67, 32, 12, 23,
+        0, 0, 0, 0, 0,
+        8, -12, 23, 65, 45,
+        -1, 93, -54, 987, 3
+    };
+    HASH_NAMESPACE::hash<int[25]> hasher1;
+
+    int array2[1] = {3};
+    HASH_NAMESPACE::hash<int[1]> hasher2;
+
+    int array3[2] = {2, 3};
+    HASH_NAMESPACE::hash<int[2]> hasher3;
+
+    BOOST_CHECK(hasher1(array1) == HASH_NAMESPACE::hash_value(array1));
+    BOOST_CHECK(hasher2(array2) == HASH_NAMESPACE::hash_value(array2));
+    BOOST_CHECK(hasher3(array3) == HASH_NAMESPACE::hash_value(array3));
+}
+
+BOOST_AUTO_UNIT_TEST(two_dimensional_array_test)
+{
+    int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}};
+    HASH_NAMESPACE::hash<int[3][2]> hasher;
+
+    BOOST_CHECK(hasher(array) == HASH_NAMESPACE::hash_value(array));
+}
+
+#endif

test/hash_vector_test.cpp

@@ -0,0 +1,28 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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"
+
+#ifdef TEST_EXTENSIONS
+#  ifdef TEST_STD_INCLUDES
+#    include <functional>
+#  else
+#    include <boost/functional/hash/vector.hpp>
+#  endif
+#endif
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#ifdef TEST_EXTENSIONS
+
+#include <vector>
+
+using std::vector;
+#define CONTAINER_TYPE vector
+#include "./hash_sequence_test.hpp"
+
+#endif // TEST_EXTENSIONS

test/link_test.cpp

@@ -0,0 +1,18 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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/pair.hpp>
+#include <boost/functional/hash/vector.hpp>
+#include <boost/functional/hash/list.hpp>
+#include <boost/functional/hash/deque.hpp>
+#include <boost/functional/hash/set.hpp>
+#include <boost/functional/hash/map.hpp>
+#include <boost/functional/hash/hash.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/functional/hash.hpp>
+
+extern int f();
+int main() { return f(); }

test/link_test_2.cpp

@@ -0,0 +1,9 @@
+
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to 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.hpp>
+
+int f() { return 0; }