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/exception/Jamfile.v2

@@ -14,9 +14,9 @@ project unordered-test/exception-tests
         <toolset>intel:<warnings>on
         <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
         <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
-        <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/objects/minimal.hpp

@@ -202,17 +202,67 @@ namespace minimal
     template <class T> class ptr;
     template <class T> class const_ptr;
 
+    struct void_ptr
+    {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+        template <typename T>
+        friend class ptr;
+    private:
+#endif
+
+        void* ptr_;
+
+    public:
+        void_ptr() : ptr_(0) {}
+
+        template <typename T>
+        explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+
+        // I'm not using the safe bool idiom because the containers should be
+        // able to cope with bool conversions.
+        operator bool() const { return !!ptr_; }
+
+        bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
+        bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
+    };
+
+    class void_const_ptr
+    {
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+        template <typename T>
+        friend class const_ptr;
+    private:
+#endif
+
+        void* ptr_;
+
+    public:
+        void_const_ptr() : ptr_(0) {}
+
+        template <typename T>
+        explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_) {}
+
+        // I'm not using the safe bool idiom because the containers should be
+        // able to cope with bool conversions.
+        operator bool() const { return !!ptr_; }
+
+        bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
+        bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
+    };
+
     template <class T>
     class ptr
     {
         friend class allocator<T>;
         friend class const_ptr<T>;
+        friend struct void_ptr;
 
         T* ptr_;
 
         ptr(T* x) : ptr_(x) {}
     public:
         ptr() : ptr_(0) {}
+        explicit ptr(void_ptr const& x) : ptr_((T*) x.ptr_) {}
 
         T& operator*() const { return *ptr_; }
         T* operator->() const { return ptr_; }
@@ -234,13 +284,6 @@ namespace minimal
         bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
         bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
         bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
-
-        bool operator==(const_ptr<T> const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(const_ptr<T> const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(const_ptr<T> const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(const_ptr<T> const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(const_ptr<T> const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(const_ptr<T> const& x) const { return ptr_ >= x.ptr_; }
     private:
         // TODO:
         //ampersand_operator_used operator&() const { return ampersand_operator_used(); }
@@ -250,6 +293,7 @@ namespace minimal
     class const_ptr
     {
         friend class allocator<T>;
+        friend struct const_void_ptr;
 
         T const* ptr_;
 
@@ -257,6 +301,7 @@ namespace minimal
     public:
         const_ptr() : ptr_(0) {}
         const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+        explicit const_ptr(void_const_ptr const& x) : ptr_((T const*) x.ptr_) {}
 
         T const& operator*() const { return *ptr_; }
         T const* operator->() const { return ptr_; }
@@ -270,13 +315,6 @@ namespace minimal
         bool operator!() const { return !ptr_; }
         operator bool() const { return !!ptr_; }
 
-        bool operator==(ptr<T> const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(ptr<T> const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(ptr<T> const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(ptr<T> const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(ptr<T> const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(ptr<T> const& x) const { return ptr_ >= x.ptr_; }
-
         bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
         bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
         bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
@@ -294,6 +332,8 @@ namespace minimal
     public:
         typedef std::size_t size_type;
         typedef std::ptrdiff_t difference_type;
+        typedef void_ptr void_pointer;
+        typedef void_const_ptr void_const_pointer;
         typedef ptr<T> pointer;
         typedef const_ptr<T> const_pointer;
         typedef T& reference;

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);