Unordered: Merge from trunk.

Anotehr overhaul. Can now use `void_pointer` for links between nodes, although
it doesn't as I don't think `void_pointer` support is strong enough in existing
allocators.

Also no longer relies on using base pointers for custome pointer types.  And
scaled back member function detection to just detect if an allocator has a
member, not what its signature is. I found that the trait could be confused by
ambiguous overloads. This might be fixable.

Better documentation of C++11 compliance to come.


[SVN r74859]

test/unordered/Jamfile.v2

@@ -11,9 +11,9 @@ project unordered-test/unordered
         <toolset>intel:<warnings>on
         <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
         <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
-        <toolset>gcc:<define>_GLIBCXX_DEBUG
+        #<toolset>gcc:<define>_GLIBCXX_DEBUG
         #<toolset>darwin:<define>_GLIBCXX_DEBUG
-        <toolset>msvc:<warnings-as-errors>on
+        #<toolset>msvc:<warnings-as-errors>on
         #<toolset>gcc:<warnings-as-errors>on
         #<toolset>darwin:<warnings-as-errors>on
     ;

test/unordered/allocator_traits.cpp

@@ -136,8 +136,17 @@ void test_allocator1()
 
 // allocator 2
 
+template <typename Alloc>
+struct allocator2_base
+{
+    Alloc select_on_container_copy_construction() const {
+        ++selected;
+        return Alloc();
+    }
+};
+
 template <typename T>
-struct allocator2
+struct allocator2 : allocator2_base<allocator2<T> >
 {
     typedef T value_type;
     typedef T* pointer;
@@ -149,12 +158,6 @@ struct allocator2
     typedef no_type propagate_on_container_copy_assignment;
     typedef no_type propagate_on_container_move_assignment;
     typedef no_type propagate_on_container_swap;
-
-    // Note: Not const - so it shouldn't be called.
-    allocator2<T> select_on_container_copy_construction() {
-        ++selected;
-        return allocator2<T>();
-    }
 };
 
 void test_allocator2()
@@ -169,7 +172,7 @@ void test_allocator2()
     BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
     BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
     BOOST_TEST(!traits::propagate_on_container_swap::value);
-    BOOST_TEST(call_select<allocator>() == 0);
+    BOOST_TEST(call_select<allocator>() == 1);
 }
 
 // allocator 3

test/unordered/assign_tests.cpp

@@ -57,9 +57,12 @@ void assign_tests1(T*,
 
         T y;
         y.max_load_factor(x.max_load_factor() / 20);
+        float mlf = x.max_load_factor();
         y = x;
+        tracker.compare(x);
         tracker.compare(y);
-        BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+        BOOST_TEST(x.max_load_factor() == mlf);
+        BOOST_TEST(y.max_load_factor() == mlf);
     }
 }
 

test/unordered/compile_set.cpp

@@ -128,7 +128,7 @@ UNORDERED_AUTO_TEST(test1)
     std::equal_to<int> equal_to;
     int value = 0;
 
-    std::cout<<"Test unordered_set.\n";
+    std::cout<<"Test unordered_set." << std::endl;
 
     boost::unordered_set<int> set;
     
@@ -145,7 +145,7 @@ UNORDERED_AUTO_TEST(test1)
     unordered_set_test(set2, value);
     unordered_copyable_test(set2, value, value, hash, equal_to);
 
-    std::cout<<"Test unordered_multiset.\n";
+    std::cout<<"Test unordered_multiset." << std::endl;
 
     boost::unordered_multiset<int> multiset;
     

test/unordered/compile_tests.hpp

@@ -413,6 +413,7 @@ void unordered_copyable_test(X& x, Key& k, T& t, Hash& hf, Pred& eq)
     BOOST_DEDUCED_TYPENAME X::value_type* j = 0;
 
     X(i, j, 10, hf, eq);
+
     X a5(i, j, 10, hf, eq);
     X(i, j, 10, hf);
     X a6(i, j, 10, hf);

test/unordered/constructor_tests.cpp

@@ -15,8 +15,6 @@
 #include "../helpers/input_iterator.hpp"
 #include "../helpers/invariants.hpp"
 
-#include <iostream>
-
 namespace constructor_tests {
 
 test::seed_t seed(356730);

test/unordered/incomplete_test.cpp

@@ -5,6 +5,7 @@
 
 #include "../helpers/prefix.hpp"
 
+#include <utility>
 #include <boost/unordered_map.hpp>
 #include <boost/unordered_set.hpp>
 

test/unordered/unnecessary_copy_tests.cpp

@@ -245,9 +245,11 @@ namespace unnecessary_copy_tests
         x.emplace();
 #if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
         COPY_COUNT(1); MOVE_COUNT(0);
-#else
+#elif !defined(BOOST_NO_RVALUE_REFERENCES)
         // source_cost doesn't make much sense here, but it seems to fit.
         COPY_COUNT(1); MOVE_COUNT(source_cost);
+#else
+        COPY_COUNT(1); MOVE_COUNT(1 + source_cost);
 #endif
 #endif
 
@@ -355,9 +357,7 @@ namespace unnecessary_copy_tests
 
 #if (defined(__GNUC__) && __GNUC__ > 4) || \
     (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ > 2) || \
-    (defined(BOOST_MSVC) && BOOST_MSVC >= 1600 ) || \
-    (!defined(__GNUC__) && !defined(BOOST_MSVC))
-
+    (defined(BOOST_MSVC) && BOOST_MSVC >= 1600 )
         count_copies part;
         reset();
         std::pair<count_copies const&, count_copies const&> a_ref(part, part);