Merge new changes to unordered & hash.

- Unordered tests can run lightweight test or Boost.Test (at least
   theoretically).
 - Workaround Open BSD's incorrect numeric_limits.
 - Move the hash extensions in their own file.
 - Various small improvements to the unordered docs.
 - Fix some unordered examples.

Merged revisions 43117-43837 via svnmerge from 
https://svn.boost.org/svn/boost/branches/unordered/trunk


[SVN r43838]

doc/Jamfile.v2

@@ -12,4 +12,15 @@ boostbook standalone : unordered :
     <xsl:param>chunk.section.depth=2
     <xsl:param>generate.section.toc.level=2
     <xsl:param>toc.section.depth=1
-    <xsl:param>toc.max.depth=1 ;
+    <xsl:param>toc.max.depth=1
+
+    <dependency>css
+    <dependency>images
+    ;
+
+install css : [ glob $(BOOST_ROOT)/doc/src/*.css ]
+    : <location>html ;
+install images : [ glob $(BOOST_ROOT)/doc/src/images/*.png ]
+    : <location>html/images ;
+explicit css ;
+explicit images ;

doc/comparison.qbk

@@ -83,7 +83,7 @@
     ]
     [
         [`erase` never throws an exception]
-        [The containers hash or predicate function can throw exceptions
+        [The containers' hash or predicate function can throw exceptions
             from `erase`]
     ]
 ]

doc/hash_equality.qbk

@@ -6,32 +6,35 @@
 
 While the associative containers use an ordering relation to specify how the
 elements are stored, the unordered associative containers use an equality
-predicate and a hash function. For example, [classref boost::unordered_set]
+predicate and a hash function. For example, [classref boost::unordered_map]
 is declared as:
 
-    template<typename Value,
-           typename Hash = ``[classref boost::hash]``<Value>, 
-           typename Pred = std::equal_to<Value>, 
-           typename Alloc = std::allocator<Value> > 
-    class ``[classref boost::unordered_set unordered_set]``;
+        template <
+            class Key, class Mapped,
+            class Hash = ``[classref boost::hash]``<Key>,
+            class Pred = std::equal_to<Key>,
+            class Alloc = std::allocator<Key> >
+        class ``[classref boost::unordered_map unordered_map]``;
 
 The hash function comes first as you might want to change the hash function
-but not the equality predicate, while if you were to change the behavior
-of the equality predicate you would have to change the hash function to match
-it.  So, if you wanted to use the
+but not the equality predicate. For example, if you wanted to use the
 [@http://www.isthe.com/chongo/tech/comp/fnv/ FNV-1 hash] you could write:
 
-    ``[classref boost::unordered_set]``<std::string, hash::fnv_1> words;
+[import src_code/dictionary.cpp]
+[case_sensitive_dictionary_fnv]
 
 An example implementation of FNV-1, and some other hash functions are supplied
 in the examples directory.
 
-Alternatively, you might wish to use a different equality function. If you do
-this you will need to use a hash function that matches it. So to implement a
-case-insensitive dictionary:
+If you wish to use a different equality function,
+you will also need to use a matching hash function. For
+example, to implement a case insensitive dictionary you need to define a
+case insensitive equality predicate and hash function:
 
-[import src_code/insensitive.cpp]
 [case_insensitive_functions]
+
+Which you can then use in a case insensitive dictionary:
+
 [case_insensitive_dictionary]
 
 This is a simplified version of the example at
@@ -45,8 +48,9 @@ Similarly, a custom hash function can be used for custom types:
 [import src_code/point1.cpp]
 [point_example1]
 
-Although, [link hash.custom extending boost::hash to support the type] is
-probably a better solution:
+Since the default hash function is [link hash Boost.Hash],
+we can [link hash.custom extend it to support the type]
+so that the hash function doesn't need to be explicitly given:
 
 [import src_code/point2.cpp]
 [point_example2]

doc/intro.qbk

@@ -84,32 +84,18 @@ When using Boost.TR1, these classes are included from `<unordered_set>` and
 The containers are used in a similar manner to the normal associative
 containers:
 
-    #include <``[headerref boost/unordered_map.hpp]``>
-    #include <cassert>
-
-    int main()
-    {
-        boost::unordered_map<std::string, int> x;
-        x["one"] = 1;
-        x["two"] = 2;
-        x["three"] = 3;
-
-        assert(x["one"] == 1);
-        assert(x["missing"] == 0);
-    }
+[import src_code/intro.cpp]
+[intro_example1_2]
 
 But since the elements aren't ordered, the output of:
 
-    BOOST_FOREACH(map::value_type i, x) {
-        std::cout<<i.first<<","<<i.second<<"\n";
-    }
+[intro_example1_3]
 
 can be in any order. For example, it might be:
 
     two,2
     one,1
     three,3
-    missing,0
 
 To store an object in an unordered associative container requires both an
 key equality function and a hash function. The default function objects in

doc/rationale.qbk

@@ -10,7 +10,7 @@
     N2345, 'Placement Insert for Containers']]
 [def __n2369__
     [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2369.pdf
-    the August 2008 version of the working draft standard]]
+    the August 2007 version of the working draft standard]]
 
 [section:rationale Implementation Rationale]
 

doc/src_code/dictionary.cpp

@@ -6,6 +6,7 @@
 #include <boost/unordered_map.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/algorithm/string/predicate.hpp>
+#include "../../examples/hash_functions/fnv-1.hpp"
 
 //[case_insensitive_functions
     struct iequal_to
@@ -35,45 +36,68 @@
             return seed;
         }
     };
-
-    struct word_info;
 //]
 
-    struct word_info {
-        int tag;
-        explicit word_info(int t = 0) : tag(t) {}
-    };
-
 int main() {
+//[case_sensitive_dictionary_fnv
+    boost::unordered_map<std::string, int, hash::fnv_1>
+        dictionary;
+//]
+
+    BOOST_TEST(dictionary.empty());
+
+    dictionary["one"] = 1;
+    BOOST_TEST(dictionary.size() == 1);
+    BOOST_TEST(dictionary.find("ONE") == dictionary.end());
+
+    dictionary.insert(std::make_pair("ONE", 2));
+    BOOST_TEST(dictionary.size() == 2);
+    BOOST_TEST(dictionary.find("ONE") != dictionary.end() &&
+            dictionary.find("ONE")->first == "ONE" &&
+            dictionary.find("ONE")->second == 2);
+
+    dictionary["One"] = 3;
+    BOOST_TEST(dictionary.size() == 3);
+    BOOST_TEST(dictionary.find("One") != dictionary.end() &&
+            dictionary.find("One")->first == "One" &&
+            dictionary.find("One")->second == 3);
+
+    dictionary["two"] = 4;
+    BOOST_TEST(dictionary.size() == 4);
+    BOOST_TEST(dictionary.find("Two") == dictionary.end() &&
+            dictionary.find("two") != dictionary.end() &&
+            dictionary.find("two")->second == 4);
+
+
 //[case_insensitive_dictionary
-    boost::unordered_map<std::string, word_info, ihash, iequal_to>
+    boost::unordered_map<std::string, int, ihash, iequal_to>
         idictionary;
 //]
 
     BOOST_TEST(idictionary.empty());
 
-    idictionary["one"] = word_info(1);
+    idictionary["one"] = 1;
     BOOST_TEST(idictionary.size() == 1);
     BOOST_TEST(idictionary.find("ONE") != idictionary.end() &&
         idictionary.find("ONE") == idictionary.find("one"));
 
-    idictionary.insert(std::make_pair("ONE", word_info(2)));
+    idictionary.insert(std::make_pair("ONE", 2));
     BOOST_TEST(idictionary.size() == 1);
     BOOST_TEST(idictionary.find("ONE") != idictionary.end() &&
             idictionary.find("ONE")->first == "one" &&
-            idictionary.find("ONE")->second.tag == 1);
+            idictionary.find("ONE")->second == 1);
 
-    idictionary["One"] = word_info(3);
+    idictionary["One"] = 3;
     BOOST_TEST(idictionary.size() == 1);
     BOOST_TEST(idictionary.find("ONE") != idictionary.end() &&
             idictionary.find("ONE")->first == "one" &&
-            idictionary.find("ONE")->second.tag == 3);
+            idictionary.find("ONE")->second == 3);
 
-    idictionary["two"] = word_info(4);
+    idictionary["two"] = 4;
     BOOST_TEST(idictionary.size() == 2);
     BOOST_TEST(idictionary.find("two") != idictionary.end() &&
             idictionary.find("TWO")->first == "two" &&
-            idictionary.find("Two")->second.tag == 4);
+            idictionary.find("Two")->second == 4);
 
     return boost::report_errors();
 }

doc/src_code/intro.cpp

@@ -0,0 +1,30 @@
+
+// Copyright 2006-2008 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//[intro_example1_1
+#include <boost/unordered_map.hpp>
+#include <boost/foreach.hpp>
+#include <cassert>
+#include <iostream>
+//]
+
+int main() {
+//[intro_example1_2
+    typedef boost::unordered_map<std::string, int> map;
+    map x;
+    x["one"] = 1;
+    x["two"] = 2;
+    x["three"] = 3;
+
+    assert(x.at("one") == 1);
+    assert(x.find("missing") == x.end());
+//]
+
+//[intro_example1_3
+    BOOST_FOREACH(map::value_type i, x) {
+        std::cout<<i.first<<","<<i.second<<"\n";
+    }
+//]
+}

doc/src_code/point1.cpp

@@ -29,8 +29,7 @@
         }
     };
 
-    boost::unordered_multiset<point, point_hash, std::equal_to<point> >
-        points;
+    boost::unordered_multiset<point, point_hash> points;
 //]
 
 int main() {